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

winipedia_utils/dev/configs/workflows/health_check.py

@@ -0,0 +1,69 @@
+"""Contains the pull request workflow.
+
+This workflow is used to run tests on pull requests.
+"""
+
+from typing import Any
+
+from winipedia_utils.dev.configs.workflows.base.base import Workflow
+
+
+class HealthCheckWorkflow(Workflow):
+    """Pull request workflow.
+
+    This workflow is triggered by a pull request.
+    It runs tests on the pull request.
+    """
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        triggers = super().get_workflow_triggers()
+        triggers.update(cls.on_pull_request())
+        triggers.update(cls.on_schedule(cron="0 6 * * *"))
+        return triggers
+
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        jobs: dict[str, Any] = {}
+        jobs.update(cls.job_health_check_matrix())
+        jobs.update(cls.job_health_check())
+        return jobs
+
+    @classmethod
+    def job_health_check_matrix(cls) -> dict[str, Any]:
+        """Get the health check matrix job."""
+        return cls.get_job(
+            job_func=cls.job_health_check_matrix,
+            strategy=cls.strategy_matrix_os_and_python_version(),
+            runs_on=cls.insert_matrix_os(),
+            steps=cls.steps_health_check_matrix(),
+        )
+
+    @classmethod
+    def job_health_check(cls) -> dict[str, Any]:
+        """Get the health check job."""
+        return cls.get_job(
+            job_func=cls.job_health_check,
+            needs=[cls.make_id_from_func(cls.job_health_check_matrix)],
+            steps=cls.steps_aggregate_matrix_results(),
+        )
+
+    @classmethod
+    def steps_health_check_matrix(cls) -> list[dict[str, Any]]:
+        """Get the health check matrix steps."""
+        return [
+            *cls.steps_core_matrix_setup(
+                python_version=cls.insert_matrix_python_version()
+            ),
+            cls.step_protect_repository(),
+            cls.step_run_pre_commit_hooks(),
+        ]
+
+    @classmethod
+    def steps_aggregate_matrix_results(cls) -> list[dict[str, Any]]:
+        """Get the aggregate matrix results step."""
+        return [
+            cls.step_aggregate_matrix_results(),
+        ]

winipedia_utils/dev/configs/workflows/publish.py

@@ -0,0 +1,51 @@
+"""Contains the publish workflow.
+
+This workflow is used to publish the package to PyPI with poetry.
+"""
+
+from typing import Any
+
+from winipedia_utils.dev.configs.workflows.base.base import Workflow
+from winipedia_utils.dev.configs.workflows.release import ReleaseWorkflow
+
+
+class PublishWorkflow(Workflow):
+    """Publish workflow.
+
+    This workflow is triggered by the release workflow.
+    It publishes the package to PyPI with poetry.
+    """
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        triggers = super().get_workflow_triggers()
+        triggers.update(
+            cls.on_workflow_run(workflows=[ReleaseWorkflow.get_workflow_name()])
+        )
+        return triggers
+
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        jobs: dict[str, Any] = {}
+        jobs.update(cls.job_publish())
+        return jobs
+
+    @classmethod
+    def job_publish(cls) -> dict[str, Any]:
+        """Get the publish job."""
+        return cls.get_job(
+            job_func=cls.job_publish,
+            steps=cls.steps_publish(),
+            if_condition=cls.if_workflow_run_is_success(),
+        )
+
+    @classmethod
+    def steps_publish(cls) -> list[dict[str, Any]]:
+        """Get the publish steps."""
+        return [
+            *cls.steps_core_setup(),
+            cls.step_add_pypi_token_to_poetry(),
+            cls.step_publish_to_pypi(),
+        ]

winipedia_utils/dev/configs/workflows/release.py

