fedrq.backends.base

PackageQueryAlias module-attribute

PackageQueryAlias: TypeAlias = PackageQueryCompat[
    PackageCompat
]

RepoqueryAlias module-attribute

RepoqueryAlias: TypeAlias = RepoqueryBase[PackageCompat]

BackendMod

Bases: Protocol

Protocol for a fedrq backend module. Each backend module (e.g. fedrq.backends.dnf.backend) implements this interface.

BACKEND instance-attribute

BACKEND: str

BaseMaker instance-attribute

BaseMaker: type[BaseMakerBase]

NEVRAForms instance-attribute

NEVRAForms: type[NEVRAFormsCompat]

Package instance-attribute

Package: type[PackageCompat]

PackageQuery instance-attribute

PackageQuery: type[PackageQueryCompat]

PackageQueryAlias instance-attribute

PackageQueryAlias: type[PackageQueryCompat]

RepoError instance-attribute

RepoError: type[BaseException]

Repoquery instance-attribute

Repoquery: type[RepoqueryBase]

get_changelogs instance-attribute

get_changelogs: _get_changelogs

get_releasever instance-attribute

get_releasever: Callable[[], str]

BaseMakerBase

BaseMakerBase(base=None)

Create a Base object, set configuration, and load repos

Source code in src/fedrq/backends/base/__init__.py

def __init__(self, base=None) -> None:
    self.base = base

backend abstractmethod property

backend: BackendMod

base instance-attribute

base: Any = base

conf abstractmethod property

conf: Any

Return the backend’s Config object

create_repo abstractmethod

create_repo(repoid: str, **kwargs: Any) -> None

Add a Repo object to the repo sack and configure it.

Parameters:

Name	Type	Description	Default
repoid	str	Repository ID	required
kwargs	Any	key-values options that should be set on the Repo object values (like $basearch) will be substituted automatically.	{}

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def create_repo(self, repoid: str, **kwargs: Any) -> None:
    """
    Add a Repo object to the repo sack and configure it.

    Args:
        repoid:
            Repository ID
        kwargs:
            key-values options that should be set on the Repo object values
            (like $basearch) will be substituted automatically.
    """
    ...

disable_repo abstractmethod

disable_repo(
    repo: str, ignore_missing: bool = True
) -> None

Disable a repo by its id. Raise a ValueError if the repoid is not in self.base’s configuration when ignore_missing is False.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def disable_repo(self, repo: str, ignore_missing: bool = True) -> None:
    """
    Disable a repo by its id.
    Raise a ValueError if the repoid is not in `self.base`'s configuration
    when ignore_missing is False.
    """

enable_repo abstractmethod

enable_repo(repo: str) -> None

Enable a repo by its id. Raise a ValueError if the repoid is not in self.base’s configuration.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def enable_repo(self, repo: str) -> None:
    """
    Enable a repo by its id.
    Raise a ValueError if the repoid is not in `self.base`'s configuration.
    """

enable_repos abstractmethod

enable_repos(repos: Collection[str]) -> None

Enable a list of repositories by their repoid. Raise a ValueError if the repoid is not in self.base’s configuration.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def enable_repos(self, repos: Collection[str]) -> None:
    """
    Enable a list of repositories by their repoid.
    Raise a ValueError if the repoid is not in `self.base`'s configuration.
    """

enable_source_repos abstractmethod

enable_source_repos() -> None

Enable the corresponding -source repos of the currently enabled repositories

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def enable_source_repos(self) -> None:
    """
    Enable the corresponding -source repos of the currently enabled
    repositories
    """
    ...

fill_sack abstractmethod

fill_sack(
    *,
    from_cache: bool = False,
    load_system_repo: bool = False
) -> Any

Fill the sack and returns the Base object. The repository configuration shouldn’t be manipulated after this. ‘from_cache’ isn’t currently supported by the libdnf5 backend.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def fill_sack(
    self,
    *,
    from_cache: bool = False,
    load_system_repo: bool = False,
) -> Any:
    """
    Fill the sack and returns the Base object.
    The repository configuration shouldn't be manipulated after this.
    'from_cache' isn't currently supported by the libdnf5 backend.
    """
    ...

load_changelogs abstractmethod

load_changelogs(enable: bool = True) -> None

