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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winipedia-utils
-Version: 0.4.56
+Version: 0.5.19
 Summary: A package with many utility functions
 License-Expression: MIT
 License-File: LICENSE
@@ -105,7 +105,7 @@ The setup creates the following configuration files:
 - `.pre-commit-config.yaml` - Pre-commit hook configuration
 - `.gitignore` - Git ignore rules (assumes you added one on GitHub before.)
 - `pyproject.toml` - Project configuration with Poetry settings
-- `.github/workflows/health_check.yaml` - Health check workflow (Runs on every push and pull request, all workfows run on the latest possible python version in pyproject.toml)
+- `.github/workflows/health_check.yaml` - Health check workflow (Runs on every push and pull request using a matrix strategy to test across multiple operating systems and Python versions)
 - `.github/workflows/release.yaml` - Release workflow (Creates a release on GitHub when the same actions as in health check pass and commits are pushed to main)
 - `.github/workflows/publish.yaml` - Publishing workflow (Publishes to PyPI when a release is created by the release workflow, if you use this workflow, you need to add a PYPI_TOKEN (named PYPI_TOKEN) to your GitHub secrets that has write access to the package on PyPI.)
 - `py.typed` - PEP 561 marker for type hints
@@ -114,6 +114,38 @@ The setup creates the following configuration files:
 - `conftest.py` - Pytest configuration file
 - `.python-version` - Python version file for pyenv (if you use pyenv, puts in the lowest supported python version in pyproject.toml opposed to the latest possible python version in workflows)
 
+### GitHub Workflows and Matrix Strategy
+
+The project uses GitHub Actions workflows with a **matrix strategy** to ensure cross-platform compatibility:
+
+#### Matrix Configuration
+
+The health check and release workflows test your code across:
+- **Operating Systems**: Ubuntu (latest), Windows (latest), macOS (latest)
+- **Python Versions**: All versions specified in your `pyproject.toml` (e.g., 3.12, 3.13, 3.14)
+
+This matrix strategy ensures your code works reliably across different environments before merging or releasing.
+
+#### Workflow Structure
+
+The health check workflow consists of two jobs:
+
+1. **Matrix Job** (`health_check_matrix`) - Runs all checks in parallel across the matrix of OS and Python versions:
+   - Checkout repository
+   - Setup Git, Python, and Poetry
+   - Add Poetry to PATH (Windows-specific step)
+   - Install dependencies
+   - Setup CI keyring
+   - Protect repository (applies branch protection rules)
+   - Run pre-commit hooks (linting, formatting, type checking, security, tests)
+
+2. **Aggregation Job** (`health_check`) - Aggregates matrix results into a single status check:
+   - Required for branch protection compatibility
+   - Only runs after all matrix jobs complete successfully
+   - Provides a single status check that can be marked as required in branch protection rules
+
+The release workflow extends the health check workflow and adds a release job that runs after all health checks pass.
+
 ### Pre-commit Hook Workflow
 
 When you commit code using `git commit`, the following checks run automatically:
@@ -203,8 +235,8 @@ A ruleset named `main protection` is created for the `main` branch with the foll
   - Requires review thread resolution (all comments in reviews must be resolved before merge)
   - Allowed merge methods: `squash` and `rebase` (no merge commits, keeps history clean)
 - **Required Status Checks:**
-  - Strict mode enabled (all status checks must pass on the latest commit, not older ones (sets the health check as required status check))
-  - Health check workflow must pass (the CI/CD pipeline must complete successfully)
+  - Strict mode enabled (all status checks must pass on the latest commit, not older ones)
+  - Health check workflow must pass (the aggregated `health_check` job ensures all matrix combinations passed successfully)
 - **Bypass Actors** - Repository admins can bypass all rules (for emergency situations)
 
 ## Utilities

{winipedia_utils-0.4.56 → winipedia_utils-0.5.19}/README.md

@@ -78,7 +78,7 @@ The setup creates the following configuration files:
 - `.pre-commit-config.yaml` - Pre-commit hook configuration
 - `.gitignore` - Git ignore rules (assumes you added one on GitHub before.)
 - `pyproject.toml` - Project configuration with Poetry settings
-- `.github/workflows/health_check.yaml` - Health check workflow (Runs on every push and pull request, all workfows run on the latest possible python version in pyproject.toml)
+- `.github/workflows/health_check.yaml` - Health check workflow (Runs on every push and pull request using a matrix strategy to test across multiple operating systems and Python versions)
 - `.github/workflows/release.yaml` - Release workflow (Creates a release on GitHub when the same actions as in health check pass and commits are pushed to main)
 - `.github/workflows/publish.yaml` - Publishing workflow (Publishes to PyPI when a release is created by the release workflow, if you use this workflow, you need to add a PYPI_TOKEN (named PYPI_TOKEN) to your GitHub secrets that has write access to the package on PyPI.)
 - `py.typed` - PEP 561 marker for type hints
@@ -87,6 +87,38 @@ The setup creates the following configuration files:
 - `conftest.py` - Pytest configuration file
 - `.python-version` - Python version file for pyenv (if you use pyenv, puts in the lowest supported python version in pyproject.toml opposed to the latest possible python version in workflows)
 
+### GitHub Workflows and Matrix Strategy
+
+The project uses GitHub Actions workflows with a **matrix strategy** to ensure cross-platform compatibility:
+
+#### Matrix Configuration
+
+The health check and release workflows test your code across:
+- **Operating Systems**: Ubuntu (latest), Windows (latest), macOS (latest)
+- **Python Versions**: All versions specified in your `pyproject.toml` (e.g., 3.12, 3.13, 3.14)
+
+This matrix strategy ensures your code works reliably across different environments before merging or releasing.
+
+#### Workflow Structure
+
+The health check workflow consists of two jobs:
+
+1. **Matrix Job** (`health_check_matrix`) - Runs all checks in parallel across the matrix of OS and Python versions:
+   - Checkout repository
+   - Setup Git, Python, and Poetry
+   - Add Poetry to PATH (Windows-specific step)
+   - Install dependencies
+   - Setup CI keyring
+   - Protect repository (applies branch protection rules)
+   - Run pre-commit hooks (linting, formatting, type checking, security, tests)
+
+2. **Aggregation Job** (`health_check`) - Aggregates matrix results into a single status check:
+   - Required for branch protection compatibility
+   - Only runs after all matrix jobs complete successfully
+   - Provides a single status check that can be marked as required in branch protection rules
+
+The release workflow extends the health check workflow and adds a release job that runs after all health checks pass.
+
 ### Pre-commit Hook Workflow
 
 When you commit code using `git commit`, the following checks run automatically:
@@ -176,8 +208,8 @@ A ruleset named `main protection` is created for the `main` branch with the foll
   - Requires review thread resolution (all comments in reviews must be resolved before merge)
   - Allowed merge methods: `squash` and `rebase` (no merge commits, keeps history clean)
 - **Required Status Checks:**
-  - Strict mode enabled (all status checks must pass on the latest commit, not older ones (sets the health check as required status check))
-  - Health check workflow must pass (the CI/CD pipeline must complete successfully)
+  - Strict mode enabled (all status checks must pass on the latest commit, not older ones)
+  - Health check workflow must pass (the aggregated `health_check` job ensures all matrix combinations passed successfully)
 - **Bypass Actors** - Repository admins can bypass all rules (for emergency situations)
 
 ## Utilities

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

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

{winipedia_utils-0.4.56 → winipedia_utils-0.5.19}/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,14 @@ 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,
+                with_keyring=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 +293,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 +323,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.19}/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.19}/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.19}/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.19}/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.19}/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.19}/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.19}/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