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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pre-commit-localupdate
-Version: 0.3.1
-Summary: A CLI tool to automatically update additional dependencies within local Python, Julia, Rust, and Node.js hooks in pre-commit config files.
+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.
 Author: M. Farzalipour Tabriz
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
@@ -11,11 +11,12 @@ Project-URL: source, https://gitlab.mpcdf.mpg.de/tbz/pre-commit-localupdate.git
 Requires-Python: <3.15,>=3.11
 Requires-Dist: requests>=2.32.5
 Requires-Dist: ruamel-yaml>=0.19.1
+Requires-Dist: packaging>=26.0
 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, 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 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.
 
 ## Installation
 
@@ -31,22 +32,22 @@ To check and update the `additional_dependencies` in your `.pre-commit-config.ya
 pre-commit-localupdate
 ```
 
-By default, the tool looks for `.pre-commit-config.yaml` in the current directory. To specify a custom file path, use the `-c` or `--config` argument:
+All options:
 
 ```shell
-pre-commit-localupdate --config path/to/.pre-commit-config.yaml
-```
-
-To check the dependencies without updating, use the `--dry-run` flag. The command will exit with a non-zero status code if any package needs updating:
-
-```shell
-pre-commit-localupdate --dry-run
-```
-
-To get debug output use `--debug` flag:
-
-```shell
-pre-commit-localupdate --debug
+usage: pre-commit-localupdate [-h] [--debug] [--dry-run] [-c CONFIG] [--timeout TIMEOUT] [--version]
+
+Automatically update additional dependencies within local Python, Julia, Rust, Go, and Node.js 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
 ```
 
 ## Example

{pre_commit_localupdate-0.3.1 → pre_commit_localupdate-0.4.1}/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, 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 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.
 
 ## Installation
 
@@ -16,22 +16,22 @@ To check and update the `additional_dependencies` in your `.pre-commit-config.ya
 pre-commit-localupdate
 ```
 
-By default, the tool looks for `.pre-commit-config.yaml` in the current directory. To specify a custom file path, use the `-c` or `--config` argument:
+All options:
 
 ```shell
-pre-commit-localupdate --config path/to/.pre-commit-config.yaml
-```
-
-To check the dependencies without updating, use the `--dry-run` flag. The command will exit with a non-zero status code if any package needs updating:
-
-```shell
-pre-commit-localupdate --dry-run
-```
-
-To get debug output use `--debug` flag:
-
-```shell
-pre-commit-localupdate --debug
+usage: pre-commit-localupdate [-h] [--debug] [--dry-run] [-c CONFIG] [--timeout TIMEOUT] [--version]
+
+Automatically update additional dependencies within local Python, Julia, Rust, Go, and Node.js 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
 ```
 
 ## Example

pre_commit_localupdate-0.4.1/pre_commit_localupdate/__init__.py

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

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

@@ -25,7 +25,9 @@ def main() -> None:
     setup_logging(debug=args.debug)
 
     try:
-        if update_additional_dependencies(Path(args.config), dry_run=args.dry_run):
+        if update_additional_dependencies(
+            Path(args.config), args.timeout, dry_run=args.dry_run
+        ):
             if args.dry_run:
                 sys.exit(1)
             logging.info("Done.")

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

@@ -7,19 +7,24 @@ from pre_commit_localupdate import __version__
 
 
 def parse_args() -> argparse.Namespace:
-    """Parse command line arguments."""
+    """Parse command line arguments.
+
+    Returns:
+        argparse.Namespace: Parsed arguments.
+    """
     parser = argparse.ArgumentParser(
-        description="Automatically update additional dependencies within local Python, Julia, Rust, and Node.js hooks in a pre-commit config file.",
+        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,
     )
     parser.add_argument(
         "--debug",
         action="store_true",
-        help="Enable debug logging",
+        help="enable debug logging",
     )
     parser.add_argument(
         "--dry-run",
         action="store_true",
-        help="Dry run mode. Do not update the file and exit with a non-zero code if the configuration file require an update.",
+        help="dry run mode. Do not update the file and exit with a non-zero code if the configuration file require an update.",
     )
     parser.add_argument(
         "-c",
@@ -28,6 +33,12 @@ def parse_args() -> argparse.Namespace:
         help="pre-commit config file path",
         default=".pre-commit-config.yaml",
     )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        help="connection timeout in seconds",
