winipedia-utils 0.4.48__py3-none-any.whl → 0.6.12__py3-none-any.whl

winipedia_utils/modules/package.py

@@ -50,7 +50,7 @@ def get_src_package() -> ModuleType:
         TESTS_PACKAGE_NAME,
     )
 
-    packages = find_packages_as_modules(depth=0)
+    packages = find_packages_as_modules(depth=0, include_namespace_packages=True)
     return next(p for p in packages if p.__name__ != TESTS_PACKAGE_NAME)
 
 
@@ -409,33 +409,6 @@ def get_main_package() -> ModuleType:
     raise ValueError(msg)
 
 
-def make_name_from_package(
-    package: ModuleType,
-    split_on: str = "_",
-    join_on: str = "-",
-    *,
-    capitalize: bool = True,
-) -> str:
-    """Make a name from a package.
-
-    takes a package and makes a name from it that is readable by humans.
-
-    Args:
-        package (ModuleType): The package to make a name from
-        split_on (str, optional): what to split the package name on. Defaults to "_".
-        join_on (str, optional): what to join the package name with. Defaults to "-".
-        capitalize (bool, optional): Whether to capitalize each part. Defaults to True.
-
-    Returns:
-        str: _description_
-    """
-    package_name = package.__name__.split(".")[-1]
-    parts = package_name.split(split_on)
-    if capitalize:
-        parts = [part.capitalize() for part in parts]
-    return join_on.join(parts)
-
-
 class DependencyGraph(nx.DiGraph):  # type: ignore [type-arg]
     """A directed graph representing Python package dependencies."""
 
@@ -472,7 +445,8 @@ class DependencyGraph(nx.DiGraph):  # type: ignore [type-arg]
     def parse_pkg_name_from_req(req: str) -> str | None:
         """Extract the bare dependency name from a requirement string."""
         # split on the first non alphanumeric character like >, <, =, etc.
