commitizen 4.13.1__tar.gz → 4.13.3__tar.gz

{commitizen-4.13.1 → commitizen-4.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: commitizen
-Version: 4.13.1
+Version: 4.13.3
 Summary: Python commitizen client tool
 Keywords: commitizen,conventional,commits,git
 Author: Santiago Fraire

commitizen-4.13.3/commitizen/__version__.py

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

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/changelog_formats/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import os
 from abc import ABCMeta
+from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any, ClassVar
 
 from commitizen.changelog import IncrementalMergeInfo, Metadata
@@ -36,12 +36,11 @@ class BaseFormat(ChangelogFormat, metaclass=ABCMeta):
         )
 
     def get_metadata(self, filepath: str) -> Metadata:
-        if not os.path.isfile(filepath):
+        file = Path(filepath)
+        if not file.is_file():
             return Metadata()
 
-        with open(
-            filepath, encoding=self.config.settings["encoding"]
-        ) as changelog_file:
+        with file.open(encoding=self.config.settings["encoding"]) as changelog_file:
             return self.get_metadata_from_file(changelog_file)
 
     def get_metadata_from_file(self, file: IO[Any]) -> Metadata:
@@ -74,12 +73,11 @@ class BaseFormat(ChangelogFormat, metaclass=ABCMeta):
         return meta
 
     def get_latest_full_release(self, filepath: str) -> IncrementalMergeInfo:
-        if not os.path.isfile(filepath):
+        file = Path(filepath)
+        if not file.is_file():
             return IncrementalMergeInfo()
 
-        with open(
-            filepath, encoding=self.config.settings["encoding"]
-        ) as changelog_file:
+        with file.open(encoding=self.config.settings["encoding"]) as changelog_file:
             return self.get_latest_full_release_from_file(changelog_file)
 
     def get_latest_full_release_from_file(self, file: IO[Any]) -> IncrementalMergeInfo:

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/commands/changelog.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import os
-import os.path
 from difflib import SequenceMatcher
 from operator import itemgetter
 from pathlib import Path
@@ -66,7 +64,7 @@ class Changelog:
                 f"or the setting `changelog_file` in {self.config.path}"
             )
         self.file_name = (
-            os.path.join(str(self.config.path.parent), changelog_file_name)
+            Path(self.config.path.parent, changelog_file_name).as_posix()
             if self.config.path is not None
             else changelog_file_name
         )
@@ -282,9 +280,10 @@ class Changelog:
             raise DryRunExit()
 
         lines = []
-        if self.incremental and os.path.isfile(self.file_name):
-            with open(
-                self.file_name, encoding=self.config.settings["encoding"]
+        changelog_path = Path(self.file_name)
+        if self.incremental and changelog_path.is_file():
+            with changelog_path.open(
+                encoding=self.config.settings["encoding"]
             ) as changelog_file:
                 lines = changelog_file.readlines()
 

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/commands/commit.py

@@ -61,9 +61,7 @@ class Commit:
             return None
 
         # Read commit message from backup
-        with open(
-            self.backup_file_path, encoding=self.config.settings["encoding"]
-        ) as f:
+        with self.backup_file_path.open(encoding=self.config.settings["encoding"]) as f:
             return f.read().strip()
 
     def _get_message_by_prompt_commit_questions(self) -> str:

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/commands/init.py

@@ -288,11 +288,12 @@ class Init:
             ],
         }
 
-        if not Path(".pre-commit-config.yaml").is_file():
+        pre_commit_config_path = Path(self._PRE_COMMIT_CONFIG_PATH)
+        if not pre_commit_config_path.is_file():
             return {"repos": [CZ_HOOK_CONFIG]}
 
