ACIL FM

Nama	Ukuran	Aksi
cli	-	Open
conf	-	Open
db	-	Open
module	-	Open
rpm	-	Open
yum	-	Open
__pycache__	-	Open
base.py	118.17 MB	View DL Edit
callback.py	3.64 MB	View DL Edit
comps.py	24.24 MB	View DL Edit
const.py	2.39 MB	View DL Edit
crypto.py	5.98 MB	View DL Edit
dnssec.py	11.36 MB	View DL Edit
drpm.py	6.2 MB	View DL Edit
exceptions.py	5.89 MB	View DL Edit
goal.py	1.08 MB	View DL Edit
history.py	1.12 MB	View DL Edit
i18n.py	12.03 MB	View DL Edit
lock.py	5.2 MB	View DL Edit
logging.py	10.11 MB	View DL Edit
match_counter.py	3.83 MB	View DL Edit
package.py	11.04 MB	View DL Edit
persistor.py	4.58 MB	View DL Edit
plugin.py	9.33 MB	View DL Edit
pycomp.py	3.52 MB	View DL Edit
query.py	1.62 MB	View DL Edit
repo.py	20.31 MB	View DL Edit
repodict.py	5.04 MB	View DL Edit
sack.py	2.97 MB	View DL Edit
selector.py	1.1 MB	View DL Edit
subject.py	1.12 MB	View DL Edit
transaction.py	4.29 MB	View DL Edit
transaction_sr.py	25.2 MB	View DL Edit
util.py	24.4 MB	View DL Edit
__init__.py	1.36 MB	View DL Edit

Edit file: /lib/python3.9/site-packages/dnf/exceptions.py

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Library 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.
# Copyright 2004 Duke University

"""
Core DNF Errors.
"""

from __future__ import unicode_literals
from dnf.i18n import ucd, _, P_
import dnf.util
import libdnf
import warnings

class DeprecationWarning(DeprecationWarning):
    # :api
    pass

class Error(Exception):
    # :api
    """Base Error. All other Errors thrown by DNF should inherit from this.

:api

"""
    def __init__(self, value=None):
        super(Error, self).__init__()
        self.value = None if value is None else ucd(value)

def __str__(self):
        return "{}".format(self.value)

def __unicode__(self):
        return ucd(self.__str__())

class CompsError(Error):
    # :api
    pass

class ConfigError(Error):
    def __init__(self, value=None, raw_error=None):
        super(ConfigError, self).__init__(value)
        self.raw_error = ucd(raw_error) if raw_error is not None else None

class DatabaseError(Error):
    pass

class DepsolveError(Error):
    # :api
    pass

class DownloadError(Error):
    # :api
    def __init__(self, errmap):
        super(DownloadError, self).__init__()
        self.errmap = errmap

@staticmethod
    def errmap2str(errmap):
        errstrings = []
        for key in errmap:
            for error in errmap[key]:
                msg = '%s: %s' % (key, error) if key else '%s' % error
                errstrings.append(msg)
        return '\n'.join(errstrings)

def __str__(self):
        return self.errmap2str(self.errmap)

class LockError(Error):
    pass

class MarkingError(Error):
    # :api

def __init__(self, value=None, pkg_spec=None):
        """Initialize the marking error instance."""
        super(MarkingError, self).__init__(value)
        self.pkg_spec = None if pkg_spec is None else ucd(pkg_spec)

def __str__(self):
        string = super(MarkingError, self).__str__()
        if self.pkg_spec:
            string += ': ' + self.pkg_spec
        return string

class MarkingErrors(Error):
    # :api
    def __init__(self, no_match_group_specs=(), error_group_specs=(), no_match_pkg_specs=(),
                 error_pkg_specs=(), module_depsolv_errors=()):
        """Initialize the marking error instance."""
        msg = _("Problems in request:")
        if (no_match_pkg_specs):
            msg += "\n" + _("missing packages: ") + ", ".join(no_match_pkg_specs)
        if (error_pkg_specs):
            msg += "\n" + _("broken packages: ") + ", ".join(error_pkg_specs)
        if (no_match_group_specs):
            msg += "\n" + _("missing groups or modules: ") + ", ".join(no_match_group_specs)
        if (error_group_specs):
            msg += "\n" + _("broken groups or modules: ") + ", ".join(error_group_specs)
        if (module_depsolv_errors):
            msg_mod = dnf.util._format_resolve_problems(module_depsolv_errors[0])
            if module_depsolv_errors[1] == \
                    libdnf.module.ModulePackageContainer.ModuleErrorType_ERROR_IN_DEFAULTS:
                msg += "\n" + "\n".join([P_('Modular dependency problem with Defaults:',
                                            'Modular dependency problems with Defaults:',
                                            len(module_depsolv_errors)),
                                        msg_mod])
            else:
                msg += "\n" + "\n".join([P_('Modular dependency problem:',
                                            'Modular dependency problems:',
                                            len(module_depsolv_errors)),
                                        msg_mod])
        super(MarkingErrors, self).__init__(msg)
        self.no_match_group_specs = no_match_group_specs
        self.error_group_specs = error_group_specs
        self.no_match_pkg_specs = no_match_pkg_specs
        self.error_pkg_specs = error_pkg_specs
        self.module_depsolv_errors = module_depsolv_errors

@property
    def module_debsolv_errors(self):
        msg = "Attribute module_debsolv_errors is deprecated. Use module_depsolv_errors " \
              "attribute instead."
        warnings.warn(msg, DeprecationWarning, stacklevel=2)
        return self.module_depsolv_errors

class MetadataError(Error):
    pass

class MiscError(Error):
    pass

class PackagesNotAvailableError(MarkingError):
    def __init__(self, value=None, pkg_spec=None, packages=None):
        super(PackagesNotAvailableError, self).__init__(value, pkg_spec)
        self.packages = packages or []

class PackageNotFoundError(MarkingError):
    pass

class PackagesNotInstalledError(MarkingError):
    def __init__(self, value=None, pkg_spec=None, packages=None):
        super(PackagesNotInstalledError, self).__init__(value, pkg_spec)
        self.packages = packages or []

class ProcessLockError(LockError):
    def __init__(self, value, pid):
        super(ProcessLockError, self).__init__(value)
        self.pid = pid

def __reduce__(self):
        """Pickling support."""
        return (ProcessLockError, (self.value, self.pid))

class ReadOnlyVariableError(Error):
    def __init__(self, value, variable_name):
        super(ReadOnlyVariableError, self).__init__(value)
        self.variable_name = variable_name

class RepoError(Error):
    # :api
    pass

class ThreadLockError(LockError):
    pass

class TransactionCheckError(Error):
    pass

Batal