winipedia-utils 0.5.22__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/{git → dev/git}/pre_commit/hooks.py

@@ -7,79 +7,19 @@ 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.projects.poetry.poetry import (
+from winipedia_utils.dev.projects.poetry.poetry import (
     POETRY_ARG,
     get_poetry_run_module_args,
 )
 
 
-def patch_version() -> list[str]:
-    """Patch the version in pyproject.toml.
-
-    This function returns the input for subprocess.run() to patch the version
-    in pyproject.toml.
-    """
-    return [POETRY_ARG, "version", "patch"]
-
-
-def add_version_patch_to_git() -> list[str]:
-    """Add the version patch to git.
-
-    This function returns the input for subprocess.run() to add the version
-    patch to git, so that the hook does not fail bc the file was changed.
-    """
-    return ["git", "add", "pyproject.toml"]
-
-
-def update_package_manager() -> list[str]:
-    """Update the package manager.
-
-    This function returns the input for subprocess.run() to update the package
-    manager.
-    """
-    return [POETRY_ARG, "self", "update"]
-
-
-def install_dependencies_with_dev() -> list[str]:
-    """Install all dependencies.
-
-    This function returns the input for subprocess.run() to install all dependencies.
-    """
-    return [POETRY_ARG, "install", "--with", "dev"]
-
-
-def update_dependencies_with_dev() -> list[str]:
-    """Update all dependencies.
-
-    This function returns the input for subprocess.run() to update all dependencies.
-    """
-    return [POETRY_ARG, "update", "--with", "dev"]
-
-
 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"]
-
-
-def lock_dependencies() -> list[str]:
-    """Lock the dependencies.
-
-    This function returns the input for subprocess.run() to lock the dependencies.
-    """
-    return [POETRY_ARG, "lock"]
-
-
-def add_lock_file_to_git() -> list[str]:
-    """Add the lock file to git.
-
-    This function returns the input for subprocess.run() to add the lock file
-    to git, so that the hook does not fail bc the file was changed.
-    """
-    return ["git", "add", "poetry.lock"]
+    return ["git", "add", "pyproject.toml", "poetry.lock"]
 
 
 def check_package_manager_configs() -> list[str]:
@@ -96,7 +36,7 @@ def create_missing_tests() -> list[str]:
 
     This function returns the input for subprocess.run() to create all tests.
     """
-    from winipedia_utils.testing import (  # noqa: PLC0415  # avoid circular import
+    from winipedia_utils.dev.testing import (  # noqa: PLC0415  # avoid circular import
         create_tests,
     )
 

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(
@@ -44,7 +43,7 @@ Stderr:
 
 ---------------------------------------------------------------------------------------------
 """
-            exit_code = 1
+
         # make the dashes always the same lentgth by adjusting to len of hook name
         num_dashes = 50 - len(hook_func.__name__)
         log_method(
@@ -53,6 +52,5 @@ Stderr:
             "-" * num_dashes,
             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/{projects → dev/projects}/poetry/poetry.py

@@ -10,7 +10,7 @@ from typing import Literal
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version
 
-from winipedia_utils.logging.logger import get_logger
+from winipedia_utils.utils.logging.logger import get_logger
 
 logger = get_logger(__name__)
 
@@ -29,7 +29,7 @@ def get_script_from_args(args: Iterable[str]) -> str:
 
 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
+    from winipedia_utils.utils.modules.module import (  # noqa: PLC0415  # avoid circular import
         make_obj_importpath,
     )
 

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."""

winipedia_utils/{testing → dev/testing}/convention.py

@@ -13,7 +13,7 @@ from collections.abc import Callable, Iterable
 from types import ModuleType
 from typing import Any
 
-from winipedia_utils.modules.module import (
+from winipedia_utils.utils.modules.module import (
     get_isolated_obj_name,
     import_obj_from_importpath,
     make_obj_importpath,

winipedia_utils/{testing → dev/testing}/create_tests.py

@@ -9,31 +9,31 @@ NotImplementedError to indicate tests that need to be written.
 from types import ModuleType
 from typing import cast
 
-from winipedia_utils.modules.class_ import (
+from winipedia_utils.dev.configs.testing import ConftestConfigFile, ZeroTestConfigFile
+from winipedia_utils.dev.testing import tests
+from winipedia_utils.dev.testing.convention import (
+    get_test_obj_from_obj,
+    make_test_obj_importpath_from_obj,
+    make_test_obj_name,
+    reverse_make_test_obj_name,
+)
+from winipedia_utils.utils.modules.class_ import (
     get_all_cls_from_module,
     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 (
+from winipedia_utils.utils.modules.function import get_all_functions_from_module
+from winipedia_utils.utils.modules.inspection import get_qualname_of_obj
+from winipedia_utils.utils.modules.module import (
     create_module,
     get_isolated_obj_name,
     get_module_content_as_str,
     to_path,
 )
-from winipedia_utils.modules.package import (
+from winipedia_utils.utils.modules.package import (
     copy_package,
     get_src_package,
     walk_package,
 )
-from winipedia_utils.testing import tests
-from winipedia_utils.testing.config import ConftestConfigFile, ZeroTestConfigFile
-from winipedia_utils.testing.convention import (
-    get_test_obj_from_obj,
-    make_test_obj_importpath_from_obj,
-    make_test_obj_name,
-    reverse_make_test_obj_name,
-)
 
 
 def create_tests() -> None:
@@ -50,7 +50,7 @@ def create_tests_base() -> None:
     """Create the base test structure.
 
     This function:
-    1. Creates a mirror of winipedia_utils.testing.tests in the tests directory
+    1. Creates a mirror of testing.tests in the tests directory
     2. Skips copying __init__.py file contents
     3. Writes new __init__.py files for all packages
     4. Creates a conftest.py file with the appropriate pytest plugin configuration

winipedia_utils/dev/testing/tests/__init__.py

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

winipedia_utils/dev/testing/tests/base/__init__.py

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

winipedia_utils/dev/testing/tests/base/fixtures/__init__.py

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

winipedia_utils/{testing → dev/testing}/tests/base/fixtures/fixture.py

@@ -10,7 +10,7 @@ from pathlib import Path
 
 import pytest
 
-from winipedia_utils.text.config import ConfigFile
+from winipedia_utils.dev.configs.base.config import ConfigFile
 
 
 @pytest.fixture

winipedia_utils/dev/testing/tests/base/fixtures/scopes/__init__.py

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

winipedia_utils/{testing → dev/testing}/tests/base/fixtures/scopes/class_.py

@@ -8,8 +8,8 @@ mechanism.
 
 import pytest
 
-from winipedia_utils.testing.fixtures import autouse_class_fixture
-from winipedia_utils.testing.tests.base.utils.utils import assert_no_untested_objs
+from winipedia_utils.dev.testing.utils import assert_no_untested_objs
+from winipedia_utils.utils.testing.fixtures import autouse_class_fixture
 
 
 @autouse_class_fixture

winipedia_utils/{testing → dev/testing}/tests/base/fixtures/scopes/module.py

@@ -10,8 +10,8 @@ from typing import TYPE_CHECKING
 
 import pytest
 
-from winipedia_utils.testing.fixtures import autouse_module_fixture
-from winipedia_utils.testing.tests.base.utils.utils import assert_no_untested_objs
+from winipedia_utils.dev.testing.utils import assert_no_untested_objs
+from winipedia_utils.utils.testing.fixtures import autouse_module_fixture
 
 if TYPE_CHECKING:
     from types import ModuleType

winipedia_utils/{testing → dev/testing}/tests/base/fixtures/scopes/session.py

@@ -10,21 +10,21 @@ from importlib import import_module
 from pathlib import Path
 
 import winipedia_utils
-from winipedia_utils.modules.package import (
-    find_packages,
-    get_src_package,
-    walk_package,
-)
-from winipedia_utils.projects.poetry.config import (
+from winipedia_utils.dev.configs.base.config import ConfigFile
+from winipedia_utils.dev.configs.pyproject import (
     PyprojectConfigFile,
 )
-from winipedia_utils.testing.assertions import assert_with_msg
-from winipedia_utils.testing.convention import (
+from winipedia_utils.dev.testing.convention import (
     TESTS_PACKAGE_NAME,
     make_test_obj_importpath_from_obj,
 )
-from winipedia_utils.testing.fixtures import autouse_session_fixture
-from winipedia_utils.text.config import ConfigFile
+from winipedia_utils.utils.modules.package import (
+    find_packages,
+    get_src_package,
+    walk_package,
+)
+from winipedia_utils.utils.testing.assertions import assert_with_msg
+from winipedia_utils.utils.testing.fixtures import autouse_session_fixture
 
 
 @autouse_session_fixture

winipedia_utils/dev/testing/tests/base/utils/__init__.py

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

winipedia_utils/dev/testing/tests/base/utils/utils.py

@@ -0,0 +1 @@
+"""Testing utilities."""

winipedia_utils/{testing → dev/testing}/tests/conftest.py

@@ -7,13 +7,13 @@ and adds them to pytest_plugins. This way defining reusable fixtures is easy.
 from pathlib import Path
 
 import winipedia_utils
-from winipedia_utils.modules.module import to_module_name, to_path
+from winipedia_utils.utils.modules.module import to_module_name, to_path
 
 package_path = Path(winipedia_utils.__path__[0])
 
 custom_plugin_path = to_path("tests.base.fixtures", is_package=True)
 package_plugin_path = (
-    package_path / to_path("testing", is_package=True) / custom_plugin_path
+    package_path / to_path("dev.testing", is_package=True) / custom_plugin_path
 )
 
 custom_plugin_module_names = [

winipedia_utils/{testing/tests/base/utils → dev/testing}/utils.py

@@ -13,18 +13,17 @@ from collections.abc import Callable
 from types import ModuleType
 from typing import Any
 
-from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.modules.function import is_abstractmethod
-from winipedia_utils.modules.module import (
-    get_objs_from_obj,
-    make_obj_importpath,
-)
-from winipedia_utils.testing.assertions import assert_with_msg
-from winipedia_utils.testing.convention import (
+from winipedia_utils.dev.testing.convention import (
     get_obj_from_test_obj,
     make_test_obj_importpath_from_obj,
     make_untested_summary_error_msg,
 )
+from winipedia_utils.utils.logging.logger import get_logger
+from winipedia_utils.utils.modules.module import (
+    get_objs_from_obj,
+    make_obj_importpath,
+)
+from winipedia_utils.utils.testing.assertions import assert_with_msg
 
 logger = get_logger(__name__)
 
@@ -63,19 +62,3 @@ def assert_no_untested_objs(
     untested_objs = supposed_test_objs_paths - test_objs_paths
 
     assert_with_msg(not untested_objs, make_untested_summary_error_msg(untested_objs))
-
-
-def assert_isabstrct_method(method: Any) -> None:
-    """Assert that a method is an abstract method.
-
-    Args:
-        method: The method to check
-
-    Raises:
-        AssertionError: If the method is not an abstract method
-
-    """
-    assert_with_msg(
-        is_abstractmethod(method),
-        f"Expected {method} to be abstract method",
-    )