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

winipedia_utils/concurrent/concurrent.py

@@ -20,8 +20,6 @@ from typing import TYPE_CHECKING, Any, cast
 
 from tqdm import tqdm
 
-from winipedia_utils.concurrent.multiprocessing import get_spwan_pool
-from winipedia_utils.concurrent.multithreading import imap_unordered
 from winipedia_utils.iterating.iterate import get_len_with_default
 from winipedia_utils.logging.logger import get_logger
 
@@ -210,6 +208,13 @@ def concurrent_loop(  # noqa: PLR0913
     Returns:
         list[Any]: Results from the process_function executions
     """
+    from winipedia_utils.concurrent.multiprocessing import (  # noqa: PLC0415  # avoid circular import
+        get_spwan_pool,
+    )
+    from winipedia_utils.concurrent.multithreading import (  # noqa: PLC0415  # avoid circular import
+        imap_unordered,
+    )
+
     process_args_len = get_len_with_default(process_args, process_args_len)
     process_args = generate_process_args(
         process_function=process_function,

winipedia_utils/concurrent/multiprocessing.py

@@ -15,6 +15,7 @@ from functools import wraps
 from multiprocessing.pool import Pool
 from typing import Any
 
+from winipedia_utils.concurrent.concurrent import concurrent_loop
 from winipedia_utils.logging.logger import get_logger
 
 logger = get_logger(__name__)
@@ -118,8 +119,6 @@ def multiprocess_loop(
         Also given functions must be pickle-able.
 
     """
-    from winipedia_utils.concurrent.concurrent import concurrent_loop
-
     return concurrent_loop(
         threading=False,
         process_function=process_function,

winipedia_utils/concurrent/multithreading.py

@@ -15,6 +15,8 @@ from collections.abc import Callable, Generator, Iterable
 from concurrent.futures import Future, ThreadPoolExecutor, as_completed
 from typing import Any
 
+from winipedia_utils.concurrent.concurrent import concurrent_loop
+
 
 def get_future_results_as_completed(
     futures: Iterable[Future[Any]],
@@ -62,8 +64,6 @@ def multithread_loop(
         ThreadPoolExecutor is used for I/O-bound tasks, not for CPU-bound tasks.
 
     """
-    from winipedia_utils.concurrent.concurrent import concurrent_loop
-
     return concurrent_loop(
         threading=True,
         process_function=process_function,

winipedia_utils/git/gitignore/config.py

@@ -0,0 +1,54 @@
+"""Config utilities for .gitignore."""
+
+from pathlib import Path
+from typing import Any
+
+from winipedia_utils.text.config import ConfigFile
+
+
+class GitIgnoreConfigFile(ConfigFile):
+    """Config file for .gitignore."""
+
+    PATH = Path(".gitignore")
+
+    IGNORE_KEY = "ignore"
+
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
+
+    def load(self) -> dict[str, Any]:
+        """Load the config file."""
+        return self.load_static()
+
+    @classmethod
+    def load_static(cls) -> dict[str, Any]:
+        """Load the config file."""
+        paths = cls.PATH.read_text().splitlines()
+        return {cls.IGNORE_KEY: paths}
+
+    def dump(self, config: dict[str, Any]) -> None:
+        """Dump the config file."""
+        patterns = config.get(self.IGNORE_KEY, [])
+        self.path.write_text("\n".join(patterns))
+
+    def get_configs(self) -> dict[str, Any]:
+        """Get the config."""
+        from winipedia_utils.testing.config import (  # noqa: PLC0415  # avoid circular import
+            ExperimentConfigFile,
+        )
+
+        needed = [
+            "__pycache__/",
+            ".idea/",
+            ".mypy_cache/",
+            ".pytest_cache/",
+            ".ruff_cache/",
+            ".vscode/",
+            "dist/",
+            ".git/",  # for walk_os_skipping_gitignore_patterns func
+            ExperimentConfigFile.PATH.name,  # for executing experimental code
+        ]
+        existing = self.load()[self.IGNORE_KEY]
+        needed = [p for p in needed if p not in set(existing)]
+        return {self.IGNORE_KEY: existing + needed}

winipedia_utils/git/gitignore/gitignore.py

@@ -12,6 +12,7 @@ from pathlib import Path
 
 import pathspec
 
+from winipedia_utils.git.gitignore.config import GitIgnoreConfigFile
 from winipedia_utils.logging.logger import get_logger
 
 logger = get_logger(__name__)
@@ -37,7 +38,10 @@ def path_is_in_gitignore(relative_path: str | Path) -> bool:
     if is_dir and not as_posix.endswith("/"):
         as_posix += "/"
 
-    spec = pathspec.PathSpec.from_lines("gitwildmatch", load_gitignore())
+    spec = pathspec.PathSpec.from_lines(
+        "gitwildmatch",
+        GitIgnoreConfigFile.load_static()[GitIgnoreConfigFile.IGNORE_KEY],
+    )
 
     return spec.match_file(as_posix)
 
@@ -72,65 +76,3 @@ def walk_os_skipping_gitignore_patterns(
         valid_dirs = [d for d in dirs if not path_is_in_gitignore(rel_root / d)]
 
         yield rel_root, valid_dirs, valid_files
-
-
-def load_gitignore() -> list[str]:
-    """Load the .gitignore file."""
-    gitignore_path = Path(".gitignore")
-    if not gitignore_path.exists():
-        gitignore_path.touch()
-    return gitignore_path.read_text().splitlines()
-
-
-def dump_gitignore(patterns: list[str]) -> None:
-    """Dump the given patterns to a .gitignore file (overwrites it)."""
-    gitignore_path = Path(".gitignore")
-    gitignore_path.write_text("\n".join(patterns))
-
-
-def add_patterns_to_gitignore(patterns: list[str]) -> None:
-    """Add the given patterns to the .gitignore file."""
-    existing_patterns = load_gitignore()
-    new_patterns = [p for p in patterns if p not in existing_patterns]
-    if new_patterns:
-        logger.info("Adding patterns to .gitignore: %s", new_patterns)
-        dump_gitignore(existing_patterns + new_patterns)
-
-
-def _get_gitignore_patterns() -> list[str]:
-    """Get the patterns that should be in the .gitignore file.
-
-    Those are the patterns that should be in there when using winipedia_utils.
-    """
-    return [
-        "__pycache__/",
-        ".idea/",
-        ".mypy_cache/",
-        ".pytest_cache/",
-        ".ruff_cache/",
-        ".vscode/",
-        "dist/",
-        "test.py",  # I use this for testing code
-        ".git/",  # ignore the .git folder for walk_os_skipping_gitignore_patterns func
-    ]
-
-
-def _get_missing_patterns() -> list[str]:
-    """Get the patterns that are in the .gitignore file but shouldn't be."""
-    needed_patterns = _get_gitignore_patterns()
-    existing_patterns = load_gitignore()
-    return [p for p in needed_patterns if p not in existing_patterns]
-
-
-def _gitignore_is_correct() -> bool:
-    """Check if the .gitignore file contains all the patterns it should."""
-    missing_patterns = _get_missing_patterns()
-    return not missing_patterns
-
-
-def _add_package_patterns_to_gitignore() -> None:
-    """Add any missing patterns to the .gitignore file."""
-    if _gitignore_is_correct():
-        return
-    missing_patterns = _get_missing_patterns()
-    add_patterns_to_gitignore(missing_patterns)

winipedia_utils/git/pre_commit/config.py

@@ -3,68 +3,55 @@
 from pathlib import Path
 from typing import Any
 
-import yaml
-
+import winipedia_utils
+from winipedia_utils.git.pre_commit import run_hooks
 from winipedia_utils.logging.logger import get_logger
+from winipedia_utils.modules.module import make_obj_importpath
 from winipedia_utils.os.os import run_subprocess
 from winipedia_utils.projects.poetry.poetry import POETRY_RUN_ARGS
+from winipedia_utils.projects.project import make_name_from_package
+from winipedia_utils.text.config import YamlConfigFile
 
 logger = get_logger(__name__)
 
 
-def load_pre_commit_config() -> dict[str, Any]:
-    """Load the pre-commit config."""
-    path = Path(".pre-commit-config.yaml")
-    if not path.exists():
-        path.touch()
-    return yaml.safe_load(path.read_text()) or {}
-
-
-def dump_pre_commit_config(config: dict[str, Any]) -> None:
-    """Dump the pre-commit config."""
-    path = Path(".pre-commit-config.yaml")
-    with path.open("w") as f:
-        yaml.safe_dump(config, f, sort_keys=False)
-
-
-def _get_pre_commit_config_dict() -> dict[str, Any]:
-    """Get the content for a pre-commit config file as a dictionary."""
-    return {
-        "repo": "local",
-        "hooks": [
-            {
-                "id": "winipedia-utils",
-                "name": "winipedia-utils",
-                "entry": "python -m winipedia_utils.git.pre_commit.run_hooks",
-                "language": "system",
-                "always_run": True,
-                "pass_filenames": False,
-            }
-        ],
-    }
-
-
-def _pre_commit_config_is_correct() -> bool:
-    """Check if the pre-commit config is correct."""
-    config = load_pre_commit_config()
-    package_hook_config = _get_pre_commit_config_dict().get("hooks", [{}])[0]
-    return bool(
-        config.get("repos", [{}])[0].get("hooks", [{}])[0] == package_hook_config
-    )
-
-
-def _add_package_hook_to_pre_commit_config() -> None:
-    """Add the winipedia-utils hook to the pre-commit config."""
-    config = load_pre_commit_config()
-    package_hook_config = _get_pre_commit_config_dict()
-    # insert at the beginning of the list
-    if not _pre_commit_config_is_correct():
-        logger.info("Adding winipedia-utils hook to pre-commit config")
-        config["repos"] = [package_hook_config, *config.get("repos", [])]
-        dump_pre_commit_config(config)
-
-
-def _pre_commit_install() -> None:
-    """Install pre-commit."""
-    logger.info("Running pre-commit install")
-    run_subprocess([*POETRY_RUN_ARGS, "pre-commit", "install"], check=True)
+class PreCommitConfigFile(YamlConfigFile):
+    """Config file for pre-commit."""
+
+    PATH = Path(".pre-commit-config.yaml")
+
+    def __init__(self) -> None:
+        """Init the file."""
+        super().__init__()
+        self.install()
+
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
+
+    def get_configs(self) -> dict[str, Any]:
+        """Get the config."""
+        hook_name = make_name_from_package(winipedia_utils, capitalize=False)
+        return {
+            "repos": [
+                {
+                    "repo": "local",
+                    "hooks": [
+                        {
+                            "id": hook_name,
+                            "name": hook_name,
+                            "entry": f"python -m {make_obj_importpath(run_hooks)}",
+                            "language": "system",
+                            "always_run": True,
+                            "pass_filenames": False,
+                        }
+                    ],
+                },
+            ]
+        }
+
+    @classmethod
+    def install(cls) -> None:
+        """Installs the pre commits in the config."""
+        logger.info("Running pre-commit install")
+        run_subprocess([*POETRY_RUN_ARGS, "pre-commit", "install"], check=True)

winipedia_utils/git/pre_commit/hooks.py

@@ -17,7 +17,7 @@ from winipedia_utils.projects.poetry.poetry import (
 )
 
 
-def _version_patch() -> list[str | Path]:
+def patch_version() -> list[str | Path]:
     """Patch the version in pyproject.toml.
 
     This function returns the input for subprocess.run() to patch the version
@@ -26,7 +26,7 @@ def _version_patch() -> list[str | Path]:
     return [POETRY_PATH, "version", "patch"]
 
 
-def _add_version_patch_to_git() -> list[str | Path]:
+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
@@ -35,7 +35,7 @@ def _add_version_patch_to_git() -> list[str | Path]:
     return [*POETRY_RUN_ARGS, "git", "add", "pyproject.toml"]
 
 
-def _update_package_manager() -> list[str | Path]:
+def update_package_manager() -> list[str | Path]:
     """Update the package manager.
 
     This function returns the input for subprocess.run() to update the package
@@ -44,7 +44,7 @@ def _update_package_manager() -> list[str | Path]:
     return [POETRY_PATH, "self", "update"]
 
 
-def _install_packages() -> list[str | Path]:
+def install_packages() -> list[str | Path]:
     """Install all dependencies.
 
     This function returns the input for subprocess.run() to install all dependencies.
@@ -52,7 +52,7 @@ def _install_packages() -> list[str | Path]:
     return [POETRY_PATH, "install"]
 
 
-def _update_packages() -> list[str | Path]:
+def update_packages() -> list[str | Path]:
     """Update all dependencies.
 
     This function returns the input for subprocess.run() to update all dependencies.
@@ -60,7 +60,7 @@ def _update_packages() -> list[str | Path]:
     return [POETRY_PATH, "update"]
 
 
-def _lock_dependencies() -> list[str | Path]:
+def lock_dependencies() -> list[str | Path]:
     """Lock the dependencies.
 
     This function returns the input for subprocess.run() to lock the dependencies.
@@ -68,7 +68,7 @@ def _lock_dependencies() -> list[str | Path]:
     return [POETRY_PATH, "lock"]
 
 
-def _check_configurations() -> list[str | Path]:
+def check_package_manager_configs() -> list[str | Path]:
     """Check that poetry.lock and pyproject.toml is up to date.
 
     This function returns the input for subprocess.run() to check that poetry.lock
@@ -77,7 +77,7 @@ def _check_configurations() -> list[str | Path]:
     return [POETRY_PATH, "check", "--strict"]
 
 
-def _creating_tests() -> list[str | Path]:
+def create_tests() -> list[str | Path]:
     """Create all tests for the project.
 
     This function returns the input for subprocess.run() to create all tests.
@@ -85,7 +85,7 @@ def _creating_tests() -> list[str | Path]:
     return [*POETRY_RUN_PYTHON_ARGS, "-m", "winipedia_utils.testing.create_tests"]
 
 
-def _linting() -> list[str | Path]:
+def lint_code() -> list[str | Path]:
     """Check the code.
 
     This function returns the input for subprocess.run() to lint the code.
@@ -94,7 +94,7 @@ def _linting() -> list[str | Path]:
     return [*POETRY_RUN_RUFF_ARGS, "check", "--fix"]
 
 
-def _formating() -> list[str | Path]:
+def format_code() -> list[str | Path]:
     """Format the code.
 
     This function calls ruff format to format the code.
@@ -102,7 +102,7 @@ def _formating() -> list[str | Path]:
     return [*POETRY_RUN_RUFF_ARGS, "format"]
 
 
-def _type_checking() -> list[str | Path]:
+def check_static_types() -> list[str | Path]:
     """Check the types.
 
     This function returns the input for subprocess.run() to check the static types.
@@ -110,7 +110,7 @@ def _type_checking() -> list[str | Path]:
     return [*POETRY_RUN_ARGS, "mypy"]
 
 
-def _security_checking() -> list[str | Path]:
+def check_security() -> list[str | Path]:
     """Check the security of the code.
 
     This function returns the input for subprocess.run() to check the security of
@@ -119,7 +119,7 @@ def _security_checking() -> list[str | Path]:
     return [*POETRY_RUN_ARGS, "bandit", "-c", "pyproject.toml", "-r", "."]
 
 
-def _testing() -> list[str | Path]:
+def run_tests() -> list[str | Path]:
     """Run the tests.
 
     This function returns the input for subprocess.run() to run all tests.

winipedia_utils/git/pre_commit/run_hooks.py

@@ -15,7 +15,7 @@ from winipedia_utils.os.os import run_subprocess
 logger = get_logger(__name__)
 
 
-def _run_all_hooks() -> None:
+def run_all() -> None:
     """Import all funcs defined in hooks.py and runs them."""
     hook_funcs = get_all_functions_from_module(hooks)
 
@@ -46,4 +46,4 @@ def _run_all_hooks() -> None:
 
 
 if __name__ == "__main__":
-    _run_all_hooks()
+    run_all()

winipedia_utils/git/workflows/base/base.py

@@ -1,38 +1,76 @@
 """Contains base utilities for git workflows."""
 
+from abc import abstractmethod
 from typing import Any
 
+from winipedia_utils.text.config import YamlConfigFile
+from winipedia_utils.text.string import split_on_uppercase
 
-def _get_checkout_step(
-    fetch_depth: int | None = None,
-) -> dict[str, Any]:
-    """Get the checkout step.
 
-    Args:
+class Workflow(YamlConfigFile):
+    """Base class for workflows."""
+
+    @abstractmethod
+    def get_workflow_triggers(self) -> dict[str, Any]:
+        """Get the workflow triggers."""
+
+    @abstractmethod
+    def get_permissions(self) -> dict[str, Any]:
+        """Get the workflow permissions."""
+
+    @abstractmethod
+    def get_jobs(self) -> dict[str, Any]:
+        """Get the workflow jobs."""
+
+    @classmethod
+    def get_workflow_name(cls) -> str:
+        """Get the workflow name."""
+        return " ".join(split_on_uppercase(cls.__name__))
+
+    def get_run_name(self) -> str:
+        """Get the workflow run name."""
+        return self.get_workflow_name() + self.get_repo_and_ref_name_formatted()
+
+    def get_configs(self) -> dict[str, Any]:
+        """Get the workflow config."""
+        return {
+            "name": self.get_workflow_name(),
+            "on": self.get_workflow_triggers(),
+            "permissions": self.get_permissions(),
+            "run-name": self.get_run_name(),
+            "jobs": self.get_jobs(),
+        }
+
+    @classmethod
+    def get_checkout_step(cls, fetch_depth: int | None = None) -> dict[str, Any]:
+        """Get the checkout step.
+
+        Args:
         fetch_depth: The fetch depth to use. If None, no fetch depth is specified.
 
-    Returns:
+        Returns:
         The checkout step.
-    """
-    step: dict[str, Any] = {
-        "name": "Checkout repository",
-        "uses": "actions/checkout@v5",
-    }
-    if fetch_depth is not None:
-        step["with"] = {"fetch-depth": fetch_depth}
-    return step
-
-
-def _get_poetry_setup_steps(
-    *,
-    install_dependencies: bool = False,
-    fetch_depth: int | None = None,
-    configure_pipy_token: bool = False,
-    force_main_head: bool = False,
-) -> list[dict[str, Any]]:
-    """Get the poetry steps.
-
-    Args:
+        """
+        step: dict[str, Any] = {
+            "name": "Checkout repository",
+            "uses": "actions/checkout@v5",
+        }
+        if fetch_depth is not None:
+            step["with"] = {"fetch-depth": fetch_depth}
+        return step
+
+    @classmethod
+    def get_poetry_setup_steps(
+        cls,
+        *,
+        install_dependencies: bool = False,
+        fetch_depth: int | None = None,
+        configure_pipy_token: bool = False,
+        force_main_head: bool = False,
+    ) -> list[dict[str, Any]]:
+        """Get the poetry steps.
+
+        Args:
         install_dependencies: Whether to install dependencies.
         fetch_depth: The fetch depth to use. If None, no fetch depth is specified.
         configure_pipy_token: Whether to configure the pipy token.
@@ -40,38 +78,57 @@ def _get_poetry_setup_steps(
             equal to the most recent commit on main. This is useful for workflows that
             should only run on main.
 
-    Returns:
+        Returns:
         The poetry steps.
-    """
-    steps = [_get_checkout_step(fetch_depth)]
-    if force_main_head:
-        # exit with code 1 if the running branch is not main
+        """
+        steps = [cls.get_checkout_step(fetch_depth)]
+        if force_main_head:
+            # exit with code 1 if the running branch is not main
+            steps.append(
+                {
+                    "name": "Assert running on head of main",
+                    "run": 'git fetch origin main --depth=1; main_sha=$(git rev-parse origin/main); if [ "$GITHUB_SHA" != "$main_sha" ]; then echo "Tag commit is not the latest commit on main."; exit 1; fi',  # noqa: E501
+                }
+            )
         steps.append(
             {
-                "name": "Assert running on head of main",
-                "run": 'git fetch origin main --depth=1; main_sha=$(git rev-parse origin/main); if [ "$GITHUB_SHA" != "$main_sha" ]; then echo "Tag commit is not the latest commit on main."; exit 1; fi',  # noqa: E501
+                "name": "Setup Python",
+                "uses": "actions/setup-python@v6",
+                "with": {"python-version": "3.x"},
             }
         )
-    steps.append(
-        {
-            "name": "Setup Python",
-            "uses": "actions/setup-python@v6",
-            "with": {"python-version": "3.x"},
-        }
-    )
-    steps.append(
-        {
-            "name": "Install Poetry",
-            "run": "curl -sSL https://install.python-poetry.org | python3 -",
-        }
-    )
-    if configure_pipy_token:
         steps.append(
             {
-                "name": "Configure Poetry",
-                "run": "poetry config pypi-token.pypi ${{ secrets.PYPI_TOKEN }}",
+                "name": "Install Poetry",
+                "run": "curl -sSL https://install.python-poetry.org | python3 -",
             }
         )
-    if install_dependencies:
-        steps.append({"name": "Install Dependencies", "run": "poetry install"})
-    return steps
+        if configure_pipy_token:
+            steps.append(
+                {
+                    "name": "Configure Poetry",
+                    "run": "poetry config pypi-token.pypi ${{ secrets.PYPI_TOKEN }}",
+                }
+            )
+        if install_dependencies:
+            steps.append({"name": "Install Dependencies", "run": "poetry install"})
+        return steps
+
+    @staticmethod
+    def get_repository_name() -> str:
+        """Get the repository name."""
+        return "${{ github.event.repository.name }}"
+
+    def get_ref_name(self) -> str:
+        """Get the ref name."""
+        return "${{ github.ref_name }}"
+
+    @staticmethod
+    def get_repo_and_ref_name() -> str:
+        """Get the repository name and ref name."""
+        return "${{ github.event.repository.name }}-${{ github.ref_name }}"
+
+    @classmethod
+    def get_repo_and_ref_name_formatted(cls) -> str:
+        """Get the repository name and ref name."""
+        return f": {cls.get_repo_and_ref_name()}"