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

winipedia_utils/git/github/workflows/health_check.py

@@ -18,40 +18,52 @@ class HealthCheckWorkflow(Workflow):
     @classmethod
     def get_workflow_triggers(cls) -> dict[str, Any]:
         """Get the workflow triggers."""
-        return {
-            "pull_request": {
-                "types": ["opened", "synchronize", "reopened"],
-            },
-            "schedule": [
-                {
-                    # run every day at 6 am
-                    "cron": "0 6 * * *",
-                },
-            ],
-            "workflow_dispatch": {},
-        }
-
-    @classmethod
-    def get_permissions(cls) -> dict[str, Any]:
-        """Get the workflow permissions."""
-        return {}
+        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."""
-        return {
-            **cls.get_standard_job(
-                steps=[
-                    *(
-                        cls.get_poetry_setup_steps(
-                            install_dependencies=True,
-                            token=True,
-                        )
-                    ),
-                    cls.get_protect_repository_step(),
-                    cls.get_pre_commit_step(),
-                    cls.get_commit_step(),
-                    cls.get_extract_version_step(),
-                ],
+        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/git/github/workflows/publish.py

@@ -19,31 +19,33 @@ class PublishWorkflow(Workflow):
     @classmethod
     def get_workflow_triggers(cls) -> dict[str, Any]:
         """Get the workflow triggers."""
-        return {
-            "workflow_run": {
-                "workflows": [ReleaseWorkflow.get_workflow_name()],
-                "types": ["completed"],
-            },
-        }
-
-    @classmethod
-    def get_permissions(cls) -> dict[str, Any]:
-        """Get the workflow permissions."""
-        return {
-            "contents": "read",
-        }
+        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."""
-        return cls.get_standard_job(
-            steps=[
-                *(
-                    cls.get_poetry_setup_steps(
-                        configure_pipy_token=True,
-                    )
-                ),
-                cls.get_publish_to_pypi_step(),
-            ],
-            if_condition="${{ github.event.workflow_run.conclusion == 'success' }}",
+        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/git/github/workflows/release.py

@@ -19,16 +19,10 @@ class ReleaseWorkflow(HealthCheckWorkflow):
     @classmethod
     def get_workflow_triggers(cls) -> dict[str, Any]:
         """Get the workflow triggers."""
-        return {
-            "push": {"branches": ["main"]},
-            "workflow_dispatch": {},
-            "schedule": [
-                {
-                    # run every Tuesday at 6 am
-                    "cron": "0 6 * * 2",
-                },
-            ],
-        }
+        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]:
@@ -40,6 +34,57 @@ class ReleaseWorkflow(HealthCheckWorkflow):
     @classmethod
     def get_jobs(cls) -> dict[str, Any]:
         """Get the workflow jobs."""
-        steps = super().get_jobs()
-        steps[cls.get_filename()]["steps"].extend(cls.get_release_steps())
-        return steps
+        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_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/git/pre_commit/config.py

@@ -5,9 +5,9 @@ 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.text.string import make_name_from_obj
 
 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/git/pre_commit/hooks.py

@@ -7,84 +7,22 @@ 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 pathlib import Path
-
 from winipedia_utils.projects.poetry.poetry import (
     POETRY_ARG,
-    get_run_python_module_args,
+    get_poetry_run_module_args,
 )
 
 
-def patch_version() -> list[str | Path]:
-    """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 | Path]:
-    """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 | Path]:
-    """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 | Path]:
-    """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 | Path]:
-    """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 | Path]:
+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 | Path]:
-    """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 | Path]:
-    """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 | Path]:
+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
@@ -93,7 +31,7 @@ def check_package_manager_configs() -> list[str | Path]:
     return [POETRY_ARG, "check", "--strict"]
 
 
-def create_missing_tests() -> list[str | Path]:
+def create_missing_tests() -> list[str]:
     """Create all tests for the project.
 
     This function returns the input for subprocess.run() to create all tests.
@@ -102,10 +40,10 @@ def create_missing_tests() -> list[str | Path]:
         create_tests,
     )
 
