commitizen 4.13.10__tar.gz → 4.15.0__tar.gz

{commitizen-4.13.10 → commitizen-4.15.0}/PKG-INFO

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

commitizen-4.15.0/commitizen/__version__.py

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

{commitizen-4.13.10 → commitizen-4.15.0}/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.13.10 → commitizen-4.15.0}/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",
+                    },
                 ],
             },
         ],

{commitizen-4.13.10 → commitizen-4.15.0}/commitizen/commands/bump.py

@@ -330,7 +330,11 @@ class Bump:
 
             changelog_cmd = Changelog(
                 self.config,
-                {**changelog_args, "file_name": self.file_name},  # type: ignore[typeddict-item]
+                {
+                    **changelog_args,  # type: ignore[typeddict-item]
+                    "file_name": self.file_name,
+                    "allow_no_commit": bool(self.arguments["allow_no_commit"]),
+                },
             )
             changelog_cmd()
             changelog_file_name = changelog_cmd.file_name

{commitizen-4.13.10 → commitizen-4.15.0}/commitizen/commands/changelog.py

@@ -43,6 +43,7 @@ class ChangelogArgs(TypedDict, total=False):
     extras: dict[str, Any]
     export_template: str
     during_version_bump: bool | None
+    allow_no_commit: bool | None  # Internal-only when invoked by bump.
 
 
 class Changelog:
@@ -124,6 +125,8 @@ class Changelog:
         self.export_template_to = arguments.get("export_template")
 
         self.during_version_bump: bool = arguments.get("during_version_bump") or False
+        # Internal flag used when changelog is invoked from `cz bump --allow-no-commit`.
+        self.allow_no_commit: bool = bool(arguments.get("allow_no_commit"))
 
     def _find_incremental_rev(self, latest_version: str, tags: Iterable[GitTag]) -> str:
         """Try to find the 'start_rev'.
@@ -255,8 +258,10 @@ class Changelog:
                     changelog_meta.unreleased_end = latest_full_release_info.index + 1
 
         commits = git.get_commits(start=start_rev, end=end_rev, args="--topo-order")
-        if not commits and (
-            self.current_version is None or not self.current_version.is_prerelease
+        if (
+            not self.allow_no_commit
+            and not commits
+            and (self.current_version is None or not self.current_version.is_prerelease)
         ):
             raise NoCommitsFoundError("No commits found")
 

{commitizen-4.13.10 → commitizen-4.15.0}/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 (
@@ -265,7 +269,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 +327,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.0/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.13.10 → commitizen-4.15.0}/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.13.10 → commitizen-4.15.0}/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.0/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.13.10 → commitizen-4.15.0}/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.13.10 → commitizen-4.15.0}/pyproject.toml

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

commitizen-4.13.10/commitizen/__version__.py

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

commitizen-4.13.10/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__)