rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
s = SeqDict() s[10] = 'ten' s[20] = 'twenty' s[30] = 'thirty' del s[20] verify(s[10] == 'ten') verify(s.keys() == [10, 30]) verify(s.has_key(10)) verify(not s.has_key(20)) verify(10 in s) verify(20 not in s) verify([k for k in s] == [10, 30]) verify(len(s) == 2) verify(list(s.iteritems()) == [(10,'ten'), (30, 'th... | class UserDictMixinTest(unittest.TestCase): def test_all(self): s = SeqDict() s[10] = 'ten' s[20] = 'twenty' s[30] = 'thirty' del s[20] self.assertEqual(s[10], 'ten') self.assertEqual(s.keys(), [10, 30]) self.assert_(s.has_key(10)) self.assert_(not s.has_key(20)) self.assert_(10 in s) self.assert_(20 not ... | def keys(self): return list(self.keylist) |
for name in ('lib', 'purelib', 'platlib', 'scripts', 'data'): | for name in ('lib', 'purelib', 'platlib', 'scripts', 'data', 'headers'): | def finalize_options (self): |
if hasattr(package, "__loader__"): | if (hasattr(package, "__loader__") and hasattr(package.__loader__, '_files')): | def find_package_modules(package, mask): import fnmatch if hasattr(package, "__loader__"): path = package.__name__.replace(".", os.path.sep) mask = os.path.join(path, mask) for fnm in package.__loader__._files.iterkeys(): if fnmatch.fnmatchcase(fnm, mask): yield os.path.splitext(fnm)[0].replace(os.path.sep, ".") else: ... |
if typ is dict: | if issubclass(typ, dict): | def _format(self, object, stream, indent, allowance, context, level): level = level + 1 objid = _id(object) if objid in context: stream.write(_recursion(object)) self._recursive = True self._readable = False return rep = self._repr(object, context, level - 1) typ = _type(object) sepLines = _len(rep) > (self._width - 1 ... |
if typ is list or typ is tuple: if typ is list: | if issubclass(typ, list) or issubclass(typ, tuple): if issubclass(typ, list): | def _format(self, object, stream, indent, allowance, context, level): level = level + 1 objid = _id(object) if objid in context: stream.write(_recursion(object)) self._recursive = True self._readable = False return rep = self._repr(object, context, level - 1) typ = _type(object) sepLines = _len(rep) > (self._width - 1 ... |
if typ is tuple and length == 1: | if issubclass(typ, tuple) and length == 1: | def _format(self, object, stream, indent, allowance, context, level): level = level + 1 objid = _id(object) if objid in context: stream.write(_recursion(object)) self._recursive = True self._readable = False return rep = self._repr(object, context, level - 1) typ = _type(object) sepLines = _len(rep) > (self._width - 1 ... |
if typ is str: | if issubclass(typ, basestring): | def _safe_repr(object, context, maxlevels, level): typ = _type(object) if typ is str: if 'locale' not in _sys.modules: return `object`, True, False if "'" in object and '"' not in object: closure = '"' quotes = {'"': '\\"'} else: closure = "'" quotes = {"'": "\\'"} qget = quotes.get sio = _StringIO() write = sio.write ... |
if typ is dict: | if issubclass(typ, dict): | def _safe_repr(object, context, maxlevels, level): typ = _type(object) if typ is str: if 'locale' not in _sys.modules: return `object`, True, False if "'" in object and '"' not in object: closure = '"' quotes = {'"': '\\"'} else: closure = "'" quotes = {"'": "\\'"} qget = quotes.get sio = _StringIO() write = sio.write ... |
if typ is list or typ is tuple: if typ is list: | if issubclass(typ, list) or issubclass(typ, tuple): if issubclass(typ, list): | def _safe_repr(object, context, maxlevels, level): typ = _type(object) if typ is str: if 'locale' not in _sys.modules: return `object`, True, False if "'" in object and '"' not in object: closure = '"' quotes = {'"': '\\"'} else: closure = "'" quotes = {"'": "\\'"} qget = quotes.get sio = _StringIO() write = sio.write ... |
while nl < 0: | while (nl < 0 and size > 0): | def readline(self, size=-1): """Read a line with approx. size. If size is negative, read a whole line. readline() and read() must not be mixed up (!). """ if size < 0: size = sys.maxint |
if size <= 0: break | def readline(self, size=-1): """Read a line with approx. size. If size is negative, read a whole line. readline() and read() must not be mixed up (!). """ if size < 0: size = sys.maxint | |
return self.parser.names | if self.parser: return self.parser.names else: return [] | def getnames(self): return self.parser.names |
exts.append( Extension('_CF', ['cf/_CFmodule.c'], | exts.append( Extension('_CF', ['cf/_CFmodule.c', 'cf/pycfbridge.c'], | def detect_modules(self): # Ensure that /usr/local is always used add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib') add_dir_to_list(self.compiler.include_dirs, '/usr/local/include') |
waste_incs = find_file("WASTE.h", [], ["../waste/C_C++ Headers"]) | waste_incs = find_file("WASTE.h", [], ['../'*n + 'waste/C_C++ Headers' for n in (0,1,2,3,4)]) | def detect_modules(self): # Ensure that /usr/local is always used add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib') add_dir_to_list(self.compiler.include_dirs, '/usr/local/include') |
["../waste/Static Libraries"]) | ["../"*n + "waste/Static Libraries" for n in (0,1,2,3,4)]) | def detect_modules(self): # Ensure that /usr/local is always used add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib') add_dir_to_list(self.compiler.include_dirs, '/usr/local/include') |
['waste/wastemodule.c', | ['waste/wastemodule.c'] + [ os.path.join(srcdir, d) for d in | def detect_modules(self): # Ensure that /usr/local is always used add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib') add_dir_to_list(self.compiler.include_dirs, '/usr/local/include') |
include_dirs = waste_incs + ['Mac/Wastemods'], | include_dirs = waste_incs + [os.path.join(srcdir, 'Mac/Wastemods')], | def detect_modules(self): # Ensure that /usr/local is always used add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib') add_dir_to_list(self.compiler.include_dirs, '/usr/local/include') |
def detect_tkinter_darwin(self, inc_dirs, lib_dirs): from os.path import join, exists framework_dirs = [ '/System/Library/Frameworks/', '/Library/Frameworks', join(os.getenv('HOME'), '/Library/Frameworks') ] for F in framework_dirs: for fw in 'Tcl', 'Tk': if not exists(join(F, fw + '.framework')): break else: ... | def detect_modules(self): # Ensure that /usr/local is always used add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib') add_dir_to_list(self.compiler.include_dirs, '/usr/local/include') | |
platform = self.get_platform() | def detect_tkinter(self, inc_dirs, lib_dirs): # The _tkinter module. | |
self.assertRaises(TypeError, list, chain(N(s))) | self.assertRaises(TypeError, chain, N(s)) | def test_chain(self): for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): self.assertEqual(list(chain(g(s))), list(g(s))) self.assertEqual(list(chain(g(s), g(s))), list(g(s))+list(g(s))) self.assertRaises(TypeError, chain, X(s)) self.assertRaises(TypeError, list, chain(N(s... |
self.assertRaises(TypeError, list, cycle(N(s))) | self.assertRaises(TypeError, cycle, N(s)) | def test_cycle(self): for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): tgtlen = len(s) * 3 expected = list(g(s))*3 actual = list(islice(cycle(g(s)), tgtlen)) self.assertEqual(actual, expected) self.assertRaises(TypeError, cycle, X(s)) self.assertRaises(TypeError, list, ... |
self.assertRaises(TypeError, list, groupby(N(s))) | self.assertRaises(TypeError, groupby, N(s)) | def test_groupby(self): for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): self.assertEqual([k for k, sb in groupby(g(s))], list(g(s))) self.assertRaises(TypeError, groupby, X(s)) self.assertRaises(TypeError, list, groupby(N(s))) self.assertRaises(ZeroDivisionError, ... |
self.assertRaises(TypeError, list, ifilter(isEven, N(s))) | self.assertRaises(TypeError, ifilter, isEven, N(s)) | def test_ifilter(self): for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): self.assertEqual(list(ifilter(isEven, g(s))), filter(isEven, g(s))) self.assertRaises(TypeError, ifilter, isEven, X(s)) self.assertRaises(TypeError, list, ifilter(isEven, N(s))) self.assertRai... |
self.assertRaises(TypeError, list, ifilterfalse(isEven, N(s))) | self.assertRaises(TypeError, ifilterfalse, isEven, N(s)) | def test_ifilterfalse(self): for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): self.assertEqual(list(ifilterfalse(isEven, g(s))), filter(isOdd, g(s))) self.assertRaises(TypeError, ifilterfalse, isEven, X(s)) self.assertRaises(TypeError, list, ifilterfalse(isEven, N(... |
self.assertRaises(TypeError, list, izip(N(s))) | self.assertRaises(TypeError, izip, N(s)) | def test_izip(self): for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): self.assertEqual(list(izip(g(s))), zip(g(s))) self.assertEqual(list(izip(g(s), g(s))), zip(g(s), g(s))) self.assertRaises(TypeError, izip, X(s)) self.assertRaises(TypeError, list, izip(N(s))) self.ass... |
self.assertRaises(TypeError, list, imap(onearg, N(s))) | self.assertRaises(TypeError, imap, onearg, N(s)) | def test_imap(self): for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)): for g in (G, I, Ig, S, L, R): self.assertEqual(list(imap(onearg, g(s))), map(onearg, g(s))) self.assertEqual(list(imap(operator.pow, g(s), g(s))), map(operator.pow, g(s), g(s))) self.assertRaises(TypeError, imap, onearg, X(s)) sel... |
self.assertRaises(TypeError, list, islice(N(s), 10)) | self.assertRaises(TypeError, islice, N(s), 10) | def test_islice(self): for s in ("12345", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): self.assertEqual(list(islice(g(s),1,None,2)), list(g(s))[1::2]) self.assertRaises(TypeError, islice, X(s), 10) self.assertRaises(TypeError, list, islice(N(s), 10)) self.assertRaises(ZeroDivisionEr... |
self.assertRaises(TypeError, list, starmap(operator.pow, N(ss))) | self.assertRaises(TypeError, starmap, operator.pow, N(ss)) | def test_starmap(self): for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)): for g in (G, I, Ig, S, L, R): ss = zip(s, s) self.assertEqual(list(starmap(operator.pow, g(ss))), map(operator.pow, g(s), g(s))) self.assertRaises(TypeError, starmap, operator.pow, X(ss)) self.assertRaises(TypeError, list, star... |
self.assertRaises(TypeError, list, takewhile(isEven, N(s))) | self.assertRaises(TypeError, takewhile, isEven, N(s)) | def test_takewhile(self): for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): tgt = [] for elem in g(s): if not isEven(elem): break tgt.append(elem) self.assertEqual(list(takewhile(isEven, g(s))), tgt) self.assertRaises(TypeError, takewhile, isEven, X(s)) self.assertR... |
self.assertRaises(TypeError, list, dropwhile(isOdd, N(s))) | self.assertRaises(TypeError, dropwhile, isOdd, N(s)) | def test_dropwhile(self): for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): tgt = [] for elem in g(s): if not tgt and isOdd(elem): continue tgt.append(elem) self.assertEqual(list(dropwhile(isOdd, g(s))), tgt) self.assertRaises(TypeError, dropwhile, isOdd, X(s)) self... |
self.assertRaises(TypeError, list, tee(N(s))[0]) | self.assertRaises(TypeError, tee, N(s)) | def test_tee(self): for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): it1, it2 = tee(g(s)) self.assertEqual(list(it1), list(g(s))) self.assertEqual(list(it2), list(g(s))) self.assertRaises(TypeError, tee, X(s)) self.assertRaises(TypeError, list, tee(N(s))[0]) self.assert... |
if proxy_auth: h.putheader('Proxy-Authorization: Basic %s' % proxy_auth) if auth: h.putheader('Authorization: Basic %s' % auth) | if proxy_auth: h.putheader('Proxy-Authorization', 'Basic %s' % proxy_auth) if auth: h.putheader('Authorization', 'Basic %s' % auth) | def open_https(self, url, data=None): """Use HTTPS protocol.""" import httplib user_passwd = None proxy_passwd = None if isinstance(url, str): host, selector = splithost(url) if host: user_passwd, host = splituser(host) host = unquote(host) realhost = host else: host, selector = url # here, we determine, whether the pr... |
s.bind(hostname, PORT) | s.bind((hostname, PORT)) | def missing_ok(str): try: getattr(socket, str) except AttributeError: pass |
s.connect(hostname, PORT) | s.connect((hostname, PORT)) | def missing_ok(str): try: getattr(socket, str) except AttributeError: pass |
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 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... |
self._name = 'PY_VAR' + `_varnum` | self._name = 'PY_VAR' + repr(_varnum) | def __init__(self, master=None, value=None, name=None): """Construct a variable |
def _interact(): """Make sure the application is in the foreground""" AE.AEInteractWithUser(50000000) | def _initialize(): global _initialized if _initialized: return macresource.need("DLOG", 260, "dialogs.rsrc", __name__) | |
return self | return iter(self.next, None) | def __iter__(self): return self |
self.checksyntax(filename) | def check_module_event(self, event): filename = self.getfilename() if not filename: return if not self.tabnanny(filename): return self.checksyntax(filename) | |
except IndentationError: pass | def tabnanny(self, filename): f = open(filename, 'r') try: tabnanny.process_tokens(tokenize.generate_tokens(f.readline)) except tokenize.TokenError, msg: msgtxt, (lineno, start) = msg self.editwin.gotoline(lineno) self.errorbox("Tabnanny Tokenizing Error", "Token Error: %s" % msgtxt) return False except tabnanny.NannyN... | |
if not self.tabnanny(filename): return | def run_module_event(self, event): """Run the module after setting up the environment. | |
self.packageRootFolder = root | self.sourceFolder = root | def build(self, root, resources=None, **options): """Create a package for some given root folder. |
self.packageResourceFolder = root | self.resourceFolder = root else: self.resourceFolder = resources | def build(self, root, resources=None, **options): """Create a package for some given root folder. |
elif not k in ["OutputDir"]: raise Error, "Unknown package option: %s" % k outputdir = options.get("OutputDir", os.getcwd()) packageName = self.packageInfo["Title"] self.PackageRootFolder = os.path.join(outputdir, packageName + ".pkg") | def build(self, root, resources=None, **options): """Create a package for some given root folder. | |
packageName = self.packageInfo["Title"] rootFolder = packageName + ".pkg" contFolder = join(rootFolder, "Contents") resourceFolder = join(contFolder, "Resources") os.mkdir(rootFolder) | contFolder = join(self.PackageRootFolder, "Contents") self.packageResourceFolder = join(contFolder, "Resources") os.mkdir(self.PackageRootFolder) | def _makeFolders(self): "Create package folder structure." |
os.mkdir(resourceFolder) self.resourceFolder = resourceFolder | os.mkdir(self.packageResourceFolder) | def _makeFolders(self): "Create package folder structure." |
base = basename(self.packageRootFolder) + ".info" path = join(self.resourceFolder, base) | base = self.packageInfo["Title"] + ".info" path = join(self.packageResourceFolder, base) | def _addInfo(self): "Write .info file containing installing options." |
base = basename(self.packageRootFolder) + ".bom" bomPath = join(self.resourceFolder, base) cmd = "mkbom %s %s" % (self.packageRootFolder, bomPath) | base = self.packageInfo["Title"] + ".bom" bomPath = join(self.packageResourceFolder, base) cmd = "mkbom %s %s" % (self.sourceFolder, bomPath) | def _addBom(self): "Write .bom file containing 'Bill of Materials'." |
packageRootFolder = self.packageRootFolder try: d = dirname(packageRootFolder) os.chdir(packageRootFolder) base = basename(packageRootFolder) + ".pax" archPath = join(d, self.resourceFolder, base) cmd = "pax -w -f %s %s" % (archPath, ".") res = os.system(cmd) cmd = "gzip %s" % archPath res = os.system(cmd) except: ... | os.chdir(self.sourceFolder) base = basename(self.packageInfo["Title"]) + ".pax" self.archPath = join(self.packageResourceFolder, base) cmd = "pax -w -f %s %s" % (self.archPath, ".") res = os.system(cmd) cmd = "gzip %s" % self.archPath res = os.system(cmd) | def _addArchive(self): "Write .pax.gz file, a compressed archive using pax/gzip." |
if not self.packageResourceFolder: | if not self.resourceFolder: | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
pattern = join(self.packageResourceFolder, pat) | pattern = join(self.resourceFolder, pat) | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
pattern = join(self.packageResourceFolder, packageName + pat) | pattern = join(self.resourceFolder, packageName + pat) | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
files.append(f) | files.append((f, f)) | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
files.append(f) | files.append((f, f)) elif f in ["pre-upgrade", "pre-install", "post-upgrade", "post-install"]: files.append((f, self.packageInfo["Title"]+"."+f)) | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
for g in files: f = join(self.packageResourceFolder, g) | for src, dst in files: f = join(self.resourceFolder, src) | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
shutil.copy(f, self.resourceFolder) | shutil.copy(f, os.path.join(self.packageResourceFolder, dst)) | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
d = join(self.resourceFolder, basename(f)) | d = join(self.packageResourceFolder, dst) | def _addResources(self): "Add Welcome/ReadMe/License files, .lproj folders and scripts." |
packageRootFolder = self.packageRootFolder files = GlobDirectoryWalker(packageRootFolder) | files = GlobDirectoryWalker(self.sourceFolder) | def _addSizes(self): "Write .sizes file with info about number and size of files." |
installedSize = installedSize + os.stat(f)[6] d = dirname(packageRootFolder) base = basename(packageRootFolder) + ".pax.gz" archPath = join(d, self.resourceFolder, base) | installedSize = installedSize + os.lstat(f)[6] | def _addSizes(self): "Write .sizes file with info about number and size of files." |
zippedSize = os.stat(archPath)[6] | zippedSize = os.stat(self.archPath+ ".gz")[6] | def _addSizes(self): "Write .sizes file with info about number and size of files." |
base = basename(packageRootFolder) + ".sizes" f = open(join(self.resourceFolder, base), "w") format = "NumFiles %d\nInstalledSize %d\nCompressedSize %d" | base = self.packageInfo["Title"] + ".sizes" f = open(join(self.packageResourceFolder, base), "w") format = "NumFiles %d\nInstalledSize %d\nCompressedSize %d\n" | def _addSizes(self): "Write .sizes file with info about number and size of files." |
self._read(length, self.fp.read) | return self._read(length, self.fp.read) | def read(self, length = None): self._read(length, self.fp.read) |
self._read(length, self.fp.readline) | return self._read(length, self.fp.readline) | def readline(self, length = None): self._read(length, self.fp.readline) |
def __init__(self, allow_none): | def __init__(self, allow_none, encoding): | def __init__(self, allow_none): self.funcs = {} self.instance = None self.allow_none = allow_none |
allow_none = self.allow_none) | allow_none=self.allow_none, encoding=self.encoding) | def _marshaled_dispatch(self, data, dispatch_method = None): """Dispatches an XML-RPC method from marshalled (XML) data. |
response = xmlrpclib.dumps(fault) | response = xmlrpclib.dumps(fault, allow_none=self.allow_none, encoding=self.encoding) | def _marshaled_dispatch(self, data, dispatch_method = None): """Dispatches an XML-RPC method from marshalled (XML) data. |
xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value)) | xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value)), encoding=self.encoding, allow_none=self.allow_none, | def _marshaled_dispatch(self, data, dispatch_method = None): """Dispatches an XML-RPC method from marshalled (XML) data. |
logRequests=True, allow_none=False): | logRequests=True, allow_none=False, encoding=None): | def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler, logRequests=True, allow_none=False): self.logRequests = logRequests |
SimpleXMLRPCDispatcher.__init__(self, allow_none) | SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) | def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler, logRequests=True, allow_none=False): self.logRequests = logRequests |
def __init__(self, allow_none=False): SimpleXMLRPCDispatcher.__init__(self, allow_none) | def __init__(self, allow_none=False, encoding=None): SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) | def __init__(self, allow_none=False): SimpleXMLRPCDispatcher.__init__(self, allow_none) |
n = int(s.rstrip(NUL) or "0", 8) | n = int(s.rstrip(NUL + " ") or "0", 8) | def nti(s): """Convert a number field to a python number. """ # There are two possible encodings for a number field, see # itn() below. if s[0] != chr(0200): n = int(s.rstrip(NUL) or "0", 8) else: n = 0L for i in xrange(len(s) - 1): n <<= 8 n += ord(s[i + 1]) return n |
def read(self, n = 0): if n <= 0: | def read(self, n = -1): if n < 0: | def read(self, n = 0): if n <= 0: newpos = len(self.buf) else: newpos = min(self.pos+n, len(self.buf)) r = self.buf[self.pos:newpos] self.pos = newpos return r |
"timeout (%g) is %g seconds more than expected (%g)" | "timeout (%g) is more than %g seconds more than expected (%g)" | def testConnectTimeout(self): # Test connect() timeout _timeout = 0.001 self.sock.settimeout(_timeout) |
print "<H3>Shell environment:</H3>" | print "<H3>Shell Environment:</H3>" | def print_environ(): """Dump the shell environment as HTML.""" keys = environ.keys() keys.sort() print print "<H3>Shell environment:</H3>" print "<DL>" for key in keys: print "<DT>", escape(key), "<DD>", escape(environ[key]) print "</DL>" print |
print "<H3>Form contents:</H3>" | print "<H3>Form Contents:</H3>" | def print_form(form): """Dump the contents of a form as HTML.""" keys = form.keys() keys.sort() print print "<H3>Form contents:</H3>" print "<DL>" for key in keys: print "<DT>" + escape(key) + ":", value = form[key] print "<i>" + escape(`type(value)`) + "</i>" print "<DD>" + escape(`value`) print "</DL>" print |
print "<H3>Command line Arguments:</H3>" | print "<H3>Command Line Arguments:</H3>" | def print_arguments(): print print "<H3>Command line Arguments:</H3>" print print sys.argv print |
sqstring = r"(\b[rR])?'([^'\\\n]|\\.)*'?" dqstring = r'(\b[rR])?"([^"\\\n]|\\.)*"?' sq3string = r"(\b[rR])?'''([^'\\]|\\.|'(?!''))*(''')?" dq3string = r'(\b[rR])?"""([^"\\]|\\.|"(?!""))*(""")?' | sqstring = r"(\b[rR])?'[^'\\\n]*(\\.[^'\\\n]*)*'?" dqstring = r'(\b[rR])?"[^"\\\n]*(\\.[^"\\\n]*)*"?' sq3string = r"(\b[rR])?'''[^'\\]*((\\.|'(?!''))[^'\\]*)*(''')?" dq3string = r'(\b[rR])?"""[^"\\]*((\\.|"(?!""))[^"\\]*)*(""")?' | def make_pat(): kw = r"\b" + any("KEYWORD", keyword.kwlist) + r"\b" comment = any("COMMENT", [r"#[^\n]*"]) sqstring = r"(\b[rR])?'([^'\\\n]|\\.)*'?" dqstring = r'(\b[rR])?"([^"\\\n]|\\.)*"?' sq3string = r"(\b[rR])?'''([^'\\]|\\.|'(?!''))*(''')?" dq3string = r'(\b[rR])?"""([^"\\]|\\.|"(?!""))*(""")?' string = any("STRIN... |
headers, 'file:'+pathname2url(file)) | headers, 'file:'+file) | def open_local_file(self, url): import mimetypes, mimetools, StringIO mtype = mimetypes.guess_type(url)[0] headers = mimetools.Message(StringIO.StringIO( 'Content-Type: %s\n' % (mtype or 'text/plain'))) host, file = splithost(url) if not host: return addinfourl(open(url2pathname(file), 'rb'), headers, 'file:'+pathname2... |
file = mod.get_file() self.assertEquals(file, os.path.join(TEMP_ZIP, os.sep.join(modules) + expected_ext)) | if expected_ext: file = mod.get_file() self.assertEquals(file, os.path.join(TEMP_ZIP, os.sep.join(modules) + expected_ext)) | def doTest(self, expected_ext, files, *modules): z = ZipFile(TEMP_ZIP, "w") try: for name, (mtime, data) in files.items(): zinfo = ZipInfo(name, time.localtime(mtime)) zinfo.compress_type = self.compression z.writestr(zinfo, data) z.close() sys.path.insert(0, TEMP_ZIP) |
>>> print a.__dict__ {'default': -1000, 'x2': 200, 'x1': 100} | >>> print sortdict(a.__dict__) {'default': -1000, 'x1': 100, 'x2': 200} | >>> def sorted(seq): |
for file in filenames: fp = open(file) self.__read(fp) | for filename in filenames: try: fp = open(filename) except IOError: continue self.__read(fp, filename) | def read(self, filenames): """Read and parse a list of filenames.""" if type(filenames) is type(''): filenames = [filenames] for file in filenames: fp = open(file) self.__read(fp) fp.close() |
def __read(self, fp): | def __read(self, fp, fpname): | def __read(self, fp): """Parse a sectioned setup file. |
raise MissingSectionHeaderError(fp.name, lineno, `line`) | raise MissingSectionHeaderError(fpname, lineno, `line`) | def __read(self, fp): """Parse a sectioned setup file. |
e = ParsingError(fp.name) | e = ParsingError(fpname) | def __read(self, fp): """Parse a sectioned setup file. |
genpluginproject("carbon", "_CF", sources=[":cf:_CFmodule.c", ":cf:pycfbridge.c"], outputdir="::Lib:Carbon") | genpluginproject("carbon", "_CF", sources=["_CFmodule.c", "pycfbridge.c"], outputdir="::Lib:Carbon") | def genpluginproject(architecture, module, project=None, projectdir=None, sources=[], sourcedirs=[], libraries=[], extradirs=[], extraexportsymbols=[], outputdir=":::Lib:lib-dynload", libraryflags=None, stdlibraryflags=None, prefixname=None, initialize=None): if CARBON_ONLY and architecture == "ppc": return if architec... |
def item_cget(self, col, opt): return self.tk.call(self._w, 'item', 'cget', col, opt) | def item_cget(self, entry, col, opt): return self.tk.call(self._w, 'item', 'cget', entry, col, opt) | def item_cget(self, col, opt): return self.tk.call(self._w, 'item', 'cget', col, opt) |
import linecache | def formatwarning(message, category, filename, lineno): """Function to format a warning the standard way.""" import linecache s = "%s:%s: %s: %s\n" % (filename, lineno, category.__name__, message) line = linecache.getline(filename, lineno).strip() if line: s = s + " " + line + "\n" return s | |
if sys.byteorder == 'little': fmt = ossaudiodev.AFMT_S16_LE else: fmt = ossaudiodev.AFMT_S16_BE | def play_sound_file(data, rate, ssize, nchannels): try: dsp = ossaudiodev.open('w') except IOError, msg: if msg[0] in (errno.EACCES, errno.ENODEV, errno.EBUSY): raise TestSkipped, msg raise TestFailed, msg # set the data format if sys.byteorder == 'little': fmt = ossaudiodev.AFMT_S16_LE else: fmt = ossaudiodev.AFMT_S1... | |
dsp.setparameters(fmt, nchannels, rate) | dsp.setparameters(AFMT_S16_NE, nchannels, rate) | def play_sound_file(data, rate, ssize, nchannels): try: dsp = ossaudiodev.open('w') except IOError, msg: if msg[0] in (errno.EACCES, errno.ENODEV, errno.EBUSY): raise TestSkipped, msg raise TestFailed, msg # set the data format if sys.byteorder == 'little': fmt = ossaudiodev.AFMT_S16_LE else: fmt = ossaudiodev.AFMT_S1... |
def_build = "%s setup.py build" % self.python | def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0])) def_build = "%s build" % def_setup_call | def _make_spec_file(self): """Generate the text of an RPM spec file and return it as a list of strings (one per line). """ # definitions and headers spec_file = [ '%define name ' + self.distribution.get_name(), '%define version ' + self.distribution.get_version().replace('-','_'), '%define release ' + self.release.repl... |
("%s setup.py install " | ("%s install " | def _make_spec_file(self): """Generate the text of an RPM spec file and return it as a list of strings (one per line). """ # definitions and headers spec_file = [ '%define name ' + self.distribution.get_name(), '%define version ' + self.distribution.get_version().replace('-','_'), '%define release ' + self.release.repl... |
"--record=INSTALLED_FILES") % self.python), | "--record=INSTALLED_FILES") % def_setup_call), | def _make_spec_file(self): """Generate the text of an RPM spec file and return it as a list of strings (one per line). """ # definitions and headers spec_file = [ '%define name ' + self.distribution.get_name(), '%define version ' + self.distribution.get_version().replace('-','_'), '%define release ' + self.release.repl... |
del names["__builtins__"] | if names.has_key("__builtins__"): del names["__builtins__"] | def check_all(modname): names = {} try: exec "import %s" % modname in names except ImportError: # silent fail here seems the best route since some modules # may not be available in all environments return verify(hasattr(sys.modules[modname], "__all__"), "%s has no __all__ attribute" % modname) names = {} exec "from %s ... |
([("Point", "indent", "OutMode")], [("Point_ptr", "indent", "InMode")]), | def makerepairinstructions(self): return [ ([('ListBounds_ptr', '*', 'InMode')], [('Rect_ptr', '*', 'InMode')]), | |
def sample(self, population, k, int=int): | def sample(self, population, k): | def sample(self, population, k, int=int): """Chooses k unique random elements from a population sequence. |
j = int(random() * (n-i)) | j = _int(random() * (n-i)) | def sample(self, population, k, int=int): """Chooses k unique random elements from a population sequence. |
j = int(random() * n) | j = _int(random() * n) | def sample(self, population, k, int=int): """Chooses k unique random elements from a population sequence. |
transform = element._as_temporarily_immutable except AttributeError: pass else: element = transform() return element in self._data | return element in self._data except TypeError: transform = getattr(element, "_as_temporary_immutable", None) if transform is None: raise return transform() in self._data | def __contains__(self, element): """Report whether an element is a member of a set. |
for elt in iterable: | for element in iterable: | def update(self, iterable): """Add all values from an iterable (such as a list or file).""" data = self._data value = True for elt in iterable: try: transform = elt._as_immutable except AttributeError: pass else: elt = transform() data[elt] = value |
transform = elt._as_immutable except AttributeError: pass else: elt = transform() data[elt] = value | data[element] = value except TypeError: transform = getattr(element, "_as_temporary_immutable", None) if transform is None: raise data[transform()] = value | def update(self, iterable): """Add all values from an iterable (such as a list or file).""" data = self._data value = True for elt in iterable: try: transform = elt._as_immutable except AttributeError: pass else: elt = transform() data[elt] = value |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.