golden hour

/usr/lib/python2.7/site-packages/jinja2

File/Folder	Size	Actions
__init__.py	2.22 KB
__init__.pyc	2.38 KB
__init__.pyo	2.38 KB
_compat.py	3.95 KB
_compat.pyc	5.99 KB
_compat.pyo	5.99 KB
_stringdefs.py	394.82 KB
_stringdefs.pyc	203.64 KB
_stringdefs.pyo	203.64 KB
bccache.py	12.04 KB
bccache.pyc	13.85 KB
bccache.pyo	13.85 KB
compiler.py	60.34 KB
compiler.pyc	53.21 KB
compiler.pyo	53.15 KB
constants.py	1.59 KB
constants.pyc	1.65 KB
constants.pyo	1.65 KB
debug.py	10.72 KB
debug.pyc	10.45 KB
debug.pyo	10.37 KB
defaults.py	1.03 KB
defaults.pyc	1.46 KB
defaults.pyo	1.46 KB
environment.py	46.14 KB
environment.pyc	45 KB
environment.pyo	44.59 KB
exceptions.py	4.32 KB
exceptions.pyc	6.11 KB
exceptions.pyo	6.11 KB
ext.py	24.49 KB
ext.pyc	23.5 KB
ext.pyo	23.43 KB
filters.py	29.14 KB
filters.pyc	33.13 KB
filters.pyo	33.13 KB
lexer.py	27.73 KB
lexer.pyc	22.11 KB
lexer.pyo	21.95 KB
loaders.py	16.64 KB
loaders.pyc	18.5 KB
loaders.pyo	18.5 KB
meta.py	4.09 KB
meta.pyc	3.92 KB
meta.pyo	3.92 KB
nodes.py	28.23 KB
nodes.pyc	41.54 KB
nodes.pyo	41.06 KB
optimizer.py	2.25 KB
optimizer.pyc	2.78 KB
optimizer.pyo	2.78 KB
parser.py	34.36 KB
parser.pyc	30.5 KB
parser.pyo	30.5 KB
runtime.py	19.1 KB
runtime.pyc	22.5 KB
runtime.pyo	22.46 KB
sandbox.py	18.09 KB
sandbox.pyc	17.23 KB
sandbox.pyo	17.23 KB
tests.py	3.36 KB
tests.pyc	4.93 KB
tests.pyo	4.93 KB
testsuite	-
utils.py	15.79 KB
utils.pyc	19.08 KB
utils.pyo	19.08 KB
visitor.py	3.24 KB
visitor.pyc	3.72 KB
visitor.pyo	3.72 KB

Edit: _compat.py

# -*- coding: utf-8 -*-
"""
    jinja2._compat
    ~~~~~~~~~~~~~~

Some py2/py3 compatibility support based on a stripped down
    version of six so we don't have to depend on a specific version
    of it.

:copyright: Copyright 2013 by the Jinja team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""
import sys

PY2 = sys.version_info[0] == 2
PYPY = hasattr(sys, 'pypy_translation_info')
_identity = lambda x: x

if not PY2:
    unichr = chr
    range_type = range
    text_type = str
    string_types = (str,)

iterkeys = lambda d: iter(d.keys())
    itervalues = lambda d: iter(d.values())
    iteritems = lambda d: iter(d.items())

import pickle
    from io import BytesIO, StringIO
    NativeStringIO = StringIO

def reraise(tp, value, tb=None):
        if value.__traceback__ is not tb:
            raise value.with_traceback(tb)
        raise value

ifilter = filter
    imap = map
    izip = zip
    intern = sys.intern

implements_iterator = _identity
    implements_to_string = _identity
    encode_filename = _identity
    get_next = lambda x: x.__next__

else:
    unichr = unichr
    text_type = unicode
    range_type = xrange
    string_types = (str, unicode)

iterkeys = lambda d: d.iterkeys()
    itervalues = lambda d: d.itervalues()
    iteritems = lambda d: d.iteritems()

import cPickle as pickle
    from cStringIO import StringIO as BytesIO, StringIO
    NativeStringIO = BytesIO

exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')

from itertools import imap, izip, ifilter
    intern = intern

def implements_iterator(cls):
        cls.next = cls.__next__
        del cls.__next__
        return cls

def implements_to_string(cls):
        cls.__unicode__ = cls.__str__
        cls.__str__ = lambda x: x.__unicode__().encode('utf-8')
        return cls

get_next = lambda x: x.next

def encode_filename(filename):
        if isinstance(filename, unicode):
            return filename.encode('utf-8')
        return filename

try:
    next = next
except NameError:
    def next(it):
        return it.next()

def with_metaclass(meta, *bases):
    # This requires a bit of explanation: the basic idea is to make a
    # dummy metaclass for one level of class instanciation that replaces
    # itself with the actual metaclass.  Because of internal type checks
    # we also need to make sure that we downgrade the custom metaclass
    # for one level to something closer to type (that's why __call__ and
    # __init__ comes back from type etc.).
    #
    # This has the advantage over six.with_metaclass in that it does not
    # introduce dummy classes into the final MRO.
    class metaclass(meta):
        __call__ = type.__call__
        __init__ = type.__init__
        def __new__(cls, name, this_bases, d):
            if this_bases is None:
                return type.__new__(cls, name, (), d)
            return meta(name, bases, d)
    return metaclass('temporary_class', None, {})

try:
    from collections import Mapping as mapping_types
except ImportError:
    import UserDict
    mapping_types = (UserDict.UserDict, UserDict.DictMixin, dict)

# common types.  These do exist in the special types module too which however
# does not exist in IronPython out of the box.  Also that way we don't have
# to deal with implementation specific stuff here
class _C(object):
    def method(self): pass
def _func():
    yield None
function_type = type(_func)
generator_type = type(_func())
method_type = type(_C().method)
code_type = type(_C.method.__code__)
try:
    raise TypeError()
except TypeError:
    _tb = sys.exc_info()[2]
    traceback_type = type(_tb)
    frame_type = type(_tb.tb_frame)

try:
    from urllib.parse import quote_from_bytes as url_quote
except ImportError:
    from urllib import quote as url_quote

try:
    from thread import allocate_lock
except ImportError:
    try:
        from threading import Lock as allocate_lock
    except ImportError:
        from dummy_thread import allocate_lock