@@ -0,0 +1,91 @@
+"""Contains the release workflow.
+
+This workflow is used to create a release on GitHub.
+"""
+
+from typing import Any
+
+from winipedia_utils.dev.configs.workflows.health_check import HealthCheckWorkflow
+
+
+class ReleaseWorkflow(HealthCheckWorkflow):
+    """Release workflow.
+
+    This workflow is triggered by a push to the main branch.
+    It creates a tag for the release and builds a changelog.
+    With tag and changelog it creates a release on GitHub
+    """
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        triggers = super().get_workflow_triggers()
+        triggers.update(cls.on_push())
+        triggers.update(cls.on_schedule(cron="0 6 * * 2"))
+        return triggers
+
+    @classmethod
+    def get_permissions(cls) -> dict[str, Any]:
+        """Get the workflow permissions."""
+        permissions = super().get_permissions()
+        permissions["contents"] = "write"
+        return permissions
+
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        jobs = super().get_jobs()
+        last_job_name = list(jobs.keys())[-1]
+        jobs.update(cls.job_build(needs=[last_job_name]))
+        jobs.update(cls.job_release())
+        return jobs
+
+    @classmethod
+    def job_build(cls, needs: list[str] | None = None) -> dict[str, Any]:
+        """Get the build job."""
+        return cls.get_job(
+            job_func=cls.job_build,
+            needs=needs,
+            strategy=cls.strategy_matrix_os(),
+            runs_on=cls.insert_matrix_os(),
+            steps=cls.steps_build(),
+        )
+
+    @classmethod
+    def job_release(cls) -> dict[str, Any]:
+        """Get the release job."""
+        return cls.get_job(
+            job_func=cls.job_release,
+            needs=[cls.make_id_from_func(cls.job_build)],
+            steps=cls.steps_release(),
+        )
+
+    @classmethod
+    def steps_build(cls) -> list[dict[str, Any]]:
+        """Get the build steps."""
+        if not cls.BUILD_SCRIPT_PATH.exists():
+            return [cls.step_no_build_script()]
+        return [
+            *cls.steps_core_matrix_setup(),
+            cls.step_build_artifacts(),
+            cls.step_upload_artifacts(),
+        ]
+
+    @classmethod
+    def steps_release(cls) -> list[dict[str, Any]]:
+        """Get the release steps."""
+        return [
+            *cls.steps_core_setup(repo_token=True),
+            cls.step_install_python_dependencies(),
+            cls.step_setup_keyring(),
+            cls.step_setup_git(),
+            cls.step_add_version_patch(),
+            cls.step_run_pre_commit_hooks(),
+            cls.step_commit_added_changes(),
+            cls.step_push_commits(),
+            cls.step_create_and_push_tag(),
+            cls.step_extract_version(),
+            cls.step_download_artifacts(),
+            cls.step_build_changelog(),
+            cls.step_create_release(),
+        ]

winipedia_utils/dev/git/github/repo/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils/{git → dev/git}/github/repo/protect.py

@@ -2,17 +2,17 @@
 
 from typing import Any
 