Load changelog metadata

Parameters:

Name	Type	Description	Default
enable	bool	Whether to enable or disable filelists	True

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def load_changelogs(self, enable: bool = True) -> None:
    """
    Load changelog metadata

    Args:
        enable:
            Whether to enable or disable filelists
    """

load_filelists

load_filelists(enable: bool = True) -> None

Load the filelists if they’re not already enabled by default

Parameters:

Name	Type	Description	Default
enable	bool	Whether to enable or disable filelists	True

Source code in src/fedrq/backends/base/__init__.py

def load_filelists(self, enable: bool = True) -> None:  # noqa: ARG002
    # Can be overriden by subclasses. Purposely isn't an @abstractmethod.
    """
    Load the filelists if they're not already enabled by default

    Args:
        enable:
            Whether to enable or disable filelists
    """
    return None

load_release_repos

load_release_repos(
    release: Release, set_releasever: bool = True
) -> None

Load the repositories from a fedrq.config.Release object

Parameters:

Name	Type	Description	Default
release	Release	Release object	required
set_releasever	bool	Whether to set the $releasever based on the release or just leave it alone	True

Source code in src/fedrq/backends/base/__init__.py

def load_release_repos(self, release: Release, set_releasever: bool = True) -> None:
    """
    Load the repositories from a fedrq.config.Release object

    Args:
        release:
            [`Release`][fedrq.config.Release] object
        set_releasever:
            Whether to set the `$releasever` based on the release or just
            leave it alone
    """
    if set_releasever:
        self.set_var("releasever", release.version)
    if release.release_config.system_repos:
        self.read_system_repos(
            disable=not release.release_config.append_system_repos
        )
    for path in release.release_config.full_def_paths:
        with importlib.resources.as_file(path) as fp:
            LOG.debug("Reading %s", fp)
            self._read_repofile_new(fp)
    release.repog.load(self, release.config, release)

read_repofile abstractmethod

read_repofile(file: StrPath) -> None

Load repositories from a repo file

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def read_repofile(self, file: StrPath) -> None:
    """
    Load repositories from a repo file
    """

read_system_repos abstractmethod

read_system_repos(disable: bool = True) -> None

Load system repositories into the base object. By default, they are all disabled even if ‘enabled=1’ is in the repository configuration.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def read_system_repos(self, disable: bool = True) -> None:
    """
    Load system repositories into the base object.
    By default, they are all disabled even if 'enabled=1' is in the
    repository configuration.
    """

repolist abstractmethod

repolist(enabled: bool | None = None) -> list[str]

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def repolist(self, enabled: bool | None = None) -> list[str]: ...

set abstractmethod

set(key: str, value: Any) -> None

Set configuration options. Must be called before reading repos.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def set(self, key: str, value: Any) -> None:
    """
    Set configuration options. Must be called before reading repos.
    """
    ...

set_var abstractmethod

set_var(key: str, value: Any) -> None

Set substitutions (e.g. arch, basearch, releasever). Needs to be called before reading repos.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def set_var(self, key: str, value: Any) -> None:
    """
    Set substitutions (e.g. arch, basearch, releasever).
    Needs to be called before reading repos.
    """
    ...

sets

sets(
    conf: dict[str, Any], substitutions: dict[str, Any]
) -> None

Set options on the base object

Parameters:

Name	Type	Description	Default
conf	dict[str, Any]	A dict of configuration options. Call self.set() for each k-v pair.	required
substitutions	dict[str, Any]	A dict of substitutions/vars options. Call self.set_var() for each k-v pair.	required

Source code in src/fedrq/backends/base/__init__.py

def sets(self, conf: dict[str, Any], substitutions: dict[str, Any]) -> None:
    """
    Set options on the base object

    Args:
        conf:
            A dict of configuration options. Call self.set() for each k-v
            pair.
        substitutions:
            A dict of substitutions/vars options. Call self.set_var() for
            each k-v pair.
    """
    for opt in conf.items():
        self.set(*opt)
    for opt in substitutions.items():
        self.set_var(*opt)

ChangelogEntry dataclass

ChangelogEntry(text: str, author: str, date: date)

Data class for changelog entry data. Do not instantiate directly!

author instance-attribute

author: str

date instance-attribute

date: date

