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

winipedia_utils/git/github/workflows/health_check.py

@@ -0,0 +1,69 @@
+"""Contains the pull request workflow.
+
+This workflow is used to run tests on pull requests.
+"""
+
+from typing import Any
+
+from winipedia_utils.git.github.workflows.base.base import Workflow
+
+
+class HealthCheckWorkflow(Workflow):
+    """Pull request workflow.
+
+    This workflow is triggered by a pull request.
+    It runs tests on the pull request.
+    """
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        triggers = super().get_workflow_triggers()
+        triggers.update(cls.on_pull_request())
+        triggers.update(cls.on_schedule(cron="0 6 * * *"))
+        return triggers
+
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        jobs: dict[str, Any] = {}
+        jobs.update(cls.job_health_check_matrix())
+        jobs.update(cls.job_health_check())
+        return jobs
+
+    @classmethod
+    def job_health_check_matrix(cls) -> dict[str, Any]:
+        """Get the health check matrix job."""
+        return cls.get_job(
+            job_func=cls.job_health_check_matrix,
+            strategy=cls.strategy_matrix_os_and_python_version(),
+            runs_on=cls.insert_matrix_os(),
+            steps=cls.steps_health_check_matrix(),
+        )
+
+    @classmethod
+    def job_health_check(cls) -> dict[str, Any]:
+        """Get the health check job."""
+        return cls.get_job(
+            job_func=cls.job_health_check,
+            needs=[cls.make_id_from_func(cls.job_health_check_matrix)],
+            steps=cls.steps_aggregate_matrix_results(),
+        )
+
+    @classmethod
+    def steps_health_check_matrix(cls) -> list[dict[str, Any]]:
+        """Get the health check matrix steps."""
+        return [
+            *cls.steps_core_matrix_setup(
+                python_version=cls.insert_matrix_python_version()
+            ),
+            cls.step_protect_repository(),
+            cls.step_run_pre_commit_hooks(),
+        ]
+
+    @classmethod
+    def steps_aggregate_matrix_results(cls) -> list[dict[str, Any]]:
+        """Get the aggregate matrix results step."""
+        return [
+            cls.step_aggregate_matrix_results(),
+        ]

winipedia_utils/git/github/workflows/publish.py

@@ -0,0 +1,51 @@
+"""Contains the publish workflow.
+
+This workflow is used to publish the package to PyPI with poetry.
+"""
+
+from typing import Any
+
+from winipedia_utils.git.github.workflows.base.base import Workflow
+from winipedia_utils.git.github.workflows.release import ReleaseWorkflow
+
+
+class PublishWorkflow(Workflow):
+    """Publish workflow.
+
+    This workflow is triggered by the release workflow.
+    It publishes the package to PyPI with poetry.
+    """
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        triggers = super().get_workflow_triggers()
+        triggers.update(
+            cls.on_workflow_run(workflows=[ReleaseWorkflow.get_workflow_name()])
+        )
+        return triggers
+
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        jobs: dict[str, Any] = {}
+        jobs.update(cls.job_publish())
+        return jobs
+
+    @classmethod
+    def job_publish(cls) -> dict[str, Any]:
+        """Get the publish job."""
+        return cls.get_job(
+            job_func=cls.job_publish,
+            steps=cls.steps_publish(),
+            if_condition=cls.if_workflow_run_is_success(),
+        )
+
+    @classmethod
+    def steps_publish(cls) -> list[dict[str, Any]]:
+        """Get the publish steps."""
+        return [
+            *cls.steps_core_setup(),
+            cls.step_add_pypi_token_to_poetry(),
+            cls.step_publish_to_pypi(),
+        ]

winipedia_utils/git/github/workflows/release.py