-    return [*get_run_python_module_args(create_tests)]
+    return get_poetry_run_module_args(create_tests)
 
 
-def lint_code() -> list[str | Path]:
+def lint_code() -> list[str]:
     """Check the code.
 
     This function returns the input for subprocess.run() to lint the code.
@@ -114,7 +52,7 @@ def lint_code() -> list[str | Path]:
     return ["ruff", "check", "--fix"]
 
 
-def format_code() -> list[str | Path]:
+def format_code() -> list[str]:
     """Format the code.
 
     This function calls ruff format to format the code.
@@ -122,7 +60,7 @@ def format_code() -> list[str | Path]:
     return ["ruff", "format"]
 
 
-def check_static_types() -> list[str | Path]:
+def check_static_types() -> list[str]:
     """Check the types.
 
     This function returns the input for subprocess.run() to check the static types.
@@ -130,7 +68,7 @@ def check_static_types() -> list[str | Path]:
     return ["mypy", "--exclude-gitignore"]
 
 
-def check_security() -> list[str | Path]:
+def check_security() -> list[str]:
     """Check the security of the code.
 
     This function returns the input for subprocess.run() to check the security of
@@ -139,7 +77,7 @@ def check_security() -> list[str | Path]:
     return ["bandit", "-c", "pyproject.toml", "-r", "."]
 
 
-def run_tests() -> list[str | Path]:
+def run_tests() -> list[str]:
     """Run the tests.
 
     This function returns the input for subprocess.run() to run all tests.

winipedia_utils/git/pre_commit/run_hooks.py

@@ -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/modules/class_.py

@@ -13,10 +13,14 @@ from types import ModuleType
 from typing import Any
 
 from winipedia_utils.modules.function import is_func
+from winipedia_utils.modules.inspection import get_def_line, get_obj_members
 
 
 def get_all_methods_from_cls(
-    class_: type, *, exclude_parent_methods: bool = False
+    class_: type,
+    *,
+    exclude_parent_methods: bool = False,
+    include_annotate: bool = False,
 ) -> list[Callable[..., Any]]:
     """Get all methods from a class.
 
@@ -27,17 +31,21 @@ def get_all_methods_from_cls(
         class_: The class to extract methods from
         exclude_parent_methods: If True, only include methods defined in this class,
         excluding those inherited from parent classes
+        include_annotate: If False, exclude __annotate__ method
+        introduced in Python 3.14, defaults to False
+
     Returns:
         A list of callable methods from the class
 
     """
     from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
-        get_def_line,
         get_module_of_obj,
     )
 
     methods = [
-        (method, name) for name, method in inspect.getmembers(class_) if is_func(method)
+        (method, name)
+        for name, method in get_obj_members(class_, include_annotate=include_annotate)
+        if is_func(method)
     ]
 
     if exclude_parent_methods:
@@ -67,7 +75,6 @@ def get_all_cls_from_module(module: ModuleType | str) -> list[type]:
 
     """
     from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
-        get_def_line,
         get_module_of_obj,
     )
 

winipedia_utils/modules/function.py

@@ -12,6 +12,8 @@ from importlib import import_module
 from types import ModuleType
 from typing import Any
 
+from winipedia_utils.modules.inspection import get_def_line, get_obj_members
+
 
 def is_func_or_method(obj: Any) -> bool:
     """Return True if *obj* is a function or method.
@@ -57,7 +59,9 @@ def is_func(obj: Any) -> bool:
     return is_func_or_method(unwrapped)
 
 
-def get_all_functions_from_module(module: ModuleType | str) -> list[Callable[..., Any]]:
+def get_all_functions_from_module(
+    module: ModuleType | str, *, include_annotate: bool = False
+) -> list[Callable[..., Any]]:
     """Get all functions defined in a module.
 
     Retrieves all function objects that are defined directly in the specified module,
