winipedia-utils 0.4.43__py3-none-any.whl → 0.7.1__py3-none-any.whl

winipedia_utils/artifacts/build.py

@@ -0,0 +1,27 @@
+"""Build utilities for creating and managing project builds.
+
+This module provides functions for building and managing project artifacts,
+including creating build scripts, configuring build environments, and
+handling build dependencies. These utilities help with the packaging and
+distribution of project code.
+"""
+
+from pathlib import Path
+
+from winipedia_utils.dev.artifacts.build import Build
+
+
+class WinipediaUtilsBuild(Build):
+    """Build script for winipedia_utils."""
+
+    @classmethod
+    def get_artifacts(cls) -> list[Path]:
+        """Build the project."""
+        paths = [cls.ARTIFACTS_PATH / "build.txt"]
+        for path in paths:
+            path.write_text("Hello World!")
+        return paths
+
+
+if __name__ == "__main__":
+    WinipediaUtilsBuild()

winipedia_utils/dev/artifacts/build.py

@@ -0,0 +1,62 @@
+"""Build utilities for creating and managing project builds.
+
+This module provides functions for building and managing project artifacts,
+including creating build scripts, configuring build environments, and
+handling build dependencies. These utilities help with the packaging and
+distribution of project code.
+"""
+
+import platform
+from abc import abstractmethod
+from pathlib import Path
+
+from winipedia_utils.dev.configs.workflows.base.base import Workflow
+from winipedia_utils.utils.oop.mixins.mixin import ABCLoggingMixin
+
+
+class Build(ABCLoggingMixin):
+    """Base class for build scripts.
+
+    Subclass this class and implement the get_artifacts method to create
+    a build script for your project. The build method will be called
+    automatically when the class is initialized. At the end of the file add
+    if __name__ == "__main__":
+        YourBuildClass()
+    """
+
+    ARTIFACTS_PATH = Workflow.ARTIFACTS_PATH
+
+    @classmethod
+    @abstractmethod
+    def get_artifacts(cls) -> list[Path]:
+        """Build the project.
+
+        Returns:
+            list[Path]: List of paths to the built artifacts
+        """
+
+    @classmethod
+    def __init__(cls) -> None:
+        """Initialize the build script."""
+        cls.build()
+
+    @classmethod
+    def build(cls) -> None:
+        """Build the project.
+
+        This method is called by the __init__ method.
+        It takes all the files and renames them with -platform.system()
+        and puts them in the artifacts folder.
+        """
+        cls.ARTIFACTS_PATH.mkdir(parents=True, exist_ok=True)
+        artifacts = cls.get_artifacts()
+        for artifact in artifacts:
+            parent = artifact.parent
+            if parent != cls.ARTIFACTS_PATH:
+                msg = f"You must create {artifact} in {cls.ARTIFACTS_PATH}"
+                raise FileNotFoundError(msg)
+
+            # rename the files with -platform.system()
+            new_name = f"{artifact.stem}-{platform.system()}{artifact.suffix}"
+            new_path = cls.ARTIFACTS_PATH / new_name
+            artifact.rename(new_path)

winipedia_utils/{text → dev/configs/base}/config.py

@@ -9,14 +9,13 @@ import tomlkit
 import yaml
 from dotenv import dotenv_values
 
