commitizen 4.13.6__tar.gz → 4.13.7__tar.gz

{commitizen-4.13.6 → commitizen-4.13.7}/PKG-INFO

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

commitizen-4.13.7/commitizen/__version__.py

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

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/commands/check.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 import sys
+from pathlib import Path
 from typing import TYPE_CHECKING, TypedDict
 
 from commitizen import factory, git, out
@@ -116,11 +117,10 @@ class Check:
             # Get commit message from command line (--message)
             return self.commit_msg
 
-        with open(
-            self.commit_msg_file, encoding=self.config.settings["encoding"]
-        ) as commit_file:
-            # Get commit message from file (--commit-msg-file)
-            return commit_file.read()
+        # Get commit message from file (--commit-msg-file)
+        return Path(self.commit_msg_file).read_text(
+            encoding=self.config.settings["encoding"]
+        )
 
     def _get_commits(self) -> list[git.GitCommit]:
         if (msg := self._get_commit_message()) is not None:

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/commands/commit.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import subprocess
 import tempfile
+from pathlib import Path
 from typing import TYPE_CHECKING, TypedDict
 
 import questionary
@@ -26,8 +27,6 @@ from commitizen.exceptions import (
 from commitizen.git import smart_open
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
     from commitizen.config import BaseConfig
 
 
@@ -61,8 +60,9 @@ class Commit:
             return None
 
         # Read commit message from backup
-        with self.backup_file_path.open(encoding=self.config.settings["encoding"]) as f:
-            return f.read().strip()
+        return self.backup_file_path.read_text(
+            encoding=self.config.settings["encoding"]
+        ).strip()
 
     def _get_message_by_prompt_commit_questions(self) -> str:
         # Prompt user for the commit message
@@ -112,8 +112,7 @@ class Commit:
         file_path = file.name
         argv = [exec_path, file_path]
         subprocess.call(argv)
-        with open(file_path) as temp_file:
-            message = temp_file.read().strip()
+        message = Path(file_path).read_text().strip()
         os.unlink(file.name)
         return message
 

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/config/__init__.py

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

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/config/toml_config.py

@@ -26,15 +26,13 @@ class TomlConfig(BaseConfig):
         self._parse_setting(data)
 
     def contains_commitizen_section(self) -> bool:
-        with self.path.open("rb") as f:
-            config_doc = parse(f.read())
+        config_doc = parse(self.path.read_bytes())
         return config_doc.get("tool", {}).get("commitizen") is not None
 
     def init_empty_config_content(self) -> None:
         config_doc = TOMLDocument()
         if self.path.is_file():
-            with self.path.open("rb") as input_toml_file:
-                config_doc = parse(input_toml_file.read())
+            config_doc = parse(self.path.read_bytes())
 
         if config_doc.get("tool") is None:
             config_doc["tool"] = table()
@@ -46,12 +44,10 @@ class TomlConfig(BaseConfig):
             )
 
     def set_key(self, key: str, value: object) -> Self:
-        with self.path.open("rb") as f:
-            config_doc = parse(f.read())
+        config_doc = parse(self.path.read_bytes())
 
         config_doc["tool"]["commitizen"][key] = value  # type: ignore[index]
-        with self.path.open("wb") as f:
-            f.write(config_doc.as_string().encode(self._settings["encoding"]))
+        self.path.write_bytes(config_doc.as_string().encode(self._settings["encoding"]))
 
         return self
 

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/cz/conventional_commits/conventional_commits.py

@@ -215,5 +215,4 @@ class ConventionalCommitsCz(BaseCommitizen):
 
     def info(self) -> str:
         filepath = Path(__file__).parent / "conventional_commits_info.txt"
-        with filepath.open(encoding=self.config.settings["encoding"]) as f:
-            return f.read()
+        return filepath.read_text(encoding=self.config.settings["encoding"])

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/cz/customize/customize.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -68,6 +69,5 @@ class CustomizeCommitsCz(BaseCommitizen):
 
     def info(self) -> str:
         if info_path := self.custom_settings.get("info_path"):
