commitizen 4.2.2__tar.gz → 4.4.0__tar.gz

{commitizen-4.2.2 → commitizen-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: commitizen
-Version: 4.2.2
+Version: 4.4.0
 Summary: Python commitizen client tool
 License: LICENSE
 Keywords: commitizen,conventional,commits,git

commitizen-4.4.0/commitizen/__version__.py

@@ -0,0 +1 @@
+__version__ = "4.4.0"

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/bump.py

@@ -11,7 +11,7 @@ from typing import cast
 from commitizen.defaults import MAJOR, MINOR, PATCH, bump_message, encoding
 from commitizen.exceptions import CurrentVersionNotFoundError
 from commitizen.git import GitCommit, smart_open
-from commitizen.version_schemes import DEFAULT_SCHEME, Increment, Version, VersionScheme
+from commitizen.version_schemes import Increment, Version
 
 VERSION_TYPES = [None, PATCH, MINOR, MAJOR]
 
@@ -142,34 +142,6 @@ def _version_to_regex(version: str) -> str:
     return version.replace(".", r"\.").replace("+", r"\+")
 
 
-def normalize_tag(
-    version: Version | str,
-    tag_format: str,
-    scheme: VersionScheme | None = None,
-) -> str:
-    """The tag and the software version might be different.
-
-    That's why this function exists.
-
-    Example:
-    | tag | version (PEP 0440) |
-    | --- | ------- |
-    | v0.9.0 | 0.9.0 |
-    | ver1.0.0 | 1.0.0 |
-    | ver1.0.0.a0 | 1.0.0a0 |
-    """
-    scheme = scheme or DEFAULT_SCHEME
-    version = scheme(version) if isinstance(version, str) else version
-
-    major, minor, patch = version.release
-    prerelease = version.prerelease or ""
-
-    t = Template(tag_format)
-    return t.safe_substitute(
-        version=version, major=major, minor=minor, patch=patch, prerelease=prerelease
-    )
-
-
 def create_commit_message(
     current_version: Version | str,
     new_version: Version | str,

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/changelog.py

@@ -42,21 +42,13 @@ from jinja2 import (
     Template,
 )
 
-from commitizen import out
-from commitizen.bump import normalize_tag
 from commitizen.cz.base import ChangelogReleaseHook
-from commitizen.defaults import get_tag_regexes
 from commitizen.exceptions import InvalidConfigurationError, NoCommitsFoundError
 from commitizen.git import GitCommit, GitTag
-from commitizen.version_schemes import (
-    DEFAULT_SCHEME,
-    BaseVersion,
-    InvalidVersion,
-)
+from commitizen.tags import TagRules
 
 if TYPE_CHECKING:
     from commitizen.cz.base import MessageBuilderHook
-    from commitizen.version_schemes import VersionScheme
 
 
 @dataclass
@@ -69,50 +61,19 @@ class Metadata:
     unreleased_end: int | None = None
     latest_version: str | None = None
     latest_version_position: int | None = None
+    latest_version_tag: str | None = None
+
+    def __post_init__(self):
+        if self.latest_version and not self.latest_version_tag:
+            # Test syntactic sugar
+            # latest version tag is optional if same as latest version
+            self.latest_version_tag = self.latest_version
 
 
 def get_commit_tag(commit: GitCommit, tags: list[GitTag]) -> GitTag | None:
     return next((tag for tag in tags if tag.rev == commit.rev), None)
 
 
-def tag_included_in_changelog(
-    tag: GitTag,
-    used_tags: list,
-    merge_prerelease: bool,
-    scheme: VersionScheme = DEFAULT_SCHEME,
-) -> bool:
-    if tag in used_tags:
-        return False
-
-    try:
-        version = scheme(tag.name)
-    except InvalidVersion:
-        return False
-
-    if merge_prerelease and version.is_prerelease:
-        return False
-
-    return True
-
-
-def get_version_tags(
-    scheme: type[BaseVersion], tags: list[GitTag], tag_format: str
-) -> list[GitTag]:
-    valid_tags: list[GitTag] = []
-    TAG_FORMAT_REGEXS = get_tag_regexes(scheme.parser.pattern)
-    tag_format_regex = tag_format
-    for pattern, regex in TAG_FORMAT_REGEXS.items():
-        tag_format_regex = tag_format_regex.replace(pattern, regex)
-    for tag in tags:
-        if re.match(tag_format_regex, tag.name):
-            valid_tags.append(tag)
-        else:
-            out.warn(
-                f"InvalidVersion {tag.name} doesn't match configured tag format {tag_format}"
-            )
-    return valid_tags
-
-
 def generate_tree_from_commits(
     commits: list[GitCommit],
     tags: list[GitTag],
@@ -122,13 +83,13 @@ def generate_tree_from_commits(
     change_type_map: dict[str, str] | None = None,
     changelog_message_builder_hook: MessageBuilderHook | None = None,
     changelog_release_hook: ChangelogReleaseHook | None = None,
-    merge_prerelease: bool = False,
-    scheme: VersionScheme = DEFAULT_SCHEME,
+    rules: TagRules | None = None,
 ) -> Iterable[dict]:
     pat = re.compile(changelog_pattern)
     map_pat = re.compile(commit_parser, re.MULTILINE)
     body_map_pat = re.compile(commit_parser, re.MULTILINE | re.DOTALL)
     current_tag: GitTag | None = None
+    rules = rules or TagRules()
 
     # Check if the latest commit is not tagged
     if commits:
@@ -148,8 +109,10 @@ def generate_tree_from_commits(
     for commit in commits:
         commit_tag = get_commit_tag(commit, tags)
 
-        if commit_tag is not None and tag_included_in_changelog(
-            commit_tag, used_tags, merge_prerelease, scheme=scheme
+        if (
+            commit_tag
+            and commit_tag not in used_tags
+            and rules.include_in_changelog(commit_tag)
         ):
             used_tags.append(commit_tag)
             release = {
@@ -343,8 +306,7 @@ def get_smart_tag_range(
 def get_oldest_and_newest_rev(
     tags: list[GitTag],
     version: str,
-    tag_format: str,
-    scheme: VersionScheme | None = None,
+    rules: TagRules,
 ) -> tuple[str | None, str | None]:
     """Find the tags for the given version.
 
@@ -358,22 +320,28 @@ def get_oldest_and_newest_rev(
         oldest, newest = version.split("..")
     except ValueError:
         newest = version
-    newest_tag = normalize_tag(newest, tag_format=tag_format, scheme=scheme)
+    if not (newest_tag := rules.find_tag_for(tags, newest)):
+        raise NoCommitsFoundError("Could not find a valid revision range.")
 
     oldest_tag = None
+    oldest_tag_name = None
     if oldest:
-        oldest_tag = normalize_tag(oldest, tag_format=tag_format, scheme=scheme)
+        if not (oldest_tag := rules.find_tag_for(tags, oldest)):
+            raise NoCommitsFoundError("Could not find a valid revision range.")
+        oldest_tag_name = oldest_tag.name
 
-    tags_range = get_smart_tag_range(tags, newest=newest_tag, oldest=oldest_tag)
+    tags_range = get_smart_tag_range(
+        tags, newest=newest_tag.name, oldest=oldest_tag_name
+    )
     if not tags_range:
         raise NoCommitsFoundError("Could not find a valid revision range.")
 
     oldest_rev: str | None = tags_range[-1].name
-    newest_rev = newest_tag
+    newest_rev = newest_tag.name
 
     # check if it's the first tag created
     # and it's also being requested as part of the range
-    if oldest_rev == tags[-1].name and oldest_rev == oldest_tag:
+    if oldest_rev == tags[-1].name and oldest_rev == oldest_tag_name:
         return None, newest_rev
 
     # when they are the same, and it's also the

commitizen-4.4.0/commitizen/changelog_formats/asciidoc.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import BaseFormat
+
+if TYPE_CHECKING:
+    from commitizen.tags import VersionTag
+
+
+class AsciiDoc(BaseFormat):
+    extension = "adoc"
+
+    RE_TITLE = re.compile(r"^(?P<level>=+) (?P<title>.*)$")
+
+    def parse_version_from_title(self, line: str) -> VersionTag | None:
+        m = self.RE_TITLE.match(line)
+        if not m:
+            return None
+        # Capture last match as AsciiDoc use postfixed URL labels
+        return self.tag_rules.search_version(m.group("title"), last=True)
+
+    def parse_title_level(self, line: str) -> int | None:
+        m = self.RE_TITLE.match(line)
+        if not m:
+            return None
+        return len(m.group("level"))

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/changelog_formats/base.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
 import os
-import re
 from abc import ABCMeta
-from re import Pattern
 from typing import IO, Any, ClassVar
 
 from commitizen.changelog import Metadata
 from commitizen.config.base_config import BaseConfig
-from commitizen.defaults import get_tag_regexes
+from commitizen.tags import TagRules, VersionTag
 from commitizen.version_schemes import get_version_scheme
 
 from . import ChangelogFormat
@@ -28,15 +26,12 @@ class BaseFormat(ChangelogFormat, metaclass=ABCMeta):
         self.config = config
         self.encoding = self.config.settings["encoding"]
         self.tag_format = self.config.settings["tag_format"]
-
-    @property
-    def version_parser(self) -> Pattern:
-        tag_regex: str = self.tag_format
-        version_regex = get_version_scheme(self.config).parser.pattern
-        TAG_FORMAT_REGEXS = get_tag_regexes(version_regex)
-        for pattern, regex in TAG_FORMAT_REGEXS.items():
-            tag_regex = tag_regex.replace(pattern, regex)
-        return re.compile(tag_regex)
+        self.tag_rules = TagRules(
+            scheme=get_version_scheme(self.config.settings),
+            tag_format=self.tag_format,
+            legacy_tag_formats=self.config.settings["legacy_tag_formats"],
+            ignored_tag_formats=self.config.settings["ignored_tag_formats"],
+        )
 
     def get_metadata(self, filepath: str) -> Metadata:
         if not os.path.isfile(filepath):
@@ -63,9 +58,10 @@ class BaseFormat(ChangelogFormat, metaclass=ABCMeta):
                 meta.unreleased_end = index
 
             # Try to find the latest release done
-            version = self.parse_version_from_title(line)
-            if version:
-                meta.latest_version = version
+            parsed = self.parse_version_from_title(line)
+            if parsed:
+                meta.latest_version = parsed.version
+                meta.latest_version_tag = parsed.tag
                 meta.latest_version_position = index
                 break  # there's no need for more info
         if meta.unreleased_start is not None and meta.unreleased_end is None:
@@ -73,7 +69,7 @@ class BaseFormat(ChangelogFormat, metaclass=ABCMeta):
 
         return meta
 
-    def parse_version_from_title(self, line: str) -> str | None:
+    def parse_version_from_title(self, line: str) -> VersionTag | None:
         """
         Extract the version from a title line if any
         """

commitizen-4.4.0/commitizen/changelog_formats/markdown.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import BaseFormat
+
+if TYPE_CHECKING:
+    from commitizen.tags import VersionTag
+
+
+class Markdown(BaseFormat):
+    extension = "md"
+
+    alternative_extensions = {"markdown", "mkd"}
+
+    RE_TITLE = re.compile(r"^(?P<level>#+) (?P<title>.*)$")
+
+    def parse_version_from_title(self, line: str) -> VersionTag | None:
+        m = self.RE_TITLE.match(line)
+        if not m:
+            return None
+        return self.tag_rules.search_version(m.group("title"))
+
+    def parse_title_level(self, line: str) -> int | None:
+        m = self.RE_TITLE.match(line)
+        if not m:
+            return None
+        return len(m.group("level"))

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/changelog_formats/restructuredtext.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import re
 import sys
 from itertools import zip_longest
 from typing import IO, TYPE_CHECKING, Any, Union
@@ -64,31 +63,11 @@ class RestructuredText(BaseFormat):
                 elif unreleased_title_kind and unreleased_title_kind == kind:
                     meta.unreleased_end = index
                 # Try to find the latest release done
-                m = re.search(self.version_parser, title)
-                if m:
-                    matches = m.groupdict()
-                    if "version" in matches:
-                        version = m.group("version")
-                        meta.latest_version = version
-                        meta.latest_version_position = index
-                        break  # there's no need for more info
-                    try:
-                        partial_version = (
-                            f"{matches['major']}.{matches['minor']}.{matches['patch']}"
-                        )
-                        if matches.get("prerelease"):
-                            partial_version = (
-                                f"{partial_version}-{matches['prerelease']}"
-                            )
-                        if matches.get("devrelease"):
-                            partial_version = (
-                                f"{partial_version}{matches['devrelease']}"
-                            )
-                        meta.latest_version = partial_version
-                        meta.latest_version_position = index
-                        break
-                    except KeyError:
-                        pass
+                if version := self.tag_rules.search_version(title):
+                    meta.latest_version = version[0]
+                    meta.latest_version_tag = version[1]
+                    meta.latest_version_position = index
+                    break
         if meta.unreleased_start is not None and meta.unreleased_end is None:
             meta.unreleased_end = (
                 meta.latest_version_position if meta.latest_version else index + 1

commitizen-4.4.0/commitizen/changelog_formats/textile.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import BaseFormat
+
+if TYPE_CHECKING:
+    from commitizen.tags import VersionTag
+
+
+class Textile(BaseFormat):
+    extension = "textile"
+
+    RE_TITLE = re.compile(r"^h(?P<level>\d)\. (?P<title>.*)$")
+
+    def parse_version_from_title(self, line: str) -> VersionTag | None:
+        if not self.RE_TITLE.match(line):
+            return None
+        return self.tag_rules.search_version(line)
+
+    def parse_title_level(self, line: str) -> int | None:
+        m = self.RE_TITLE.match(line)
+        if not m:
+            return None
+        return int(m.group("level"))

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/commands/bump.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import warnings
 from logging import getLogger
+from typing import cast
 
 import questionary
 
@@ -9,6 +10,7 @@ from commitizen import bump, factory, git, hooks, out
 from commitizen.changelog_formats import get_changelog_format
 from commitizen.commands.changelog import Changelog
 from commitizen.config import BaseConfig
+from commitizen.defaults import Settings
 from commitizen.exceptions import (
     BumpCommitFailedError,
     BumpTagFailedError,
@@ -24,6 +26,7 @@ from commitizen.exceptions import (
     NoVersionSpecifiedError,
 )
 from commitizen.providers import get_provider
+from commitizen.tags import TagRules
 from commitizen.version_schemes import (
     Increment,
     InvalidVersion,
@@ -84,7 +87,7 @@ class Bump:
                 )
             )
         self.scheme = get_version_scheme(
-            self.config, arguments["version_scheme"] or deprecated_version_type
+            self.config.settings, arguments["version_scheme"] or deprecated_version_type
         )
         self.file_name = arguments["file_name"] or self.config.settings.get(
             "changelog_file"
@@ -98,18 +101,20 @@ class Bump:
         )
         self.extras = arguments["extras"]
 
-    def is_initial_tag(self, current_tag_version: str, is_yes: bool = False) -> bool:
+    def is_initial_tag(
+        self, current_tag: git.GitTag | None, is_yes: bool = False
+    ) -> bool:
         """Check if reading the whole git tree up to HEAD is needed."""
         is_initial = False
-        if not git.tag_exist(current_tag_version):
+        if not current_tag:
             if is_yes:
                 is_initial = True
             else:
-                out.info(f"Tag {current_tag_version} could not be found. ")
+                out.info("No tag matching configuration could not be found.")
                 out.info(
                     "Possible causes:\n"
                     "- version in configuration is not the current version\n"
-                    "- tag_format is missing, check them using 'git tag --list'\n"
+                    "- tag_format or legacy_tag_formats is missing, check them using 'git tag --list'\n"
                 )
                 is_initial = questionary.confirm("Is this the first tag created?").ask()
         return is_initial
@@ -143,7 +148,6 @@ class Bump:
         except TypeError:
             raise NoVersionSpecifiedError()
 
-        tag_format: str = self.bump_settings["tag_format"]
         bump_commit_message: str = self.bump_settings["bump_message"]
         version_files: list[str] = self.bump_settings["version_files"]
         major_version_zero: bool = self.bump_settings["major_version_zero"]
@@ -221,13 +225,13 @@ class Bump:
                 or self.changelog_config
             )
 
-        current_tag_version: str = bump.normalize_tag(
-            current_version,
-            tag_format=tag_format,
-            scheme=self.scheme,
+        rules = TagRules.from_settings(cast(Settings, self.bump_settings))
+        current_tag = rules.find_tag_for(git.get_tags(), current_version)
+        current_tag_version = getattr(
+            current_tag, "name", rules.normalize_tag(current_version)
         )
 
-        is_initial = self.is_initial_tag(current_tag_version, is_yes)
+        is_initial = self.is_initial_tag(current_tag, is_yes)
 
         if manual_version:
             try:
@@ -239,10 +243,10 @@ class Bump:
                 ) from exc
         else:
             if increment is None:
-                if is_initial:
-                    commits = git.get_commits()
+                if current_tag:
+                    commits = git.get_commits(current_tag.name)
                 else:
-                    commits = git.get_commits(current_tag_version)
+                    commits = git.get_commits()
 
                 # No commits, there is no need to create an empty tag.
                 # Unless we previously had a prerelease.
@@ -280,11 +284,7 @@ class Bump:
                 exact_increment=increment_mode == "exact",
             )
 
-        new_tag_version = bump.normalize_tag(
-            new_version,
-            tag_format=tag_format,
-            scheme=self.scheme,
-        )
+        new_tag_version = rules.normalize_tag(new_version)
         message = bump.create_commit_message(
             current_version, new_version, bump_commit_message
         )

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/commands/changelog.py

@@ -6,7 +6,7 @@ from operator import itemgetter
 from pathlib import Path
 from typing import Callable, cast
 
-from commitizen import bump, changelog, defaults, factory, git, out
+from commitizen import changelog, defaults, factory, git, out
 from commitizen.changelog_formats import get_changelog_format
 from commitizen.config import BaseConfig
 from commitizen.cz.base import ChangelogReleaseHook, MessageBuilderHook
@@ -20,6 +20,7 @@ from commitizen.exceptions import (
     NotAllowed,
 )
 from commitizen.git import GitTag, smart_open
+from commitizen.tags import TagRules
 from commitizen.version_schemes import get_version_scheme
 
 
@@ -53,7 +54,9 @@ class Changelog:
         )
         self.dry_run = args["dry_run"]
 
-        self.scheme = get_version_scheme(self.config, args.get("version_scheme"))
+        self.scheme = get_version_scheme(
+            self.config.settings, args.get("version_scheme")
+        )
 
         current_version = (
             args.get("current_version", config.settings.get("version")) or ""
@@ -73,9 +76,14 @@ class Changelog:
         self.tag_format: str = (
             args.get("tag_format") or self.config.settings["tag_format"]
         )
-        self.merge_prerelease = args.get(
-            "merge_prerelease"
-        ) or self.config.settings.get("changelog_merge_prerelease")
+        self.tag_rules = TagRules(
+            scheme=self.scheme,
+            tag_format=self.tag_format,
+            legacy_tag_formats=self.config.settings["legacy_tag_formats"],
+            ignored_tag_formats=self.config.settings["ignored_tag_formats"],
+            merge_prereleases=args.get("merge_prerelease")
+            or self.config.settings["changelog_merge_prerelease"],
+        )
 
         self.template = (
             args.get("template")
@@ -152,7 +160,6 @@ class Changelog:
         changelog_release_hook: ChangelogReleaseHook | None = (
             self.cz.changelog_release_hook
         )
-        merge_prerelease = self.merge_prerelease
 
         if self.export_template_to:
             return self.export_template()
@@ -168,28 +175,19 @@ class Changelog:
         # Don't continue if no `file_name` specified.
         assert self.file_name
 
-        tags = (
-            changelog.get_version_tags(self.scheme, git.get_tags(), self.tag_format)
-            or []
-        )
+        tags = self.tag_rules.get_version_tags(git.get_tags(), warn=True)
         end_rev = ""
         if self.incremental:
             changelog_meta = self.changelog_format.get_metadata(self.file_name)
             if changelog_meta.latest_version:
-                latest_tag_version: str = bump.normalize_tag(
-                    changelog_meta.latest_version,
-                    tag_format=self.tag_format,
-                    scheme=self.scheme,
-                )
                 start_rev = self._find_incremental_rev(
-                    strip_local_version(latest_tag_version), tags
+                    strip_local_version(changelog_meta.latest_version_tag), tags
                 )
         if self.rev_range:
             start_rev, end_rev = changelog.get_oldest_and_newest_rev(
                 tags,
-                version=self.rev_range,
-                tag_format=self.tag_format,
-                scheme=self.scheme,
+                self.rev_range,
+                self.tag_rules,
             )
         commits = git.get_commits(start=start_rev, end=end_rev, args="--topo-order")
         if not commits and (
@@ -205,8 +203,7 @@ class Changelog:
             change_type_map=change_type_map,
             changelog_message_builder_hook=changelog_message_builder_hook,
             changelog_release_hook=changelog_release_hook,
-            merge_prerelease=merge_prerelease,
-            scheme=self.scheme,
+            rules=self.tag_rules,
         )
         if self.change_type_order:
             tree = changelog.order_changelog_tree(tree, self.change_type_order)

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/commands/init.py

@@ -98,7 +98,7 @@ class Init:
             version_provider = self._ask_version_provider()  # select
             tag = self._ask_tag()  # confirm & select
             version_scheme = self._ask_version_scheme()  # select
-            version = get_version_scheme(self.config, version_scheme)(tag)
+            version = get_version_scheme(self.config.settings, version_scheme)(tag)
             tag_format = self._ask_tag_format(tag)  # confirm & text
             update_changelog_on_bump = self._ask_update_changelog_on_bump()  # confirm
             major_version_zero = self._ask_major_version_zero(version)  # confirm

{commitizen-4.2.2 → commitizen-4.4.0}/commitizen/defaults.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import pathlib
 from collections import OrderedDict
-from collections.abc import Iterable, MutableMapping
+from collections.abc import Iterable, MutableMapping, Sequence
 from typing import Any, TypedDict
 
 # Type
@@ -35,6 +35,8 @@ class Settings(TypedDict, total=False):
     version_scheme: str | None
     version_type: str | None
     tag_format: str
+    legacy_tag_formats: Sequence[str]
+    ignored_tag_formats: Sequence[str]
     bump_message: str | None
     retry_after_failure: bool
     allow_abort: bool
@@ -77,6 +79,8 @@ DEFAULT_SETTINGS: Settings = {
     "version_provider": "commitizen",
     "version_scheme": None,
     "tag_format": "$version",  # example v$version
+    "legacy_tag_formats": [],
+    "ignored_tag_formats": [],
     "bump_message": None,  # bumped v$current_version to $new_version
     "retry_after_failure": False,
     "allow_abort": False,
@@ -138,17 +142,15 @@ bump_message = "bump: version $current_version → $new_version"
 def get_tag_regexes(
     version_regex: str,
 ) -> dict[str, str]:
+    regexs = {
+        "version": version_regex,
+        "major": r"(?P<major>\d+)",
+        "minor": r"(?P<minor>\d+)",
+        "patch": r"(?P<patch>\d+)",
+        "prerelease": r"(?P<prerelease>\w+\d+)?",
+        "devrelease": r"(?P<devrelease>\.dev\d+)?",
+    }
     return {
-        "$version": version_regex,
-        "$major": r"(?P<major>\d+)",
-        "$minor": r"(?P<minor>\d+)",
-        "$patch": r"(?P<patch>\d+)",
-        "$prerelease": r"(?P<prerelease>\w+\d+)?",
-        "$devrelease": r"(?P<devrelease>\.dev\d+)?",
-        "${version}": version_regex,
-        "${major}": r"(?P<major>\d+)",
-        "${minor}": r"(?P<minor>\d+)",
-        "${patch}": r"(?P<patch>\d+)",
-        "${prerelease}": r"(?P<prerelease>\w+\d+)?",
-        "${devrelease}": r"(?P<devrelease>\.dev\d+)?",
+        **{f"${k}": v for k, v in regexs.items()},
+        **{f"${{{k}}}": v for k, v in regexs.items()},
     }