rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
return map(None, [red] * numchips, seq, seq) | return map(None, seq, [green] * numchips, [blue] * numchips) | def constant_red_generator(numchips, rgbtuple): red = rgbtuple[0] seq = constant(numchips) return map(None, [red] * numchips, seq, seq) |
def constant_green_generator(numchips, rgbtuple): green = rgbtuple[1] | def constant_magenta_generator(numchips, rgbtuple): red, green, blue = rgbtuple | def constant_green_generator(numchips, rgbtuple): green = rgbtuple[1] seq = constant(numchips) return map(None, seq, [green] * numchips, seq) |
return map(None, seq, [green] * numchips, seq) | return map(None, [red] * numchips, seq, [blue] * numchips) | def constant_green_generator(numchips, rgbtuple): green = rgbtuple[1] seq = constant(numchips) return map(None, seq, [green] * numchips, seq) |
def constant_blue_generator(numchips, rgbtuple): blue = rgbtuple[2] | def constant_yellow_generator(numchips, rgbtuple): red, green, blue = rgbtuple | def constant_blue_generator(numchips, rgbtuple): blue = rgbtuple[2] seq = constant(numchips) return map(None, seq, seq, [blue] * numchips) |
return map(None, seq, seq, [blue] * numchips) | return map(None, [red] * numchips, [green] * numchips, seq) | def constant_blue_generator(numchips, rgbtuple): blue = rgbtuple[2] seq = constant(numchips) return map(None, seq, seq, [blue] * numchips) |
generator=constant_red_generator) | generator=constant_cyan_generator, axis=0) | def __init__(self, colordb, parent=None, **kw): |
generator=constant_blue_generator) | generator=constant_magenta_generator, axis=1) | def __init__(self, colordb, parent=None, **kw): |
generator=constant_green_generator) | generator=constant_yellow_generator, axis=2) | def __init__(self, colordb, parent=None, **kw): |
pat = re.compile(r'^\s*def\s') | pat = re.compile(r'^(\s*def\s)|(.*\slambda(:|\s))') | def findsource(object): """Return the entire source file and starting line number for an object. The argument may be a module, class, method, function, traceback, frame, or code object. The source code is returned as a list of all the lines in the file and the line number indexes a line in that list. An IOError is r... |
def __init__(self, screenName=None, baseName=None, className='Tk', useTk=1): | def __init__(self, screenName=None, baseName=None, className='Tk', useTk=1, sync=0, use=None): | def __init__(self, screenName=None, baseName=None, className='Tk', useTk=1): """Return a new Toplevel widget on screen SCREENNAME. A new Tcl interpreter will be created. BASENAME will be used for the identification of the profile file (see readprofile). It is constructed from sys.argv[0] without extensions if None is g... |
self.tk = _tkinter.create(screenName, baseName, className, interactive, wantobjects, useTk) | self.tk = _tkinter.create(screenName, baseName, className, interactive, wantobjects, useTk, sync, use) | def __init__(self, screenName=None, baseName=None, className='Tk', useTk=1): """Return a new Toplevel widget on screen SCREENNAME. A new Tcl interpreter will be created. BASENAME will be used for the identification of the profile file (see readprofile). It is constructed from sys.argv[0] without extensions if None is g... |
def opendbm(filename, mode, perm): return Dbm().init(filename, mode, perm) | def opendbm(filename, mode, perm): return Dbm().init(filename, mode, perm) | |
def init(self, filename, mode, perm): | def __init__(self, filename, mode, perm): | def init(self, filename, mode, perm): import dbm self.db = dbm.open(filename, mode, perm) return self |
return self | def init(self, filename, mode, perm): import dbm self.db = dbm.open(filename, mode, perm) return self | |
if s: t = t + ', ' | if s: t = ', ' + t | def __repr__(self): s = '' for key in self.keys(): t = `key` + ': ' + `self[key]` if s: t = t + ', ' s = s + t return '{' + s + '}' |
{'fill': 'red', 'tags': 'box'}) | {'fill': 'blue', 'tags': 'box'}) | def __init__(self, master=None, cnf={}): Canvas.__init__(self, master, {'width': 100, 'height': 100}) Canvas.config(self, cnf) self.create_rectangle(30, 30, 70, 70, {'fill': 'red', 'tags': 'box'}) Canvas.bind(self, 'box', '<Enter>', self.enter) Canvas.bind(self, 'box', '<Leave>', self.leave) |
_urandomfd = None | def _pickle_statvfs_result(sr): (type, args) = sr.__reduce__() return (_make_statvfs_result, args) | |
global _urandomfd if _urandomfd is None: try: _urandomfd = open("/dev/urandom", O_RDONLY) except: _urandomfd = NotImplementedError if _urandomfd is NotImplementedError: | try: _urandomfd = open("/dev/urandom", O_RDONLY) except: | def urandom(n): """urandom(n) -> str |
dist = self.distribution | metadata = self.distribution.metadata | def check_metadata (self): |
if not (hasattr (dist, attr) and getattr (dist, attr)): | if not (hasattr (metadata, attr) and getattr (metadata, attr)): | def check_metadata (self): |
if dist.author: if not dist.author_email: | if metadata.author: if not metadata.author_email: | def check_metadata (self): |
elif dist.maintainer: if not dist.maintainer_email: | elif metadata.maintainer: if not metadata.maintainer_email: | def check_metadata (self): |
ic.launcurl(url) | ic.launchurl(url) | def open(self, url, new=0): ic.launcurl(url) |
except RuntimeError: | except (RuntimeError, MacOS.Error): | def _mac_ver_lookup(selectors,default=None): from gestalt import gestalt l = [] append = l.append for selector in selectors: try: append(gestalt(selector)) except RuntimeError: append(default) return l |
unquote(password))) | unquote(password))).strip() | def proxy_open(self, req, proxy, type): orig_type = req.get_type() type, r_type = splittype(proxy) host, XXX = splithost(r_type) if '@' in host: user_pass, host = host.split('@', 1) if ':' in user_pass: user, password = user_pass.split(':', 1) user_pass = base64.encodestring('%s:%s' % (unquote(user), unquote(password))... |
return '<Coerce %s>' % self.arg | return '<CoerceNumber %s>' % repr(self.arg) | def __repr__(self): return '<Coerce %s>' % self.arg |
if isinstance(other, Coerce): | if isinstance(other, CoerceNumber): | def __coerce__(self, other): if isinstance(other, Coerce): return self.arg, other.arg else: return (self.arg, other) |
class Cmp: | class MethodNumber: | def __coerce__(self, other): if isinstance(other, Coerce): return self.arg, other.arg else: return (self.arg, other) |
return '<Cmp %s>' % self.arg | return '<MethodNumber %s>' % repr(self.arg) def __add__(self,other): return self.arg + other def __radd__(self,other): return other + self.arg def __sub__(self,other): return self.arg - other def __rsub__(self,other): return other - self.arg def __mul__(self,other): return self.arg * other def __rmul__(self,other... | def __repr__(self): return '<Cmp %s>' % self.arg |
class RCmp: def __init__(self,arg): self.arg = arg | def __cmp__(self, other): return cmp(self.arg, other) | |
def __repr__(self): return '<RCmp %s>' % self.arg | candidates = [ 2, 2.2, 2L, 2+4j, [1], (2,), None, MethodNumber(1), CoerceNumber(8)] | def __repr__(self): return '<RCmp %s>' % self.arg |
def __rcmp__(self, other): return cmp(other, self.arg) | infix_binops = [ '+', '-', '*', '/', '**', '%' ] prefix_binops = [ 'divmod' ] | def __rcmp__(self, other): return cmp(other, self.arg) |
candidates = [2, 2.2, 2L, 2+4j, [1], (2,), None, Empty(), Coerce(3), Cmp(4), RCmp(5)] def test(): | def do_infix_binops(): | def __rcmp__(self, other): return cmp(other, self.arg) |
self._file_.close() | if hasattr(self, "_file_"): self._file_.close() | def __del__(self): self._file_.close() |
print "Will rollover at %d, %d seconds from now" % (self.rolloverAt, self.rolloverAt - currentTime) | def __init__(self, filename, when='h', interval=1, backupCount=0): BaseRotatingHandler.__init__(self, filename, 'a') self.when = string.upper(when) self.backupCount = backupCount # Calculate the real rollover interval, which is just the number of # seconds between rollovers. Also set the filename suffix used when # a ... | |
print "No need to rollover: %d, %d" % (t, self.rolloverAt) | def shouldRollover(self, record): """ Determine if rollover should occur | |
print "%s -> %s" % (self.baseFilename, dfn) | def doRollover(self): """ do a rollover; in this case, a date/time stamp is appended to the filename when the rollover happens. However, you want the file to be named for the start of the interval, not the current time. If there is a backup count, then we have to get a list of matching filenames, sort them and remove... | |
if self._file: self.close() | self.close() | def __del__(self): if self._file: self.close() |
self._ensure_header_written(0) if self._datalength != self._datawritten: self._patchheader() self._file.flush() self._file = None | if self._file: self._ensure_header_written(0) if self._datalength != self._datawritten: self._patchheader() self._file.flush() self._file = None if self._i_opened_the_file: self._i_opened_the_file.close() self._i_opened_the_file = None | def close(self): self._ensure_header_written(0) if self._datalength != self._datawritten: self._patchheader() self._file.flush() self._file = None |
for i in range(100): | for i in range(60): | def test_nonrecursive_deep(self): a = [] for i in range(100): a = [a] b = self.loads(self.dumps(a)) self.assertEqual(a, b) |
self.assertEqual(pwd.getpwuid(e.pw_uid), e) | entriesbyuid.setdefault(e.pw_uid, []).append(e) for e in entries: self.assert_(pwd.getpwuid(e.pw_uid) in entriesbyuid[e.pw_uid]) | def test_values(self): entries = pwd.getpwall() |
ainv = _sqrt(2.0 * alpha - 1.0) return beta * self.stdgamma(alpha, ainv, alpha - LOG4, alpha + ainv) def stdgamma(self, alpha, ainv, bbb, ccc): | return beta * self.stdgamma(alpha) def stdgamma(self, alpha, *args): | def gammavariate(self, alpha, beta): # beta times standard gamma ainv = _sqrt(2.0 * alpha - 1.0) return beta * self.stdgamma(alpha, ainv, alpha - LOG4, alpha + ainv) |
return 1 | return self.robots[root].can_fetch(AGENTNAME, url) | def inroots(self, url): |
outf.write(" (os.path.normpath(sys.executable), post_interp)) | if not sysconfig.python_build: outf.write(" (os.path.normpath(sys.executable), post_interp)) else: outf.write(" (os.path.join( sysconfig.get_config_var("BINDIR"), "python" + sysconfig.get_config_var("EXE")), post_interp)) | def copy_scripts (self): """Copy each script listed in 'self.scripts'; if it's marked as a Python script in the Unix way (first line matches 'first_line_re', ie. starts with "\#!" and contains "python"), then adjust the first line to refer to the current Python interpreter as we copy. """ self.mkpath(self.build_dir) fo... |
ssl_incs = find_file('openssl/ssl.h', inc_dirs, | ssl_incs = find_file('openssl/ssl.h', self.compiler.include_dirs, | 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') |
f = file(fullname, "rU") | f = open(fullname, "rU") | def addpackage(sitedir, name, known_paths): """Add a new path to known_paths by combining sitedir and 'name' or execute sitedir if it starts with 'import'""" if known_paths is None: _init_pathinfo() reset = 1 else: reset = 0 fullname = os.path.join(sitedir, name) try: f = file(fullname, "rU") except IOError: return try... |
d = _init_pathinfo() | known_paths = _init_pathinfo() | def addsitedir(sitedir, known_paths=None): """Add 'sitedir' argument to sys.path if missing and handle .pth files in 'sitedir'""" if known_paths is None: d = _init_pathinfo() reset = 1 else: reset = 0 sitedir, sitedircase = makepath(sitedir) if not sitedircase in known_paths: sys.path.append(sitedir) # Add path ... |
if name[-4:] == os.extsep + "pth": | if name.endswith(os.extsep + "pth"): | def addsitedir(sitedir, known_paths=None): """Add 'sitedir' argument to sys.path if missing and handle .pth files in 'sitedir'""" if known_paths is None: d = _init_pathinfo() reset = 1 else: reset = 0 sitedir, sitedircase = makepath(sitedir) if not sitedircase in known_paths: sys.path.append(sitedir) # Add path ... |
objects = self.object_filenames(sources, 0, outdir) | objects = self.object_filenames(sources, strip_dir=python_build, output_dir=outdir) | def _setup_compile(self, outdir, macros, incdirs, sources, depends, extra): """Process arguments and decide which source files to compile. |
objects = self.object_filenames(sources, strip_dir=0, | objects = self.object_filenames(sources, strip_dir=python_build, | def _prep_compile(self, sources, output_dir, depends=None): """Decide which souce files must be recompiled. |
if not line: | if not line.strip(): | def precmd(self, line): """Handle alias expansion and ';;' separator.""" if not line: return line args = line.split() while args[0] in self.aliases: line = self.aliases[args[0]] ii = 1 for tmpArg in args[1:]: line = line.replace("%" + str(ii), tmpArg) ii = ii + 1 line = line.replace("%*", ' '.join(args[1:])) args = lin... |
if (count > 0): | if count > 0: | def do_ignore(self,arg): """arg is bp number followed by ignore count.""" args = arg.split() bpnum = int(args[0].strip()) try: count = int(args[1].strip()) except: count = 0 bp = bdb.Breakpoint.bpbynumber[bpnum] if bp: bp.ignore = count if (count > 0): reply = 'Will ignore next ' if (count > 1): reply = reply + '%d cro... |
if (count > 1): | if count > 1: | def do_ignore(self,arg): """arg is bp number followed by ignore count.""" args = arg.split() bpnum = int(args[0].strip()) try: count = int(args[1].strip()) except: count = 0 bp = bdb.Breakpoint.bpbynumber[bpnum] if bp: bp.ignore = count if (count > 0): reply = 'Will ignore next ' if (count > 1): reply = reply + '%d cro... |
if auth: h.putheader('Authorization: Basic %s' % auth) | if auth: h.putheader('Authorization', 'Basic %s' % auth) | def open_http(self, url): import httplib if type(url) is type(""): host, selector = splithost(url) user_passwd, host = splituser(host) else: host, selector = url urltype, rest = splittype(selector) if string.lower(urltype) == 'http': realhost, rest = splithost(rest) user_passwd, realhost = splituser(realhost) if user_p... |
try: f = eval('self.repr_' + typename) except AttributeError: | if hasattr(self, 'repr_' + typename): return getattr(self, 'repr_' + typename)(x, level) else: | def repr1(self, x, level): typename = `type(x)`[7:-2] # "<type '......'>" if ' ' in typename: parts = string.split(typename) typename = string.joinfields(parts, '_') try: f = eval('self.repr_' + typename) except AttributeError: s = `x` if len(s) > self.maxother: i = max(0, (self.maxother-3)/2) j = max(0, self.maxother-... |
return f(x, level) | def repr1(self, x, level): typename = `type(x)`[7:-2] # "<type '......'>" if ' ' in typename: parts = string.split(typename) typename = string.joinfields(parts, '_') try: f = eval('self.repr_' + typename) except AttributeError: s = `x` if len(s) > self.maxother: i = max(0, (self.maxother-3)/2) j = max(0, self.maxother-... | |
if type(to_addrs) == types.StringType: | if isinstance(to_addrs, types.StringTypes): | def sendmail(self, from_addr, to_addrs, msg, mail_options=[], rcpt_options=[]): """This command performs an entire mail transaction. |
TypeError: iteration over non-sequence | TypeError: 'int' object is not iterable | >>> def f(n): |
version_req = '"1.1.4"' | version_req = '"1.1.3"' | 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') |
self.s_apply(self.r_exec, args) | return self.s_apply(self.r_exec, args) | def s_exec(self, *args): self.s_apply(self.r_exec, args) |
self.s_apply(self.r_eval, args) | return self.s_apply(self.r_eval, args) | def s_eval(self, *args): self.s_apply(self.r_eval, args) |
self.s_apply(self.r_execfile, args) | return self.s_apply(self.r_execfile, args) | def s_execfile(self, *args): self.s_apply(self.r_execfile, args) |
self.s_apply(self.r_import, args) | return self.s_apply(self.r_import, args) | def s_import(self, *args): self.s_apply(self.r_import, args) |
self.s_apply(self.r_reload, args) | return self.s_apply(self.r_reload, args) | def s_reload(self, *args): self.s_apply(self.r_reload, args) |
self.s_apply(self.r_unload, args) | return self.s_apply(self.r_unload, args) | def s_unload(self, *args): self.s_apply(self.r_unload, args) |
def __init__(self, encoding=None): | def __init__(self, encoding=None, allow_none=0): | def __init__(self, encoding=None): self.memo = {} self.data = None self.encoding = encoding |
self.allow_none = allow_none | def __init__(self, encoding=None): self.memo = {} self.data = None self.encoding = encoding | |
def dumps(params, methodname=None, methodresponse=None, encoding=None): | def dumps(params, methodname=None, methodresponse=None, encoding=None, allow_none=0): | def dumps(params, methodname=None, methodresponse=None, encoding=None): """data [,options] -> marshalled data Convert an argument tuple or a Fault instance to an XML-RPC request (or response, if the methodresponse option is used). In addition to the data object, the following options can be given as keyword arguments... |
m = Marshaller(encoding) | m = Marshaller(encoding, allow_none) | def dumps(params, methodname=None, methodresponse=None, encoding=None): """data [,options] -> marshalled data Convert an argument tuple or a Fault instance to an XML-RPC request (or response, if the methodresponse option is used). In addition to the data object, the following options can be given as keyword arguments... |
def __init__(self, uri, transport=None, encoding=None, verbose=0): | def __init__(self, uri, transport=None, encoding=None, verbose=0, allow_none=0): | def __init__(self, uri, transport=None, encoding=None, verbose=0): # establish a "logical" server connection |
self.__allow_none = allow_none | def __init__(self, uri, transport=None, encoding=None, verbose=0): # establish a "logical" server connection | |
request = dumps(params, methodname, encoding=self.__encoding) | request = dumps(params, methodname, encoding=self.__encoding, allow_none=self.__allow_none) | def __request(self, methodname, params): # call a method on the remote server |
log.info("changing mode of %s to %o", file, mode) | log.info("changing mode of %s", file) | def run (self): if not self.skip_build: self.run_command('build_scripts') self.outfiles = self.copy_tree(self.build_dir, self.install_dir) if os.name == 'posix': # Set the executable bits (owner, group, and world) on # all the scripts we just installed. for file in self.get_outputs(): if self.dry_run: log.info("changin... |
h.update(u''.join(data).encode('unicode-internal')) | h.update(u''.join(data).encode(encoding)) | def test_methods(): h = sha.sha() for i in range(65536): char = unichr(i) data = [ # Predicates (single char) char.isalnum() and u'1' or u'0', char.isalpha() and u'1' or u'0', char.isdecimal() and u'1' or u'0', char.isdigit() and u'1' or u'0', char.islower() and u'1' or u'0', char.isnumeric() and u'1' or u'0', char.i... |
def __init__(self, master=None, cnf={}, **kw): | def __init__(self, master=None, cnf=None, **kw): if cnf is None: cnf = {} | def __init__(self, master=None, cnf={}, **kw): if kw: cnf = _cnfmerge((cnf, kw)) fcnf = {} for k in cnf.keys(): if type(k) == ClassType or k == 'name': fcnf[k] = cnf[k] del cnf[k] self.frame = apply(Frame, (master,), fcnf) self.vbar = Scrollbar(self.frame, name='vbar') self.vbar.pack(side=RIGHT, fill=Y) cnf['name'] = '... |
tempcache = None | __tempfiles = [] | def urlcleanup(): if _urlopener: _urlopener.cleanup() |
if self.tempcache: | if self.__tempfiles: | def cleanup(self): if self.tempcache: import os for url in self.tempcache.keys(): try: os.unlink(self.tempcache[url][0]) except os.error: pass del self.tempcache[url] |
for url in self.tempcache.keys(): | for file in self.__tempfiles: | def cleanup(self): if self.tempcache: import os for url in self.tempcache.keys(): try: os.unlink(self.tempcache[url][0]) except os.error: pass del self.tempcache[url] |
os.unlink(self.tempcache[url][0]) | os.unlink(file) | def cleanup(self): if self.tempcache: import os for url in self.tempcache.keys(): try: os.unlink(self.tempcache[url][0]) except os.error: pass del self.tempcache[url] |
del self.tempcache[url] | URLopener.__tempfiles = [] self.tempcache = None | def cleanup(self): if self.tempcache: import os for url in self.tempcache.keys(): try: os.unlink(self.tempcache[url][0]) except os.error: pass del self.tempcache[url] |
i = string.rfind(basepath, '/') | i = string.rfind(basepath[:-1], '/') | def basejoin(base, url): type, path = splittype(url) if type: # if url is complete (i.e., it contains a type), return it return url host, path = splithost(path) type, basepath = splittype(base) # inherit type from base if host: # if url contains host, just inherit type if type: return type + '://' + host + path else: #... |
basepath = basepath[:i-1] | basepath = basepath[:i+1] elif i == 0: basepath = '/' break else: basepath = '' | def basejoin(base, url): type, path = splittype(url) if type: # if url is complete (i.e., it contains a type), return it return url host, path = splithost(path) type, basepath = splittype(base) # inherit type from base if host: # if url contains host, just inherit type if type: return type + '://' + host + path else: #... |
addr = socket.gethostbyname(socket.gethostname()) | addr = '127.0.0.1' try: addr = socket.gethostbyname(socket.gethostname()) except socket.gaierror: pass | def __init__(self, host = '', port = 0, local_hostname = None): """Initialize a new instance. |
if code in self.BUGGY_RANGE_CHECK: | if not PY_STRUCT_RANGE_CHECKING and code in self.BUGGY_RANGE_CHECK: | def test_one(self, x, pack=struct.pack, unpack=struct.unpack, unhexlify=binascii.unhexlify): if verbose: print "trying std", self.formatpair, "on", x, "==", hex(x) |
if 0: | if PY_STRUCT_RANGE_CHECKING: | def test_1229380(): for endian in ('', '>', '<'): for cls in (int, long): for fmt in ('B', 'H', 'I', 'L'): any_err(struct.pack, endian + fmt, cls(-1)) any_err(struct.pack, endian + 'B', cls(300)) any_err(struct.pack, endian + 'H', cls(70000)) any_err(struct.pack, endian + 'I', sys.maxint * 4L) any_err(struct.pack, en... |
locale.getlocale(locale.LC_TIME), | locale.getlocale(locale.LC_TIME)[0], | def test_lang(self): # Make sure lang is set self.failUnless(self.LT_ins.lang in (locale.getdefaultlocale()[0], locale.getlocale(locale.LC_TIME), ''), "Setting of lang failed") |
if mname in self.modules: return self.modules[mname] self.modules[mname] = m = self.hooks.new_module(mname) | m = self.modules.get(mname) if m is None: self.modules[mname] = m = self.hooks.new_module(mname) | def add_module(self, mname): if mname in self.modules: return self.modules[mname] self.modules[mname] = m = self.hooks.new_module(mname) m.__builtins__ = self.modules['__builtin__'] return m |
code.interact( "*** RESTRICTED *** Python %s on %s\n" 'Type "help", "copyright", "credits" or "license" ' "for more information." % (sys.version, sys.platform), local=r.modules['__main__'].__dict__) | RestrictedConsole(r.modules['__main__'].__dict__).interact() | def test(): import getopt, traceback opts, args = getopt.getopt(sys.argv[1:], 'vt:') verbose = 0 trusted = [] for o, a in opts: if o == '-v': verbose = verbose+1 if o == '-t': trusted.append(a) r = RExec(verbose=verbose) if trusted: r.ok_builtin_modules = r.ok_builtin_modules + tuple(trusted) if args: r.modules['sys'].... |
mod = __import__(modname, globals(), locals(), _import_tail) | mod = __import__('encodings.' + modname, globals(), locals(), _import_tail) | def search_function(encoding): # Cache lookup entry = _cache.get(encoding, _unknown) if entry is not _unknown: return entry # Import the module: # # First look in the encodings package, then try to lookup the # encoding in the aliases mapping and retry the import using the # default import module lookup scheme with t... |
if type(commandlist) == type(()) and len(commandlist[0]) > 1: | if type(commandlist[0]) == type(()) and len(commandlist[0]) > 1: | def GetArgv(optionlist=None, commandlist=None, addoldfile=1, addnewfile=1, addfolder=1, id=ARGV_ID): d = GetNewDialog(id, -1) if not d: print "Can't get DLOG resource with id =", id return |
if type(optionlist) == type(()): option = optionlist[idx][0] else: option = optionlist[idx] | option = optionlist[idx] if type(option) == type(()): option = option[0] | def GetArgv(optionlist=None, commandlist=None, addoldfile=1, addnewfile=1, addfolder=1, id=ARGV_ID): d = GetNewDialog(id, -1) if not d: print "Can't get DLOG resource with id =", id return |
if 0 <= idx < len(commandlist) and type(commandlist) == type(()) and \ | if 0 <= idx < len(commandlist) and type(commandlist[idx]) == type(()) and \ | def GetArgv(optionlist=None, commandlist=None, addoldfile=1, addnewfile=1, addfolder=1, id=ARGV_ID): d = GetNewDialog(id, -1) if not d: print "Can't get DLOG resource with id =", id return |
if type(commandlist) == type(()): stringstoadd = [commandlist[idx][0]] else: stringstoadd = [commandlist[idx]] | command = commandlist[idx] if type(command) == type(()): command = command[0] stringstoadd = [command] | def GetArgv(optionlist=None, commandlist=None, addoldfile=1, addnewfile=1, addfolder=1, id=ARGV_ID): d = GetNewDialog(id, -1) if not d: print "Can't get DLOG resource with id =", id return |
genpluginproject("ppc", "_AE", libraries=["ObjectSupportLib"], outputdir="::Lib:Carbon") | genpluginproject("ppc", "_AE", libraries=["ObjectSupportLib"], stdlibraryflags="Debug, WeakImport", 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): if architecture == "all": # For the time being we generate two project files.... |
genpluginproject("ppc", "_Cm", libraries=["QuickTimeLib"], outputdir="::Lib:Carbon") | genpluginproject("ppc", "_Cm", libraries=["QuickTimeLib"], stdlibraryflags="Debug, WeakImport", 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): if architecture == "all": # For the time being we generate two project files.... |
genpluginproject("ppc", "_Drag", libraries=["DragLib"], outputdir="::Lib:Carbon") genpluginproject("all", "_Evt", outputdir="::Lib:Carbon") genpluginproject("all", "_Fm", outputdir="::Lib:Carbon") | genpluginproject("ppc", "_Drag", libraries=["DragLib"], libraryflags="Debug, WeakImport", outputdir="::Lib:Carbon") genpluginproject("all", "_Evt", stdlibraryflags="Debug, WeakImport", outputdir="::Lib:Carbon") genpluginproject("all", "_Fm", stdlibraryflags="Debug, WeakImport", 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): if architecture == "all": # For the time being we generate two project files.... |
genpluginproject("ppc", "_Icn", libraries=["IconServicesLib"], outputdir="::Lib:Carbon") | genpluginproject("ppc", "_Icn", libraries=["IconServicesLib"], libraryflags="Debug, WeakImport", 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): if architecture == "all": # For the time being we generate two project files.... |
genpluginproject("all", "_Qd", outputdir="::Lib:Carbon") genpluginproject("ppc", "_Qt", libraries=["QuickTimeLib"], outputdir="::Lib:Carbon") genpluginproject("carbon", "_Qt", outputdir="::Lib:Carbon") genpluginproject("all", "_Qdoffs", outputdir="::Lib:Carbon") | genpluginproject("all", "_Qd", stdlibraryflags="Debug, WeakImport", outputdir="::Lib:Carbon") genpluginproject("ppc", "_Qt", libraries=["QuickTimeLib"], libraryflags="Debug, WeakImport", outputdir="::Lib:Carbon") genpluginproject("carbon", "_Qt", libraryflags="Debug, WeakImport", outputdir="::Lib:Carbon") genpluginp... | def genpluginproject(architecture, module, project=None, projectdir=None, sources=[], sourcedirs=[], libraries=[], extradirs=[], extraexportsymbols=[], outputdir=":::Lib:lib-dynload", libraryflags=None, stdlibraryflags=None, prefixname=None): if architecture == "all": # For the time being we generate two project files.... |
genpluginproject("ppc", "_TE", libraries=["CarbonAccessors.o", "DragLib"], outputdir="::Lib:Carbon") | genpluginproject("ppc", "_TE", libraries=["CarbonAccessors.o", "DragLib"], stdlibraryflags="Debug, WeakImport", libraryflags="Debug, WeakImport", 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): if architecture == "all": # For the time being we generate two project files.... |
genpluginproject("ppc", "_Mlte", libraries=["Textension"], outputdir="::Lib:Carbon") | genpluginproject("ppc", "_Mlte", libraries=["Textension"], libraryflags="Debug, WeakImport", 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): if architecture == "all": # For the time being we generate two project files.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.