-            with open(info_path, encoding=self.config.settings["encoding"]) as f:
-                return f.read()
+            return Path(info_path).read_text(encoding=self.config.settings["encoding"])
         return self.custom_settings.get("info") or ""

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/cz/jira/jira.py

@@ -74,5 +74,4 @@ class JiraSmartCz(BaseCommitizen):
 
     def info(self) -> str:
         filepath = Path(__file__).parent / "jira_info.txt"
-        with filepath.open(encoding=self.config.settings["encoding"]) as f:
-            return f.read()
+        return filepath.read_text(encoding=self.config.settings["encoding"])

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/providers/base_provider.py

@@ -49,6 +49,9 @@ class FileProvider(VersionProvider):
     def file(self) -> Path:
         return Path() / self.filename
 
+    def _get_encoding(self) -> str:
+        return self.config.settings["encoding"]
+
 
 class JsonProvider(FileProvider):
     """
@@ -58,13 +61,16 @@ class JsonProvider(FileProvider):
     indent: ClassVar[int] = 2
 
     def get_version(self) -> str:
-        document = json.loads(self.file.read_text())
+        document = json.loads(self.file.read_text(encoding=self._get_encoding()))
         return self.get(document)
 
     def set_version(self, version: str) -> None:
-        document = json.loads(self.file.read_text())
+        document = json.loads(self.file.read_text(encoding=self._get_encoding()))
         self.set(document, version)
-        self.file.write_text(json.dumps(document, indent=self.indent) + "\n")
+        self.file.write_text(
+            json.dumps(document, indent=self.indent) + "\n",
+            encoding=self._get_encoding(),
+        )
 
     def get(self, document: Mapping[str, str]) -> str:
         return document["version"]
@@ -79,13 +85,13 @@ class TomlProvider(FileProvider):
     """
 
     def get_version(self) -> str:
-        document = tomlkit.parse(self.file.read_text())
+        document = tomlkit.parse(self.file.read_text(encoding=self._get_encoding()))
         return self.get(document)
 
     def set_version(self, version: str) -> None:
-        document = tomlkit.parse(self.file.read_text())
+        document = tomlkit.parse(self.file.read_text(encoding=self._get_encoding()))
         self.set(document, version)
-        self.file.write_text(tomlkit.dumps(document))
+        self.file.write_text(tomlkit.dumps(document), encoding=self._get_encoding())
 
     def get(self, document: tomlkit.TOMLDocument) -> str:
         return document["project"]["version"]  # type: ignore[index,return-value]

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/providers/cargo_provider.py

@@ -43,8 +43,10 @@ class CargoProvider(TomlProvider):
             self.set_lock_version(version)
 
     def set_lock_version(self, version: str) -> None:
-        cargo_toml_content = parse(self.file.read_text())
-        cargo_lock_content = parse(self.lock_file.read_text())
+        cargo_toml_content = parse(self.file.read_text(encoding=self._get_encoding()))
+        cargo_lock_content = parse(
+            self.lock_file.read_text(encoding=self._get_encoding())
+        )
         packages = cargo_lock_content["package"]
 
         if TYPE_CHECKING:
@@ -75,7 +77,9 @@ class CargoProvider(TomlProvider):
                         continue
 
                     cargo_file = Path(path) / "Cargo.toml"
-                    package_content = parse(cargo_file.read_text()).get("package", {})
+                    package_content = parse(
+                        cargo_file.read_text(encoding=self._get_encoding())
+                    ).get("package", {})
                     if TYPE_CHECKING:
                         assert isinstance(package_content, dict)
                     try:
@@ -92,7 +96,9 @@ class CargoProvider(TomlProvider):
                 if package["name"] in members_inheriting:
                     cargo_lock_content["package"][i]["version"] = version  # type: ignore[index]
 
-        self.lock_file.write_text(dumps(cargo_lock_content))
+        self.lock_file.write_text(
+            dumps(cargo_lock_content), encoding=self._get_encoding()
+        )
 
 
 def _try_get_workspace(document: TOMLDocument) -> dict:

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/providers/npm_provider.py

@@ -4,13 +4,13 @@ import json
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
 
-from commitizen.providers.base_provider import VersionProvider
+from commitizen.providers.base_provider import JsonProvider
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
 