text instance-attribute

text: str

NEVRAFormsCompat

Bases: Protocol

NA instance-attribute

NA: int

NAME instance-attribute

NAME: int

NEV instance-attribute

NEV: int

NEVR instance-attribute

NEVR: int

NEVRA instance-attribute

NEVRA: int

PackageCompat

Bases: Protocol

Common interface provided by dnf.package.Package and other backends

a property

a: str

arch property

arch: str

buildtime property

buildtime: int

conflicts property

conflicts: Iterable[Any]

debug_name property

debug_name: str

description property

description: str

downloadsize property

downloadsize: int

e property

e: int

enhances property

enhances: Iterable[Any]

epoch property

epoch: int

evr property

evr: str

files property

files: Iterable[str]

from_repo property

from_repo: str

installsize property

installsize: int

installtime property

installtime: int

license property

license: str

location property

location: str

name property

name: str

obsoletes property

obsoletes: Iterable[Any]

packager property

packager: str

provides property

provides: Iterable[Any]

r property

r: str

reason property

reason: Optional[str]

recommends property

recommends: Iterable[Any]

release property

release: str

repo property

repo: Any

Return the package’s Repo object. The exact object depends on which backend is used.

repoid property

repoid: str

reponame property

reponame: str

requires property

requires: Iterable[Any]

size property

size: int

source_debug_name property

source_debug_name: str

source_name property

source_name: Optional[str]

sourcerpm property

sourcerpm: Optional[str]

suggests property

suggests: Iterable[Any]

summary property

summary: str

supplements property

supplements: Iterable[Any]

url property

url: str

v property

v: str

vendor property

vendor: str

version property

version: str

remote_location

remote_location(
    schemes: Collection[str] | None = (
        "http",
        "ftp",
        "file",
        "https",
    )
) -> str | None

Source code in src/fedrq/backends/base/__init__.py

def remote_location(
    self, schemes: Collection[str] | None = ("http", "ftp", "file", "https")
) -> str | None: ...

PackageQueryCompat

Bases: Generic[_PackageT]

Common PackageQuery interface provided by hawkey.Query and other backends. When using to annotate function parameters and return value, use PackageQueryAlias instead of directly annotating with this type.

difference abstractmethod

difference(other) -> Self

Return the difference between self and other (packages that are in self but not other). Depending on the backend, this either modifies ‘self’ in place and returns ‘self’ or returns a new PackageQuery object.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def difference(self, other) -> Self:
    """
    Return the difference between `self` and `other`
    (packages that are in `self` but not `other`).
    Depending on the backend, this either modifies 'self' in place and
    returns 'self' or returns a new PackageQuery object.
    """

filter abstractmethod

filter(**kwargs) -> Self

Filter the PackageQuery. Depending on the backend, this either modifies ‘self’ in place and return ‘self’ or return a new PackageQuery object. See https://dnf.readthedocs.io/en/latest/api_queries.html#dnf.query.Query.filter for the allowed kwargs.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def filter(self, **kwargs) -> Self:
    """
    Filter the PackageQuery.
    Depending on the backend, this either modifies 'self' in place and
    return 'self' or return a new PackageQuery object.
    See https://dnf.readthedocs.io/en/latest/api_queries.html#dnf.query.Query.filter
    for the allowed kwargs.
    """
    ...

filterm abstractmethod

filterm(**kwargs) -> Self

Filter the PackageQuery in place and return ‘self’. See https://dnf.readthedocs.io/en/latest/api_queries.html#dnf.query.Query.filter for the allowed kwargs.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def filterm(self, **kwargs) -> Self:
    """
    Filter the PackageQuery in place and return 'self'.
    See https://dnf.readthedocs.io/en/latest/api_queries.html#dnf.query.Query.filter
    for the allowed kwargs.
    """
    ...

intersection abstractmethod

intersection(other) -> Self

Return the difference between self and other (packages that are in both self and other). Depending on the backend, this either modifies ‘self’ in place and returns ‘self’ or returns a new PackageQuery object.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def intersection(self, other) -> Self:
    """
    Return the difference between `self` and `other`
    (packages that are in both `self` and `other`).
    Depending on the backend, this either modifies 'self' in place and
    returns 'self' or returns a new PackageQuery object.
    """

