pre-commit-localupdate 0.4.1__tar.gz → 0.5.0__tar.gz

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pre-commit-localupdate
-Version: 0.4.1
-Summary: A CLI tool to automatically update additional dependencies within local Python, Julia, Rust, Go, and Node.js hooks in pre-commit config files.
+Version: 0.5.0
+Summary: A CLI tool to automatically update additional dependencies within local hooks in pre-commit config files.
 Author: M. Farzalipour Tabriz
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
@@ -16,7 +16,7 @@ Description-Content-Type: text/markdown
 
 # pre-commit-localupdate
 
-A CLI tool to automatically update dependencies in `pre-commit-config.yml` files. It specifically targets `additional_dependencies` within local Python, Julia, Rust, Go, and Node.js hooks to ensure your tooling stays up-to-date. It also adds version to unversioned packages and pins exact version of loosely defined ones. You can also pin a specific package to an older version by adding a `# freeze` comment.
+A CLI tool to automatically update dependencies in `pre-commit-config.yml` files. It specifically targets `additional_dependencies` within local hooks to ensure your tooling stays up-to-date. It also adds version to unversioned packages and pins exact version of loosely defined ones. You can also pin a specific package to an older version by adding a `# freeze` comment.
 
 ## Installation
 
@@ -34,20 +34,25 @@ pre-commit-localupdate
 
 All options:
 
-```shell
-usage: pre-commit-localupdate [-h] [--debug] [--dry-run] [-c CONFIG] [--timeout TIMEOUT] [--version]
+```text
+usage: pre-commit-localupdate [-h] [--debug] [--dry-run] [-c PRE-COMMIT-CONFIG] [--timeout TIMEOUT]
+                              [--indent-mapping INDENT_MAPPING] [--indent-sequence INDENT_SEQUENCE]
+                              [--indent-offset INDENT_OFFSET] [--line-width LINE_WIDTH] [--version]
 
-Automatically update additional dependencies within local Python, Julia, Rust, Go, and Node.js hooks in a pre-commit config
-file.
+Automatically update additional dependencies within local hooks in a pre-commit config file.
 
 options:
-  -h, --help           show this help message and exit
-  --debug              enable debug logging (default: False)
-  --dry-run            dry run mode. Do not update the file and exit with a non-zero code if the configuration file require an
-                       update. (default: False)
-  -c, --config CONFIG  pre-commit config file path (default: .pre-commit-config.yaml)
-  --timeout TIMEOUT    connection timeout in seconds (default: 10)
-  --version            show program's version number and exit
+  -h, --help                         show this help message and exit
+  --debug                            enable debug logging (default: False)
+  --dry-run                          dry run mode. Do not update the file and exit with a non-zero code if the
+                                     configuration file require an update. (default: False)
+  -c, --config PRE-COMMIT-CONFIG     pre-commit config file path (default: .pre-commit-config.yaml)
+  --timeout TIMEOUT                  connection timeout in seconds (default: 10)
+  --indent-mapping INDENT_MAPPING    YAML indentation for mappings (default: 2)
+  --indent-sequence INDENT_SEQUENCE  YAML indentation for sequences (default: 4)
+  --indent-offset INDENT_OFFSET      YAML indentation offset (default: 2)
+  --line-width LINE_WIDTH            maximum line width (default: 80)
+  --version                          show program's version number and exit
 ```
 
 ## Example
@@ -70,7 +75,7 @@ repos:
       # All comment are preserved
       - id: black
         name: black
-        description: "Long strings are automatically folded into multilines by ruamel-yaml library!"
+        description: "Length of strings is automatically adjusted based on the value of --line-width"
         entry: black
         language: python
         minimum_pre_commit_version: 2.9.2
@@ -84,7 +89,7 @@ repos:
 
       - id: julia-format
         name: format julia code
-        description: Run `JuliaFormatter.jl` against Julia source files
+        description: Unicodeテキストは保持されます。
         language: julia
         types: [julia]
         entry: tools/formatter.jl
@@ -120,8 +125,8 @@ repos:
       # All comment are preserved
       - id: black
         name: black
-        description: "Long strings are automatically folded into multilines by ruamel-yaml
-          library!"
+        description: "Length of strings is automatically adjusted based on the value
+          of --line-width"
         entry: black
         language: python
         minimum_pre_commit_version: 2.9.2
@@ -135,7 +140,7 @@ repos:
 
       - id: julia-format
         name: format julia code
-        description: Run `JuliaFormatter.jl` against Julia source files
+        description: Unicodeテキストは保持されます。
         language: julia
         types: [julia]
         entry: tools/formatter.jl
@@ -153,14 +158,25 @@ repos:
         additional_dependencies: ["cli:mdbook-lint:0.14.2"]
 ```
 
+## Supported Languages
+
+Following local hook languages are currently supported:
+
+- Go (golang)
+- Julia
+- Node.js (node)
+- Python
+- Rust
+
 ## Formatting
 
-A considerable amount of effort has been put into making `pre-commit-localupdate` respect the original style and preserve the comments in the pre-commit configuration files. Although it is currently folding long strings (for example, in description lines) and enforcing block indentation for better readability.
+Significant effort has been made to ensure `pre-commit-localupdate` maintains the original style and preserves comments in pre-commit configuration files. However, since the current version of the underlying library does not perfectly preserve the original YAML file format after processing, `pre-commit-localupdate` automatically folds long string values (like descriptions) and enforces block indentation by default when updating files to enhance readability. Both behaviors can be adjusted using command-line parameters.
 
 ## Requirements
 
-- ruamel.yaml
-- requests
+- `packaging`
+- `requests`
+- `ruamel.yaml`
 
 ## License
 

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/README.md

@@ -1,6 +1,6 @@
 # pre-commit-localupdate
 
