OLD | NEW |
(Empty) | |
| 1 # -*- coding: utf-8 -*- |
| 2 """ |
| 3 jinja2._compat |
| 4 ~~~~~~~~~~~~~~ |
| 5 |
| 6 Some py2/py3 compatibility support based on a stripped down |
| 7 version of six so we don't have to depend on a specific version |
| 8 of it. |
| 9 |
| 10 :copyright: Copyright 2013 by the Jinja team, see AUTHORS. |
| 11 :license: BSD, see LICENSE for details. |
| 12 """ |
| 13 import sys |
| 14 |
| 15 PY2 = sys.version_info[0] == 2 |
| 16 PYPY = hasattr(sys, 'pypy_translation_info') |
| 17 _identity = lambda x: x |
| 18 |
| 19 |
| 20 if not PY2: |
| 21 unichr = chr |
| 22 range_type = range |
| 23 text_type = str |
| 24 string_types = (str,) |
| 25 |
| 26 iterkeys = lambda d: iter(d.keys()) |
| 27 itervalues = lambda d: iter(d.values()) |
| 28 iteritems = lambda d: iter(d.items()) |
| 29 |
| 30 import pickle |
| 31 from io import BytesIO, StringIO |
| 32 NativeStringIO = StringIO |
| 33 |
| 34 def reraise(tp, value, tb=None): |
| 35 if value.__traceback__ is not tb: |
| 36 raise value.with_traceback(tb) |
| 37 raise value |
| 38 |
| 39 ifilter = filter |
| 40 imap = map |
| 41 izip = zip |
| 42 intern = sys.intern |
| 43 |
| 44 implements_iterator = _identity |
| 45 implements_to_string = _identity |
| 46 encode_filename = _identity |
| 47 get_next = lambda x: x.__next__ |
| 48 |
| 49 else: |
| 50 unichr = unichr |
| 51 text_type = unicode |
| 52 range_type = xrange |
| 53 string_types = (str, unicode) |
| 54 |
| 55 iterkeys = lambda d: d.iterkeys() |
| 56 itervalues = lambda d: d.itervalues() |
| 57 iteritems = lambda d: d.iteritems() |
| 58 |
| 59 import cPickle as pickle |
| 60 from cStringIO import StringIO as BytesIO, StringIO |
| 61 NativeStringIO = BytesIO |
| 62 |
| 63 exec('def reraise(tp, value, tb=None):\n raise tp, value, tb') |
| 64 |
| 65 from itertools import imap, izip, ifilter |
| 66 intern = intern |
| 67 |
| 68 def implements_iterator(cls): |
| 69 cls.next = cls.__next__ |
| 70 del cls.__next__ |
| 71 return cls |
| 72 |
| 73 def implements_to_string(cls): |
| 74 cls.__unicode__ = cls.__str__ |
| 75 cls.__str__ = lambda x: x.__unicode__().encode('utf-8') |
| 76 return cls |
| 77 |
| 78 get_next = lambda x: x.next |
| 79 |
| 80 def encode_filename(filename): |
| 81 if isinstance(filename, unicode): |
| 82 return filename.encode('utf-8') |
| 83 return filename |
| 84 |
| 85 try: |
| 86 next = next |
| 87 except NameError: |
| 88 def next(it): |
| 89 return it.next() |
| 90 |
| 91 |
| 92 def with_metaclass(meta, *bases): |
| 93 # This requires a bit of explanation: the basic idea is to make a |
| 94 # dummy metaclass for one level of class instanciation that replaces |
| 95 # itself with the actual metaclass. Because of internal type checks |
| 96 # we also need to make sure that we downgrade the custom metaclass |
| 97 # for one level to something closer to type (that's why __call__ and |
| 98 # __init__ comes back from type etc.). |
| 99 # |
| 100 # This has the advantage over six.with_metaclass in that it does not |
| 101 # introduce dummy classes into the final MRO. |
| 102 class metaclass(meta): |
| 103 __call__ = type.__call__ |
| 104 __init__ = type.__init__ |
| 105 def __new__(cls, name, this_bases, d): |
| 106 if this_bases is None: |
| 107 return type.__new__(cls, name, (), d) |
| 108 return meta(name, bases, d) |
| 109 return metaclass('temporary_class', None, {}) |
| 110 |
| 111 |
| 112 try: |
| 113 from collections import Mapping as mapping_types |
| 114 except ImportError: |
| 115 import UserDict |
| 116 mapping_types = (UserDict.UserDict, UserDict.DictMixin, dict) |
| 117 |
| 118 |
| 119 # common types. These do exist in the special types module too which however |
| 120 # does not exist in IronPython out of the box. Also that way we don't have |
| 121 # to deal with implementation specific stuff here |
| 122 class _C(object): |
| 123 def method(self): pass |
| 124 def _func(): |
| 125 yield None |
| 126 function_type = type(_func) |
| 127 generator_type = type(_func()) |
| 128 method_type = type(_C().method) |
| 129 code_type = type(_C.method.__code__) |
| 130 try: |
| 131 raise TypeError() |
| 132 except TypeError: |
| 133 _tb = sys.exc_info()[2] |
| 134 traceback_type = type(_tb) |
| 135 frame_type = type(_tb.tb_frame) |
| 136 |
| 137 |
| 138 try: |
| 139 from urllib.parse import quote_from_bytes as url_quote |
| 140 except ImportError: |
| 141 from urllib import quote as url_quote |
| 142 |
| 143 |
| 144 try: |
| 145 from thread import allocate_lock |
| 146 except ImportError: |
| 147 try: |
| 148 from threading import Lock as allocate_lock |
| 149 except ImportError: |
| 150 from dummy_thread import allocate_lock |
OLD | NEW |