-        dep = re.split(r"[^a-zA-Z0-9]", req.strip())[0].strip()
+        # keep - and _ for names like winipedia-utils or winipedia_utils
+        dep = re.split(r"[^a-zA-Z0-9_-]", req.strip())[0].strip()
         return DependencyGraph.normalize_package_name(dep) if dep else None
 
     def get_all_depending_on(

winipedia_utils/os/os.py

@@ -7,7 +7,7 @@ These utilities help with system-level operations and configuration.
 
 import shutil
 import subprocess  # nosec: B404
-from pathlib import Path
+from collections.abc import Sequence
 from typing import Any
 
 
@@ -34,7 +34,7 @@ def which_with_raise(cmd: str, *, raise_error: bool = True) -> str | None:
 
 
 def run_subprocess(
-    args: list[str | Path],
+    args: Sequence[str],
     *,
     input_: str | bytes | None = None,
     capture_output: bool = True,

winipedia_utils/projects/poetry/config.py

@@ -1,31 +1,62 @@
 """Config utilities for poetry and pyproject.toml."""
 
+from functools import cache
 from pathlib import Path
 from typing import Any, cast
 
-from winipedia_utils.modules.package import get_src_package, make_name_from_package
-from winipedia_utils.projects.poetry.poetry import VersionConstraint
+import requests
+from packaging.version import Version
+
+from winipedia_utils.os.os import run_subprocess
+from winipedia_utils.projects.poetry.dev_deps import DEV_DEPENDENCIES
+from winipedia_utils.projects.poetry.poetry import POETRY_ARG, 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 dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file.
+
+        We remove the wrong dependencies from the config before dumping.
+        So we do not want dependencies under tool.poetry.dependencies but
+        under project.dependencies. And we do not want dev dependencies under
+        tool.poetry.dev-dependencies but under tool.poetry.group.dev.dependencies.
+        """
+        if not isinstance(config, dict):
+            msg = f"Cannot dump {config} to pyproject.toml file."
+            raise TypeError(msg)
+        config = cls.remove_wrong_dependencies(config)
+        super().dump(config)
+
     @classmethod
     def get_parent_path(cls) -> Path:
         """Get the path to the config file."""
         return Path()
 
+    @classmethod
+    def get_repository_name(cls) -> str:
+        """Get the repository name.
+
+        Is the parent folder the project ives in and should be the same as the
+        project name.
+        """
+        cwd = Path.cwd()
+        return cwd.name
+
     @classmethod
     def get_configs(cls) -> dict[str, Any]:
         """Get the config."""
         return {
             "project": {
-                "name": make_name_from_package(get_src_package(), capitalize=False),
+                "name": make_name_from_obj(cls.get_repository_name(), capitalize=False),
                 "readme": "README.md",
-                "dynamic": ["dependencies"],
+                "dependencies": list(cls.get_dependencies()),
             },
             "build-system": {
                 "requires": ["poetry-core>=2.0.0,<3.0.0"],
@@ -33,15 +64,11 @@ class PyprojectConfigFile(TomlConfigFile):
             },
             "tool": {
                 "poetry": {
-                    "packages": [{"include": get_src_package().__name__}],
-                    "dependencies": dict.fromkeys(
-                        cls.get_dependencies(),
-                        "*",
-                    ),
+                    "packages": [{"include": cls.get_repository_name()}],
                     "group": {
                         "dev": {
                             "dependencies": dict.fromkeys(
-                                cls.get_dev_dependencies(),
+                                cls.get_dev_dependencies() | DEV_DEPENDENCIES,
                                 "*",
                             )
                         }
@@ -76,6 +103,29 @@ class PyprojectConfigFile(TomlConfigFile):
         package_name = str(project_dict.get("name", ""))
         return package_name.replace("-", "_")
 
+    @classmethod
+    def remove_wrong_dependencies(cls, config: dict[str, Any]) -> dict[str, Any]:
+        """Remove the wrong dependencies from the config."""
+        # raise if the right sections do not exist
+        if config.get("project", {}).get("dependencies") is None:
+            msg = "No dependencies section in config"
+            raise ValueError(msg)
+
+        if (
+            config.get("tool", {}).get("poetry", {}).get("group", {}).get("dev", {})
+            is None
+        ):
+            msg = "No dev dependencies section in config"
+            raise ValueError(msg)
+
+        # remove the wrong dependencies sections if they exist
+        if config.get("tool", {}).get("poetry", {}).get("dependencies") is not None:
+            del config["tool"]["poetry"]["dependencies"]
+        if config.get("tool", {}).get("poetry", {}).get("dev-dependencies") is not None:
+            del config["tool"]["poetry"]["dev-dependencies"]
+
+        return config
+
     @classmethod
     def get_all_dependencies(cls) -> set[str]:
         """Get all dependencies."""
@@ -103,9 +153,17 @@ class PyprojectConfigFile(TomlConfigFile):
     @classmethod
     def get_dependencies(cls) -> set[str]:
         """Get the dependencies."""
-        return set(
-            cls.load().get("tool", {}).get("poetry", {}).get("dependencies", {}).keys()
-        )
+        deps = set(cls.load().get("project", {}).get("dependencies", {}))
+        deps = {d.split("(")[0].strip() for d in deps}
+        if not deps:
+            deps = set(
+                cls.load()
+                .get("tool", {})
+                .get("poetry", {})
+                .get("dependencies", {})
+                .keys()
+            )
+        return deps
 
     @classmethod
     def get_expected_dev_dependencies(cls) -> set[str]:
@@ -135,25 +193,29 @@ class PyprojectConfigFile(TomlConfigFile):
         return cls.get_main_author()["name"]
 
     @classmethod
-    def get_latest_possible_python_version(cls) -> str:
+    @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)
-        upper = version_constraint.get_upper_exclusive()
-        if upper is None:
-            return "3.x"
-
-        # convert to inclusive
-        if upper.micro != 0:
-            micro = upper.micro - 1
-            return f"{upper.major}.{upper.minor}" + (f".{micro}" if micro != 0 else "")
-        if upper.minor != 0:
-            minor = upper.minor - 1
-            return f"{upper.major}" + (f".{minor}" if minor != 0 else "")
-        return f"{upper.major - 1}.x"
+        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) -> str:
+    def get_first_supported_python_version(cls) -> Version:
         """Get the first supported python version."""
         constraint = cls.load()["project"]["requires-python"]
         version_constraint = VersionConstraint(constraint)
@@ -161,7 +223,28 @@ class PyprojectConfigFile(TomlConfigFile):
         if lower is None:
             msg = "Need a lower bound for python version"
             raise ValueError(msg)
-        return str(lower)
+        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()
+        )
+
+    @classmethod
+    def update_poetry(cls) -> None:
+        """Update poetry."""
+        args = [POETRY_ARG, "self", "update"]
+        run_subprocess(args)
+
+    @classmethod
+    def update_with_dev(cls) -> None:
+        """Install all dependencies with dev."""
+        args = [POETRY_ARG, "update", "--with", "dev"]
+        run_subprocess(args)
 
 
 class TypedConfigFile(ConfigFile):
@@ -223,7 +306,9 @@ class DotPythonVersionConfigFile(ConfigFile):
     def get_configs(cls) -> dict[str, Any]:
         """Get the config."""
         return {
-            cls.VERSION_KEY: PyprojectConfigFile.get_first_supported_python_version()
+            cls.VERSION_KEY: str(
+                PyprojectConfigFile.get_first_supported_python_version()
+            )
         }
 
     @classmethod

winipedia_utils/projects/poetry/dev_deps.py

@@ -0,0 +1,21 @@
+"""Contains a dict with the dev dependencies.
+
+For poetry when winipedia_utils is a dependency.
+winipedia_utils will add these automatically to the pyproject.toml file.
+winipedia utils PyprojectConfigFile will auto dump the config here so it can access it
+when being a dependency in another project.
+"""
+
+DEV_DEPENDENCIES: set[str] = {
+    "ruff",
+    "types-networkx",
+    "types-defusedxml",
+    "types-pyyaml",
+    "pytest",
+    "types-setuptools",
+    "pytest-mock",
+    "bandit",
+    "pre-commit",
+    "mypy",
+    "types-tqdm",
+}

winipedia_utils/projects/poetry/poetry.py

@@ -5,6 +5,7 @@ This module provides utility functions for working with Python projects
 
 from collections.abc import Iterable
 from types import ModuleType
+from typing import Literal
 
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version
@@ -35,6 +36,11 @@ def get_run_python_module_args(module: ModuleType) -> list[str]:
     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))
@@ -42,7 +48,7 @@ def get_python_module_script(module: ModuleType) -> str:
 
 def get_poetry_run_module_script(module: ModuleType) -> str:
     """Get the script to run a module."""
-    return get_script_from_args([*POETRY_RUN_ARGS, *get_run_python_module_args(module)])
+    return get_script_from_args(get_poetry_run_module_args(module))
 
 
 class VersionConstraint:
@@ -92,7 +98,9 @@ class VersionConstraint:
             max(self.lowers_inclusive) if self.lowers_inclusive else None
         )
 
-    def get_lower_inclusive(self, default: str | None = None) -> Version | 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
@@ -106,12 +114,15 @@ class VersionConstraint:
         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 | None = None) -> Version | None:
+    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
@@ -123,7 +134,115 @@ class VersionConstraint:
         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
+
+        Returns:
+            A list of versions
+        """
+        lower = self.get_lower_inclusive(lower_default)
+        upper = self.get_upper_inclusive(upper_default)
+
+        if lower is None or upper is None:
+            msg = "No lower or upper bound. Please specify default values."
+            raise ValueError(msg)
+
+        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]
+
+        versions: list[list[int]] = []
+        for major in range(lower_as_list[major_level], upper_as_list[major_level] + 1):
+            version = [major]
+
+            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)
+
+                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)]