@@ -66,13 +70,14 @@ def get_all_functions_from_module(module: ModuleType | str) -> list[Callable[...
 
     Args:
         module: The module to extract functions from
+        include_annotate: If False, exclude __annotate__ method
+        introduced in Python 3.14, defaults to False
 
     Returns:
         A list of callable functions defined in the module
 
     """
     from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
-        get_def_line,
         get_module_of_obj,
     )
 
@@ -80,7 +85,8 @@ def get_all_functions_from_module(module: ModuleType | str) -> list[Callable[...
         module = import_module(module)
     funcs = [
         func
-        for _name, func in inspect.getmembers(module, is_func)
+        for _name, func in get_obj_members(module, include_annotate=include_annotate)
+        if is_func(func)
         if get_module_of_obj(func).__name__ == module.__name__
     ]
     # sort by definition order

winipedia_utils/modules/inspection.py

@@ -0,0 +1,56 @@
+"""Inspection utilities for introspecting Python objects.
+
+This module provides utility functions for inspecting Python objects,
+including checking if an object is a function or method, and unwrapping
+methods to their underlying functions.
+"""
+
+import inspect
+import sys
+from collections.abc import Callable
+from typing import Any, cast
+
+
+def get_obj_members(
+    obj: Any, *, include_annotate: bool = False
+) -> list[tuple[str, Any]]:
+    """Get all members of an object."""
+    members = [(member, value) for member, value in inspect.getmembers(obj)]
+    if not include_annotate:
+        members = [
+            (member, value)
+            for member, value in members
+            if member not in ("__annotate__", "__annotate_func__")
+        ]
+    return members
+
+
+def inside_frozen_bundle() -> bool:
+    """Return True if the code is running inside a frozen bundle."""
+    return getattr(sys, "frozen", False)
+
+
+def get_def_line(obj: Any) -> int:
+    """Return the line number where a method-like object is defined."""
+    if isinstance(obj, property):
+        obj = obj.fget
+    unwrapped = inspect.unwrap(obj)
+    if hasattr(unwrapped, "__code__"):
+        return int(unwrapped.__code__.co_firstlineno)
+    # getsourcelines does not work if in a pyinstaller bundle or something
+    if inside_frozen_bundle():
+        return 0
+    return inspect.getsourcelines(unwrapped)[1]
+
+
+def get_unwrapped_obj(obj: Any) -> Any:
+    """Return the unwrapped version of a method-like object."""
+    if isinstance(obj, property):
+        obj = obj.fget  # get the getter function of the property
+    return inspect.unwrap(obj)
+
+
+def get_qualname_of_obj(obj: Callable[..., Any] | type) -> str:
+    """Return the name of a method-like object."""
+    unwrapped = get_unwrapped_obj(obj)
+    return cast("str", unwrapped.__qualname__)

winipedia_utils/modules/module.py

@@ -17,7 +17,7 @@ from collections.abc import Callable, Sequence
 from importlib import import_module
 from pathlib import Path
 from types import ModuleType
-from typing import Any, cast
+from typing import Any
 
 from winipedia_utils.logging.logger import get_logger
 from winipedia_utils.modules.class_ import (
@@ -25,6 +25,7 @@ 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, get_unwrapped_obj
 from winipedia_utils.modules.package import (
     get_modules_and_packages_from_package,
     make_dir_with_init_file,
@@ -329,24 +330,6 @@ def get_default_module_content() -> str:
     return '''"""module."""'''
 
 
-def inside_frozen_bundle() -> bool:
-    """Return True if the code is running inside a frozen bundle."""
-    return getattr(sys, "frozen", False)
-
-
-def get_def_line(obj: Any) -> int:
-    """Return the line number where a method-like object is defined."""
-    if isinstance(obj, property):
-        obj = obj.fget
-    unwrapped = inspect.unwrap(obj)
-    if hasattr(unwrapped, "__code__"):
-        return int(unwrapped.__code__.co_firstlineno)
-    # getsourcelines does not work if in a pyinstaller bundle or something
-    if inside_frozen_bundle():
-        return 0
-    return inspect.getsourcelines(unwrapped)[1]
-
-
 def get_module_of_obj(obj: Any, default: ModuleType | None = None) -> ModuleType:
     """Return the module name where a method-like object is defined.
 
@@ -368,19 +351,6 @@ def get_module_of_obj(obj: Any, default: ModuleType | None = None) -> ModuleType
     return module
 
 
-def get_qualname_of_obj(obj: Callable[..., Any] | type) -> str:
-    """Return the name of a method-like object."""
-    unwrapped = get_unwrapped_obj(obj)
-    return cast("str", unwrapped.__qualname__)
-
-
-def get_unwrapped_obj(obj: Any) -> Any:
-    """Return the unwrapped version of a method-like object."""
-    if isinstance(obj, property):
-        obj = obj.fget  # get the getter function of the property
-    return inspect.unwrap(obj)
-
-
 def get_executing_module() -> ModuleType:
     """Get the module where execution has started.