commitizen 4.14.0__tar.gz → 4.15.1__tar.gz

{commitizen-4.14.0 → commitizen-4.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commitizen
-Version: 4.14.0
+Version: 4.15.1
 Summary: Python commitizen client tool
 Keywords: commitizen,conventional,commits,git
 Author: Santiago Fraire

commitizen-4.15.1/commitizen/__version__.py

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

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/bump.py

@@ -15,7 +15,7 @@ from commitizen.git import GitCommit, smart_open
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable
 
-    from commitizen.version_schemes import Increment, Version
+    from commitizen.version_schemes import Increment, VersionProtocol
 
 VERSION_TYPES = [None, PATCH, MINOR, MAJOR]
 
@@ -131,8 +131,8 @@ def _resolve_files_and_regexes(
 
 
 def create_commit_message(
-    current_version: Version | str,
-    new_version: Version | str,
+    current_version: VersionProtocol | str,
+    new_version: VersionProtocol | str,
     message_template: str | None = None,
 ) -> str:
     if message_template is None:

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/cli.py

@@ -21,6 +21,7 @@ from commitizen.exceptions import (
     InvalidCommandArgumentError,
     NoCommandFoundError,
 )
+from commitizen.version_increment import VersionIncrement
 
 logger = logging.getLogger(__name__)
 
@@ -542,13 +543,19 @@ data = {
                     },
                     {
                         "name": ["--major"],
-                        "help": "Output just the major version. Must be used with --project or --verbose.",
+                        "help": (
+                            "Output just the major version. Must be used with MANUAL_VERSION, "
+                            "--project, or --verbose."
+                        ),
                         "action": "store_true",
                         "exclusive_group": "group2",
                     },
                     {
                         "name": ["--minor"],
-                        "help": "Output just the minor version. Must be used with --project or --verbose.",
+                        "help": (
+                            "Output just the minor version. Must be used with MANUAL_VERSION, "
+                            "--project, or --verbose."
+                        ),
                         "action": "store_true",
                         "exclusive_group": "group2",
                     },
@@ -558,6 +565,33 @@ data = {
                         "action": "store_true",
                         "exclusive_group": "group2",
                     },
+                    {
+                        "name": ["--patch"],
+                        "help": (
+                            "Output the patch version only. Must be used with MANUAL_VERSION, "
+                            "--project, or --verbose."
+                        ),
+                        "action": "store_true",
+                        "exclusive_group": "group2",
+                    },
+                    {
+                        "name": ["--next"],
+                        "help": "Output the next version.",
+                        "type": str,
+                        "nargs": "?",
+                        "default": None,
+                        "const": "USE_GIT_COMMITS",
+                        "choices": ["USE_GIT_COMMITS"]
+                        + [str(increment) for increment in VersionIncrement],
+                        "exclusive_group": "group2",
+                    },
+                    {
+                        "name": "manual_version",
+                        "type": str,
+                        "nargs": "?",
+                        "help": "Use the version provided instead of the version from the project. Can be used to test the selected version scheme.",
+                        "metavar": "MANUAL_VERSION",
+                    },
                 ],
             },
         ],
@@ -670,7 +704,7 @@ def main() -> None:
             logger.warning(
                 "\nWARN: Incomplete commit command: received -- separator without any following git arguments\n"
             )
-        extra_args = " ".join(unknown_args[1:])
+        extra_args = unknown_args[1:]
         arguments["extra_cli_args"] = extra_args
 
     conf = config.read_cfg(args.config)