@@ -0,0 +1,90 @@
+"""Contains the release workflow.
+
+This workflow is used to create a release on GitHub.
+"""
+
+from typing import Any
+
+from winipedia_utils.git.github.workflows.health_check import HealthCheckWorkflow
+
+
+class ReleaseWorkflow(HealthCheckWorkflow):
+    """Release workflow.
+
+    This workflow is triggered by a push to the main branch.
+    It creates a tag for the release and builds a changelog.
+    With tag and changelog it creates a release on GitHub
+    """
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        triggers = super().get_workflow_triggers()
+        triggers.update(cls.on_push())
+        triggers.update(cls.on_schedule(cron="0 6 * * 2"))
+        return triggers
+
+    @classmethod
+    def get_permissions(cls) -> dict[str, Any]:
+        """Get the workflow permissions."""
+        permissions = super().get_permissions()
+        permissions["contents"] = "write"
+        return permissions
+
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        jobs = super().get_jobs()
+        last_job_name = list(jobs.keys())[-1]
+        jobs.update(cls.job_build(needs=[last_job_name]))
+        jobs.update(cls.job_release())
+        return jobs
+
+    @classmethod
+    def job_build(cls, needs: list[str] | None = None) -> dict[str, Any]:
+        """Get the build job."""
+        return cls.get_job(
+            job_func=cls.job_build,
+            needs=needs,
+            strategy=cls.strategy_matrix_os(),
+            runs_on=cls.insert_matrix_os(),
+            steps=cls.steps_build(),
+        )
+
+    @classmethod
+    def job_release(cls) -> dict[str, Any]:
+        """Get the release job."""
+        return cls.get_job(
+            job_func=cls.job_release,
+            needs=[cls.make_id_from_func(cls.job_build)],
+            steps=cls.steps_release(),
+        )
+
+    @classmethod
+    def steps_build(cls) -> list[dict[str, Any]]:
+        """Get the build steps."""
+        if not cls.BUILD_SCRIPT_PATH.exists():
+            return [cls.step_no_build_script()]
+        return [
+            *cls.steps_core_matrix_setup(),
+            cls.step_build_artifacts(),
+            cls.step_upload_artifacts(),
+        ]
+
+    @classmethod
+    def steps_release(cls) -> list[dict[str, Any]]:
+        """Get the release steps."""
+        return [
+            *cls.steps_core_setup(repo_token=True),
+            cls.step_install_python_dependencies(),
+            cls.step_setup_keyring(),
+            cls.step_setup_git(),
+            cls.step_run_pre_commit_hooks(),
+            cls.step_commit_added_changes(),
+            cls.step_push_commits(),
+            cls.step_create_and_push_tag(),
+            cls.step_extract_version(),
+            cls.step_download_artifacts(),
+            cls.step_build_changelog(),
+            cls.step_create_release(),
+        ]

winipedia_utils/git/gitignore/config.py

@@ -0,0 +1,77 @@
+"""Config utilities for .gitignore."""
+
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from winipedia_utils.testing.config import ExperimentConfigFile
+from winipedia_utils.text.config import ConfigFile, DotEnvConfigFile
+
+
+class GitIgnoreConfigFile(ConfigFile):
+    """Config file for .gitignore."""
+
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        return ""  # so it builds the path .gitignore and not gitignore.gitignore
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path()
+
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "gitignore"
+
+    @classmethod
+    def load(cls) -> list[str]:
+        """Load the config file."""
+        return cls.get_path().read_text().splitlines()
+
+    @classmethod
+    def dump(cls, config: list[str] | dict[str, Any]) -> None:
+        """Dump the config file."""
+        if not isinstance(config, list):
+            msg = f"Cannot dump {config} to .gitignore file."
+            raise TypeError(msg)
+        cls.get_path().write_text("\n".join(config))
+
+    @classmethod
+    def get_configs(cls) -> list[str]:
+        """Get the config."""
+        # fetch the standard github gitignore via https://github.com/github/gitignore/blob/main/Python.gitignore
+        needed = [
+            *cls.get_github_python_gitignore(),
+            "# vscode stuff",
+            ".vscode/",
+            "",
+            "# winipedia_utils stuff",
+            "# for walk_os_skipping_gitignore_patterns func",
+            ".git/",
+            "# for executing experimental code",
+            ExperimentConfigFile.get_path().as_posix(),
+        ]
+
+        dotenv_path = DotEnvConfigFile.get_path().as_posix()
+        if dotenv_path not in needed:
+            needed.extend(["# for secrets used locally", dotenv_path])
+
+        existing = cls.load()
+        needed = [p for p in needed if p not in set(existing)]
+        return existing + needed
+
+    @classmethod
+    def get_github_python_gitignore(cls) -> list[str]:
+        """Get the standard github python gitignore."""
+        url = "https://raw.githubusercontent.com/github/gitignore/main/Python.gitignore"
+        res = requests.get(url, timeout=10)
+        if not res.ok:
+            if not Path(".gitignore").exists():
+                msg = f"Failed to fetch {url}. Cannot create .gitignore."
+                raise RuntimeError(msg)
+            return []
+        return res.text.splitlines()

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(),
+    )
 
     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,58 @@
 from pathlib import Path
 from typing import Any
 
-import yaml
-
+import winipedia_utils
 from winipedia_utils.logging.logger import get_logger
 from winipedia_utils.os.os import run_subprocess
-from winipedia_utils.projects.poetry.poetry import POETRY_RUN_ARGS
+from winipedia_utils.text.config import YamlConfigFile
+from winipedia_utils.text.string import make_name_from_obj
 
 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 PreCommitConfigConfigFile(YamlConfigFile):
