rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:m", | opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:msC:", | def main(argv = None): import getopt if argv is None: argv = sys.argv try: opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:m", ["help", "version", "trace", "count", "report", "no-report", "file=", "logdir=", "missing", "ignore-module=", "ignore-dir="]) except getopt.error, msg: sys.stderr.write("%s: %s\n" % (sys.a... |
"ignore-module=", "ignore-dir="]) | "ignore-module=", "ignore-dir=", "coverdir="]) | def main(argv = None): import getopt if argv is None: argv = sys.argv try: opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:m", ["help", "version", "trace", "count", "report", "no-report", "file=", "logdir=", "missing", "ignore-module=", "ignore-dir="]) except getopt.error, msg: sys.stderr.write("%s: %s\n" % (sys.a... |
sys.stderr.write("%s: %s\n" % (sys.argv[0], msg)) sys.stderr.write("Try `%s --help' for more information\n" % sys.argv[0]) | print >> sys.stderr, "%s: %s" % (sys.argv[0], msg) print >> sys.stderr, "Try `%s --help' for more information" \ % sys.argv[0] | def main(argv = None): import getopt if argv is None: argv = sys.argv try: opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:m", ["help", "version", "trace", "count", "report", "no-report", "file=", "logdir=", "missing", "ignore-module=", "ignore-dir="]) except getopt.error, msg: sys.stderr.write("%s: %s\n" % (sys.a... |
create_results_log(results, logdir, missing) | create_results_log(results, logdir, missing, summary=summary, coverdir=coverdir) | def main(argv = None): import getopt if argv is None: argv = sys.argv try: opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:m", ["help", "version", "trace", "count", "report", "no-report", "file=", "logdir=", "missing", "ignore-module=", "ignore-dir="]) except getopt.error, msg: sys.stderr.write("%s: %s\n" % (sys.a... |
write32(self.fileobj, self.crc) | write32u(self.fileobj, LOWU32(self.crc)) | def close(self): if self.mode == WRITE: self.fileobj.write(self.compress.flush()) write32(self.fileobj, self.crc) # self.size may exceed 2GB, or even 4GB write32u(self.fileobj, LOWU32(self.size)) self.fileobj = None elif self.mode == READ: self.fileobj = None if self.myfileobj: self.myfileobj.close() self.myfileobj = N... |
self._do('tag_lower', belowThis) | self._do('lower', belowThis) | def lower(self, belowThis=None): self._do('tag_lower', belowThis) |
self._do('tag_raise', aboveThis) | self._do('raise', aboveThis) | def tkraise(self, aboveThis=None): self._do('tag_raise', aboveThis) |
def compare_generic_iter(make_it,match): | def compare_generic_iter(test, make_it, match): | def compare_generic_iter(make_it,match): """Utility to compare a generic 2.1/2.2+ iterator with an iterable If running under Python 2.2+, this tests the iterator using iter()/next(), as well as __getitem__. 'make_it' must be a function returning a fresh iterator to be tested (since this may test the iterator twice)."... |
assert it[n]==item | test.assertEqual(it[n], item) | def compare_generic_iter(make_it,match): """Utility to compare a generic 2.1/2.2+ iterator with an iterable If running under Python 2.2+, this tests the iterator using iter()/next(), as well as __getitem__. 'make_it' must be a function returning a fresh iterator to be tested (since this may test the iterator twice)."... |
assert iter(it) is it | test.assert_(iter(it) is it) | def compare_generic_iter(make_it,match): """Utility to compare a generic 2.1/2.2+ iterator with an iterable If running under Python 2.2+, this tests the iterator using iter()/next(), as well as __getitem__. 'make_it' must be a function returning a fresh iterator to be tested (since this may test the iterator twice)."... |
assert it.next()==item try: it.next() except StopIteration: pass else: raise AssertionError("Too many items from .next()",it) | test.assertEqual(it.next(), item) test.assertRaises(StopIteration, it.next) | def compare_generic_iter(make_it,match): """Utility to compare a generic 2.1/2.2+ iterator with an iterable If running under Python 2.2+, this tests the iterator using iter()/next(), as well as __getitem__. 'make_it' must be a function returning a fresh iterator to be tested (since this may test the iterator twice)."... |
compare_generic_iter(make_it,match) | compare_generic_iter(self, make_it, match) | def make_it(text=text,size=size): return util.FileWrapper(StringIO(text),size) |
assert h.environ.has_key(key) | self.assert_(h.environ.has_key(key)) | def testCGIEnviron(self): h = BaseCGIHandler(None,None,None,{}) h.setup_environ() for key in 'wsgi.url_scheme', 'wsgi.input', 'wsgi.errors': assert h.environ.has_key(key) |
print 'cwd', os.getcwd() print 'fsspec', macfs.FSSpec(fullname) raise | print '*** Copy failed mysteriously, try again' print '*** cwd', os.getcwd() print '*** fsspec', macfs.FSSpec(fullname) try: i = 1 / 0 except: pass macostools.copy(fullname, os.path.join(destprefix, dest), 1) | def rundir(self, path, destprefix, doit): files = os.listdir(path) todo = [] rv = 1 for f in files: if self.exc.match(f): continue fullname = os.path.join(path, f) if os.path.isdir(fullname): todo.append(fullname) else: dest = self.inc.match(fullname) if dest == None: print 'Not yet resolved:', fullname rv = 0 if dest:... |
counter = 0 | def gettempprefix(): """Function to calculate a prefix of the filename to use.""" global template, _pid if os.name == 'posix' and _pid and _pid != os.getpid(): # Our pid changed; we must have forked -- zap the template template = None if template is None: if os.name == 'posix': _pid = os.getpid() template = '@' + `_pid... | |
global counter | def mktemp(suffix=""): """User-callable function to return a unique temporary file name.""" global counter dir = gettempdir() pre = gettempprefix() while 1: counter = counter + 1 file = os.path.join(dir, pre + `counter` + suffix) if not os.path.exists(file): return file | |
counter = counter + 1 file = os.path.join(dir, pre + `counter` + suffix) | i = _counter.get_next() file = os.path.join(dir, pre + str(i) + suffix) | def mktemp(suffix=""): """User-callable function to return a unique temporary file name.""" global counter dir = gettempdir() pre = gettempprefix() while 1: counter = counter + 1 file = os.path.join(dir, pre + `counter` + suffix) if not os.path.exists(file): return file |
print 'XXXX boolean:', `data` | def _decode_boolean(data, key): print 'XXXX boolean:', `data` return ord(data[0]) | |
return addinfourl(fp, headers, url) | return addinfourl(fp, headers, "https:" + url) | def open_https(self, url, data=None): """Use HTTPS protocol.""" import httplib user_passwd = None if type(url) is types.StringType: host, selector = splithost(url) if host: user_passwd, host = splituser(host) host = unquote(host) realhost = host else: host, selector = url urltype, rest = splittype(selector) url = rest ... |
self.curNode.appendChild(node) self.curNode = node | def startElementNS(self, name, tagName , attrs): uri, localname = name if uri: # When using namespaces, the reader may or may not # provide us with the original name. If not, create # *a* valid tagName from the current context. if tagName is None: tagName = self._current_context[uri] + ":" + localname node = self.docum... | |
self.push(node) | def startElementNS(self, name, tagName , attrs): uri, localname = name if uri: # When using namespaces, the reader may or may not # provide us with the original name. If not, create # *a* valid tagName from the current context. if tagName is None: tagName = self._current_context[uri] + ":" + localname node = self.docum... | |
node = self.curNode self.lastEvent[1] = [(END_ELEMENT, node), None] self.lastEvent = self.lastEvent[1] self.curNode = self.curNode.parentNode | self.lastEvent[1] = [(END_ELEMENT, self.pop()), None] self.lastEvent = self.lastEvent[1] | def endElementNS(self, name, tagName): node = self.curNode self.lastEvent[1] = [(END_ELEMENT, node), None] self.lastEvent = self.lastEvent[1] #self.events.append((END_ELEMENT, node)) self.curNode = self.curNode.parentNode |
self.curNode.appendChild(node) self.curNode = node | def startElement(self, name, attrs): node = self.document.createElement(name) | |
self.push(node) | def startElement(self, name, attrs): node = self.document.createElement(name) | |
node = self.curNode self.lastEvent[1] = [(END_ELEMENT, node), None] self.lastEvent = self.lastEvent[1] self.curNode = node.parentNode | self.lastEvent[1] = [(END_ELEMENT, self.pop()), None] self.lastEvent = self.lastEvent[1] | def endElement(self, name): node = self.curNode self.lastEvent[1] = [(END_ELEMENT, node), None] self.lastEvent = self.lastEvent[1] #self.events.append((END_ELEMENT, node)) self.curNode = node.parentNode |
self.curNode.appendChild(node) | def comment(self, s): node = self.document.createComment(s) self.curNode.appendChild(node) | |
self.curNode.appendChild(node) | def processingInstruction(self, target, data): node = self.document.createProcessingInstruction(target, data) | |
self.curNode.appendChild(node) | def ignorableWhitespace(self, chars): node = self.document.createTextNode(chars) self.curNode.appendChild(node) | |
self.curNode.appendChild(node) | def characters(self, chars): node = self.document.createTextNode(chars) self.curNode.appendChild(node) | |
self.curNode = self.document = node | self.document = node | def startDocument(self): publicId = systemId = None if self._locator: publicId = self._locator.getPublicId() systemId = self._locator.getSystemId() if self.documentFactory is None: import xml.dom.minidom self.documentFactory = xml.dom.minidom.Document.implementation node = self.documentFactory.createDocument(None, publ... |
self.push(node) | def startDocument(self): publicId = systemId = None if self._locator: publicId = self._locator.getPublicId() systemId = self._locator.getSystemId() if self.documentFactory is None: import xml.dom.minidom self.documentFactory = xml.dom.minidom.Document.implementation node = self.documentFactory.createDocument(None, publ... | |
assert self.curNode.parentNode is None, \ "not all elements have been properly closed" assert self.curNode.documentElement is not None, \ "document does not contain a root element" node = self.curNode.documentElement self.lastEvent[1] = [(END_DOCUMENT, node), None] | self.lastEvent[1] = [(END_DOCUMENT, self.document), None] self.pop() | def endDocument(self): assert self.curNode.parentNode is None, \ "not all elements have been properly closed" assert self.curNode.documentElement is not None, \ "document does not contain a root element" node = self.curNode.documentElement self.lastEvent[1] = [(END_DOCUMENT, node), None] #self.events.append((END_DOCUME... |
cur_node.parentNode.appendChild(cur_node) | parents[-1].appendChild(cur_node) if token == START_ELEMENT: parents.append(cur_node) elif token == END_ELEMENT: del parents[-1] | def expandNode(self, node): event = self.getEvent() while event: token, cur_node = event if cur_node is node: return if token != END_ELEMENT: cur_node.parentNode.appendChild(cur_node) event = self.getEvent() |
self.curNode.parentNode.appendChild(self.curNode) | curNode = self.elementStack[-1] parentNode = self.elementStack[-2] parentNode.appendChild(curNode) | def startElementNS(self, name, tagName , attrs): PullDOM.startElementNS(self, name, tagName, attrs) self.curNode.parentNode.appendChild(self.curNode) |
self.curNode.parentNode.appendChild(self.curNode) | curNode = self.elementStack[-1] parentNode = self.elementStack[-2] parentNode.appendChild(curNode) | def startElement(self, name, attrs): PullDOM.startElement(self, name, attrs) self.curNode.parentNode.appendChild(self.curNode) |
node.parentNode.appendChild(node) | parentNode = self.elementStack[-1] parentNode.appendChild(node) | def processingInstruction(self, target, data): PullDOM.processingInstruction(self, target, data) node = self.lastEvent[0][1] node.parentNode.appendChild(node) |
node.parentNode.appendChild(node) | parentNode = self.elementStack[-1] parentNode.appendChild(node) | def ignorableWhitespace(self, chars): PullDOM.ignorableWhitespace(self, chars) node = self.lastEvent[0][1] node.parentNode.appendChild(node) |
node.parentNode.appendChild(node) | parentNode = self.elementStack[-1] parentNode.appendChild(node) | def characters(self, chars): PullDOM.characters(self, chars) node = self.lastEvent[0][1] node.parentNode.appendChild(node) |
m235 to share a single generator". | m235 to share a single generator". Unfortunately, using generators this way creates a reference-cycle that the garbage collector (currently) can't clean up, so we have to explicitly break the cycle (by calling the inner generator's close() method) | ... def tail(g): |
... m2, m3, m5, mRes = tee(_m235(), 4) ... return mRes >>> it = m235() | ... m1 = _m235() ... m2, m3, m5, mRes = tee(m1, 4) ... return m1.close, mRes >>> closer, it = m235() | ... def _m235(): |
are quite straightforwardly expressed with this Python idiom. | are quite straightforwardly expressed with this Python idiom. The problem is that this creates the same kind of reference cycle as the m235() implementation above, and again we have to explicitly close the innermost generator to clean up the cycle. | ... def _m235(): |
... fibHead, fibTail, fibRes = tee(_fib(), 3) ... return fibRes >>> firstn(fib(), 17) | ... realfib = _fib() ... fibHead, fibTail, fibRes = tee(realfib, 3) ... return realfib.close, fibRes >>> closer, fibber = fib() >>> firstn(fibber, 17) | ... def _fib(): |
lines.append ("pthname=%s.%s" % (metadata.name, metadata.version)) | def get_inidata (self): # Return data describing the installation. | |
AAAA8AAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1v ZGUuDQ0KJAAAAAAAAADqs5WMrtL7367S+9+u0vvf1c7336/S+98tzvXfrNL731Hy/9+s0vvfzM3o 36bS+9+u0vrf89L7367S+9+j0vvfUfLx36PS+99p1P3fr9L731JpY2iu0vvfAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAUEUAAEwBAwBmkbo5AAAAAAAAAADgAA8BCwEGAABAAAAAEAAAAJAAABDVAAAA oAAAAOAAAAAA... | AAAA4AAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1v ZGUuDQ0KJAAAAAAAAADq05KMrrL8366y/N+usvzf1a7w36+y/N8trvLfrLL831GS+N+ssvzfzK3v 36ay/N+usv3fzrL8366y/N+jsvzfUZL236Oy/N9ptPrfr7L831JpY2iusvzfAAAAAAAAAABQRQAA TAEDAPimujkAAAAAAAAAAOAADwELAQYAAEAAAAAQAAAAkAAA4NUAAACgAAAA4AAAAABAAAAQAAAA AgAABAAAAAAA... | def get_exe_bytes (self): import base64 return base64.decodestring (EXEDATA) |
bGwgUmlnaHRzIFJlc2VydmVkLiAkCgBVUFghDAkCCjUEmknnJr9G0bYAAAU1AAAAsAAAJgEABf+/ /f9TVVaLdCQUhfZXdHaLfAi9EHBAAIA+AHRoalxWbP/29v8V/GANi/BZHll0V4AmAFcRmP833//Y g/v/dR5qD5SFwHUROUQkHHQLV9na//9VagX/VCQog8QM9sMQdR1otwAAJJD/T9itg10cACHGBlxG dZNqAVhfXr/7//9dW8NVi+yD7BCLRRRTVleLQBaLPXg0iUX4M/a79u7+d0PAOXUIdQfHRQgBDFZo gFYRY9/+9lZW... | bGwgUmlnaHRzIFJlc2VydmVkLiAkCgBVUFghDAkCCgSozNfnkDDP6bYAANQ1AAAAsAAAJgEAjf+/ /f9TVVaLdCQUhfZXdHaLfAi9EHBAAIA+AHRoalxWbP/29v8V/GANi/BZHll0V4AmAFcReP833//Y g/v/dR5qD3yFwHUROUQkHHQLV9na//9VagX/VCQog8QM9sMQdR1otwAAJID/T9itg10cACHGBlxG dZNqAVhfXr/7//9dW8NVi+yD7BCLRRRTVleLQBaLPYg0iUX4M/a79u7+d0PAOXUIdQfHRQgBDFZo gFYRY9/+9lZW... | def get_exe_bytes (self): import base64 return base64.decodestring (EXEDATA) |
vb37yAONRfBQ3GaLSAoDQAxRYdj70Ht0Sn38GQNQ4XVvpqQ7+HUJC4idhy+U7psOVmoEVhCghIs9 iN/X4CKQhg9oOIk8mu3WNusmrCsCUyqcU8/3W9uuCCV2CDvGdRcnECjChmYwhJURM8B8ti385FvJ OFOLXVKLIVeh2B4W/kYIZj0IAFGeADiayG1uu13sUOjWPrJMEDZXyLbLVrgiEkC7CMwWXgbYtvvP 3SVoqFgq8VCJXdQtFVze+/7CjVrAdHf/dChQaJCfGUtbutvnBBZ8lXQTGg18kobPde4E0JH2IR8V rqEbyGEfZNxQ... | vb37yAONRfBQ3GaLSAoDQAxRYdj70HuESn38GQNQ4XVvppQ7+HUJC1Sdhy+U7psOVmoEVhBwhIs9 VN/X4CKQhg9oOIk8mu3WNusmrCsCUyp0U8/3W9uuCCV2CDvGdRcnECjChmYwhJURM8B8ti385FvJ OFOLXVKLIVeh2B4W/kYIZj0IAFGeADiayG1uu13sUOjWP+JMEDZXyLbLVrgiEkC7CMwWXgbYtvvP 3SVoqFgq8VCJXdQtFoze+/7CjVrAdHf/dChQaJCfGUtbutvnBBeslXQTGg18kvLPde4E0JH2IR8W PIXAHrqBHGTc... | def get_exe_bytes (self): import base64 return base64.decodestring (EXEDATA) |
AAAAAAAAAAAAAAAAAAABAAkEAACoAAAAOKsAAH4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAJ BAAA0AAAALisAABuAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEACQQAAPgAAAAorgAAWgIAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAABAAkEAAAgAQAAiLAAAFwBAAAAAAAAAAAAAAAAAAAAAAAAAAAA | AAAAAAAAAAAAAAAAAAABAAkEAACoAAAAOKsAAKABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAJ BAAA0AAAANisAABiAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEACQQAAPgAAABArgAAWgIAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAABAAkEAAAgAQAAoLAAAFwBAAAAAAAAAAAAAAAAAAAAAAAAAAAA | def get_exe_bytes (self): import base64 return base64.decodestring (EXEDATA) |
AABFeGl0UHJvY2VzcwAAAFJlZ0Nsb3NlS2V5AAAAUHJvcGVydHlTaGVldEEAAFRleHRPdXRBAABl eGl0AABFbmRQYWludAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | AABFeGl0UHJvY2VzcwAAAFJlZ0Nsb3NlS2V5AAAAUHJvcGVydHlTaGVldEEAAFRleHRPdXRBAABm cmVlAABFbmRQYWludAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | def get_exe_bytes (self): import base64 return base64.decodestring (EXEDATA) |
raise self.failureException, (msg or '%s != %s' % (first, second)) | raise self.failureException, \ (msg or '%s != %s' % (`first`, `second`)) | def failUnlessEqual(self, first, second, msg=None): """Fail if the two objects are unequal as determined by the '!=' operator. """ if first != second: raise self.failureException, (msg or '%s != %s' % (first, second)) |
raise self.failureException, (msg or '%s == %s' % (first, second)) | raise self.failureException, \ (msg or '%s == %s' % (`first`, `second`)) | def failIfEqual(self, first, second, msg=None): """Fail if the two objects are equal as determined by the '==' operator. """ if first == second: raise self.failureException, (msg or '%s == %s' % (first, second)) |
if err[0] is KeyboardInterrupt: self.shouldStop = 1 | def addError(self, test, err): TestResult.addError(self, test, err) if self.showAll: self.stream.writeln("ERROR") elif self.dots: self.stream.write('E') if err[0] is KeyboardInterrupt: self.shouldStop = 1 | |
__test__ = {"tut": tutorial_tests, "pep": pep_tests, "email": email_tests, "fun": fun_tests, "syntax": syntax_tests} | x_tests = """ >>> def firstn(g, n): ... return [g.next() for i in range(n)] >>> def times(n, g): ... for i in g: ... yield n * i >>> def merge(g, h): ... ng = g.next() ... nh = h.next() ... while 1: ... if ng < nh: ... yield ng ... ng = g.next() ... ... | >>> def f(): |
for i in range(1000): | for i in range(5000): | def test_main(): import doctest, test_generators if 0: # Temporary block to help track down leaks. So far, the blame # has fallen mostly on doctest. for i in range(1000): doctest.master = None doctest.testmod(test_generators) else: doctest.testmod(test_generators) |
return attrname[:len(prefix)] == prefix and callable(getattr(testCaseClass, attrname)) | return attrname.startswith(prefix) and callable(getattr(testCaseClass, attrname)) | def isTestMethod(attrname, testCaseClass=testCaseClass, prefix=self.testMethodPrefix): return attrname[:len(prefix)] == prefix and callable(getattr(testCaseClass, attrname)) |
raise WalkerEror, "Can't find appropriate Node type: %s" % str(args) | raise WalkerError, "Can't find appropriate Node type: %s" % str(args) | def Node(*args): kind = args[0] if nodes.has_key(kind): try: return nodes[kind](*args[1:]) except TypeError: print nodes[kind], len(args), args raise else: raise WalkerEror, "Can't find appropriate Node type: %s" % str(args) #return apply(ast.Node, args) |
raise WalkerEror, ('unexpected node type', n) | raise WalkerError, ('unexpected node type', n) | def compile_node(self, node): ### emit a line-number node? n = node[0] |
raise WalkerEror | raise WalkerError | def parameters(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def varargslist(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def fpdef(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def fplist(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def dotted_name(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def comp_op(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def trailer(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def sliceop(self, nodelist): raise WalkerEror |
raise WalkerEror | raise WalkerError | def argument(self, nodelist): raise WalkerEror |
return self.list == [] | return not self.list | def is_empty (self): return self.list == [] |
self.data[k] = v | self[k] = v | def update(self, dict): if isinstance(dict, UserDict): self.data.update(dict.data) elif isinstance(dict, type(self.data)): self.data.update(dict) else: for k, v in dict.items(): self.data[k] = v |
return self.data.get(key, failobj) | if not self.has_key(key): return failobj return self[key] | def get(self, key, failobj=None): return self.data.get(key, failobj) |
if not self.data.has_key(key): self.data[key] = failobj return self.data[key] | if not self.has_key(key): self[key] = failobj return self[key] | def setdefault(self, key, failobj=None): if not self.data.has_key(key): self.data[key] = failobj return self.data[key] |
verify(log == [('getattr', '__setattr__'), ("setattr", "foo", 12), | verify(log == [("setattr", "foo", 12), | def __delattr__(self, name): log.append(("delattr", name)) MT.__delattr__(self, name) |
('getattr', '__delattr__'), | def __delattr__(self, name): log.append(("delattr", name)) MT.__delattr__(self, name) | |
suffixes = [".py", ".pyc", ".pyo"] | suffixes = [] for triple in imp.get_suffixes(): suffixes.append(triple[0]) | def find_all_submodules(self, m): if not m.__path__: return modules = {} suffixes = [".py", ".pyc", ".pyo"] for dir in m.__path__: try: names = os.listdir(dir) except os.error: self.msg(2, "can't list directory", dir) continue for name in names: mod = None for suff in suffixes: n = len(suff) if name[-n:] == suff: mod =... |
if size < 0: size = sys.maxint | if size < 0: size = sys.maxint readsize = self.min_readsize else: readsize = size | def readline(self, size=-1): if size < 0: size = sys.maxint bufs = [] readsize = min(100, size) # Read from the file in small chunks while True: if size == 0: return "".join(bufs) # Return resulting line |
readsize = min(100, size) while True: if size == 0: return "".join(bufs) | while size != 0: | def readline(self, size=-1): if size < 0: size = sys.maxint bufs = [] readsize = min(100, size) # Read from the file in small chunks while True: if size == 0: return "".join(bufs) # Return resulting line |
if size is not None: if i==-1 and len(c) > size: i=size-1 elif size <= i: i = size -1 | if (size <= i) or (i == -1 and len(c) > size): i = size - 1 | def readline(self, size=-1): if size < 0: size = sys.maxint bufs = [] readsize = min(100, size) # Read from the file in small chunks while True: if size == 0: return "".join(bufs) # Return resulting line |
bufs.append(c[:i+1]) self._unread(c[i+1:]) return ''.join(bufs) | bufs.append(c[:i + 1]) self._unread(c[i + 1:]) break | def readline(self, size=-1): if size < 0: size = sys.maxint bufs = [] readsize = min(100, size) # Read from the file in small chunks while True: if size == 0: return "".join(bufs) # Return resulting line |
up in the table self.extensions_map, using text/plain | up in the table self.extensions_map, using application/octet-stream | def guess_type(self, path): """Guess the type of a file. |
if dir not in dirs and os.path.isdir(dir): | normdir = os.path.normcase(dir) if normdir not in normdirs and os.path.isdir(dir): | def pathdirs(): """Convert sys.path into a list of absolute, existing, unique paths.""" dirs = [] for dir in sys.path: dir = os.path.abspath(dir or '.') if dir not in dirs and os.path.isdir(dir): dirs.append(dir) return dirs |
def cleanid(text): | def stripid(text): | def cleanid(text): """Remove the hexadecimal id from a Python object representation.""" return re.sub(' at 0x[0-9a-f]{5,}>$', '>', text) |
return re.sub(' at 0x[0-9a-f]{5,}>$', '>', text) | for pattern in [' at 0x[0-9a-f]{6,}>$', ' at [0-9A-F]{8,}>$']: if re.search(pattern, repr(Exception)): return re.sub(pattern, '>', text) return text | def cleanid(text): """Remove the hexadecimal id from a Python object representation.""" return re.sub(' at 0x[0-9a-f]{5,}>$', '>', text) |
return self.escape(cram(cleanid(repr(x)), self.maxother)) | return self.escape(cram(stripid(repr(x)), self.maxother)) | def repr1(self, x, level): methodname = 'repr_' + join(split(type(x).__name__), '_') if hasattr(self, methodname): return getattr(self, methodname)(x, level) else: return self.escape(cram(cleanid(repr(x)), self.maxother)) |
return cram(cleanid(repr(x)), self.maxstring) | return cram(stripid(repr(x)), self.maxstring) | def repr_instance(self, x, level): try: return cram(cleanid(repr(x)), self.maxstring) except: return self.escape('<%s instance>' % x.__class__.__name__) |
file = inspect.getsourcefile(object) filelink = '<a href="file:%s">%s</a>' % (file, file) | path = os.path.abspath(inspect.getfile(object)) filelink = '<a href="file:%s">%s</a>' % (path, path) | def docmodule(self, object): """Produce HTML documentation for a module object.""" name = object.__name__ result = '' head = '<br><big><big><strong> %s</strong></big></big>' % name try: file = inspect.getsourcefile(object) filelink = '<a href="file:%s">%s</a>' % (file, file) except TypeError: filelink = '(built-in... |
info.append('version: %s' % self.escape(version)) | info.append('version %s' % self.escape(version)) | def docmodule(self, object): """Produce HTML documentation for a module object.""" name = object.__name__ result = '' head = '<br><big><big><strong> %s</strong></big></big>' % name try: file = inspect.getsourcefile(object) filelink = '<a href="file:%s">%s</a>' % (file, file) except TypeError: filelink = '(built-in... |
return cram(cleanid(repr(x)), self.maxother) | return cram(stripid(repr(x)), self.maxother) | def repr1(self, x, level): methodname = 'repr_' + join(split(type(x).__name__), '_') if hasattr(self, methodname): return getattr(self, methodname)(x, level) else: return cram(cleanid(repr(x)), self.maxother) |
return cram(cleanid(repr(x)), self.maxstring) | return cram(stripid(repr(x)), self.maxstring) | def repr_instance(self, x, level): try: return cram(cleanid(repr(x)), self.maxstring) except: return '<%s instance>' % x.__class__.__name__ |
if version[:11] == '$Revision$': version = version[11:-1] | if version[:11] == '$' + 'Revision: ' and version[-1:] == '$': version = strip(version[11:-1]) | def docmodule(self, object): """Produce text documentation for a given module object.""" result = '' |
if __name__ == '__main__': | def cli(): | def server_activate(self): self.base.server_activate(self) if self.callback: self.callback() |
size = (size // 2) | size //= 2 | def test_format(self, size): s = '-' * size sf = '%s' % (s,) self.failUnless(s == sf) del sf sf = '..%s..' % (s,) self.assertEquals(len(sf), len(s) + 4) self.failUnless(sf.startswith('..-')) self.failUnless(sf.endswith('-..')) del s, sf |
@bigmemtest(minsize=_2G + 10, memuse=8) | @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) | def test_extend_large(self, size): return self.basic_test_extend(size) |
l = [1L, 2L, 3L, 4L, 5L] * (size // 5) | l = [1L, 2L, 3L, 4L, 5L] * size size *= 5 | def test_index(self, size): l = [1L, 2L, 3L, 4L, 5L] * (size // 5) self.assertEquals(l.index(1), 0) self.assertEquals(l.index(5, size - 5), size - 1) self.assertEquals(l.index(5, size - 5, size), size - 1) self.assertRaises(ValueError, l.index, 1, size - 4, size) self.assertRaises(ValueError, l.index, 6L) |
@bigmemtest(minsize=_2G + 20, memuse=8) | @bigmemtest(minsize=_2G // 5 + 4, memuse=8 * 5) | def test_insert(self, size): l = [1.0] * size l.insert(size - 1, "A") size += 1 self.assertEquals(len(l), size) self.assertEquals(l[-3:], [1.0, "A", 1.0]) |
l = [u"a", u"b", u"c", u"d", u"e"] * (size // 5) | l = [u"a", u"b", u"c", u"d", u"e"] * size size *= 5 | def test_pop(self, size): l = [u"a", u"b", u"c", u"d", u"e"] * (size // 5) self.assertEquals(len(l), size) |
@bigmemtest(minsize=_2G + 10, memuse=8) | @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) | def test_remove(self, size): l = [10] * size self.assertEquals(len(l), size) |
l = [1, 2, 3, 4, 5] * (size // 5) | l = [1, 2, 3, 4, 5] * size | def test_reverse(self, size): l = [1, 2, 3, 4, 5] * (size // 5) l.reverse() self.assertEquals(len(l), size) self.assertEquals(l[-5:], [5, 4, 3, 2, 1]) self.assertEquals(l[:5], [5, 4, 3, 2, 1]) |
self.assertEquals(len(l), size) | self.assertEquals(len(l), size * 5) | def test_reverse(self, size): l = [1, 2, 3, 4, 5] * (size // 5) l.reverse() self.assertEquals(len(l), size) self.assertEquals(l[-5:], [5, 4, 3, 2, 1]) self.assertEquals(l[:5], [5, 4, 3, 2, 1]) |
@bigmemtest(minsize=_2G + 10, memuse=8) | @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) | def test_reverse(self, size): l = [1, 2, 3, 4, 5] * (size // 5) l.reverse() self.assertEquals(len(l), size) self.assertEquals(l[-5:], [5, 4, 3, 2, 1]) self.assertEquals(l[:5], [5, 4, 3, 2, 1]) |
l = [1, 2, 3, 4, 5] * (size // 5) | l = [1, 2, 3, 4, 5] * size | def test_sort(self, size): l = [1, 2, 3, 4, 5] * (size // 5) l.sort() self.assertEquals(len(l), size) self.assertEquals(l.count(1), size // 5) self.assertEquals(l[:10], [1] * 10) self.assertEquals(l[-10:], [5] * 10) |
self.assertEquals(len(l), size) self.assertEquals(l.count(1), size // 5) | self.assertEquals(len(l), size * 5) self.assertEquals(l.count(1), size) | def test_sort(self, size): l = [1, 2, 3, 4, 5] * (size // 5) l.sort() self.assertEquals(len(l), size) self.assertEquals(l.count(1), size // 5) self.assertEquals(l[:10], [1] * 10) self.assertEquals(l[-10:], [5] * 10) |
o = PyString_FromStringAndSize((char *)&qd.arrow, sizeof(qd.arrow)); if (o == NULL || PyDict_SetItemString(d, "arrow", o) != 0) Py_FatalError("can't initialize Qd.arrow"); o = PyString_FromStringAndSize((char *)&qd.black, sizeof(qd.black)); if (o == NULL || PyDict_SetItemString(d, "black", o) != 0) Py_FatalError("can't... | o = QDGA_New(); if (o == NULL || PyDict_SetItemString(d, "qd", o) != 0) Py_FatalError("can't initialize Qd.qd"); | def getargsCheck(self, name): pass |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.