refactor(bump): TypedDict for bump argument

Author: bearomorphism

commitizen/cli.py

@@ -680,7 +680,7 @@ def main() -> None:
         )
         sys.excepthook = no_raise_debug_excepthook
 
-    args.func(conf, arguments)()
+    args.func(conf, arguments)()  # type: ignore
 
 
 if __name__ == "__main__":

commitizen/commands/bump.py

@@ -37,37 +37,65 @@
 logger = getLogger("commitizen")
 
 
+class BumpArguments(Settings, total=False):
+    allow_no_commit: bool | None
+    annotated_tag_message: str | None
+    annotated_tag: bool
+    build_metadata: str | None
+    changelog_to_stdout: bool
+    changelog: bool
+    check_consistency: bool
+    devrelease: int | None
+    dry_run: bool
+    file_name: str
+    files_only: bool | None
+    get_next: bool
+    git_output_to_stderr: bool
+    gpg_sign: bool
+    increment_mode: str
+    increment: Increment | None
+    local_version: bool
+    manual_version: str | None
+    no_verify: bool
+    prerelease: Prerelease | None
+    retry: bool
+    yes: bool
+
+
 class Bump:
     """Show prompt for the user to create a guided commit."""
 
-    def __init__(self, config: BaseConfig, arguments: dict) -> None:
+    def __init__(self, config: BaseConfig, arguments: BumpArguments) -> None:
         if not git.is_git_project():
             raise NotAGitProjectError()
 
         self.config: BaseConfig = config
         self.encoding = config.settings["encoding"]
