rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
self._remove(pkg, changeset, locked, pending, WEIGHT_NONE) | task = self._remove(pkg, changeset, locked, pending, WEIGHT_NONE) for res in task: pass | def run(self): |
self._pending(changeset, locked, pending, WEIGHT_NONE) | task = self._pending(changeset, locked, pending, WEIGHT_NONE) for res in task: pass | def run(self): |
self._upgrade(upgpkgs, changeset, locked, pending, WEIGHT_NONE) | task = self._upgrade(upgpkgs, changeset, locked, pending, WEIGHT_NONE) for res in task: pass | def run(self): |
self._fix(fixpkgs, changeset, locked, pending, WEIGHT_NONE) | task = self._fix(fixpkgs, changeset, locked, pending, WEIGHT_NONE) for res in task: pass | def run(self): |
_pending = [] self._install(upgpkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._install(upgpkg, cs, lk, None, depth) | def _updown(self, pkg, changeset, locked, depth=0): #print "[%03d] _updown(%s)" % (depth, pkg) #depth += 1 |
_pending = [] self._install(dwnpkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._install(dwnpkg, cs, lk, None, depth) | def _updown(self, pkg, changeset, locked, depth=0): #print "[%03d] _updown(%s)" % (depth, pkg) #depth += 1 |
_pending = [] | def _pending(self, changeset, locked, pending, depth=0): #print "[%03d] _pending()" % depth #depth += 1 | |
self._install(prvpkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._install(prvpkg, cs, lk, None, depth) | def _pending(self, changeset, locked, pending, depth=0): #print "[%03d] _pending()" % depth #depth += 1 |
_pending = [] self._remove(reqpkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._remove(reqpkg, cs, lk, None, depth) | def _pending(self, changeset, locked, pending, depth=0): #print "[%03d] _pending()" % depth #depth += 1 |
_pending = [] self._install(pkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._install(pkg, cs, lk, None, depth) | def _upgrade(self, pkgs, changeset, locked, pending, depth=0): #print "[%03d] _upgrade()" % depth #depth += 1 |
_pending = [] | def _upgrade(self, pkgs, changeset, locked, pending, depth=0): #print "[%03d] _upgrade()" % depth #depth += 1 | |
self._install(pkg, cs, lk, _pending, depth) | self._install(pkg, cs, lk, None, depth) | def _upgrade(self, pkgs, changeset, locked, pending, depth=0): #print "[%03d] _upgrade()" % depth #depth += 1 |
self._remove(pkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._remove(pkg, cs, lk, None, depth) | def _upgrade(self, pkgs, changeset, locked, pending, depth=0): #print "[%03d] _upgrade()" % depth #depth += 1 |
_pending = [] self._install(pkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._install(pkg, cs, lk, None, depth) | def _fix(self, pkgs, changeset, locked, pending, depth=0): #print "[%03d] _fix()" % depth #depth += 1 |
_pending = [] self._remove(pkg, cs, lk, _pending, depth) if _pending: self._pending(cs, lk, _pending, depth) | self._remove(pkg, cs, lk, None, depth) | def _fix(self, pkgs, changeset, locked, pending, depth=0): #print "[%03d] _fix()" % depth #depth += 1 |
__stateversion__ = Loader.__stateversion__+1 | __stateversion__ = Loader.__stateversion__+2 | def getGroup(self): return self._info.get("group", "") |
parsed = False | parsed = self._parsedflist | def loadFileProvides(self, fndict): bfp = self.buildFileProvides parsed = False for fn in fndict: if fn not in self._fileprovides: if not parsed: parsed = True self._fileprovides.clear() XMLFileListsParser(self).parse(fndict) if fn not in self._fileprovides: pkgs = self._fileprovides[fn] = () else: pkgs = self._filepro... |
parsed = True self._fileprovides.clear() | self._parsedflist = parsed = True | def loadFileProvides(self, fndict): bfp = self.buildFileProvides parsed = False for fn in fndict: if fn not in self._fileprovides: if not parsed: parsed = True self._fileprovides.clear() XMLFileListsParser(self).parse(fndict) if fn not in self._fileprovides: pkgs = self._fileprovides[fn] = () else: pkgs = self._filepro... |
output.end() | def main(ctrl, opts, reloadchannels=True): if reloadchannels: ctrl.reloadChannels() cache = ctrl.getCache() if not opts.args: packages = cache.getPackages()[:] else: packages = {} for arg in opts.args: ratio, results, suggestions = ctrl.search(arg, addprovides=False) if not results: if suggestions: dct = {} for r, ob... | |
self.__sys_stdout = sys.stdout | def startGrabOutput(self, output=None): if output or self.opts.output: self.output = output or open(self.opts.output, "w") sys.stdout = self.output self.__sys_stdout = sys.stdout else: self.output = sys.stdout self.__sys_stdout = None | |
def include(self, changeset, pkg, locked=None): | def _remove(self, subset, pkg, locked): | def include(self, changeset, pkg, locked=None): # Try to include pkg in the subset, if it won't # require changing the state of other locked packages. set = self._changeset subset = changeset |
subset = changeset | for prv in pkg.provides: for req in prv.requiredby: reqpkgs = [reqpkg for reqpkg in req.packages if subset.get(reqpkg) is INSTALL or subset.get(reqpkg) is not REMOVE and reqpkg.installed] if not reqpkgs: continue found = False for prv in req.providedby: for prvpkg in prv.packages: if (subset.get(prvpkg) is INSTA... | def include(self, changeset, pkg, locked=None): # Try to include pkg in the subset, if it won't # require changing the state of other locked packages. set = self._changeset subset = changeset |
if pkg in subset: return | if self.DEBUG: strop = set.get(pkg) is INSTALL and "INSTALL" or "REMOVE" print "Including %s of %s" % (strop, pkg) | def include(self, changeset, pkg, locked=None): # Try to include pkg in the subset, if it won't # require changing the state of other locked packages. set = self._changeset subset = changeset |
op = set[pkg] | op = subset[pkg] = set[pkg] | def include(self, changeset, pkg, locked=None): # Try to include pkg in the subset, if it won't # require changing the state of other locked packages. set = self._changeset subset = changeset |
subset[pkg] = INSTALL for req in pkg.requires: found = False for prv in req.providedby: for prvpkg in prv.packages: if subset.get(prvpkg) is INSTALL: found = True elif (set.get(prvpkg) is INSTALL and not prvpkg in locked): try: self.include(changeset, prvpkg, locked) found = True except Error: pass else: break if ... | self._install(subset, pkg, locked) else: self._remove(subset, pkg, locked) | def include(self, changeset, pkg, locked=None): # Try to include pkg in the subset, if it won't # require changing the state of other locked packages. set = self._changeset subset = changeset |
def exclude(self, changeset, pkg, locked=None): | def exclude(self, subset, pkg, locked=None): | def exclude(self, changeset, pkg, locked=None): # Try to exclude package from the changeset, it it won't # have to change the state of other locked packages. set = self._changeset subset = changeset |
subset = changeset | def exclude(self, changeset, pkg, locked=None): # Try to exclude package from the changeset, it it won't # have to change the state of other locked packages. set = self._changeset subset = changeset | |
if pkg not in subset: return | if self.DEBUG: strop = set.get(pkg) is INSTALL and "INSTALL" or "REMOVE" print "Excluding %s of %s" % (strop, pkg) | def exclude(self, changeset, pkg, locked=None): # Try to exclude package from the changeset, it it won't # have to change the state of other locked packages. set = self._changeset subset = changeset |
for prv in pkg.provides: for req in prv.requiredby: for reqpkg in req.packages: if (subset.get(reqpkg) is REMOVE or (subset.get(reqpkg) is not INSTALL and not pkg.installed)): continue found = False for prv in req.providedby: for prvpkg in prv.packages: if (subset.get(prvpkg) is INSTALL or (prvpkg.installed and ... | self._remove(subset, pkg, locked) | def exclude(self, changeset, pkg, locked=None): # Try to exclude package from the changeset, it it won't # have to change the state of other locked packages. set = self._changeset subset = changeset |
cnfpkgs = [prvpkg for cnf in pkg.conflicts for prv in cnf.providedby for prvpkg in prv.packages] cnfpkgs.extend([cnfpkg for prv in pkg.provides for cnf in prv.conflictedby for cnfpkg in cnf.packages]) for cnfpkg in cnfpkgs: if subset.get(cnfpkg) is INSTALL: if cnfpkg in locked: raise Error, "Package '%s' is locked" % c... | self._install(subset, pkg, locked) | def exclude(self, changeset, pkg, locked=None): # Try to exclude package from the changeset, it it won't # have to change the state of other locked packages. set = self._changeset subset = changeset |
def includeAll(self, changeset): | def includeAll(self, subset): | def includeAll(self, changeset): # Include everything that doesn't change locked packages set = self._changeset.get() for pkg in set.keys(): try: self.include(changeset, pkg) except Error: pass |
self.include(changeset, pkg) | self.include(subset, pkg) | def includeAll(self, changeset): # Include everything that doesn't change locked packages set = self._changeset.get() for pkg in set.keys(): try: self.include(changeset, pkg) except Error: pass |
def excludeAll(self, changeset): | def excludeAll(self, subset): | def excludeAll(self, changeset): # Exclude everything that doesn't change locked packages set = self._changeset.get() for pkg in set.keys(): try: self.exclude(changeset, pkg) except Error: pass |
self.exclude(changeset, pkg) | self.exclude(subset, pkg) | def excludeAll(self, changeset): # Exclude everything that doesn't change locked packages set = self._changeset.get() for pkg in set.keys(): try: self.exclude(changeset, pkg) except Error: pass |
print response | def askYesNo(self, question, default=False): dialog = gtk.MessageDialog(parent=self._window, flags=gtk.DIALOG_MODAL, type=gtk.MESSAGE_QUESTION, buttons=gtk.BUTTONS_YES_NO, message_format=question+"?") dialog.set_default_response(default and gtk.RESPONSE_YES or gtk.RESPONSE_NO) response = dialog.run() dialog.destroy() p... | |
print response | def askOkCancel(self, question, default=False): dialog = gtk.MessageDialog(parent=self._window, flags=gtk.DIALOG_MODAL, type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK_CANCEL, message_format=question+".") dialog.set_default_response(default and gtk.RESPONSE_OK or gtk.RESPONSE_CANCEL) response = dialog.run() dialog.destro... | |
if not fetched: return False | if not fetched or fetched.getStatus() == FAILED: return False | def fetch(self, fetcher, progress): |
if not fetched or open(fetched.getTargetPath()).read(9) != "=Ver: 2.0": | if not fetched or fetched.getStatus() == FAILED or open(fetched.getTargetPath()).read(9) != "=Ver: 2.0": | def fetch(self, fetcher, progress): |
if (prvpkg.installed and self.getPriority(pkg) >= self.getPriority(prvpkg)): | if prvpkg.installed: deltapri = self.getPriority(pkg) - self.getPriority(prvpkg) if deltapri==0: deltapri = 0.5 | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._sortbonus = sortbonus = {} self._stablebonus = stablebonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: f... |
dct[prvpkg] = True | dct[prvpkg] = deltapri | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._sortbonus = sortbonus = {} self._stablebonus = stablebonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: f... |
upgrading[pkg] = {prvpkg: True} lst = upgraded.get(prvpkg) if lst: lst.append(pkg) else: upgraded[prvpkg] = [pkg] | upgrading[pkg] = {prvpkg: deltapri} if deltapri>0: lst = upgraded.get(prvpkg) if lst: lst.append(pkg) else: upgraded[prvpkg] = [pkg] | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._sortbonus = sortbonus = {} self._stablebonus = stablebonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: f... |
if (upgpkg.installed and self.getPriority(pkg) > self.getPriority(upgpkg)): | if upgpkg.installed: deltapri = self.getPriority(pkg) - self.getPriority(upgpkg) if deltapri==0: deltapri = -0.5 | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._sortbonus = sortbonus = {} self._stablebonus = stablebonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: f... |
dct[upgpkg] = True | dct[upgpkg] = deltapri | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._sortbonus = sortbonus = {} self._stablebonus = stablebonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: f... |
upgrading[pkg] = {upgpkg: True} lst = upgraded.get(upgpkg) if lst: lst.append(pkg) else: upgraded[upgpkg] = [pkg] | upgrading[pkg] = {upgpkg: deltapri} if deltapri>0: lst = upgraded.get(upgpkg) if lst: lst.append(pkg) else: upgraded[upgpkg] = [pkg] | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._sortbonus = sortbonus = {} self._stablebonus = stablebonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: f... |
weight += 3 | weight += self._deltaWeightForRemove(self.getPriority(pkg)) | def getWeight(self, changeset): weight = 0 upgrading = self._upgrading upgraded = self._upgraded sortbonus = self._sortbonus stablebonus = self._stablebonus |
upgradedmap.update(upgpkgs) | for upgpkg in upgpkgs: deltapri = upgpkgs[upgpkg] if upgradedmap.has_key(upgpkg): upgradedmap[upgpkg] = max(deltapri,upgradedmap[upgpkg]) else: upgradedmap[upgpkg] = deltapri | def getWeight(self, changeset): weight = 0 upgrading = self._upgrading upgraded = self._upgraded sortbonus = self._sortbonus stablebonus = self._stablebonus |
weight += -30*upgradedcount+(installedcount-upgradedcount) | weight += installedcount-upgradedcount | def getWeight(self, changeset): weight = 0 upgrading = self._upgrading upgraded = self._upgraded sortbonus = self._sortbonus stablebonus = self._stablebonus |
root = ElementTree.parse(item.getTargetPath()).getroot() | try: root = ElementTree.parse(item.getTargetPath()).getroot() except expat.error, e: raise Error, _("Invalid XML file:\n %s\n %s\n %s") % \ (item.getTargetPath(), repomd, str(e)) | def fetch(self, fetcher, progress): fetcher.reset() repomd = posixpath.join(self._baseurl, "repodata/repomd.xml") item = fetcher.enqueue(repomd) fetcher.run(progress=progress) |
if pkg in self.upgraded: | if pkg in self.downgraded: | def compute(self): changeset = self._changeset for pkg in changeset.getCache().getPackages(): if pkg in self.exclude: continue if changeset.get(pkg) is REMOVE: self.remove[pkg] = True for prv in pkg.provides: for upg in prv.upgradedby: for upgpkg in upg.packages: if changeset.get(upgpkg) is INSTALL: if pkg in self.upgr... |
packages[_("Keep (%d)") % len(keep)] = keep | packages[Sorter(_("Keep (%d)") % len(keep))] = keep | def __lt__(self, other): return cmp(self, other) < 0 |
dot = rfind(".") | dot = version.rfind(".") | def load(self): |
if name[0] == "/": | if prv.name[0] == "/": | def newProvides(self, pkg, prvargs): cache = self._cache prv = cache._prvmap.get(prvargs) if not prv: prv = prvargs[0](*prvargs[1:]) cache._prvmap[prvargs] = prv lst = cache._prvnames.get(prv.name) if lst is not None: lst.append(prv) else: cache._prvnames[prv.name] = [prv] cache._provides.append(prv) prv.packages.appen... |
if req.name == name: | if req.name == prv.name: | def newProvides(self, pkg, prvargs): cache = self._cache prv = cache._prvmap.get(prvargs) if not prv: prv = prvargs[0](*prvargs[1:]) cache._prvmap[prvargs] = prv lst = cache._prvnames.get(prv.name) if lst is not None: lst.append(prv) else: cache._prvnames[prv.name] = [prv] cache._provides.append(prv) prv.packages.appen... |
cache._provides.append(obs) | cache._obsoletes.append(obs) | def newObsoletes(self, pkg, obsargs): cache = self._cache obs = cache._obsmap.get(obsargs) if not obs: obs = obsargs[0](*obsargs[1:]) cache._obsmap[obsargs] = obs lst = cache._obsnames.get(obs.name) if lst is not None: lst.append(obs) else: cache._obsnames[obs.name] = [obs] cache._provides.append(obs) obs.packages.appe... |
url = obj.getURL().original | url = obj.getOriginalURL() | def getLocalPath(self, obj): if isinstance(obj, URL): url = obj.original elif isinstance(obj, FetchItem): url = obj.getURL().original elif type(obj) is str: url = obj else: raise Error, "getLocalPath() can't handle %s" % repr(obj) if self._mangle: filename = url.replace("/", "_") else: scheme, selector = urllib.splitty... |
localpath = self.getLocalPath(url) | localpath = self.getLocalPath(item) | def fetch(self, ftp, item): import socket, ftplib |
self._csweight = self._gen.next() | try: self._csweight = self._gen.next() except Prune: self._trans.numTaskPruned += 1 raise except Failed: self._trans.numTaskFailed += 1 raise except StopIteration: self._trans.numTaskCompleted += 1 raise | def next(self): self._csweight = WEIGHT_NONE # in case _gen raises StopIteration without recomputing self._csweight = self._gen.next() return self._csweight |
PYTHONLIB = get_python_lib() | PYTHONLIB = get_python_lib(1) | def copy_tree(*args, **kwargs): outputs = copy_tree_orig(*args, **kwargs) for i in range(len(outputs)): if outputs[i].endswith("bin/smart.py"): outputs[i] = outputs[i][:-3] return outputs |
raise FetcherCancelled, "Fetch cancelled" | raise FetcherCancelled, "Cancelled" | def run(self, what=None, progress=None): self._cancel = False self.time = time.time() handlers = self._handlers.values() total = len(self._items) self.runLocal() local = len([x for x in self._items.values() if x.getStatus() == SUCCEEDED]) if local == total or self._caching is ALWAYS: if progress: progress.add(total) re... |
self._inactive[handle] = userhost del self._active[:] | self._active.clear() | def tick(self): import pycurl |
selfver, selfarch = splitarch(self.version) otherver, otherarch = splitarch(other.version) | def coexists(self, other): if not isinstance(other, RPMPackage): return True if self.version == other.version: return False if not sysconf.testFlag("multi-version", self): return False selfver, selfarch = splitarch(self.version) otherver, otherarch = splitarch(other.version) return selfver != otherver | |
weight -= 4 | weight -= 5 | def getWeight(self, changeset): weight = 0 upgrading = self._upgrading upgraded = self._upgraded bonus = self._bonus for pkg in changeset: if changeset[pkg] is REMOVE: # Upgrading a package that will be removed # is better than upgrading a package that will # stay in the system. lst = upgraded.get(pkg, ()) for lstpkg i... |
alternatives.append((getweight(cs)+pw[prvpkg], cs, lk)) | alternatives.append((getweight(cs)+pw[prvpkg]+ keeporder, cs, lk)) keeporder += 0.000001 | def _pending(self, changeset, locked, pending, depth=0): #print "[%03d] _pending(%s)" % depth depth += 1 |
penality += (mirrordata["size"]/1000000.)/mirrordata["time"] | penality += float(mirrordata["time"])/mirrordata["size"] | def updatePenality(self): if not self._changed: return self._changed = False self._penality.clear() data = {} for mirror, info in self._history: if mirror not in data: mirrordata = data.setdefault(mirror, {"size": 0, "time": 0, "failed": 0}) else: mirrordata = data[mirror] mirrordata["size"] += info.get("size", 0) mirr... |
upgraded[prvpkg].append(pkg) | upgraded[upgpkg].append(pkg) | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._bonus = bonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: for prv in upg.providedby: for prvpkg in prv.p... |
upgraded[prvpkg] = [pkg] | upgraded[upgpkg] = [pkg] | def runStarting(self): Policy.runStarting(self) self._upgrading = upgrading = {} self._upgraded = upgraded = {} self._bonus = bonus = {} queue = self._trans.getQueue() for pkg in self._trans.getCache().getPackages(): # Precompute upgrade relations. for upg in pkg.upgrades: for prv in upg.providedby: for prvpkg in prv.p... |
task = trans.TaskRemove(self, pkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) task = trans.TaskUpdown(self, pkg, cs, lk, pruneweight, self._yieldweight, force=0) for res in task: yield res; pru... | if immediateUpdown: task = trans.TaskUpdown(self, pkg, cs, lk, pruneweight, self._yieldweight, force=1) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) else: task = trans.TaskRemove(self, pkg, cs, lk, None, pruneweight, self._yieldweight) for r... | def _fix(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth self.trace(1, "_fix(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) getweight = trans.getPolicy().getWeight isinst = changeset.installed |
self.__class__.getHeaders = self.getHeadersHDL self.__class__.getHeader = self.getHeaderHDL self.__class__.loadFileProvides = self.loadFileProvidesHDL | self.__class__.getHeaders = self.getHeadersHDL.im_func self.__class__.getHeader = self.getHeaderHDL.im_func self.__class__.loadFileProvides = self.loadFileProvidesHDL.im_func | def _checkRPM(self): if not hasattr(rpm, "readHeaderFromFD"): |
if os.access(conffile, os.W_OK): | dirname = os.path.dirname(conffile) if not os.path.isdir(dirname) or os.access(dirname, os.W_OK): | def saveSysConf(self, conffile=None): if not conffile: confdigest = md5.md5(str(sysconf.getMap())).digest() if confdigest == self._confdigest: return self._confdigest = confdigest conffile = self._conffile conffile = os.path.expanduser(conffile) if os.access(conffile, os.W_OK): sysconf.save(conffile) |
print self._info | def __init__(self, package, loader, info): PackageInfo.__init__(self, package) self._loader = loader self._info = info print self._info | |
alternatives = [] | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) | |
keeporder = 0.000001 | taskheap = [] doneheap = [] order = 1 csweight = getweight(changeset) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) |
_maxpw = None | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) | |
if (earlyAbort and _maxpw is not None and pw[prvpkg] > _maxpw): self.trace(2, "early abort of PENDING_INSTALL at %s", (prvpkg)) continue | cs = changeset.copy() lk = locked.copy() task = trans.TaskInstall(self, prvpkg, cs, lk, None, _pruneweight, self._yieldweight, csweight, pw[prvpkg], order, "install %s" % prvpkg) heappush(taskheap, task) order += 1 while len(taskheap)>0: task = heappop(taskheap) yw = min(self._yieldweight, _pruneweight) if len(taskhe... | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) |
cs = changeset.copy() lk = locked.copy() task = trans.TaskInstall(self, prvpkg, cs, lk, None, _pruneweight, self._yieldweight) for res in task: yield res; _pruneweight=min(_pruneweight,self._pruneweight); task.setWeights(_pruneweight, self._yieldweight) | task.setWeights(_pruneweight, yw) res = task.next() | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) |
csweight = getweight(cs) self.trace(2, "feasible PENDING_INSTALL alternative: %s (csw=%f)", (prvpkg, csweight), cs) _pruneweight = min(_pruneweight, csweight) alternatives.append((csweight+pw[prvpkg]+ keeporder, cs, lk)) keeporder += 0.000001 if earlyAbort: _maxpw = pw[prvpkg] if not alternatives: | yield res _pruneweight = min(_pruneweight, self._pruneweight) heappush(taskheap, task) if len(doneheap)==0: | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) |
alternatives.sort() changeset.setState(alternatives[0][1]) if len(alternatives) == 1: locked.update(alternatives[0][2]) | changeset.setState(doneheap[0]._changeset) if len(doneheap) == 1: locked.update(doneheap[0]._locked) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) |
version = pkg.version if ":" in version: version = version[version.find(":")+1:] version, arch = splitarch(version) | loader = [x for x in pkg.loaders if x.getInstalled()][0] offset = pkg.loaders[loader] | def commit(self, changeset, pkgpaths): |
ts.addErase("%s-%s" % (pkg.name, version)) | ts.addErase(offset) | def commit(self, changeset, pkgpaths): |
targetpath = os.path.dirname(os.path.join(sys.prefix, "share", filepath)) | targetpath = os.path.dirname(os.path.join("share", filepath)) | def copy_tree(*args, **kwargs): outputs = copy_tree_orig(*args, **kwargs) for i in range(len(outputs)): if outputs[i].endswith("bin/smart.py"): outputs[i] = outputs[i][:-3] return outputs |
glob.glob("smart/interfaces/images/*.png"))], | glob.glob("smart/interfaces/images/*.png")), ("share/man/man8/", glob.glob("doc/*.8")) ] | def copy_tree(*args, **kwargs): outputs = copy_tree_orig(*args, **kwargs) for i in range(len(outputs)): if outputs[i].endswith("bin/smart.py"): outputs[i] = outputs[i][:-3] return outputs |
if not os.path.isfile(os.path.join(getTS.root, "var/lib/rpm/Packages")): | dbdir = os.path.join(getTS.root, "var/lib/rpm") if not os.path.isfile(os.path.join(dbdir, "Packages")): | def getTS(new=False): if not hasattr(getTS, "ts"): getTS.root = sysconf.get("rpm-root", "/") getTS.ts = rpm.ts(getTS.root) if not os.path.isfile(os.path.join(getTS.root, "var/lib/rpm/Packages")): try: getTS.ts.initDB() except rpm.error: raise Error, _("Couldn't initizalize rpm database at %s") \ % getTS.root else: ifac... |
except rpm.error: | except (rpm.error, OSError): | def getTS(new=False): if not hasattr(getTS, "ts"): getTS.root = sysconf.get("rpm-root", "/") getTS.ts = rpm.ts(getTS.root) if not os.path.isfile(os.path.join(getTS.root, "var/lib/rpm/Packages")): try: getTS.ts.initDB() except rpm.error: raise Error, _("Couldn't initizalize rpm database at %s") \ % getTS.root else: ifac... |
myversion, myarch = splitarch(self.version) myversion = _epochre.sub("", myversion) | myversionwithepoch, myarch = splitarch(self.version) myversionwithoutepoch = _epochre.sub("", myversionwithepoch) | def search(self, searcher, _epochre=re.compile("[0-9]+:")): myname = self.name myversion, myarch = splitarch(self.version) myversion = _epochre.sub("", myversion) ratio = 0 ic = searcher.ignorecase for nameversion, cutoff in searcher.nameversion: nameversion = _epochre.sub("", nameversion) if '@' in nameversion: _, rat... |
nameversion = _epochre.sub("", nameversion) | if _epochre.search(nameversion): myversion = myversionwithepoch else: myversion = myversionwithoutepoch | def search(self, searcher, _epochre=re.compile("[0-9]+:")): myname = self.name myversion, myarch = splitarch(self.version) myversion = _epochre.sub("", myversion) ratio = 0 ic = searcher.ignorecase for nameversion, cutoff in searcher.nameversion: nameversion = _epochre.sub("", nameversion) if '@' in nameversion: _, rat... |
_, ratio1 = globdistance(nameversion, "%s-%s" % (myname, self.version), cutoff, ic) | _, ratio1 = globdistance(nameversion, "%s-%s@%s" % (myname, myversion, myarch), cutoff, ic) | def search(self, searcher, _epochre=re.compile("[0-9]+:")): myname = self.name myversion, myarch = splitarch(self.version) myversion = _epochre.sub("", myversion) ratio = 0 ic = searcher.ignorecase for nameversion, cutoff in searcher.nameversion: nameversion = _epochre.sub("", nameversion) if '@' in nameversion: _, rat... |
if force: alternatives = [] else: alternatives = [(getweight(changeset), changeset)] pruneweight = min(pruneweight, alternatives[0][0]) if earlyAbort: upgpkgs = upgpkgs.keys() sortUpgrades(upgpkgs) pw = trans.getPolicy().getPriorityWeights(upgpkgs) _maxpw = None | csweight = getweight(changeset) if not force: pruneweight = min(pruneweight, csweight) upgpkgs = upgpkgs.keys() sortUpgrades(upgpkgs) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
if (earlyAbort and _maxpw is not None and pw[upgpkg] > _maxpw): self.trace(2, "early abort of _updown.upg at %s", (upgpkg)) continue try: cs = changeset.copy() lk = locked.copy() task = trans.TaskInstall(self, upgpkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,... | cs = changeset.copy() lk = locked.copy() task = trans.TaskInstall(self, upgpkg, cs, lk, None, pruneweight, self._yieldweight, csweight, 0, order, "upgrade to %s" % upgpkg) heappush(taskheap, task) order += 1 | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
if earlyAbort and _maxpw is not None: raise StopIteration | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) | |
if pruneByWeight and len(alternatives)==0: if getweight(changeset) > pruneweight: self.trace(2, "pruned downgrading _updown") raise Prune, _("Pruned downgrading of %s") % (pkg) if earlyAbort: dwnpkgs = dwnpkgs.keys() sortUpgrades(dwnpkgs) pw = trans.getPolicy().getPriorityWeights(dwnpkgs) _maxpw = None | dwnpkgs = dwnpkgs.keys() sortUpgrades(dwnpkgs) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
if (earlyAbort and _maxpw is not None and pw[dwnpkg] > _maxpw): self.trace(2, "early abort of _updown.dwn at %s", (dwnpkg)) continue try: cs = changeset.copy() lk = locked.copy() task = trans.TaskInstall(self, dwnpkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,... | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) | |
task = trans.TaskRemove(self, pkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | task = trans.TaskInstall(self, dwnpkg, cs, lk, None, pruneweight, self._yieldweight, csweight, 1, order, "downgrade to %s" % dwnpkg) heappush(taskheap, task) order += 1 if force: cs = changeset.copy() lk = locked.copy() task = trans.TaskRemove(self, pkg, cs, lk, None, pruneweight, self._yieldweight, csweight, 2, orde... | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
if len(alternatives)==0: raise Failed, _("Can't get rid of %s" % pkg) | pass | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
if len(alternatives)==0: raise | pass except StopIteration: cs = task._changeset csw = task.getChangesetWeight() self.trace(3, "feasible _updown alternative for %s: %s (csw=%f)", (pkg, task._desc, csw), cs) heappush(doneheap, task) pruneweight = min(pruneweight, csw) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
csweight = getweight(cs) self.trace(3, "feasible delete alternative (csw=%f)", (csweight), cs) alternatives.append((csweight, cs)) pruneweight = min(pruneweight, csweight) if len(alternatives) > 1: alternatives.sort() if force or len(alternatives) > 1: changeset.setState(alternatives[0][1]) | yield res pruneweight = min(pruneweight, self._pruneweight) heappush(taskheap, task) if force: if len(doneheap)==0: raise Failed, _("Can't get rid of %s" % pkg) else: if doneheap[0].getChangesetWeight() >= csweight: self._csweight = csweight return self._changeset.setState(doneheap[0]._changeset) self._csweight = (don... | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
return (self.operation.copy(), self.touched.copy()) | return (self.operation.copy(), self.touched.copy(), self.queue[:]) | def getState(self): return (self.operation.copy(), self.touched.copy()) |
self.queue.append((pkg, OPER_INSTALL)) | self.queue.append((pkg, OPER_INSTALL, len(self.backtrack))) | def install(self, pkg): self.touched[pkg] = True if not self.getInstalled(pkg): self.operation[pkg] = (OPER_INSTALL, REASON_REQUESTED, None, None) self.queue.append((pkg, OPER_INSTALL)) |
self.queue.append((pkg, OPER_REMOVE)) | self.queue.append((pkg, OPER_REMOVE, len(self.backtrack))) | def remove(self, pkg): self.touched[pkg] = True self.operation[pkg] = (OPER_REMOVE, REASON_REQUESTED, None, None) self.queue.append((pkg, OPER_REMOVE)) |
backtrack = self.backtrack | bt = self.backtrack | def run(self): loopctrl = {} |
pkg, op = queue.pop(0) savedbt = backtrack[:] | pkg, op, btlen = queue.pop(0) | def run(self): loopctrl = {} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.