-        with open(
-            self._PRE_COMMIT_CONFIG_PATH, encoding=self.config.settings["encoding"]
+        with pre_commit_config_path.open(
+            encoding=self.config.settings["encoding"]
         ) as config_file:
             config_data: dict[str, Any] = yaml.safe_load(config_file) or {}
 

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/config/__init__.py

@@ -28,10 +28,8 @@ def _resolve_config_candidates() -> list[BaseConfig]:
 
 
 def _create_config_from_path(path: Path) -> BaseConfig:
-    with open(path, "rb") as f:
-        data: bytes = f.read()
-
-    return create_config(data=data, path=path)
+    with path.open("rb") as f:
+        return create_config(data=f.read(), path=path)
 
 
 def read_cfg(filepath: str | None = None) -> BaseConfig:

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/config/toml_config.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 from typing import TYPE_CHECKING
 
 from tomlkit import TOMLDocument, exceptions, parse, table
@@ -33,25 +32,25 @@ class TomlConfig(BaseConfig):
 
     def init_empty_config_content(self) -> None:
         config_doc = TOMLDocument()
-        if os.path.isfile(self.path):
-            with open(self.path, "rb") as input_toml_file:
+        if self.path.is_file():
+            with self.path.open("rb") as input_toml_file:
                 config_doc = parse(input_toml_file.read())
 
         if config_doc.get("tool") is None:
             config_doc["tool"] = table()
         config_doc["tool"]["commitizen"] = table()  # type: ignore[index]
 
-        with open(self.path, "wb") as output_toml_file:
+        with self.path.open("wb") as output_toml_file:
             output_toml_file.write(
                 config_doc.as_string().encode(self._settings["encoding"])
             )
 
     def set_key(self, key: str, value: object) -> Self:
-        with open(self.path, "rb") as f:
+        with self.path.open("rb") as f:
             config_doc = parse(f.read())
 
         config_doc["tool"]["commitizen"][key] = value  # type: ignore[index]
-        with open(self.path, "wb") as f:
+        with self.path.open("wb") as f:
             f.write(config_doc.as_string().encode(self._settings["encoding"]))
 
         return self

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/config/yaml_config.py

@@ -56,7 +56,7 @@ class YAMLConfig(BaseConfig):
             pass
 
     def set_key(self, key: str, value: object) -> Self:
-        with open(self.path, "rb") as yaml_file:
+        with self.path.open("rb") as yaml_file:
             config_doc = yaml.load(yaml_file, Loader=yaml.FullLoader)
 
         config_doc["commitizen"][key] = value

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/cz/conventional_commits/conventional_commits.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import os
+from pathlib import Path
 from typing import TYPE_CHECKING, TypedDict
 
 from commitizen import defaults
@@ -214,7 +214,6 @@ class ConventionalCommitsCz(BaseCommitizen):
         )
 
     def info(self) -> str:
-        dir_path = os.path.dirname(os.path.realpath(__file__))
-        filepath = os.path.join(dir_path, "conventional_commits_info.txt")
-        with open(filepath, encoding=self.config.settings["encoding"]) as f:
+        filepath = Path(__file__).parent / "conventional_commits_info.txt"
+        with filepath.open(encoding=self.config.settings["encoding"]) as f:
             return f.read()

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/cz/jira/jira.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import os
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from commitizen.cz.base import BaseCommitizen
@@ -73,7 +73,6 @@ class JiraSmartCz(BaseCommitizen):
         return r".*[A-Z]{2,}\-[0-9]+( #| .* #).+( #.+)*"
 
     def info(self) -> str:
-        dir_path = os.path.dirname(os.path.realpath(__file__))
-        filepath = os.path.join(dir_path, "jira_info.txt")
-        with open(filepath, encoding=self.config.settings["encoding"]) as f:
+        filepath = Path(__file__).parent / "jira_info.txt"
+        with filepath.open(encoding=self.config.settings["encoding"]) as f:
             return f.read()

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/providers/cargo_provider.py

@@ -39,7 +39,7 @@ class CargoProvider(TomlProvider):
 
     def set_version(self, version: str) -> None:
         super().set_version(version)
-        if self.lock_file.exists():
+        if self.lock_file.is_file():
             self.set_lock_version(version)
 
     def set_lock_version(self, version: str) -> None:

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/providers/npm_provider.py

@@ -46,14 +46,14 @@ class NpmProvider(VersionProvider):
         self.package_file.write_text(
             json.dumps(package_document, indent=self.indent) + "\n"
         )