-A CLI tool to automatically update dependencies in `pre-commit-config.yml` files. It specifically targets `additional_dependencies` within local Python, Julia, Rust, Go, and Node.js hooks to ensure your tooling stays up-to-date. It also adds version to unversioned packages and pins exact version of loosely defined ones. You can also pin a specific package to an older version by adding a `# freeze` comment.
+A CLI tool to automatically update dependencies in `pre-commit-config.yml` files. It specifically targets `additional_dependencies` within local hooks to ensure your tooling stays up-to-date. It also adds version to unversioned packages and pins exact version of loosely defined ones. You can also pin a specific package to an older version by adding a `# freeze` comment.
 
 ## Installation
 
@@ -18,20 +18,25 @@ pre-commit-localupdate
 
 All options:
 
-```shell
-usage: pre-commit-localupdate [-h] [--debug] [--dry-run] [-c CONFIG] [--timeout TIMEOUT] [--version]
+```text
+usage: pre-commit-localupdate [-h] [--debug] [--dry-run] [-c PRE-COMMIT-CONFIG] [--timeout TIMEOUT]
+                              [--indent-mapping INDENT_MAPPING] [--indent-sequence INDENT_SEQUENCE]
+                              [--indent-offset INDENT_OFFSET] [--line-width LINE_WIDTH] [--version]
 
-Automatically update additional dependencies within local Python, Julia, Rust, Go, and Node.js hooks in a pre-commit config
-file.
+Automatically update additional dependencies within local hooks in a pre-commit config file.
 
 options:
-  -h, --help           show this help message and exit
-  --debug              enable debug logging (default: False)
-  --dry-run            dry run mode. Do not update the file and exit with a non-zero code if the configuration file require an
-                       update. (default: False)
-  -c, --config CONFIG  pre-commit config file path (default: .pre-commit-config.yaml)
-  --timeout TIMEOUT    connection timeout in seconds (default: 10)
-  --version            show program's version number and exit
+  -h, --help                         show this help message and exit
+  --debug                            enable debug logging (default: False)
+  --dry-run                          dry run mode. Do not update the file and exit with a non-zero code if the
+                                     configuration file require an update. (default: False)
+  -c, --config PRE-COMMIT-CONFIG     pre-commit config file path (default: .pre-commit-config.yaml)
+  --timeout TIMEOUT                  connection timeout in seconds (default: 10)
+  --indent-mapping INDENT_MAPPING    YAML indentation for mappings (default: 2)
+  --indent-sequence INDENT_SEQUENCE  YAML indentation for sequences (default: 4)
+  --indent-offset INDENT_OFFSET      YAML indentation offset (default: 2)
+  --line-width LINE_WIDTH            maximum line width (default: 80)
+  --version                          show program's version number and exit
 ```
 
 ## Example
@@ -54,7 +59,7 @@ repos:
       # All comment are preserved
       - id: black
         name: black
-        description: "Long strings are automatically folded into multilines by ruamel-yaml library!"
+        description: "Length of strings is automatically adjusted based on the value of --line-width"
         entry: black
         language: python
         minimum_pre_commit_version: 2.9.2
@@ -68,7 +73,7 @@ repos:
 
       - id: julia-format
         name: format julia code
-        description: Run `JuliaFormatter.jl` against Julia source files
+        description: Unicodeテキストは保持されます。
         language: julia
         types: [julia]
         entry: tools/formatter.jl
@@ -104,8 +109,8 @@ repos:
       # All comment are preserved
       - id: black
         name: black
-        description: "Long strings are automatically folded into multilines by ruamel-yaml
-          library!"
+        description: "Length of strings is automatically adjusted based on the value
+          of --line-width"
         entry: black
         language: python
         minimum_pre_commit_version: 2.9.2
@@ -119,7 +124,7 @@ repos:
 
       - id: julia-format
         name: format julia code
-        description: Run `JuliaFormatter.jl` against Julia source files
+        description: Unicodeテキストは保持されます。
         language: julia
         types: [julia]
         entry: tools/formatter.jl
@@ -137,14 +142,25 @@ repos:
         additional_dependencies: ["cli:mdbook-lint:0.14.2"]
 ```
 
+## Supported Languages
+
+Following local hook languages are currently supported:
+
+- Go (golang)
+- Julia
+- Node.js (node)
+- Python
+- Rust
+
 ## Formatting
 
-A considerable amount of effort has been put into making `pre-commit-localupdate` respect the original style and preserve the comments in the pre-commit configuration files. Although it is currently folding long strings (for example, in description lines) and enforcing block indentation for better readability.
+Significant effort has been made to ensure `pre-commit-localupdate` maintains the original style and preserves comments in pre-commit configuration files. However, since the current version of the underlying library does not perfectly preserve the original YAML file format after processing, `pre-commit-localupdate` automatically folds long string values (like descriptions) and enforces block indentation by default when updating files to enhance readability. Both behaviors can be adjusted using command-line parameters.
 
 ## Requirements
 
-- ruamel.yaml
-- requests
+- `packaging`
+- `requests`
+- `ruamel.yaml`
 
 ## License
 

pre_commit_localupdate-0.5.0/pre_commit_localupdate/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.5.0'

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/__main__.py

@@ -11,10 +11,10 @@ to their latest versions.
 
 import logging
 import sys
-from pathlib import Path
 
 from pre_commit_localupdate.cli import parse_args
 from pre_commit_localupdate.error import PreCommitLocalUpdateError
+from pre_commit_localupdate.io import YAMLFormat
 from pre_commit_localupdate.logs import setup_logging
 from pre_commit_localupdate.pre_commit_config import update_additional_dependencies
 
@@ -23,12 +23,18 @@ def main() -> None:
     """Main entry point for the script."""
     args = parse_args()
     setup_logging(debug=args.debug)
