id	summary	reporter	owner	description	type	status	priority	milestone	component	resolution	keywords	cc	repo	theme
2870	1.8 tag_list not defined	ross	seanh	"From: <thedatahub.org@s077.okserver.org>
Date: Thu, Aug 16, 2012 at 3:20 AM
Subject: WebApp Error: <class 'genshi.template.eval.UndefinedError'>: ""tag_list"" not defined
To: ckan-sysadmin@okfn.org, kindly@gmail.com


URL: http://ckan.net/dataset/uk-postboxes
Module weberror.errormiddleware:162 in __call__
<<              __traceback_supplement__ = Supplement, self, environ
                   sr_checker = ResponseStartChecker(start_response)
                   app_iter = self.application(environ, sr_checker)
                   return self.make_catching_iter(app_iter, environ, sr_checker)
               except:
>>  app_iter = self.application(environ, sr_checker)
Module beaker.middleware:73 in __call__
<<                                                     self.cache_manager)
               environ[self.environ_key] = self.cache_manager
               return self.app(environ, start_response)
>>  return self.app(environ, start_response)
Module beaker.middleware:155 in __call__
<<                          headers.append(('Set-cookie', cookie))
                   return start_response(status, headers, exc_info)
               return self.wrap_app(environ, session_start_response)
       
           def _get_session(self):
>>  return self.wrap_app(environ, session_start_response)
Module routes.middleware:131 in __call__
<<                                               r'\1', oldpath)
               
               response = self.app(environ, start_response)
               
               # Wrapped in try as in rare cases the attribute will be gone already
>>  response = self.app(environ, start_response)
Module pylons.wsgiapp:125 in __call__
<<          
               controller = self.resolve(environ, start_response)
               response = self.dispatch(controller, environ, start_response)
               
               if 'paste.testing_variables' in environ and hasattr(response,
>>  response = self.dispatch(controller, environ, start_response)
Module pylons.wsgiapp:324 in dispatch
<<          if log_debug:
                   log.debug(""Calling controller class with WSGI interface"")
               return controller(environ, start_response)
           
           def load_test_env(self, environ):
>>  return controller(environ, start_response)
Module ckan.lib.base:239 in __call__
<<          try:
                   res = WSGIController.__call__(self, environ, start_response)
               finally:
                   model.Session.remove()
>>  res = WSGIController.__call__(self, environ, start_response)
Module pylons.controllers.core:221 in __call__
<<                  return response(environ, self.start_response)
               
               response = self._dispatch_call()
               if not start_response_called:
                   self.start_response = start_response
>>  response = self._dispatch_call()
Module pylons.controllers.core:172 in _dispatch_call
<<              req.environ['pylons.action_method'] = func
                   
                   response = self._inspect_call(func)
               else:
                   if log_debug:
>>  response = self._inspect_call(func)
Module pylons.controllers.core:107 in _inspect_call
<<                        func.__name__, args)
               try:
                   result = self._perform_call(func, args)
               except HTTPException, httpe:
                   if log_debug:
>>  result = self._perform_call(func, args)
Module pylons.controllers.core:60 in _perform_call
<<          """"""Hide the traceback for everything above this method""""""
               __traceback_hide__ = 'before_and_this'
               return func(**args)
           
           def _inspect_call(self, func):
>>  return func(**args)
Module ckan.controllers.package:322 in read
<<          template = template[:template.index('.') + 1] + format
       
               return render(template, loader_class=loader)
       
           def comments(self, id):
>>  return render(template, loader_class=loader)
Module ckan.lib.base:153 in render
<<      try:
               return cached_template(template_name, render_template,
                                      loader_class=loader_class)
           except ckan.exceptions.CkanUrlException, e:
               raise
>>  loader_class=loader_class)
Module pylons.templating:249 in cached_template
<<          return content
           else:
               return render_func()
