fedrq.release_repo

Warning

The fedrq.release_repo is a private, unstable API

Classes:

• AliasRepoG –
• BaseurlRepoG –
• CoprRepoG –
• FileRepoG –
• MirrorlistRepoG –
• MultiNameG –
• RepoG –

  Base class containing a repo group to load. These can be added to a Repos

• Repos –

  Immutable mapping like class of RepoG types.

• SimpleRepoG –
• SourceRepoG –

Attributes:

• DefaultRepoGs –

DefaultRepoGs module-attribute

DefaultRepoGs = Repos(
    {
        "file": FileRepoG,
        "copr": CoprRepoG,
        "repo": SimpleRepoG,
        "baseurl": BaseurlRepoG,
        "mirrorlist": MirrorlistRepoG,
        "source-repos": SourceRepoG,
    }
)

AliasRepoG

AliasRepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: RepoG

Methods:

• from_str –
• from_str_mapping –
• load –
• validate –

Attributes:

• final (RepoG) –
• fmt_str (str) –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

final instance-attribute

final: RepoG

fmt_str instance-attribute

fmt_str: str

from_str classmethod

from_str(fmt_str: str, class_name: str) -> type[AliasRepoG]

Source code in src/fedrq/release_repo.py

@classmethod
def from_str(cls, fmt_str: str, class_name: str) -> type[AliasRepoG]:
    dct = dict(
        __doc__=f"Load a repo from the {fmt_str!r} alias",
        __module__=__name__,
        fmt_str=fmt_str,
    )
    typ = type(f"{class_name.upper()}AliasRepoG", (cls,), dct)
    return typ

from_str_mapping classmethod

from_str_mapping(
    mapping: dict[str, str],
) -> dict[str, type[AliasRepoG]]

Source code in src/fedrq/release_repo.py

@classmethod
def from_str_mapping(cls, mapping: dict[str, str]) -> dict[str, type[AliasRepoG]]:
    return {name: cls.from_str(fmt_str, name) for name, fmt_str in mapping.items()}

load

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None:
    self.final.load(base_maker, config, release)

validate

validate() -> None

Source code in src/fedrq/release_repo.py

def validate(self) -> None:
    super().validate()
    expanded = self.fmt_str.format(*self.args.split(";"))
    self.final = self.container.get_repo(expanded)

BaseurlRepoG

BaseurlRepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: RepoG

Methods:

• load –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

load

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None:
    url, _, key = self.args.partition(";")
    repoid = _clean_invalid(url, self._ALLOWED_REPOID_CHARS, "_")
    repo_kwargs: dict[str, Any] = {
        self._ATTR: ([url] if self._COERCE_TO_LIST else url),
        "gpgcheck": bool(key),
        "name": repoid,
    }
    if key:
        repo_kwargs["gpgkey"] = key
    base_maker.create_repo(repoid, **repo_kwargs)

CoprRepoG

CoprRepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: RepoG

Methods:

• load –

Attributes:

• url (str) –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

url instance-attribute

url: str

load

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None:
    self.url = release._copr_repo(self.args, config.copr_baseurl)
    with _get_file(self.url) as path:
        base_maker._read_repofile_new(path, True)

FileRepoG

FileRepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: RepoG

Methods:

• load –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

load

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None:
    with _get_file(self.args) as path:
        base_maker.read_repofile(path)

MirrorlistRepoG

MirrorlistRepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: BaseurlRepoG

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

MultiNameG

MultiNameG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: _NoArgRepoG

Methods:

• from_names –
• load –
• validate –

Attributes:

• repogs (list[RepoG]) –
• repos (Sequence[str]) –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

repogs instance-attribute

repogs: list[RepoG]

repos class-attribute instance-attribute

repos: Sequence[str] = ()

from_names classmethod

from_names(
    class_name: str, names: Sequence[str] | str
) -> type[MultiNameG]

Source code in src/fedrq/release_repo.py

@classmethod
def from_names(
    cls, class_name: str, names: Sequence[str] | str
) -> type[MultiNameG]:
    dct = dict(
        __doc__=f"Load the following repos: {names}",
        __module__=__name__,
        repos=[names] if isinstance(names, str) else names,
    )
    typ = type(f"{class_name.upper()}MultiNameG", (cls,), dct)
    return typ

