| {{ column }} | \n {%- endfor %}\n
%s
' % escape(x) for x in result))\n\n\ndef unicode_urlencode(obj, charset='utf-8'):\n \"\"\"URL escapes a single bytestring or unicode string with the\n given charset if applicable to URL safe quoting under all rules\n that need to be considered under all supported Python versions.\n\n If non strings are provided they are converted to their unicode\n representation first.\n \"\"\"\n if not isinstance(obj, string_types):\n obj = text_type(obj)\n if isinstance(obj, text_type):\n obj = obj.encode(charset)\n return text_type(url_quote(obj))\n\n\nclass LRUCache(object):\n \"\"\"A simple LRU Cache implementation.\"\"\"\n\n # this is fast for small capacities (something below 1000) but doesn't\n # scale. But as long as it's only used as storage for templates this\n # won't do any harm.\n\n def __init__(self, capacity):\n self.capacity = capacity\n self._mapping = {}\n self._queue = deque()\n self._postinit()\n\n def _postinit(self):\n # alias all queue methods for faster lookup\n self._popleft = self._queue.popleft\n self._pop = self._queue.pop\n self._remove = self._queue.remove\n self._wlock = Lock()\n self._append = self._queue.append\n\n def __getstate__(self):\n return {\n 'capacity': self.capacity,\n '_mapping': self._mapping,\n '_queue': self._queue\n }\n\n def __setstate__(self, d):\n self.__dict__.update(d)\n self._postinit()\n\n def __getnewargs__(self):\n return (self.capacity,)\n\n def copy(self):\n \"\"\"Return a shallow copy of the instance.\"\"\"\n rv = self.__class__(self.capacity)\n rv._mapping.update(self._mapping)\n rv._queue = deque(self._queue)\n return rv\n\n def get(self, key, default=None):\n \"\"\"Return an item from the cache dict or `default`\"\"\"\n try:\n return self[key]\n except KeyError:\n return default\n\n def setdefault(self, key, default=None):\n \"\"\"Set `default` if the key is not in the cache otherwise\n leave unchanged. Return the value of this key.\n \"\"\"\n self._wlock.acquire()\n try:\n try:\n return self[key]\n except KeyError:\n self[key] = default\n return default\n finally:\n self._wlock.release()\n\n def clear(self):\n \"\"\"Clear the cache.\"\"\"\n self._wlock.acquire()\n try:\n self._mapping.clear()\n self._queue.clear()\n finally:\n self._wlock.release()\n\n def __contains__(self, key):\n \"\"\"Check if a key exists in this cache.\"\"\"\n return key in self._mapping\n\n def __len__(self):\n \"\"\"Return the current size of the cache.\"\"\"\n return len(self._mapping)\n\n def __repr__(self):\n return '<%s %r>' % (\n self.__class__.__name__,\n self._mapping\n )\n\n def __getitem__(self, key):\n \"\"\"Get an item from the cache. Moves the item up so that it has the\n highest priority then.\n\n Raise a `KeyError` if it does not exist.\n \"\"\"\n self._wlock.acquire()\n try:\n rv = self._mapping[key]\n if self._queue[-1] != key:\n try:\n self._remove(key)\n except ValueError:\n # if something removed the key from the container\n # when we read, ignore the ValueError that we would\n # get otherwise.\n pass\n self._append(key)\n return rv\n finally:\n self._wlock.release()\n\n def __setitem__(self, key, value):\n \"\"\"Sets the value for an item. Moves the item up so that it\n has the highest priority then.\n \"\"\"\n self._wlock.acquire()\n try:\n if key in self._mapping:\n self._remove(key)\n elif len(self._mapping) == self.capacity:\n del self._mapping[self._popleft()]\n self._append(key)\n self._mapping[key] = value\n finally:\n self._wlock.release()\n\n def __delitem__(self, key):\n \"\"\"Remove an item from the cache dict.\n Raise a `KeyError` if it does not exist.\n \"\"\"\n self._wlock.acquire()\n try:\n del self._mapping[key]\n try:\n self._remove(key)\n except ValueError:\n # __getitem__ is not locked, it might happen\n pass\n finally:\n self._wlock.release()\n\n def items(self):\n \"\"\"Return a list of items.\"\"\"\n result = [(key, self._mapping[key]) for key in list(self._queue)]\n result.reverse()\n return result\n\n def iteritems(self):\n \"\"\"Iterate over all items.\"\"\"\n return iter(self.items())\n\n def values(self):\n \"\"\"Return a list of all values.\"\"\"\n return [x[1] for x in self.items()]\n\n def itervalue(self):\n \"\"\"Iterate over all values.\"\"\"\n return iter(self.values())\n\n def keys(self):\n \"\"\"Return a list of all keys ordered by most recent usage.\"\"\"\n return list(self)\n\n def iterkeys(self):\n \"\"\"Iterate over all keys in the cache dict, ordered by\n the most recent usage.\n \"\"\"\n return reversed(tuple(self._queue))\n\n __iter__ = iterkeys\n\n def __reversed__(self):\n \"\"\"Iterate over the values in the cache dict, oldest items\n coming first.\n \"\"\"\n return iter(tuple(self._queue))\n\n __copy__ = copy\n\n\n# register the LRU cache as mutable mapping if possible\ntry:\n from collections import MutableMapping\n MutableMapping.register(LRUCache)\nexcept ImportError:\n pass\n\n\n@implements_iterator\nclass Cycler(object):\n \"\"\"A cycle helper for templates.\"\"\"\n\n def __init__(self, *items):\n if not items:\n raise RuntimeError('at least one item has to be provided')\n self.items = items\n self.reset()\n\n def reset(self):\n \"\"\"Resets the cycle.\"\"\"\n self.pos = 0\n\n @property\n def current(self):\n \"\"\"Returns the current item.\"\"\"\n return self.items[self.pos]\n\n def __next__(self):\n \"\"\"Goes one item ahead and returns it.\"\"\"\n rv = self.current\n self.pos = (self.pos + 1) % len(self.items)\n return rv\n\n\nclass Joiner(object):\n \"\"\"A joining helper for templates.\"\"\"\n\n def __init__(self, sep=u', '):\n self.sep = sep\n self.used = False\n\n def __call__(self):\n if not self.used:\n self.used = True\n return u''\n return self.sep\n\n\n# Imported here because that's where it was in the past\nfrom markupsafe import Markup, escape, soft_unicode\n" }, { "path": "jinja2/visitor.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n jinja2.visitor\n ~~~~~~~~~~~~~~\n\n This module implements a visitor for the nodes.\n\n :copyright: (c) 2010 by the Jinja Team.\n :license: BSD.\n\"\"\"\nfrom jinja2.nodes import Node\n\n\nclass NodeVisitor(object):\n \"\"\"Walks the abstract syntax tree and call visitor functions for every\n node found. The visitor functions may return values which will be\n forwarded by the `visit` method.\n\n Per default the visitor functions for the nodes are ``'visit_'`` +\n class name of the node. So a `TryFinally` node visit function would\n be `visit_TryFinally`. This behavior can be changed by overriding\n the `get_visitor` function. If no visitor function exists for a node\n (return value `None`) the `generic_visit` visitor is used instead.\n \"\"\"\n\n def get_visitor(self, node):\n \"\"\"Return the visitor function for this node or `None` if no visitor\n exists for this node. In that case the generic visit function is\n used instead.\n \"\"\"\n method = 'visit_' + node.__class__.__name__\n return getattr(self, method, None)\n\n def visit(self, node, *args, **kwargs):\n \"\"\"Visit a node.\"\"\"\n f = self.get_visitor(node)\n if f is not None:\n return f(node, *args, **kwargs)\n return self.generic_visit(node, *args, **kwargs)\n\n def generic_visit(self, node, *args, **kwargs):\n \"\"\"Called if no explicit visitor function exists for a node.\"\"\"\n for node in node.iter_child_nodes():\n self.visit(node, *args, **kwargs)\n\n\nclass NodeTransformer(NodeVisitor):\n \"\"\"Walks the abstract syntax tree and allows modifications of nodes.\n\n The `NodeTransformer` will walk the AST and use the return value of the\n visitor functions to replace or remove the old node. If the return\n value of the visitor function is `None` the node will be removed\n from the previous location otherwise it's replaced with the return\n value. The return value may be the original node in which case no\n replacement takes place.\n \"\"\"\n\n def generic_visit(self, node, *args, **kwargs):\n for field, old_value in node.iter_fields():\n if isinstance(old_value, list):\n new_values = []\n for value in old_value:\n if isinstance(value, Node):\n value = self.visit(value, *args, **kwargs)\n if value is None:\n continue\n elif not isinstance(value, Node):\n new_values.extend(value)\n continue\n new_values.append(value)\n old_value[:] = new_values\n elif isinstance(old_value, Node):\n new_node = self.visit(old_value, *args, **kwargs)\n if new_node is None:\n delattr(node, field)\n else:\n setattr(node, field, new_node)\n return node\n\n def visit_list(self, node, *args, **kwargs):\n \"\"\"As transformers may return lists in some places this method\n can be used to enforce a list as return value.\n \"\"\"\n rv = self.visit(node, *args, **kwargs)\n if not isinstance(rv, list):\n rv = [rv]\n return rv\n" }, { "path": "markupsafe/__init__.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n markupsafe\n ~~~~~~~~~~\n\n Implements a Markup string.\n\n :copyright: (c) 2010 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nimport re\nfrom markupsafe._compat import text_type, string_types, int_types, \\\n unichr, PY2\n\n\n__all__ = ['Markup', 'soft_unicode', 'escape', 'escape_silent']\n\n\n_striptags_re = re.compile(r'(|<[^>]*>)')\n_entity_re = re.compile(r'&([^;]+);')\n\n\nclass Markup(text_type):\n r\"\"\"Marks a string as being safe for inclusion in HTML/XML output without\n needing to be escaped. This implements the `__html__` interface a couple\n of frameworks and web applications use. :class:`Markup` is a direct\n subclass of `unicode` and provides all the methods of `unicode` just that\n it escapes arguments passed and always returns `Markup`.\n\n The `escape` function returns markup objects so that double escaping can't\n happen.\n\n The constructor of the :class:`Markup` class can be used for three\n different things: When passed an unicode object it's assumed to be safe,\n when passed an object with an HTML representation (has an `__html__`\n method) that representation is used, otherwise the object passed is\n converted into a unicode string and then assumed to be safe:\n\n >>> Markup(\"Hello World!\")\n Markup(u'Hello World!')\n >>> class Foo(object):\n ... def __html__(self):\n ... return 'foo'\n ... \n >>> Markup(Foo())\n Markup(u'foo')\n\n If you want object passed being always treated as unsafe you can use the\n :meth:`escape` classmethod to create a :class:`Markup` object:\n\n >>> Markup.escape(\"Hello World!\")\n Markup(u'Hello <em>World</em>!')\n\n Operations on a markup string are markup aware which means that all\n arguments are passed through the :func:`escape` function:\n\n >>> em = Markup(\"%s\")\n >>> em % \"foo & bar\"\n Markup(u'foo & bar')\n >>> strong = Markup(\"%(text)s\")\n >>> strong % {'text': ''}\n Markup(u'<blink>hacker here</blink>')\n >>> Markup(\"Hello \") + \"