-import winipedia_utils
-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 get_src_package
-from winipedia_utils.projects.poetry.poetry import (
-    get_python_module_script,
+from winipedia_utils.dev.projects.poetry.poetry import (
+    get_poetry_run_module_script,
 )
-from winipedia_utils.text.string import split_on_uppercase
+from winipedia_utils.utils.data.structures.text.string import split_on_uppercase
+from winipedia_utils.utils.iterating.iterate import nested_structure_is_subset
+from winipedia_utils.utils.modules.class_ import init_all_nonabstract_subclasses
+from winipedia_utils.utils.modules.package import DependencyGraph, get_src_package
 
 
 class ConfigFile(ABC):
@@ -149,15 +148,21 @@ class ConfigFile(ABC):
     @classmethod
     def init_config_files(cls) -> None:
         """Initialize all subclasses."""
-        init_all_nonabstract_subclasses(cls, load_package_before=winipedia_utils)
-        init_all_nonabstract_subclasses(cls, load_package_before=get_src_package())
+        pkgs_depending_on_winipedia_utils = (
+            DependencyGraph().get_all_depending_on_winipedia_utils(
+                include_winipedia_utils=True
+            )
+        )
+        pkgs_depending_on_winipedia_utils.add(get_src_package())
+        for pkg in pkgs_depending_on_winipedia_utils:
+            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/{git/gitignore/config.py → dev/configs/gitignore.py}

@@ -5,8 +5,8 @@ from typing import Any
 
 import requests
 
-from winipedia_utils.testing.config import ExperimentConfigFile
-from winipedia_utils.text.config import ConfigFile, DotEnvConfigFile
+from winipedia_utils.dev.configs.base.config import ConfigFile, DotEnvConfigFile
+from winipedia_utils.dev.configs.testing import ExperimentConfigFile
 
 
 class GitIgnoreConfigFile(ConfigFile):

winipedia_utils/{git/pre_commit/config.py → dev/configs/pre_commit.py}

@@ -4,10 +4,10 @@ from pathlib import Path
 from typing import Any
 
 import winipedia_utils
-from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.modules.package import make_name_from_package
-from winipedia_utils.os.os import run_subprocess
-from winipedia_utils.text.config import YamlConfigFile
+from winipedia_utils.dev.configs.base.config import YamlConfigFile
+from winipedia_utils.utils.data.structures.text.string import make_name_from_obj
+from winipedia_utils.utils.logging.logger import get_logger
+from winipedia_utils.utils.os.os import run_subprocess
 
 logger = get_logger(__name__)
 
@@ -29,7 +29,7 @@ class PreCommitConfigConfigFile(YamlConfigFile):
     @classmethod
     def get_configs(cls) -> dict[str, Any]:
         """Get the config."""
-        hook_name = make_name_from_package(winipedia_utils, capitalize=False)
+        hook_name = make_name_from_obj(winipedia_utils, capitalize=False)
         return {
             "repos": [
                 {
@@ -38,7 +38,7 @@ class PreCommitConfigConfigFile(YamlConfigFile):
                         {
                             "id": hook_name,
                             "name": hook_name,
-                            "entry": cls.get_python_setup_script(),
+                            "entry": cls.get_poetry_run_setup_script(),
                             "language": "system",
                             "always_run": True,
                             "pass_filenames": False,

winipedia_utils/{projects/poetry/config.py → dev/configs/pyproject.py}

@@ -1,30 +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
-from winipedia_utils.testing.convention import TESTS_PACKAGE_NAME
-from winipedia_utils.text.config import ConfigFile, TomlConfigFile
+import requests
+from packaging.version import Version
+
+from winipedia_utils.dev.configs.base.config import ConfigFile, TomlConfigFile
+from winipedia_utils.dev.configs.testing import ExperimentConfigFile
+from winipedia_utils.dev.projects.poetry.dev_deps import DEV_DEPENDENCIES
+from winipedia_utils.dev.projects.poetry.poetry import POETRY_ARG, VersionConstraint
+from winipedia_utils.dev.testing.convention import TESTS_PACKAGE_NAME
+from winipedia_utils.utils.data.structures.text.string import make_name_from_obj
+from winipedia_utils.utils.os.os import run_subprocess
 
 
 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"],
@@ -32,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,
                                 "*",
                             )
                         }
@@ -62,7 +90,9 @@ class PyprojectConfigFile(TomlConfigFile):
                     "files": ".",
                 },
                 "pytest": {"ini_options": {"testpaths": [TESTS_PACKAGE_NAME]}},
-                "bandit": {},
+                "bandit": {
+                    "exclude_dirs": [ExperimentConfigFile.get_path().as_posix()],
+                },
             },
         }
 
@@ -73,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."""
@@ -100,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]:
@@ -132,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)
@@ -158,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):
@@ -220,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/{testing/config.py → dev/configs/testing.py}

@@ -4,8 +4,9 @@ from abc import abstractmethod
 from pathlib import Path
 from typing import Any
 
-from winipedia_utils.testing.convention import TESTS_PACKAGE_NAME
-from winipedia_utils.text.config import ConfigFile
+from winipedia_utils.dev.configs.base.config import ConfigFile
+from winipedia_utils.dev.testing.convention import TESTS_PACKAGE_NAME
+from winipedia_utils.utils.modules.module import make_obj_importpath
 
 
 class PythonConfigFile(ConfigFile):
@@ -73,7 +74,9 @@ class ConftestConfigFile(PythonTestsConfigFile):
     @classmethod
     def get_content_str(cls) -> str:
         """Get the config content."""
-        return '''"""Pytest configuration for tests.
+        from winipedia_utils.dev.testing.tests import conftest  # noqa: PLC0415
+
+        return f'''"""Pytest configuration for tests.
 
 This module configures pytest plugins for the test suite, setting up the necessary
 fixtures and hooks for the different
@@ -82,7 +85,7 @@ It also import custom plugins from tests/base/scopes.
 This file should not be modified manually.
 """
 
-pytest_plugins = ["winipedia_utils.testing.tests.conftest"]
+pytest_plugins = ["{make_obj_importpath(conftest)}"]
 '''