<h2>Edit File - transaction.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/site-packages/rpm/transaction.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">from __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(&#039;_vsflags&#039;, flags)

    def getVSFlags(self):
        return self._vsflags

    def setVfyFlags(self, flags):
        return self._wrapSetGet(&#039;_vfyflags&#039;, flags)

    def getVfyFlags(self):
        return self._vfyflags

    def getVfyLevel(self):
        return self._vfylevel

    def setVfyLevel(self, flags):
        return self._wrapSetGet(&#039;_vfylevel&#039;, flags)

    def setColor(self, color):
        return self._wrapSetGet(&#039;_color&#039;, color)

    def setPrefColor(self, color):
        return self._wrapSetGet(&#039;_prefcolor&#039;, color)

    def setFlags(self, flags):
        return self._wrapSetGet(&#039;_flags&#039;, flags)

    def setProbFilter(self, ignoreSet):
        return self._wrapSetGet(&#039;_probFilter&#039;, 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=&quot;u&quot;):
        header = self._f2hdr(item)

        if how not in [&#039;u&#039;, &#039;i&#039;]:
            raise ValueError(&#039;how argument must be &quot;u&quot; or &quot;i&quot;&#039;)
        upgrade = (how == &quot;u&quot;)

        if not TransactionSetCore.addInstall(self, header, key, upgrade):
            raise rpm.error(&quot;adding package to transaction failed&quot;)

    def addReinstall(self, item, key):
        header = self._f2hdr(item)

        if not TransactionSetCore.addReinstall(self, header, key):
            raise rpm.error(&quot;adding package to transaction failed&quot;)

    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(&quot;package not installed&quot;)
        else:
            raise TypeError(&quot;invalid type %s&quot; % type(item))

        for h in hdrs:
            if not TransactionSetCore.addErase(self, h):
                raise rpm.error(&quot;package not installed&quot;)

    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&#039;t complete and empty list if it completed
        # with errors
        if rc == 0:
            return None

        res = []
        if rc &gt; 0:
            for prob in self.problems():
                item = (&quot;%s&quot; % 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(&#039;.&#039;, 1)[0]
            n, v, r = nevr.rsplit(&#039;-&#039;, 2)

            # extract the dependency information
            needs = p._str.split()
            needname = needs[0]
            needflags = rpm.RPMSENSE_ANY
            if len(needs) == 3:
                needop = needs[1]
                if &#039;&lt;&#039; in needop:
                    needflags |= rpm.RPMSENSE_LESS
                if &#039;=&#039; in needop:
                    needflags |= rpm.RPMSENSE_EQUAL
                if &#039;&gt;&#039; in needop:
                    needflags |= rpm.RPMSENSE_GREATER
                needver = needs[2]
            else:
                needver = &quot;&quot;

            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(&quot;public key not available&quot;)
        elif res == rpm.RPMRC_NOTTRUSTED:
            raise rpm.error(&quot;public key not trusted&quot;)
        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(&quot;public key not available&quot;)
        elif res == rpm.RPMRC_NOTTRUSTED:
            raise rpm.error(&quot;public key not trusted&quot;)
        elif res != rpm.RPMRC_OK:
            raise rpm.error(&quot;error reading package header&quot;)

        return h
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>