commitizen 4.13.0__tar.gz → 4.13.2__tar.gz

{commitizen-4.13.0 → commitizen-4.13.2}/PKG-INFO

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

commitizen-4.13.2/commitizen/__version__.py

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

{commitizen-4.13.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/commitizen/config/__init__.py

@@ -13,40 +13,32 @@ def _resolve_config_candidates() -> list[BaseConfig]:
     git_project_root = git.find_git_project_root()
     cfg_search_paths = [Path(".")]
 
-    if git_project_root and not cfg_search_paths[0].samefile(git_project_root):
+    if git_project_root and cfg_search_paths[0].resolve() != git_project_root.resolve():
         cfg_search_paths.append(git_project_root)
 
-    # The following algorithm is ugly, but we need to ensure that the order of the candidates are preserved before v5.
-    # Also, the number of possible config files is limited, so the complexity is not a problem.
     candidates: list[BaseConfig] = []
     for dir in cfg_search_paths:
         for filename in defaults.CONFIG_FILES:
-            out_path = dir / Path(filename)
-            if (
-                out_path.exists()
-                and not any(
-                    out_path.samefile(candidate.path) for candidate in candidates
-                )
-                and not (conf := _create_config_from_path(out_path)).is_empty_config
-            ):
-                candidates.append(conf)
+            out_path = dir / filename
+            if out_path.is_file():
+                conf = _create_config_from_path(out_path)
+                if conf.contains_commitizen_section():
+                    candidates.append(conf)
     return candidates
 
 
 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:
     if filepath is not None:
         conf_path = Path(filepath)
-        if not conf_path.exists():
+        if not conf_path.is_file():
             raise ConfigFileNotFound()
         conf = _create_config_from_path(conf_path)
-        if conf.is_empty_config:
+        if not conf.contains_commitizen_section():
             raise ConfigFileIsEmpty()
         return conf
 

{commitizen-4.13.0 → commitizen-4.13.2}/commitizen/config/base_config.py

@@ -17,10 +17,16 @@ if TYPE_CHECKING:
 
 class BaseConfig:
     def __init__(self) -> None:
-        self.is_empty_config = False
         self._settings: Settings = DEFAULT_SETTINGS.copy()
         self._path: Path | None = None
 
+    def contains_commitizen_section(self) -> bool:
+        """Check if the config file contains a commitizen section.
+
+        The implementation is different for each config file type.
+        """
+        raise NotImplementedError()
+
     @property
     def settings(self) -> Settings:
         return self._settings

{commitizen-4.13.0 → commitizen-4.13.2}/commitizen/config/json_config.py

@@ -25,6 +25,11 @@ class JsonConfig(BaseConfig):
         self.path = path
         self._parse_setting(data)
 
+    def contains_commitizen_section(self) -> bool:
+        with self.path.open("rb") as json_file:
+            config_doc = json.load(json_file)
+        return config_doc.get("commitizen") is not None
+
     def init_empty_config_content(self) -> None:
         with smart_open(
             self.path, "a", encoding=self._settings["encoding"]
@@ -32,7 +37,7 @@ class JsonConfig(BaseConfig):
             json.dump({"commitizen": {}}, json_file)
 
     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 = json.load(f)
 
         config_doc["commitizen"][key] = value
@@ -59,4 +64,4 @@ class JsonConfig(BaseConfig):
         try:
             self.settings.update(doc["commitizen"])
         except KeyError:
-            self.is_empty_config = True
+            pass

{commitizen-4.13.0 → commitizen-4.13.2}/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
@@ -26,27 +25,32 @@ class TomlConfig(BaseConfig):
         self.path = path
         self._parse_setting(data)
 
+    def contains_commitizen_section(self) -> bool:
+        with self.path.open("rb") as f:
+            config_doc = parse(f.read())
+        return config_doc.get("tool", {}).get("commitizen") is not None
+
     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
@@ -67,4 +71,4 @@ class TomlConfig(BaseConfig):
         try:
             self.settings.update(doc["tool"]["commitizen"])  # type: ignore[index,typeddict-item] # TODO: fix this
         except exceptions.NonExistentKey:
-            self.is_empty_config = True
+            pass

{commitizen-4.13.0 → commitizen-4.13.2}/commitizen/config/yaml_config.py

@@ -32,6 +32,11 @@ class YAMLConfig(BaseConfig):
         ) as json_file:
             yaml.dump({"commitizen": {}}, json_file, explicit_start=True)
 
+    def contains_commitizen_section(self) -> bool:
+        with self.path.open("rb") as yaml_file:
+            config_doc = yaml.load(yaml_file, Loader=yaml.FullLoader)
+        return config_doc.get("commitizen") is not None
+
     def _parse_setting(self, data: bytes | str) -> None:
         """We expect to have a section in cz.yaml looking like
 
@@ -40,8 +45,6 @@ class YAMLConfig(BaseConfig):
           name: cz_conventional_commits
         ```
         """
-        import yaml.scanner
-
         try:
             doc = yaml.safe_load(data)
         except yaml.YAMLError as e:
@@ -50,10 +53,10 @@ class YAMLConfig(BaseConfig):
         try:
             self.settings.update(doc["commitizen"])
         except (KeyError, TypeError):
-            self.is_empty_config = True
+            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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/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.0 → commitizen-4.13.2}/pyproject.toml

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

commitizen-4.13.0/commitizen/__version__.py

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