|
1 import sys |
|
2 |
|
3 try: |
|
4 reversed = reversed |
|
5 except NameError: |
|
6 def reversed(sequence): |
|
7 """reversed(sequence) -> reverse iterator over values of the sequence |
|
8 |
|
9 Return a reverse iterator |
|
10 """ |
|
11 if hasattr(sequence, '__reversed__'): |
|
12 return sequence.__reversed__() |
|
13 if not hasattr(sequence, '__getitem__'): |
|
14 raise TypeError("argument to reversed() must be a sequence") |
|
15 return reversed_iterator(sequence) |
|
16 |
|
17 class reversed_iterator(object): |
|
18 |
|
19 def __init__(self, seq): |
|
20 self.seq = seq |
|
21 self.remaining = len(seq) |
|
22 |
|
23 def __iter__(self): |
|
24 return self |
|
25 |
|
26 def next(self): |
|
27 i = self.remaining |
|
28 if i > 0: |
|
29 i -= 1 |
|
30 item = self.seq[i] |
|
31 self.remaining = i |
|
32 return item |
|
33 raise StopIteration |
|
34 |
|
35 def __length_hint__(self): |
|
36 return self.remaining |
|
37 |
|
38 try: |
|
39 any = any |
|
40 except NameError: |
|
41 def any(iterable): |
|
42 for x in iterable: |
|
43 if x: |
|
44 return True |
|
45 return False |
|
46 |
|
47 try: |
|
48 all = all |
|
49 except NameError: |
|
50 def all(iterable): |
|
51 for x in iterable: |
|
52 if not x: |
|
53 return False |
|
54 return True |
|
55 |
|
56 try: |
|
57 sorted = sorted |
|
58 except NameError: |
|
59 builtin_cmp = cmp # need to use cmp as keyword arg |
|
60 |
|
61 def sorted(iterable, cmp=None, key=None, reverse=0): |
|
62 use_cmp = None |
|
63 if key is not None: |
|
64 if cmp is None: |
|
65 def use_cmp(x, y): |
|
66 return builtin_cmp(x[0], y[0]) |
|
67 else: |
|
68 def use_cmp(x, y): |
|
69 return cmp(x[0], y[0]) |
|
70 l = [(key(element), element) for element in iterable] |
|
71 else: |
|
72 if cmp is not None: |
|
73 use_cmp = cmp |
|
74 l = list(iterable) |
|
75 if use_cmp is not None: |
|
76 l.sort(use_cmp) |
|
77 else: |
|
78 l.sort() |
|
79 if reverse: |
|
80 l.reverse() |
|
81 if key is not None: |
|
82 return [element for (_, element) in l] |
|
83 return l |
|
84 |
|
85 try: |
|
86 set, frozenset = set, frozenset |
|
87 except NameError: |
|
88 from sets import set, frozenset |
|
89 |
|
90 # pass through |
|
91 enumerate = enumerate |
|
92 |
|
93 try: |
|
94 BaseException = BaseException |
|
95 except NameError: |
|
96 BaseException = Exception |
|
97 |
|
98 try: |
|
99 GeneratorExit = GeneratorExit |
|
100 except NameError: |
|
101 class GeneratorExit(Exception): |
|
102 """ This exception is never raised, it is there to make it possible to |
|
103 write code compatible with CPython 2.5 even in lower CPython |
|
104 versions.""" |
|
105 pass |
|
106 GeneratorExit.__module__ = 'exceptions' |
|
107 |
|
108 _sysex = (KeyboardInterrupt, SystemExit, MemoryError, GeneratorExit) |
|
109 |
|
110 if sys.version_info >= (3, 0): |
|
111 exec ("print_ = print ; exec_=exec") |
|
112 import builtins |
|
113 |
|
114 # some backward compatibility helpers |
|
115 _basestring = str |
|
116 def _totext(obj, encoding=None): |
|
117 if isinstance(obj, bytes): |
|
118 obj = obj.decode(encoding) |
|
119 elif not isinstance(obj, str): |
|
120 obj = str(obj) |
|
121 return obj |
|
122 |
|
123 def _isbytes(x): |
|
124 return isinstance(x, bytes) |
|
125 def _istext(x): |
|
126 return isinstance(x, str) |
|
127 |
|
128 def _getimself(function): |
|
129 return getattr(function, '__self__', None) |
|
130 |
|
131 def _getfuncdict(function): |
|
132 return getattr(function, "__dict__", None) |
|
133 |
|
134 def _getcode(function): |
|
135 return getattr(function, "__code__", None) |
|
136 |
|
137 def execfile(fn, globs=None, locs=None): |
|
138 if globs is None: |
|
139 back = sys._getframe(1) |
|
140 globs = back.f_globals |
|
141 locs = back.f_locals |
|
142 del back |
|
143 elif locs is None: |
|
144 locs = globs |
|
145 fp = open(fn, "rb") |
|
146 try: |
|
147 source = fp.read() |
|
148 finally: |
|
149 fp.close() |
|
150 co = compile(source, fn, "exec", dont_inherit=True) |
|
151 exec_(co, globs, locs) |
|
152 |
|
153 def callable(obj): |
|
154 return hasattr(obj, "__call__") |
|
155 |
|
156 else: |
|
157 import __builtin__ as builtins |
|
158 _totext = unicode |
|
159 _basestring = basestring |
|
160 execfile = execfile |
|
161 callable = callable |
|
162 def _isbytes(x): |
|
163 return isinstance(x, str) |
|
164 def _istext(x): |
|
165 return isinstance(x, unicode) |
|
166 |
|
167 def _getimself(function): |
|
168 return getattr(function, 'im_self', None) |
|
169 |
|
170 def _getfuncdict(function): |
|
171 return getattr(function, "__dict__", None) |
|
172 |
|
173 def _getcode(function): |
|
174 try: |
|
175 return getattr(function, "__code__") |
|
176 except AttributeError: |
|
177 return getattr(function, "func_code", None) |
|
178 |
|
179 def print_(*args, **kwargs): |
|
180 """ minimal backport of py3k print statement. """ |
|
181 sep = ' ' |
|
182 if 'sep' in kwargs: |
|
183 sep = kwargs.pop('sep') |
|
184 end = '\n' |
|
185 if 'end' in kwargs: |
|
186 end = kwargs.pop('end') |
|
187 file = 'file' in kwargs and kwargs.pop('file') or sys.stdout |
|
188 if kwargs: |
|
189 args = ", ".join([str(x) for x in kwargs]) |
|
190 raise TypeError("invalid keyword arguments: %s" % args) |
|
191 at_start = True |
|
192 for x in args: |
|
193 if not at_start: |
|
194 file.write(sep) |
|
195 file.write(str(x)) |
|
196 at_start = False |
|
197 file.write(end) |
|
198 |
|
199 def exec_(obj, globals=None, locals=None): |
|
200 """ minimal backport of py3k exec statement. """ |
|
201 __tracebackhide__ = True |
|
202 if globals is None: |
|
203 frame = sys._getframe(1) |
|
204 globals = frame.f_globals |
|
205 if locals is None: |
|
206 locals = frame.f_locals |
|
207 elif locals is None: |
|
208 locals = globals |
|
209 exec2(obj, globals, locals) |
|
210 |
|
211 if sys.version_info >= (3,0): |
|
212 def _reraise(cls, val, tb): |
|
213 __tracebackhide__ = True |
|
214 assert hasattr(val, '__traceback__') |
|
215 raise val |
|
216 else: |
|
217 exec (""" |
|
218 def _reraise(cls, val, tb): |
|
219 __tracebackhide__ = True |
|
220 raise cls, val, tb |
|
221 def exec2(obj, globals, locals): |
|
222 __tracebackhide__ = True |
|
223 exec obj in globals, locals |
|
224 """) |
|
225 |
|
226 def _tryimport(*names): |
|
227 """ return the first successfully imported module. """ |
|
228 assert names |
|
229 for name in names: |
|
230 try: |
|
231 return __import__(name, None, None, '__doc__') |
|
232 except ImportError: |
|
233 excinfo = sys.exc_info() |
|
234 _reraise(*excinfo) |