+    """Config file for pre-commit."""
+
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        filename = super().get_filename()
+        return f".{filename.replace('_', '-')}"
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path()
+
+    @classmethod
+    def get_configs(cls) -> dict[str, Any]:
+        """Get the config."""
+        hook_name = make_name_from_obj(winipedia_utils, capitalize=False)
+        return {
+            "repos": [
+                {
+                    "repo": "local",
+                    "hooks": [
+                        {
+                            "id": hook_name,
+                            "name": hook_name,
+                            "entry": cls.get_poetry_run_setup_script(),
+                            "language": "system",
+                            "always_run": True,
+                            "pass_filenames": False,
+                        }
+                    ],
+                },
+            ]
+        }
+
+    def __init__(self) -> None:
+        """Init the file."""
+        super().__init__()
+        self.install()
+
+    @classmethod
+    def install(cls) -> None:
+        """Installs the pre commits in the config."""
+        logger.info("Running pre-commit install")
+        run_subprocess(["pre-commit", "install"], check=True)

winipedia_utils/git/pre_commit/hooks.py

@@ -7,121 +7,121 @@ 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_PATH,
-    POETRY_RUN_ARGS,
-    POETRY_RUN_PYTHON_ARGS,
-    POETRY_RUN_RUFF_ARGS,
+    POETRY_ARG,
+    get_poetry_run_module_args,
 )
 
 
-def _version_patch() -> list[str | Path]:
-    """Patch the version in pyproject.toml.
-
-    This function returns the input for subprocess.run() to patch the version
-    in pyproject.toml.
-    """
-    return [POETRY_PATH, "version", "patch"]
-
-
-def _add_version_patch_to_git() -> list[str | Path]:
-    """Add the version patch to git.
-
-    This function returns the input for subprocess.run() to add the version
-    patch to git, so that the hook does not fail bc the file was changed.
-    """
-    return [*POETRY_RUN_ARGS, "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
     manager.
     """
-    return [POETRY_PATH, "self", "update"]
+    return [POETRY_ARG, "self", "update"]
 
 
-def _install_packages() -> 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.
     """
-    return [POETRY_PATH, "install"]
+    return [POETRY_ARG, "install", "--with", "dev"]
 
 
-def _update_packages() -> 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.
     """
-    return [POETRY_PATH, "update"]
+    return [POETRY_ARG, "update", "--with", "dev"]
 
 
-def _lock_dependencies() -> list[str | Path]:
+def add_updates_to_git() -> list[str]:
+    """Add the updated dependencies to git.
+
+    This function returns the input for subprocess.run() to add the updated
+    dependencies to git, so that the hook does not fail bc the file was changed.
+    """
+    return ["git", "add", "pyproject.toml"]
+
+
+def lock_dependencies() -> list[str]:
     """Lock the dependencies.
 
     This function returns the input for subprocess.run() to lock the dependencies.
     """
-    return [POETRY_PATH, "lock"]
+    return [POETRY_ARG, "lock"]
+
 
+def add_lock_file_to_git() -> list[str]:
+    """Add the lock file to git.
 
-def _check_configurations() -> list[str | Path]:
+    This function returns the input for subprocess.run() to add the lock file
+    to git, so that the hook does not fail bc the file was changed.
+    """
+    return ["git", "add", "poetry.lock"]
+
+
+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
     is up to date.
     """
-    return [POETRY_PATH, "check", "--strict"]
+    return [POETRY_ARG, "check", "--strict"]
 
 
-def _creating_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.
     """
-    return [*POETRY_RUN_PYTHON_ARGS, "-m", "winipedia_utils.testing.create_tests"]
+    from winipedia_utils.testing import (  # noqa: PLC0415  # avoid circular import
+        create_tests,
+    )
+
+    return get_poetry_run_module_args(create_tests)
 
 
-def _linting() -> list[str | Path]:
+def lint_code() -> list[str]:
     """Check the code.
 
     This function returns the input for subprocess.run() to lint the code.
     It autofixes all errors that can be autofixed with --fix.
     """
-    return [*POETRY_RUN_RUFF_ARGS, "check", "--fix"]
+    return ["ruff", "check", "--fix"]
 
 
-def _formating() -> list[str | Path]:
+def format_code() -> list[str]:
     """Format the code.
 
     This function calls ruff format to format the code.
     """
-    return [*POETRY_RUN_RUFF_ARGS, "format"]
+    return ["ruff", "format"]
 
 
-def _type_checking() -> 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.
     """
-    return [*POETRY_RUN_ARGS, "mypy"]
+    return ["mypy", "--exclude-gitignore"]
 
 
-def _security_checking() -> 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
     the code.
     """
-    return [*POETRY_RUN_ARGS, "bandit", "-c", "pyproject.toml", "-r", "."]
+    return ["bandit", "-c", "pyproject.toml", "-r", "."]
 
 
-def _testing() -> list[str | Path]:
+def run_tests() -> list[str]:
     """Run the tests.
 
     This function returns the input for subprocess.run() to run all tests.
     """
-    return [*POETRY_RUN_ARGS, "pytest"]
+    return ["pytest"]