asda?‰PNG  IHDR ? f ??C1 sRGB ??é gAMA ±? üa pHYs ? ??o¨d GIDATx^íüL”÷e÷Y?a?("Bh?_ò???￠§?q5k?*:t0A-o??￥]VkJ￠M??f?±8\k2íll￡1]q?ù???T usr/lib64/python3.6/site-packages/rpm/transaction.py000064400000013523151027627260016276 0ustar00from __future__ import with_statement import sys import rpm from rpm._rpm import ts as TransactionSetCore if sys.version_info[0] == 3: _string_types = str, else: _string_types = basestring, # TODO: migrate relevant documentation from C-side class TransactionSet(TransactionSetCore): _probFilter = 0 def _wrapSetGet(self, attr, val): oval = getattr(self, attr) setattr(self, attr, val) return oval def setVSFlags(self, flags): return self._wrapSetGet('_vsflags', flags) def getVSFlags(self): return self._vsflags def setVfyFlags(self, flags): return self._wrapSetGet('_vfyflags', flags) def getVfyFlags(self): return self._vfyflags def getVfyLevel(self): return self._vfylevel def setVfyLevel(self, flags): return self._wrapSetGet('_vfylevel', flags) def setColor(self, color): return self._wrapSetGet('_color', color) def setPrefColor(self, color): return self._wrapSetGet('_prefcolor', color) def setFlags(self, flags): return self._wrapSetGet('_flags', flags) def setProbFilter(self, ignoreSet): return self._wrapSetGet('_probFilter', ignoreSet) def parseSpec(self, specfile): import rpm._rpmb return rpm._rpmb.spec(specfile) def getKeys(self): keys = [] for te in self: keys.append(te.Key()) # Backwards compatibility goo - WTH does this return a *tuple* ?! if not keys: return None else: return tuple(keys) def _f2hdr(self, item): if isinstance(item, _string_types): with open(item) as f: header = self.hdrFromFdno(f) elif isinstance(item, rpm.hdr): header = item else: header = self.hdrFromFdno(item) return header def addInstall(self, item, key, how="u"): header = self._f2hdr(item) if how not in ['u', 'i']: raise ValueError('how argument must be "u" or "i"') upgrade = (how == "u") if not TransactionSetCore.addInstall(self, header, key, upgrade): raise rpm.error("adding package to transaction failed") def addReinstall(self, item, key): header = self._f2hdr(item) if not TransactionSetCore.addReinstall(self, header, key): raise rpm.error("adding package to transaction failed") def addErase(self, item): hdrs = [] # match iterators are passed on as-is if isinstance(item, rpm.mi): hdrs = item elif isinstance(item, rpm.hdr): hdrs.append(item) elif isinstance(item, (int, _string_types)): if isinstance(item, int): dbi = rpm.RPMDBI_PACKAGES else: dbi = rpm.RPMDBI_LABEL for h in self.dbMatch(dbi, item): hdrs.append(h) if not hdrs: raise rpm.error("package not installed") else: raise TypeError("invalid type %s" % type(item)) for h in hdrs: if not TransactionSetCore.addErase(self, h): raise rpm.error("package not installed") def run(self, callback, data): rc = TransactionSetCore.run(self, callback, data, self._probFilter) # crazy backwards compatibility goo: None for ok, list of problems # if transaction didn't complete and empty list if it completed # with errors if rc == 0: return None res = [] if rc > 0: for prob in self.problems(): item = ("%s" % prob, (prob.type, prob._str, prob._num)) res.append(item) return res def check(self, *args, **kwds): TransactionSetCore.check(self, *args, **kwds) # compatibility: munge problem strings into dependency tuples of doom res = [] for p in self.problems(): # is it anything we need to care about? if p.type == rpm.RPMPROB_CONFLICT: sense = rpm.RPMDEP_SENSE_CONFLICTS elif p.type == rpm.RPMPROB_REQUIRES: sense = rpm.RPMDEP_SENSE_REQUIRES else: continue # strip arch, split to name, version, release nevr = p.altNEVR.rsplit('.', 1)[0] n, v, r = nevr.rsplit('-', 2) # extract the dependency information needs = p._str.split() needname = needs[0] needflags = rpm.RPMSENSE_ANY if len(needs) == 3: needop = needs[1] if '<' in needop: needflags |= rpm.RPMSENSE_LESS if '=' in needop: needflags |= rpm.RPMSENSE_EQUAL if '>' in needop: needflags |= rpm.RPMSENSE_GREATER needver = needs[2] else: needver = "" res.append(((n, v, r), (needname, needver), needflags, sense, p.key)) return res def hdrCheck(self, blob): res, msg = TransactionSetCore.hdrCheck(self, blob) # generate backwards compatibly broken exceptions if res == rpm.RPMRC_NOKEY: raise rpm.error("public key not available") elif res == rpm.RPMRC_NOTTRUSTED: raise rpm.error("public key not trusted") elif res != rpm.RPMRC_OK: raise rpm.error(msg) def hdrFromFdno(self, fd): res, h = TransactionSetCore.hdrFromFdno(self, fd) # generate backwards compatibly broken exceptions if res == rpm.RPMRC_NOKEY: raise rpm.error("public key not available") elif res == rpm.RPMRC_NOTTRUSTED: raise rpm.error("public key not trusted") elif res != rpm.RPMRC_OK: raise rpm.error("error reading package header") return h usr/lib/python3.6/site-packages/dnf/transaction.py000064400000010455151030101070016052 0ustar00# -*- coding: utf-8 -*- # transaction.py # Managing the transaction to be passed to RPM. # # Copyright (C) 2013-2018 Red Hat, Inc. # # This copyrighted material is made available to anyone wishing to use, # modify, copy, or redistribute it subject to the terms and conditions of # the GNU General Public License v.2, or (at your option) any later version. # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY expressed or implied, including the implied warranties of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. You should have received a copy of the # GNU General Public License along with this program; if not, write to the # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. Any Red Hat trademarks that are incorporated in the # source code or documentation are not subject to the GNU General Public # License and may only be used or replicated with the express permission of # Red Hat, Inc. # from __future__ import absolute_import from __future__ import unicode_literals import libdnf.transaction from dnf.i18n import _, C_ # :api - all action constants are considered an API # per-package actions - from libdnf PKG_DOWNGRADE = libdnf.transaction.TransactionItemAction_DOWNGRADE PKG_DOWNGRADED = libdnf.transaction.TransactionItemAction_DOWNGRADED PKG_INSTALL = libdnf.transaction.TransactionItemAction_INSTALL PKG_OBSOLETE = libdnf.transaction.TransactionItemAction_OBSOLETE PKG_OBSOLETED = libdnf.transaction.TransactionItemAction_OBSOLETED PKG_REINSTALL = libdnf.transaction.TransactionItemAction_REINSTALL PKG_REINSTALLED = libdnf.transaction.TransactionItemAction_REINSTALLED PKG_REMOVE = libdnf.transaction.TransactionItemAction_REMOVE PKG_UPGRADE = libdnf.transaction.TransactionItemAction_UPGRADE PKG_UPGRADED = libdnf.transaction.TransactionItemAction_UPGRADED # compatibility PKG_ERASE = PKG_REMOVE # per-package actions - additional PKG_CLEANUP = 101 PKG_VERIFY = 102 PKG_SCRIPTLET = 103 # transaction-wide actions TRANS_PREPARATION = 201 TRANS_POST = 202 # packages that appeared on the system FORWARD_ACTIONS = [ libdnf.transaction.TransactionItemAction_INSTALL, libdnf.transaction.TransactionItemAction_DOWNGRADE, libdnf.transaction.TransactionItemAction_OBSOLETE, libdnf.transaction.TransactionItemAction_UPGRADE, libdnf.transaction.TransactionItemAction_REINSTALL, ] # packages that got removed from the system BACKWARD_ACTIONS = [ libdnf.transaction.TransactionItemAction_DOWNGRADED, libdnf.transaction.TransactionItemAction_OBSOLETED, libdnf.transaction.TransactionItemAction_UPGRADED, libdnf.transaction.TransactionItemAction_REMOVE, # TODO: REINSTALLED may and may not belong here; the same NEVRA is in FORWARD_ACTIONS already # libdnf.transaction.TransactionItemAction_REINSTALLED, ] ACTIONS = { # TRANSLATORS: This is for a single package currently being downgraded. PKG_DOWNGRADE: C_('currently', 'Downgrading'), PKG_DOWNGRADED: _('Cleanup'), # TRANSLATORS: This is for a single package currently being installed. PKG_INSTALL: C_('currently', 'Installing'), PKG_OBSOLETE: _('Obsoleting'), PKG_OBSOLETED: _('Obsoleting'), # TRANSLATORS: This is for a single package currently being reinstalled. PKG_REINSTALL: C_('currently', 'Reinstalling'), PKG_REINSTALLED: _('Cleanup'), # TODO: 'Removing'? PKG_REMOVE: _('Erasing'), # TRANSLATORS: This is for a single package currently being upgraded. PKG_UPGRADE: C_('currently', 'Upgrading'), PKG_UPGRADED: _('Cleanup'), PKG_CLEANUP: _('Cleanup'), PKG_VERIFY: _('Verifying'), PKG_SCRIPTLET: _('Running scriptlet'), TRANS_PREPARATION: _('Preparing'), # TODO: TRANS_POST } # untranslated strings, logging to /var/log/dnf/dnf.rpm.log FILE_ACTIONS = { PKG_DOWNGRADE: 'Downgrade', PKG_DOWNGRADED: 'Downgraded', PKG_INSTALL: 'Installed', PKG_OBSOLETE: 'Obsolete', PKG_OBSOLETED: 'Obsoleted', PKG_REINSTALL: 'Reinstall', PKG_REINSTALLED: 'Reinstalled', # TODO: 'Removed'? PKG_REMOVE: 'Erase', PKG_UPGRADE: 'Upgrade', PKG_UPGRADED: 'Upgraded', PKG_CLEANUP: 'Cleanup', PKG_VERIFY: 'Verified', PKG_SCRIPTLET: 'Running scriptlet', TRANS_PREPARATION: 'Preparing', # TODO: TRANS_POST }