union abstractmethod

union(other: Any) -> Self

Combine two PackageQuery objects. Depending on the backend, this either modifies ‘self’ in place and returns ‘self’ or returns a new PackageQuery object.

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def union(self, other: Any) -> Self:
    """
    Combine two PackageQuery objects.
    Depending on the backend, this either modifies 'self' in place and
    returns 'self' or returns a new PackageQuery object.
    """
    ...

RepoqueryBase

RepoqueryBase(base)

Bases: Generic[_PackageT]

Helpers to query a repository. Provides a unified repoquery interface for different backends.

Source code in src/fedrq/backends/base/__init__.py

def __init__(self, base) -> None:
    self.base = base

backend abstractmethod property

backend: BackendMod

base instance-attribute

base = base

base_arches abstractmethod property

base_arches: set[str]

Return a set of the system’s arch and basearch.

arch_filter

arch_filter(
    query: PackageQueryCompat,
    arch: str | Iterable[str] | None = None,
) -> PackageQueryCompat[_PackageT]

Filter a query’s architectures and return it. It includes a little more functionality than query.filter(arch=…).

• When arch is None, the query is left untouched.
• If arch equals ‘notsrc’, all src and multilib packages are excluded.
• If arch equals ‘arched’, all noarch, multilib, and source packages are excluded.
• Otherwise, arch is passed to query.filterm(arch=…) and no other validation is preformed.

Source code in src/fedrq/backends/base/__init__.py

def arch_filter(
    self,
    query: PackageQueryCompat,
    arch: str | Iterable[str] | None = None,
) -> PackageQueryCompat[_PackageT]:
    """
    Filter a query's architectures and return it.
    It includes a little more functionality than query.filter(arch=...).

    - When arch is None, the query is left untouched.
    - If arch equals 'notsrc', all src and multilib packages are
      excluded.
    - If arch equals 'arched', all noarch, multilib, and source
      packages are excluded.
    - Otherwise, arch is passed to query.filterm(arch=...) and no other
      validation is preformed.
    """
    if not arch:
        return query
    if arch == "notsrc":
        return query.filter(arch=(*self.base_arches, "noarch"))  # type: ignore
    if arch == "arched":
        return query.filter(arch=list(self.base_arches))
    return query.filter(arch=arch)

arch_filterm

arch_filterm(
    query: PackageQueryCompat,
    arch: str | Iterable[str] | None = None,
) -> PackageQueryCompat[_PackageT]

Filter a query’s architectures in place and return it. It includes a little more functionality than query.filterm(arch=…).

• When arch is None, the query is left untouched.
• If arch equals ‘notsrc’, all src and multilib packages are excluded.
• If arch equals ‘arched’, all noarch, multilib, and source packages are excluded.
• Otherwise, arch is passed to query.filterm(arch=…) and no other validation is preformed.

Source code in src/fedrq/backends/base/__init__.py

def arch_filterm(
    self,
    query: PackageQueryCompat,
    arch: str | Iterable[str] | None = None,
) -> PackageQueryCompat[_PackageT]:
    """
    Filter a query's architectures in place and return it.
    It includes a little more functionality than query.filterm(arch=...).

    - When arch is None, the query is left untouched.
    - If arch equals 'notsrc', all src and multilib packages are
      excluded.
    - If arch equals 'arched', all noarch, multilib, and source
      packages are excluded.
    - Otherwise, arch is passed to query.filterm(arch=...) and no other
      validation is preformed.
    """
    if not arch:
        return query
    if arch == "notsrc":
        return query.filterm(arch=(*self.base_arches, "noarch"))  # type: ignore
    elif arch == "arched":
        return query.filterm(arch=self.base.conf.basearch)
    else:
        return query.filterm(arch=arch)

get_package

get_package(
    name: str, arch: str | Iterable[str] | None = None
) -> _PackageT

Return the latest Package that matches the ‘name’ and ‘arch’. A ValueError is raised when no matches are found.

Source code in src/fedrq/backends/base/__init__.py

def get_package(
    self,
    name: str,
    arch: str | Iterable[str] | None = None,
) -> _PackageT:
    """
    Return the latest Package that matches the 'name' and 'arch'.
    A ValueError is raised when no matches are found.
    """
    query = self.query(name=name, arch=arch, latest=1)
    if len(query) < 1:
        raise ValueError(f"Zero packages found for {name} on {arch}")
    return next(iter(query))

