winipedia-utils 0.2.63__py3-none-any.whl → 0.6.6__py3-none-any.whl

winipedia_utils/projects/poetry/config.py

@@ -1,117 +1,260 @@
 """Config utilities for poetry and pyproject.toml."""
 
+from functools import cache
 from pathlib import Path
-from typing import Any
-
-import tomlkit
-from tomlkit.toml_document import TOMLDocument
-
-from winipedia_utils.projects.poetry.poetry import logger
-
-
-def laod_pyproject_toml() -> TOMLDocument:
-    """Load the pyproject.toml file."""
-    return tomlkit.parse(Path("pyproject.toml").read_text())
-
-
-def get_dev_dependencies_from_pyproject_toml() -> set[str]:
-    """Get the dev dependencies from pyproject.toml."""
-    toml = laod_pyproject_toml()
-    dev_dependencies = (
-        toml.get("tool", {})
-        .get("poetry", {})
-        .get("group", {})
-        .get("dev", {})
-        .get("dependencies", {})
-        .keys()
-    )
-    if not dev_dependencies:
-        dev_dependencies = toml.get("dependency-groups", {}).get("dev", [])
-        dev_dependencies = [d.split("(")[0].strip() for d in dev_dependencies]
-    return set(dev_dependencies)
-
-
-def dump_pyproject_toml(toml: TOMLDocument) -> None:
-    """Dump the pyproject.toml file."""
-    with Path("pyproject.toml").open("w") as f:
-        tomlkit.dump(toml, f)
-
-
-def get_poetry_package_name() -> str:
-    """Get the name of the project from pyproject.toml."""
-    toml = laod_pyproject_toml()
-    project_dict = toml.get("project", {})
-    project_name = str(project_dict.get("name", ""))
-    return project_name.replace("-", "_")
-
-
-def _get_pyproject_toml_tool_configs() -> dict[str, Any]:
-    """Get the tool configurations for pyproject.toml."""
-    return {
-        "ruff": {
-            "exclude": [".*", "**/migrations/*.py"],
-            "lint": {
-                "select": ["ALL"],
-                "ignore": ["D203", "D213", "COM812", "ANN401"],
-                "fixable": ["ALL"],
-                "pydocstyle": {
-                    "convention": "google",
+from typing import Any, cast
+
+import requests
+from packaging.version import Version
+
+from winipedia_utils.modules.package import get_src_package
+from winipedia_utils.projects.poetry.poetry import VersionConstraint
+from winipedia_utils.testing.config import ExperimentConfigFile
+from winipedia_utils.testing.convention import TESTS_PACKAGE_NAME
+from winipedia_utils.text.config import ConfigFile, TomlConfigFile
+from winipedia_utils.text.string import make_name_from_obj
+
+
+class PyprojectConfigFile(TomlConfigFile):
+    """Config file for pyproject.toml."""
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path()
+
+    @classmethod
+    def get_configs(cls) -> dict[str, Any]:
+        """Get the config."""
+        return {
+            "project": {
+                "name": make_name_from_obj(get_src_package(), capitalize=False),
+                "readme": "README.md",
+                "dynamic": ["dependencies"],
+            },
+            "build-system": {
+                "requires": ["poetry-core>=2.0.0,<3.0.0"],
+                "build-backend": "poetry.core.masonry.api",
+            },
+            "tool": {
+                "poetry": {
+                    "packages": [{"include": get_src_package().__name__}],
+                    "dependencies": dict.fromkeys(
+                        cls.get_dependencies(),
+                        "*",
+                    ),
+                    "group": {
+                        "dev": {
+                            "dependencies": dict.fromkeys(
+                                cls.get_dev_dependencies(),
+                                "*",
+                            )
+                        }
+                    },
+                },
+                "ruff": {
+                    "exclude": [".*", "**/migrations/*.py"],
+                    "lint": {
+                        "select": ["ALL"],
+                        "ignore": ["D203", "D213", "COM812", "ANN401"],
+                        "fixable": ["ALL"],
+                        "pydocstyle": {"convention": "google"},
+                    },
+                },
+                "mypy": {
+                    "strict": True,
+                    "warn_unreachable": True,
+                    "show_error_codes": True,
+                    "files": ".",
+                },
+                "pytest": {"ini_options": {"testpaths": [TESTS_PACKAGE_NAME]}},
+                "bandit": {
+                    "exclude_dirs": [ExperimentConfigFile.get_path().as_posix()],
                 },
             },
-        },
-        "mypy": {
-            "strict": True,
-            "warn_unreachable": True,
-            "show_error_codes": True,
-            "files": ".",
-        },
-        "pytest": {
-            "ini_options": {
-                "testpaths": ["tests"],
-            }
-        },
-        "bandit": {},
-    }
-
-
-def _tool_config_is_correct(tool: str, config: dict[str, Any]) -> bool:
-    """Check if the tool configuration in pyproject.toml is correct."""
-    toml = laod_pyproject_toml()
-    actual_tools = toml.get("tool", {})
-
-    return bool(actual_tools.get(tool) == config)
-
-
-def _pyproject_tool_configs_are_correct() -> bool:
-    """Check if the tool configurations in pyproject.toml are correct."""
-    expected_tool_dict = _get_pyproject_toml_tool_configs()
-    for tool, config in expected_tool_dict.items():
-        if not _tool_config_is_correct(tool, config):
-            return False
-
-    return True
-
-
-def _add_configurations_to_pyproject_toml() -> None:
-    """Add tool.* configurations to pyproject.toml."""
-    expected_tool_dict = _get_pyproject_toml_tool_configs()
-    toml = laod_pyproject_toml()
-    actual_tool_dict = toml.get("tool", None)
-    if actual_tool_dict is None:
-        # add tool section
-        toml.add("tool", tomlkit.table())
-
-    actual_tool_dict = toml.get("tool", None)
-    if actual_tool_dict is None:
-        msg = "tool section is None after adding it"
-        raise ValueError(msg)
-
-    # update the toml dct and dump it but only update the tools specified not all tools
-    for tool, config in expected_tool_dict.items():
-        # if tool section already exists skip it
-        if not _tool_config_is_correct(tool, config):
-            logger.info("Adding tool.%s configuration to pyproject.toml", tool)
-            # updates inplace of toml_dict["tool"][tool]
-            actual_tool_dict[tool] = config
-
-    dump_pyproject_toml(toml)
+        }
+
+    @classmethod
+    def get_package_name(cls) -> str:
+        """Get the package name."""
+        project_dict = cls.load().get("project", {})
+        package_name = str(project_dict.get("name", ""))
+        return package_name.replace("-", "_")
+
+    @classmethod
+    def get_all_dependencies(cls) -> set[str]:
+        """Get all dependencies."""
+        return cls.get_dependencies() | cls.get_dev_dependencies()
+
+    @classmethod
+    def get_dev_dependencies(cls) -> set[str]:
+        """Get the dev dependencies."""
+        dev_dependencies = set(
+            cls.load()
+            .get("tool", {})
+            .get("poetry", {})
+            .get("group", {})
+            .get("dev", {})
+            .get("dependencies", {})
+            .keys()
+        )
+        if not dev_dependencies:
+            dev_dependencies = set(
+                cls.load().get("dependency-groups", {}).get("dev", [])
+            )
+            dev_dependencies = {d.split("(")[0].strip() for d in dev_dependencies}
+        return dev_dependencies
+
+    @classmethod
+    def get_dependencies(cls) -> set[str]:
+        """Get the dependencies."""
+        return set(
+            cls.load().get("tool", {}).get("poetry", {}).get("dependencies", {}).keys()
+        )
+
+    @classmethod
+    def get_expected_dev_dependencies(cls) -> set[str]:
+        """Get the expected dev dependencies."""
+        return set(
+            cls.get_configs()["tool"]["poetry"]["group"]["dev"]["dependencies"].keys()
+        )
+
+    @classmethod
+    def get_authors(cls) -> list[dict[str, str]]:
+        """Get the authors."""
+        return cast(
+            "list[dict[str, str]]", cls.load().get("project", {}).get("authors", [])
+        )
+
+    @classmethod
+    def get_main_author(cls) -> dict[str, str]:
+        """Get the main author.
+
+        Assumes the main author is the first author.
+        """
+        return cls.get_authors()[0]
+
+    @classmethod
+    def get_main_author_name(cls) -> str:
+        """Get the main author name."""
+        return cls.get_main_author()["name"]
+
+    @classmethod
+    @cache
+    def fetch_latest_python_version(cls) -> Version:
+        """Fetch the latest python version from python.org."""
+        url = "https://endoflife.date/api/python.json"
+        resp = requests.get(url, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        # first element has metadata for latest stable
+        latest_version = data[0]["latest"]
+        return Version(latest_version)
+
+    @classmethod
+    def get_latest_possible_python_version(cls) -> Version:
+        """Get the latest possible python version."""
+        constraint = cls.load()["project"]["requires-python"]
+        version_constraint = VersionConstraint(constraint)
+        version = version_constraint.get_upper_inclusive()
+        if version is None:
+            version = cls.fetch_latest_python_version()
+        return version
+
+    @classmethod
+    def get_first_supported_python_version(cls) -> Version:
+        """Get the first supported python version."""
+        constraint = cls.load()["project"]["requires-python"]
+        version_constraint = VersionConstraint(constraint)
+        lower = version_constraint.get_lower_inclusive()
+        if lower is None:
+            msg = "Need a lower bound for python version"
+            raise ValueError(msg)
+        return lower
+
+    @classmethod
+    def get_supported_python_versions(cls) -> list[Version]:
+        """Get all supported python versions."""
+        constraint = cls.load()["project"]["requires-python"]
+        version_constraint = VersionConstraint(constraint)
+        return version_constraint.get_version_range(
+            level="minor", upper_default=cls.fetch_latest_python_version()
+        )
+
+
+class TypedConfigFile(ConfigFile):
+    """Config file for py.typed."""
+
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "typed"
+
+    @classmethod
+    def load(cls) -> dict[str, Any] | list[Any]:
+        """Load the config file."""
+        return {}
+
+    @classmethod
+    def dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file."""
+        if config:
+            msg = "Cannot dump to py.typed file."
+            raise ValueError(msg)
+
+    @classmethod
+    def get_configs(cls) -> dict[str, Any] | list[Any]:
+        """Get the config."""
+        return {}
+
+
+class PyTypedConfigFile(ConfigFile):
+    """Config file for py.typed."""
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path(PyprojectConfigFile.get_package_name())
+
+
+class DotPythonVersionConfigFile(ConfigFile):
+    """Config file for .python-version."""
+
+    VERSION_KEY = "version"
+
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        return ""  # so it builds the path .python-version
+
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "python-version"
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path()
+
+    @classmethod
+    def get_configs(cls) -> dict[str, Any]:
+        """Get the config."""
+        return {
+            cls.VERSION_KEY: str(
+                PyprojectConfigFile.get_first_supported_python_version()
+            )
+        }
+
+    @classmethod
+    def load(cls) -> dict[str, Any]:
+        """Load the config file."""
+        return {cls.VERSION_KEY: cls.get_path().read_text()}
+
+    @classmethod
+    def dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file."""
+        if not isinstance(config, dict):
+            msg = f"Cannot dump {config} to .python-version file."
+            raise TypeError(msg)
+        cls.get_path().write_text(config[cls.VERSION_KEY])

winipedia_utils/projects/poetry/poetry.py

@@ -3,29 +3,246 @@
 This module provides utility functions for working with Python projects
 """
 
-import sys
+from collections.abc import Iterable
+from types import ModuleType
+from typing import Literal
+
+from packaging.specifiers import SpecifierSet
+from packaging.version import Version
 
-from winipedia_utils.consts import _DEV_DEPENDENCIES
 from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.os.os import run_subprocess, which_with_raise
 
 logger = get_logger(__name__)
 
 
-POETRY_PATH = which_with_raise("poetry", raise_error=False) or "poetry"
+POETRY_ARG = "poetry"
+
+POETRY_RUN_ARGS = [POETRY_ARG, "run"]
+
+RUN_PYTHON_MODULE_ARGS = ["python", "-m"]
+
+
+def get_script_from_args(args: Iterable[str]) -> str:
+    """Get the script from args."""
+    return " ".join(args)
+
+
+def get_run_python_module_args(module: ModuleType) -> list[str]:
+    """Get the args to run a module."""
+    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+        make_obj_importpath,
+    )
+
+    return [*RUN_PYTHON_MODULE_ARGS, make_obj_importpath(module)]
+
+
+def get_poetry_run_module_args(module: ModuleType) -> list[str]:
+    """Get the args to run a module."""
+    return [*POETRY_RUN_ARGS, *get_run_python_module_args(module)]
+
+
+def get_python_module_script(module: ModuleType) -> str:
+    """Get the script to run a module."""
+    return get_script_from_args(get_run_python_module_args(module))
+
+
+def get_poetry_run_module_script(module: ModuleType) -> str:
+    """Get the script to run a module."""
+    return get_script_from_args(get_poetry_run_module_args(module))
+
+
+class VersionConstraint:
+    """Version class."""
+
+    def __init__(self, constraint: str) -> None:
+        """Initialize the version."""
+        self.constraint = constraint
+        self.spec = self.constraint.strip().strip('"').strip("'")
+        self.sset = SpecifierSet(self.spec)
+
+        self.lowers_inclusive = [
+            Version(s.version) for s in self.sset if s.operator == ">="
+        ]
+        self.lowers_exclusive = [
+            Version(s.version) for s in self.sset if s.operator == ">"
+        ]
+        # increment the last number of exclusive, so
+        # >3.4.1 to >=3.4.2; <3.4.0 to <=3.4.1; 3.0.0 to <=3.0.1
+        self.lowers_exclusive_to_inclusive = [
+            Version(f"{v.major}.{v.minor}.{v.micro + 1}") for v in self.lowers_exclusive
+        ]
+        self.lowers_inclusive = (
+            self.lowers_inclusive + self.lowers_exclusive_to_inclusive
+        )
+
+        self.uppers_inclusive = [
+            Version(s.version) for s in self.sset if s.operator == "<="
+        ]
+        self.uppers_exclusive = [
+            Version(s.version) for s in self.sset if s.operator == "<"
+        ]
+
+        # increment the last number of inclusive, so
+        # <=3.4.1 to <3.4.2; >=3.4.0 to >3.4.1; 3.0.0 to >3.0.1
+        self.uppers_inclusive_to_exclusive = [
+            Version(f"{v.major}.{v.minor}.{v.micro + 1}") for v in self.uppers_inclusive
+        ]
+        self.uppers_exclusive = (
+            self.uppers_inclusive_to_exclusive + self.uppers_exclusive
+        )
+
+        self.upper_exclusive = (
+            min(self.uppers_exclusive) if self.uppers_exclusive else None
+        )
+        self.lower_inclusive = (
+            max(self.lowers_inclusive) if self.lowers_inclusive else None
+        )
+
+    def get_lower_inclusive(
+        self, default: str | Version | None = None
+    ) -> Version | None:
+        """Get the minimum version.
+
+        Is given inclusive. E.g. >=3.8, <3.12 -> 3.8
+        if >3.7, <3.12 -> 3.7.1
+
+        E.g. >=3.8, <3.12 -> 3.8
+
+        Args:
+            default: The default value to return if there is no minimum version
+
+        Returns:
+            The minimum version
+        """
+        default = str(default) if default else None
+        if self.lower_inclusive is None:
+            return Version(default) if default else None
+
+        return self.lower_inclusive
+
+    def get_upper_exclusive(
+        self, default: str | Version | None = None
+    ) -> Version | None:
+        """Get the maximum version.
+
+        Is given exclusive. E.g. >=3.8, <3.12 -> 3.12
+        if >=3.8, <=3.12 -> 3.12.1
+
+        Args:
+            default: The default value to return if there is no maximum version
+
+        Returns:
+            The maximum version
+        """
+        default = str(default) if default else None
+        if self.upper_exclusive is None:
+            return Version(default) if default else None
+
+        return self.upper_exclusive
+
+    def get_upper_inclusive(
+        self, default: str | Version | None = None
+    ) -> Version | None:
+        """Get the maximum version.
+
+        Is given inclusive. E.g. >=3.8, <3.12 -> 3.11
+        if >=3.8, <=3.12 -> 3.12
+
+        Args:
+            default: The default value to return if there is no maximum version
+
+        Returns:
+            The maximum version
+        """
+        # increment the default by 1 micro to make it exclusive
+        if default:
+            default = Version(str(default))
+            default = Version(f"{default.major}.{default.minor}.{default.micro + 1}")
+        upper_exclusive = self.get_upper_exclusive(default)
+        if upper_exclusive is None:
+            return None
+
+        if upper_exclusive.micro != 0:
+            return Version(
+                f"{upper_exclusive.major}.{upper_exclusive.minor}.{upper_exclusive.micro - 1}"  # noqa: E501
+            )
+        if upper_exclusive.minor != 0:
+            return Version(f"{upper_exclusive.major}.{upper_exclusive.minor - 1}")
+        return Version(f"{upper_exclusive.major - 1}")
+
+    def get_version_range(
+        self,
+        level: Literal["major", "minor", "micro"] = "major",
+        lower_default: str | Version | None = None,
+        upper_default: str | Version | None = None,
+    ) -> list[Version]:
+        """Get the version range.
+
+        returns a range of versions according to the level
+
+        E.g. >=3.8, <3.12; level=major -> 3
+            >=3.8, <4.12; level=major -> 3, 4
+        E.g. >=3.8, <=3.12; level=minor -> 3.8, 3.9, 3.10, 3.11, 3.12
+        E.g. >=3.8.1, <=4.12.1; level=micro -> 3.8.1, 3.8.2, ... 4.12.1
+
+        Args:
+            level: The level of the version to return
+            lower_default: The default lower bound if none is specified
+            upper_default: The default upper bound if none is specified
 
-POETRY_RUN_ARGS = [POETRY_PATH, "run"]
+        Returns:
+            A list of versions
+        """
+        lower = self.get_lower_inclusive(lower_default)
+        upper = self.get_upper_inclusive(upper_default)
 
-POETRY_ADD_ARGS = [POETRY_PATH, "add"]
+        if lower is None or upper is None:
+            msg = "No lower or upper bound. Please specify default values."
+            raise ValueError(msg)
 
-POETRY_ADD_DEV_ARGS = [*POETRY_ADD_ARGS, "--group", "dev"]
+        major_level, minor_level, micro_level = range(3)
+        level_int = {"major": major_level, "minor": minor_level, "micro": micro_level}[
+            level
+        ]
+        lower_as_list = [lower.major, lower.minor, lower.micro]
+        upper_as_list = [upper.major, upper.minor, upper.micro]
 
-POETRY_RUN_PYTHON_ARGS = [*POETRY_RUN_ARGS, sys.executable]
+        versions: list[list[int]] = []
+        for major in range(lower_as_list[major_level], upper_as_list[major_level] + 1):
+            version = [major]
 
-POETRY_RUN_RUFF_ARGS = [*POETRY_RUN_ARGS, "ruff"]
+            minor_lower_og, minor_upper_og = (
+                lower_as_list[minor_level],
+                upper_as_list[minor_level],
+            )
+            diff = minor_upper_og - minor_lower_og
+            minor_lower = minor_lower_og if diff >= 0 else 0
+            minor_upper = minor_upper_og if diff >= 0 else minor_lower_og + abs(diff)
+            for minor in range(
+                minor_lower,
+                minor_upper + 1,
+            ):
+                # pop the minor if one already exists
+                if len(version) > minor_level:
+                    version.pop()
 
+                version.append(minor)
 
-def _install_dev_dependencies() -> None:
-    """Install winipedia_utils dev dependencies as dev dependencies."""
-    logger.info("Adding dev dependencies: %s", _DEV_DEPENDENCIES)
-    run_subprocess([*POETRY_ADD_DEV_ARGS, *_DEV_DEPENDENCIES], check=True)
+                micro_lower_og, micro_upper_og = (
+                    lower_as_list[micro_level],
+                    upper_as_list[micro_level],
+                )
+                diff = micro_upper_og - micro_lower_og
+                micro_lower = micro_lower_og if diff >= 0 else 0
+                micro_upper = (
+                    micro_upper_og if diff >= 0 else micro_lower_og + abs(diff)
+                )
+                for micro in range(
+                    micro_lower,
+                    micro_upper + 1,
+                ):
+                    version.append(micro)
+                    versions.append(version[: level_int + 1])
+                    version.pop()
+        version_versions = sorted({Version(".".join(map(str, v))) for v in versions})
+        return [v for v in version_versions if self.sset.contains(v)]