>>  return render_func()
Module ckan.lib.base:102 in render_template
<<          if loader_class == NewTextTemplate:
                   return literal(stream.render(method=""text"", encoding=None))
       
               return literal(stream.render(method=method, encoding=None,
>>  return literal(stream.render(method=""text"", encoding =None))
Module genshi.core:183 in render
<<              method = self.serializer or 'xml'
               generator = self.serialize(method=method, **kwargs)
               return encode(generator, method=method, encoding=encoding, out=out)
       
           def select(self, path, namespaces=None, variables=None):
>>  return encode(generator, method=method, encoding=encoding, out =out)
Module genshi.output:57 in encode
<<          _encode = lambda string: string
           if out is None:
               return _encode(''.join(list(iterator)))
           for chunk in iterator:
               out.write(_encode(chunk))
>>  return _encode(''.join(list(iterator)))
Module genshi.output:569 in __call__
<<      def __call__(self, stream):
               strip_markup = self.strip_markup
               for event in stream:
                   if event[0] is TEXT:
                       data = event[1]
>>  for event in stream:
Module genshi.core:288 in _ensure
<<      # unchanged
           yield event
           for event in stream:
               yield event
>>  for event in stream:
Module genshi.core:288 in _ensure
<<      # unchanged
           yield event
           for event in stream:
               yield event
>>  for event in stream:
Module genshi.filters.transform:686 in _unmark
<<      def _unmark(self, stream):
               for mark, event in stream:
                   kind = event[0]
                   if not (kind is None or kind is ATTR or kind is BREAK):
>>  for mark, event in stream:
Module genshi.filters.transform:1145 in __call__
<<          :param stream: The marked event stream to filter
               """"""
               for mark, event in stream:
                   yield mark, event
                   if mark is ENTER:
>>  for mark, event in stream:
Module genshi.filters.transform:714 in __call__
<<          stream = iter(stream)
               next = stream.next
               for mark, event in stream:
                   if mark is None:
                       yield mark, event
>>  for mark, event in stream:
Module genshi.filters.transform:682 in _mark
<<      def _mark(self, stream):
               for event in stream:
                   yield OUTSIDE, event
>>  for event in stream:
Module genshi.core:288 in _ensure
<<      # unchanged
           yield event
           for event in stream:
               yield event
>>  for event in stream:
Module genshi.filters.transform:686 in _unmark
<<      def _unmark(self, stream):
               for mark, event in stream:
                   kind = event[0]
                   if not (kind is None or kind is ATTR or kind is BREAK):
>>  for mark, event in stream:
Module genshi.filters.transform:1145 in __call__
<<          :param stream: The marked event stream to filter
               """"""
               for mark, event in stream:
                   yield mark, event
                   if mark is ENTER:
>>  for mark, event in stream:
Module genshi.filters.transform:714 in __call__
<<          stream = iter(stream)
               next = stream.next
               for mark, event in stream:
                   if mark is None:
                       yield mark, event
>>  for mark, event in stream:
Module genshi.filters.transform:682 in _mark
<<      def _mark(self, stream):
               for event in stream:
                   yield OUTSIDE, event
>>  for event in stream:
Module genshi.core:288 in _ensure
<<      # unchanged
           yield event
           for event in stream:
               yield event
>>  for event in stream:
Module genshi.filters.transform:686 in _unmark
<<      def _unmark(self, stream):
               for mark, event in stream:
                   kind = event[0]
                   if not (kind is None or kind is ATTR or kind is BREAK):
>>  for mark, event in stream:
Module genshi.filters.transform:1145 in __call__
<<          :param stream: The marked event stream to filter
               """"""
               for mark, event in stream:
                   yield mark, event
                   if mark is ENTER:
>>  for mark, event in stream:
Module genshi.filters.transform:714 in __call__
<<          stream = iter(stream)
               next = stream.next
               for mark, event in stream:
                   if mark is None:
                       yield mark, event
>>  for mark, event in stream:
Module genshi.filters.transform:682 in _mark
<<      def _mark(self, stream):
               for event in stream:
                   yield OUTSIDE, event
>>  for event in stream:
Module genshi.core:288 in _ensure
<<      # unchanged
           yield event
           for event in stream:
               yield event
>>  for event in stream:
Module genshi.filters.transform:686 in _unmark
<<      def _unmark(self, stream):
               for mark, event in stream:
                   kind = event[0]
                   if not (kind is None or kind is ATTR or kind is BREAK):
>>  for mark, event in stream:
Module ckanext.googleanalytics.plugin:93 in download_adder
<<                  [downloaded %s times]</span>'''
                       count = None
                       for mark, (kind, data, pos) in stream:
                           if mark and kind == START:
                               href = data[1].get('href')
>>  for mark, (kind, data, pos) in stream:
Module genshi.filters.transform:714 in __call__
<<          stream = iter(stream)
               next = stream.next
               for mark, event in stream:
                   if mark is None:
                       yield mark, event
>>  for mark, event in stream:
Module genshi.filters.transform:682 in _mark
<<      def _mark(self, stream):
               for event in stream:
                   yield OUTSIDE, event
>>  for event in stream:
Module genshi.core:288 in _ensure
<<      # unchanged
           yield event
           for event in stream:
               yield event
>>  for event in stream:
Module genshi.filters.transform:686 in _unmark
<<      def _unmark(self, stream):
               for mark, event in stream:
                   kind = event[0]
                   if not (kind is None or kind is ATTR or kind is BREAK):
>>  for mark, event in stream:
Module genshi.filters.transform:1175 in __call__
<<          """"""
               callable_value = hasattr(self.value, '__call__')
               for mark, (kind, data, pos) in stream:
                   if mark is ENTER:
                       if callable_value:
>>  for mark, (kind, data, pos) in stream:
Module genshi.filters.transform:714 in __call__
<<          stream = iter(stream)
               next = stream.next
               for mark, event in stream:
                   if mark is None:
                       yield mark, event
>>  for mark, event in stream:
Module genshi.filters.transform:682 in _mark
<<      def _mark(self, stream):
               for event in stream:
                   yield OUTSIDE, event
>>  for event in stream:
Module genshi.core:288 in _ensure
<<      # unchanged
           yield event
           for event in stream:
               yield event
>>  for event in stream:
Module genshi.filters.transform:686 in _unmark
<<      def _unmark(self, stream):
               for mark, event in stream:
                   kind = event[0]
                   if not (kind is None or kind is ATTR or kind is BREAK):
>>  for mark, event in stream:
Module genshi.filters.transform:1145 in __call__
<<          :param stream: The marked event stream to filter
               """"""
               for mark, event in stream:
                   yield mark, event
                   if mark is ENTER:
>>  for mark, event in stream:
Module genshi.filters.transform:714 in __call__
<<          stream = iter(stream)
               next = stream.next
               for mark, event in stream:
                   if mark is None:
                       yield mark, event
>>  for mark, event in stream:
Module genshi.filters.transform:682 in _mark
<<      def _mark(self, stream):
               for event in stream:
                   yield OUTSIDE, event
>>  for event in stream:
Module genshi.template.base:605 in _include
<<          from genshi.template.loader import TemplateNotFound
       
               for event in stream:
                   if event[0] is INCLUDE:
                       href, cls, fallback = event[1]
>>  for event in stream:
Module genshi.template.base:565 in _flatten
<<                  elif kind is EXPR:
                           result = _eval_expr(data, ctxt, vars)
                           if result is not None:
                               # First check for a string, otherwise the iterable test
>>  result = _eval_expr(data, ctxt, vars)
Module genshi.template.base:277 in _eval_expr
<<      if vars:
               ctxt.push(vars)
           retval = expr.evaluate(ctxt)
           if vars:
               ctxt.pop()
>>  retval = expr.evaluate(ctxt)
Module genshi.template.eval:178 in evaluate
<<          __traceback_hide__ = 'before_and_this'
               _globals = self._globals(data)
               return eval(self.code, _globals, {'__data__': data})
>>  return eval(self.code, _globals, {'__data__': data})
Module ?:51 in <Expression u""tag_list(c.pkg_dict.get('tags', ''))"">
<<      <li py:if=""c.pkg_dict.get('tags')"" class=""sidebar-section"">
             <h3>Tags</h3>
             ${tag_list(c.pkg_dict.get('tags', ''))}
           </li>
>>  ${tag_list(c.pkg_dict.get('tags', ''))}
Module genshi.template.eval:309 in lookup_name
<<              val = BUILTINS.get(name, val)
                   if val is UNDEFINED:
                       val = cls.undefined(name)
               return val
>>  val = cls.undefined(name)
Module genshi.template.eval:410 in undefined
<<          """"""Raise an ``UndefinedError`` immediately.""""""
               __traceback_hide__ = True
               raise UndefinedError(key, owner=owner)
>>  raise UndefinedError(key, owner=owner)
UndefinedError: ""tag_list"" not defined
CGI Variables
CKAN_CURRENT_URL	'/dataset/uk-postboxes'
CKAN_LANG	'en'
CKAN_LANG_IS_DEFAULT	True
CKAN_PAGE_CACHABLE	True
CONTENT_TYPE	'; charset=utf-8'
DOCUMENT_ROOT	'/etc/apache2/htdocs'
GATEWAY_INTERFACE	'CGI/1.1'
HTTP_ACCEPT	'text/html,text/plain,text/xml'
HTTP_ACCEPT_CHARSET	'ISO-8859-1,utf-8;q=0.7,*;q=0.7'
HTTP_ACCEPT_ENCODING	'gzip'
HTTP_ACCEPT_LANGUAGE	'vi,en-us;q=0.7,en;q=0.3'
HTTP_CONNECTION	'close'
HTTP_HOST	'ckan.net'
HTTP_USER_AGENT	'coccoc/1.0 ()'
PATH_INFO	'/dataset/uk-postboxes'
PATH_TRANSLATED	'/etc/ckan/datahub/apache.wsgi/dataset/uk-postboxes'
REMOTE_ADDR	'127.0.0.1'
REMOTE_PORT	'47065'
REQUEST_METHOD	'GET'
REQUEST_URI	'/dataset/uk-postboxes'
SCRIPT_FILENAME	'/etc/ckan/datahub/apache.wsgi'
SERVER_ADDR	'127.0.0.1'
SERVER_ADMIN	'[no address given]'
SERVER_NAME	'ckan.net'
SERVER_PORT	'80'
SERVER_PROTOCOL	'HTTP/1.0'
SERVER_SIGNATURE	'<address>Apache/2.2.22 (Ubuntu) Server at ckan.net Port 80</address>\n'
SERVER_SOFTWARE	'Apache/2.2.22 (Ubuntu)'
WSGI Variables
application	<beaker.middleware.CacheMiddleware object at 0x7f5312a51650>
beaker.cache	<beaker.cache.CacheManager object at 0x7f5312a51790>
beaker.get_session	<bound method SessionMiddleware._get_session of <beaker.middleware.SessionMiddleware object at 0x7f5312a516d0>>
beaker.session	{'_accessed_time': 1345083636.079552, '_creation_time': 1345083636.079552}
mod_wsgi.application_group	'ckan.net|'
mod_wsgi.callable_object	'application'
mod_wsgi.handler_script	''
mod_wsgi.input_chunked	'0'
mod_wsgi.listener_host	''
mod_wsgi.listener_port	'8080'
mod_wsgi.process_group	'datahub'
mod_wsgi.request_handler	'wsgi-script'
mod_wsgi.script_reloading	'1'
mod_wsgi.version	(3, 3)
paste.cookies	(<SimpleCookie: >, '')
paste.registry	<paste.registry.Registry object at 0x7f52e47477d0>
paste.throw_errors	True
pylons.action_method	<bound method PackageController.read of <ckan.controllers.package.PackageController object at 0x7f52e477b810>>
pylons.controller	<ckan.controllers.package.PackageController object at 0x7f52e477b810>
pylons.environ_config	{'session': 'beaker.session', 'cache': 'beaker.cache'}
pylons.pylons	<pylons.util.PylonsContext object at 0x7f52e477be90>
pylons.routes_dict	{'action': u'read', 'controller': u'package', 'id': u'uk-postboxes'}
repoze.who.logger	<logging.Logger object at 0x7f53127b2b50>
repoze.who.plugins	{'openid': <OpenIdIdentificationPlugin 139994769488336>, 'friendlyform': <FriendlyFormPlugin 139994769488528>, 'ckan.lib.authenticator:UsernamePasswordAuthenticator': <ckan.lib.authenticator.UsernamePasswordAuthenticator object at 0x7f5312d893d0>, 'auth_tkt': <AuthTktCookiePlugin 139994771858704>, 'ckan.lib.authenticator:OpenIDAuthenticator': <ckan.lib.authenticator.OpenIDAuthenticator object at 0x7f5312d89350>}
routes.route	<routes.route.Route object at 0x7f5312955a50>
routes.url	<routes.util.URLGenerator object at 0x7f52eb8c9090>
webob._parsed_query_vars	(GET([]), '')
webob.adhoc_attrs	{'language': 'en-us'}
wsgi process	'Multi process AND threads (?)'
wsgi.file_wrapper	<built-in method file_wrapper of mod_wsgi.Adapter object at 0x7f5308983a80>
wsgi.version	(1, 1)
wsgiorg.routing_args	(<routes.util.URLGenerator object at 0x7f52eb8c9090>, {'action': u'read', 'controller': u'package', 'id': u'uk-postboxes'})
"	enhancement	new	awaiting triage		ckan				ckan	none