commitizen-4.15.1/commitizen/cmd.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import warnings
+from typing import TYPE_CHECKING, NamedTuple, overload
+
+from charset_normalizer import from_bytes
+
+from commitizen.exceptions import CharacterSetDecodeError
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+
+class Command(NamedTuple):
+    out: str
+    err: str
+    stdout: bytes
+    stderr: bytes
+    return_code: int
+
+
+def _try_decode(bytes_: bytes) -> str:
+    try:
+        return bytes_.decode("utf-8")
+    except UnicodeDecodeError:
+        pass
+
+    charset_match = from_bytes(bytes_).best()
+    if charset_match is None:
+        raise CharacterSetDecodeError()
+    try:
+        return bytes_.decode(charset_match.encoding)
+    except UnicodeDecodeError as e:
+        raise CharacterSetDecodeError() from e
+
+
+def _popen(
+    cmd: str | Sequence[str],
+    *,
+    shell: bool,
+    env: Mapping[str, str] | None = None,
+) -> Command:
+    if env is not None:
+        env = {**os.environ, **env}
+
+    process = subprocess.Popen(
+        cmd,
+        shell=shell,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        stdin=subprocess.PIPE,
+        env=env,
+    )
+    stdout, stderr = process.communicate()
+    return_code = process.returncode
+    return Command(
+        _try_decode(stdout),
+        _try_decode(stderr),
+        stdout,
+        stderr,
+        return_code,
+    )
+
+
+@overload
+def run(cmd: str, env: Mapping[str, str] | None = None) -> Command: ...
+
+
+@overload
+def run(cmd: Sequence[str], env: Mapping[str, str] | None = None) -> Command: ...
+
+
+def run(cmd: str | Sequence[str], env: Mapping[str, str] | None = None) -> Command:
+    """Run a command safely without shell interpretation (shell=False).
+
+    Arguments are passed directly to the OS, preventing shell-injection
+    vulnerabilities (CWE-78).
+
+    Passing a string is deprecated and will be removed in a future version.
+    Use a list of arguments instead, or use run_shell() for shell features.
+    """
+    if isinstance(cmd, str):
+        warnings.warn(
+            "Passing a string to cmd.run() is deprecated and will be removed in v5. "
+            "Use a list of arguments instead, or use cmd.run_shell() explicitly.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _popen(cmd, shell=True, env=env)
+    return _popen(cmd, shell=False, env=env)
+
+
+def run_shell(cmd: str, env: Mapping[str, str] | None = None) -> Command:
+    """Run a command string via the system shell (shell=True).
+
+    Only use this for cases that intentionally require shell features
+    (e.g., user-defined hooks with pipes/redirects). Never pass
+    untrusted/user-controlled values into *cmd*.
+
+    Related: CWE-78 (OS Command Injection),
+    https://github.com/commitizen-tools/commitizen/issues/1918
+    """
+    return _popen(cmd, shell=True, env=env)

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/commands/bump.py

@@ -439,8 +439,8 @@ class Bump:
         else:
             out.success("Done!")
 
-    def _get_commit_args(self) -> str:
+    def _get_commit_args(self) -> list[str]:
         commit_args = ["-a"]
         if self.no_verify:
             commit_args.append("--no-verify")
-        return " ".join(commit_args)
+        return commit_args

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/commands/changelog.py

@@ -257,7 +257,7 @@ class Changelog:
                     changelog_meta.latest_version_position = None
                     changelog_meta.unreleased_end = latest_full_release_info.index + 1
 
-        commits = git.get_commits(start=start_rev, end=end_rev, args="--topo-order")
+        commits = git.get_commits(start=start_rev, end=end_rev, args=["--topo-order"])
         if (
             not self.allow_no_commit
             and not commits

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/commands/commit.py

@@ -34,7 +34,7 @@ class CommitArgs(TypedDict, total=False):
     all: bool
     dry_run: bool
     edit: bool
-    extra_cli_args: str
+    extra_cli_args: list[str]
     message_length_limit: int
     no_retry: bool
     signoff: bool
@@ -132,7 +132,7 @@ class Commit:
         return self._get_message_by_prompt_commit_questions()
 
     def __call__(self) -> None:
-        extra_args = self.arguments.get("extra_cli_args", "")
+        extra_args: list[str] = self.arguments.get("extra_cli_args", [])
         dry_run = bool(self.arguments.get("dry_run"))
         write_message_to_file = self.arguments.get("write_message_to_file")
         signoff = bool(self.arguments.get("signoff"))
@@ -167,7 +167,7 @@ class Commit:
             raise DryRunExit()
 
         if self.config.settings["always_signoff"] or signoff:
-            extra_args = f"{extra_args} -s".strip()
+            extra_args = [*extra_args, "-s"]
 
         c = git.commit(commit_message, args=extra_args)
         if c.return_code != 0:

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/commands/init.py

@@ -17,7 +17,11 @@ from commitizen.exceptions import (
     NoAnswersError,
 )
 from commitizen.git import get_latest_tag_name, get_tag_names, smart_open
-from commitizen.version_schemes import KNOWN_SCHEMES, Version, get_version_scheme
+from commitizen.version_schemes import (
+    KNOWN_SCHEMES,
+    VersionProtocol,
+    get_version_scheme,
+)
 
 if TYPE_CHECKING:
     from commitizen.config import (
@@ -130,11 +134,12 @@ class Init:
                     "pre-commit is not installed in current environment."
                 )
 
-            cmd_str = "pre-commit install " + " ".join(
-                f"--hook-type {ty}" for ty in hook_types
-            )
-            c = cmd.run(cmd_str)
+            cmd_args = ["pre-commit", "install"]
+            for ty in hook_types:
+                cmd_args.extend(["--hook-type", ty])
+            c = cmd.run(cmd_args)
             if c.return_code != 0:
+                cmd_str = " ".join(cmd_args)
                 raise InitFailedError(
                     "Failed to install pre-commit hook.\n"
                     f"Error running {cmd_str}."
@@ -265,7 +270,7 @@ class Init:
         ).unsafe_ask()
         return scheme
 
-    def _ask_major_version_zero(self, version: Version) -> bool:
+    def _ask_major_version_zero(self, version: VersionProtocol) -> bool:
         """Ask for setting: major_version_zero"""
         if version.major > 0:
             return False
@@ -323,7 +328,7 @@ def _write_config_to_file(
     cz_name: str,
     version_provider: str,
     version_scheme: str,
-    version: Version,
+    version: VersionProtocol,
     tag_format: str,
     update_changelog_on_bump: bool,
     major_version_zero: bool,

commitizen-4.15.1/commitizen/commands/version.py

@@ -0,0 +1,141 @@
+import platform
+import sys
+from typing import TypedDict
+
+from packaging.version import InvalidVersion
+
+from commitizen import out
+from commitizen.__version__ import __version__
+from commitizen.config import BaseConfig
+from commitizen.exceptions import NoVersionSpecifiedError, VersionSchemeUnknown
+from commitizen.providers import get_provider
+from commitizen.tags import TagRules
+from commitizen.version_increment import VersionIncrement
+from commitizen.version_schemes import Increment, get_version_scheme
+
+
+class VersionArgs(TypedDict, total=False):
+    manual_version: str | None
+    next: str | None
+
+    # Exclusive groups 1
+    commitizen: bool
+    report: bool
+    project: bool
+    verbose: bool
+
+    # Exclusive groups 2
+    major: bool
+    minor: bool
+    patch: bool
+    tag: bool
+
+
+class Version:
+    """Get the version of the installed commitizen or the current project.
+    Precedence:
+    1. report
+    2. commitizen
+    3. verbose, project
+    """
+
+    def __init__(self, config: BaseConfig, arguments: VersionArgs) -> None:
+        self.config: BaseConfig = config
+        self.arguments = arguments
+
+    def __call__(self) -> None:
+        if self.arguments.get("report"):
+            out.write(f"Commitizen Version: {__version__}")
+            out.write(f"Python Version: {sys.version}")
+            out.write(f"Operating System: {platform.system()}")
+            return
+
+        if self.arguments.get("verbose"):
+            out.write(f"Installed Commitizen Version: {__version__}")
+
+        if self.arguments.get("commitizen"):
+            out.write(__version__)
+            return
+
+        if (
+            self.arguments.get("project")
+            or self.arguments.get("verbose")
+            or self.arguments.get("next")
+            or self.arguments.get("manual_version")
+        ):
+            version_str = self.arguments.get("manual_version")
+            if version_str is None:
+                try:
+                    version_str = get_provider(self.config).get_version()
+                except NoVersionSpecifiedError:
+                    out.error("No project information in this project.")
+                    return
+            try:
+                scheme_factory = get_version_scheme(self.config.settings)
+            except VersionSchemeUnknown:
+                out.error("Unknown version scheme.")
+                return
+
+            try:
+                version = scheme_factory(version_str)
+            except InvalidVersion:
+                out.error(f"Invalid version: '{version_str}'")
+                return
+
+            if next_increment_str := self.arguments.get("next"):
+                if next_increment_str == "USE_GIT_COMMITS":
+                    # TODO: implement USE_GIT_COMMITS by deriving the increment from
+                    # git history. This requires refactoring the bump logic out of
+                    # `commitizen/commands/bump.py` so it can be reused here. See #1678.
+                    out.error("--next USE_GIT_COMMITS is not implemented yet.")
+                    return
+
+                next_increment = VersionIncrement.from_value(next_increment_str)
+                increment: Increment | None
+                if next_increment == VersionIncrement.NONE:
+                    increment = None
+                elif next_increment == VersionIncrement.PATCH:
+                    increment = "PATCH"
+                elif next_increment == VersionIncrement.MINOR:
+                    increment = "MINOR"
+                else:
+                    increment = "MAJOR"
+                version = version.bump(increment=increment)
+
+            if self.arguments.get("major"):
+                out.write(version.major)
+                return
+            if self.arguments.get("minor"):
+                out.write(version.minor)
+                return
+            if self.arguments.get("patch"):
+                out.write(version.micro)
+                return
+
+            display_version: str
+            if self.arguments.get("tag"):
+                tag_rules = TagRules.from_settings(self.config.settings)
+                display_version = tag_rules.normalize_tag(version)
+            else:
+                display_version = str(version)
+
+            out.write(
+                f"Project Version: {display_version}"
+                if self.arguments.get("verbose")
+                else display_version
+            )
+            return
+
+        for argument in ("major", "minor", "patch"):
+            if self.arguments.get(argument):
+                out.error(
+                    f"{argument} can only be used with MANUAL_VERSION, --project or --verbose."
+                )
+                return
+
+        if self.arguments.get("tag"):
+            out.error("Tag can only be used with --project or --verbose.")
+            return
+
+        # If no arguments are provided, just show the installed commitizen version
+        out.write(__version__)

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/git.py

@@ -5,10 +5,14 @@ from enum import Enum
 from functools import lru_cache
 from pathlib import Path
 from tempfile import NamedTemporaryFile
+from typing import TYPE_CHECKING
 
 from commitizen import cmd, out
 from commitizen.exceptions import GitCommandError
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class EOLType(Enum):
     """The EOL type from `git config core.eol`."""
@@ -19,7 +23,7 @@ class EOLType(Enum):
 
     @classmethod
     def for_open(cls) -> str:
-        c = cmd.run("git config core.eol")
+        c = cmd.run(["git", "config", "core.eol"])
         eol = c.out.strip().upper()
         return cls._char_for_open()[cls._safe_cast(eol)]
 
@@ -164,49 +168,47 @@ def tag(
     tag: str, annotated: bool = False, signed: bool = False, msg: str | None = None
 ) -> cmd.Command:
     if not annotated and not signed:
-        return cmd.run(f"git tag {tag}")
+        return cmd.run(["git", "tag", 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
     option = "-s" if signed else "-a"  # The else case is for annotated tags
-    return cmd.run(f'git tag {option} {tag} -m "{msg or tag}"')
+    return cmd.run(["git", "tag", option, tag, "-m", msg or tag])
 
 
 def add(*args: str) -> cmd.Command:
-    return cmd.run(f"git add {' '.join(args)}")
+    return cmd.run(["git", "add", *args])
 
 
 def commit(
     message: str,
-    args: str = "",
+    args: Sequence[str] = (),
     committer_date: str | None = None,
 ) -> cmd.Command:
     f = NamedTemporaryFile("wb", delete=False)
     f.write(message.encode("utf-8"))
     f.close()
 
-    command = _create_commit_cmd_string(args, committer_date, f.name)
-    c = cmd.run(command)
-    os.unlink(f.name)
-    return c
+    cmd_args = ["git", "commit"]
+    if args:
+        cmd_args.extend(args)
+    cmd_args.extend(["-F", f.name])
 
+    env: dict[str, str] | None = None
+    if committer_date:
+        env = {"GIT_COMMITTER_DATE": committer_date}
 
-def _create_commit_cmd_string(args: str, committer_date: str | None, name: str) -> str:
-    command = f'git commit {args} -F "{name}"'
-    if not committer_date:
-        return command
-    if os.name != "nt":
-        return f"GIT_COMMITTER_DATE={committer_date} {command}"
-    # Using `cmd /v /c "{command}"` sets environment variables only for that command
-    return f'cmd /v /c "set GIT_COMMITTER_DATE={committer_date}&& {command}"'
+    c = cmd.run(cmd_args, env=env)
+    os.unlink(f.name)
+    return c
 
 
 def get_commits(
     start: str | None = None,
     end: str | None = None,
     *,
-    args: str = "",
+    args: Sequence[str] = (),
 ) -> list[GitCommit]:
     """Get the commits between start and end."""
     if end is None:
@@ -226,7 +228,10 @@ def get_filenames_in_commit(git_reference: str = "") -> list[str]:
 
     :returns: file names committed in the last commit by default or inside the passed git reference
     """
-    c = cmd.run(f"git show --name-only --pretty=format: {git_reference}")
+    cmd_args = ["git", "show", "--name-only", "--pretty=format:"]
+    if git_reference:
+        cmd_args.append(git_reference)
+    c = cmd.run(cmd_args)
     if c.return_code == 0:
         return c.out.strip().split("\n")
     raise GitCommandError(c.err)
@@ -237,15 +242,17 @@ def get_tags(
 ) -> list[GitTag]:
     inner_delimiter = "---inner_delimiter---"
     formatter = (
-        f'"%(refname:strip=2){inner_delimiter}'
+        f"%(refname:strip=2){inner_delimiter}"
         f"%(objectname){inner_delimiter}"
         f"%(creatordate:format:{dateformat}){inner_delimiter}"
-        f'%(object)"'
+        f"%(object)"
     )
-    extra = "--merged" if reachable_only else ""
+    cmd_args = ["git", "tag", f"--format={formatter}", "--sort=-creatordate"]
+    if reachable_only:
+        cmd_args.append("--merged")
     # Force the default language for parsing
     env = {"LC_ALL": "C", "LANG": "C", "LANGUAGE": "C"}
-    c = cmd.run(f"git tag --format={formatter} --sort=-creatordate {extra}", env=env)
+    c = cmd.run(cmd_args, env=env)
     if c.return_code != 0:
         if reachable_only and c.err == "fatal: malformed object name HEAD\n":
             # this can happen if there are no commits in the repo yet
@@ -262,37 +269,37 @@ def get_tags(
 
 
 def tag_exist(tag: str) -> bool:
-    c = cmd.run(f"git tag --list {tag}")
+    c = cmd.run(["git", "tag", "--list", tag])
     return tag in c.out
 
 
 def is_signed_tag(tag: str) -> bool:
-    return cmd.run(f"git tag -v {tag}").return_code == 0
+    return cmd.run(["git", "tag", "-v", tag]).return_code == 0
 
 
 def get_latest_tag_name() -> str | None:
-    c = cmd.run("git describe --abbrev=0 --tags")
+    c = cmd.run(["git", "describe", "--abbrev=0", "--tags"])
     if c.err:
         return None
     return c.out.strip()
 
 
 def get_tag_message(tag: str) -> str | None:
-    c = cmd.run(f"git tag -l --format='%(contents:subject)' {tag}")
+    c = cmd.run(["git", "tag", "-l", "--format=%(contents:subject)", tag])
     if c.err:
         return None
     return c.out.strip()
 
 
 def get_tag_names() -> list[str]:
-    c = cmd.run("git tag --list")
+    c = cmd.run(["git", "tag", "--list"])
     if c.err:
         return []
     return [tag for raw in c.out.split("\n") if (tag := raw.strip())]
 
 
 def find_git_project_root() -> Path | None:
-    c = cmd.run("git rev-parse --show-toplevel")
+    c = cmd.run(["git", "rev-parse", "--show-toplevel"])
     if c.err:
         return None
     return Path(c.out.strip())
@@ -300,17 +307,17 @@ def find_git_project_root() -> Path | None:
 
 def is_staging_clean() -> bool:
     """Check if staging is clean."""
-    c = cmd.run("git diff --no-ext-diff --cached --name-only")
+    c = cmd.run(["git", "diff", "--no-ext-diff", "--cached", "--name-only"])
     return not bool(c.out)
 
 
 def is_git_project() -> bool:
-    c = cmd.run("git rev-parse --is-inside-work-tree")
+    c = cmd.run(["git", "rev-parse", "--is-inside-work-tree"])
     return c.out.strip() == "true"
 
 
 def get_core_editor() -> str | None:
-    c = cmd.run("git var GIT_EDITOR")
+    c = cmd.run(["git", "var", "GIT_EDITOR"])
     if c.out:
         return c.out.strip()
     return None
@@ -321,21 +328,31 @@ def smart_open(*args, **kwargs):  # type: ignore[no-untyped-def,unused-ignore] #
     return open(*args, newline=EOLType.for_open(), **kwargs)
 
 
-def _get_log_as_str_list(start: str | None, end: str, args: str) -> list[str]:
+def _get_log_as_str_list(start: str | None, end: str, args: Sequence[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"
     command_range = f"{start}..{end}" if start else end
-    command = f"git -c log.showSignature=False log --pretty={log_format}{delimiter} {args} {command_range}"
+    cmd_args = [
+        "git",
+        "-c",
+        "log.showSignature=False",
+        "log",
+        f"--pretty={log_format}{delimiter}",
+    ]
+    if args:
+        cmd_args.extend(args)
+    if command_range:
+        cmd_args.append(command_range)
 
-    c = cmd.run(command)
+    c = cmd.run(cmd_args)
     if c.return_code != 0:
         raise GitCommandError(c.err)
     return c.out.split(f"{delimiter}\n")
 
 
 def get_default_branch() -> str:
-    c = cmd.run("git symbolic-ref refs/remotes/origin/HEAD")
+    c = cmd.run(["git", "symbolic-ref", "refs/remotes/origin/HEAD"])
     if c.return_code != 0:
         raise GitCommandError(c.err)
     return c.out.strip()

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/hooks.py

@@ -17,7 +17,7 @@ def run(hooks: str | list[str], _env_prefix: str = "CZ_", **env: object) -> None
     for hook in hooks:
         out.info(f"Running hook '{hook}'")
 
-        c = cmd.run(hook, env=_format_env(_env_prefix, env))
+        c = cmd.run_shell(hook, env=_format_env(_env_prefix, env))
 
         if c.out:
             out.write(c.out)

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/out.py

@@ -9,35 +9,35 @@ if sys.platform == "win32":
         sys.stdout.reconfigure(encoding="utf-8")
 
 
-def write(value: str, *args: object) -> None:
+def write(value: object, *args: object) -> None:
     """Intended to be used when value is multiline."""
     print(value, *args)
 
 
-def line(value: str, *args: object, **kwargs: Any) -> None:
+def line(value: object, *args: object, **kwargs: Any) -> None:
     """Wrapper in case I want to do something different later."""
     print(value, *args, **kwargs)
 
 
-def error(value: str) -> None:
-    message = colored(value, "red")
+def error(value: object) -> None:
+    message = colored(str(value), "red")
     line(message, file=sys.stderr)
 
 
-def success(value: str) -> None:
-    message = colored(value, "green")
+def success(value: object) -> None:
+    message = colored(str(value), "green")
     line(message)
 
 
-def info(value: str) -> None:
-    message = colored(value, "blue")
+def info(value: object) -> None:
+    message = colored(str(value), "blue")
     line(message)
 
 
-def diagnostic(value: str) -> None:
+def diagnostic(value: object) -> None:
     line(value, file=sys.stderr)
 
 
-def warn(value: str) -> None:
-    message = colored(value, "magenta")
+def warn(value: object) -> None:
+    message = colored(str(value), "magenta")
     line(message, file=sys.stderr)

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/tags.py

@@ -14,7 +14,7 @@ from commitizen.git import GitTag
 from commitizen.version_schemes import (
     DEFAULT_SCHEME,
     InvalidVersion,
-    Version,
+    VersionProtocol,
     VersionScheme,
     get_version_scheme,
 )
@@ -23,8 +23,6 @@ if TYPE_CHECKING:
     import sys
     from collections.abc import Iterable, Sequence
 
-    from commitizen.version_schemes import VersionScheme
-
     # Self is Python 3.11+ but backported in typing-extensions
     if sys.version_info < (3, 11):
         from typing_extensions import Self
@@ -75,7 +73,7 @@ class TagRules:
     assert not rules.is_version_tag("warn1.0.0", warn=True)  # Does warn
 
     assert rules.search_version("# My v1.0.0 version").version == "1.0.0"
-    assert rules.extract_version("v1.0.0") == Version("1.0.0")
+    assert rules.extract_version("v1.0.0") == rules.scheme("1.0.0")
     try:
         assert rules.extract_version("not-a-v1.0.0")
     except InvalidVersion:
@@ -145,7 +143,7 @@ class TagRules:
         """Filter in version tags and warn on unexpected tags"""
         return [tag for tag in tags if self.is_version_tag(tag, warn)]
 
-    def extract_version(self, tag: GitTag) -> Version:
+    def extract_version(self, tag: GitTag) -> VersionProtocol:
         """
         Extract a version from the tag as defined in tag formats.
 
@@ -195,7 +193,7 @@ class TagRules:
         return VersionTag(version, match.group(0))
 
     def normalize_tag(
-        self, version: Version | str, tag_format: str | None = None
+        self, version: VersionProtocol | str, tag_format: str | None = None
     ) -> str:
         """
         The tag and the software version might be different.
@@ -225,7 +223,7 @@ class TagRules:
         )
 
     def find_tag_for(
-        self, tags: Iterable[GitTag], version: Version | str
+        self, tags: Iterable[GitTag], version: VersionProtocol | str
     ) -> GitTag | None:
         """Find the first matching tag for a given version."""
         version = self.scheme(version) if isinstance(version, str) else version
@@ -234,7 +232,7 @@ class TagRules:
         # If the requested version is incomplete (e.g., "1.2"), try to find the latest
         # matching tag that shares the provided prefix.
         if len(release) < 3:
-            matching_versions: list[tuple[Version, GitTag]] = []
+            matching_versions: list[tuple[VersionProtocol, GitTag]] = []
             for tag in tags:
                 try:
                     tag_version = self.extract_version(tag)

commitizen-4.15.1/commitizen/version_increment.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class VersionIncrement(IntEnum):
+    """Semantic versioning bump increments.
+
+    IntEnum keeps a total order compatible with NONE < PATCH < MINOR < MAJOR
+    for comparisons across the codebase.
+
+    - NONE: no bump (docs-only / style commits, etc.)
+    - PATCH: backwards-compatible bug fixes
+    - MINOR: backwards-compatible features
+    - MAJOR: incompatible API changes
+    """
+
+    NONE = 0
+    PATCH = 1
+    MINOR = 2
+    MAJOR = 3
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def from_value(cls, value: object) -> VersionIncrement:
+        if not isinstance(value, str):
+            return VersionIncrement.NONE
+        try:
+            return cls[value]
+        except KeyError:
+            return VersionIncrement.NONE

{commitizen-4.14.0 → commitizen-4.15.1}/commitizen/version_schemes.py

@@ -10,6 +10,7 @@ from typing import (
     ClassVar,
     Literal,
     Protocol,
+    TypeAlias,
     cast,
     runtime_checkable,
 )
@@ -22,7 +23,6 @@ from commitizen.exceptions import VersionSchemeUnknown
 
 if TYPE_CHECKING:
     import sys
-    from typing import TypeAlias
 
     # Self is Python 3.11+ but backported in typing-extensions
     if sys.version_info < (3, 11):
@@ -31,7 +31,7 @@ if TYPE_CHECKING:
         from typing import Self
 
 
-Increment: TypeAlias = Literal["MAJOR", "MINOR", "PATCH"]
+Increment: TypeAlias = Literal["MAJOR", "MINOR", "PATCH"]  # TODO: deprecate
 Prerelease: TypeAlias = Literal["alpha", "beta", "rc"]
 _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+)?)"
@@ -140,7 +140,7 @@ class VersionProtocol(Protocol):
         """
 
 
-# With PEP 440 and SemVer semantic, Scheme is the type, Version is an instance
+# With PEP 440 and SemVer semantics, a scheme is the class; a version is an instance.
 Version: TypeAlias = VersionProtocol
 VersionScheme: TypeAlias = type[VersionProtocol]
 
@@ -422,7 +422,16 @@ def get_version_scheme(settings: Settings, name: str | None = None) -> VersionSc
         raise VersionSchemeUnknown(f'Version scheme "{name}" unknown.')
     scheme = cast("VersionScheme", ep.load())
 
-    if not isinstance(scheme, VersionProtocol):
+    # `VersionProtocol` is a `@runtime_checkable` Protocol, but `issubclass()` is not
+    # supported for Protocols with non-method members. We check an instance instead by
+    # verifying the loaded object is a class with the expected interface.
+    if isinstance(scheme, type):
+        # Check for a key method/attribute that VersionProtocol requires
+        if not hasattr(scheme, "bump"):
+            warnings.warn(
+                f"Version scheme {name} does not implement the VersionProtocol"
+            )
+    else:
         warnings.warn(f"Version scheme {name} does not implement the VersionProtocol")
 
     return scheme

{commitizen-4.14.0 → commitizen-4.15.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "commitizen"
-version = "4.14.0"
+version = "4.15.1"
 description = "Python commitizen client tool"
 authors = [{ name = "Santiago Fraire", email = "santiwilly@gmail.com" }]
 maintainers = [

commitizen-4.14.0/commitizen/__version__.py

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

commitizen-4.14.0/commitizen/cmd.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import os
-import subprocess
-from typing import TYPE_CHECKING, NamedTuple
-
-from charset_normalizer import from_bytes
-
-from commitizen.exceptions import CharacterSetDecodeError
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
-
-class Command(NamedTuple):
-    out: str
-    err: str
-    stdout: bytes
-    stderr: bytes
-    return_code: int
-
-
-def _try_decode(bytes_: bytes) -> str:
-    try:
-        return bytes_.decode("utf-8")
-    except UnicodeDecodeError:
-        pass
-
-    charset_match = from_bytes(bytes_).best()
-    if charset_match is None:
-        raise CharacterSetDecodeError()
-    try:
-        return bytes_.decode(charset_match.encoding)
-    except UnicodeDecodeError as e:
-        raise CharacterSetDecodeError() from e
-
-
-def run(cmd: str, env: Mapping[str, str] | None = None) -> Command:
-    if env is not None:
-        env = {**os.environ, **env}
-    process = subprocess.Popen(
-        cmd,
-        shell=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        stdin=subprocess.PIPE,
-        env=env,
-    )
-    stdout, stderr = process.communicate()
-    return_code = process.returncode
-    return Command(
-        _try_decode(stdout),
-        _try_decode(stderr),
-        stdout,
-        stderr,
-        return_code,
-    )

commitizen-4.14.0/commitizen/commands/version.py

@@ -1,86 +0,0 @@
-import platform
-import sys
-from typing import TypedDict
-
-from commitizen import out
-from commitizen.__version__ import __version__
-from commitizen.config import BaseConfig
-from commitizen.exceptions import NoVersionSpecifiedError, VersionSchemeUnknown
-from commitizen.providers import get_provider
-from commitizen.tags import TagRules
-from commitizen.version_schemes import get_version_scheme
-
-
-class VersionArgs(TypedDict, total=False):
-    commitizen: bool
-    report: bool
-    project: bool
-    verbose: bool
-    major: bool
-    minor: bool
-    tag: bool
-
-
-class Version:
-    """Get the version of the installed commitizen or the current project.
-    Precedence:
-    1. report
-    2. commitizen
-    3. verbose, project
-    """
-
-    def __init__(self, config: BaseConfig, arguments: VersionArgs) -> None:
-        self.config: BaseConfig = config
-        self.arguments = arguments
-
-    def __call__(self) -> None:
-        if self.arguments.get("report"):
-            out.write(f"Commitizen Version: {__version__}")
-            out.write(f"Python Version: {sys.version}")
-            out.write(f"Operating System: {platform.system()}")
-            return
-
-        if self.arguments.get("verbose"):
-            out.write(f"Installed Commitizen Version: {__version__}")
-
-        if not self.arguments.get("commitizen") and (
-            self.arguments.get("project") or self.arguments.get("verbose")
-        ):
-            try:
-                version = get_provider(self.config).get_version()
-            except NoVersionSpecifiedError:
-                out.error("No project information in this project.")
-                return
-            try:
-                version_scheme = get_version_scheme(self.config.settings)(version)
-            except VersionSchemeUnknown:
-                out.error("Unknown version scheme.")
-                return
-
-            if self.arguments.get("major"):
-                version = f"{version_scheme.major}"
-            elif self.arguments.get("minor"):
-                version = f"{version_scheme.minor}"
-            elif self.arguments.get("tag"):
-                tag_rules = TagRules.from_settings(self.config.settings)
-                version = tag_rules.normalize_tag(version_scheme)
-
-            out.write(
-                f"Project Version: {version}"
-                if self.arguments.get("verbose")
-                else version
-            )
-            return
-
-        if self.arguments.get("major") or self.arguments.get("minor"):
-            out.error(
-                "Major or minor version can only be used with --project or --verbose."
-            )
-            return
-
-        if self.arguments.get("tag"):
-            out.error("Tag can only be used with --project or --verbose.")
-            return
-
-        # If no arguments are provided, just show the installed commitizen version
-        out.write(__version__)