git_changelog ¤

def __init__(self, namespace: str, project: str, url: str | None = None):
    """Initialization method.

    Parameters:
        namespace: The Bitbucket namespace.
        project: The Bitbucket project.
        url: The Bitbucket URL.
    """
    self.namespace: str = namespace
    """The namespace for the provider."""
    self.project: str = project
    """The project for the provider."""
    self.url: str = url or self.url
    """The URL for the provider."""

def __init__(
    self,
    repository: str | Path,
    *,
    provider: ProviderRefParser | type[ProviderRefParser] | None = None,
    convention: ConventionType | None = None,
    parse_provider_refs: bool = False,
    parse_trailers: bool = False,
    sections: list[str] | None = None,
    # YORE: Bump 3: Remove line.
    bump_latest: bool = False,
    bump: str | None = None,
    zerover: bool = True,
    filter_commits: str | None = None,
    versioning: Literal["semver", "pep440"] = "semver",
):
    """Initialization method.

    Parameters:
        repository: The repository (directory) for which to build the changelog.
        provider: The provider to use (github.com, gitlab.com, etc.).
        convention: The commit convention to use (angular, etc.).
        parse_provider_refs: Whether to parse provider-specific references in the commit messages.
        parse_trailers: Whether to parse Git trailers in the commit messages.
        sections: The sections to render (features, bug fixes, etc.).
        bump_latest: Deprecated, use `bump="auto"` instead. Whether to try and bump latest version to guess new one.
        bump: Whether to try and bump to a given version.
        zerover: Keep major version at zero, even for breaking changes.
        filter_commits: The Git revision-range used to filter commits in git-log (e.g: `v1.0.1..`).
    """
    self.repository: str | Path = repository
    """The repository (directory) for which to build the changelog."""
    self.parse_provider_refs: bool = parse_provider_refs
    """Whether to parse provider-specific references in the commit messages."""
    self.parse_trailers: bool = parse_trailers
    """Whether to parse Git trailers in the commit messages."""
    self.zerover: bool = zerover
    """Whether to keep major version at zero, even for breaking changes."""
    self.filter_commits: str | None = filter_commits
    """The Git revision-range used to filter commits in git-log (e.g: `v1.0.1..`)."""

    # Set provider.
    if not isinstance(provider, ProviderRefParser):
        remote_url = self.get_remote_url()
        split = remote_url.split("/")
        provider_url = "/".join(split[:3])
        namespace, project = "/".join(split[3:-1]), split[-1]
        if callable(provider):
            provider = provider(namespace, project, url=provider_url)
        elif "github" in provider_url:
            provider = GitHub(namespace, project, url=provider_url)
        elif "gitlab" in provider_url:
            provider = GitLab(namespace, project, url=provider_url)
        elif "bitbucket" in provider_url:
            provider = Bitbucket(namespace, project, url=provider_url)
        else:
            provider = None
        self.remote_url: str = remote_url
        """The remote URL of the repository."""
    self.provider = provider
    """The provider to use (github.com, gitlab.com, etc.)."""

    # Set convention.
    if isinstance(convention, str):
        try:
            convention = self.CONVENTION[convention]()
        except KeyError:
            print(  # noqa: T201
                f"git-changelog: no such convention available: {convention}, using default convention",
                file=sys.stderr,
            )
            convention = BasicConvention()
    elif convention is None:
        convention = BasicConvention()
    elif not isinstance(convention, CommitConvention) and issubclass(convention, CommitConvention):
        convention = convention()
    self.convention: CommitConvention = convention
    """The commit convention to use."""

    # Set sections.
    sections = (
        [self.convention.TYPES[section] for section in sections] if sections else self.convention.DEFAULT_RENDER
    )
    self.sections = sections
    """The sections to include in the changelog."""

    # Get version parser based on selected versioning scheme.
    version_parser, version_bumper = {
        "semver": (parse_semver, bump_semver),
        "pep440": (parse_pep440, bump_pep440),
    }[versioning]
    self.version_parser = version_parser
    """The version parser function."""
    self.version_bumper = version_bumper
    """The version bumper function."""

    # Get git log and parse it into list of commits.
    self.raw_log: str = self.get_log()
    """The raw Git log output."""
    self.commits: list[Commit] = self.parse_commits()
    """The list of parsed commits."""
    self.tag_commits: list[Commit] = [commit for commit in self.commits[1:] if commit.tag]
    """The list of tagged commits."""
    self.tag_commits.insert(0, self.commits[0])

    # Apply dates to commits and group them by version.
    v_list, v_dict = self._group_commits_by_version()
    self.versions_list = v_list
    """The list of versions."""
    self.versions_dict = v_dict
    """The dictionary of versions."""

    # YORE: Bump 3: Remove block.
    if bump_latest:
        warnings.warn(
            "`bump_latest=True` is deprecated in favor of `bump='auto'`",
            DeprecationWarning,
            stacklevel=1,
        )
        if bump is None:
            bump = "auto"

    if bump:
        self._bump(bump)

