Skip to content

fedrq.backends.base

Modules:

  • experimental –

    This module (and the other experimental modules in fedrq) are not meant for public use.

Classes:

Attributes:

PackageQueryAlias module-attribute 

PackageQueryAlias: TypeAlias = PackageQueryCompat

RepoqueryAlias module-attribute 

RepoqueryAlias: TypeAlias = RepoqueryBase

BackendMod

Bases: Protocol

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

Attributes:

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

Methods:

  • create_repo –

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

  • disable_repo –

    Disable a repo by its id.

  • enable_repo –

    Enable a repo by its id.

  • enable_repos –

    Enable a list of repositories by their repoid.

  • enable_source_repos –

    Enable the corresponding -source repos of the currently enabled

  • fill_sack –

    Fill the sack and returns the Base object.

  • load_changelogs –

    Load changelog metadata

  • load_filelists –

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

  • load_release_repos –

    Load the repositories from a fedrq.config.Release object

  • read_repofile –

    Load repositories from a repo file

  • read_system_repos –

    Load system repositories into the base object.

  • repolist –

    List available repoids.

  • set –

    Set configuration options. Must be called before reading repos.

  • set_var –

    Set substitutions (e.g. arch, basearch, releasever).

  • sets –

    Set options on the base object

Attributes:

Source code in src/fedrq/backends/base/__init__.py 
288
289
def __init__(self, base=None) -> None:
    self.base = base

backend abstractmethod property 

backend: BackendMod

Return the backend’s module

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:

  • repoid (str) –

    Repository ID

  • kwargs (Any, default: {} ) –

    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 
434
435
436
437
438
439
440
441
442
443
444
445
@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 
335
336
337
338
339
340
341
@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 
328
329
330
331
332
333
@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 
321
322
323
324
325
326
@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 
463
464
465
466
467
468
@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 
299
300
301
302
303
304
305
306
307
308
309
310
311
@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:

  • enable (bool, default: True ) –

    Whether to enable or disable filelists

Source code in src/fedrq/backends/base/__init__.py 
398
399
400
401
402
403
404
405
406
@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:

  • enable (bool, default: True ) –

    Whether to enable or disable filelists

Source code in src/fedrq/backends/base/__init__.py 
387
388
389
390
391
392
393
394
395
396
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:

  • release (Release) –

    Release object

  • set_releasever (bool, default: True ) –

    Whether to set the $releasever based on the release or just leave it alone

Source code in src/fedrq/backends/base/__init__.py 
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
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.repo_name in {"@base", "base"}
                and 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 
343
344
345
346
347
@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 
313
314
315
316
317
318
319
@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]

List available repoids.

Parameters:

  • enabled (bool | None, default: None ) –

    Only show enabled repositories

Source code in src/fedrq/backends/base/__init__.py 
454
455
456
457
458
459
460
461
@abc.abstractmethod
def repolist(self, enabled: bool | None = None) -> list[str]:
    """
    List available repoids.

    Args:
        enabled: Only show enabled repositories
    """

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 
349
350
351
352
353
@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 
355
356
357
358
359
360
@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:

  • conf (dict[str, Any]) –

    A dict of configuration options. Call self.set() for each k-v pair.

  • substitutions (dict[str, Any]) –

    A dict of substitutions/vars options. Call self.set_var() for each k-v pair.

Source code in src/fedrq/backends/base/__init__.py 
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
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!

Attributes:

author instance-attribute 

author: str

date instance-attribute 

date: date

text instance-attribute 

text: str

NEVRAFormsCompat

Bases: Protocol

Attributes:

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

Methods:

Attributes:

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 
202
203
204
def remote_location(
    self, schemes: Collection[str] | None = ("http", "ftp", "file", "https")
) -> str | None: ...

PackageQueryCompat

Bases: Iterable[_PackageT_co], Generic[_PackageT_co]

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

Methods:

  • difference –

    Return the difference between self and other

  • filter –

    Filter the PackageQuery.

  • filterm –

    Filter the PackageQuery in place and return ‘self’.

  • intersection –

    Return the difference between self and other

  • union –

    Combine two PackageQuery objects.

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 
256
257
258
259
260
261
262
263
@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 
227
228
229
230
231
232
233
234
235
236
@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 
238
239
240
241
242
243
244
245
@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 
265
266
267
268
269
270
271
272
@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 
247
248
249
250
251
252
253
254
@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_co, _PackageQueryT_co]

Helpers to query a repository. Provides a unified repoquery interface for different backends. When annotating function parameters and return values, use RepoqueryAlias instead of directly annotating with this type.

Methods:

  • arch_filter –

    Filter a query’s architectures and return it.

  • arch_filterm –

    Filter a query’s architectures in place and return it.

  • get_package –

    Return the latest Package that matches the ‘name’ and ‘arch’.

  • get_subpackages –

    Return a PackageQuery containing the binary RPMS/subpackages produced

  • query –

    Return an inital PackageQuery that’s filtered with **kwargs.

  • resolve_pkg_specs –

    Resolve pkg specs.

Attributes:

Source code in src/fedrq/backends/base/__init__.py 
488
489
def __init__(self, base) -> None:
    self.base = base

backend abstractmethod property 

backend: BackendMod

Return backend module

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: _PackageQueryT,
    arch: str | Iterable[str] | None = None,
) -> _PackageQueryT

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 
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
def arch_filter(
    self: RepoqueryBase[PackageCompat, _PackageQueryT],
    query: _PackageQueryT,
    arch: str | Iterable[str] | None = None,
) -> _PackageQueryT:
    """
    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: _PackageQueryT,
    arch: str | Iterable[str] | None = None,
) -> _PackageQueryT

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 
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
def arch_filterm(
    self: RepoqueryBase[PackageCompat, _PackageQueryT],
    query: _PackageQueryT,
    arch: str | Iterable[str] | None = None,
) -> _PackageQueryT:
    """
    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_co

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 
620
621
622
623
624
625
626
627
628
629
630
631
632
def get_package(
    self,
    name: str,
    arch: str | Iterable[str] | None = None,
) -> _PackageT_co:
    """
    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 cast("_PackageT_co", next(iter(query)))

get_subpackages 

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

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

Parameters:

  • packages (Iterable[_PackageT]) –

    An interable of PackageCompat containing source packages

Source code in src/fedrq/backends/base/__init__.py 
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
def get_subpackages(
    self: RepoqueryBase[_PackageT, _PackageQueryT],
    packages: Iterable[_PackageT],
    **kwargs,
) -> _PackageQueryT:
    """
    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
) -> _PackageQueryT_co

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 
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
def query(
    self,
    *,
    arch: str | Iterable[str] | None = None,
    **kwargs,
) -> _PackageQueryT_co:
    """
    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
) -> _PackageQueryT_co

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:

  • specs (Collection[str]) –

    Package specs to resolve.

  • resolve (bool, default: False ) –

    Whether to resolve file paths or virtual Provides in addition to package specs

  • latest (int | None, default: None ) –

    Limit packages with the same name and arch.

  • with_src (bool, default: True ) –

    Whether to consider .src packages when resolving specs

Source code in src/fedrq/backends/base/__init__.py 
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
@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,
) -> _PackageQueryT_co:
    """
    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`
    """