-
+    yaml_format = YAMLFormat(
+        indent_mapping=args.indent_mapping,
+        indent_sequence=args.indent_sequence,
+        indent_offset=args.indent_offset,
+        line_width=args.line_width,
+    )
     try:
         if update_additional_dependencies(
-            Path(args.config), args.timeout, dry_run=args.dry_run
+            args.config, args.timeout, yaml_format, dry_run=args.dry_run
         ):
             if args.dry_run:
+                logging.info("Additional dependencies require updating!")
                 sys.exit(1)
             logging.info("Done.")
         else:

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/cli.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: LGPL-3.0-or-later
 
 import argparse
+from pathlib import Path
 
 from pre_commit_localupdate import __version__
 
@@ -13,8 +14,10 @@ def parse_args() -> argparse.Namespace:
         argparse.Namespace: Parsed arguments.
     """
     parser = argparse.ArgumentParser(
-        description="Automatically update additional dependencies within local Python, Julia, Rust, Go, and Node.js hooks in a pre-commit config file.",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description="Automatically update additional dependencies within local hooks in a pre-commit config file.",
+        formatter_class=lambda prog: argparse.ArgumentDefaultsHelpFormatter(
+            prog, max_help_position=40, width=120
+        ),
     )
     parser.add_argument(
         "--debug",
@@ -29,9 +32,10 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "-c",
         "--config",
-        type=str,
+        type=Path,
         help="pre-commit config file path",
         default=".pre-commit-config.yaml",
+        metavar="PRE-COMMIT-CONFIG",
     )
     parser.add_argument(
         "--timeout",
@@ -39,6 +43,30 @@ def parse_args() -> argparse.Namespace:
         help="connection timeout in seconds",
         default=10,
     )
+    parser.add_argument(
+        "--indent-mapping",
+        type=int,
+        help="YAML indentation for mappings",
+        default=2,
+    )
+    parser.add_argument(
+        "--indent-sequence",
+        type=int,
+        help="YAML indentation for sequences",
+        default=4,
+    )
+    parser.add_argument(
+        "--indent-offset",
+        type=int,
+        help="YAML indentation offset",
+        default=2,
+    )
+    parser.add_argument(
+        "--line-width",
+        type=int,
+        help="maximum line width",
+        default=80,
+    )
     parser.add_argument(
         "--version",
         action="version",

pre_commit_localupdate-0.5.0/pre_commit_localupdate/io.py

@@ -0,0 +1,121 @@
+# SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+import io
+import logging
+import os
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from ruamel.yaml import YAML
+from ruamel.yaml.comments import CommentedMap
+
+from pre_commit_localupdate.error import PreCommitLocalUpdateError
+
+
+@dataclass(frozen=True)
+class YAMLFormat:
+    """Configuration for YAML file formatting parameters.
+
+    Attributes:
+        indent_mapping (int): YAML indentation for mappings
+        indent_sequence (int): YAML indentation for sequences
+        indent_offset (int): YAML indentation offset
+        line_width (int): maximum line width
+
+    """
+
+    indent_mapping: int
+    indent_sequence: int
+    indent_offset: int
+    line_width: int
+
+
+def load_config_file(file_path: Path) -> tuple[list[str], str]:
+    """Reads pre-commit configuration file and returns its header lines and content.
+
+    Args:
+        file_path (Path): Path to config file
+
+    Returns:
+        tuple[list[str], str]: Header lines, config file content
+
+    Raises:
+        PreCommitLocalUpdateError: Error in reading config file
+    """
+    logging.debug("Reading configuration file: %s", file_path)
+
+    try:
+        file_content = file_path.read_text(encoding="utf-8")
+    except FileNotFoundError as exc:
+        raise PreCommitLocalUpdateError(f"File not found: {file_path}") from exc
+    except OSError as exc:
+        raise PreCommitLocalUpdateError(
+            f"IOError while reading file {file_path}"
+        ) from exc
+
+    raw_lines = file_content.splitlines(keepends=True)
+
+    content_start_index = 0
+    for i, line in enumerate(raw_lines):
+        stripped = line.strip()
+        if stripped == "---":
+            logging.debug("YAML marker found.")
+            content_start_index = i + 1
+            break
+        if stripped and not stripped.startswith("#"):
+            content_start_index = i
+            break
+
+    header_lines = raw_lines[:content_start_index]
+    content = "".join(raw_lines[content_start_index:])
+
+    return header_lines, content
+
+
+def save_config_file(
+    file_path: Path,
+    config: CommentedMap,
+    header_lines: list[str],
+    yaml_dumper: YAML,
+) -> None:
+    """Writes pre-commit configuration file.
+
+    Args:
+        file_path (Path): Path to config file
+        config (CommentedMap): Config file content
+        header_lines (list[str]): File header lines
+        yaml_dumper (YAML): YAML dumper
+
+    Raises:
+        PreCommitLocalUpdateError: Error in writing config file
+    """
+
+    logging.debug("Writing modifications to disk...")
+    stream = io.StringIO()
+    yaml_dumper.dump(config, stream)
+    modified_body = stream.getvalue()
+    final_content = "".join(header_lines) + modified_body
+
+    temp_file_path = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=file_path.parent,
+            delete=False,
+        ) as temp_file:
+            temp_file.write(final_content)
+            os.fsync(temp_file.fileno())
+            temp_file_path = temp_file.name
+
+        os.replace(temp_file_path, file_path)
+        logging.info("Successfully updated %s", file_path)
+
+    except OSError as exc:
+        if temp_file_path and os.path.exists(temp_file_path):
+            os.unlink(temp_file_path)
+        raise PreCommitLocalUpdateError(
+            f"IOError while writing to file {file_path}"
+        ) from exc

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/packages/golang.py

@@ -3,7 +3,6 @@
 
 import logging
 import re
-from dataclasses import dataclass
 
 import requests
 
@@ -13,51 +12,39 @@ from .package import PackageBase
 GO_PKG_LATEST_VERSION_API_URL = "https://proxy.golang.org/{package_path}/@latest"
 
 
-@dataclass
 class GoPackage(PackageBase):
     """Represents a Go module."""
 
     @classmethod
-    def from_specification(
-        cls, spec: str, connection_timeout: int
-    ) -> "GoPackage" | None:
+    def from_specification(cls, spec: str) -> "GoPackage" | None:
         """Parse a Go module specification string into a Package object.
 