-        self.arguments: dict = arguments
-        self.bump_settings: dict = {
-            **config.settings,
-            **{
-                key: arguments[key]
-                for key in [
-                    "tag_format",
-                    "prerelease",
-                    "increment",
-                    "increment_mode",
-                    "bump_message",
-                    "gpg_sign",
-                    "annotated_tag",
-                    "annotated_tag_message",
-                    "major_version_zero",
-                    "prerelease_offset",
-                    "template",
-                    "file_name",
-                ]
-                if arguments.get(key) is not None
+        self.arguments = arguments
+        self.bump_settings = cast(
+            BumpArguments,
+            {
+                **config.settings,
+                **{
+                    k: v
+                    for k, v in {
+                        "annotated_tag_message": arguments.get("annotated_tag_message"),
+                        "annotated_tag": arguments.get("annotated_tag"),
+                        "bump_message": arguments.get("bump_message"),
+                        "file_name": arguments.get("file_name"),
+                        "gpg_sign": arguments.get("gpg_sign"),
+                        "increment_mode": arguments.get("increment_mode"),
+                        "increment": arguments.get("increment"),
+                        "major_version_zero": arguments.get("major_version_zero"),
+                        "prerelease_offset": arguments.get("prerelease_offset"),
+                        "prerelease": arguments.get("prerelease"),
+                        "tag_format": arguments.get("tag_format"),
+                        "template": arguments.get("template"),
+                    }.items()
+                    if v is not None
+                },
             },
-        }
+        )
         self.cz = factory.committer_factory(self.config)
         self.changelog_flag = arguments["changelog"]
         self.changelog_config = self.config.settings.get("update_changelog_on_bump")
@@ -120,11 +148,10 @@ def _is_initial_tag(
 
     def _find_increment(self, commits: list[git.GitCommit]) -> Increment | None:
         # Update the bump map to ensure major version doesn't increment.
-        is_major_version_zero: bool = self.bump_settings["major_version_zero"]
         # self.cz.bump_map = defaults.bump_map_major_version_zero
         bump_map = (
             self.cz.bump_map_major_version_zero
-            if is_major_version_zero
+            if self.bump_settings["major_version_zero"]
             else self.cz.bump_map
         )
         bump_pattern = self.cz.bump_pattern
@@ -144,23 +171,14 @@ def __call__(self) -> None:
         except TypeError:
             raise NoVersionSpecifiedError()
 
-        bump_commit_message: str | None = self.bump_settings["bump_message"]
-        version_files: list[str] = self.bump_settings["version_files"]
-        major_version_zero: bool = self.bump_settings["major_version_zero"]
-        prerelease_offset: int = self.bump_settings["prerelease_offset"]
-
-        dry_run: bool = self.arguments["dry_run"]
-        is_yes: bool = self.arguments["yes"]
-        increment: Increment | None = self.arguments["increment"]
-        prerelease: Prerelease | None = self.arguments["prerelease"]
-        devrelease: int | None = self.arguments["devrelease"]
-        is_files_only: bool | None = self.arguments["files_only"]
-        is_local_version: bool = self.arguments["local_version"]
+        increment = self.arguments["increment"]
+        prerelease = self.arguments["prerelease"]
+        devrelease = self.arguments["devrelease"]
+        is_local_version = self.arguments["local_version"]
         manual_version = self.arguments["manual_version"]
         build_metadata = self.arguments["build_metadata"]
-        increment_mode: str = self.arguments["increment_mode"]
-        get_next: bool = self.arguments["get_next"]
-        allow_no_commit: bool | None = self.arguments["allow_no_commit"]
+        get_next = self.arguments["get_next"]
+        allow_no_commit = self.arguments["allow_no_commit"]
 
         if manual_version:
             if increment:
@@ -182,15 +200,15 @@ def __call__(self) -> None:
                     "--build-metadata cannot be combined with MANUAL_VERSION"
                 )
 
-            if major_version_zero:
+            if self.bump_settings["major_version_zero"]:
                 raise NotAllowed(
                     "--major-version-zero cannot be combined with MANUAL_VERSION"
                 )
 
             if get_next:
                 raise NotAllowed("--get-next cannot be combined with MANUAL_VERSION")
 
-        if major_version_zero:
+        if self.bump_settings["major_version_zero"]:
             if not current_version.release[0] == 0:
                 raise NotAllowed(
                     f"--major-version-zero is meaningless for current version {current_version}"
@@ -215,7 +233,7 @@ def __call__(self) -> None:
         else:
             # If user specified changelog_to_stdout, they probably want the
             # changelog to be generated as well, this is the most intuitive solution
-            self.changelog_flag = (
+            self.changelog_flag = bool(
                 self.changelog_flag
                 or bool(self.changelog_to_stdout)
                 or self.changelog_config
@@ -227,7 +245,7 @@ def __call__(self) -> None:
             current_tag, "name", rules.normalize_tag(current_version)
         )
 
-        is_initial = self._is_initial_tag(current_tag, is_yes)
+        is_initial = self._is_initial_tag(current_tag, self.arguments["yes"])
 
         if manual_version:
             try:
@@ -273,16 +291,16 @@ def __call__(self) -> None:
             new_version = current_version.bump(
                 increment,
                 prerelease=prerelease,
-                prerelease_offset=prerelease_offset,
+                prerelease_offset=self.bump_settings["prerelease_offset"],
                 devrelease=devrelease,
                 is_local_version=is_local_version,
                 build_metadata=build_metadata,
-                exact_increment=increment_mode == "exact",
+                exact_increment=self.arguments["increment_mode"] == "exact",
             )
 
         new_tag_version = rules.normalize_tag(new_version)
         message = bump.create_commit_message(
-            current_version, new_version, bump_commit_message
+            current_version, new_version, self.bump_settings["bump_message"]
         )
 
         if get_next:
@@ -314,6 +332,7 @@ def __call__(self) -> None:
             )
 
         files: list[str] = []
+        dry_run = self.arguments["dry_run"]
         if self.changelog_flag:
             args = {
                 "unreleased_version": new_tag_version,
@@ -342,7 +361,7 @@ def __call__(self) -> None:
             bump.update_version_in_files(
                 str(current_version),
                 str(new_version),
-                version_files,
+                self.bump_settings["version_files"],
                 check_consistency=self.check_consistency,
                 encoding=self.encoding,
             )
@@ -366,7 +385,7 @@ def __call__(self) -> None:
                 else None,
             )
 
-        if is_files_only:
+        if self.arguments["files_only"]:
             raise ExpectedExit()
 
         # FIXME: check if any changes have been staged
@@ -395,11 +414,15 @@ def __call__(self) -> None:
 
         c = git.tag(
             new_tag_version,
-            signed=self.bump_settings.get("gpg_sign", False)
-            or bool(self.config.settings.get("gpg_sign", False)),
-            annotated=self.bump_settings.get("annotated_tag", False)
-            or bool(self.config.settings.get("annotated_tag", False))
-            or bool(self.bump_settings.get("annotated_tag_message", False)),
+            signed=bool(
+                self.bump_settings.get("gpg_sign")
+                or self.config.settings.get("gpg_sign")
+            ),
+            annotated=bool(
+                self.bump_settings.get("annotated_tag")
+                or self.config.settings.get("annotated_tag")
+                or self.bump_settings.get("annotated_tag_message")
+            ),
             msg=self.bump_settings.get("annotated_tag_message", None),
             # TODO: also get from self.config.settings?
         )

commitizen/defaults.py

@@ -29,36 +29,36 @@ class CzSettings(TypedDict, total=False):
 
 
 class Settings(TypedDict, total=False):
-    name: str
-    version: str | None
-    version_files: list[str]
-    version_provider: str | None
-    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
     allowed_prefixes: list[str]
+    always_signoff: bool
+    bump_message: str | None
     changelog_file: str
     changelog_format: str | None
     changelog_incremental: bool
-    changelog_start_rev: str | None
     changelog_merge_prerelease: bool
-    update_changelog_on_bump: bool
-    use_shortcuts: bool
-    style: list[tuple[str, str]]
+    changelog_start_rev: str | None
     customize: CzSettings
+    encoding: str
+    extras: dict[str, Any]
+    ignored_tag_formats: Sequence[str]
+    legacy_tag_formats: Sequence[str]
     major_version_zero: bool
-    pre_bump_hooks: list[str] | None
+    name: str
     post_bump_hooks: list[str] | None
+    pre_bump_hooks: list[str] | None
     prerelease_offset: int
-    encoding: str
-    always_signoff: bool
+    retry_after_failure: bool
+    style: list[tuple[str, str]]
+    tag_format: str
     template: str | None
-    extras: dict[str, Any]
+    update_changelog_on_bump: bool
+    use_shortcuts: bool
+    version_files: list[str]
+    version_provider: str | None
+    version_scheme: str | None
+    version_type: str | None
+    version: str | None
 
 
 CONFIG_FILES: list[str] = [

tests/commands/test_bump_command.py

@@ -1721,7 +1721,7 @@ def test_is_initial_tag(mocker: MockFixture, tmp_commitizen_project):
         "extras": None,
     }
 
-    bump_cmd = bump.Bump(config, arguments)
+    bump_cmd = bump.Bump(config, arguments)  # type: ignore
 
     # Test case 1: No current tag, not yes mode
     mocker.patch("questionary.confirm", return_value=mocker.Mock(ask=lambda: True))