winipedia_utils/projects/project.py

@@ -11,7 +11,6 @@ from winipedia_utils.text.config import (
 
 def create_project_root() -> None:
     """Create the project root."""
-    ConfigFile.init_config_files()
-
     src_package_name = PyprojectConfigFile.get_package_name()
     create_module(src_package_name, is_package=True)
+    ConfigFile.init_config_files()

winipedia_utils/setup.py

@@ -12,13 +12,17 @@ from typing import Any
 from winipedia_utils.git.gitignore.config import GitIgnoreConfigFile
 from winipedia_utils.git.pre_commit.run_hooks import run_hooks
 from winipedia_utils.logging.logger import get_logger
+from winipedia_utils.projects.poetry.config import PyprojectConfigFile
 from winipedia_utils.projects.project import create_project_root
 
 logger = get_logger(__name__)
 
 
 SETUP_STEPS: list[Callable[..., Any]] = [
-    GitIgnoreConfigFile,  # must be first
+    GitIgnoreConfigFile,  # must be before create_project_root
+    PyprojectConfigFile,  # must be before create_project_root
+    PyprojectConfigFile.update_poetry,  # must be before create_project_root
+    PyprojectConfigFile.update_with_dev,  # must be before create_project_root
     create_project_root,
     run_hooks,
 ]

winipedia_utils/testing/create_tests.py

@@ -14,11 +14,11 @@ from winipedia_utils.modules.class_ import (
     get_all_methods_from_cls,
 )
 from winipedia_utils.modules.function import get_all_functions_from_module
+from winipedia_utils.modules.inspection import get_qualname_of_obj
 from winipedia_utils.modules.module import (
     create_module,
     get_isolated_obj_name,
     get_module_content_as_str,
-    get_qualname_of_obj,
     to_path,
 )
 from winipedia_utils.modules.package import (

winipedia_utils/text/config.py

@@ -13,7 +13,7 @@ from winipedia_utils.iterating.iterate import nested_structure_is_subset
 from winipedia_utils.modules.class_ import init_all_nonabstract_subclasses
 from winipedia_utils.modules.package import DependencyGraph, get_src_package
 from winipedia_utils.projects.poetry.poetry import (
-    get_python_module_script,
+    get_poetry_run_module_script,
 )
 from winipedia_utils.text.string import split_on_uppercase
 
@@ -158,11 +158,11 @@ class ConfigFile(ABC):
             init_all_nonabstract_subclasses(cls, load_package_before=pkg)
 
     @staticmethod
-    def get_python_setup_script() -> str:
+    def get_poetry_run_setup_script() -> str:
         """Get the poetry run setup script."""
         from winipedia_utils import setup  # noqa: PLC0415  # avoid circular import
 
-        return get_python_module_script(setup)
+        return get_poetry_run_module_script(setup)
 
 
 class YamlConfigFile(ConfigFile):

winipedia_utils/text/string.py

@@ -7,7 +7,10 @@ These utilities simplify common string manipulation tasks throughout the applica
 
 import hashlib
 import textwrap
+from collections.abc import Callable
 from io import StringIO
+from types import ModuleType
+from typing import Any
 
 from defusedxml import ElementTree as DefusedElementTree
 
@@ -124,3 +127,33 @@ def split_on_uppercase(string: str) -> list[str]:
             current_part += letter
     parts.append(current_part)
     return parts
+
+
+def make_name_from_obj(
+    package: ModuleType | Callable[..., Any] | type | str,
+    split_on: str = "_",
+    join_on: str = "-",
+    *,
+    capitalize: bool = True,
+) -> str:
+    """Make a name from a package.
+
+    takes a package and makes a name from it that is readable by humans.
+
+    Args:
+        package (ModuleType): The package to make a name from
+        split_on (str, optional): what to split the package name on. Defaults to "_".
+        join_on (str, optional): what to join the package name with. Defaults to "-".
+        capitalize (bool, optional): Whether to capitalize each part. Defaults to True.
+
+    Returns:
+        str: _description_
+    """
+    if not isinstance(package, str):
+        package_name = package.__name__.split(".")[-1]
+    else:
+        package_name = package
+    parts = package_name.split(split_on)
+    if capitalize:
+        parts = [part.capitalize() for part in parts]
+    return join_on.join(parts)