-        Handles formats like:
-        - 'mvdan.cc/sh' (Module path only)
-        - 'mvdan.cc/sh@v1.3.0' (Module path with specific version)
-        - 'mvdan.cc/sh/v3' (Module path with major version suffix)
-        - 'mvdan.cc/sh/v3@v3.10.0' (Major suffix with version)
-        - 'mvdan.cc/sh/v3/cmd/shfmt' (Submodule)
-        - 'mvdan.cc/sh/v3/cmd/shfmt@v3.10.0' (Submodule with version)
+        Supported formats:
+        - `mvdan.cc/sh` (Module path only)
+        - `mvdan.cc/sh@v1.3.0` (Module path with specific version)
+        - `mvdan.cc/sh/v3` (Module path with major version suffix)
+        - `mvdan.cc/sh/v3@v3.10.0` (Major suffix with version)
+        - `mvdan.cc/sh/v3/cmd/shfmt` (Submodule)
+        - `mvdan.cc/sh/v3/cmd/shfmt@v3.10.0` (Submodule with version)
 
         Args:
-            spec (str): The package specification string.
-            connection_timeout (int): Connection timeout in seconds.
+            spec (str): The package specification string (without quotations).
 
         Returns:
             "GoPackage" | None: A Package instance if parsing succeeds, otherwise None.
         """
-        clean_spec = spec.strip().strip('"').strip("'")
 
-        match = re.match(r"^([a-zA-Z0-9._/-]+)(@.+)?$", clean_spec)
+        match = re.match(r"^([a-zA-Z0-9._/-]+)(@.+)?$", spec)
 
         if not match:
-            logging.warning(
-                "Could not parse the Go package specification: %s", clean_spec
-            )
             return None
 
         name = match.group(1)
         raw_spec = match.group(2)
 
-        module_path = cls._resolve_module_path(name)
-        latest_version = cls._get_latest_version(module_path, connection_timeout)
-
         return cls(
             name=name,
             raw_spec=raw_spec,
-            latest_version=latest_version,
         )
 
     @staticmethod
@@ -82,17 +69,13 @@ class GoPackage(PackageBase):
 
         return package_path
 
-    @staticmethod
-    def _get_latest_version(package_path: str, connection_timeout: int) -> str | None:
+    def fetch_latest_version(self, connection_timeout: int) -> None:
         """Fetch the latest version of a Go module from proxy.golang.org.
 
         Args:
-            package_path (str): The module path (e.g., mvdan.cc/sh/v3).
             connection_timeout (int): Connection timeout in seconds.
-
-        Returns:
-            str | None: The latest version string (e.g., v3.10.0) if found, otherwise None.
         """
+        package_path = self._resolve_module_path(self.name)
         logging.debug("Fetching latest version for %s", package_path)
         try:
             url = GO_PKG_LATEST_VERSION_API_URL.format(package_path=package_path)
@@ -103,16 +86,15 @@ class GoPackage(PackageBase):
             data = response.json()
             latest_version = data.get("Version")
 
-            return latest_version if isinstance(latest_version, str) else None
+            if isinstance(latest_version, str):
+                self.latest_version = latest_version
 
         except requests.exceptions.RequestException as exc:
             logging.warning(
                 "Could not fetch latest version for %s: %s", package_path, exc
             )
-            return None
         except (KeyError, ValueError) as exc:
             logging.warning("Could not parse response for %s: %s", package_path, exc)
-            return None
 
     def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/packages/julia.py

@@ -17,57 +17,69 @@ JULIA_PKG_API_URL = "https://raw.githubusercontent.com/JuliaRegistries/General/r
 
 @dataclass
 class JuliaPackage(PackageBase):
-    """Represents a Julia package."""
+    """Represents a Julia package.
+
+    Attributes:
+        uuid (str): Package UUID [not validated]
+    """
+
+    uuid: str = ""
 
     @classmethod
-    def from_specification(
-        cls, spec: str, connection_timeout: int
-    ) -> "JuliaPackage" | None:
+    def from_specification(cls, spec: str) -> "JuliaPackage" | None:
         """Parse a package specification string into a Package object.
 
-        Handles formats like 'Example@0.4.1', 'Example@0.4', or just 'Example'.
+        Supported formats:
+        - `package`
+        - `package@1.2.3`
+        - `package=2edaba10-b0f1-5616-af89-8c11ac63239a`
+        - `package=2edaba10-b0f1-5616-af89-8c11ac63239a@1.2`
 
         Args:
-            spec (str): The package specification string.
-            connection_timeout (int): Connection timeout in seconds.
+            spec (str): The package specification string (without quotations).
 
         Returns:
             "JuliaPackage" | None: A Package instance if parsing succeeds, otherwise None.
 
         """
-        clean_spec = spec.strip().strip('"').strip("'")
-        match = re.match(r"^([a-zA-Z0-9_]+)(?:@([a-zA-Z0-9._+,-]+))?$", clean_spec)
+
+        pattern = re.compile(
+            r"^(?P<name>[a-zA-Z0-9_]+)"
+            r"(?:=(?P<uuid>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}))?"
+            r"(?:@(?P<version>[a-zA-Z0-9._+,-]+))?$"
+        )
+
+        match = pattern.match(spec)
 
         if not match:
-            logging.warning("Could not parse the package specification: %s", clean_spec)
             return None
 
-        name = match.group(1)
-        raw_spec = match.group(2)
-        latest_version = cls._get_latest_version(name, connection_timeout)
+        name = match.group("name")
+        uuid = match.group("uuid")
+        version = match.group("version")
+
+        raw_spec = None
+        if uuid:
+            raw_spec = f"={uuid}@{version}" if version else f"={uuid}"
+        elif version:
+            raw_spec = f"@{version}"
 
         return cls(
             name=name,
             raw_spec=raw_spec,
-            latest_version=latest_version,
+            uuid=uuid,
         )
 
-    @staticmethod
-    def _get_latest_version(package_name: str, connection_timeout: int) -> str | None:
+    def fetch_latest_version(self, connection_timeout: int) -> None:
         """Fetch the latest version of a package from the Julia General Registry.
 
         Args:
-            package_name (str): Name of the package.
             connection_timeout (int): Connection timeout in seconds.
-
-        Returns:
-            str | None: The latest version string if found, otherwise None.
-
         """
-        logging.debug("Fetching latest version for %s", package_name)
+        logging.debug("Fetching latest version for %s", self.name)
         try:
             url = JULIA_PKG_API_URL.format(
-                package_name=package_name, package_name_first_letter=package_name[0]
+                package_name=self.name, package_name_first_letter=self.name[0]
             )
             response = requests.get(url, timeout=connection_timeout)
             response.raise_for_status()
@@ -75,22 +87,14 @@ class JuliaPackage(PackageBase):
             data = tomllib.loads(response.text)
 
             versions = list(data.keys())
-            if not versions:
-                return None
-
-            versions.sort(key=lambda v: Version(v), reverse=True)
-            latest_version = versions[0]
-
-            return latest_version if isinstance(latest_version, str) else None
+            if versions:
+                versions.sort(key=lambda v: Version(v), reverse=True)
+                self.latest_version = versions[0]
 
         except requests.exceptions.RequestException as exc:
-            logging.warning(
-                "Could not fetch latest version for %s: %s", package_name, exc
-            )
-            return None
+            logging.warning("Could not fetch latest version for %s: %s", self.name, exc)
         except (KeyError, ValueError, tomllib.TOMLDecodeError, InvalidVersion) as exc:
-            logging.warning("Could not parse response for %s: %s", package_name, exc)
-            return None
+            logging.warning("Could not parse response for %s: %s", self.name, exc)
 
     def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.
@@ -102,5 +106,6 @@ class JuliaPackage(PackageBase):
         """
         if not self.latest_version:
             return None
-
+        if self.uuid:
+            return f"{self.name}={self.uuid}@{self.latest_version}"
         return f"{self.name}@{self.latest_version}"

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/packages/node.py

@@ -3,7 +3,6 @@
 
 import logging
 import re
-from dataclasses import dataclass
 
 import requests
 
@@ -12,81 +11,66 @@ from .package import PackageBase
 NPM_API_URL = "https://registry.npmjs.org/{package_name}"
 
 
-@dataclass
 class NodePackage(PackageBase):
     """Represents a Node.js package."""
 
     @classmethod
-    def from_specification(
-        cls, spec: str, connection_timeout: int
-    ) -> "NodePackage" | None:
+    def from_specification(cls, spec: str) -> "NodePackage" | None:
         """Parse a package specification string into a NodePackage object.
 
-        Handles formats like 'react@4.17.21', 'react@>=18.0.0', '@scope/name@^1.2.3', or just 'react'.
+        Supported formats:
+        - `package`
+        - `package@1.2.3`
+        - `package@>=1.2.3`
+        - `@scope/name@^1.2.3`
 
         Args:
-            spec (str): The package specification string.
-            connection_timeout (int): Connection timeout in seconds.
+            spec (str): The package specification string (without quotations).
 
         Returns:
             "NodePackage" | None: A NodePackage instance if parsing succeeds, otherwise None.
 
         """
-        clean_spec = spec.strip().strip('"').strip("'")
 
-        if not clean_spec:
+        if not spec:
             return None
 
-        parts = clean_spec.split("@")
-
-        name = clean_spec
-        raw_spec = None
+        # (@scope/name|name)(@version)?
+        match = re.match(r"^(?P<name>(?:@[^/]+\/)?[^@]+?)(?:@(?P<spec>.*))?$", spec)
+        if not match:
+            return None
 
-        # Look for version from the end (handles scoped packages correctly).
-        for i in range(len(parts) - 1, 0, -1):
-            if re.match(r"^(\d+|[<>=~^])", parts[i]):
-                name = "@".join(parts[:i])
-                raw_spec = "@" + "@".join(parts[i:])
-                break
+        name = match.group("name")
+        raw_spec = match.group("spec")
 
-        latest_version = cls._get_latest_version(name, connection_timeout)
+        if not name:
+            return None
 
         return cls(
             name=name,
             raw_spec=raw_spec,
-            latest_version=latest_version,
         )
 
-    @staticmethod
-    def _get_latest_version(package_name: str, connection_timeout: int) -> str | None:
+    def fetch_latest_version(self, connection_timeout: int) -> None:
         """Fetch the latest version of a package from the npm registry.
 
         Args:
-            package_name (str): Name of the package.
             connection_timeout (int): Connection timeout in seconds.
-
-        Returns:
-            str | None: The latest version string if found, otherwise None.
-
         """
         try:
-            url = NPM_API_URL.format(package_name=package_name)
+            url = NPM_API_URL.format(package_name=self.name)
             response = requests.get(url, timeout=connection_timeout)
             response.raise_for_status()
             data = response.json()
 
             latest_version = data.get("dist-tags", {}).get("latest")
-
-            return latest_version if isinstance(latest_version, str) else None
+            if isinstance(latest_version, str):
+                self.latest_version = latest_version
 
         except requests.exceptions.RequestException as exc:
-            logging.warning(
-                "Could not fetch latest version for %s: %s", package_name, exc
-            )
-            return None
+            logging.warning("Could not fetch latest version for %s: %s", self.name, exc)
         except (KeyError, ValueError) as exc:
-            logging.warning("Could not parse response for %s: %s", package_name, exc)
-            return None
+            logging.warning("Could not parse response for %s: %s", self.name, exc)
 
     def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/packages/package.py

@@ -11,30 +11,38 @@ class PackageBase(ABC):
 
     Attributes:
         name (str): The name of the package (e.g., 'requests').
-        raw_spec (str | None): The original version specifier string (e.g., '==2.25.1', '^4.17.21', '>=1.0.0', '@1.2.3').
-        latest_version (str | None): Latest version number without operators (e.g., '2.25.1').
+        raw_spec (str | None): The original version specifier string (e.g., '==1.2.3', '^1.2.3', '>=1.2.3', '@1.2.3').
+        latest_version (str | None): Latest version number without operators (e.g., '1.2.3').
 
     """
 
     name: str
     raw_spec: str | None
-    latest_version: str | None
+    latest_version: str | None = None
 
     @classmethod
     @abstractmethod
     def from_specification(
-        cls, spec_string: str, connection_timeout: int
+        cls,
+        spec_string: str,
     ) -> "PackageBase" | None:
         """Parse a package specification string into a Package object.
 
         Args:
-            spec_string (str): The package specification string.
-            connection_timeout (int): Connection timeout in seconds.
+            spec_string (str): The package specification string (without quotations).
 
         Returns:
             "PackageBase" | None: A Package instance if parsing succeeds, otherwise None.
         """
 
+    @abstractmethod
+    def fetch_latest_version(self, connection_timeout: int) -> None:
+        """Get latest package version and set self.latest_version
+
+        Args:
+            connection_timeout (int): Connection timeout in seconds.
+        """
+
     @abstractmethod
     def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.
@@ -43,7 +51,7 @@ class PackageBase(ABC):
             str | None: The latest version specification string if found, otherwise None.
         """
 
-    def version_specification(self) -> str | None:
+    def original_version_specification(self) -> str | None:
         """Version specification of package as originally defined.
 
         Returns:
@@ -52,4 +60,4 @@ class PackageBase(ABC):
         """
         if self.raw_spec:
             return f"{self.name}{self.raw_spec}"
-        return f"{self.name}[unspecified version]"
+        return f"{self.name}"

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/packages/python.py

@@ -2,85 +2,69 @@
 # SPDX-License-Identifier: LGPL-3.0-or-later
 
 import logging
-from dataclasses import dataclass
 
 import requests
-from packaging.requirements import Requirement
+from packaging.requirements import InvalidRequirement, Requirement
 
 from .package import PackageBase
 
 PYPI_API_URL = "https://pypi.org/pypi/{package_name}/json"
 
 
-@dataclass
 class PyPackage(PackageBase):
     """Represents a Python package."""
 
     @classmethod
-    def from_specification(
-        cls, spec: str, connection_timeout: int
-    ) -> "PyPackage" | None:
+    def from_specification(cls, spec: str) -> "PyPackage" | None:
         """Parse a package specification string into a Package object.
 
-        Handles formats like 'ansible==13.3.0', 'ansible>=1.0', or just 'ansible'.
+        Supported formats (and other specifications in PEP 508):
+        - `package`
+        - `package==1.2.3`
+        - `package>=1.2.3`
 
         Args:
-            spec (str): The package specification string.
-            connection_timeout (int): Connection timeout in seconds.
+            spec (str): The package specification string (without quotations).
 
         Returns:
             "PyPackage" | None: A Package instance if parsing succeeds, otherwise None.
 
         """
-        clean_spec = spec.strip().strip('"').strip("'")
 
         try:
-            requirement = Requirement(clean_spec)
-        except Exception as exc:
-            logging.warning(
-                "Could not parse the package specification: %s - %s", clean_spec, exc
-            )
+            requirement = Requirement(spec)
+        except InvalidRequirement:
             return None
 
         name = requirement.name
         raw_spec = str(requirement.specifier) if requirement.specifier else None
-        latest_version = cls._get_latest_version(name, connection_timeout)
 
         return cls(
             name=name,
             raw_spec=raw_spec,
-            latest_version=latest_version,
         )
 
-    @staticmethod
-    def _get_latest_version(package_name: str, connection_timeout: int) -> str | None:
+    def fetch_latest_version(self, connection_timeout: int) -> None:
         """Fetch the latest version of a package from PyPI.
 
         Args:
-            package_name (str): Name of the package.
             connection_timeout (int): Connection timeout in seconds.
 
-        Returns:
-            str | None: The latest version string if found, otherwise None.
-
         """
-        logging.debug("Fetching latest version for %s", package_name)
+        logging.debug("Fetching latest version for %s", self.name)
         try:
-            url = PYPI_API_URL.format(package_name=package_name)
+            url = PYPI_API_URL.format(package_name=self.name)
             response = requests.get(url, timeout=connection_timeout)
             response.raise_for_status()
             data = response.json()
             latest_version = data.get("info", {}).get("version")
-            return latest_version if isinstance(latest_version, str) else None
+            if isinstance(latest_version, str):
+                self.latest_version = latest_version
 
         except requests.exceptions.RequestException as exc:
-            logging.warning(
-                "Could not fetch latest version for %s: %s", package_name, exc
-            )
-            return None
+            logging.warning("Could not fetch latest version for %s: %s", self.name, exc)
         except (KeyError, ValueError) as exc:
-            logging.warning("Could not parse response for %s: %s", package_name, exc)
-            return None
+            logging.warning("Could not parse response for %s: %s", self.name, exc)
 
     def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/packages/rust.py

@@ -23,29 +23,26 @@ class RustPackage(PackageBase):
     cli: bool = False
 
     @classmethod