-class NpmProvider(VersionProvider):
+class NpmProvider(JsonProvider):
     """
     npm package.json and package-lock.json version management
     """
@@ -36,29 +36,39 @@ class NpmProvider(VersionProvider):
         """
         Get the current version from package.json
         """
-        package_document = json.loads(self.package_file.read_text())
+        package_document = json.loads(
+            self.package_file.read_text(encoding=self._get_encoding())
+        )
         return self.get_package_version(package_document)
 
     def set_version(self, version: str) -> None:
         package_document = self.set_package_version(
-            json.loads(self.package_file.read_text()), version
+            json.loads(self.package_file.read_text(encoding=self._get_encoding())),
+            version,
         )
         self.package_file.write_text(
-            json.dumps(package_document, indent=self.indent) + "\n"
+            json.dumps(package_document, indent=self.indent) + "\n",
+            encoding=self._get_encoding(),
         )
         if self.lock_file.is_file():
             lock_document = self.set_lock_version(
-                json.loads(self.lock_file.read_text()), version
+                json.loads(self.lock_file.read_text(encoding=self._get_encoding())),
+                version,
             )
             self.lock_file.write_text(
-                json.dumps(lock_document, indent=self.indent) + "\n"
+                json.dumps(lock_document, indent=self.indent) + "\n",
+                encoding=self._get_encoding(),
             )
         if self.shrinkwrap_file.is_file():
             shrinkwrap_document = self.set_shrinkwrap_version(
-                json.loads(self.shrinkwrap_file.read_text()), version
+                json.loads(
+                    self.shrinkwrap_file.read_text(encoding=self._get_encoding())
+                ),
+                version,
             )
             self.shrinkwrap_file.write_text(
-                json.dumps(shrinkwrap_document, indent=self.indent) + "\n"
+                json.dumps(shrinkwrap_document, indent=self.indent) + "\n",
+                encoding=self._get_encoding(),
             )
 
     def get_package_version(self, document: Mapping[str, str]) -> str:

{commitizen-4.13.6 → commitizen-4.13.7}/commitizen/providers/uv_provider.py

@@ -26,15 +26,21 @@ class UvProvider(TomlProvider):
         self.set_lock_version(version)
 
     def set_lock_version(self, version: str) -> None:
-        pyproject_toml_content = tomlkit.parse(self.file.read_text())
+        pyproject_toml_content = tomlkit.parse(
+            self.file.read_text(encoding=self._get_encoding())
+        )
         project_name = pyproject_toml_content["project"]["name"]  # type: ignore[index]
         normalized_project_name = canonicalize_name(str(project_name))
 
-        document = tomlkit.parse(self.lock_file.read_text())
+        document = tomlkit.parse(
+            self.lock_file.read_text(encoding=self._get_encoding())
+        )
 
         packages: tomlkit.items.AoT = document["package"]  # type: ignore[assignment]
         for i, package in enumerate(packages):
             if package["name"] == normalized_project_name:
                 document["package"][i]["version"] = version  # type: ignore[index]
                 break
-        self.lock_file.write_text(tomlkit.dumps(document))
+        self.lock_file.write_text(
+            tomlkit.dumps(document), encoding=self._get_encoding()
+        )

{commitizen-4.13.6 → commitizen-4.13.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "commitizen"
-version = "4.13.6"
+version = "4.13.7"
 description = "Python commitizen client tool"
 authors = [{ name = "Santiago Fraire", email = "santiwilly@gmail.com" }]
 maintainers = [
@@ -237,8 +237,9 @@ select = [
 ]
 ignore = ["E501", "D1", "D415"]
 extend-safe-fixes = [
-    "TC", # Move imports inside/outside TYPE_CHECKING blocks
-    "UP", # Update syntaxes for current Python version recommendations
+    "TC",    # Move imports inside/outside TYPE_CHECKING blocks
+    "UP",    # Update syntaxes for current Python version recommendations
+    "PT006", # Use tuple in pytest.mark.parametrize
 ]
 
 [tool.ruff.lint.per-file-ignores]

commitizen-4.13.6/commitizen/__version__.py

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