+        default=10,
+    )
     parser.add_argument(
         "--version",
         action="version",

{pre_commit_localupdate-0.3.1 → pre_commit_localupdate-0.4.1}/pre_commit_localupdate/io.py

@@ -8,7 +8,17 @@ 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."""
+    """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] = []

{pre_commit_localupdate-0.3.1 → pre_commit_localupdate-0.4.1}/pre_commit_localupdate/logs.py

@@ -6,7 +6,11 @@ import sys
 
 
 def setup_logging(*, debug: bool = False) -> None:
-    """Configure logging based on the debug flag."""
+    """Configure logging based on the debug flag.
+
+    Args:
+        debug (bool): activate debug logs
+    """
     level = logging.DEBUG if debug else logging.INFO
     logging.basicConfig(
         level=level,

{pre_commit_localupdate-0.3.1 → pre_commit_localupdate-0.4.1}/pre_commit_localupdate/packages/__init__.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
 # SPDX-License-Identifier: LGPL-3.0-or-later
 
+from .golang import GoPackage
 from .julia import JuliaPackage
 from .node import NodePackage
 from .package import PackageBase
@@ -8,6 +9,7 @@ from .python import PyPackage
 from .rust import RustPackage
 
 SUPPORTED_PACKAGES: dict[str, type[PackageBase]] = {
+    "golang": GoPackage,
     "julia": JuliaPackage,
     "node": NodePackage,
     "python": PyPackage,

pre_commit_localupdate-0.4.1/pre_commit_localupdate/packages/golang.py

@@ -0,0 +1,126 @@
+# SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+import logging
+import re
+from dataclasses import dataclass
+
+import requests
+
+from .package import PackageBase
+
+# Go Proxy API endpoints
+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:
+        """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)
+
+        Args:
+            spec (str): The package specification string.
+            connection_timeout (int): Connection timeout in seconds.
+
+        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)
+
+        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
+    def _resolve_module_path(package_path: str) -> str:
+        """
+        Resolve a submodule path to a module path.
+
+        If the path contains a major version suffix (e.g., /v2, /v3) followed by
+        additional path segments, it trims the path at the suffix.
+
+        Args:
+            package_path (str): The full submodule path.
+
+        Returns:
+            str: The resolved module path.
+        """
+
+        match = re.search(r"/v([2-9]|[1-9][0-9]+)(?=/)", package_path)
+
+        if match:
+            return package_path[: match.end()]
+
+        return package_path
+
+    @staticmethod
+    def _get_latest_version(package_path: str, connection_timeout: int) -> str | 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.
+        """
+        logging.debug("Fetching latest version for %s", package_path)
+        try:
+            url = GO_PKG_LATEST_VERSION_API_URL.format(package_path=package_path)
+
+            response = requests.get(url, timeout=connection_timeout)
+            response.raise_for_status()
+
+            data = response.json()
+            latest_version = data.get("Version")
+
+            return latest_version if isinstance(latest_version, str) else None
+
+        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.
+
+        Returns:
+            str | None: The latest version specification string if found, otherwise None.
+        """
+        if not self.latest_version:
+            return None
+
+        return f"{self.name}@{self.latest_version}"

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

@@ -4,30 +4,35 @@
 import logging
 import re
 import tomllib
+from dataclasses import dataclass
 
 import requests
+from packaging.version import InvalidVersion, Version
 
 from .package import PackageBase
 
 # Julia General Registry Source
 JULIA_PKG_API_URL = "https://raw.githubusercontent.com/JuliaRegistries/General/refs/heads/master/{package_name_first_letter}/{package_name}/Versions.toml"
-REQUEST_TIMEOUT = 10
 
 
+@dataclass
 class JuliaPackage(PackageBase):
     """Represents a Julia package."""
 
     @classmethod
-    def from_specification(package, spec: str) -> "JuliaPackage" | None:
+    def from_specification(
+        cls, spec: str, connection_timeout: int
+    ) -> "JuliaPackage" | None:
         """Parse a package specification string into a Package object.
 
         Handles formats like 'Example@0.4.1', 'Example@0.4', or just 'Example'.
 
         Args:
-            spec: The package specification string.
+            spec (str): The package specification string.
+            connection_timeout (int): Connection timeout in seconds.
 
         Returns:
-            A Package instance if parsing succeeds, otherwise None.
+            "JuliaPackage" | None: A Package instance if parsing succeeds, otherwise None.
 
         """
         clean_spec = spec.strip().strip('"').strip("'")
@@ -39,20 +44,24 @@ class JuliaPackage(PackageBase):
 
         name = match.group(1)
         raw_spec = match.group(2)
-        latest_version = package._get_latest_version(name)
+        latest_version = cls._get_latest_version(name, connection_timeout)
 
-        return package(
+        return cls(
             name=name,
             raw_spec=raw_spec,
             latest_version=latest_version,
         )
 
     @staticmethod
-    def _get_latest_version(package_name: str) -> str | None:
+    def _get_latest_version(package_name: str, connection_timeout: int) -> str | 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:
-            The latest version string if found, otherwise None.
+            str | None: The latest version string if found, otherwise None.
 
         """
         logging.debug("Fetching latest version for %s", package_name)
@@ -60,7 +69,7 @@ class JuliaPackage(PackageBase):
             url = JULIA_PKG_API_URL.format(
                 package_name=package_name, package_name_first_letter=package_name[0]
             )
-            response = requests.get(url, timeout=REQUEST_TIMEOUT)
+            response = requests.get(url, timeout=connection_timeout)
             response.raise_for_status()
 
             data = tomllib.loads(response.text)
@@ -69,31 +78,29 @@ class JuliaPackage(PackageBase):
             if not versions:
                 return None
 
-            versions.sort(reverse=True)
-            latest = versions[0]
+            versions.sort(key=lambda v: Version(v), reverse=True)
+            latest_version = versions[0]
 
-            if latest and isinstance(latest, str):
-                return latest
+            return latest_version if isinstance(latest_version, str) else None
 
-            return None
         except requests.exceptions.RequestException as exc:
             logging.warning(
                 "Could not fetch latest version for %s: %s", package_name, exc
             )
             return None
-        except (KeyError, ValueError, tomllib.TOMLDecodeError) as exc:
+        except (KeyError, ValueError, tomllib.TOMLDecodeError, InvalidVersion) as exc:
             logging.warning("Could not parse response for %s: %s", package_name, exc)
             return None
 
-    def latest_version_specification(package) -> str | None:
+    def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.
 
         Returns:
-            The latest version specification string if found, otherwise None.
+            str | None: The latest version specification string if found, otherwise None.
             Format: PackageName@version
 
         """
-        if not package.latest_version:
+        if not self.latest_version:
             return None
 
-        return f"{package.name}@{package.latest_version}"
+        return f"{self.name}@{self.latest_version}"

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

@@ -4,14 +4,12 @@
 import logging
 import re
 from dataclasses import dataclass
-from typing import cast
 
 import requests
 
 from .package import PackageBase
 
 NPM_API_URL = "https://registry.npmjs.org/{package_name}"
-REQUEST_TIMEOUT = 10
 
 
 @dataclass
@@ -19,16 +17,19 @@ class NodePackage(PackageBase):
     """Represents a Node.js package."""
 
     @classmethod
-    def from_specification(package, spec: str) -> "NodePackage" | None:
+    def from_specification(
+        cls, spec: str, connection_timeout: int
+    ) -> "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'.
 
         Args:
-            spec: The package specification string.
+            spec (str): The package specification string.
+            connection_timeout (int): Connection timeout in seconds.
 
         Returns:
-            A NodePackage instance if parsing succeeds, otherwise None.
+            "NodePackage" | None: A NodePackage instance if parsing succeeds, otherwise None.
 
         """
         clean_spec = spec.strip().strip('"').strip("'")
@@ -48,34 +49,36 @@ class NodePackage(PackageBase):
                 raw_spec = "@" + "@".join(parts[i:])
                 break
 
-        latest_version = package._get_latest_version(name)
+        latest_version = cls._get_latest_version(name, connection_timeout)
 
-        return package(
+        return cls(
             name=name,
             raw_spec=raw_spec,
             latest_version=latest_version,
         )
 
     @staticmethod
-    def _get_latest_version(package_name: str) -> str | None:
+    def _get_latest_version(package_name: str, connection_timeout: int) -> str | 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:
-            The latest version string if found, otherwise None.
+            str | None: The latest version string if found, otherwise None.
 
         """
         try:
             url = NPM_API_URL.format(package_name=package_name)
-            response = requests.get(url, timeout=REQUEST_TIMEOUT)
+            response = requests.get(url, timeout=connection_timeout)
             response.raise_for_status()
             data = response.json()
 
-            version = data.get("dist-tags", {}).get("latest")
+            latest_version = data.get("dist-tags", {}).get("latest")
 
-            if version and isinstance(version, str):
-                return cast("str", version)
+            return latest_version if isinstance(latest_version, str) else None
 
-            return None
         except requests.exceptions.RequestException as exc:
             logging.warning(
                 "Could not fetch latest version for %s: %s", package_name, exc
@@ -85,14 +88,14 @@ class NodePackage(PackageBase):
             logging.warning("Could not parse response for %s: %s", package_name, exc)
             return None
 
-    def latest_version_specification(package) -> str | None:
+    def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.
 
         Returns:
-            The latest version specification string if found, otherwise None.
+            str | None: The latest version specification string if found, otherwise None.
 
         """
-        if not package.latest_version:
+        if not self.latest_version:
             return None
 
-        return f"{package.name}@{package.latest_version}"
+        return f"{self.name}@{self.latest_version}"

pre_commit_localupdate-0.4.1/pre_commit_localupdate/packages/package.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class PackageBase(ABC):
+    """Abstract base class defining the interface for all package types.
+
+    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').
+
+    """
+
+    name: str
+    raw_spec: str | None
+    latest_version: str | None
+
+    @classmethod
+    @abstractmethod
+    def from_specification(
+        cls, spec_string: str, connection_timeout: int
+    ) -> "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.
+
+        Returns:
+            "PackageBase" | None: A Package instance if parsing succeeds, otherwise None.
+        """
+
+    @abstractmethod
+    def latest_version_specification(self) -> str | None:
+        """Version specification of package pinned to the latest version.
+
+        Returns:
+            str | None: The latest version specification string if found, otherwise None.
+        """
+
+    def version_specification(self) -> str | None:
+        """Version specification of package as originally defined.
+
+        Returns:
+            str | None: The version specification string.
+
+        """
+        if self.raw_spec:
+            return f"{self.name}{self.raw_spec}"
+        return f"{self.name}[unspecified version]"

pre_commit_localupdate-0.4.1/pre_commit_localupdate/packages/python.py

@@ -0,0 +1,95 @@
+# SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+import logging
+from dataclasses import dataclass
+
+import requests
+from packaging.requirements import 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:
+        """Parse a package specification string into a Package object.
+
+        Handles formats like 'ansible==13.3.0', 'ansible>=1.0', or just 'ansible'.
+
+        Args:
+            spec (str): The package specification string.
+            connection_timeout (int): Connection timeout in seconds.
+
+        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
+            )
+            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:
+        """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)
+        try:
+            url = PYPI_API_URL.format(package_name=package_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
+
+        except requests.exceptions.RequestException as exc:
+            logging.warning(
+                "Could not fetch latest version for %s: %s", package_name, exc
+            )
+            return None
+        except (KeyError, ValueError) as exc:
+            logging.warning("Could not parse response for %s: %s", package_name, exc)
+            return None
+
+    def latest_version_specification(self) -> str | None:
+        """Version specification of package pinned to the latest version.
+
+        Returns:
+            str | None: The latest version specification string if found, otherwise None.
+
+        """
+        if not self.latest_version:
+            return None
+
+        return f"{self.name}=={self.latest_version}"

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

@@ -3,40 +3,39 @@
 
 import logging
 import re
-from typing import Any, cast
+from dataclasses import dataclass
 
 import requests
 
 from .package import PackageBase
 
 CRATES_API_URL = "https://crates.io/api/v1/crates/{package_name}"
-REQUEST_TIMEOUT = 10
 
 
+@dataclass
 class RustPackage(PackageBase):
     """Represents a Rust package.
 
     Attributes:
-        cli: Package is a CLI tool.
+        cli (bool): Package is a CLI tool.
     """
 
     cli: bool = False
 
-    def __init__(self, **kwargs: Any) -> None:
-        self.cli = kwargs.pop("cli", False)
-        super().__init__(**kwargs)
-
     @classmethod
-    def from_specification(package, spec: str) -> "RustPackage" | None:
+    def from_specification(
+        cls, spec: str, connection_timeout: int
+    ) -> "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'.
 
         Args:
-            spec: The package specification string.
+            spec (str): The package specification string.
+            connection_timeout (int): Connection timeout in seconds.
 
         Returns:
-            A Package instance if parsing succeeds, otherwise None.
+            "RustPackage" | None: A Package instance if parsing succeeds, otherwise None.
 
         """
         clean_spec = spec.strip().strip('"').strip("'")
@@ -51,34 +50,34 @@ class RustPackage(PackageBase):
 
         name = match.group("name")
         version = match.group("version")
-        cli = True if match.group("cli") else False
+        cli = bool(match.group("cli"))
 
         raw_spec = f":{version}" if version else None
-        latest_version = package._get_latest_version(name)
+        latest_version = cls._get_latest_version(name, connection_timeout)
 
-        return package(
-            name=name, raw_spec=raw_spec, latest_version=latest_version, cli=cli
-        )
+        return cls(name=name, raw_spec=raw_spec, latest_version=latest_version, cli=cli)
 
     @staticmethod
-    def _get_latest_version(package_name: str) -> str | None:
+    def _get_latest_version(package_name: str, connection_timeout: int) -> str | 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:
-            The latest version string if found, otherwise None.
+            str | None: The latest version string if found, otherwise None.
 
         """
         logging.debug("Fetching latest version for %s", package_name)
         try:
             url = CRATES_API_URL.format(package_name=package_name)
-            response = requests.get(url, timeout=REQUEST_TIMEOUT)
+            response = requests.get(url, timeout=connection_timeout)
             response.raise_for_status()
             data = response.json()
-            version = data.get("crate", {}).get("max_version")
-            if version and isinstance(version, str):
-                return cast("str", version)
+            latest_version = data.get("crate", {}).get("max_version")
+            return latest_version if isinstance(latest_version, str) else None
 
-            return None
         except requests.exceptions.RequestException as exc:
             logging.warning(
                 "Could not fetch latest version for %s: %s", package_name, exc
@@ -88,16 +87,16 @@ class RustPackage(PackageBase):
             logging.warning("Could not parse response for %s: %s", package_name, exc)
             return None
 
-    def latest_version_specification(package) -> str | None:
+    def latest_version_specification(self) -> str | None:
         """Version specification of package pinned to the latest version.
 
         Returns:
-            The latest version specification string if found, otherwise None.
+            str | None: The latest version specification string if found, otherwise None.
 
         """
-        if not package.latest_version:
+        if not self.latest_version:
             return None
-        if package.cli:
-            return f"cli:{package.name}:{package.latest_version}"
+        if self.cli:
+            return f"cli:{self.name}:{self.latest_version}"
         else:
-            return f"{package.name}:{package.latest_version}"
+            return f"{self.name}:{self.latest_version}"

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

@@ -15,7 +15,9 @@ from pre_commit_localupdate.io import load_config_file
 from pre_commit_localupdate.packages import SUPPORTED_PACKAGES
 
 
-def update_additional_dependencies(file_path: Path, *, dry_run: bool = False) -> bool:
+def update_additional_dependencies(
+    file_path: Path, connection_timeout: int, *, dry_run: bool = False
+) -> bool:
     """Reads the pre-commit configuration file, identifies outdated packages
     in local hooks, and updates them directly in the file.
 
@@ -23,11 +25,15 @@ def update_additional_dependencies(file_path: Path, *, dry_run: bool = False) ->
     and comments preceding it.
 
     Args:
-        file_path: Path to the pre-commit configuration file.
-        dry_run: Do not update the pre-commit configuration file.
+        file_path (Path): Path to the pre-commit configuration file.
+        connection_timeout (int): Connection timeout in seconds.
+        dry_run (bool): Do not update the pre-commit configuration file.
 
     Returns:
-        True if the file needed updating, False otherwise.
+        bool: True if the file needed updating, False otherwise.
+
+    Raises:
+        PreCommitLocalUpdateError: Error in parsing or updating pre-commit hooks
 
     """
     header_lines, yaml_content = load_config_file(file_path)
@@ -88,7 +94,9 @@ def update_additional_dependencies(file_path: Path, *, dry_run: bool = False) ->
                                 continue
 
                     logging.debug("Checking dependency: %s", dep_str)
-                    package = package_type.from_specification(dep_str)
+                    package = package_type.from_specification(
+                        dep_str, connection_timeout
+                    )
                     if not package:
                         continue
 

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

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

pre_commit_localupdate-0.3.1/pre_commit_localupdate/__init__.py

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

pre_commit_localupdate-0.3.1/pre_commit_localupdate/packages/package.py

@@ -1,41 +0,0 @@
-# SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
-# SPDX-License-Identifier: LGPL-3.0-or-later
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-
-
-@dataclass
-class PackageBase(ABC):
-    """Abstract base class defining the interface for all package types.
-
-    Attributes:
-        name: The name of the package (e.g., 'requests').
-        raw_spec: The original version specifier string (e.g., '==2.25.1', '^4.17.21', '>=1.0.0', '@1.2.3').
-        latest_version: Latest version number without operators (e.g., '2.25.1').
-
-    """
-
-    name: str
-    raw_spec: str | None
-    latest_version: str | None
-
-    @classmethod
-    @abstractmethod
-    def from_specification(package, spec_string: str) -> "PackageBase" | None:
-        """Parse a package specification string into a Package object."""
-
-    @abstractmethod
-    def latest_version_specification(package) -> str | None:
-        """Version specification of package pinned to the latest version."""
-
-    def version_specification(package) -> str | None:
-        """Version specification of package as originally defined.
-
-        Returns:
-            The version specification string.
-
-        """
-        if package.raw_spec:
-            return f"{package.name}{package.raw_spec}"
-        return f"{package.name}[unspecified version]"

pre_commit_localupdate-0.3.1/pre_commit_localupdate/packages/python.py

@@ -1,86 +0,0 @@
-# SPDX-FileCopyrightText: 2026 M. Farzalipour Tabriz, Max Planck Institute for Physics
-# SPDX-License-Identifier: LGPL-3.0-or-later
-
-import logging
-import re
-from typing import cast
-
-import requests
-
-from .package import PackageBase
-
-PYPI_API_URL = "https://pypi.org/pypi/{package_name}/json"
-REQUEST_TIMEOUT = 10
-
-
-class PyPackage(PackageBase):
-    """Represents a Python package."""
-
-    @classmethod
-    def from_specification(package, 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'.
-
-        Args:
-            spec: The package specification string.
-
-        Returns:
-            A Package instance if parsing succeeds, otherwise None.
-
-        """
-        clean_spec = spec.strip().strip('"').strip("'")
-        match = re.match(r"^([a-zA-Z0-9._-]+)([=<>!~]+.*)?$", clean_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 = package._get_latest_version(name)
-
-        return package(
-            name=name,
-            raw_spec=raw_spec,
-            latest_version=latest_version,
-        )
-
-    @staticmethod
-    def _get_latest_version(package_name: str) -> str | None:
-        """Fetch the latest version of a package from PyPI.
-
-        Returns:
-            The latest version string if found, otherwise None.
-
-        """
-        logging.debug("Fetching latest version for %s", package_name)
-        try:
-            url = PYPI_API_URL.format(package_name=package_name)
-            response = requests.get(url, timeout=REQUEST_TIMEOUT)
-            response.raise_for_status()
-            data = response.json()
-            version = data.get("info", {}).get("version")
-            if version and isinstance(version, str):
-                return cast("str", version)
-
-            return None
-        except requests.exceptions.RequestException as exc:
-            logging.warning(
-                "Could not fetch latest version for %s: %s", package_name, exc
-            )
-            return None
-        except (KeyError, ValueError) as exc:
-            logging.warning("Could not parse response for %s: %s", package_name, exc)
-            return None
-
-    def latest_version_specification(package) -> str | None:
-        """Version specification of package pinned to the latest version.
-
-        Returns:
-            The latest version specification string if found, otherwise None.
-
-        """
-        if not package.latest_version:
-            return None
-
-        return f"{package.name}=={package.latest_version}"