-    def from_specification(
-        cls, spec: str, connection_timeout: int
-    ) -> "RustPackage" | None:
+    def from_specification(cls, spec: str) -> "RustPackage" | None:
         """Parse a package specification string into a Package object.
 
-        Handles formats like 'package', 'package:1.2.3', or 'cli:package:1.2.3'.
+        Supported formats:
+        - `package`
+        - `package:1.2.3`
+        - `cli:package:1.2.3`
 
         Args:
-            spec (str): The package specification string.
-            connection_timeout (int): Connection timeout in seconds.
+            spec (str): The package specification string (without quotations).
 
         Returns:
             "RustPackage" | None: A Package instance if parsing succeeds, otherwise None.
 
         """
-        clean_spec = spec.strip().strip('"').strip("'")
-
         match = re.match(
             r"^(?:(?P<cli>cli):)?(?P<name>[a-zA-Z0-9_-]+)(?::(?P<version>[^:]+))?$",
-            clean_spec,
+            spec,
         )
         if not match:
-            logging.warning("Could not parse the package specification: %s", clean_spec)
             return None
 
         name = match.group("name")
@@ -53,39 +50,29 @@ class RustPackage(PackageBase):
         cli = bool(match.group("cli"))
 
         raw_spec = f":{version}" if version else None
-        latest_version = cls._get_latest_version(name, connection_timeout)
 
-        return cls(name=name, raw_spec=raw_spec, latest_version=latest_version, cli=cli)
+        return cls(name=name, raw_spec=raw_spec, cli=cli)
 
-    @staticmethod
-    def _get_latest_version(package_name: str, connection_timeout: int) -> str | None:
+    def fetch_latest_version(self, connection_timeout: int) -> None:
         """Fetch the latest version of a package from crates.io.
 
         Args:
-            package_name (str): Name of the package.
             connection_timeout (int): Connection timeout in seconds.
-
-        Returns:
-            str | None: The latest version string if found, otherwise None.
-
         """
-        logging.debug("Fetching latest version for %s", package_name)
+        logging.debug("Fetching latest version for %s", self.name)
         try:
-            url = CRATES_API_URL.format(package_name=package_name)
+            url = CRATES_API_URL.format(package_name=self.name)
             response = requests.get(url, timeout=connection_timeout)
             response.raise_for_status()
             data = response.json()
             latest_version = data.get("crate", {}).get("max_version")
-            return latest_version if isinstance(latest_version, str) else None
+            if isinstance(latest_version, str):
+                self.latest_version = latest_version
 
         except requests.exceptions.RequestException as exc:
-            logging.warning(
-                "Could not fetch latest version for %s: %s", package_name, exc
-            )
-            return None
+            logging.warning("Could not fetch latest version for %s: %s", self.name, exc)
         except (KeyError, ValueError) as exc:
-            logging.warning("Could not parse response for %s: %s", package_name, exc)
-            return None
+            logging.warning("Could not parse response for %s: %s", self.name, exc)
 
     def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pre_commit_localupdate/pre_commit_config.py

@@ -1,22 +1,25 @@
 # SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
 # SPDX-License-Identifier: LGPL-3.0-or-later
 
-import io
 import logging
-import os
 import re
-import tempfile
 from pathlib import Path
 
-import ruamel.yaml
+from ruamel.yaml import YAML
+from ruamel.yaml.comments import CommentedSeq
+from ruamel.yaml.error import YAMLError
 
 from pre_commit_localupdate.error import PreCommitLocalUpdateError
