pspm 1.0.0__py3-none-any.whl

pspm/__init__.py

@@ -0,0 +1 @@
+"""Initial docstring."""

pspm/cli.py

@@ -0,0 +1,24 @@
+"""main."""
+
+from typing import Annotated
+
+import typer
+from rich import print as rprint
+
+from pspm.services.dependencies import add_dependency
+
+app = typer.Typer()
+
+
+@app.callback()
+def callback() -> None:
+    """Python simple package manager."""
+
+
+@app.command()
+def add(
+    package: str, group: Annotated[str, typer.Option("--group", "-g")] = ""
+) -> None:
+    """Add package to pyproject, install it and lock version."""
+    rprint(f"Adding package {package}")
+    add_dependency(package, group or None)

pspm/entities/__init__.py

@@ -0,0 +1 @@
+"""Modules to put entities."""

pspm/entities/installer.py

@@ -0,0 +1,69 @@
+"""Module with classes to deal with packages."""
+
+import abc
+import subprocess
+from shutil import which
+
+import uv
+
+from pspm.errors.dependencies import InstallError
+
+
+class BaseInstaller(abc.ABC):
+    """Package installer."""
+
+    @abc.abstractmethod
+    def install(self, package: str) -> None:
+        """Install package.
+
+        Args:
+        ----
+            package: Package to install
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def uninstall(self, package: str) -> None:
+        """Uninstall package.
+
+        Args:
+        ----
+            package: Package to uninstall
+
+        """
+        raise NotImplementedError
+
+
+class UVInstaller(BaseInstaller):
+    """Install packages with UV."""
+
+    def __init__(self) -> None:
+        """Initialize UV Installer."""
+        self._uv_path = which("uv") or uv.find_uv_bin()
+
+    def install(self, package: str) -> None:
+        """Install package.
+
+        Args:
+        ----
+            package: Package to install
+
+        Raises:
+        ------
+            InstallError: If can't install package
+
+        """
+        retcode = subprocess.call([self._uv_path, "pip", "install", package])  # noqa: S603
+        if retcode != 0:
+            raise InstallError(package)
+
+    def uninstall(self, package: str) -> None:
+        """Uninstall package.
+
+        Args:
+        ----
+            package: Package to uninstall
+
+        """
+        raise NotImplementedError

pspm/entities/pyproject.py

@@ -0,0 +1,50 @@
+"""Module to interact with pyproject.toml file."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pspm.entities.toml import BaseToml
+
+
+class Pyproject:
+    """Class for manipulating pyproject.toml file."""
+
+    def __init__(self, toml_parser: BaseToml) -> None:
+        """Init Pyproject.
+
+        Args:
+            toml_parser: Parser to be used for parsing TOML
+        """
+        self._parser = toml_parser
+
+    def add_dependency(self, package: str) -> None:
+        """Add dependency to project.
+
+        Args:
+            package: Package to download
+        """
+        data = self._parser.load()
+        dependencies: list[str] = data["project"].get("dependencies", [])
+        dependencies.append(package)
+        data["project"]["dependencies"] = dependencies
+        self._parser.dump(data)
+
+    def add_group_dependency(self, package: str, group: str) -> None:
+        """Add optional-dependency with group to project.
+
+        Args:
+            package: Package to install
+            group: Group that package will be inserted
+        """
+        data = self._parser.load()
+        optional_dependencies = data["project"].get(
+            "optional-dependencies",
+            {},
+        )
+        dependencies = optional_dependencies.get(group, [])
+        dependencies.append(package)
+        optional_dependencies[group] = dependencies
+        data["project"]["optional-dependencies"] = optional_dependencies
+        self._parser.dump(data)

pspm/entities/resolver.py

