Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

import sys 

 

try: 

reversed = reversed 

except NameError: 

def reversed(sequence): 

"""reversed(sequence) -> reverse iterator over values of the sequence 

 

Return a reverse iterator 

""" 

if hasattr(sequence, '__reversed__'): 

return sequence.__reversed__() 

if not hasattr(sequence, '__getitem__'): 

raise TypeError("argument to reversed() must be a sequence") 

return reversed_iterator(sequence) 

 

class reversed_iterator(object): 

 

def __init__(self, seq): 

self.seq = seq 

self.remaining = len(seq) 

 

def __iter__(self): 

return self 

 

def next(self): 

i = self.remaining 

if i > 0: 

i -= 1 

item = self.seq[i] 

self.remaining = i 

return item 

raise StopIteration 

 

def __length_hint__(self): 

return self.remaining 

 

try: 

any = any 

except NameError: 

def any(iterable): 

for x in iterable: 

if x: 

return True 

return False 

 

try: 

all = all 

except NameError: 

def all(iterable): 

for x in iterable: 

if not x: 

return False 

return True 

 

try: 

sorted = sorted 

except NameError: 

builtin_cmp = cmp # need to use cmp as keyword arg 

 

def sorted(iterable, cmp=None, key=None, reverse=0): 

use_cmp = None 

if key is not None: 

if cmp is None: 

def use_cmp(x, y): 

return builtin_cmp(x[0], y[0]) 

else: 

def use_cmp(x, y): 

return cmp(x[0], y[0]) 

l = [(key(element), element) for element in iterable] 

else: 

if cmp is not None: 

use_cmp = cmp 

l = list(iterable) 

if use_cmp is not None: 

l.sort(use_cmp) 

else: 

l.sort() 

if reverse: 

l.reverse() 

if key is not None: 

return [element for (_, element) in l] 

return l 

 

try: 

set, frozenset = set, frozenset 

except NameError: 

from sets import set, frozenset 

 

# pass through 

enumerate = enumerate 

 

try: 

BaseException = BaseException 

except NameError: 

BaseException = Exception 

 

try: 

GeneratorExit = GeneratorExit 

except NameError: 

class GeneratorExit(Exception): 

""" This exception is never raised, it is there to make it possible to 

write code compatible with CPython 2.5 even in lower CPython 

versions.""" 

pass 

GeneratorExit.__module__ = 'exceptions' 

 

_sysex = (KeyboardInterrupt, SystemExit, MemoryError, GeneratorExit) 

 

try: 

callable = callable 

except NameError: 

def callable(obj): 

return hasattr(obj, "__call__") 

 

if sys.version_info >= (3, 0): 

exec ("print_ = print ; exec_=exec") 

import builtins 

 

# some backward compatibility helpers 

_basestring = str 

def _totext(obj, encoding=None, errors=None): 

if isinstance(obj, bytes): 

if errors is None: 

obj = obj.decode(encoding) 

else: 

obj = obj.decode(encoding, errors) 

elif not isinstance(obj, str): 

obj = str(obj) 

return obj 

 

def _isbytes(x): 

return isinstance(x, bytes) 

def _istext(x): 

return isinstance(x, str) 

 

text = str 

bytes = bytes 

 

 

def _getimself(function): 

return getattr(function, '__self__', None) 

 

def _getfuncdict(function): 

return getattr(function, "__dict__", None) 

 

def _getcode(function): 

return getattr(function, "__code__", None) 

 

def execfile(fn, globs=None, locs=None): 

if globs is None: 

back = sys._getframe(1) 

globs = back.f_globals 

locs = back.f_locals 

del back 

elif locs is None: 

locs = globs 

fp = open(fn, "r") 

try: 

source = fp.read() 

finally: 

fp.close() 

co = compile(source, fn, "exec", dont_inherit=True) 

exec_(co, globs, locs) 

 

else: 

import __builtin__ as builtins 

_totext = unicode 

_basestring = basestring 

text = unicode 

bytes = str 

execfile = execfile 

callable = callable 

def _isbytes(x): 

return isinstance(x, str) 

def _istext(x): 

return isinstance(x, unicode) 

 

def _getimself(function): 

return getattr(function, 'im_self', None) 

 

def _getfuncdict(function): 

return getattr(function, "__dict__", None) 

 

def _getcode(function): 

try: 

return getattr(function, "__code__") 

except AttributeError: 

return getattr(function, "func_code", None) 

 

def print_(*args, **kwargs): 

""" minimal backport of py3k print statement. """ 

sep = ' ' 

if 'sep' in kwargs: 

sep = kwargs.pop('sep') 

end = '\n' 

if 'end' in kwargs: 

end = kwargs.pop('end') 

file = 'file' in kwargs and kwargs.pop('file') or sys.stdout 

if kwargs: 

args = ", ".join([str(x) for x in kwargs]) 

raise TypeError("invalid keyword arguments: %s" % args) 

at_start = True 

for x in args: 

if not at_start: 

file.write(sep) 

file.write(str(x)) 

at_start = False 

file.write(end) 

 

def exec_(obj, globals=None, locals=None): 

""" minimal backport of py3k exec statement. """ 

__tracebackhide__ = True 

if globals is None: 

frame = sys._getframe(1) 

globals = frame.f_globals 

if locals is None: 

locals = frame.f_locals 

elif locals is None: 

locals = globals 

exec2(obj, globals, locals) 

 

if sys.version_info >= (3, 0): 

def _reraise(cls, val, tb): 

__tracebackhide__ = True 

assert hasattr(val, '__traceback__') 

raise cls.with_traceback(val, tb) 

else: 

exec (""" 

def _reraise(cls, val, tb): 

__tracebackhide__ = True 

raise cls, val, tb 

def exec2(obj, globals, locals): 

__tracebackhide__ = True 

exec obj in globals, locals 

""") 

 

def _tryimport(*names): 

""" return the first successfully imported module. """ 

assert names 

for name in names: 

try: 

__import__(name) 

except ImportError: 

excinfo = sys.exc_info() 

else: 

return sys.modules[name] 

_reraise(*excinfo)