-from pre_commit_localupdate.io import load_config_file
+from pre_commit_localupdate.io import YAMLFormat, load_config_file, save_config_file
 from pre_commit_localupdate.packages import SUPPORTED_PACKAGES
 
 
 def update_additional_dependencies(
-    file_path: Path, connection_timeout: int, *, dry_run: bool = False
+    file_path: Path,
+    connection_timeout: int,
+    yaml_format: YAMLFormat,
+    *,
+    dry_run: bool = False,
 ) -> bool:
     """Reads the pre-commit configuration file, identifies outdated packages
     in local hooks, and updates them directly in the file.
@@ -27,10 +30,11 @@ def update_additional_dependencies(
     Args:
         file_path (Path): Path to the pre-commit configuration file.
         connection_timeout (int): Connection timeout in seconds.
+        yaml_format (YAMLFormat): YAML file formatting parameters
         dry_run (bool): Do not update the pre-commit configuration file.
 
     Returns:
-        bool: True if the file needed updating, False otherwise.
+        bool: True if the dependencies needed updating, False otherwise.
 
     Raises:
         PreCommitLocalUpdateError: Error in parsing or updating pre-commit hooks
@@ -40,17 +44,20 @@ def update_additional_dependencies(
 
     logging.debug("Parsing YAML content...")
 
-    yaml = ruamel.yaml.YAML()
+    yaml = YAML()
     yaml.preserve_quotes = True
-    yaml.indent(mapping=2, sequence=4, offset=2)
+    yaml.indent(
+        mapping=yaml_format.indent_mapping,
+        sequence=yaml_format.indent_sequence,
+        offset=yaml_format.indent_offset,
+    )
     yaml.default_flow_style = False
-    yaml.width = None
+    yaml.width = yaml_format.line_width
     yaml.explicit_start = False
     yaml.allow_unicode = True
-
     try:
         config = yaml.load(yaml_content)
-    except ruamel.yaml.error.YAMLError as exc:
+    except YAMLError as exc:
         raise PreCommitLocalUpdateError("Failed to parse YAML content.") from exc
 
     if config is None:
@@ -59,6 +66,7 @@ def update_additional_dependencies(
         )
 
     update_required = False
+    FREEZE_PATTERN = re.compile(r"^#\s*freeze(\s|$)")
 
     if "repos" in config:
         logging.debug("Scanning repositories for local hooks")
@@ -81,35 +89,38 @@ def update_additional_dependencies(
 
                 package_type = SUPPORTED_PACKAGES[hook.get("language")]
 
-                for i, dep_spec in enumerate(deps_list):
-                    dep_str = str(dep_spec)
+                for i, dep_str in enumerate(deps_list):
+
+                    comment = None
+                    if isinstance(deps_list, CommentedSeq):
+                        comment = deps_list.ca.items.get(i, [None, None])[0]
 
-                    if hasattr(deps_list, "ca") and deps_list.ca.items:
-                        comment_data = deps_list.ca.items.get(i)
-                        if comment_data:
-                            if re.match(
-                                r"^#\s*freeze(\s|$)", comment_data[0].value.lower()
-                            ):
-                                logging.debug("Skipping frozen dependency: %s", dep_str)
-                                continue
+                    if comment and hasattr(comment, "value"):
+                        comment_text = comment.value.strip().lower()
+                        if FREEZE_PATTERN.match(comment_text):
+                            logging.debug("Skipping frozen dependency: %s", dep_str)
+                            continue
 
                     logging.debug("Checking dependency: %s", dep_str)
-                    package = package_type.from_specification(
-                        dep_str, connection_timeout
-                    )
+                    clean_dep_str = dep_str.strip().strip('"').strip("'")
+                    package = package_type.from_specification(clean_dep_str)
                     if not package:
+                        logging.warning(
+                            "Unsupported package specification: %s", dep_str
+                        )
                         continue
 
+                    package.fetch_latest_version(connection_timeout)
                     if not package.latest_version_specification():
                         continue
 
                     if (
                         package.latest_version_specification()
-                        != package.version_specification()
+                        != package.original_version_specification()
                     ):
-                        logging.info(
+                        logging.debug(
                             "%s needs updating to %s",
-                            package.version_specification(),
+                            package.original_version_specification(),
                             package.latest_version_specification(),
                         )
                         hook["additional_dependencies"][
@@ -121,41 +132,14 @@ def update_additional_dependencies(
                         logging.debug(
                             "%s is already correctly defined and up to date (%s).",
                             package.name,
-                            package.version_specification(),
+                            package.original_version_specification(),
                         )
     else:
         raise PreCommitLocalUpdateError("Failed to parse pre-commit hooks!")
 
     if update_required:
-        if dry_run:
-            return True
-
-        logging.debug("Writing modifications to disk...")
-        stream = io.StringIO()
-        yaml.dump(config, stream)
-        modified_body = stream.getvalue()
-        final_content = "".join(header_lines) + modified_body
-
-        try:
-            with tempfile.NamedTemporaryFile(
-                mode="w",
-                encoding="utf-8",
-                dir=file_path.parent,
-                delete=False,
-            ) as tmp_file:
-                tmp_file.write(final_content)
-                os.fsync(tmp_file.fileno())
-                temp_file_path = tmp_file.name
-
-            os.replace(temp_file_path, file_path)
-            logging.info("Successfully updated %s", file_path)
-            return True
-
-        except OSError as exc:
-            if "temp_file_path" in locals() and os.path.exists(temp_file_path):
-                os.unlink(temp_file_path)
-            raise PreCommitLocalUpdateError(
-                f"IOError while writing to file {file_path}"
-            ) from exc
+        if not dry_run:
+            save_config_file(file_path, config, header_lines, yaml)
+        return True
 
     return False

{pre_commit_localupdate-0.4.1 → pre_commit_localupdate-0.5.0}/pyproject.toml

@@ -24,12 +24,12 @@ dependencies = [
     "ruamel-yaml>=0.19.1",
     "packaging>=26.0",
 ]
-description = "A CLI tool to automatically update additional dependencies within local Python, Julia, Rust, Go, and Node.js hooks in pre-commit config files."
+description = "A CLI tool to automatically update additional dependencies within local hooks in pre-commit config files."
 dynamic = []
 name = "pre-commit-localupdate"
 readme = "README.md"
 requires-python = "<3.15,>=3.11"
-version = "0.4.1"
+version = "0.5.0"
 
 [project.scripts]
 pre-commit-localupdate = "pre_commit_localupdate.__main__:main"

pre_commit_localupdate-0.4.1/pre_commit_localupdate/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.4.1'

pre_commit_localupdate-0.4.1/pre_commit_localupdate/io.py

@@ -1,53 +0,0 @@
-# SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
-# SPDX-License-Identifier: LGPL-3.0-or-later
-
-import logging
-from pathlib import Path
-
-from pre_commit_localupdate.error import PreCommitLocalUpdateError
-
-
-def load_config_file(file_path: Path) -> tuple[list[str], str]:
-    """Reads pre-commit configuration file and returns its header lines and content.
-
-    Args:
-        file_path (Path): Path to config file
-
-    Returns:
-        tuple[list[str], str]: Header lines, config file content
-
-    Raises:
-        PreCommitLocalUpdateError: Error in reading config file
-    """
-    logging.debug("Reading configuration file: %s", file_path)
-
-    raw_lines: list[str] = []
-    header_lines: list[str] = []
-    content_start_index: int = 0
-
-    try:
-        with file_path.open("r", encoding="utf-8") as f:
-            raw_lines = f.readlines()
-    except FileNotFoundError as exc:
-        error = f"File not found: {file_path}"
-        raise PreCommitLocalUpdateError(error) from exc
-    except OSError as exc:
-        error = f"IOError while reading file {file_path}"
-        raise PreCommitLocalUpdateError(error) from exc
-
-    logging.debug("Parsing file header...")
-    content_start_index = 0
-    for i, line in enumerate(raw_lines):
-        stripped: str = line.strip()
-        if stripped == "---":
-            logging.debug("YAML marker found.")
-            content_start_index = i + 1
-            break
-        if stripped and not stripped.startswith("#"):
-            content_start_index = i
-            break
-
-    header_lines = raw_lines[:content_start_index]
-    content: str = "".join(raw_lines[content_start_index:])
-
-    return header_lines, content