-        if self.lock_file.exists():
+        if self.lock_file.is_file():
             lock_document = self.set_lock_version(
                 json.loads(self.lock_file.read_text()), version
             )
             self.lock_file.write_text(
                 json.dumps(lock_document, indent=self.indent) + "\n"
             )
-        if self.shrinkwrap_file.exists():
+        if self.shrinkwrap_file.is_file():
             shrinkwrap_document = self.set_shrinkwrap_version(
                 json.loads(self.shrinkwrap_file.read_text()), version
             )

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/tags.py

@@ -154,24 +154,13 @@ class TagRules:
         candidates = (
             m for regex in self.version_regexes if (m := regex.fullmatch(tag.name))
         )
-        if not (m := next(candidates, None)):
+        if not (match := next(candidates, None)):
             raise InvalidVersion(self._version_tag_error(tag.name))
-        if "version" in m.groupdict():
-            return self.scheme(m.group("version"))
 
-        parts = m.groupdict()
-        version = parts["major"]
+        if version := match.groupdict().get("version"):
+            return self.scheme(version)
 
-        if minor := parts.get("minor"):
-            version = f"{version}.{minor}"
-        if patch := parts.get("patch"):
-            version = f"{version}.{patch}"
-
-        if parts.get("prerelease"):
-            version = f"{version}-{parts['prerelease']}"
-        if parts.get("devrelease"):
-            version = f"{version}{parts['devrelease']}"
-        return self.scheme(version)
+        return self.scheme(self._extract_version(match))
 
     def include_in_changelog(self, tag: GitTag) -> bool:
         """Check if a tag should be included in the changelog"""
@@ -195,19 +184,14 @@ class TagRules:
 
         match = matches[-1 if last else 0]
 
-        if "version" in match.groupdict():
-            return VersionTag(match.group("version"), match.group(0))
+        groups = match.groupdict()
+        if version := groups.get("version"):
+            return VersionTag(version, match.group(0))
 
-        parts = match.groupdict()
-        try:
-            version = f"{parts['major']}.{parts['minor']}.{parts['patch']}"
-        except KeyError:
+        if not all(value in groups for value in ["major", "minor", "patch"]):
             return None
 
-        if parts.get("prerelease"):
-            version = f"{version}-{parts['prerelease']}"
-        if parts.get("devrelease"):
-            version = f"{version}{parts['devrelease']}"
+        version = self._extract_version(match)
         return VersionTag(version, match.group(0))
 
     def normalize_tag(
@@ -284,3 +268,16 @@ class TagRules:
             ignored_tag_formats=settings["ignored_tag_formats"],
             merge_prereleases=settings["changelog_merge_prerelease"],
         )
+
+    def _extract_version(self, match: re.Match[str]) -> str:
+        groups = match.groupdict()
+        parts: list[str] = [groups["major"]]
+        if minor := groups.get("minor"):
+            parts.append(f".{minor}")
+        if patch := groups.get("patch"):
+            parts.append(f".{patch}")
+        if prerelease := groups.get("prerelease"):
+            parts.append(f"-{prerelease}")
+        if devrelease := groups.get("devrelease"):
+            parts.append(devrelease)
+        return "".join(parts)

{commitizen-4.13.1 → commitizen-4.13.3}/commitizen/version_schemes.py

@@ -185,15 +185,10 @@ class BaseVersion(_BaseVersion):
         # https://semver.org/#spec-item-11
         if self.is_prerelease and self.pre:
             prerelease = max(prerelease, self.pre[0])
+            if prerelease.startswith(self.pre[0]):
+                offset = self.pre[1] + 1
 
-        # version.pre is needed for mypy check
-        if self.is_prerelease and self.pre and prerelease.startswith(self.pre[0]):
-            prev_prerelease: int = self.pre[1]
-            new_prerelease_number = prev_prerelease + 1
-        else:
-            new_prerelease_number = offset
-        pre_version = f"{prerelease}{new_prerelease_number}"
-        return pre_version
+        return f"{prerelease}{offset}"
 
     def generate_devrelease(self, devrelease: int | None) -> str:
         """Generate devrelease

{commitizen-4.13.1 → commitizen-4.13.3}/pyproject.toml

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

commitizen-4.13.1/commitizen/__version__.py

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