winipedia-utils 0.4.56__tar.gz → 0.5.18__tar.gz

{winipedia_utils-0.4.56 → winipedia_utils-0.5.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winipedia-utils
-Version: 0.4.56
+Version: 0.5.18
 Summary: A package with many utility functions
 License-Expression: MIT
 License-File: LICENSE

{winipedia_utils-0.4.56 → winipedia_utils-0.5.18}/pyproject.toml

@@ -1,7 +1,7 @@
 # Project section
 [project]
 name = "winipedia-utils"
-version = "0.4.56"
+version = "0.5.18"
 description = "A package with many utility functions"
 readme = "README.md"
 requires-python = ">=3.12"

{winipedia_utils-0.4.56 → winipedia_utils-0.5.18}/winipedia_utils/git/github/workflows/base/base.py

@@ -74,36 +74,46 @@ class Workflow(YamlConfigFile):
             "on": cls.get_workflow_triggers(),
             "permissions": cls.get_permissions(),
             "run-name": cls.get_run_name(),
+            "defaults": {"run": {"shell": "bash"}},
             "jobs": cls.get_jobs(),
         }
 
     @classmethod
-    def get_standard_job(
+    def get_standard_job(  # noqa: PLR0913
         cls,
         name: str | None = None,
         runs_on: str = "ubuntu-latest",
+        strategy: dict[str, Any] | None = None,
         permissions: dict[str, Any] | None = None,
         if_condition: str | None = None,
         steps: list[dict[str, Any]] | None = None,
+        needs: list[str] | None = None,
     ) -> dict[str, Any]:
         """Get a standard job."""
+        job: dict[str, Any] = {}
         if name is None:
             name = cls.get_filename()
+        job[name] = {}
+        job_config = job[name]
 
-        if steps is None:
-            steps = []
-
-        job: dict[str, Any] = {
-            name: {
-                "runs-on": runs_on,
-                "steps": steps,
-            }
-        }
         if permissions is not None:
-            job[name]["permissions"] = permissions
+            job_config["permissions"] = permissions
+
+        if strategy is not None:
+            job_config["strategy"] = strategy
+
+        job_config["runs-on"] = runs_on
+
+        if needs is not None:
+            job_config["needs"] = needs
 
         if if_condition is not None:
-            job[name]["if"] = if_condition
+            job_config["if"] = if_condition
+
+        if steps is None:
+            steps = []
+        job_config["steps"] = steps
+
         return job
 
     @classmethod
@@ -151,8 +161,9 @@ class Workflow(YamlConfigFile):
         fetch_depth: int | None = None,
         configure_pipy_token: bool = False,
         force_main_head: bool = False,
-        token: bool = False,
+        repo_token: bool = False,
         with_keyring: bool = False,
+        strategy_matrix: bool = False,
     ) -> list[dict[str, Any]]:
         """Get the poetry steps.
 
@@ -163,13 +174,15 @@ class Workflow(YamlConfigFile):
         force_main_head: Whether to exit if the running branch or current commit is not
             equal to the most recent commit on main. This is useful for workflows that
             should only run on main.
-        token: Whether to use the repository token.
+        repo_token: Whether to use the repository token.
         with_keyring: Whether to setup the keyring.
+        strategy_matrix: Whether to use the strategy matrix python-version.
+            This is useful for jobs that use a matrix.
 
         Returns:
         The poetry steps.
         """
-        steps = [cls.get_checkout_step(fetch_depth, token=token)]
+        steps = [cls.get_checkout_step(fetch_depth, token=repo_token)]
         if force_main_head:
             # exit with code 1 if the running branch is not main
             steps.append(
@@ -184,21 +197,33 @@ class Workflow(YamlConfigFile):
                 "name": "Setup Python",
                 "uses": "actions/setup-python@main",
                 "with": {
-                    "python-version": PyprojectConfigFile.get_latest_possible_python_version()  # noqa: E501
+                    # get latest if strategy matrix python-version is not set
+                    "python-version": "${{ matrix.python-version }}"
+                    if strategy_matrix
+                    else str(PyprojectConfigFile.get_latest_possible_python_version())
                 },
             }
         )
         steps.append(
             {
-                "name": "Install Poetry",
-                "run": "curl -sSL https://install.python-poetry.org | python3 -",
+                "name": "Setup Poetry",
+                "uses": "snok/install-poetry@main",
             }
         )
 
