rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
backtrack.append((prvpkg, OPER_INSTALL, REASON_REQUIRES, pkg, prvpkg, self.getState())) | bt.append((prvpkg, OPER_INSTALL, REASON_REQUIRES, pkg, prvpkg, self.getState())) | def run(self): loopctrl = {} |
queue.append((prvpkg, OPER_INSTALL)) | queue.append((prvpkg, OPER_INSTALL, len(bt))) | def run(self): loopctrl = {} |
backtrack.append((prvpkg, OPER_INSTALL, REASON_REQUIRES, reqpkgs[0], pkg, self.getState())) | bt.append((prvpkg, OPER_INSTALL, REASON_REQUIRES, reqpkgs[0], pkg, self.getState())) | def run(self): loopctrl = {} |
del queue[:] backtrack[:] = savedbt | del bt[btlen:] | def run(self): loopctrl = {} |
if backtrack: | if bt: | def run(self): loopctrl = {} |
print "Alternatives/Weight: %d/%d" % (len(backtrack), weight) | print "Alternatives/Weight: %d/%d" % (len(bt), weight) | def run(self): loopctrl = {} |
pkg, op, reason, pkg1, pkg2, state = backtrack.pop() | pkg, op, reason, pkg1, pkg2, state = bt.pop() | def run(self): loopctrl = {} |
self.queue.append((pkg, op)) | queue.append((pkg, op, len(bt))) | def run(self): loopctrl = {} |
self.queue.append((pkg, OPER_REMOVE)) | self.queue.append((pkg, OPER_REMOVE, len(self.backtrack))) | def _remove(self, pkg, reason, pkg1, pkg2): """ Remove package including upgrade/downgrade as an alternative. """ # Look for packages obsoleting the removed # package (upgrade) as an alternative. for prv in pkg.provides: for obs, obspkgs in prv.getObsoletedBy(): for obspkg in obspkgs: if obspkg in self.touched or self.... |
if element[1] != "0": version = "%s:%s" % (element[1], version) | def load(self): | |
summary = description = reading_ins = "" | summary = description = reading_ins = reading_del = "" | def readPkgSummDesc(self, entryname): summary = description = reading_ins = "" if self._pkgdescfile and self._pkgoffsets.has_key(entryname): self._descfile.seek((self._pkgoffsets[entryname] + 1)) summary = self._descfile.readline()[5:-1] description = "" while 1: line = self._descfile.readline() if line.startswith("##-... |
def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) | class Task(object): """ This class provides an iterator (to be implemented by a generator function). The calls to next() return a series of tentative changesets weights, which are (hopefully, but not necessarily) monotonically increasing. When the final changeset is ready, next() raises StopIteration, and _changeset an... | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
for prhpkg in self.getProhibits(pkg): | for prhpkg in trans.getProhibits(pkg): | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
optweight = self._policy.getWeight(changeset) optweight += self._policy.getBestUpdownDeltaWeight(prhpkg) if optweight is not None and optweight > pruneweight: | optweight = trans.getPolicy().getWeight(changeset) optweight += trans.getPolicy().getBestUpdownDeltaWeight(prhpkg) if optweight is not None and optweight > self._pruneweight: | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
task = self._updown(prvpkg, changeset, locked, pruneweight, depth, force=1) for res in task: yield res | task = trans.TaskUpdown(self, prvpkg, changeset, locked, self._pruneweight, self._yieldweight, force=1) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
task = self._remove(prvpkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | task = trans.TaskRemove(self, prvpkg, changeset, locked, pending, self._pruneweight, self._yieldweight) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
task = self._updown(cnfpkg, changeset, locked, pruneweight, depth, force=1) for res in task: yield res | task = trans.TaskUpdown(self, cnfpkg, changeset, locked, self._pruneweight, self._yieldweight, force=1) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
task = self._remove(cnfpkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | task = trans.TaskRemove(self, cnfpkg, changeset, locked, pending, self._pruneweight, self._yieldweight) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
namepkgs = self._cache.getPackages(pkg.name) | namepkgs = trans.getCache().getPackages(pkg.name) | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
task = self._remove(namepkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | task = trans.TaskRemove(self, namepkg, changeset, locked, pending, self._pruneweight, self._yieldweight) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
task = self._install(prvpkgs.popitem()[0], changeset, locked, pending, pruneweight, depth) for res in task: yield res | task = trans.TaskInstall(self, prvpkgs.popitem()[0], changeset, locked, pending, self._pruneweight, self._yieldweight) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
task = self._pending(changeset, locked, pending, pruneweight, depth) for res in task: yield res def _remove(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_remove(%s, pw=%f)", (pkg, pruneweight)) | task = trans.TaskPending(self, changeset, locked, pending, self._pruneweight, self._yieldweight) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) class TaskRemove(Task): def __init__(self, parent, pkg, changeset, locked, pending, pruneweight, yieldweight, csweight=WEIGHT_NONE, pri=0, o... | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
optweight = self._policy.getWeight(changeset) for necpkg in self.getNecessary(pkg): | optweight = trans.getPolicy().getWeight(changeset) for necpkg in trans.getNecessary(pkg): | def _remove(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_remove(%s, pw=%f)", (pkg, pruneweight)) |
optweight += self._policy.getBestUpdownDeltaWeight(necpkg) | optweight += trans.getPolicy().getBestUpdownDeltaWeight(necpkg) | def _remove(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_remove(%s, pw=%f)", (pkg, pruneweight)) |
task = self._updown(reqpkg, changeset, locked, pruneweight, depth, force=1) for res in task: yield res | task = trans.TaskUpdown(self, reqpkg, changeset, locked, pruneweight, self._yieldweight, force=1) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | def _remove(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_remove(%s, pw=%f)", (pkg, pruneweight)) |
task = self._remove(reqpkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | task = trans.TaskRemove(self, reqpkg, changeset, locked, pending, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | def _remove(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_remove(%s, pw=%f)", (pkg, pruneweight)) |
task = self._pending(changeset, locked, pending, pruneweight, depth) for res in task: yield res def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): | task = trans.TaskPending(self, changeset, locked, pending, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) class TaskUpdown(Task): def __init__(self, parent, pkg, changeset, locked, pruneweight, yieldweight, for... | def _remove(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_remove(%s, pw=%f)", (pkg, pruneweight)) |
depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) | gen = self._updown(pkg, force) parent._trans.Task.__init__(self, parent, gen, changeset, locked, pruneweight, yieldweight, csweight, pri, order, desc) def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth,... | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
getpriority = self._policy.getPriority | getpriority = trans.getPolicy().getPriority | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
getweight = self._policy.getWeight | getweight = trans.getPolicy().getWeight | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
pw = self._policy.getPriorityWeights(upgpkgs) | pw = trans.getPolicy().getPriorityWeights(upgpkgs) | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
task = self._install(upgpkg, cs, lk, None, pruneweight, depth) for res in task: yield res | task = trans.TaskInstall(self, upgpkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
pw = self._policy.getPriorityWeights(dwnpkgs) | pw = trans.getPolicy().getPriorityWeights(dwnpkgs) | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
task = self._install(dwnpkg, cs, lk, None, pruneweight, depth) for res in task: yield res | task = trans.TaskInstall(self, dwnpkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
task = self._remove(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | 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) | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): """ If force=1, insists on replacing or removing pkg. """ depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 | class TaskPending(Task): def __init__(self, parent, changeset, locked, pending, pruneweight, yieldweight, csweight=WEIGHT_NONE, pri=0, order=0, desc=""): gen = self._pending(pending) parent._trans.Task.__init__(self, parent, gen, changeset, locked, pruneweight, yieldweight, csweight, pri, order, desc) def _pending(sel... | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
trace(1, depth, "_pending(pw=%f)", (pruneweight)) | trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) | trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
getweight = self._policy.getWeight | getweight = trans.getPolicy().getWeight | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
pw = self._policy.getPriorityWeights(prvpkgs) | pw = trans.getPolicy().getPriorityWeights(prvpkgs) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
_pruneweight = pruneweight | _pruneweight = self._pruneweight | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
task = self._install(prvpkg, cs, lk, None, _pruneweight, depth) for res in task: yield res | 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) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
task = self._install(prvpkgs[0], changeset, locked, pending, pruneweight, depth) for res in task: yield res | task = trans.TaskInstall(self, prvpkgs[0], changeset, locked, pending, self._pruneweight, self._yieldweight) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
_pruneweight = pruneweight pw = self._policy.getPriorityWeights(prvpkgs) | _pruneweight = self._pruneweight pw = trans.getPolicy().getPriorityWeights(prvpkgs) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
task = self._updown(reqpkg, changeset, locked, pruneweight, depth, 1) for res in task: yield res | task = trans.TaskUpdown(self, reqpkg, changeset, locked, self._pruneweight, self._yieldweight, force=1) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
task = self._remove(reqpkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | task = trans.TaskRemove(self, reqpkg, changeset, locked, pending, self._pruneweight, self._yieldweight) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
task = self._updown(reqpkg, cs, lk, pruneweight, depth, force=1) for res in task: yield res | task = trans.TaskUpdown(self, reqpkg, cs, lk, _pruneweight, self._yieldweight, force=1) for res in task: yield res; pruneweight=min(_pruneweight,self._pruneweight); task.setWeights(_pruneweight, self._yieldweight) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
task = self._remove(reqpkg, cs, lk, None, pruneweight, depth) for res in task: yield res | task = trans.TaskRemove(self, reqpkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(_pruneweight,self._pruneweight); task.setWeights(_pruneweight, self._yieldweight) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
task = self._updown(pkg, changeset, locked, pruneweight, depth) for res in task: yield res | task = trans.TaskUpdown(self, pkg, changeset, locked, self._pruneweight, self._yieldweight, force=0) for res in task: yield res; task.setWeights(self._pruneweight, self._yieldweight) | def _pending(self, changeset, locked, pending, pruneweight, depth=0): depth += 1 if traceVerbosity<4: trace(1, depth, "_pending(pw=%f)", (pruneweight)) else: trace(4, depth, "_pending(%s, pw=%f)", (pending, pruneweight)) |
def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 | class TaskUpgrade(Task): def __init__(self, parent, pkgs, changeset, locked, pending, pruneweight, yieldweight, csweight=WEIGHT_NONE, pri=0, order=0, desc=""): gen = self._upgrade(pkgs, pending) parent._trans.Task.__init__(self, parent, gen, changeset, locked, pruneweight, yieldweight, csweight, pri, order, desc) def ... | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
getweight = self._policy.getWeight sortUpgrades(pkgs, self._policy) | getweight = trans.getPolicy().getWeight sortUpgrades(pkgs, trans.getPolicy()) | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
task = self._install(pkg, cs, lk, None, pruneweight, depth) for res in task: pass | task = trans.TaskInstall(self, pkg, cs, lk, None, self._pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
task = self._install(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | task = trans.TaskInstall(self, pkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
task = self._remove(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | 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) | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 | class TaskFix(Task): def __init__(self, parent, pkgs, changeset, locked, pending, pruneweight, yieldweight, csweight=WEIGHT_NONE, pri=0, order=0, desc=""): gen = self._fix(pkgs, pending) parent._trans.Task.__init__(self, parent, gen, changeset, locked, pruneweight, yieldweight, csweight, pri, order, desc) def _fix(sel... | def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_fix()") |
getweight = self._policy.getWeight | getweight = trans.getPolicy().getWeight | def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_fix()") |
namepkgs = self._cache.getPackages(pkg.name) | namepkgs = trans.getCache().getPackages(pkg.name) | def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_fix()") |
task = self._install(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | task = trans.TaskInstall(self, pkg, cs, lk, None, pruneweight, self._yieldweight) for res in task: yield res; pruneweight=min(pruneweight,self._pruneweight); task.setWeights(pruneweight, self._yieldweight) | def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_fix()") |
task = self._remove(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res task = self._updown(pkg, cs, lk, pruneweight, depth) for res in task: yield res | 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... | def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_fix()") |
task = self._install(pkg, changeset, locked, pending, WEIGHT_NONE) | task = self.TaskInstall(roottask, pkg, changeset, locked, pending, WEIGHT_NONE, WEIGHT_NONE) | def run(self): |
task = self._remove(pkg, changeset, locked, pending, WEIGHT_NONE) | task = self.TaskRemove(roottask, pkg, changeset, locked, pending, WEIGHT_NONE, WEIGHT_NONE) | def run(self): |
task = self._pending(changeset, locked, pending, WEIGHT_NONE) | task = self.TaskPending(roottask, changeset, locked, pending, WEIGHT_NONE, WEIGHT_NONE) | def run(self): |
task = self._upgrade(upgpkgs, changeset, locked, pending, WEIGHT_NONE) | task = self.TaskUpgrade(roottask, upgpkgs, changeset, locked, pending, WEIGHT_NONE, WEIGHT_NONE) | def run(self): |
task = self._fix(fixpkgs, changeset, locked, pending, WEIGHT_NONE) | task = self.TaskFix(roottask, fixpkgs, changeset, locked, pending, WEIGHT_NONE, WEIGHT_NONE) | def run(self): |
psyco.bind(Transaction._install) psyco.bind(Transaction._remove) psyco.bind(Transaction._updown) psyco.bind(Transaction._pending) psyco.bind(Transaction._upgrade) | psyco.bind(Transaction.Task) psyco.bind(Transaction.TaskInstall) psyco.bind(Transaction.TaskRemove) psyco.bind(Transaction.TaskUpdown) psyco.bind(Transaction.TaskPending) psyco.bind(Transaction.TaskUpgrade) | def enablePsyco(psyco): psyco.bind(PolicyInstall.getWeight) psyco.bind(PolicyRemove.getWeight) psyco.bind(PolicyUpgrade.getWeight) psyco.bind(Transaction.getNecessary) psyco.bind(Transaction.getNecessitates) psyco.bind(Transaction.getProhibits) psyco.bind(Transaction._install) psyco.bind(Transaction._remove) psyco.bind... |
self._changed = True self.fill() | if self._changed: self.fill() | def newChannel(self): self.enableDisable() |
if not self._type: self._type = type | def type_toggled(button, type): if button.get_active(): self._type = type | |
button = gtk.Button(stock="gtk-ok") | self._ok = button = gtk.Button(stock="gtk-ok") | def delete(widget, event): gtk.main_quit() return True |
if not self._mp: self._mp = mp | def mp_toggled(button, mp): if button.get_active(): self._mp = mp | |
obsoleting = {} obsoleted = {} | upgrading = {} upgraded = {} | def commit(self, install, remove, pkgpath): |
for prv in pkg.provides: for obs in prv.obsoletedby: for obspkg in obs.packages: if obspkg in install: obsoleted[pkg] = True obsoleting[obspkg] = True | for upg in pkg.upgrades: for prv in upg.providedby: upgd = [] for prvpkg in prv.packages: if prvpkg.installed: if prvpkg not in remove: break upgd.append(prvpkg) else: if upgd: upgrading[pkg] = True upgraded.update(dict.fromkeys(upgd)) | def commit(self, install, remove, pkgpath): |
mode = pkg in obsoleting and "u" or "i" | mode = pkg in upgrading and "u" or "i" | def commit(self, install, remove, pkgpath): |
if pkg not in obsoleted: | if pkg not in upgraded: | def commit(self, install, remove, pkgpath): |
def getPriorityWeights(self, pkgs): set = {} lower = None for pkg in pkgs: priority = self.getPriority(pkg) if lower is None or priority < lower: lower = priority set[pkg] = priority for pkg in set: set[pkg] = -(set[pkg] - lower)*10 return set | def getPriority(self, pkg): priority = self._priorities.get(pkg) if priority is None: self._priorities[pkg] = priority = pkg.getPriority() return priority | |
if not prioritiesAffectWeight: return deltapri>0 and 2 or 0 | def _deltaWeightByDeltaPri(self, deltapri): if not prioritiesAffectWeight: return deltapri>0 and 2 or 0 # Bounded effect of priorities, so that num. affected packages maintains its importance. # The +/-0.5 is for up/downgrades with no priority difference. assert(abs(deltapri)>=0.5) if deltapri>=0: return 2.5 - 1*atan((... | |
if not prioritiesAffectWeight: return 20 | def _deltaWeightForRemove(self, pri): if not prioritiesAffectWeight: return 20 # Bounded effect of priorities, so that num. affected packages maintains its importance. if pri>=0: return 20 + 10*atan(pri/priorityScale)/(pi/2) # [20,30) else: return 20 + 4*atan(1.0*pri/priorityScale)/(pi/2) # (16,20] | |
if not prioritiesAffectWeight: return deltapri>0 and -30 or 0 | def _deltaWeightByDeltaPri(self, deltapri): if not prioritiesAffectWeight: return deltapri>0 and -30 or 0 # Unbounded so we can express "get me that version whatever it takes". # The +/-0.5 is for up/downgrades with no priority difference. assert(abs(deltapri)>=0.5) if deltapri>=0: return -30 - 10*(deltapri-0.5)/priori... | |
if not prioritiesAffectWeight: return 3 | def _deltaWeightForRemove(self, pri): if not prioritiesAffectWeight: return 3 # Penalty for removing high-priority packages is unbounded, # to let us express "get me that version whatever it takes". # For negative priorities we bound up from 0, so we're never happy # to remove a package (but still prioritize by weight)... | |
pw = trans.getPolicy().getPriorityWeights(prvpkgs) | 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, pw[prvpkg], order, "install %s" % prvpkg) | csweight, -getpriority(prvpkg), order, "install %s" % prvpkg) | 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, pw[prvpkg], order, "provide using %s" % prvpkg) | csweight, -getpriority(prvpkg), order, "provide using %s" % prvpkg) | 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)) |
prog.start(True) | prog.setHasSub(True) prog.start() | def test(): prog = TextProgress() data = {"item-number": 0} total, subtotal = 100, 100 prog.start(True) prog.setTopic("Installing packages...") for n in range(1,total+1): data["item-number"] = n prog.set(n, total) prog.setSubTopic(n, "package-name%d" % n) for i in range(0,subtotal+1): prog.setSub(n, i, subtotal, subdat... |
__stateversion__ = Loader.__stateversion__+2 | __stateversion__ = Loader.__stateversion__+3 | def getGroup(self): return self._info.get("group", "") |
if shrver == (shares[1]+"-"+shares[2]) and shrarch == shares[3]: | if (pkgshr.name == name and (shrver == (shares[1]+"-"+shares[2]) and shrarch == shares[3])): | def parseEntry(self): Pkg = RPMPackage Req = RPMRequires Prq = RPMPreRequires Prv = RPMProvides Con = RPMConflicts Obs = RPMObsoletes NPrv = RPMNameProvides # SUSE fields not yet handled # Rec / Sug / Src / Aut / Key |
print "%s> %s" % (self._tracepath, str % args) | iface.debug("%s> %s" % (self._tracepath, str % args)) | def trace(self, verbosity, str, args=[], cs=None): """ pretty-print a trace line if it patches the current filter. It accepts format arguments and evaluates them only if needed, instead of having the caller always evaluate its % operator. """ if verbosity<=traceVerbosity and self._depth<=traceDepth: print "%s> %s" ... |
print "--> changeset:\n%s" % (cs) | iface.debug("--> changeset:\n%s" % (cs)) | def trace(self, verbosity, str, args=[], cs=None): """ pretty-print a trace line if it patches the current filter. It accepts format arguments and evaluates them only if needed, instead of having the caller always evaluate its % operator. """ if verbosity<=traceVerbosity and self._depth<=traceDepth: print "%s> %s" ... |
if traceVerbosity>0: print "\n (self.numTaskStarted, self.numTaskCompleted, self.numTaskPruned, self.numTaskFailed) | iface.debug("\nTasks started: %d, completed: %d, pruned: %d, failed: %d." % \ (self.numTaskStarted, self.numTaskCompleted, self.numTaskPruned, self.numTaskFailed)) | def run(self): |
if traceVerbosity>=7: print " | if traceVerbosity>=7: iface.debug("getNecessary(%s) -> %s" % (pkg, sorted(necdct.keys()))) | def getNecessary(self, pkg, ignorepkgs={}): """ Return the set of packages for which pkg is necessary (i.e., a chain of requires with no alternatives). """ |
if traceVerbosity>=7: print " | if traceVerbosity>=7: iface.debug(" | def getNecessitates(self, pkg, ignorepkgs={}): """ Return a set of packages which are necessary for pkg because they are the only way to satisfy requirements. The result is cached. """ |
if traceVerbosity>=7: print " | if traceVerbosity>=7: iface.debug(" | def getProhibits(self, pkg): """ Return a set of packages which directly or indirectly conflict with pkg. We first construct a set of "red" packages, which must be installed if pkg is installed. We then identify all "blue" packages, which conflict with red packages. Then we find the closure of the "blue" packages by co... |
prog.set(0, total) | prog.set(local, total) | def run(self, what=None, progress=None): 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) return if progress: prog = progress prog.add(lo... |
if self._status in (RUNNING, WAITING): | if self._status is not FAILED: | def setSucceeded(self, targetpath, fetchedsize=0): if self._status in (RUNNING, WAITING): self._status = SUCCEEDED self._targetpath = targetpath if self._starttime: if fetchedsize: now = self._fetcher.time timedelta = now-self._starttime if timedelta < 1: timedelta = 1 self._mirror.addInfo(time=timedelta, size=fetcheds... |
if self._status in (RUNNING, WAITING): self._status = FAILED self._failedreason = reason if self._starttime: self._mirror.addInfo(failed=1) self._progress.setSubStopped(self._urlobj.original) self._progress.show() | self._status = FAILED self._failedreason = reason if self._starttime: self._mirror.addInfo(failed=1) self._progress.setSubStopped(self._urlobj.original) self._progress.show() | def setFailed(self, reason): if self._status in (RUNNING, WAITING): self._status = FAILED self._failedreason = reason if self._starttime: self._mirror.addInfo(failed=1) self._progress.setSubStopped(self._urlobj.original) self._progress.show() |
pycurl.TIMECONDITION_IFUNMODSINCE) | pycurl.TIMECONDITION_NONE) | def progress(downtotal, downcurrent, uptotal, upcurrent, item=item, size=size, partsize=partsize): if not downtotal: if size and downcurrent: item.progress(partsize+downcurrent, size) else: item.progress(partsize+downcurrent, partsize+downtotal) |
set[pkg] = -(set[pkg] - lower) | set[pkg] = -(set[pkg] - lower)*100 | def getPriorityWeights(self, pkgs): set = {} lower = None for pkg in pkgs: priority = self.getPriority(pkg) if lower is None or priority < lower: lower = priority set[pkg] = priority for pkg in set: set[pkg] = -(set[pkg] - lower) return set |
failures.append(str(e)) | failures.append(e.args[0]) | def _pending(self, changeset, locked, pending, depth=0): #print "[%03d] _pending(%s)" % depth #depth += 1 |
failures.append(str(e)) | failures.append(e.args[0]) | def _fix(self, pkgs, changeset, locked, pending, depth=0): #print "[%03d] _fix()" % depth #depth += 1 |
rpmname = "%s-%s.%s.rpm" % (self._info["name"], self._info["version"], self._info["arch"]) return [posixpath.join(self._loader._baseurl, rpmname)] | name = self._package.name version, arch = splitarch(self._package.version) version = EPOCHRE.sub("", version) return [posixpath.join(self._loader._baseurl, "%s-%s.%s.rpm" % (name, version, arch))] | def getURLs(self): rpmname = "%s-%s.%s.rpm" % (self._info["name"], self._info["version"], self._info["arch"]) return [posixpath.join(self._loader._baseurl, rpmname)] |
name = depends.groups()[0] operation = "" version = "" condition = depends.groups()[1] | name, flag, condition = depends.groups() operation = None version = None | def splitDepends(self, depsarray, _dependsre=DEPENDSRE, _operationre=OPERATIONRE): result = [] for deps in depsarray: depends = _dependsre.match(deps) if depends: name = depends.groups()[0] operation = "" version = "" condition = depends.groups()[1] if condition: o = _operationre.match(condition) if o: (operation, vers... |
(operation, version) = o.groups()[0:2] if operation == "==": operation = "=" result.append((name, operation, version)) | operation, version = o.groups() if operation == "==": operation = "=" if version and version.startswith("0:"): version = version[2:] result.append((name, operation, version, bool(flag))) | def splitDepends(self, depsarray, _dependsre=DEPENDSRE, _operationre=OPERATIONRE): result = [] for deps in depsarray: depends = _dependsre.match(deps) if depends: name = depends.groups()[0] operation = "" version = "" condition = depends.groups()[1] if condition: o = _operationre.match(condition) if o: (operation, vers... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.