@@ -0,0 +1,59 @@
+"""Module with classes to deal with dependecy versions."""
+
+from __future__ import annotations
+
+import abc
+import subprocess
+from shutil import which
+
+import uv
+
+
+class BaseResolver(abc.ABC):
+    """Base class for resolving dependencies.
+
+    Attributes:
+        pyproject_path: Path to pyproject.
+    """
+
+    def __init__(self, pyproject_path: str) -> None:
+        """Initialize BaseResolver."""
+        self.pyproject_path = pyproject_path
+
+    @abc.abstractmethod
+    def compile(self, output_file: str, group: str | None = None) -> None:
+        """Compiles requirements into a lock file.
+
+        Args:
+            output_file: File to write output
+            group: Group to include dependencies from
+        """
+        raise NotImplementedError
+
+
+class UVResolver(BaseResolver):
+    """Class for resolving dependencies with UV."""
+
+    def __init__(self, pyproject_path: str) -> None:
+        """Initialize UV Compiler."""
+        self.pyproject_path = pyproject_path
+        self._uv_path = which("uv") or uv.find_uv_bin()
+
+    def compile(self, output_file: str, group: str | None = None) -> None:
+        """Compiles requirements into a lock file.
+
+        Args:
+            output_file: File to write output
+            group: Group to include dependencies from
+        """
+        extra_arguments = ["--extra", group] if group else []
+        subprocess.call([  # noqa: S603
+            self._uv_path,
+            "pip",
+            "compile",
+            "-q",
+            *extra_arguments,
+            "-o",
+            output_file,
+            self.pyproject_path,
+        ])

pspm/entities/toml.py

@@ -0,0 +1,62 @@
+"""Module for interacting with toml files."""
+
+from __future__ import annotations
+
+import abc
+from pathlib import Path
+from typing import Any
+
+import tomli
+import tomli_w
+
+
+class BaseToml(abc.ABC):
+    """TOML Parser and writer.
+
+    Attributes:
+        path: TOML file path
+    """
+
+    def __init__(self, path: str) -> None:
+        """Initialize TOML.
+
+        Args:
+            path: File path to TOML file
+        """
+        self.path = path
+
+    @abc.abstractmethod
+    def load(self) -> dict[str, Any]:
+        """Load TOML file."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def dump(self, data: dict[str, Any]) -> None:
+        """Write a dictionary to a file containing TOML-formatted data.
+
+        Args:
+            data: TOML data
+        """
+        raise NotImplementedError
+
+
+class Toml(BaseToml):
+    """TOML Parser and writer."""
+
+    def load(self) -> dict[str, Any]:
+        """Load TOML file.
+
+        Returns:
+            A dictionary containing parsed TOML
+        """
+        with Path(self.path).open("rb") as f:
+            return tomli.load(f)
+
+    def dump(self, data: dict[str, Any]) -> None:
+        """Write a dictionary to a file containing TOML-formatted data.
+
+        Args:
+            data: TOML data
+        """
+        with Path(self.path).open("wb") as f:
+            tomli_w.dump(data, f)

pspm/errors/__init__.py

@@ -0,0 +1 @@
+"""Error modules."""

pspm/errors/dependencies.py

@@ -0,0 +1,15 @@
+"""Module with errors related to dependency management."""
+
+
+class InstallError(Exception):
+    """Can't install package."""
+
+    def __init__(self, package: str) -> None:
+        """Initialize InstallError.
+
+        Args:
+            package: Package that failed to be installed
+        """
+        self.package = package
+        self.message = f"Error installing package {package}"
+        super().__init__(self.message)

pspm/services/__init__.py

@@ -0,0 +1 @@
+"""Modules to put logic."""

pspm/services/dependencies.py

@@ -0,0 +1,57 @@
+"""Module to handle dependencies."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich import print as rprint
+
+from pspm.entities.installer import BaseInstaller, UVInstaller
+from pspm.entities.pyproject import Pyproject
+from pspm.entities.resolver import BaseResolver, UVResolver
+from pspm.entities.toml import Toml
+from pspm.errors.dependencies import InstallError
+
+
+def _get_pyproject_path() -> str:
+    path = Path(Path.cwd()) / "pyproject.toml"
+    return str(path)
+
+
+def _get_pyproject() -> Pyproject:
+    path = _get_pyproject_path()
+    parser = Toml(str(path))
+    return Pyproject(parser)
+
+
+def _get_resolver() -> BaseResolver:
+    path = _get_pyproject_path()
+    return UVResolver(path)
+
+
+def _get_installer() -> BaseInstaller:
+    return UVInstaller()
+
+
+def add_dependency(package: str, group: str | None = None) -> None:
+    """Add dependency to pyproject.
+
+    Args:
+        package: Package to install
+        group: Group to insert package
+    """
+    installer = _get_installer()
+    try:
+        installer.install(package)
+    except InstallError:
+        rprint(f":boom: [red]Failed to install {package}[/red]")
+        return
+
+    pyproject = _get_pyproject()
+    if not group:
+        pyproject.add_dependency(package)
+    else:
+        pyproject.add_group_dependency(package, group)
+    resolver = _get_resolver()
+    output_file = f"requirements{'-' + group if group else ''}.lock"
+    resolver.compile(output_file, group)