+        if strategy_matrix:
+            steps.append(
+                {
+                    # windows needs this step to find poetry
+                    "name": "Add Poetry to PATH",
+                    "run": "echo 'C:/Users/runneradmin/.local/bin' >> $GITHUB_PATH",
+                }
+            )
+
         if configure_pipy_token:
             steps.append(
                 {
-                    "name": "Configure Poetry",
+                    "name": "Configure Poetry with PyPI Token",
                     "run": "poetry config pypi-token.pypi ${{ secrets.PYPI_TOKEN }}",
                 }
             )
@@ -215,6 +240,13 @@ class Workflow(YamlConfigFile):
     def get_release_steps(cls) -> list[dict[str, Any]]:
         """Get the release steps."""
         return [
+            *cls.get_poetry_setup_steps(
+                install_dependencies=True,
+                repo_token=True,
+            ),
+            cls.get_pre_commit_step(),
+            cls.get_commit_step(),
+            cls.get_extract_version_step(),
             {
                 "name": "Tag and Push",
                 "run": f"git push && git tag {cls.get_version()} && git push origin {cls.get_version()}",  # noqa: E501
@@ -260,6 +292,9 @@ class Workflow(YamlConfigFile):
         """
         step: dict[str, Any] = {
             "name": "Run Hooks",
+            # poetry run is necessary although the hook itself uses poetry run as well.
+            # not sure why, but on windows-latest the venv is not continued to the hooks
+            # and if you leave it here then pre-commit command is not found
             "run": "poetry run pre-commit run --all-files --verbose",
         }
         if get_src_package() == winipedia_utils:
@@ -287,7 +322,7 @@ class Workflow(YamlConfigFile):
         """Get the setup keyring step."""
         return {
             "name": "Setup CI keyring",
-            "run": """poetry run pip install keyrings.alt && poetry run python -c "import keyring; from keyrings.alt.file import PlaintextKeyring; keyring.set_keyring(PlaintextKeyring()); keyring.set_password('video_vault','ci_user','ci-secret-token'); print('Keyring OK:', keyring.get_password('video_vault','ci_user'))" """,  # noqa: E501
+            "run": 'poetry run pip install keyrings.alt && poetry run python -c "import keyring; from keyrings.alt.file import PlaintextKeyring; keyring.set_keyring(PlaintextKeyring());"',  # noqa: E501
         }
 
     @classmethod

{winipedia_utils-0.4.56 → winipedia_utils-0.5.18}/winipedia_utils/git/github/workflows/health_check.py

@@ -6,6 +6,7 @@ This workflow is used to run tests on pull requests.
 from typing import Any
 
 from winipedia_utils.git.github.workflows.base.base import Workflow
+from winipedia_utils.projects.poetry.config import PyprojectConfigFile
 
 
 class HealthCheckWorkflow(Workflow):
@@ -39,20 +40,41 @@ class HealthCheckWorkflow(Workflow):
     @classmethod
     def get_jobs(cls) -> dict[str, Any]:
         """Get the workflow jobs."""
+        matrix_job_name = f"{cls.get_filename()}_matrix"
         return {
             **cls.get_standard_job(
+                name=matrix_job_name,
+                runs_on="${{ matrix.os }}",
+                strategy={
+                    "matrix": {
+                        "os": ["ubuntu-latest", "windows-latest", "macos-latest"],
+                        "python-version": [
+                            str(v)
+                            for v in PyprojectConfigFile.get_supported_python_versions()
+                        ],
+                    },
+                    "fail-fast": True,
+                },
                 steps=[
                     *(
                         cls.get_poetry_setup_steps(
                             install_dependencies=True,
-                            token=True,
+                            repo_token=True,
                             with_keyring=True,
+                            strategy_matrix=True,
                         )
                     ),
                     cls.get_protect_repository_step(),
                     cls.get_pre_commit_step(),
-                    cls.get_commit_step(),
-                    cls.get_extract_version_step(),
+                ],
+            ),
+            **cls.get_standard_job(
+                needs=[matrix_job_name],
+                steps=[
+                    {
+                        "name": "Aggregate Matrix Results",
+                        "run": "echo 'Aggregating matrix results into one job.'",
+                    }
                 ],
             ),
         }

{winipedia_utils-0.4.56 → winipedia_utils-0.5.18}/winipedia_utils/git/github/workflows/release.py

@@ -40,6 +40,12 @@ 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 = HealthCheckWorkflow.get_jobs()
+        release_job = cls.get_standard_job(
+            needs=[HealthCheckWorkflow.get_filename()],
+            steps=[
+                *cls.get_release_steps(),
+            ],
+        )
+        jobs.update(release_job)
+        return jobs

{winipedia_utils-0.4.56 → winipedia_utils-0.5.18}/winipedia_utils/git/pre_commit/config.py

@@ -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-0.4.56 → winipedia_utils-0.5.18}/winipedia_utils/git/pre_commit/hooks.py

@@ -7,15 +7,13 @@ 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]:
+def patch_version() -> list[str]:
     """Patch the version in pyproject.toml.
 
     This function returns the input for subprocess.run() to patch the version
@@ -24,7 +22,7 @@ def patch_version() -> list[str | Path]:
     return [POETRY_ARG, "version", "patch"]
 
 
-def add_version_patch_to_git() -> list[str | Path]:
+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
@@ -33,7 +31,7 @@ def add_version_patch_to_git() -> list[str | Path]:
     return ["git", "add", "pyproject.toml"]
 
 
-def update_package_manager() -> list[str | Path]:
+def update_package_manager() -> list[str]:
     """Update the package manager.
 
     This function returns the input for subprocess.run() to update the package
@@ -42,7 +40,7 @@ def update_package_manager() -> list[str | Path]:
     return [POETRY_ARG, "self", "update"]
 
 
-def install_dependencies_with_dev() -> list[str | Path]:
+def install_dependencies_with_dev() -> list[str]:
     """Install all dependencies.
 
     This function returns the input for subprocess.run() to install all dependencies.
@@ -50,7 +48,7 @@ def install_dependencies_with_dev() -> list[str | Path]:
     return [POETRY_ARG, "install", "--with", "dev"]
 
 
-def update_dependencies_with_dev() -> list[str | Path]:
+def update_dependencies_with_dev() -> list[str]:
     """Update all dependencies.
 
     This function returns the input for subprocess.run() to update all dependencies.
@@ -58,7 +56,7 @@ def update_dependencies_with_dev() -> list[str | Path]:
     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
@@ -67,7 +65,7 @@ def add_updates_to_git() -> list[str | Path]:
     return ["git", "add", "pyproject.toml"]
 
 
-def lock_dependencies() -> list[str | Path]:
+def lock_dependencies() -> list[str]:
     """Lock the dependencies.
 
     This function returns the input for subprocess.run() to lock the dependencies.
@@ -75,7 +73,7 @@ def lock_dependencies() -> list[str | Path]:
     return [POETRY_ARG, "lock"]
 
 
-def add_lock_file_to_git() -> list[str | Path]:
+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
@@ -84,7 +82,7 @@ def add_lock_file_to_git() -> list[str | Path]:
     return ["git", "add", "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 +91,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 +100,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 +112,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 +120,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 +128,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 +137,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-0.4.56 → winipedia_utils-0.5.18}/winipedia_utils/git/pre_commit/run_hooks.py

@@ -28,10 +28,22 @@ 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}"
+            status_str += f"""
+---------------------------------------------------------------------------------------------
+Stdout:
+
+{result.stdout}
+
+---------------------------------------------------------------------------------------------
+Stderr:
+
+{result.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__)
@@ -39,7 +51,7 @@ def run_hooks() -> None:
             "Hook %s -%s> %s",
             hook_func.__name__,
             "-" * num_dashes,
-            passed_str,
+            status_str,
         )
 
     if exit_code != 0:

{winipedia_utils-0.4.56 → winipedia_utils-0.5.18}/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-0.4.56 → winipedia_utils-0.5.18}/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-0.5.18/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-0.4.56 → winipedia_utils-0.5.18}/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.