rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
ERROR = Enum("ERROR") WARNING = Enum("WARNING") INFO = Enum("INFO") DEBUG = Enum("DEBUG") | def __new__(klass, name): instance = klass._registry.get(name) if not instance: instance = klass._registry[name] = object.__new__(klass, name) return instance | |
if alias in self._sysconfchannels: | if alias in self._sysconfchannels.keys(): | def rebuildSysConfChannels(self): |
for alias in self._sysconfchannels: | for alias in self._sysconfchannels.keys(): | def rebuildSysConfChannels(self): |
import codecs, locale encoding = locale.getpreferredencoding() sys.stdout = codecs.getwriter(encoding)(os.fdopen(os.dup(1), "w")) sys.stderr = codecs.getwriter(encoding)(os.fdopen(os.dup(2), "w")) | def grabOutput(self, flag): if flag: if not self.rpmout: # Grab rpm output, but not the python one. import codecs, locale encoding = locale.getpreferredencoding() sys.stdout = codecs.getwriter(encoding)(os.fdopen(os.dup(1), "w")) sys.stderr = codecs.getwriter(encoding)(os.fdopen(os.dup(2), "w")) self.stdout = sys.stdou... | |
self.rpmout = pipe[0] setCloseOnExec(self.rpmout) flags = fcntl.fcntl(self.rpmout, fcntl.F_GETFL, 0) | self.rpmout = reader(os.fdopen(pipe[0], "r")) setCloseOnExec(self.rpmout.fileno()) flags = fcntl.fcntl(self.rpmout.fileno(), fcntl.F_GETFL, 0) | def grabOutput(self, flag): if flag: if not self.rpmout: # Grab rpm output, but not the python one. import codecs, locale encoding = locale.getpreferredencoding() sys.stdout = codecs.getwriter(encoding)(os.fdopen(os.dup(1), "w")) sys.stderr = codecs.getwriter(encoding)(os.fdopen(os.dup(2), "w")) self.stdout = sys.stdou... |
fcntl.fcntl(self.rpmout, fcntl.F_SETFL, flags) | fcntl.fcntl(self.rpmout.fileno(), fcntl.F_SETFL, flags) | def grabOutput(self, flag): if flag: if not self.rpmout: # Grab rpm output, but not the python one. import codecs, locale encoding = locale.getpreferredencoding() sys.stdout = codecs.getwriter(encoding)(os.fdopen(os.dup(1), "w")) sys.stderr = codecs.getwriter(encoding)(os.fdopen(os.dup(2), "w")) self.stdout = sys.stdou... |
os.close(self.rpmout) | self.rpmout.close() | def grabOutput(self, flag): if flag: if not self.rpmout: # Grab rpm output, but not the python one. import codecs, locale encoding = locale.getpreferredencoding() sys.stdout = codecs.getwriter(encoding)(os.fdopen(os.dup(1), "w")) sys.stderr = codecs.getwriter(encoding)(os.fdopen(os.dup(2), "w")) self.stdout = sys.stdou... |
output = os.read(self.rpmout, 8192) except OSError, e: | output = self.rpmout.read(BLOCKSIZE) except (OSError, IOError), e: | def _rpmout(self): if self.rpmout: try: output = os.read(self.rpmout, 8192) except OSError, e: if e[0] != errno.EWOULDBLOCK: raise else: if output: if self.topic and self.topic != self.lasttopic: self.lasttopic = self.topic iface.info(self.topic) iface.info(output) |
if _("Not a gzipped file") not in e[0]: | if "Not a gzipped file" not in e[0]: | def fetch(self, fetcher, progress): |
if open(localpath).read(4) == "\xad\x8e\x01\xe8": | if open(localpath).read(4) == "\x8e\xad\xe8\x01": | def fetch(self, fetcher, progress): |
_pruneweight = self._pruneweight | pruneweight = self._pruneweight | 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)) |
yw = min(self._yieldweight, _pruneweight) | yw = min(self._yieldweight, pruneweight) | def evacuate(self): cs = self._changeset lk = self._locked self.trace(1, "_pending.evacuate (pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) for reqpkg in reqpkgs: if reqpkg in lk and cs.installed(reqpkg): raise Failed, _("%s is locked") % reqpkg for reqpkg in reqpkgs: if not cs.installed(reqpkg): continue if r... |
task.setWeights(_pruneweight, yw) | task.setWeights(pruneweight, yw) | def evacuate(self): cs = self._changeset lk = self._locked self.trace(1, "_pending.evacuate (pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) for reqpkg in reqpkgs: if reqpkg in lk and cs.installed(reqpkg): raise Failed, _("%s is locked") % reqpkg for reqpkg in reqpkgs: if not cs.installed(reqpkg): continue if r... |
_pruneweight = min(_pruneweight, csw) | pruneweight = min(pruneweight, csw) | def evacuate(self): cs = self._changeset lk = self._locked self.trace(1, "_pending.evacuate (pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) for reqpkg in reqpkgs: if reqpkg in lk and cs.installed(reqpkg): raise Failed, _("%s is locked") % reqpkg for reqpkg in reqpkgs: if not cs.installed(reqpkg): continue if r... |
_pruneweight = min(_pruneweight, self._pruneweight) | pruneweight = min(pruneweight, self._pruneweight) | def evacuate(self): cs = self._changeset lk = self._locked self.trace(1, "_pending.evacuate (pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) for reqpkg in reqpkgs: if reqpkg in lk and cs.installed(reqpkg): raise Failed, _("%s is locked") % reqpkg for reqpkg in reqpkgs: if not cs.installed(reqpkg): continue if r... |
file = item["info"].split("/")[-1:] iface.warning(_("Failed to download '%s'. You must fetch channel" "information to acquire needed filelists.") % file) | iface.warning(_("Failed to download. You must fetch channel " "information to acquire needed filelists.\n" "%s: %s") % (flitem.getURL(), flitem.getFailedReason())) | def fetch(self, fetcher, progress): fetcher.reset() repomd = posixpath.join(self._baseurl, "repodata/repomd.xml") item = fetcher.enqueue(repomd) fetcher.run(progress=progress) |
"%s-%s" % (myname, myversion), cutoff, ic) _, ratio3 = globdistance(nameversion, "%s-%s" % | "%s_%s" % (myname, myversion), cutoff, ic) _, ratio3 = globdistance(nameversion, "%s_%s" % | def search(self, searcher): myname = self.name myversion = self.version ratio = 0 ic = searcher.ignorecase for nameversion, cutoff in searcher.nameversion: _, ratio1 = globdistance(nameversion, myname, cutoff, ic) _, ratio2 = globdistance(nameversion, "%s-%s" % (myname, myversion), cutoff, ic) _, ratio3 = globdistance(... |
if value < cursori: | if str(value) < str(cursori): | def setCursor(self, cursor): if not cursor: return treeview = self._treeview model = treeview.get_model() iter = None bestiter = None for i in range(len(cursor)): cursori = cursor[i] iter = model.iter_children(iter) while iter: value = model.get_value(iter, 0) if value == cursori: bestiter = iter break if value < curso... |
gobject.TYPE_STRING) | gobject.TYPE_STRING, gobject.TYPE_INT); | def delete(widget, event): gtk.main_quit() return True |
renderer.set_property("xpad", 3) | renderer.set_property("xpad", 4) | def delete(widget, event): gtk.main_quit() return True |
renderer.set_property("xpad", 3) | renderer.set_property("xpad", 4) self._treeview.insert_column_with_attributes(-1, _("Pri"), renderer, text=4) | def toggled(cell, path): model = self._treemodel iter = model.get_iter(path) model.set(iter, 0, not bool(model.get_value(iter, 0))) |
channel.get("name", ""))) | channel.get("name", ""), int(channel.get("priority", "") or 0), )) | def fill(self): self._treemodel.clear() channels = sysconf.get("channels", {}) aliases = channels.keys() aliases.sort() for alias in aliases: channel = channels[alias] self._treemodel.append((not strToBool(channel.get("disabled")), alias, channel.get("type", ""), channel.get("name", ""))) |
elif not chndescr: | elif (not chndescr or newdescr == chndescr or newdescr == olddescr): | def syncChannels(channelsdir=CHANNELSDIR, force=None): if force is None: force = sysconf.get("force-channelsync", False) if os.path.isdir(channelsdir): seenalias = {} for entry in os.listdir(channelsdir): if not entry.endswith(".channel"): continue filepath = os.path.join(channelsdir, entry) if not os.path.isfile(... |
"Do you want to replace it?") % name, | "Old channel:\n\n%s\n\n" "New channel:\n\n%s\n\n" "Do you want to replace it?") % (name, createChannelDescription(alias, chndescr), createChannelDescription(alias, newdescr)), | def syncChannels(channelsdir=CHANNELSDIR, force=None): if force is None: force = sysconf.get("force-channelsync", False) if os.path.isdir(channelsdir): seenalias = {} for entry in os.listdir(channelsdir): if not entry.endswith(".channel"): continue filepath = os.path.join(channelsdir, entry) if not os.path.isfile(... |
elif newdescr != olddescr: | else: | def syncChannels(channelsdir=CHANNELSDIR, force=None): if force is None: force = sysconf.get("force-channelsync", False) if os.path.isdir(channelsdir): seenalias = {} for entry in os.listdir(channelsdir): if not entry.endswith(".channel"): continue filepath = os.path.join(channelsdir, entry) if not os.path.isfile(... |
def colorblue(bpkg): if bpkg not in blues and bpkg not in reds: blues[bpkg] = True bluequeue.append(bpkg) | def colorblue(bpkg): if bpkg not in blues and bpkg not in reds: blues[bpkg] = True bluequeue.append(bpkg) | |
if namepkg is not redpkg and namepkg not in blues and not redpkg.coexists(namepkg): colorblue(namepkg) | if namepkg not in reds and namepkg not in blues and not redpkg.coexists(namepkg): blues[namepkg] = True bluequeue.append(namepkg) | def colorblue(bpkg): if bpkg not in blues and bpkg not in reds: blues[bpkg] = True bluequeue.append(bpkg) |
colorblue(prvpkg) | if prvpkg not in blues and prvpkg not in reds: blues[prvpkg] = True bluequeue.append(prvpkg) | def colorblue(bpkg): if bpkg not in blues and bpkg not in reds: blues[bpkg] = True bluequeue.append(bpkg) |
colorblue(cnfpkg) | if cnfpkg not in blues and cnfpkg not in reds: blues[cnfpkg] = True bluequeue.append(cnfpkg) | def colorblue(bpkg): if bpkg not in blues and bpkg not in reds: blues[bpkg] = True bluequeue.append(bpkg) |
colorblue(reqpkg) | if reqpkg not in blues and reqpkg not in reds: blues[reqpkg] = True bluequeue.append(reqpkg) | def colorblue(bpkg): if bpkg not in blues and bpkg not in reds: blues[bpkg] = True bluequeue.append(bpkg) |
trace(1, depth, "_install(%s, pw=%f, yw=%f)", (pkg, self._pruneweight, self._yieldweight)) | self.trace(1, "_install(%s, pw=%f, yw=%f)", (pkg, self._pruneweight, self._yieldweight)) | def _install(self, pkg, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth trace(1, depth, "_install(%s, pw=%f, yw=%f)", (pkg, self._pruneweight, self._yieldweight)) |
trace(2, depth, "pruned _install") | self.trace(2, "pruned _install") | def _install(self, pkg, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth trace(1, depth, "_install(%s, pw=%f, yw=%f)", (pkg, self._pruneweight, self._yieldweight)) |
trace(1, depth, "_remove(%s, pw=%f, yw=%f))", (pkg, self._pruneweight, self._yieldweight)) | self.trace(1, "_remove(%s, pw=%f, yw=%f)", (pkg, self._pruneweight, self._yieldweight)) | def _remove(self, pkg, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_remove(%s, pw=%f, yw=%f))", (pkg, self._pruneweight, self._yieldweight)) |
trace(2, depth, "pruned _remove") | self.trace(2, "pruned _remove (ow=%f > pw=%f)", (optweight, pruneweight)) | def _remove(self, pkg, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_remove(%s, pw=%f, yw=%f))", (pkg, self._pruneweight, self._yieldweight)) |
trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) | self.trace(1, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
trace(2, depth, "early abort of _updown.upg at %s", (upgpkg)) | self.trace(2, "early abort of _updown.upg at %s", (upgpkg)) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
trace(3, depth, "feasible upg alternative: %s (csw=%f)", (upgpkg, csweight), cs) | self.trace(3, "feasible upg alternative: %s (csw=%f)", (upgpkg, csweight), cs) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
trace(2, depth, "pruned downgrading _updown") | self.trace(2, "pruned downgrading _updown") | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
trace(2, depth, "early abort of _updown.dwn at %s", (dwnpkg)) | self.trace(2, "early abort of _updown.dwn at %s", (dwnpkg)) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
trace(3, depth, "feasible dwn alternative: %s (csw=%f)", (dwnpkg, csweight), cs) | self.trace(3, "feasible dwn alternative: %s (csw=%f)", (dwnpkg, csweight), cs) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
trace(3, depth, "feasible delete alternative (csw=%f)", (csweight), cs) | self.trace(3, "feasible delete alternative (csw=%f)", (csweight), cs) | def _updown(self, pkg, force): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_updown(%s, pw=%f, yw=%f, f=%d)", (pkg, pruneweight, self._yieldweight, force)) |
trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) | self.trace(1, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) | self.trace(4, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight)) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(1, depth, "_pending.PENDING_UPDOWN (%s)", (pkg) ) | self.trace(1, "_pending.PENDING_UPDOWN (%s)", (pkg) ) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(1, depth, "_pending.PENDING_INSTALL (%s, %s, %s)", (pkg,req,prvpkgs) ) | self.trace(1, "_pending.PENDING_INSTALL (%s, %s, %s)", (pkg,req,prvpkgs) ) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(2, depth, "early abort of PENDING_INSTALL at %s", (prvpkg)) | self.trace(2, "early abort of PENDING_INSTALL at %s", (prvpkg)) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(2, depth, "feasible PENDING_INSTALL alternative: %s (csw=%f)", (prvpkg, csweight), cs) | self.trace(2, "feasible PENDING_INSTALL alternative: %s (csw=%f)", (prvpkg, csweight), cs) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(1, depth, "_pending.PENDING_REMOVE (%s, %s, %s, %s)", (pkg, prv, reqpkgs, prvpkgs) ) | self.trace(1, "_pending.PENDING_REMOVE (%s, %s, %s, %s)", (pkg, prv, reqpkgs, prvpkgs) ) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(2, depth, "early abort of PENDING_REMOVE at %s", (prvpkg)) | self.trace(2, "early abort of PENDING_REMOVE at %s", (prvpkg)) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(3, depth, "feasible PENDING_REMOVE prv alternative: %s (csw=%f)", (prvpkg, csweight), cs) | self.trace(3, "feasible PENDING_REMOVE prv alternative: %s (csw=%f)", (prvpkg, csweight), cs) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(3, depth, "feasible PENDING_REMOVE remove alternative (csw=%f)", (csweight), cs) | self.trace(3, "feasible PENDING_REMOVE remove alternative (csw=%f)", (csweight), cs) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(1, depth, "_pending.final updown: %s", (pkg) ) | self.trace(1, "_pending.final updown: %s", (pkg) ) | def _pending(self, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth if traceVerbosity<4: trace(1, depth, "_pending(pw=%f, yw=%f)", (self._pruneweight, self._yieldweight)) else: trace(4, depth, "_pending(%s, pw=%f, yw=%f)", (pending, self._pruneweight, self._yieldweight... |
trace(2, depth, "_upgrade(%s)", (pkgs)) | self.trace(2, "_upgrade(%s)", (pkgs)) | def _upgrade(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(2, depth, "_upgrade(%s)", (pkgs)) |
trace(1, depth, "_upgrade: add %s (pw=%f)", (pkg, pruneweight)) | self.trace(1, "_upgrade: add %s (pw=%f)", (pkg, pruneweight)) | def _upgrade(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(2, depth, "_upgrade(%s)", (pkgs)) |
trace(2,depth,"_upgrade added %s (csw=%f < w=%f)", (pkg, csweight, weight), cs) | self.trace(2, "_upgrade added %s (csw=%f < w=%f)", (pkg, csweight, weight), cs) | def _upgrade(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(2, depth, "_upgrade(%s)", (pkgs)) |
trace(3,depth,"_upgrade not added %s (csw=%f >= w=%f)", (pkg, csweight, weight)) | self.trace(3, "_upgrade not added %s (csw=%f >= w=%f)", (pkg, csweight, weight)) | def _upgrade(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(2, depth, "_upgrade(%s)", (pkgs)) |
trace(1, depth, "_upgrade: undo %s %s", (op,pkg)) | self.trace(1, "_upgrade: undo %s %s", (op,pkg)) | def _upgrade(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(2, depth, "_upgrade(%s)", (pkgs)) |
trace(2,depth,"_upgrade undid %s %s (csw=%f < w=%f)", (op, pkg, csweight, weight), cs) | self.trace(2, "_upgrade undid %s %s (csw=%f < w=%f)", (op, pkg, csweight, weight), cs) | def _upgrade(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(2, depth, "_upgrade(%s)", (pkgs)) |
trace(3,depth,"_upgrade kept %s %s (csw=%f => w=%f)", (op, pkg, csweight, weight)) | self.trace(3, "_upgrade kept %s %s (csw=%f => w=%f)", (op, pkg, csweight, weight)) | def _upgrade(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(2, depth, "_upgrade(%s)", (pkgs)) |
trace(1, depth, "_fix()") | self.trace(1, "_fix()") | def _fix(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_fix()") |
trace(3, depth, "feasible _fix install alternative (csw=%f)", (csweight), cs) | self.trace(3, "feasible _fix install alternative (csw=%f)", (csweight), cs) | def _fix(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_fix()") |
trace(3, depth, "feasible _fix remove alternative (csw=%f)", (csweight), cs) | self.trace(3, "feasible _fix remove alternative (csw=%f)", (csweight), cs) | def _fix(self, pkgs, pending): trans = self._trans changeset = self._changeset locked = self._locked depth = self._depth pruneweight = self._pruneweight trace(1, depth, "_fix()") |
if traceVerbosity>=7: trace(7, 0, "getNecessary(%s) -> %s", (pkg, sorted(necdct.keys()))) | if traceVerbosity>=7: print " | 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: trace(7, 0, "getNecessitates(%s) -> %s", (pkg, sorted(necdct.keys()))) | if traceVerbosity>=7: print " | 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: trace(7, 0, "getProhibits(%s) -> %s", (pkg, sorted(blues.keys()))) | if traceVerbosity>=7: print " | 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... |
seen = {} | bonusvalue = {} bonusdeps = {} | 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... |
sb[pkg] = -30*(len(path)-1) | if pathlen > 1: bonusvalue[pkg] = -30*(pathlen-1) deps = bonusdeps.setdefault(pkg, {}) for pathpkg in path[1:]: deps[pathpkg] = True | 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... |
prvpkg in upgmap and prvpkg not in seen and | prvpkg in upgmap and prvpkg not in path and | 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... |
self.getPriority(upgpkg)): sb[pkg] = -30*(len(path)-1) | self.getPriority(prvpkg)): if pathlen > 1: bonusvalue[pkg] = -30*(pathlen-1) deps = bonusdeps.setdefault(pkg, {}) for pathpkg in path[1:-1]: deps[pathpkg] = True | 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 sb: stablebonus[bonuspkg] = sb | if bonusvalue: lst = [(bonusvalue[pkg], bonusdeps[pkg]) for pkg in bonusvalue] lst.sort() stablebonus[bonuspkg] = lst | 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... |
lst = [sb[upgpkg] for upgpkg in sb if upgpkg not in changeset] if lst: weight += min(lst) | for bonusvalue, bonusdeps in sb: for deppkg in bonusdeps: if deppkg in changeset: break else: weight += bonusvalue break | def getWeight(self, changeset): weight = 0 upgrading = self._upgrading upgraded = self._upgraded sortbonus = self._sortbonus stablebonus = self._stablebonus |
else: weight += self._weighInstallNotUpdown | else: weight += self._weighInstallation(self.getPriority(pkg)) | def getWeight(self, changeset): weight = 0 upgrading = self._upgrading upgraded = self._upgraded downgraded = self._downgraded sortbonus = self._sortbonus |
_weighInstallNotUpdown = 3 | def getBestUpdownDeltaWeight(self, pkg): weight = self._bestUpdownDeltaWeight.get(pkg); if weight is not None: return weight | |
_weighInstallNotUpdown = 1 | def getWeight(self, changeset): weight = 0 for pkg in changeset: if changeset[pkg] is REMOVE: weight += 1 else: weight += 5 return weight | |
self._updown(prvpkg, changeset, locked, pruneweight, depth, force=1) | task = self._updown(prvpkg, changeset, locked, pruneweight, depth, force=1) for res in task: yield res | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
self._remove(prvpkg, changeset, locked, pending, pruneweight, depth) | task = self._remove(prvpkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
self._updown(cnfpkg, changeset, locked, pruneweight, depth, force=1) | task = self._updown(cnfpkg, changeset, locked, pruneweight, depth, force=1) for res in task: yield res | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
self._remove(cnfpkg, changeset, locked, pending, pruneweight, depth) | task = self._remove(cnfpkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
self._remove(namepkg, changeset, locked, pending, pruneweight, depth) | task = self._remove(namepkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
self._install(prvpkgs.popitem()[0], changeset, locked, pending, pruneweight, depth) | task = self._install(prvpkgs.popitem()[0], changeset, locked, pending, pruneweight, depth) for res in task: yield res | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
self._pending(changeset, locked, pending, pruneweight, depth) | task = self._pending(changeset, locked, pending, pruneweight, depth) for res in task: yield res | def _install(self, pkg, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_install(%s, pw=%f)", (pkg, pruneweight)) |
self._updown(reqpkg, changeset, locked, pruneweight, depth, force=1) | task = self._updown(reqpkg, changeset, locked, pruneweight, depth, force=1) 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)) |
self._remove(reqpkg, changeset, locked, pending, pruneweight, depth) | task = self._remove(reqpkg, 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)) |
self._pending(changeset, locked, pending, pruneweight, depth) | 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)) |
self._install(upgpkg, cs, lk, None, pruneweight, depth) | task = self._install(upgpkg, cs, lk, None, pruneweight, depth) for res in task: yield res | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
self._install(dwnpkg, cs, lk, None, pruneweight, depth) | task = self._install(dwnpkg, cs, lk, None, pruneweight, depth) for res in task: yield res | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
self._remove(pkg, cs, lk, None, pruneweight, depth) | task = self._remove(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | def _updown(self, pkg, changeset, locked, pruneweight, depth=0, force=0): depth += 1 trace(1, depth, "_updown(%s, pw=%f, f=%d)", (pkg, pruneweight, force)) |
self._install(prvpkg, cs, lk, None, _pruneweight, depth) | task = self._install(prvpkg, cs, lk, None, _pruneweight, depth) for res in task: yield res | 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)) |
self._install(prvpkgs[0], changeset, locked, pending, pruneweight, depth) | task = self._install(prvpkgs[0], changeset, locked, pending, pruneweight, depth) for res in task: yield res | 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)) |
self._updown(reqpkg, changeset, locked, pruneweight, depth, 1) | task = self._updown(reqpkg, changeset, locked, pruneweight, depth, 1) for res in task: yield res | 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)) |
self._remove(reqpkg, changeset, locked, pending, pruneweight, depth) | task = self._remove(reqpkg, changeset, locked, pending, pruneweight, depth) for res in task: yield res | 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)) |
self._updown(reqpkg, cs, lk, pruneweight, depth, force=1) | task = self._updown(reqpkg, cs, lk, pruneweight, depth, force=1) for res in task: yield res | 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)) |
self._remove(reqpkg, cs, lk, None, pruneweight, depth) | task = self._remove(reqpkg, cs, lk, None, pruneweight, depth) for res in task: yield res | 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)) |
self._updown(pkg, changeset, locked, pruneweight, depth) | task = self._updown(pkg, changeset, locked, pruneweight, depth) for res in task: yield res | 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)) |
self._install(pkg, cs, lk, None, pruneweight, depth) | task = self._install(pkg, cs, lk, None, pruneweight, depth) for res in task: pass | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
self._install(pkg, cs, lk, None, pruneweight, depth) | task = self._install(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
self._remove(pkg, cs, lk, None, pruneweight, depth) | task = self._remove(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | def _upgrade(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(2, depth, "_upgrade(%s)", (pkgs)) |
self._install(pkg, cs, lk, None, pruneweight, depth) | task = self._install(pkg, cs, lk, None, pruneweight, depth) for res in task: yield res | def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_fix()") |
self._remove(pkg, cs, lk, None, pruneweight, depth) self._updown(pkg, cs, lk, pruneweight, depth) | 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 | def _fix(self, pkgs, changeset, locked, pending, pruneweight, depth=0): depth += 1 trace(1, depth, "_fix()") |
self._install(pkg, changeset, locked, pending, WEIGHT_NONE) | task = self._install(pkg, changeset, locked, pending, WEIGHT_NONE) for res in task: pass | def run(self): |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.