rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
if argSet['debug'] == 1: | if argSet['debug'] is True: | def _processArgs(params, cfgMap, cfg, usage, argv=sys.argv, version=None, commonParams=None, useHelp=False, defaultGroup=None, interspersedArgs=True, hobbleShortOpts=False): argSet = {} # don't mangle the command line argv = argv[:] # historically, usage was generally a function to print out the usage # message. We w... |
if ';' in keywords['preMake']: log.error(TypeError, 'preMake argument cannot contain ;') | for i in (';', '&&', '||'): if i in keywords['preMake']: log.error('preMake argument cannot contain "%s"', i) | def __init__(self, recipe, *args, **keywords): """ @keyword forceFlags: boolean; if set, unconditionally override the C{Makefile} definitions of *FLAGS (that is, CFLAGS, CXXFLAGS, LDFLAGS) @keyword makeName: The name of the make command; normally C{make} but occasionally 'qmake' or something else. @keyword preMake: str... |
C{class DocbookDtds(BuidlPackageRecipe):} | C{class DocbookDtds(BuildPackageRecipe):} | def __init__(self, cfg, laReposCache, srcdirs, extraMacros={}, crossCompile=None, lightInstance=False): Recipe.__init__(self) |
(fileId, path, version) = line.split() | fields = line.split() fileId = fields.pop(0) version = fields.pop(-1) path = " ".join(fields) | def read(self, dataFile): |
(fileId, path, version) = line[1:].split() | fields = line[1:].split() fileId = fields.pop(0) version = fields.pop(-1) path = " ".join(fields) | def parse(self, line): |
if not newFlavor or newFlavor in used: | if newFlavor in used: | def diff(self, them, absolute = 0): |
ldso = file(util.joinPaths(self.root, '/etc/ld.so.conf'), 'w+') ldsolines = ldso.readlines() | ldsopath = util.joinPaths(self.root, '/etc/ld.so.conf') try: ldso = file(ldsopath, 'r+') ldsolines = ldso.readlines() ldso.close() except: ldsolines = [] | def apply(self): |
ldso.seek(0) | ldso = file(ldsopath, 'w+') | def apply(self): |
raise repository.netrepos.netserver.AlreadySignedError(exceptionArgs[0]) | raise AlreadySignedError(exceptionArgs[0]) | def handleError(self, result): |
@strFields(char = 'A') | @strFields(char = '') | def main(self, auth): self._write("main_page") return apache.OK |
packages = [] components = {} | def browse(self, auth, char): troves = self.repos.getAllTroveLeaves(self.serverName, {None: [None]}) # keep a running total of each letter we see so that the display # code can skip letters that have no troves totals = dict.fromkeys(list(string.digits) + list(string.uppercase), 0) if char in string.digits: char = '0' f... | |
totals[trove[0].upper()] += 1 | def browse(self, auth, char): troves = self.repos.getAllTroveLeaves(self.serverName, {None: [None]}) # keep a running total of each letter we see so that the display # code can skip letters that have no troves totals = dict.fromkeys(list(string.digits) + list(string.uppercase), 0) if char in string.digits: char = '0' f... | |
other = other.freeze() if first < second: return -1 elif first == second: return 0 return 1 | second = other.freeze() return cmp(first, second) | def __cmp__(self, other): first = self.name() second = other.name() |
self.c[serverName].prepareChangeSet() | url = self.c[serverName].prepareChangeSet() | def _commit(self, chgSet, fName, callback = None, mirror = False): |
version provided. If any errors are occured, PackageNotFound is raised with an appropriate error message. Multiple matches could be found if versionStr refers to a label. | version provided. If any errors occur, PackageNotFound is raised with an appropriate error message. Multiple matches could be found if versionStr refers to a label. | def findTrove(self, defaultLabel, name, flavor, versionStr = None): |
log.debug(cmd) | log.info(cmd) | def execute(cmd, destDir=None, verbose=True): if verbose: log.debug(cmd) if destDir: rc = os.system('cd %s; %s' %(destDir, cmd)) else: rc = os.system(cmd) _handle_rc(rc, cmd) |
def addAction(self, action, targetdir='', use=None): self._appendSource('', '', 'action', targetdir, use, (action)) | def addSourceFromRPM(self, rpm, filename, **keywords): self._extractFromRPM(rpm, filename) self.addSource(filename, **keywords) | |
log.debug('%s=%s[%s]\n REQ: %s=%s[%s]\n SOLVES: %s' % (troveTup + choice + ('\n\t'.join(str(depSet).split('\n')),))) | log.debug('%s=%s[%s]\n' ' Requires: %s: %s\n' ' Provided by: %s=%s[%s]', *(troveTup + (depClass.tagName, dep) + choice)) | def filterSuggestions(self, depList, sugg, suggMap): """ Given a list of several suggestions for one dependency, pick the dep that matches the best. """ troves = set() |
util.execute('gunzip %s; gzip -n -9 %s', syspath, syspath[:-3]) | util.execute('gunzip %s; gzip -n -9 %s' %(syspath, syspath[:-3]) | def do(self): |
util.execute('bunzip2 %s; gzip -n -9 %s', syspath, syspath[:-4]) | util.execute('bunzip2 %s; gzip -n -9 %s' %(syspath, syspath[:-4]) | def do(self): |
if oldTroveV: | if oldFileV: | def _cvtFileList(l): new = [] for (pathId, troveName, (oldTroveV, oldTroveF, oldFileId, oldFileV), (newTroveV, newTroveF, newFileId, newFileV)) in l: if oldTroveV: oldTroveV = self.fromVersion(oldTroveV) oldFileV = self.fromVersion(oldFileV) oldFileId = self.fromFileId(oldFileId) oldTroveF = self.fromFlavor(oldTroveF) ... |
log.warning('odd permission %o, correcting to %o: add initial "0"?' \ %(mode, _permmap[mode])) | log.warning('odd permission %o for path %s, correcting to 0%o:' ' add initial "0"?', mode, destPath, _permmap[mode]) | def chmod(self, destdir, path, mode=None): isDestFile = path.startswith(destdir) |
destPath = path[len(destdir):] | def chmod(self, destdir, path, mode=None): isDestFile = path.startswith(destdir) | |
def addPatch(self, file, level='1', backup='', keyid=None, use=None): self._appendSource(file, keyid, 'patch', '', use, (level, backup)) | def addPatch(self, file, level='1', backup='', extractDir='', keyid=None, use=None): self._appendSource(file, keyid, 'patch', extractDir, use, (level, backup)) | def addPatch(self, file, level='1', backup='', keyid=None, use=None): |
util.execute('%s %s | patch -d %s -p%s %s' %(provides, f, destDir, level, backup)) | cd = '' if targetdir: cd = 'cd %s;' %targetdir util.execute('%s %s %s | patch -d %s -p%s %s' %(cd, provides, f, destDir, level, backup)) | def unpackSources(self, builddir): |
def __init__(self, recipe, *args, **keywords): BuildCommand.__init__(self, recipe, *args, **keywords) for req in ['autoconf:runtime', 'automake:runtime']: if not [ x for x in recipe.buildRequires if x.startswith(req) ]: recipe.buildRequires.append(req) | def do(self, macros): | |
cu = self.db.cursor() try: cu.execute("INSERT INTO UserGroups VALUES (NULL, ?)", user) | cu = self.db.cursor() try: cu.execute("""INSERT INTO UserGroups SELECT MAX(MAX(u.userId), MAX(g.userGroupId))+1, ? FROM Users u, UserGroups g""", user) | def addUserByMD5(self, user, salt, password): |
self.configLine('installFlavor %s' % contents, filePath, 1) | self.configLine('sense %s' % contents, filePath, 1) | def __init__(self, name, path): |
def __str__(self): return "%x%x%x%x%x" % struct.unpack("!5I", self.s) | def freeze(self): return struct.pack("!5I", int(self.s[ 0: 8], 16), int(self.s[ 8:16], 16), int(self.s[16:24], 16), int(self.s[24:32], 16), int(self.s[32:40], 16)) def thaw(self, data): if data: self.s = "%08x%08x%08x%08x%08x" % struct.unpack("!5I", data) | def __init__(self, s = ''): |
UPDATE DBTroveFiles SET isPresent = 0 WHERE instanceId IN | UPDATE DBTroveFiles SET isPresent = 0 WHERE _rowid_ IN | def checkPathConflicts(self, instanceIdList, filePriorityPath, replaceFiles): cu = self.db.cursor() cu.execute("CREATE TEMPORARY TABLE NewInstances (instanceId integer)") for instanceId in instanceIdList: cu.execute("INSERT INTO NewInstances (instanceId) VALUES (?)", instanceId) |
SELECT ExistingFiles.instanceId FROM NewInstances | SELECT ExistingFiles._rowid_ FROM NewInstances | def checkPathConflicts(self, instanceIdList, filePriorityPath, replaceFiles): cu = self.db.cursor() cu.execute("CREATE TEMPORARY TABLE NewInstances (instanceId integer)") for instanceId in instanceIdList: cu.execute("INSERT INTO NewInstances (instanceId) VALUES (?)", instanceId) |
callback.creatingDatabaseTransaction(i + 1, len(newList)) | callback.creatingDatabaseTransaction(i, len(newList)) | def __init__(self, repos, cs, fileHostFilter = [], callback = None, resetTimestamps = False, keyCache = None, threshold = 0, allowIncomplete = False): |
return self.db.nameList | return self.db.findByNames(nameList) | def findByNames(self, nameList): return self.db.nameList |
self.file = file | def read(self, file): | |
self.configLine(line) | self.configLine(line, file) | def read(self, file): |
def configLine(self, line): | def configLine(self, line, file = "override"): | def configLine(self, line): |
versionStr = self.map[name][1] if not versionStr: return ("%s was not on found on path %s" \ % (name, ', '.join(x.asString() for x in self.labelPath))) elif self.labelPath: return ("version %s of %s was not on found on path %s" \ % (versionStr, name, ', '.join(x.asString() for x in labelPath))) else: return "version %s... | raise NotImplementedError | def missingMsg(self, name): versionStr = self.map[name][1] if not versionStr: return ("%s was not on found on path %s" \ % (name, ', '.join(x.asString() for x in self.labelPath))) elif self.labelPath: return ("version %s of %s was not on found on path %s" \ % (versionStr, name, ', '.join(x.asString() for x in labelPath... |
return "version %s of %s was not on found" % (versionStr, name) | return "version %s of %s was not found" % (versionStr, name) | def missingMsg(self, name): versionStr = self.map[name][1] return "version %s of %s was not on found" % (versionStr, name) |
except versions.ParseError, e: | except versions.ParseError: | def filterTroveMatches(self, name, versionFlavorDict): versionStr = self.map[name][1] try: verRel = versions.Revision(versionStr) except versions.ParseError, e: verRel = None |
except versions.ParseError, e: | except versions.ParseError: | def filterTroveMatches(self, name, versionFlavorDict): """ Take the results found in QueryByLabelPath.findAll for name and filter them based on if they match the given revision for name. Return a versionFlavorDict """ |
verRel = versions.Revision(versionStr) | versions.Revision(versionStr) | def _getVersionType(self, troveTup): """ Return a string that describes this troveTup's versionStr The string returned corresponds to a function name for sorting on that versionStr type. """ name = troveTup[0] versionStr = troveTup[1] if not versionStr: return VERSION_STR_NONE firstChar = versionStr[0] if firstChar == ... |
self.remaining.append(tup) | self.remaining.append(troveTup) | def sortFullVersion(self, troveTup, affinityTroves): name, versionStr, flavor = troveTup if self.query[QUERY_BY_VERSION].hasName(name): self.remaining.append(tup) return version = versions.VersionFromString(versionStr) if flavor is None and affinityTroves: self.query[QUERY_BY_VERSION].addQueryWithAffinity(troveTup, ver... |
"invalid version %s" % versionStr | "invalid version %s" % troveTup[1] | def sortLabel(self, troveTup, affinityTroves): try: label = versions.Label(troveTup[1]) newLabelPath = [ label ] except versions.ParseError: raise repository.TroveNotFound, \ "invalid version %s" % versionStr return self._sortLabel(newLabelPath, troveTup, affinityTroves) |
assert(r.status == 200) | if r.status == 403: raise repository.CommitError('Permission denied. Check username, ' 'password, and https settings.') if r.status != 200: raise repository.CommitError('Error uploading to repository: ' '%s (%s)' %(r.status, r.reason)) | def _putFile(self, url, path, callbackFn=None): """ send a file to a url. Takes a callbackFn which is called with two parameters - bytes sent and total bytes """ protocol, uri = urllib.splittype(url) assert(protocol in ('http', 'https')) |
C{r.ComponentSpec([I{componentname}, I{filterexp}] || [I{packagename:componentname}, I{filterexp}])} | C{r.ComponentSpec([I{componentname}, I{filterexp}] || [I{packagename}:I{componentname}, I{filterexp}])} | def _markConfig(self, filename, fullpath): self.info(filename) f = file(fullpath) f.seek(0, 2) if f.tell(): # file has contents f.seek(-1, 2) lastchar = f.read(1) f.close() if lastchar != '\n': self.error("config file %s missing trailing newline" %filename) f.close() self.recipe.ComponentSpec(_config=filename) |
main = '' | def doProcess(self, recipe): | |
if ':' in name: main, name = name.split(':') | def doProcess(self, recipe): | |
if main: recipe.PackageSpec(main, filteritem[1:]) | def doProcess(self, recipe): | |
lineno = 0 | lineno = self.curframe.f_lineno | def do_list(self, arg): rel = re.compile(r'^[-+] *[0-9]* *$') if arg and arg == '.': self.lineno = None pdb.Pdb.do_list(self, '') return if rel.match(arg): if arg == '-': reldist = -7 else: reldist = int(arg) if self.lineno is None: lineno = 0 else: lineno = self.lineno lineno += reldist - 5 pdb.Pdb.do_list(self, str(l... |
troves += [ (x, None) for x in repos.troveNames(label) ] | troves += [ (x, None, None) for x in repos.troveNames(label) ] | def displayTroves(repos, cfg, troveList = [], all = False, ls = False, ids = False, sha1s = False, leaves = False, fullVersions = False, info = False, tags = False, deps = False): hasVersions = False if troveList: (troves, hasVersions, hasFlavors) = \ display.parseTroveStrings(troveList, cfg.flavor) else: # this retur... |
if repositries[host].has_key(name): | if repositories[host].has_key(name): | def displayTroves(repos, cfg, troveList = [], all = False, ls = False, ids = False, sha1s = False, leaves = False, fullVersions = False, info = False, tags = False, deps = False): hasVersions = False if troveList: (troves, hasVersions, hasFlavors) = \ display.parseTroveStrings(troveList, cfg.flavor) else: # this retur... |
self.cu.execute("INSERT INTO %s VALUES(NULL)" % self.seqName) | self.cu.execute("INSERT INTO %s (val) VALUES(NULL)" % self.seqName) | def nextval(self): # We have to make sure we do this in a transaction if not self.db.dbh.inTransaction: self.db.transaction() self.cu.execute("DELETE FROM %s" % self.seqName) self.cu.execute("INSERT INTO %s VALUES(NULL)" % self.seqName) self.cu.execute("SELECT val FROM %s" % self.seqName) self.__currval = self.cu.fetch... |
def __str__(self): return "UnknownException: %s %s" % (self.eName, self.eArgs) | def __str__(self): | |
def __str__(self): return "UserNotFound: %s" % self.user | RepositoryError.__init__(self, "UserNotFound: %s" % self.user) | def __init__(self, user = "user"): self.user = user |
def __init__(self, val): Exception.__init__(self) self.val = val | pass | def __init__(self, val): Exception.__init__(self) self.val = val |
def __init__(self, val): GetFileContentsError.__init__(self, val) | def __init__(self, (fileId, fileVer)): self.fileId = fileId self.fileVer = fileVer GetFileContentsError.__init__(self, '''\ File Contents Not Found The following file was not found on the server: fileId: %r fileVersion: %s ''' % (fileId, fileVer)) | def __init__(self, val): GetFileContentsError.__init__(self, val) |
def __init__(self, val): GetFileContentsError.__init__(self, val) | pass | def __init__(self, val): GetFileContentsError.__init__(self, val) |
def __str__(self): return self.error | def __str__(self): return self.error | |
self.error=error | RepositoryError.__init__(self, error) self.error = error | def __init__(self, error = "Already signed"): self.error=error |
self.args = '''\ | RepositoryError.__init__(self, '''\ | def __init__(self, url, err): self.url = url self.err = err self.args = '''\ |
''' % (url, err) | ''' % (url, err)) | def __init__(self, url, err): self.url = url self.err = err self.args = '''\ |
logMe(3, revStr, flavorStr) | logMe(1, revStr, flavorStr) | def getConaryUrl(self, authtoken, clientVersion, \ revStr, flavorStr): """ Returns a url to a downloadable changeset for the conary client that is guaranteed to work with this server's version. """ # adjust accordingly.... all urls returned are relative to this _baseUrl = "ftp://download.rpath.com/conary/" # Note: if t... |
JOIN LabelMap USING (itemid, branchId) | JOIN LabelMap ON Nodes.itemId = LabelMap.itemId AND Nodes.branchId = LabelMap.branchId | def _getTroveList(self, authToken, clientVersion, troveSpecs, versionType = _GTL_VERSION_TYPE_NONE, latestFilter = _GET_TROVE_ALL_VERSIONS, flavorFilter = _GET_TROVE_ALL_FLAVORS, withFlavors = False): self.log(3, versionType, latestFilter, flavorFilter) cu = self.db.cursor() singleVersionSpec = None dropTroveTable = Fa... |
packages[package][path].perms(mode) | packages[package][path].inode.setPerms(mode) | def doFile(self, path): |
callback.removeFiles(fileNum, len(paths)) | callback.removeFiles(fileNum + 1, len(paths)) | def restoreFile(fileObj, contents, root, target, journal): if fileObj.hasContents and contents and not \ fileObj.flags.isConfig(): # config file sha1's are verified when they get inserted # into the config file cache d = sha.new() fileObj.restore(contents, root, target, journal=journal, digest = d) assert(d.digest() ==... |
@intFields(writeperm = None, capped = None, admin = None) | @intFields(writeperm = None, capped = None, admin = None, remove = None) | def addPermForm(self, auth, userGroupName): groups = self.repServer.auth.getGroupList() labels = self.repServer.auth.getLabelList() troves = self.repServer.auth.getItemList() |
main = ''.join(x for x in main if self.legalCharsRE.match(x)) | def _markProvides(self, path, provision, pkg, m, f): if path not in pkg.providesMap: # BuildPackage only fills in providesMap for ELF files; we may # need to create a few more DependencySets. pkg.providesMap[path] = deps.DependencySet() | |
@param fromFiles: paths(s) to which symlink(s) will be created | @keyword fromFiles: paths(s) to which symlink(s) will be created | def __init__(self, *args, **keywords): """ Create a new InstallSymlinks instance |
@param toFile: path to create the symlink, or a directory in which | @keyword toFile: path to create the symlink, or a directory in which | def __init__(self, *args, **keywords): """ Create a new InstallSymlinks instance |
B{C{r.PythonSetup()}} - Moves files | B{C{r.PythonSetup()}} - Invokes setup.py to package Python code | def do(self, macros): |
path=dirname[len(policyObj.macros['destdir']):] | path=dirname[len(policyObj.macros['destdir'])-1:] | def _walkFile(policyObj, dirname, names): # chop off bit not useful for comparison path=dirname[len(policyObj.macros['destdir']):] for name in names: thispath = path + os.sep + name if _policyInclusion (policyObj, thispath) and \ not _policyException(policyObj, thispath): policyObj.doFile(thispath) |
thispath = path + os.sep + name | thispath = path + name | def _walkFile(policyObj, dirname, names): # chop off bit not useful for comparison path=dirname[len(policyObj.macros['destdir']):] for name in names: thispath = path + os.sep + name if _policyInclusion (policyObj, thispath) and \ not _policyException(policyObj, thispath): policyObj.doFile(thispath) |
re-gzip .gz files with -9 -n | re-gzip .gz files with -9 -n to get maximum compression and avoid meaningless changes overpopulating the database. | def do(self): |
other things | up other things | def do(self): |
def do(self): pass | def _uncompress(self, dirname, names): for name in names: path = dirname + os.sep + name if name.endswith('.gz') and not os.path.islink(path): util.execute('gunzip ' + dirname + os.sep + name) def _compress(self, dirname, names): for name in names: path = dirname + os.sep + name if not os.path.isdir(path) and not os.p... | def do(self): |
return "%s (alias %s): %s" % (self._fullName(), self._name(), | return "%s (alias %s): %s" % (self._fullName(), self._alias, | def __str__(self): if self._alias: return "%s (alias %s): %s" % (self._fullName(), self._name(), self._value) else: return "%s: %s" % (self._fullName(), self._value) |
m = "error: " + msg | m = "error: %s" % msg | def error(msg, *args): "Log an error" m = "error: " + msg logger.error(m, *args) hdlr.error = True |
m = "warning: " + msg | m = "warning: %s" % msg | def warning(msg, *args): "Log a warning" m = "warning: " + msg logger.warning(m, *args) |
m = "+ " + msg | m = "+ %s" % msg | def info(msg, *args): "Log an informative message" m = "+ " + msg logger.info(m, *args) |
m = "+ " + msg | m = "+ %s" % msg | def debug(msg, *args): "Log a debugging message" m = "+ " + msg logger.debug(m, *args) |
return hash((x.name(), x.version(), x.flavor())) | return hash((self.name(), self.version(), self.flavor())) | def __hash__(self): return hash((x.name(), x.version(), x.flavor())) |
elif (not info and resolve) and (not cfg.autoResolve or brokenByErase) and suggMap: | elif (not info and cfg.autoResolve) and (not cfg.autoResolve or brokenByErase) and suggMap: | def doUpdate(cfg, pkgList, replaceFiles = False, tagScript = None, keepExisting = False, depCheck = True, depsRecurse = True, test = False, justDatabase = False, recurse = True, info = False, updateByDefault = True, callback = None): if not callback: callback = callbacks.UpdateCallback() client = conaryclient.ConaryCl... |
if info: return | def doUpdate(cfg, pkgList, replaceFiles = False, tagScript = None, keepExisting = False, depCheck = True, depsRecurse = True, test = False, justDatabase = False, recurse = True, info = False, updateByDefault = True, callback = None): if not callback: callback = callbacks.UpdateCallback() client = conaryclient.ConaryCl... | |
version = self.versionTable.getId(versionId) | version = self.versionTable.getBareId(versionId) | def iterFilesInTrove(self, troveName, version, flavor, sortByPath = False, withFiles = False, |
cu.execute("INSERT INTO %s VALUES (?, ?, ?)" % (self.tableName,), (first, second, val)) | cu.execute("INSERT INTO %s (%s, %s, %s) " "VALUES (?, ?, ?)" % (self.tableName, self.tup1, self.tup2, self.item), (first, second, val)) | def __setitem__(self, key, val): |
cu.execute("INSERT INTO %s VALUES (?, ?)" % (self.tableName), | cu.execute("INSERT INTO %s (%s, %s) " "VALUES (?, ?)" % (self.tableName, self.key. self.item), | def __setitem__(self, key, val): cu = self.db.cursor() cu.execute("INSERT INTO %s VALUES (?, ?)" % (self.tableName), (key, val)) |
change = cs.getFileChange(pathId) | change = cs.getFileChange(None, fileId) | def displayChangeSet(db, repos, cs, troveList, cfg, ls = False, tags = False, info=False, fullVersions=False, showChanges=False, all=False, deps=False, sha1s=False, ids=False): (troves, hasVersions) = getTroves(cs, troveList) if all: ls = tags = fullVersions = info = deps = True if not (ls or tags or sha1s or ids): if... |
assert(not them or self.flavor == them.flavor) | def diff(self, them, absolute = 0): | |
removed[name][oldFlavor], oldFlavor)) | match, oldFlavor)) | def diff(self, them, absolute = 0): |
depformat('Old Flavor', self.flavor, f) | depformat('Old Flavor', self.oldFlavor, f) | def depformat(name, dep, f): f.write('\t%s: %s\n' %(name, str(dep).replace('\n', '\n\t%s' %(' '* (len(name)+2))))) |
depformat('New Flavor', self.flavor, f) | depformat('New Flavor', self.newFlavor, f) | def depformat(name, dep, f): f.write('\t%s: %s\n' %(name, str(dep).replace('\n', '\n\t%s' %(' '* (len(name)+2))))) |
if findOrdering: oldNewEdges, oldOldEdges, newNewEdges, newOldEdges = \ _createEdges(result, depList) for i, trvCs in enumerate(changeSet.iterNewTroveList()): for (name, changeList) in trvCs.iterChangedTroves(): for (changeType, version, flavor, byDef) in changeList: if changeType == '+': targetTrove = troveInf... | def _orderComponents(compGraph): | |
brokenByErase = set() | def _orderComponents(compGraph): | |
satisfied = set([0]) | brokenByErase = {} satisfied = { 0 : 0 } | def _orderComponents(compGraph): |
brokenByErase.add(depNum) | brokenByErase[depNum] = provNodeIdx | def _orderComponents(compGraph): |
satisfied.add(depNum) | satisfied[depNum] = provInstId | def _orderComponents(compGraph): |
if "source" in fields and fields["source"] == "freshmeat": | if "source" in fields and fields["source"].value == "freshmeat": | def _getMetadata(self, fields, troveName, branch): branch = self.repServer.thawVersion(branch) |
self.htmlWarning("No Freshmeat record found.") | self.kid_write("error", error = "No Freshmeat record found.") return | def _getMetadata(self, fields, troveName, branch): branch = self.repServer.thawVersion(branch) |
item = (name, newVersion, newFlavor) | def _processRedirects(self, jobSet, troveSource, recurse): # this returns redirectHack, which maps targets of redirections # to the sources of those redirections | |
for target in targets: | for subName, subVersion, subFlavor in targets: | def _processRedirects(self, jobSet, troveSource, recurse): # this returns redirectHack, which maps targets of redirections # to the sources of those redirections |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.