X7ROOT File Manager
Current Path:
/usr/lib/python2.7/site-packages/jinja2
usr
/
lib
/
python2.7
/
site-packages
/
jinja2
/
📁
..
📄
__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)
Editing: _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
Upload File
Create Folder