get_subpackages

get_subpackages(
    packages: Iterable[PackageCompat], **kwargs
) -> PackageQueryCompat[_PackageT]

Return a PackageQuery containing the binary RPMS/subpackages produced by {packages}.

Parameters:

Name	Type	Description	Default
packages	Iterable[PackageCompat]	An interable of PackageCompat containing source packages	required

Source code in src/fedrq/backends/base/__init__.py

def get_subpackages(
    self, packages: Iterable[PackageCompat], **kwargs
) -> PackageQueryCompat[_PackageT]:
    """
    Return a PackageQuery containing the binary RPMS/subpackages produced
    by {packages}.

    Args:
        packages:
            An interable of `PackageCompat` containing source packages
    """
    arch = kwargs.get("arch")
    if arch == "src":
        raise ValueError("{arch} cannot be 'src'")
    elif not arch:
        kwargs.setdefault("arch__neq", "src")
    if val := kwargs.pop("sourcerpm", None):
        warn(f"Removing invalid kwarg: 'sourcerpm={val}")

    for package in packages:
        if package.arch != "src":
            raise ValueError(f"{package} must be a source package.")

    sourcerpms = [
        f"{package.name}-{package.version}-{package.release}.src.rpm"
        for package in packages
    ]
    query = self.query(sourcerpm=sourcerpms, **kwargs)
    return query

query

query(
    *, arch: str | Iterable[str] | None = None, **kwargs
) -> PackageQueryCompat[_PackageT]

Return an inital PackageQuery that’s filtered with **kwargs. Further filtering can be applied with the PackageQuery’s filter and filterm methods.

Source code in src/fedrq/backends/base/__init__.py

def query(
    self,
    *,
    arch: str | Iterable[str] | None = None,
    **kwargs,
) -> PackageQueryCompat[_PackageT]:
    """
    Return an inital PackageQuery that's filtered with **kwargs.
    Further filtering can be applied with the PackageQuery's filter and
    filterm methods.
    """
    if kwargs.get("latest") is None:
        kwargs.pop("latest", None)
    query = self._query()
    query.filterm(**kwargs)
    self.arch_filterm(query, arch)
    return query

resolve_pkg_specs abstractmethod

resolve_pkg_specs(
    specs: Collection[str],
    resolve: bool = False,
    latest: int | None = None,
    with_src: bool = True,
    *,
    with_filenames: bool | None = None,
    with_provides: bool | None = None,
    resolve_provides: bool | None = None,
    nevra_forms: list[int] | None = None
) -> PackageQueryCompat[_PackageT]

Resolve pkg specs. See https://dnf.readthedocs.io/en/latest/command_ref.html?highlight=spec#specifying-packages or https://dnf5.readthedocs.io/en/latest/misc/specs.7.html for valid forms.

Parameters:

Name	Type	Description	Default
specs	Collection[str]	Package specs to resolve.	required
resolve	bool	Whether to resolve file paths or virtual Provides in addition to package specs	False
latest	int | None	Limit packages with the same name and arch.	None
with_src	bool	Whether to consider .src packages when resolving specs	True

Source code in src/fedrq/backends/base/__init__.py

@abc.abstractmethod
def resolve_pkg_specs(
    self,
    specs: Collection[str],
    resolve: bool = False,
    latest: int | None = None,
    with_src: bool = True,
    *,
    with_filenames: bool | None = None,
    with_provides: bool | None = None,
    resolve_provides: bool | None = None,
    nevra_forms: list[int] | None = None,
) -> PackageQueryCompat[_PackageT]:
    """
    Resolve pkg specs.
    See
    https://dnf.readthedocs.io/en/latest/command_ref.html?highlight=spec#specifying-packages
    or
    https://dnf5.readthedocs.io/en/latest/misc/specs.7.html
    for valid forms.

    Args:
        specs:
            Package specs to resolve.
        resolve:
            Whether to resolve file paths or virtual Provides in addition
            to package specs
        latest:
            Limit packages with the same name and arch.
        with_src:
            Whether to consider `.src` packages when resolving `specs`
    """
    ...