def __init__(
    self,
    commit_hash: str,
    author_name: str = "",
    author_email: str = "",
    author_date: str | datetime = "",
    committer_name: str = "",
    committer_email: str = "",
    committer_date: str | datetime = "",
    refs: str = "",
    subject: str = "",
    body: list[str] | None = None,
    url: str = "",
    *,
    parse_trailers: bool = False,
    parent_hashes: str | list[str] = "",
    commits_map: dict[str, Commit] | None = None,
    version_parser: Callable[[str], tuple[ParsedVersion, str]] | None = None,
):
    """Initialization method.

    Parameters:
        commit_hash: The commit hash.
        author_name: The author name.
        author_email: The author email.
        author_date: The authoring date (datetime or UTC timestamp).
        committer_name: The committer name.
        committer_email: The committer email.
        committer_date: The committing date (datetime or UTC timestamp).
        refs: The commit refs.
        subject: The commit message subject.
        body: The commit message body.
        url: The commit URL.
        parse_trailers: Whether to parse Git trailers.
    """
    if not author_date:
        author_date = datetime.now()  # noqa: DTZ005
    elif isinstance(author_date, str):
        author_date = datetime.fromtimestamp(float(author_date), tz=timezone.utc)
    if not committer_date:
        committer_date = datetime.now()  # noqa: DTZ005
    elif isinstance(committer_date, str):
        committer_date = datetime.fromtimestamp(float(committer_date), tz=timezone.utc)

    self.hash: str = commit_hash
    """The commit hash."""
    self.author_name: str = author_name
    """The author name."""
    self.author_email: str = author_email
    """The author email."""
    self.author_date: datetime = author_date
    """The author date."""
    self.committer_name: str = committer_name
    """The committer name."""
    self.committer_email: str = committer_email
    """The committer email."""
    self.committer_date: datetime = committer_date
    """The committer date."""
    self.subject: str = subject
    """The commit subject."""
    self.body: list[str] = _clean_body(body) if body else []
    """The commit body."""
    self.url: str = url
    """The commit URL."""

    tag = ""
    for ref in refs.split(","):
        ref = ref.strip()  # noqa: PLW2901
        if ref.startswith("tag: "):
            ref = ref.replace("tag: ", "")  # noqa: PLW2901
            if version_parser is None or _is_valid_version(ref, version_parser):
                tag = ref
                break
    self.tag: str = tag
    """The commit tag."""
    self.version: str = tag
    """The commit version."""

    if isinstance(parent_hashes, str):
        parent_hashes = parent_hashes.split()
    self.parent_hashes = parent_hashes
    """The parent commit hashes."""
    self._commits_map = commits_map

    self.text_refs: dict[str, list[Ref]] = {}
    """The commit text references."""
    self.convention: dict[str, Any] = {}
    """The commit message convention."""

    # YORE: Bump 3: Replace `_Trailers()` with `[]` within line.
    self.trailers: list[tuple[str, str]] = _Trailers()
    """The commit trailers."""
    self.body_without_trailers = self.body
    """The commit body without trailers."""

    if parse_trailers:
        self._parse_trailers()