load

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None:
    for repog in self.repogs:
        repog.load(base_maker, config, release)

validate

validate()

Source code in src/fedrq/release_repo.py

def validate(self):
    super().validate()
    self.repogs = [self.container.get_repo(repo) for repo in self.repos]

RepoG

RepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Base class containing a repo group to load. These can be added to a Repos container class.

Methods:

• err –
• err_fmt –
• load –
• validate –

Attributes:

• args (str) –
• config (RQConfig) –
• container (Repos) –
• name (str) –
• release (Release) –
• seperator (str) –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

args instance-attribute

args: str = args

config instance-attribute

config: RQConfig

container instance-attribute

container: Repos = container or Repos({})

name instance-attribute

name: str = name

release instance-attribute

release: Release

seperator instance-attribute

seperator: str = seperator

err

err(msg: str, from_value: Any = ...) -> NoReturn

Source code in src/fedrq/release_repo.py

def err(self, msg: str, from_value: Any = ...) -> NoReturn:
    if from_value == ...:
        raise self.err_fmt(msg)
    else:
        raise self.err_fmt(msg) from from_value

err_fmt

err_fmt(msg: str) -> ConfigError

Source code in src/fedrq/release_repo.py

def err_fmt(self, msg: str) -> ConfigError:
    return ConfigError(msg)

load abstractmethod

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

@abc.abstractmethod
def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None: ...

validate

validate() -> None

Source code in src/fedrq/release_repo.py

def validate(self) -> None:
    if not self.seperator and not self.args:
        self.err("Expected an argument")

Repos

Repos(
    repo_classes: Mapping[
        str, Sequence[str] | str | type[RepoG]
    ],
)

Bases: Mapping[str, type[RepoG]]

Immutable mapping like class of RepoG types. Converts repo aliases (strings) and list of repos in RepoG objects. Allows merging and adding other Repos objects.

Methods:

• get_repo –
• new –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    repo_classes: Mapping[str, Sequence[str] | str | type[RepoG]],
) -> None:
    self.__data: dict[str, type[RepoG]] = {
        name: (
            repos
            if isinstance(repos, type) and issubclass(repos, RepoG)
            else self._FALLBACK_FACTORY(name, repos)
        )
        for name, repos in repo_classes.items()
    }

get_repo

get_repo(key: str) -> RepoG

Source code in src/fedrq/release_repo.py

def get_repo(self, key: str) -> RepoG:
    if key.startswith("@"):
        name, seperator, args = key.partition(":")
        try:
            typ = self[name[1:]]
        except KeyError:
            raise ConfigError(f"{key} is not a valid repository class") from None
        return typ(name, seperator, args, self)
    # Repo groups are special cased to maintain backwards compatibility
    elif key in self.keys() and issubclass(self[key], self._ALLOWED_PLAIN):
        return self[key](key, "", "", self)
    else:
        return self._DEFAULT("", "", key, self)

new

new(
    other: Mapping[str, Sequence[str] | type[RepoG]],
) -> Repos

Source code in src/fedrq/release_repo.py

def new(self, other: Mapping[str, Sequence[str] | type[RepoG]]) -> Repos:
    return self | other

SimpleRepoG

SimpleRepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: RepoG

Methods:

• load –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

load

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None:
    try:
        base_maker.enable_repo(self.args)
    except ValueError:
        self.err(f"No repo named {self.args}", None)

SourceRepoG

SourceRepoG(
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
)

Bases: _NoArgRepoG

Methods:

• load –

Source code in src/fedrq/release_repo.py

def __init__(
    self,
    name: str,
    seperator: str,
    args: str,
    container: Repos | None = None,
) -> None:
    self.name = name
    self.seperator = seperator
    self.args = args
    self.container = container or Repos({})
    self.validate()

load

load(
    base_maker: BaseMakerBase,
    config: RQConfig,
    release: Release,
) -> None

Source code in src/fedrq/release_repo.py

def load(
    self, base_maker: BaseMakerBase, config: RQConfig, release: Release
) -> None:
    base_maker.enable_source_repos()