-from winipedia_utils.git.github.github import get_github_repo_token
-from winipedia_utils.git.github.repo.repo import (
+from winipedia_utils.dev.configs.pyproject import PyprojectConfigFile
+from winipedia_utils.dev.configs.workflows.health_check import HealthCheckWorkflow
+from winipedia_utils.utils.git.github.github import get_github_repo_token
+from winipedia_utils.utils.git.github.repo.repo import (
     DEFAULT_BRANCH,
     DEFAULT_RULESET_NAME,
     create_or_update_ruleset,
     get_repo,
     get_rules_payload,
 )
-from winipedia_utils.git.github.workflows.health_check import HealthCheckWorkflow
-from winipedia_utils.modules.package import get_src_package
-from winipedia_utils.projects.poetry.config import PyprojectConfigFile
+from winipedia_utils.utils.modules.package import get_src_package
 
 
 def protect_repository() -> None:

winipedia_utils/dev/git/pre_commit/hooks.py

@@ -0,0 +1,85 @@
+"""module contains functions that return the input for subprocess.run().
+
+Each function is named after the hook it represents. The docstring of each function
+describes the hook it represents. The function returns a list of strings that
+represent the command to run. The first string is the command, and the following
+strings are the arguments to the command. These funcs will be called by
+run_hooks.py, which will pass the returned list to subprocess.run().
+"""
+
+from winipedia_utils.dev.projects.poetry.poetry import (
+    POETRY_ARG,
+    get_poetry_run_module_args,
+)
+
+
+def add_updates_to_git() -> list[str]:
+    """Add the updated dependencies to git.
+
+    This function returns the input for subprocess.run() to add the updated
+    dependencies to git, so that the hook does not fail bc the file was changed.
+    """
+    return ["git", "add", "pyproject.toml", "poetry.lock"]
+
+
+def check_package_manager_configs() -> list[str]:
+    """Check that poetry.lock and pyproject.toml is up to date.
+
+    This function returns the input for subprocess.run() to check that poetry.lock
+    is up to date.
+    """
+    return [POETRY_ARG, "check", "--strict"]
+
+
+def create_missing_tests() -> list[str]:
+    """Create all tests for the project.
+
+    This function returns the input for subprocess.run() to create all tests.
+    """
+    from winipedia_utils.dev.testing import (  # noqa: PLC0415  # avoid circular import
+        create_tests,
+    )
+
+    return get_poetry_run_module_args(create_tests)
+
+
+def lint_code() -> list[str]:
+    """Check the code.
+
+    This function returns the input for subprocess.run() to lint the code.
+    It autofixes all errors that can be autofixed with --fix.
+    """
+    return ["ruff", "check", "--fix"]
+
+
+def format_code() -> list[str]:
+    """Format the code.
+
+    This function calls ruff format to format the code.
+    """
+    return ["ruff", "format"]
+
+
+def check_static_types() -> list[str]:
+    """Check the types.
+
+    This function returns the input for subprocess.run() to check the static types.
+    """
+    return ["mypy", "--exclude-gitignore"]
+
+
+def check_security() -> list[str]:
+    """Check the security of the code.
+
+    This function returns the input for subprocess.run() to check the security of
+    the code.
+    """
+    return ["bandit", "-c", "pyproject.toml", "-r", "."]
+
+
+def run_tests() -> list[str]:
+    """Run the tests.
+
+    This function returns the input for subprocess.run() to run all tests.
+    """
+    return ["pytest"]

winipedia_utils/{git → dev/git}/pre_commit/run_hooks.py

@@ -6,11 +6,11 @@ and should not be modified manually.
 
 import sys
 
-from winipedia_utils.git.pre_commit import hooks
-from winipedia_utils.logging.ansi import GREEN, RED, RESET
-from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.modules.function import get_all_functions_from_module
-from winipedia_utils.os.os import run_subprocess
+from winipedia_utils.dev.git.pre_commit import hooks
+from winipedia_utils.utils.logging.ansi import GREEN, RED, RESET
+from winipedia_utils.utils.logging.logger import get_logger
+from winipedia_utils.utils.modules.function import get_all_functions_from_module
+from winipedia_utils.utils.os.os import run_subprocess
 
 logger = get_logger(__name__)
 
@@ -19,7 +19,6 @@ def run_hooks() -> None:
     """Import all funcs defined in hooks.py and runs them."""
     hook_funcs = get_all_functions_from_module(hooks)
 
-    exit_code = 0
     for hook_func in hook_funcs:
         subprocess_args = hook_func()
         result = run_subprocess(
@@ -28,19 +27,30 @@ def run_hooks() -> None:
         passed = result.returncode == 0
 
         log_method = logger.info
-        passed_str = (f"{GREEN}PASSED" if passed else f"{RED}FAILED") + RESET
+        status_str = (f"{GREEN}PASSED" if passed else f"{RED}FAILED") + RESET
         if not passed:
             log_method = logger.error
-            passed_str += f"\n{result.stdout}"
-            exit_code = 1
+            status_str += f"""
+---------------------------------------------------------------------------------------------
+Stdout:
+
+{result.stdout}
+
+---------------------------------------------------------------------------------------------
+Stderr:
+
+{result.stderr}
+
+---------------------------------------------------------------------------------------------
+"""
+
         # make the dashes always the same lentgth by adjusting to len of hook name
         num_dashes = 50 - len(hook_func.__name__)
         log_method(
             "Hook %s -%s> %s",
             hook_func.__name__,
             "-" * num_dashes,
-            passed_str,
+            status_str,
         )
-
-    if exit_code != 0:
-        sys.exit(exit_code)
+        if not passed:
+            sys.exit(1)

winipedia_utils/dev/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/dev/projects/poetry/poetry.py

@@ -0,0 +1,248 @@
+"""Project utilities for introspection and manipulation.
+
+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
+
+from winipedia_utils.utils.logging.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+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.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
+
+        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 → dev/projects}/project.py

@@ -1,17 +1,16 @@
 """Utilities for working with Python projects."""
 
-from winipedia_utils.modules.module import create_module
-from winipedia_utils.projects.poetry.config import (
-    PyprojectConfigFile,  # avoid circular import
-)
-from winipedia_utils.text.config import (
+from winipedia_utils.dev.configs.base.config import (
     ConfigFile,  # avoid circular import
 )
+from winipedia_utils.dev.configs.pyproject import (
+    PyprojectConfigFile,  # avoid circular import
+)
+from winipedia_utils.utils.modules.module import create_module
 
 
 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/dev/testing/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""