From 3d3b90c3cc19db35e709a3a4666c2487a602b8b3 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Fri, 16 May 2025 02:03:30 +0800
Subject: [PATCH 01/12] refactor: improve readability and fix typos

---
 commitizen/bump.py      | 18 ++++++++++--------
 commitizen/changelog.py |  2 +-
 commitizen/cli.py       |  8 ++------
 commitizen/cz/utils.py  | 11 +++++------
 commitizen/defaults.py  |  6 +++---
 commitizen/tags.py      |  6 +-----
 tests/test_changelog.py |  2 +-
 7 files changed, 23 insertions(+), 30 deletions(-)

diff --git a/commitizen/bump.py b/commitizen/bump.py
index 76a8e15893..b8ae18ba64 100644
--- a/commitizen/bump.py
+++ b/commitizen/bump.py
@@ -76,7 +76,7 @@ def update_version_in_files(
     """
     # TODO: separate check step and write step
     updated = []
-    for path, regex in files_and_regexs(files, current_version):
+    for path, regex in _files_and_regexes(files, current_version):
         current_version_found, version_file = _bump_with_regex(
             path,
             current_version,
@@ -99,7 +99,7 @@ def update_version_in_files(
     return updated
 
 
-def files_and_regexs(patterns: list[str], version: str) -> list[tuple[str, str]]:
+def _files_and_regexes(patterns: list[str], version: str) -> list[tuple[str, str]]:
     """
     Resolve all distinct files with their regexp from a list of glob patterns with optional regexp
     """
@@ -128,13 +128,15 @@ def _bump_with_regex(
     pattern = re.compile(regex)
     with open(version_filepath, encoding=encoding) as f:
         for line in f:
-            if pattern.search(line):
-                bumped_line = line.replace(current_version, new_version)
-                if bumped_line != line:
-                    current_version_found = True
-                lines.append(bumped_line)
-            else:
+            if not pattern.search(line):
                 lines.append(line)
+                continue
+
+            bumped_line = line.replace(current_version, new_version)
+            if bumped_line != line:
+                current_version_found = True
+            lines.append(bumped_line)
+
     return current_version_found, "".join(lines)
 
 
diff --git a/commitizen/changelog.py b/commitizen/changelog.py
index 704efe6071..d8ab56069b 100644
--- a/commitizen/changelog.py
+++ b/commitizen/changelog.py
@@ -190,7 +190,7 @@ def process_commit_message(
 def order_changelog_tree(tree: Iterable, change_type_order: list[str]) -> Iterable:
     if len(set(change_type_order)) != len(change_type_order):
         raise InvalidConfigurationError(
-            f"Change types contain duplicates types ({change_type_order})"
+            f"Change types contain duplicated types ({change_type_order})"
         )
 
     sorted_tree = []
diff --git a/commitizen/cli.py b/commitizen/cli.py
index d08afc6706..cfa468787d 100644
--- a/commitizen/cli.py
+++ b/commitizen/cli.py
@@ -637,14 +637,10 @@ def main():
         extra_args = " ".join(unknown_args[1:])
         arguments["extra_cli_args"] = extra_args
 
-    if args.config:
-        conf = config.read_cfg(args.config)
-    else:
-        conf = config.read_cfg()
-
+    conf = config.read_cfg(args.config)
     if args.name:
         conf.update({"name": args.name})
-    elif not args.name and not conf.path:
+    elif not conf.path:
         conf.update({"name": "cz_conventional_commits"})
 
     if args.debug:
diff --git a/commitizen/cz/utils.py b/commitizen/cz/utils.py
index 7bc89673c6..cb79d65d1a 100644
--- a/commitizen/cz/utils.py
+++ b/commitizen/cz/utils.py
@@ -5,6 +5,8 @@
 from commitizen import git
 from commitizen.cz import exceptions
 
+_RE_LOCAL_VERSION = re.compile(r"\+.+")
+
 
 def required_validator(answer, msg=None):
     if not answer:
@@ -17,16 +19,13 @@ def multiple_line_breaker(answer, sep="|"):
 
 
 def strip_local_version(version: str) -> str:
-    return re.sub(r"\+.+", "", version)
+    return _RE_LOCAL_VERSION.sub("", version)
 
 
 def get_backup_file_path() -> str:
     project_root = git.find_git_project_root()
-
-    if project_root is None:
-        project = ""
-    else:
-        project = project_root.as_posix().replace("/", "%")
+    project = project_root.as_posix().replace("/", "%") if project_root else ""
 
     user = os.environ.get("USER", "")
+
     return os.path.join(tempfile.gettempdir(), f"cz.commit%{user}%{project}.backup")
diff --git a/commitizen/defaults.py b/commitizen/defaults.py
index 0b6c28e6a9..1885848618 100644
--- a/commitizen/defaults.py
+++ b/commitizen/defaults.py
@@ -141,7 +141,7 @@ class Settings(TypedDict, total=False):
 def get_tag_regexes(
     version_regex: str,
 ) -> dict[str, str]:
-    regexs = {
+    regexes = {
         "version": version_regex,
         "major": r"(?P<major>\d+)",
         "minor": r"(?P<minor>\d+)",
@@ -150,6 +150,6 @@ def get_tag_regexes(
         "devrelease": r"(?P<devrelease>\.dev\d+)?",
     }
     return {
-        **{f"${k}": v for k, v in regexs.items()},
-        **{f"${{{k}}}": v for k, v in regexs.items()},
+        **{f"${k}": v for k, v in regexes.items()},
+        **{f"${{{k}}}": v for k, v in regexes.items()},
     }
diff --git a/commitizen/tags.py b/commitizen/tags.py
index 2b9a4b091a..c5f06884fe 100644
--- a/commitizen/tags.py
+++ b/commitizen/tags.py
@@ -174,11 +174,7 @@ def include_in_changelog(self, tag: GitTag) -> bool:
             version = self.extract_version(tag)
         except InvalidVersion:
             return False
-
-        if self.merge_prereleases and version.is_prerelease:
-            return False
-
-        return True
+        return not (self.merge_prereleases and version.is_prerelease)
 
     def search_version(self, text: str, last: bool = False) -> VersionTag | None:
         """
diff --git a/tests/test_changelog.py b/tests/test_changelog.py
index b1c7c802e1..511cd1a3df 100644
--- a/tests/test_changelog.py
+++ b/tests/test_changelog.py
@@ -1236,7 +1236,7 @@ def test_order_changelog_tree_raises():
     with pytest.raises(InvalidConfigurationError) as excinfo:
         changelog.order_changelog_tree(COMMITS_TREE, change_type_order)
 
-    assert "Change types contain duplicates types" in str(excinfo)
+    assert "Change types contain duplicated types" in str(excinfo)
 
 
 def test_render_changelog(

From 8241b7e039235d8652d8f7e65f30e9116f59c2d4 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Sat, 17 May 2025 23:26:54 +0800
Subject: [PATCH 02/12] refactor(version_scheme): cleanup

---
 commitizen/version_schemes.py | 94 +++++++++++++++++------------------
 1 file changed, 47 insertions(+), 47 deletions(-)

diff --git a/commitizen/version_schemes.py b/commitizen/version_schemes.py
index 84ded9316e..d5370b2c6c 100644
--- a/commitizen/version_schemes.py
+++ b/commitizen/version_schemes.py
@@ -41,7 +41,9 @@
 
 Increment: TypeAlias = Literal["MAJOR", "MINOR", "PATCH"]
 Prerelease: TypeAlias = Literal["alpha", "beta", "rc"]
-DEFAULT_VERSION_PARSER = r"v?(?P<version>([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.]+)?(\w+)?)"
+_DEFAULT_VERSION_PARSER = re.compile(
+    r"v?(?P<version>([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.]+)?(\w+)?)"
+)
 
 
 @runtime_checkable
@@ -156,7 +158,7 @@ class BaseVersion(_BaseVersion):
     A base class implementing the `VersionProtocol` for PEP440-like versions.
     """
 
-    parser: ClassVar[re.Pattern] = re.compile(DEFAULT_VERSION_PARSER)
+    parser: ClassVar[re.Pattern] = _DEFAULT_VERSION_PARSER
     """Regex capturing this version scheme into a `version` group"""
 
     @property
@@ -265,39 +267,35 @@ def bump(
         if self.local and is_local_version:
             local_version = self.scheme(self.local).bump(increment)
             return self.scheme(f"{self.public}+{local_version}")  # type: ignore
-        else:
-            if not self.is_prerelease:
-                base = self.increment_base(increment)
-            elif exact_increment:
-                base = self.increment_base(increment)
-            else:
-                base = f"{self.major}.{self.minor}.{self.micro}"
-                if increment == PATCH:
-                    pass
-                elif increment == MINOR:
-                    if self.micro != 0:
-                        base = self.increment_base(increment)
-                elif increment == MAJOR:
-                    if self.minor != 0 or self.micro != 0:
-                        base = self.increment_base(increment)
-            dev_version = self.generate_devrelease(devrelease)
-
-            release = list(self.release)
-            if len(release) < 3:
-                release += [0] * (3 - len(release))
-            current_base = ".".join(str(part) for part in release)
-            if base == current_base:
-                pre_version = self.generate_prerelease(
-                    prerelease, offset=prerelease_offset
-                )
-            else:
-                base_version = cast(BaseVersion, self.scheme(base))
-                pre_version = base_version.generate_prerelease(
-                    prerelease, offset=prerelease_offset
-                )
-            build_metadata = self.generate_build_metadata(build_metadata)
-            # TODO: post version
-            return self.scheme(f"{base}{pre_version}{dev_version}{build_metadata}")  # type: ignore
+
+        base = self._get_increment_base(increment, exact_increment)
+        dev_version = self.generate_devrelease(devrelease)
+
+        release = list(self.release)
+        if len(release) < 3:
+            release += [0] * (3 - len(release))
+        current_base = ".".join(str(part) for part in release)
+
+        pre_version = (
+            self if base == current_base else cast(BaseVersion, self.scheme(base))
+        ).generate_prerelease(prerelease, offset=prerelease_offset)
+
+        # TODO: post version
+        return self.scheme(
+            f"{base}{pre_version}{dev_version}{self.generate_build_metadata(build_metadata)}"
+        )  # type: ignore
+
+    def _get_increment_base(
+        self, increment: Increment | None, exact_increment: bool
+    ) -> str:
+        if (
+            not self.is_prerelease
+            or exact_increment
+            or (increment == MINOR and self.micro != 0)
+            or (increment == MAJOR and (self.minor != 0 or self.micro != 0))
+        ):
+            return self.increment_base(increment)
+        return f"{self.major}.{self.minor}.{self.micro}"
 
 
 class Pep440(BaseVersion):
@@ -316,7 +314,7 @@ class SemVer(BaseVersion):
     """
 
     def __str__(self) -> str:
-        parts = []
+        parts: list[str] = []
 
         # Epoch
         if self.epoch != 0:
@@ -364,7 +362,7 @@ def prerelease(self) -> str | None:
         return None
 
     def __str__(self) -> str:
-        parts = []
+        parts: list[str] = []
 
         # Epoch
         if self.epoch != 0:
@@ -373,9 +371,19 @@ def __str__(self) -> str:
         # Release segment
         parts.append(".".join(str(x) for x in self.release))
 
+        if prerelease := self._get_prerelease():
+            parts.append(f"-{prerelease}")
+
+        # Local version segment
+        if self.local:
+            parts.append(f"+{self.local}")
+
+        return "".join(parts)
+
+    def _get_prerelease(self) -> str:
         # Pre-release identifiers
         # See: https://semver.org/spec/v2.0.0.html#spec-item-9
-        prerelease_parts = []
+        prerelease_parts: list[str] = []
         if self.prerelease:
             prerelease_parts.append(f"{self.prerelease}")
 
@@ -387,15 +395,7 @@ def __str__(self) -> str:
         if self.dev is not None:
             prerelease_parts.append(f"dev.{self.dev}")
 
-        if prerelease_parts:
-            parts.append("-")
-            parts.append(".".join(prerelease_parts))
-
-        # Local version segment
-        if self.local:
-            parts.append(f"+{self.local}")
-
-        return "".join(parts)
+        return ".".join(prerelease_parts)
 
 
 DEFAULT_SCHEME: VersionScheme = Pep440

From 3db7754e2a4d9f20e99e12916d11ba3a01821ca9 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Sat, 17 May 2025 19:05:40 +0800
Subject: [PATCH 03/12] refactor(commit): simplify call

---
 commitizen/commands/commit.py | 64 +++++++++++++++--------------------
 1 file changed, 28 insertions(+), 36 deletions(-)

diff --git a/commitizen/commands/commit.py b/commitizen/commands/commit.py
index cb34c41a50..eedf77e079 100644
--- a/commitizen/commands/commit.py
+++ b/commitizen/commands/commit.py
@@ -92,41 +92,36 @@ def manual_edit(self, message: str) -> str:
         os.unlink(file.name)
         return message
 
-    def __call__(self):
-        extra_args: str = self.arguments.get("extra_cli_args", "")
+    def _get_message(self) -> str:
+        if self.arguments.get("retry"):
+            m = self.read_backup_message()
+            if m is None:
+                raise NoCommitBackupError()
+            return m
 
-        allow_empty: bool = "--allow-empty" in extra_args
+        if self.config.settings.get("retry_after_failure") and not self.arguments.get(
+            "no_retry"
+        ):
+            return self.read_backup_message() or self.prompt_commit_questions()
+        return self.prompt_commit_questions()
 
+    def __call__(self):
+        extra_args: str = self.arguments.get("extra_cli_args", "")
         dry_run: bool = self.arguments.get("dry_run")
         write_message_to_file: bool = self.arguments.get("write_message_to_file")
-        manual_edit: bool = self.arguments.get("edit")
+        signoff: bool = self.arguments.get("signoff")
 
-        is_all: bool = self.arguments.get("all")
-        if is_all:
-            c = git.add("-u")
+        if self.arguments.get("all"):
+            git.add("-u")
 
-        if git.is_staging_clean() and not (dry_run or allow_empty):
+        if git.is_staging_clean() and not (dry_run or "--allow-empty" in extra_args):
             raise NothingToCommitError("No files added to staging!")
 
         if write_message_to_file is not None and write_message_to_file.is_dir():
             raise NotAllowed(f"{write_message_to_file} is a directory")
 
-        retry: bool = self.arguments.get("retry")
-        no_retry: bool = self.arguments.get("no_retry")
-        retry_after_failure: bool = self.config.settings.get("retry_after_failure")
-
-        if retry:
-            m = self.read_backup_message()
-            if m is None:
-                raise NoCommitBackupError()
-        elif retry_after_failure and not no_retry:
-            m = self.read_backup_message()
-            if m is None:
-                m = self.prompt_commit_questions()
-        else:
-            m = self.prompt_commit_questions()
-
-        if manual_edit:
+        m = self._get_message()
+        if self.arguments.get("edit"):
             m = self.manual_edit(m)
 
         out.info(f"\n{m}\n")
@@ -138,19 +133,15 @@ def __call__(self):
         if dry_run:
             raise DryRunExit()
 
-        always_signoff: bool = self.config.settings["always_signoff"]
-        signoff: bool = self.arguments.get("signoff")
-
         if signoff:
             out.warn(
                 "signoff mechanic is deprecated, please use `cz commit -- -s` instead."
             )
 
-        if always_signoff or signoff:
+        if self.config.settings["always_signoff"] or signoff:
             extra_args = f"{extra_args} -s".strip()
 
         c = git.commit(m, args=extra_args)
-
         if c.return_code != 0:
             out.error(c.err)
 
@@ -160,11 +151,12 @@ def __call__(self):
 
             raise CommitError()
 
-        if "nothing added" in c.out or "no changes added to commit" in c.out:
+        if any(s in c.out for s in ("nothing added", "no changes added to commit")):
             out.error(c.out)
-        else:
-            with contextlib.suppress(FileNotFoundError):
-                os.remove(self.temp_file)
-            out.write(c.err)
-            out.write(c.out)
-            out.success("Commit successful!")
+            return
+
+        with contextlib.suppress(FileNotFoundError):
+            os.remove(self.temp_file)
+        out.write(c.err)
+        out.write(c.out)
+        out.success("Commit successful!")

From f74589fc2ba7371784ed007923ecf214d9b6d834 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Sat, 17 May 2025 19:43:14 +0800
Subject: [PATCH 04/12] test(commit): when nothing is added to commit

---
 tests/commands/test_commit_command.py | 31 +++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/tests/commands/test_commit_command.py b/tests/commands/test_commit_command.py
index 3a92f5af48..930e1a7a9b 100644
--- a/tests/commands/test_commit_command.py
+++ b/tests/commands/test_commit_command.py
@@ -523,3 +523,34 @@ def test_commit_command_shows_description_when_use_help_option(
 
     out, _ = capsys.readouterr()
     file_regression.check(out, extension=".txt")
+
+
+@pytest.mark.usefixtures("staging_is_clean")
+@pytest.mark.parametrize(
+    "out", ["no changes added to commit", "nothing added to commit"]
+)
+def test_commit_when_nothing_added_to_commit(config, mocker: MockFixture, out):
+    prompt_mock = mocker.patch("questionary.prompt")
+    prompt_mock.return_value = {
+        "prefix": "feat",
+        "subject": "user created",
+        "scope": "",
+        "is_breaking_change": False,
+        "body": "",
+        "footer": "",
+    }
+
+    commit_mock = mocker.patch("commitizen.git.commit")
+    commit_mock.return_value = cmd.Command(
+        out=out,
+        err="",
+        stdout=out.encode(),
+        stderr=b"",
+        return_code=0,
+    )
+    error_mock = mocker.patch("commitizen.out.error")
+
+    commands.Commit(config, {})()
+
+    commit_mock.assert_called_once()
+    error_mock.assert_called_once_with(out)

From c61b9dd6a086708ebae79cd04e7b5f6c3808fc39 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Fri, 16 May 2025 02:18:37 +0800
Subject: [PATCH 05/12] refactor(git): code cleanup and better test coverage

---
 commitizen/git.py | 133 +++++++++++++++-------------------------------
 tests/test_git.py |  32 ++++++-----
 2 files changed, 61 insertions(+), 104 deletions(-)

diff --git a/commitizen/git.py b/commitizen/git.py
index 19ca46b6c3..d0cc901a61 100644
--- a/commitizen/git.py
+++ b/commitizen/git.py
@@ -1,34 +1,14 @@
 from __future__ import annotations
 
 import os
-from enum import Enum
-from os import linesep
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 
 from commitizen import cmd, out
 from commitizen.exceptions import GitCommandError
 
-UNIX_EOL = "\n"
-WINDOWS_EOL = "\r\n"
-
-
-class EOLTypes(Enum):
-    """The EOL type from `git config core.eol`."""
-
-    LF = "lf"
-    CRLF = "crlf"
-    NATIVE = "native"
-
-    def get_eol_for_open(self) -> str:
-        """Get the EOL character for `open()`."""
-        map = {
-            EOLTypes.CRLF: WINDOWS_EOL,
-            EOLTypes.LF: UNIX_EOL,
-            EOLTypes.NATIVE: linesep,
-        }
-
-        return map[self]
+_UNIX_EOL = "\n"
+_WINDOWS_EOL = "\r\n"
 
 
 class GitObject:
@@ -37,9 +17,7 @@ class GitObject:
     date: str
 
     def __eq__(self, other) -> bool:
-        if not hasattr(other, "rev"):
-            return False
-        return self.rev == other.rev  # type: ignore
+        return hasattr(other, "rev") and self.rev == other.rev
 
 
 class GitCommit(GitObject):
@@ -63,6 +41,20 @@ def __init__(
     def message(self):
         return f"{self.title}\n\n{self.body}".strip()
 
+    @classmethod
+    def from_rev_and_commit(cls, rev_and_commit: str) -> GitCommit:
+        rev, parents, title, author, author_email, *body_list = rev_and_commit.split(
+            "\n"
+        )
+        return cls(
+            rev=rev.strip(),
+            title=title.strip(),
+            body="\n".join(body_list).strip(),
+            author=author,
+            author_email=author_email,
+            parents=[p for p in parents.strip().split(" ") if p],
+        )
+
     def __repr__(self):
         return f"{self.title} ({self.rev})"
 
@@ -101,13 +93,11 @@ def tag(
     # according to https://git-scm.com/book/en/v2/Git-Basics-Tagging,
     # we're not able to create lightweight tag with message.
     # by adding message, we make it a annotated tags
-    c = cmd.run(f'git tag {_opt} "{tag if _opt == "" or msg is None else msg}"')
-    return c
+    return cmd.run(f'git tag {_opt} "{tag if _opt == "" or msg is None else msg}"')
 
 
 def add(*args: str) -> cmd.Command:
-    c = cmd.run(f"git add {' '.join(args)}")
-    return c
+    return cmd.run(f"git add {' '.join(args)}")
 
 
 def commit(
@@ -140,24 +130,10 @@ def get_commits(
 ) -> list[GitCommit]:
     """Get the commits between start and end."""
     git_log_entries = _get_log_as_str_list(start, end, args)
-    git_commits = []
-    for rev_and_commit in git_log_entries:
-        if not rev_and_commit:
-            continue
-        rev, parents, title, author, author_email, *body_list = rev_and_commit.split(
-            "\n"
-        )
-        if rev_and_commit:
-            git_commit = GitCommit(
-                rev=rev.strip(),
-                title=title.strip(),
-                body="\n".join(body_list).strip(),
-                author=author,
-                author_email=author_email,
-                parents=[p for p in parents.strip().split(" ") if p],
-            )
-            git_commits.append(git_commit)
-    return git_commits
+    return [
+        GitCommit.from_rev_and_commit(rev_and_commit)
+        for rev_and_commit in filter(None, git_log_entries)
+    ]
 
 
 def get_filenames_in_commit(git_reference: str = ""):
@@ -170,8 +146,7 @@ def get_filenames_in_commit(git_reference: str = ""):
     c = cmd.run(f"git show --name-only --pretty=format: {git_reference}")
     if c.return_code == 0:
         return c.out.strip().split("\n")
-    else:
-        raise GitCommandError(c.err)
+    raise GitCommandError(c.err)
 
 
 def get_tags(
@@ -197,16 +172,11 @@ def get_tags(
     if c.err:
         out.warn(f"Attempting to proceed after: {c.err}")
 
-    if not c.out:
-        return []
-
-    git_tags = [
+    return [
         GitTag.from_line(line=line, inner_delimiter=inner_delimiter)
         for line in c.out.split("\n")[:-1]
     ]
 
-    return git_tags
-
 
 def tag_exist(tag: str) -> bool:
     c = cmd.run(f"git tag --list {tag}")
@@ -231,18 +201,18 @@ def get_tag_message(tag: str) -> str | None:
     return c.out.strip()
 
 
-def get_tag_names() -> list[str | None]:
+def get_tag_names() -> list[str]:
     c = cmd.run("git tag --list")
     if c.err:
         return []
-    return [tag.strip() for tag in c.out.split("\n") if tag.strip()]
+    return list(filter(None, (tag.strip() for tag in c.out.split("\n"))))
 
 
 def find_git_project_root() -> Path | None:
     c = cmd.run("git rev-parse --show-toplevel")
-    if not c.err:
-        return Path(c.out.strip())
-    return None
+    if c.err:
+        return None
+    return Path(c.out.strip())
 
 
 def is_staging_clean() -> bool:
@@ -253,32 +223,19 @@ def is_staging_clean() -> bool:
 
 def is_git_project() -> bool:
     c = cmd.run("git rev-parse --is-inside-work-tree")
-    if c.out.strip() == "true":
-        return True
-    return False
+    return c.out.strip() == "true"
 
 
-def get_eol_style() -> EOLTypes:
+def get_eol_for_open() -> str:
+    # See: https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreeol
     c = cmd.run("git config core.eol")
     eol = c.out.strip().lower()
 
-    # We enumerate the EOL types of the response of
-    # `git config core.eol`, and map it to our enumration EOLTypes.
-    #
-    # It is just like the variant of the "match" syntax.
-    map = {
-        "lf": EOLTypes.LF,
-        "crlf": EOLTypes.CRLF,
-        "native": EOLTypes.NATIVE,
-    }
-
-    # If the response of `git config core.eol` is in the map:
-    if eol in map:
-        return map[eol]
-    else:
-        # The default value is "native".
-        # https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreeol
-        return map["native"]
+    if eol == "lf":
+        return _UNIX_EOL
+    if eol == "crlf":
+        return _WINDOWS_EOL
+    return os.linesep
 
 
 def get_core_editor() -> str | None:
@@ -288,22 +245,18 @@ def get_core_editor() -> str | None:
     return None
 
 
-def smart_open(*args, **kargs):
+def smart_open(*args, **kwargs):
     """Open a file with the EOL style determined from Git."""
-    return open(*args, newline=get_eol_style().get_eol_for_open(), **kargs)
+    return open(*args, newline=get_eol_for_open(), **kwargs)
 
 
 def _get_log_as_str_list(start: str | None, end: str, args: str) -> list[str]:
     """Get string representation of each log entry"""
     delimiter = "----------commit-delimiter----------"
     log_format: str = "%H%n%P%n%s%n%an%n%ae%n%b"
-    git_log_cmd = (
-        f"git -c log.showSignature=False log --pretty={log_format}{delimiter} {args}"
-    )
-    if start:
-        command = f"{git_log_cmd} {start}..{end}"
-    else:
-        command = f"{git_log_cmd} {end}"
+    command_range = f"{start}..{end}" if start else end
+    command = f"git -c log.showSignature=False log --pretty={log_format}{delimiter} {args} {command_range}"
+
     c = cmd.run(command)
     if c.return_code != 0:
         raise GitCommandError(c.err)
diff --git a/tests/test_git.py b/tests/test_git.py
index 8b2fc2b86e..4e4b61ffe2 100644
--- a/tests/test_git.py
+++ b/tests/test_git.py
@@ -79,8 +79,7 @@ def test_get_reachable_tags_with_commits(
     monkeypatch.setenv("LANGUAGE", f"{locale}.UTF-8")
     monkeypatch.setenv("LC_ALL", f"{locale}.UTF-8")
     with tmp_commitizen_project.as_cwd():
-        tags = git.get_tags(reachable_only=True)
-        assert tags == []
+        assert git.get_tags(reachable_only=True) == []
 
 
 def test_get_tag_names(mocker: MockFixture):
@@ -271,7 +270,7 @@ def test_get_commits_with_signature():
 def test_get_tag_names_has_correct_arrow_annotation():
     arrow_annotation = inspect.getfullargspec(git.get_tag_names).annotations["return"]
 
-    assert arrow_annotation == "list[str | None]"
+    assert arrow_annotation == "list[str]"
 
 
 def test_get_latest_tag_name(tmp_commitizen_project):
@@ -317,24 +316,18 @@ def test_is_staging_clean_when_updating_file(tmp_commitizen_project):
         assert git.is_staging_clean() is False
 
 
-def test_git_eol_style(tmp_commitizen_project):
+def test_get_eol_for_open(tmp_commitizen_project):
     with tmp_commitizen_project.as_cwd():
-        assert git.get_eol_style() == git.EOLTypes.NATIVE
+        assert git.get_eol_for_open() == os.linesep
 
         cmd.run("git config core.eol lf")
-        assert git.get_eol_style() == git.EOLTypes.LF
+        assert git.get_eol_for_open() == "\n"
 
         cmd.run("git config core.eol crlf")
-        assert git.get_eol_style() == git.EOLTypes.CRLF
+        assert git.get_eol_for_open() == "\r\n"
 
         cmd.run("git config core.eol native")
-        assert git.get_eol_style() == git.EOLTypes.NATIVE
-
-
-def test_eoltypes_get_eol_for_open():
-    assert git.EOLTypes.get_eol_for_open(git.EOLTypes.NATIVE) == os.linesep
-    assert git.EOLTypes.get_eol_for_open(git.EOLTypes.LF) == "\n"
-    assert git.EOLTypes.get_eol_for_open(git.EOLTypes.CRLF) == "\r\n"
+        assert git.get_eol_for_open() == os.linesep
 
 
 def test_get_core_editor(mocker):
@@ -401,3 +394,14 @@ def test_commit_with_spaces_in_path(mocker, file_path, expected_cmd):
 
     mock_run.assert_called_once_with(expected_cmd)
     mock_unlink.assert_called_once_with(file_path)
+
+
+def test_get_filenames_in_commit_error(mocker: MockFixture):
+    """Test that GitCommandError is raised when git command fails."""
+    mocker.patch(
+        "commitizen.cmd.run",
+        return_value=FakeCommand(out="", err="fatal: bad object HEAD", return_code=1),
+    )
+    with pytest.raises(exceptions.GitCommandError) as excinfo:
+        git.get_filenames_in_commit()
+    assert str(excinfo.value) == "fatal: bad object HEAD"

From 169d30b936a56d8715a2baf40c778a11bf1f96fa Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Sat, 17 May 2025 16:04:08 +0800
Subject: [PATCH 06/12] test(git): add test for from_rev_and_commit

---
 tests/test_git.py | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/tests/test_git.py b/tests/test_git.py
index 4e4b61ffe2..cb4ea93375 100644
--- a/tests/test_git.py
+++ b/tests/test_git.py
@@ -405,3 +405,47 @@ def test_get_filenames_in_commit_error(mocker: MockFixture):
     with pytest.raises(exceptions.GitCommandError) as excinfo:
         git.get_filenames_in_commit()
     assert str(excinfo.value) == "fatal: bad object HEAD"
+
+
+def test_git_commit_from_rev_and_commit():
+    # Test data with all fields populated
+    rev_and_commit = (
+        "abc123\n"  # rev
+        "def456 ghi789\n"  # parents
+        "feat: add new feature\n"  # title
+        "John Doe\n"  # author
+        "john@example.com\n"  # author_email
+        "This is a detailed description\n"  # body
+        "of the new feature\n"
+        "with multiple lines"
+    )
+
+    commit = git.GitCommit.from_rev_and_commit(rev_and_commit)
+
+    assert commit.rev == "abc123"
+    assert commit.title == "feat: add new feature"
+    assert (
+        commit.body
+        == "This is a detailed description\nof the new feature\nwith multiple lines"
+    )
+    assert commit.author == "John Doe"
+    assert commit.author_email == "john@example.com"
+    assert commit.parents == ["def456", "ghi789"]
+
+    # Test with minimal data
+    minimal_commit = (
+        "abc123\n"  # rev
+        "\n"  # no parents
+        "feat: minimal commit\n"  # title
+        "John Doe\n"  # author
+        "john@example.com\n"  # author_email
+    )
+
+    commit = git.GitCommit.from_rev_and_commit(minimal_commit)
+
+    assert commit.rev == "abc123"
+    assert commit.title == "feat: minimal commit"
+    assert commit.body == ""
+    assert commit.author == "John Doe"
+    assert commit.author_email == "john@example.com"
+    assert commit.parents == []

From ee06b434c1d7805bdb129a00337dcbc61573c6ac Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Sat, 17 May 2025 16:04:38 +0800
Subject: [PATCH 07/12] docs(git): from_rev_and_commit docstring

---
 commitizen/git.py | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/commitizen/git.py b/commitizen/git.py
index d0cc901a61..d80545bc44 100644
--- a/commitizen/git.py
+++ b/commitizen/git.py
@@ -43,6 +43,48 @@ def message(self):
 
     @classmethod
     def from_rev_and_commit(cls, rev_and_commit: str) -> GitCommit:
+        """Create a GitCommit instance from a formatted commit string.
+
+        This method parses a multi-line string containing commit information in the following format:
+        ```
+        <rev>
+        <parents>
+        <title>
+        <author>
+        <author_email>
+        <body_line_1>
+        <body_line_2>
+        ...
+        ```
+
+        Args:
+            rev_and_commit (str): A string containing commit information with fields separated by newlines.
+                - rev: The commit hash/revision
+                - parents: Space-separated list of parent commit hashes
+                - title: The commit title/message
+                - author: The commit author's name
+                - author_email: The commit author's email
+                - body: Optional multi-line commit body
+
+        Returns:
+            GitCommit: A new GitCommit instance with the parsed information.
+
+        Example:
+            >>> commit_str = '''abc123
+            ... def456 ghi789
+            ... feat: add new feature
+            ... John Doe
+            ... john@example.com
+            ... This is a detailed description
+            ... of the new feature'''
+            >>> commit = GitCommit.from_rev_and_commit(commit_str)
+            >>> commit.rev
+            'abc123'
+            >>> commit.title
+            'feat: add new feature'
+            >>> commit.parents
+            ['def456', 'ghi789']
+        """
         rev, parents, title, author, author_email, *body_list = rev_and_commit.split(
             "\n"
         )

From a14d947a537f80dee0f0fe0dae8cbb253e81a52f Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Sun, 18 May 2025 19:11:52 +0800
Subject: [PATCH 08/12] refactor(EOLType): add eol enum back and reorganize
 methods

---
 commitizen/git.py | 48 ++++++++++++++++++++++++++++++++---------------
 tests/test_git.py |  8 ++++----
 2 files changed, 37 insertions(+), 19 deletions(-)

diff --git a/commitizen/git.py b/commitizen/git.py
index d80545bc44..ef4e0452e3 100644
--- a/commitizen/git.py
+++ b/commitizen/git.py
@@ -1,14 +1,44 @@
 from __future__ import annotations
 
 import os
+from enum import Enum
+from functools import lru_cache
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 
 from commitizen import cmd, out
 from commitizen.exceptions import GitCommandError
 
-_UNIX_EOL = "\n"
-_WINDOWS_EOL = "\r\n"
+
+class EOLType(Enum):
+    """The EOL type from `git config core.eol`."""
+
+    LF = "lf"
+    CRLF = "crlf"
+    NATIVE = "native"
+
+    @classmethod
+    def for_open(cls) -> str:
+        c = cmd.run("git config core.eol")
+        eol = c.out.strip().upper()
+        return cls._char_for_open()[cls._safe_cast(eol)]
+
+    @classmethod
+    def _safe_cast(cls, eol: str) -> EOLType:
+        try:
+            return cls[eol]
+        except KeyError:
+            return cls.NATIVE
+
+    @classmethod
+    @lru_cache
+    def _char_for_open(cls) -> dict[EOLType, str]:
+        """Get the EOL character for `open()`."""
+        return {
+            cls.LF: "\n",
+            cls.CRLF: "\r\n",
+            cls.NATIVE: os.linesep,
+        }
 
 
 class GitObject:
@@ -268,18 +298,6 @@ def is_git_project() -> bool:
     return c.out.strip() == "true"
 
 
-def get_eol_for_open() -> str:
-    # See: https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreeol
-    c = cmd.run("git config core.eol")
-    eol = c.out.strip().lower()
-
-    if eol == "lf":
-        return _UNIX_EOL
-    if eol == "crlf":
-        return _WINDOWS_EOL
-    return os.linesep
-
-
 def get_core_editor() -> str | None:
     c = cmd.run("git var GIT_EDITOR")
     if c.out:
@@ -289,7 +307,7 @@ def get_core_editor() -> str | None:
 
 def smart_open(*args, **kwargs):
     """Open a file with the EOL style determined from Git."""
-    return open(*args, newline=get_eol_for_open(), **kwargs)
+    return open(*args, newline=EOLType.for_open(), **kwargs)
 
 
 def _get_log_as_str_list(start: str | None, end: str, args: str) -> list[str]:
diff --git a/tests/test_git.py b/tests/test_git.py
index cb4ea93375..de3130412b 100644
--- a/tests/test_git.py
+++ b/tests/test_git.py
@@ -318,16 +318,16 @@ def test_is_staging_clean_when_updating_file(tmp_commitizen_project):
 
 def test_get_eol_for_open(tmp_commitizen_project):
     with tmp_commitizen_project.as_cwd():
-        assert git.get_eol_for_open() == os.linesep
+        assert git.EOLType.for_open() == os.linesep
 
         cmd.run("git config core.eol lf")
-        assert git.get_eol_for_open() == "\n"
+        assert git.EOLType.for_open() == "\n"
 
         cmd.run("git config core.eol crlf")
-        assert git.get_eol_for_open() == "\r\n"
+        assert git.EOLType.for_open() == "\r\n"
 
         cmd.run("git config core.eol native")
-        assert git.get_eol_for_open() == os.linesep
+        assert git.EOLType.for_open() == os.linesep
 
 
 def test_get_core_editor(mocker):

From 8c2fa6f1074bf5ff8718112dfd5f59c0828345c4 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Sun, 18 May 2025 19:26:22 +0800
Subject: [PATCH 09/12] refactor(git): refactor get_tag_names

---
 commitizen/git.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/commitizen/git.py b/commitizen/git.py
index ef4e0452e3..fa59e34d48 100644
--- a/commitizen/git.py
+++ b/commitizen/git.py
@@ -277,7 +277,7 @@ def get_tag_names() -> list[str]:
     c = cmd.run("git tag --list")
     if c.err:
         return []
-    return list(filter(None, (tag.strip() for tag in c.out.split("\n"))))
+    return [tag for raw in c.out.split("\n") if (tag := raw.strip())]
 
 
 def find_git_project_root() -> Path | None:

From a51e7063f9565f64e3ead0d25c4a73c9aeab5a73 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Tue, 20 May 2025 00:46:16 +0800
Subject: [PATCH 10/12] refactor(changelog): minor cleanup

---
 commitizen/commands/changelog.py | 45 ++++++++++++++++----------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/commitizen/commands/changelog.py b/commitizen/commands/changelog.py
index 0e4efabfa1..9ab8fdc37c 100644
--- a/commitizen/commands/changelog.py
+++ b/commitizen/commands/changelog.py
@@ -2,10 +2,10 @@
 
 import os
 import os.path
+from collections.abc import Generator
 from difflib import SequenceMatcher
 from operator import itemgetter
 from pathlib import Path
-from typing import Callable, cast
 
 from commitizen import changelog, defaults, factory, git, out
 from commitizen.changelog_formats import get_changelog_format
@@ -32,9 +32,10 @@ def __init__(self, config: BaseConfig, args):
         if not git.is_git_project():
             raise NotAGitProjectError()
 
-        self.config: BaseConfig = config
-        changelog_file_name = args.get("file_name") or cast(
-            str, self.config.settings.get("changelog_file")
+        self.config = config
+
+        changelog_file_name = args.get("file_name") or self.config.settings.get(
+            "changelog_file"
         )
         if not isinstance(changelog_file_name, str):
             raise NotAllowed(
@@ -114,28 +115,28 @@ def _find_incremental_rev(self, latest_version: str, tags: list[GitTag]) -> str:
         on our experience.
         """
         SIMILARITY_THRESHOLD = 0.89
-        tag_ratio = map(
-            lambda tag: (
-                SequenceMatcher(
+        scores_and_tag_names: Generator[tuple[float, str]] = (
+            (
+                score,
+                tag.name,
+            )
+            for tag in tags
+            if (
+                score := SequenceMatcher(
                     None, latest_version, strip_local_version(tag.name)
-                ).ratio(),
-                tag,
-            ),
-            tags,
+                ).ratio()
+            )
+            >= SIMILARITY_THRESHOLD
         )
         try:
-            score, tag = max(tag_ratio, key=itemgetter(0))
+            _, start_rev = max(scores_and_tag_names, key=itemgetter(0))
         except ValueError:
             raise NoRevisionError()
-        if score < SIMILARITY_THRESHOLD:
-            raise NoRevisionError()
-        start_rev = tag.name
         return start_rev
 
     def write_changelog(
         self, changelog_out: str, lines: list[str], changelog_meta: changelog.Metadata
     ):
-        changelog_hook: Callable | None = self.cz.changelog_hook
         with smart_open(self.file_name, "w", encoding=self.encoding) as changelog_file:
             partial_changelog: str | None = None
             if self.incremental:
@@ -145,8 +146,8 @@ def write_changelog(
                 changelog_out = "".join(new_lines)
                 partial_changelog = changelog_out
 
-            if changelog_hook:
-                changelog_out = changelog_hook(changelog_out, partial_changelog)
+            if self.cz.changelog_hook:
+                changelog_out = self.cz.changelog_hook(changelog_out, partial_changelog)
 
             changelog_file.write(changelog_out)
 
@@ -221,14 +222,12 @@ def __call__(self):
         extras.update(self.extras)
         changelog_out = changelog.render_changelog(
             tree, loader=self.cz.template_loader, template=self.template, **extras
-        )
-        changelog_out = changelog_out.lstrip("\n")
+        ).lstrip("\n")
 
         # Dry_run is executed here to avoid checking and reading the files
         if self.dry_run:
-            changelog_hook: Callable | None = self.cz.changelog_hook
-            if changelog_hook:
-                changelog_out = changelog_hook(changelog_out, "")
+            if self.cz.changelog_hook:
+                changelog_out = self.cz.changelog_hook(changelog_out, "")
             out.write(changelog_out)
             raise DryRunExit()
 

From 5d05b86840d2400a286eebc89087093081753295 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Tue, 20 May 2025 21:23:30 +0800
Subject: [PATCH 11/12] refactor(BaseConfig): use setter

---
 commitizen/config/base_config.py    | 12 +++++++++---
 commitizen/config/json_config.py    |  2 +-
 commitizen/config/toml_config.py    |  2 +-
 commitizen/config/yaml_config.py    |  2 +-
 tests/commands/test_init_command.py |  2 +-
 tests/test_changelog.py             |  4 +++-
 6 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/commitizen/config/base_config.py b/commitizen/config/base_config.py
index 478691aa14..fd034412fe 100644
--- a/commitizen/config/base_config.py
+++ b/commitizen/config/base_config.py
@@ -19,6 +19,15 @@ def settings(self) -> Settings:
     def path(self) -> Path | None:
         return self._path
 
+    @path.setter
+    def path(self, path: str | Path) -> None:
+        """
+        mypy does not like this until 1.16
+        See https://github.com/python/mypy/pull/18510
+        TODO: remove "type: ignore" from the call sites when 1.16 is available
+        """
+        self._path = Path(path)
+
     def set_key(self, key, value):
         """Set or update a key in the conf.
 
@@ -30,8 +39,5 @@ def set_key(self, key, value):
     def update(self, data: Settings) -> None:
         self._settings.update(data)
 
-    def add_path(self, path: str | Path) -> None:
-        self._path = Path(path)
-
     def _parse_setting(self, data: bytes | str) -> None:
         raise NotImplementedError()
diff --git a/commitizen/config/json_config.py b/commitizen/config/json_config.py
index b6a07f4ced..d413d73383 100644
--- a/commitizen/config/json_config.py
+++ b/commitizen/config/json_config.py
@@ -13,7 +13,7 @@ class JsonConfig(BaseConfig):
     def __init__(self, *, data: bytes | str, path: Path | str):
         super().__init__()
         self.is_empty_config = False
-        self.add_path(path)
+        self.path = path  # type: ignore
         self._parse_setting(data)
 
     def init_empty_config_content(self):
diff --git a/commitizen/config/toml_config.py b/commitizen/config/toml_config.py
index 813389cbcf..e2cfcc9340 100644
--- a/commitizen/config/toml_config.py
+++ b/commitizen/config/toml_config.py
@@ -14,7 +14,7 @@ class TomlConfig(BaseConfig):
     def __init__(self, *, data: bytes | str, path: Path | str):
         super().__init__()
         self.is_empty_config = False
-        self.add_path(path)
+        self.path = path  # type: ignore
         self._parse_setting(data)
 
     def init_empty_config_content(self):
diff --git a/commitizen/config/yaml_config.py b/commitizen/config/yaml_config.py
index 2bb6fe3af8..c5721c8d4b 100644
--- a/commitizen/config/yaml_config.py
+++ b/commitizen/config/yaml_config.py
@@ -14,7 +14,7 @@ class YAMLConfig(BaseConfig):
     def __init__(self, *, data: bytes | str, path: Path | str):
         super().__init__()
         self.is_empty_config = False
-        self.add_path(path)
+        self.path = path  # type: ignore
         self._parse_setting(data)
 
     def init_empty_config_content(self):
diff --git a/tests/commands/test_init_command.py b/tests/commands/test_init_command.py
index f617c51d8f..3f12d0bd7f 100644
--- a/tests/commands/test_init_command.py
+++ b/tests/commands/test_init_command.py
@@ -86,7 +86,7 @@ def test_init_without_setup_pre_commit_hook(tmpdir, mocker: MockFixture, config)
 def test_init_when_config_already_exists(config, capsys):
     # Set config path
     path = os.sep.join(["tests", "pyproject.toml"])
-    config.add_path(path)
+    config.path = path
 
     commands.Init(config)()
     captured = capsys.readouterr()
diff --git a/tests/test_changelog.py b/tests/test_changelog.py
index 511cd1a3df..d42176f09a 100644
--- a/tests/test_changelog.py
+++ b/tests/test_changelog.py
@@ -1639,7 +1639,9 @@ def test_tags_rules_get_version_tags(capsys: pytest.CaptureFixture):
 
 def test_changelog_file_name_from_args_and_config():
     mock_config = Mock(spec=BaseConfig)
-    mock_config.path.parent = "/my/project"
+    mock_path = Mock(spec=Path)
+    mock_path.parent = Path("/my/project")
+    mock_config.path = mock_path
     mock_config.settings = {
         "name": "cz_conventional_commits",
         "changelog_file": "CHANGELOG.md",

From 50fd65f775be2757b3b1fa4ac62bd0bb934738d9 Mon Sep 17 00:00:00 2001
From: Yu-Ting Hsiung <bear890707@gmail.com>
Date: Tue, 20 May 2025 23:34:37 +0800
Subject: [PATCH 12/12] build(poetry): upgrade mypy version to ^1.15.0

---
 poetry.lock    | 108 +++++++++++++++++++++++--------------------------
 pyproject.toml |  14 ++-----
 2 files changed, 54 insertions(+), 68 deletions(-)

diff --git a/poetry.lock b/poetry.lock
index cccd7a532a..ced16626e1 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand.
 
 [[package]]
 name = "argcomplete"
@@ -31,8 +31,8 @@ files = [
 six = ">=1.12.0"
 
 [package.extras]
-astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"]
-test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"]
+astroid = ["astroid (>=1,<2) ; python_version < \"3\"", "astroid (>=2,<4) ; python_version >= \"3\""]
+test = ["astroid (>=1,<2) ; python_version < \"3\"", "astroid (>=2,<4) ; python_version >= \"3\"", "pytest"]
 
 [[package]]
 name = "babel"
@@ -302,7 +302,7 @@ files = [
 tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""}
 
 [package.extras]
-toml = ["tomli"]
+toml = ["tomli ; python_full_version <= \"3.11.0a6\""]
 
 [[package]]
 name = "decli"
@@ -344,7 +344,7 @@ files = [
 wrapt = ">=1.10,<2"
 
 [package.extras]
-dev = ["PyTest", "PyTest-Cov", "bump2version (<1)", "setuptools", "tox"]
+dev = ["PyTest", "PyTest-Cov", "bump2version (<1)", "setuptools ; python_version >= \"3.12\"", "tox"]
 
 [[package]]
 name = "distlib"
@@ -402,7 +402,7 @@ files = [
 ]
 
 [package.extras]
-tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"]
+tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich ; python_version >= \"3.11\""]
 
 [[package]]
 name = "filelock"
@@ -419,7 +419,7 @@ files = [
 [package.extras]
 docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"]
 testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"]
-typing = ["typing-extensions (>=4.12.2)"]
+typing = ["typing-extensions (>=4.12.2) ; python_version < \"3.11\""]
 
 [[package]]
 name = "freezegun"
@@ -491,7 +491,7 @@ description = "Read metadata from Python packages"
 optional = false
 python-versions = ">=3.9"
 groups = ["main", "documentation"]
-markers = "python_version < \"3.10\""
+markers = "python_version == \"3.9\""
 files = [
     {file = "importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e"},
     {file = "importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580"},
@@ -501,12 +501,12 @@ files = [
 zipp = ">=3.20"
 
 [package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"]
+check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
 cover = ["pytest-cov"]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 enabler = ["pytest-enabler (>=2.2)"]
 perf = ["ipython"]
-test = ["flufl.flake8", "importlib_resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"]
+test = ["flufl.flake8", "importlib_resources (>=1.3) ; python_version < \"3.9\"", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"]
 type = ["pytest-mypy"]
 
 [[package]]
@@ -781,7 +781,7 @@ watchdog = ">=2.0"
 
 [package.extras]
 i18n = ["babel (>=2.9.0)"]
-min-versions = ["babel (==2.9.0)", "click (==7.0)", "colorama (==0.4)", "ghp-import (==1.0)", "importlib-metadata (==4.4)", "jinja2 (==2.11.1)", "markdown (==3.3.6)", "markupsafe (==2.0.1)", "mergedeep (==1.3.4)", "mkdocs-get-deps (==0.2.0)", "packaging (==20.5)", "pathspec (==0.11.1)", "pyyaml (==5.1)", "pyyaml-env-tag (==0.1)", "watchdog (==2.0)"]
+min-versions = ["babel (==2.9.0)", "click (==7.0)", "colorama (==0.4) ; platform_system == \"Windows\"", "ghp-import (==1.0)", "importlib-metadata (==4.4) ; python_version < \"3.10\"", "jinja2 (==2.11.1)", "markdown (==3.3.6)", "markupsafe (==2.0.1)", "mergedeep (==1.3.4)", "mkdocs-get-deps (==0.2.0)", "packaging (==20.5)", "pathspec (==0.11.1)", "pyyaml (==5.1)", "pyyaml-env-tag (==0.1)", "watchdog (==2.0)"]
 
 [[package]]
 name = "mkdocs-get-deps"
@@ -845,50 +845,44 @@ files = [
 
 [[package]]
 name = "mypy"
-version = "1.14.1"
+version = "1.15.0"
 description = "Optional static typing for Python"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
 groups = ["linters"]
 files = [
-    {file = "mypy-1.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52686e37cf13d559f668aa398dd7ddf1f92c5d613e4f8cb262be2fb4fedb0fcb"},
-    {file = "mypy-1.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fb545ca340537d4b45d3eecdb3def05e913299ca72c290326be19b3804b39c0"},
-    {file = "mypy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90716d8b2d1f4cd503309788e51366f07c56635a3309b0f6a32547eaaa36a64d"},
-    {file = "mypy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae753f5c9fef278bcf12e1a564351764f2a6da579d4a81347e1d5a15819997b"},
-    {file = "mypy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e0fe0f5feaafcb04505bcf439e991c6d8f1bf8b15f12b05feeed96e9e7bf1427"},
-    {file = "mypy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:7d54bd85b925e501c555a3227f3ec0cfc54ee8b6930bd6141ec872d1c572f81f"},
-    {file = "mypy-1.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f995e511de847791c3b11ed90084a7a0aafdc074ab88c5a9711622fe4751138c"},
-    {file = "mypy-1.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d64169ec3b8461311f8ce2fd2eb5d33e2d0f2c7b49116259c51d0d96edee48d1"},
-    {file = "mypy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba24549de7b89b6381b91fbc068d798192b1b5201987070319889e93038967a8"},
-    {file = "mypy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:183cf0a45457d28ff9d758730cd0210419ac27d4d3f285beda038c9083363b1f"},
-    {file = "mypy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f2a0ecc86378f45347f586e4163d1769dd81c5a223d577fe351f26b179e148b1"},
-    {file = "mypy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:ad3301ebebec9e8ee7135d8e3109ca76c23752bac1e717bc84cd3836b4bf3eae"},
-    {file = "mypy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30ff5ef8519bbc2e18b3b54521ec319513a26f1bba19a7582e7b1f58a6e69f14"},
-    {file = "mypy-1.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb9f255c18052343c70234907e2e532bc7e55a62565d64536dbc7706a20b78b9"},
-    {file = "mypy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b4e3413e0bddea671012b063e27591b953d653209e7a4fa5e48759cda77ca11"},
-    {file = "mypy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:553c293b1fbdebb6c3c4030589dab9fafb6dfa768995a453d8a5d3b23784af2e"},
-    {file = "mypy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fad79bfe3b65fe6a1efaed97b445c3d37f7be9fdc348bdb2d7cac75579607c89"},
-    {file = "mypy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8fa2220e54d2946e94ab6dbb3ba0a992795bd68b16dc852db33028df2b00191b"},
-    {file = "mypy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:92c3ed5afb06c3a8e188cb5da4984cab9ec9a77ba956ee419c68a388b4595255"},
-    {file = "mypy-1.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbec574648b3e25f43d23577309b16534431db4ddc09fda50841f1e34e64ed34"},
-    {file = "mypy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c6d94b16d62eb3e947281aa7347d78236688e21081f11de976376cf010eb31a"},
-    {file = "mypy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4b19b03fdf54f3c5b2fa474c56b4c13c9dbfb9a2db4370ede7ec11a2c5927d9"},
-    {file = "mypy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c911fde686394753fff899c409fd4e16e9b294c24bfd5e1ea4675deae1ac6fd"},
-    {file = "mypy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8b21525cb51671219f5307be85f7e646a153e5acc656e5cebf64bfa076c50107"},
-    {file = "mypy-1.14.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7084fb8f1128c76cd9cf68fe5971b37072598e7c31b2f9f95586b65c741a9d31"},
-    {file = "mypy-1.14.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8f845a00b4f420f693f870eaee5f3e2692fa84cc8514496114649cfa8fd5e2c6"},
-    {file = "mypy-1.14.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:44bf464499f0e3a2d14d58b54674dee25c031703b2ffc35064bd0df2e0fac319"},
-    {file = "mypy-1.14.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c99f27732c0b7dc847adb21c9d47ce57eb48fa33a17bc6d7d5c5e9f9e7ae5bac"},
-    {file = "mypy-1.14.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:bce23c7377b43602baa0bd22ea3265c49b9ff0b76eb315d6c34721af4cdf1d9b"},
-    {file = "mypy-1.14.1-cp38-cp38-win_amd64.whl", hash = "sha256:8edc07eeade7ebc771ff9cf6b211b9a7d93687ff892150cb5692e4f4272b0837"},
-    {file = "mypy-1.14.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3888a1816d69f7ab92092f785a462944b3ca16d7c470d564165fe703b0970c35"},
-    {file = "mypy-1.14.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46c756a444117c43ee984bd055db99e498bc613a70bbbc120272bd13ca579fbc"},
-    {file = "mypy-1.14.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27fc248022907e72abfd8e22ab1f10e903915ff69961174784a3900a8cba9ad9"},
-    {file = "mypy-1.14.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:499d6a72fb7e5de92218db961f1a66d5f11783f9ae549d214617edab5d4dbdbb"},
-    {file = "mypy-1.14.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:57961db9795eb566dc1d1b4e9139ebc4c6b0cb6e7254ecde69d1552bf7613f60"},
-    {file = "mypy-1.14.1-cp39-cp39-win_amd64.whl", hash = "sha256:07ba89fdcc9451f2ebb02853deb6aaaa3d2239a236669a63ab3801bbf923ef5c"},
-    {file = "mypy-1.14.1-py3-none-any.whl", hash = "sha256:b66a60cc4073aeb8ae00057f9c1f64d49e90f918fbcef9a977eb121da8b8f1d1"},
-    {file = "mypy-1.14.1.tar.gz", hash = "sha256:7ec88144fe9b510e8475ec2f5f251992690fcf89ccb4500b214b4226abcd32d6"},
+    {file = "mypy-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:979e4e1a006511dacf628e36fadfecbcc0160a8af6ca7dad2f5025529e082c13"},
+    {file = "mypy-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c4bb0e1bd29f7d34efcccd71cf733580191e9a264a2202b0239da95984c5b559"},
+    {file = "mypy-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be68172e9fd9ad8fb876c6389f16d1c1b5f100ffa779f77b1fb2176fcc9ab95b"},
+    {file = "mypy-1.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7be1e46525adfa0d97681432ee9fcd61a3964c2446795714699a998d193f1a3"},
+    {file = "mypy-1.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2e2c2e6d3593f6451b18588848e66260ff62ccca522dd231cd4dd59b0160668b"},
+    {file = "mypy-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:6983aae8b2f653e098edb77f893f7b6aca69f6cffb19b2cc7443f23cce5f4828"},
+    {file = "mypy-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2922d42e16d6de288022e5ca321cd0618b238cfc5570e0263e5ba0a77dbef56f"},
+    {file = "mypy-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2ee2d57e01a7c35de00f4634ba1bbf015185b219e4dc5909e281016df43f5ee5"},
+    {file = "mypy-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:973500e0774b85d9689715feeffcc980193086551110fd678ebe1f4342fb7c5e"},
+    {file = "mypy-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a95fb17c13e29d2d5195869262f8125dfdb5c134dc8d9a9d0aecf7525b10c2c"},
+    {file = "mypy-1.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1905f494bfd7d85a23a88c5d97840888a7bd516545fc5aaedff0267e0bb54e2f"},
+    {file = "mypy-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c9817fa23833ff189db061e6d2eff49b2f3b6ed9856b4a0a73046e41932d744f"},
+    {file = "mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd"},
+    {file = "mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f"},
+    {file = "mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464"},
+    {file = "mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee"},
+    {file = "mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e"},
+    {file = "mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22"},
+    {file = "mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445"},
+    {file = "mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d"},
+    {file = "mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5"},
+    {file = "mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036"},
+    {file = "mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357"},
+    {file = "mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf"},
+    {file = "mypy-1.15.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e601a7fa172c2131bff456bb3ee08a88360760d0d2f8cbd7a75a65497e2df078"},
+    {file = "mypy-1.15.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:712e962a6357634fef20412699a3655c610110e01cdaa6180acec7fc9f8513ba"},
+    {file = "mypy-1.15.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95579473af29ab73a10bada2f9722856792a36ec5af5399b653aa28360290a5"},
+    {file = "mypy-1.15.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f8722560a14cde92fdb1e31597760dc35f9f5524cce17836c0d22841830fd5b"},
+    {file = "mypy-1.15.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:1fbb8da62dc352133d7d7ca90ed2fb0e9d42bb1a32724c287d3c76c58cbaa9c2"},
+    {file = "mypy-1.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:d10d994b41fb3497719bbf866f227b3489048ea4bbbb5015357db306249f7980"},
+    {file = "mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e"},
+    {file = "mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43"},
 ]
 
 [package.dependencies]
@@ -1785,7 +1779,7 @@ files = [
 ]
 
 [package.extras]
-brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
+brotli = ["brotli (>=1.0.9) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\""]
 h2 = ["h2 (>=4,<5)"]
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
@@ -1809,7 +1803,7 @@ platformdirs = ">=3.9.1,<5"
 
 [package.extras]
 docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
-test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
+test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""]
 
 [[package]]
 name = "watchdog"
@@ -1948,21 +1942,21 @@ description = "Backport of pathlib-compatible object wrapper for zip files"
 optional = false
 python-versions = ">=3.9"
 groups = ["main", "documentation"]
-markers = "python_version < \"3.10\""
+markers = "python_version == \"3.9\""
 files = [
     {file = "zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931"},
     {file = "zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4"},
 ]
 
 [package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"]
+check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
 cover = ["pytest-cov"]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 enabler = ["pytest-enabler (>=2.2)"]
-test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
+test = ["big-O", "importlib-resources ; python_version < \"3.9\"", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
 type = ["pytest-mypy"]
 
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.9,<4.0"
-content-hash = "e15b424a0569f939e297c8abfcf09753f1fbcc5b4ad891163cc0982accd3b372"
+content-hash = "843473c45767f6cb8992b157178ef5113a56faf28075a0a4f47b621b146d7d1b"
diff --git a/pyproject.toml b/pyproject.toml
index b306e5e78c..a6bd90e5bd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -120,7 +120,7 @@ deprecated = "^1.2.13"
 [tool.poetry.group.linters.dependencies]
 ruff = ">=0.5.0,<0.10.0"
 pre-commit = ">=2.18,<5.0"
-mypy = "^1.4"
+mypy = "^1.15.0"
 types-deprecated = "^1.2.9.2"
 types-python-dateutil = "^2.8.19.13"
 types-PyYAML = ">=5.4.3,<7.0.0"
@@ -250,12 +250,7 @@ cover.help = "Run the test suite with coverage"
 cover.ref = "test --cov-report term-missing --cov-report=xml:coverage.xml --cov=commitizen"
 
 all.help = "Run all tasks"
-all.sequence = [
-    "format",
-    "lint",
-    "cover",
-    "check-commit",
-]
+all.sequence = ["format", "lint", "cover", "check-commit"]
 
 "doc:screenshots".help = "Render documentation screeenshots"
 "doc:screenshots".script = "scripts.gen_cli_help_screenshots:gen_cli_help_screenshots"
@@ -267,10 +262,7 @@ doc.help = "Live documentation server"
 doc.cmd = "mkdocs serve"
 
 ci.help = "Run all tasks in CI"
-ci.sequence = [
-    { cmd = "pre-commit run --all-files" },
-    "cover",
-]
+ci.sequence = [{ cmd = "pre-commit run --all-files" }, "cover"]
 ci.env = { SKIP = "no-commit-to-branch" }
 
 setup-pre-commit.help = "Install pre-commit hooks"