winipedia-utils 0.2.63__py3-none-any.whl → 0.3.9__py3-none-any.whl

winipedia_utils/git/workflows/publish.py

@@ -6,74 +6,51 @@ This workflow is used to publish the package to PyPI with poetry.
 from pathlib import Path
 from typing import Any
 
-import yaml
+from winipedia_utils.git.workflows.base.base import Workflow
+from winipedia_utils.git.workflows.release import ReleaseWorkflow
 
-from winipedia_utils.git.workflows.base.base import _get_poetry_setup_steps
-from winipedia_utils.git.workflows.release import WORKFLOW_NAME
 
-PUBLISH_WORKFLOW_PATH = Path(".github/workflows/publish.yaml")
+class PublishWorkflow(Workflow):
+    """Publish workflow."""
 
+    PATH = Path(".github/workflows/publish.yaml")
 
-def load_publish_workflow() -> dict[str, Any]:
-    """Load the publish workflow."""
-    path = PUBLISH_WORKFLOW_PATH
-    if not path.exists():
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.touch()
-    return yaml.safe_load(path.read_text()) or {}
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
 
-
-def dump_publish_workflow(config: dict[str, Any]) -> None:
-    """Dump the publish workflow."""
-    path = PUBLISH_WORKFLOW_PATH
-    with path.open("w") as f:
-        yaml.safe_dump(config, f, sort_keys=False)
-
-
-def _get_publish_config() -> dict[str, Any]:
-    """Dict that represents the publish workflow yaml."""
-    return {
-        "name": "Publish to PyPI",
-        "on": {
+    def get_workflow_triggers(self) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        return {
             "workflow_run": {
-                "workflows": [WORKFLOW_NAME],
+                "workflows": [ReleaseWorkflow.get_workflow_name()],
                 "types": ["completed"],
             },
-        },
-        "jobs": {
+        }
+
+    def get_permissions(self) -> dict[str, Any]:
+        """Get the workflow permissions."""
+        return {
+            "contents": "read",
+        }
+
+    def get_jobs(self) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        return {
             "publish": {
                 "runs-on": "ubuntu-latest",
                 "if": "${{ github.event.workflow_run.conclusion == 'success' }}",
                 "steps": [
                     *(
-                        _get_poetry_setup_steps(
+                        self.get_poetry_setup_steps(
                             configure_pipy_token=True,
                         )
                     ),
                     {
-                        "name": "Build and publish to PyPI",
+                        "name": "Build and publish to PyPI"
+                        + self.get_repo_and_ref_name_formatted(),
                         "run": "poetry publish --build",
                     },
                 ],
             }
-        },
-    }
-
-
-def _publish_config_is_correct() -> bool:
-    """Check if the publish workflow is correct."""
-    config = load_publish_workflow()
-    return bool(config == _get_publish_config())
-
-
-def _add_publish_workflow() -> None:
-    """Add the publish workflow.
-
-    If you delete the .github/workflows/publish.yaml file, then the tests will not fail.
-    Not all projects need publishing to pypi. It is added on setup, but if you remove
-    the file, then the tests will not fail and the tests will assume you don't want it.
-    """
-    if _publish_config_is_correct():
-        return
-    config = _get_publish_config()
-    dump_publish_workflow(config)
+        }

winipedia_utils/git/workflows/release.py

@@ -6,47 +6,36 @@ This workflow is used to create a release on GitHub.
 from pathlib import Path
 from typing import Any
 
-import yaml
+from winipedia_utils.git.workflows.base.base import Workflow
 
-from winipedia_utils.git.workflows.base.base import _get_poetry_setup_steps
 
-RELEASE_WORKFLOW_PATH = Path(".github/workflows/release.yaml")
+class ReleaseWorkflow(Workflow):
+    """Release workflow."""
 
-WORKFLOW_NAME = "Create Release"
+    PATH = Path(".github/workflows/release.yaml")
 
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
 
-def load_release_workflow() -> dict[str, Any]:
-    """Load the release workflow."""
-    path = RELEASE_WORKFLOW_PATH
-    if not path.exists():
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.touch()
-    return yaml.safe_load(path.read_text()) or {}
+    def get_workflow_triggers(self) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        return {"push": {"tags": ["v*"]}}
 
-
-def dump_release_workflow(config: dict[str, Any]) -> None:
-    """Dump the release workflow."""
-    path = RELEASE_WORKFLOW_PATH
-    with path.open("w") as f:
-        yaml.safe_dump(config, f, sort_keys=False)
-
-
-def _get_release_config() -> dict[str, Any]:
-    """Dict that represents the release workflow yaml."""
-    repo_plus_ref = "${{ github.event.repository.name }}-${{ github.ref_name }}"
-    return {
-        "name": WORKFLOW_NAME,
-        "on": {"push": {"tags": ["v*"]}},
-        "permissions": {
+    def get_permissions(self) -> dict[str, Any]:
+        """Get the workflow permissions."""
+        return {
             "contents": "write",
-        },
-        "run-name": WORKFLOW_NAME + ": " + repo_plus_ref,
-        "jobs": {
+        }
+
+    def get_jobs(self) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        return {
             "release": {
                 "runs-on": "ubuntu-latest",
                 "steps": [
                     *(
-                        _get_poetry_setup_steps(
+                        self.get_poetry_setup_steps(
                             install_dependencies=True,
                             fetch_depth=0,
                             force_main_head=True,
@@ -54,7 +43,7 @@ def _get_release_config() -> dict[str, Any]:
                     ),
                     {
                         "name": "Run Pre-commit Hooks",
-                        "run": "poetry run pre-commit run --all-files",
+                        "run": "poetry run pre-commit run",
                     },
                     {
                         "name": "Build Changelog",
@@ -67,25 +56,10 @@ def _get_release_config() -> dict[str, Any]:
                         "uses": "ncipollo/release-action@v1",
                         "with": {
                             "tag": "${{ github.ref_name }}",
-                            "name": repo_plus_ref,
+                            "name": self.get_repo_and_ref_name(),
                             "body": "${{ steps.build_changelog.outputs.changelog }}",
                         },
                     },
                 ],
             }
-        },
-    }
-
-
-def _release_config_is_correct() -> bool:
-    """Check if the release workflow is correct."""
-    config = load_release_workflow()
-    return bool(config == _get_release_config())
-
-
-def _add_release_workflow() -> None:
-    """Add the release workflow."""
-    if _release_config_is_correct():
-        return
-    config = _get_release_config()
-    dump_release_workflow(config)
+        }

winipedia_utils/iterating/iterate.py

@@ -5,7 +5,7 @@ including getting the length of an iterable with a default value.
 These utilities help with iterable operations and manipulations.
 """
 
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from typing import Any
 
 
@@ -27,3 +27,61 @@ def get_len_with_default(iterable: Iterable[Any], default: int | None = None) ->
             msg = "Can't get length of iterable and no default value provided"
             raise TypeError(msg) from e
         return default
+
+
+def nested_structure_is_subset(
+    subset: dict[Any, Any] | list[Any] | Any,
+    superset: dict[Any, Any] | list[Any] | Any,
+    on_false_dict_action: Callable[[dict[Any, Any], dict[Any, Any], Any], Any]
+    | None = None,
+    on_false_list_action: Callable[[list[Any], list[Any], int], Any] | None = None,
+) -> bool:
+    """Check if a dictionary is a nested subset of another dictionary.
+
+    Args:
+        subset: Dictionary to check
+        superset: Dictionary to check against
+        on_false_dict_action: Action to take on each false dict comparison
+            must return a bool to indicate if after action is still false
+        on_false_list_action: Action to take on each false list comparison
+            must return a bool to indicate if after action is still false
+
+    Each value of a key must be equal to the value of the same key in the superset.
+    If the value is dictionary, the function is called recursively.
+    If the value is list, each item must be in the list of the same key in the superset.
+    The order in lists matters.
+
+    Returns:
+        True if subset is a nested subset of superset, False otherwise
+    """
+    if isinstance(subset, dict) and isinstance(superset, dict):
+        iterable: Iterable[tuple[Any, Any]] = subset.items()
+        on_false_action: Callable[[Any, Any, Any], Any] | None = on_false_dict_action
+
+        def get_actual(key_or_index: Any) -> Any:
+            """Get actual value from superset."""
+            return superset.get(key_or_index)
+
+    elif isinstance(subset, list) and isinstance(superset, list):
+        iterable = enumerate(subset)
+        on_false_action = on_false_list_action
+
+        def get_actual(key_or_index: Any) -> Any:
+            """Get actual value from superset."""
+            return superset[key_or_index] if key_or_index < len(superset) else None
+    else:
+        return (subset == superset) or (subset is Any)
+
+    all_good = True
+    for key_or_index, value in iterable:
+        actual_value = get_actual(key_or_index)
+        if not nested_structure_is_subset(
+            value, actual_value, on_false_dict_action, on_false_list_action
+        ):
+            fixed = False
+            if on_false_action is not None:
+                on_false_action(subset, superset, key_or_index)
+                fixed = nested_structure_is_subset(subset, superset)
+            if not fixed:
+                all_good = False
+    return all_good

winipedia_utils/modules/class_.py

@@ -31,7 +31,10 @@ def get_all_methods_from_cls(
         A list of callable methods from the class
 
     """
-    from winipedia_utils.modules.module import get_def_line, get_module_of_obj
+    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)
@@ -63,7 +66,10 @@ def get_all_cls_from_module(module: ModuleType | str) -> list[type]:
         A list of class types defined in the module
 
     """
-    from winipedia_utils.modules.module import get_def_line, get_module_of_obj
+    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+        get_def_line,
+        get_module_of_obj,
+    )
 
     if isinstance(module, str):
         module = import_module(module)
@@ -79,7 +85,9 @@ def get_all_cls_from_module(module: ModuleType | str) -> list[type]:
     return sorted(classes, key=get_def_line)
 
 
-def get_all_subclasses(cls: type) -> list[type]:
+def get_all_subclasses(
+    cls: type, load_package_before: ModuleType | None = None
+) -> set[type]:
     """Get all subclasses of a class.
 
     Retrieves all classes that are subclasses of the specified class.
@@ -87,18 +95,37 @@ def get_all_subclasses(cls: type) -> list[type]:
 
     Args:
         cls: The class to find subclasses of
+        load_package_before: If provided,
+        walks the package before loading the subclasses
+        This is useful when the subclasses are defined in other modules that need
+        to be imported before they can be found by __subclasses__
 
     Returns:
         A list of subclasses of the given class
 
     """
+    from winipedia_utils.modules.package import (  # noqa: PLC0415  # avoid circular import
+        walk_package,
+    )
+
+    if load_package_before:
+        _ = list(walk_package(load_package_before))
     subclasses_set = set(cls.__subclasses__())
     for subclass in cls.__subclasses__():
         subclasses_set.update(get_all_subclasses(subclass))
-    return list(subclasses_set)
-
-
-def get_all_nonabstract_subclasses(cls: type) -> list[type]:
+    if load_package_before is not None:
+        # remove all not in the package
+        subclasses_set = {
+            subclass
+            for subclass in subclasses_set
+            if subclass.__module__.startswith(load_package_before.__name__)
+        }
+    return subclasses_set
+
+
+def get_all_nonabstract_subclasses(
+    cls: type, load_package_before: ModuleType | None = None
+) -> set[type]:
     """Get all non-abstract subclasses of a class.
 
     Retrieves all classes that are subclasses of the specified class,
@@ -107,13 +134,36 @@ def get_all_nonabstract_subclasses(cls: type) -> list[type]:
 
     Args:
         cls: The class to find subclasses of
+        load_package_before: If provided,
+        walks the package before loading the subclasses
+        This is useful when the subclasses are defined in other modules that need
+        to be imported before they can be found by __subclasses__
 
     Returns:
         A list of non-abstract subclasses of the given class
 
     """
-    return [
+    return {
         subclass
-        for subclass in get_all_subclasses(cls)
+        for subclass in get_all_subclasses(cls, load_package_before=load_package_before)
         if not inspect.isabstract(subclass)
-    ]
+    }
+
+
+def init_all_nonabstract_subclasses(
+    cls: type, load_package_before: ModuleType | None = None
+) -> None:
+    """Initialize all non-abstract subclasses of a class.
+
+    Args:
+        cls: The class to find subclasses of
+        load_package_before: If provided,
+        walks the package before loading the subclasses
+        This is useful when the subclasses are defined in other modules that need
+        to be imported before they can be found by __subclasses__
+
+    """
+    for subclass in get_all_nonabstract_subclasses(
+        cls, load_package_before=load_package_before
+    ):
+        subclass()

winipedia_utils/modules/function.py

@@ -71,7 +71,10 @@ def get_all_functions_from_module(module: ModuleType | str) -> list[Callable[...
         A list of callable functions defined in the module
 
     """
-    from winipedia_utils.modules.module import get_def_line, get_module_of_obj
+    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+        get_def_line,
+        get_module_of_obj,
+    )
 
     if isinstance(module, str):
         module = import_module(module)
@@ -99,3 +102,17 @@ def unwrap_method(method: Any) -> Callable[..., Any] | Any:
     if isinstance(method, property):
         method = method.fget
     return inspect.unwrap(method)
+
+
+def is_abstractmethod(method: Any) -> bool:
+    """Check if a method is an abstract method.
+
+    Args:
+        method: The method to check
+
+    Returns:
+        True if the method is an abstract method, False otherwise
+
+    """
+    method = unwrap_method(method)
+    return getattr(method, "__isabstractmethod__", False)

winipedia_utils/modules/package.py

@@ -20,8 +20,8 @@ from types import ModuleType
 from setuptools import find_namespace_packages as _find_namespace_packages
 from setuptools import find_packages as _find_packages
 
+from winipedia_utils.git.gitignore.config import GitIgnoreConfigFile
 from winipedia_utils.git.gitignore.gitignore import (
-    load_gitignore,
     walk_os_skipping_gitignore_patterns,
 )
 from winipedia_utils.logging.logger import get_logger
@@ -44,7 +44,9 @@ def get_src_package() -> ModuleType:
                        if only the test package exists
 
     """
-    from winipedia_utils.testing.convention import TESTS_PACKAGE_NAME
+    from winipedia_utils.testing.convention import (  # noqa: PLC0415  # avoid circular import
+        TESTS_PACKAGE_NAME,
+    )
 
     packages = find_packages_as_modules(depth=0)
     return next(p for p in packages if p.__name__ != TESTS_PACKAGE_NAME)
@@ -181,7 +183,7 @@ def find_packages(
 
     """
     if exclude is None:
-        exclude = load_gitignore()
+        exclude = GitIgnoreConfigFile.load_static()[GitIgnoreConfigFile.IGNORE_KEY]
         exclude = [
             p.replace("/", ".").removesuffix(".") for p in exclude if p.endswith("/")
         ]
@@ -280,7 +282,9 @@ def make_init_modules_for_package(path: str | Path | ModuleType) -> None:
         from get_default_init_module_content.
 
     """
-    from winipedia_utils.modules.module import to_path
+    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+        to_path,
+    )
 
     path = to_path(path, is_package=True)
 
@@ -305,7 +309,10 @@ def make_init_module(path: str | Path) -> None:
         Creates parent directories if they don't exist.
 
     """
-    from winipedia_utils.modules.module import get_default_init_module_content, to_path
+    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+        get_default_init_module_content,
+        to_path,
+    )
 
     path = to_path(path, is_package=True)
 
@@ -338,7 +345,7 @@ def copy_package(
         with_file_content (bool, optional): copies the content of the files.
 
     """
-    from winipedia_utils.modules.module import (
+    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
         create_module,
         get_isolated_obj_name,
         get_module_content_as_str,
@@ -368,7 +375,9 @@ def get_main_package() -> ModuleType:
 
     Even when this package is installed as a module.
     """
-    from winipedia_utils.modules.module import to_module_name
+    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+        to_module_name,
+    )
 
     main = sys.modules.get("__main__")
     if main is None: