winipedia-utils 0.4.48__py3-none-any.whl → 0.6.12__py3-none-any.whl

winipedia_utils/git/github/workflows/base/base.py

@@ -1,39 +1,49 @@
 """Contains base utilities for git workflows."""
 
 from abc import abstractmethod
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any
+from typing import Any, ClassVar
 
-import winipedia_utils
-from winipedia_utils.modules.module import make_obj_importpath
+from winipedia_utils.modules.module import to_module_name
 from winipedia_utils.modules.package import get_src_package
 from winipedia_utils.projects.poetry.config import PyprojectConfigFile
 from winipedia_utils.text.config import YamlConfigFile
-from winipedia_utils.text.string import split_on_uppercase
+from winipedia_utils.text.string import make_name_from_obj, split_on_uppercase
 
 
 class Workflow(YamlConfigFile):
     """Base class for workflows."""
 
-    @classmethod
-    @abstractmethod
-    def get_workflow_triggers(cls) -> dict[str, Any]:
-        """Get the workflow triggers."""
-
-    @classmethod
-    @abstractmethod
-    def get_permissions(cls) -> dict[str, Any]:
-        """Get the workflow permissions."""
-
-    @classmethod
-    @abstractmethod
-    def get_jobs(cls) -> dict[str, Any]:
-        """Get the workflow jobs."""
-
-    @classmethod
-    def get_parent_path(cls) -> Path:
-        """Get the path to the config file."""
-        return Path(".github/workflows")
+    UBUNTU_LATEST = "ubuntu-latest"
+    WINDOWS_LATEST = "windows-latest"
+    MACOS_LATEST = "macos-latest"
+
+    ARTIFACTS_FOLDER = "artifacts"
+    ARTIFACTS_PATH = Path(f"{ARTIFACTS_FOLDER}")
+    ARTIFACTS_PATTERN = f"{ARTIFACTS_PATH}/*"
+
+    BUILD_SCRIPT_PATH = Path(
+        f"{get_src_package().__name__}/{ARTIFACTS_FOLDER}/build.py"
+    )
+    BUILD_SCRIPT_MODULE = to_module_name(BUILD_SCRIPT_PATH)
+
+    EMPTY_CONFIG: ClassVar[dict[str, Any]] = {
+        "on": {
+            "workflow_dispatch": {},
+        },
+        "jobs": {
+            "empty": {
+                "runs-on": "ubuntu-latest",
+                "steps": [
+                    {
+                        "name": "Empty Step",
+                        "run": "echo 'Empty Step'",
+                    }
+                ],
+            },
+        },
+    }
 
     @classmethod
     def get_configs(cls) -> dict[str, Any]:
@@ -43,38 +53,62 @@ class Workflow(YamlConfigFile):
             "on": cls.get_workflow_triggers(),
             "permissions": cls.get_permissions(),
             "run-name": cls.get_run_name(),
+            "defaults": cls.get_defaults(),
             "jobs": cls.get_jobs(),
         }
 
     @classmethod
-    def get_standard_job(
-        cls,
-        name: str | None = None,
-        runs_on: str = "ubuntu-latest",
-        permissions: dict[str, Any] | None = None,
-        if_condition: str | None = None,
-        steps: list[dict[str, Any]] | None = None,
-    ) -> dict[str, Any]:
-        """Get a standard job."""
-        if name is None:
-            name = cls.get_filename()
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path(".github/workflows")
 
-        if steps is None:
-            steps = []
+    @classmethod
+    def is_correct(cls) -> bool:
+        """Check if the config is correct.
 
-        job: dict[str, Any] = {
-            name: {
-                "runs-on": runs_on,
-                "steps": steps,
-            }
-        }
-        if permissions is not None:
-            job[name]["permissions"] = permissions
+        Needs some special handling since workflow files cannot be empty.
+        We need a workflow that will never trigger and even if doesnt do anything.
+        """
+        correct = super().is_correct()
+        if cls.get_path().read_text() == "":
+            # dump a dispatch in there for on and an empty job for jobs
+            cls.dump(cls.EMPTY_CONFIG)
 
-        if if_condition is not None:
-            job[name]["if"] = if_condition
-        return job
+        return correct or cls.load() == cls.EMPTY_CONFIG
+
+    # Overridable Workflow Parts
+    # ----------------------------------------------------------------------------
+    @classmethod
+    @abstractmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers.
+
+        Can be overriden. Standard is workflow_dispatch.
+        """
+        return cls.on_workflow_dispatch()
+
+    @classmethod
+    def get_permissions(cls) -> dict[str, Any]:
+        """Get the workflow permissions. Can be overriden.
+
+        Standard is no extra permissions.
+        """
+        return {}
+
+    @classmethod
+    def get_defaults(cls) -> dict[str, Any]:
+        """Get the workflow defaults. Can be overriden.
 
+        Standard is bash.
+        """
+        return {"run": {"shell": "bash"}}
+
+    # Workflow Conventions
+    # ----------------------------------------------------------------------------
     @classmethod
     def get_workflow_name(cls) -> str:
         """Get the workflow name."""
@@ -82,213 +116,774 @@ class Workflow(YamlConfigFile):
 
     @classmethod
     def get_run_name(cls) -> str:
-        """Get the workflow run name."""
-        return f"{cls.get_workflow_name()}"
+        """Get the run name."""
+        return cls.get_workflow_name()
 
+    # Build Utilities
+    # ----------------------------------------------------------------------------
     @classmethod
-    def get_checkout_step(
+    def get_job(  # noqa: PLR0913
         cls,
-        fetch_depth: int | None = None,
-        *,
-        token: bool = False,
+        job_func: Callable[..., Any],
+        needs: list[str] | None = None,
+        strategy: dict[str, Any] | None = None,
+        permissions: dict[str, Any] | None = None,
+        runs_on: str = UBUNTU_LATEST,
+        if_condition: str | None = None,
+        steps: list[dict[str, Any]] | None = None,
+        job: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        """Get the checkout step.
+        """Get a job.
 
         Args:
-        fetch_depth: The fetch depth to use. If None, no fetch depth is specified.
-        token: Whether to use the repository token.
+        job_func: The function that represents the job. Used to generate the name.
+        job: The job to update. Defaults to a new job.
+        needs: The needs of the job.
+        strategy: The strategy of the job. like matrix
+        permissions: The permissions of the job.
+        runs_on: The runs-on of the job. Defaults to ubuntu-latest.
+        if_condition: The if condition of the job.
+        steps: The steps of the job.
 
         Returns:
-        The checkout step.
+        The job.
         """
-        step: dict[str, Any] = {
-            "name": "Checkout repository",
-            "uses": "actions/checkout@main",
-        }
-        if fetch_depth is not None:
-            step.setdefault("with", {})["fetch-depth"] = fetch_depth
+        name = cls.make_id_from_func(job_func)
+        if job is None:
+            job = {}
+        job_config: dict[str, Any] = {}
+        if needs is not None:
+            job_config["needs"] = needs
+        if strategy is not None:
+            job_config["strategy"] = strategy
+        if permissions is not None:
+            job_config["permissions"] = permissions
+        job_config["runs-on"] = runs_on
+        if if_condition is not None:
+            job_config["if"] = if_condition
+        if steps is not None:
+            job_config["steps"] = steps
+        job_config.update(job)
+        return {name: job_config}
+
+    @classmethod
+    def make_name_from_func(cls, func: Callable[..., Any]) -> str:
+        """Make a name from a function."""
+        name = make_name_from_obj(func, split_on="_", join_on=" ", capitalize=True)
+        prefix = split_on_uppercase(name)[0]
+        return name.removeprefix(prefix)
+
+    @classmethod
+    def make_id_from_func(cls, func: Callable[..., Any]) -> str:
+        """Make an id from a function."""
+        name = func.__name__
+        prefix = name.split("_")[0]
+        return name.removeprefix(f"{prefix}_")
+
+    # triggers
+    @classmethod
+    def on_workflow_dispatch(cls) -> dict[str, Any]:
+        """Get the workflow dispatch trigger."""
+        return {"workflow_dispatch": {}}
+
+    @classmethod
+    def on_push(cls, branches: list[str] | None = None) -> dict[str, Any]:
+        """Get the push trigger."""
+        if branches is None:
+            branches = ["main"]
+        return {"push": {"branches": branches}}
 
-        if token:
-            step.setdefault("with", {})["token"] = cls.get_repo_token()
-        return step
+    @classmethod
+    def on_schedule(cls, cron: str) -> dict[str, Any]:
+        """Get the schedule trigger."""
+        return {"schedule": [{"cron": cron}]}
+
+    @classmethod
+    def on_pull_request(cls, types: list[str] | None = None) -> dict[str, Any]:
+        """Get the pull request trigger."""
+        if types is None:
+            types = ["opened", "synchronize", "reopened"]
+        return {"pull_request": {"types": types}}
+
+    @classmethod
+    def on_workflow_run(cls, workflows: list[str] | None = None) -> dict[str, Any]:
+        """Get the workflow run trigger."""
+        if workflows is None:
+            workflows = [cls.get_workflow_name()]
+        return {"workflow_run": {"workflows": workflows, "types": ["completed"]}}
 
+    # permissions
     @classmethod
-    def get_poetry_setup_steps(
+    def permission_content(cls, permission: str = "read") -> dict[str, Any]:
+        """Get the content read permission."""
+        return {"contents": permission}
+
+    # Steps
+    @classmethod
+    def get_step(  # noqa: PLR0913
         cls,
-        *,
-        install_dependencies: bool = False,
-        fetch_depth: int | None = None,
-        configure_pipy_token: bool = False,
-        force_main_head: bool = False,
-        token: bool = False,
-    ) -> list[dict[str, Any]]:
-        """Get the poetry steps.
+        step_func: Callable[..., Any],
+        run: str | None = None,
+        if_condition: str | None = None,
+        uses: str | None = None,
+        with_: dict[str, Any] | None = None,
+        env: dict[str, Any] | None = None,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get a step.
 
         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.
-        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.
+        step_func: The function that represents the step. Used to generate the name.
+        run: The run command.
+        if_condition: The if condition.
+        uses: The uses command.
+        with_: The with command.
+        env: The env command.
+        step: The step to update. Defaults to a new step.
 
         Returns:
-        The poetry steps.
+        The step.
         """
-        steps = [cls.get_checkout_step(fetch_depth, token=token)]
-        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(cls.get_setup_git_step())
-        steps.append(
-            {
-                "name": "Setup Python",
-                "uses": "actions/setup-python@main",
-                "with": {
-                    "python-version": PyprojectConfigFile.get_latest_possible_python_version()  # noqa: E501
-                },
-            }
+        if step is None:
+            step = {}
+        # make name from setup function name if name is a function
+        name = cls.make_name_from_func(step_func)
+        id_ = cls.make_id_from_func(step_func)
+        step_config: dict[str, Any] = {"name": name, "id": id_}
+        if run is not None:
+            step_config["run"] = run
+        if if_condition is not None:
+            step_config["if"] = if_condition
+        if uses is not None:
+            step_config["uses"] = uses
+        if with_ is not None:
+            step_config["with"] = with_
+        if env is not None:
+            step_config["env"] = env
+
+        step_config.update(step)
+
+        return step_config
+
+    # Strategy
+    @classmethod
+    def strategy_matrix_os_and_python_version(
+        cls,
+        os: list[str] | None = None,
+        python_version: list[str] | None = None,
+        matrix: dict[str, list[Any]] | None = None,
+        strategy: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get a strategy for os and python version."""
+        return cls.strategy_matrix(
+            matrix=cls.matrix_os_and_python_version(
+                os=os, python_version=python_version, matrix=matrix
+            ),
+            strategy=strategy,
         )
-        steps.append(
-            {
-                "name": "Install Poetry",
-                "run": "curl -sSL https://install.python-poetry.org | python3 -",
-            }
+
+    @classmethod
+    def strategy_matrix_python_version(
+        cls,
+        python_version: list[str] | None = None,
+        matrix: dict[str, list[Any]] | None = None,
+        strategy: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get a strategy for python version."""
+        return cls.strategy_matrix(
+            matrix=cls.matrix_python_version(
+                python_version=python_version, matrix=matrix
+            ),
+            strategy=strategy,
         )
-        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
 
     @classmethod
-    def get_release_steps(cls) -> list[dict[str, Any]]:
-        """Get the release steps."""
+    def strategy_matrix_os(
+        cls,
+        os: list[str] | None = None,
+        matrix: dict[str, list[Any]] | None = None,
+        strategy: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get a strategy for os."""
+        return cls.strategy_matrix(
+            matrix=cls.matrix_os(os=os, matrix=matrix), strategy=strategy
+        )
+
+    @classmethod
+    def strategy_matrix(
+        cls,
+        *,
+        strategy: dict[str, Any] | None = None,
+        matrix: dict[str, list[Any]] | None = None,
+    ) -> dict[str, Any]:
+        """Get a matrix strategy."""
+        if strategy is None:
+            strategy = {}
+        if matrix is None:
+            matrix = {}
+        strategy["matrix"] = matrix
+        return cls.get_strategy(strategy=strategy)
+
+    @classmethod
+    def get_strategy(
+        cls,
+        *,
+        strategy: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Get a strategy."""
+        strategy["fail-fast"] = strategy.pop("fail-fast", True)
+        return strategy
+
+    @classmethod
+    def matrix_os_and_python_version(
+        cls,
+        os: list[str] | None = None,
+        python_version: list[str] | None = None,
+        matrix: dict[str, list[Any]] | None = None,
+    ) -> dict[str, Any]:
+        """Get a matrix for os and python version."""
+        if matrix is None:
+            matrix = {}
+        os_matrix = cls.matrix_os(os=os, matrix=matrix)["os"]
+        python_version_matrix = cls.matrix_python_version(
+            python_version=python_version, matrix=matrix
+        )["python-version"]
+        matrix["os"] = os_matrix
+        matrix["python-version"] = python_version_matrix
+        return cls.get_matrix(matrix=matrix)
+
+    @classmethod
+    def matrix_os(
+        cls,
+        *,
+        os: list[str] | None = None,
+        matrix: dict[str, list[Any]] | None = None,
+    ) -> dict[str, Any]:
+        """Get a matrix for os."""
+        if os is None:
+            os = [cls.UBUNTU_LATEST, cls.WINDOWS_LATEST, cls.MACOS_LATEST]
+        if matrix is None:
+            matrix = {}
+        matrix["os"] = os
+        return cls.get_matrix(matrix=matrix)
+
+    @classmethod
+    def matrix_python_version(
+        cls,
+        *,
+        python_version: list[str] | None = None,
+        matrix: dict[str, list[Any]] | None = None,
+    ) -> dict[str, Any]:
+        """Get a matrix for python version."""
+        if python_version is None:
+            python_version = [
+                str(v) for v in PyprojectConfigFile.get_supported_python_versions()
+            ]
+        if matrix is None:
+            matrix = {}
+        matrix["python-version"] = python_version
+        return cls.get_matrix(matrix=matrix)
+
+    @classmethod
+    def get_matrix(cls, matrix: dict[str, list[Any]]) -> dict[str, Any]:
+        """Get a matrix."""
+        return matrix
+
+    # Workflow Steps
+    # ----------------------------------------------------------------------------
+    # Combined Steps
+    @classmethod
+    def steps_core_setup(
+        cls, python_version: str | None = None, *, repo_token: bool = False
+    ) -> list[dict[str, Any]]:
+        """Get the core setup steps."""
         return [
-            {
-                "name": "Tag and Push",
-                "run": f"git push && git tag {cls.get_version()} && git push origin {cls.get_version()}",  # noqa: E501
-            },
-            {
-                "name": "Build Changelog",
-                "id": "build_changelog",
-                "uses": "mikepenz/release-changelog-builder-action@develop",
-                "with": {"token": cls.get_github_token()},
-            },
-            {
-                "name": "Create GitHub Release",
-                "uses": "ncipollo/release-action@main",
-                "with": {
-                    "tag": cls.get_version(),
-                    "name": cls.get_repo_and_version(),
-                    "body": "${{ steps.build_changelog.outputs.changelog }}",
-                },
-            },
+            cls.step_checkout_repository(repo_token=repo_token),
+            cls.step_setup_python(python_version=python_version),
+            cls.step_setup_poetry(),
         ]
 
     @classmethod
-    def get_extract_version_step(cls) -> dict[str, Any]:
-        """Get the extract version step."""
-        return {
-            "name": "Extract Version from pyproject.toml",
-            "id": "version",
-            "run": 'version=$(poetry version -s) && echo "Project version: $version" && echo "version=v$version" >> $GITHUB_OUTPUT',  # noqa: E501
-        }
+    def steps_core_matrix_setup(
+        cls, python_version: str | None = None, *, repo_token: bool = False
+    ) -> list[dict[str, Any]]:
+        """Get the core matrix setup steps."""
+        return [
+            *cls.steps_core_setup(python_version=python_version, repo_token=repo_token),
+            cls.step_add_poetry_to_windows_path(),
+            cls.step_install_python_dependencies(),
+            cls.step_setup_keyring(),
+        ]
+
+    # Single Step
+    @classmethod
+    def step_aggregate_matrix_results(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the aggregate matrix results step."""
+        return cls.get_step(
+            step_func=cls.step_aggregate_matrix_results,
+            run="echo 'Aggregating matrix results into one job.'",
+            step=step,
+        )
 
     @classmethod
-    def get_publish_to_pypi_step(cls) -> dict[str, Any]:
-        """Get the publish step."""
-        return {"name": "Build and publish to PyPI", "run": "poetry publish --build"}
+    def step_no_build_script(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the no build script step."""
+        return cls.get_step(
+            step_func=cls.step_no_build_script,
+            run="echo 'No build script found. Skipping build.'",
+            step=step,
+        )
 
     @classmethod
-    def get_pre_commit_step(cls) -> dict[str, Any]:
-        """Get the pre-commit step.
+    def step_patch_version(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the patch version step."""
+        return cls.get_step(
+            step_func=cls.step_patch_version,
+            run="poetry version patch && git add pyproject.toml",
+            step=step,
+        )
 
-        using pre commit in case other hooks are added later
-        and bc it fails if files are changed,
-        setup script shouldnt change files
-        """
-        step: dict[str, Any] = {
-            "name": "Run Hooks",
-            "run": "poetry run pre-commit run --all-files --verbose",
-        }
-        if get_src_package() == winipedia_utils:
-            step["env"] = {"REPO_TOKEN": cls.get_repo_token()}
-        return step
+    @classmethod
+    def step_checkout_repository(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+        fetch_depth: int | None = None,
+        repo_token: bool = False,
+    ) -> dict[str, Any]:
+        """Get the checkout step."""
+        if step is None:
+            step = {}
+        if fetch_depth is not None:
+            step.setdefault("with", {})["fetch-depth"] = fetch_depth
+        if repo_token:
+            step.setdefault("with", {})["token"] = cls.insert_repo_token()
+        return cls.get_step(
+            step_func=cls.step_checkout_repository,
+            uses="actions/checkout@main",
+            step=step,
+        )
 
     @classmethod
-    def get_setup_git_step(cls) -> dict[str, Any]:
+    def step_setup_git(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Get the setup git step."""
-        return {
-            "name": "Setup Git",
-            "run": 'git config --global user.email "github-actions[bot]@users.noreply.github.com" && git config --global user.name "github-actions[bot]"',  # noqa: E501
-        }
+        return cls.get_step(
+            step_func=cls.step_setup_git,
+            run='git config --global user.email "github-actions[bot]@users.noreply.github.com" && git config --global user.name "github-actions[bot]"',  # noqa: E501
+            step=step,
+        )
 
     @classmethod
-    def get_commit_step(cls) -> dict[str, Any]:
-        """Get the commit step."""
-        return {
-            "name": "Commit added changes",
-            "run": "git commit --no-verify -m '[skip ci] CI/CD: Committing possible added changes (e.g.: pyproject.toml and poetry.lock)'",  # noqa: E501
-        }
+    def step_setup_python(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+        python_version: str | None = None,
+    ) -> dict[str, Any]:
+        """Get the setup python step."""
+        if step is None:
+            step = {}
+        if python_version is None:
+            python_version = str(
+                PyprojectConfigFile.get_latest_possible_python_version()
+            )
+
+        step.setdefault("with", {})["python-version"] = python_version
+        return cls.get_step(
+            step_func=cls.step_setup_python,
+            uses="actions/setup-python@main",
+            step=step,
+        )
+
+    @classmethod
+    def step_setup_poetry(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the setup poetry step."""
+        return cls.get_step(
+            step_func=cls.step_setup_poetry,
+            uses="snok/install-poetry@main",
+            step=step,
+        )
+
+    @classmethod
+    def step_add_poetry_to_windows_path(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the add poetry to path step."""
+        return cls.get_step(
+            step_func=cls.step_add_poetry_to_windows_path,
+            run="echo 'C:/Users/runneradmin/.local/bin' >> $GITHUB_PATH",
+            if_condition=f"{cls.insert_os()} == 'Windows'",
+            step=step,
+        )
+
+    @classmethod
+    def step_add_pypi_token_to_poetry(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the add pypi token to poetry step."""
+        return cls.get_step(
+            step_func=cls.step_add_pypi_token_to_poetry,
+            run="poetry config pypi-token.pypi ${{ secrets.PYPI_TOKEN }}",
+            step=step,
+        )
+
+    @classmethod
+    def step_publish_to_pypi(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the publish to pypi step."""
+        return cls.get_step(
+            step_func=cls.step_publish_to_pypi,
+            run="poetry publish --build",
+            step=step,
+        )
+
+    @classmethod
+    def step_install_python_dependencies(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the install dependencies step."""
+        return cls.get_step(
+            step_func=cls.step_install_python_dependencies,
+            run="poetry install",
+            step=step,
+        )
+
+    @classmethod
+    def step_setup_keyring(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the setup keyring step."""
+        return cls.get_step(
+            step_func=cls.step_setup_keyring,
+            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
+            step=step,
+        )
 
     @classmethod
-    def get_protect_repository_step(cls) -> dict[str, Any]:
+    def step_protect_repository(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Get the protect repository step."""
-        from winipedia_utils.git.github.repo import (  # noqa: PLC0415
-            protect,  # avoid circular import
+        return cls.get_step(
+            step_func=cls.step_protect_repository,
+            run="poetry run python -m winipedia_utils.git.github.repo.protect",
+            env={"REPO_TOKEN": cls.insert_repo_token()},
+            step=step,
         )
 
-        return {
-            "name": "Protect Repository",
-            "run": f"poetry run python -m {make_obj_importpath(protect)}",
-            "env": {
-                "REPO_TOKEN": cls.get_repo_token(),
+    @classmethod
+    def step_run_pre_commit_hooks(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the run pre-commit hooks step.
+
+        Patching version is useful to have at least a minimal version bump when
+        creating a release and it also makes sure git stash pop does not fail when
+        there are no changes.
+        """
+        return cls.get_step(
+            step_func=cls.step_run_pre_commit_hooks,
+            run="poetry version patch && git add pyproject.toml && poetry run pre-commit run --all-files --verbose",  # noqa: E501
+            env={"REPO_TOKEN": cls.insert_repo_token()},
+            step=step,
+        )
+
+    @classmethod
+    def step_commit_added_changes(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the commit changes step."""
+        return cls.get_step(
+            step_func=cls.step_commit_added_changes,
+            run="git commit --no-verify -m '[skip ci] CI/CD: Committing possible added changes (e.g.: pyproject.toml and poetry.lock)'",  # noqa: E501
+            step=step,
+        )
+
+    @classmethod
+    def step_push_commits(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the push changes step."""
+        return cls.get_step(
+            step_func=cls.step_push_commits,
+            run="git push",
+            step=step,
+        )
+
+    @classmethod
+    def step_create_and_push_tag(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the tag and push step."""
+        return cls.get_step(
+            step_func=cls.step_create_and_push_tag,
+            run=f"git tag {cls.insert_version()} && git push origin {cls.insert_version()}",  # noqa: E501
+            step=step,
+        )
+
+    @classmethod
+    def step_create_folder(
+        cls,
+        *,
+        folder: str,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the create folder step."""
+        # should work on all OSs
+        return cls.get_step(
+            step_func=cls.step_create_folder,
+            run=f"mkdir {folder}",
+            step=step,
+        )
+
+    @classmethod
+    def step_create_artifacts_folder(
+        cls,
+        *,
+        folder: str = ARTIFACTS_FOLDER,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the create artifacts folder step."""
+        return cls.step_create_folder(folder=folder, step=step)
+
+    @classmethod
+    def step_upload_artifacts(
+        cls,
+        *,
+        name: str | None = None,
+        path: str | Path = ARTIFACTS_PATH,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the upload artifacts step."""
+        if name is None:
+            name = cls.insert_artifact_name()
+        return cls.get_step(
+            step_func=cls.step_upload_artifacts,
+            uses="actions/upload-artifact@main",
+            with_={"name": name, "path": str(path)},
+            step=step,
+        )
+
+    @classmethod
+    def step_build_artifacts(cls) -> dict[str, Any]:
+        """Get the build artifacts step."""
+        return cls.get_step(
+            step_func=cls.step_build_artifacts,
+            run=f"poetry run python -m {cls.BUILD_SCRIPT_MODULE}",
+        )
+
+    @classmethod
+    def step_download_artifacts(
+        cls,
+        *,
+        name: str | None = None,
+        path: str | Path = ARTIFACTS_PATH,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the download artifacts step."""
+        # omit name downloads all by default
+        with_: dict[str, Any] = {"path": str(path)}
+        if name is not None:
+            with_["name"] = name
+        with_["merge-multiple"] = "true"
+        return cls.get_step(
+            step_func=cls.step_download_artifacts,
+            uses="actions/download-artifact@main",
+            with_=with_,
+            step=step,
+        )
+
+    @classmethod
+    def step_build_changelog(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the build changelog step."""
+        return cls.get_step(
+            step_func=cls.step_build_changelog,
+            uses="mikepenz/release-changelog-builder-action@develop",
+            with_={"token": cls.insert_github_token()},
+            step=step,
+        )
+
+    @classmethod
+    def step_extract_version(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the extract version step."""
+        return cls.get_step(
+            step_func=cls.step_extract_version,
+            run=f'echo "version={cls.insert_version()}" >> $GITHUB_OUTPUT',
+            step=step,
+        )
+
+    @classmethod
+    def step_create_release(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+        artifacts_pattern: str = ARTIFACTS_PATTERN,
+    ) -> dict[str, Any]:
+        """Get the create release step."""
+        version = cls.insert_version_from_extract_version_step()
+        return cls.get_step(
+            step_func=cls.step_create_release,
+            uses="ncipollo/release-action@main",
+            with_={
+                "tag": version,
+                "name": f"{cls.insert_repository_name()} {version}",
+                "body": cls.insert_changelog(),
+                cls.ARTIFACTS_FOLDER: artifacts_pattern,
             },
-        }
+            step=step,
+        )
+
+    # Insertions
+    # ----------------------------------------------------------------------------
+    @classmethod
+    def insert_repo_token(cls) -> str:
+        """Insert the repository token."""
+        return "${{ secrets.REPO_TOKEN }}"
+
+    @classmethod
+    def insert_version(cls) -> str:
+        """Insert the version."""
+        return "v$(poetry version -s)"
+
+    @classmethod
+    def insert_version_from_extract_version_step(cls) -> str:
+        """Insert the version from the extract version step."""
+        # make dynamic with cls.make_id_from_func(cls.step_extract_version)
+        return (
+            "${{ "
+            f"steps.{cls.make_id_from_func(cls.step_extract_version)}.outputs.version"
+            " }}"
+        )
+
+    @classmethod
+    def insert_changelog(cls) -> str:
+        """Insert the changelog."""
+        return (
+            "${{ "
+            f"steps.{cls.make_id_from_func(cls.step_build_changelog)}.outputs.changelog"
+            " }}"
+        )
+
+    @classmethod
+    def insert_github_token(cls) -> str:
+        """Insert the GitHub token."""
+        return "${{ secrets.GITHUB_TOKEN }}"
 
     @classmethod
-    def get_repository_name(cls) -> str:
-        """Get the repository name."""
+    def insert_repository_name(cls) -> str:
+        """Insert the repository name."""
         return "${{ github.event.repository.name }}"
 
     @classmethod
-    def get_ref_name(cls) -> str:
-        """Get the ref name."""
+    def insert_ref_name(cls) -> str:
+        """Insert the ref name."""
         return "${{ github.ref_name }}"
 
     @classmethod
-    def get_version(cls) -> str:
-        """Get the version."""
-        return "${{ steps.version.outputs.version }}"
+    def insert_repository_ownwer(cls) -> str:
+        """Insert the repository owner."""
+        return "${{ github.repository_owner }}"
 
     @classmethod
-    def get_repo_and_version(cls) -> str:
-        """Get the repository name and ref name."""
-        return f"{cls.get_repository_name()} {cls.get_version()}"
+    def insert_os(cls) -> str:
+        """Insert the os."""
+        return "${{ runner.os }}"
 
     @classmethod
-    def get_ownwer(cls) -> str:
-        """Get the repository owner."""
-        return "${{ github.repository_owner }}"
+    def insert_matrix_os(cls) -> str:
+        """Insert the matrix os."""
+        return "${{ matrix.os }}"
 
     @classmethod
-    def get_github_token(cls) -> str:
-        """Get the GitHub token."""
-        return "${{ secrets.GITHUB_TOKEN }}"
+    def insert_matrix_python_version(cls) -> str:
+        """Insert the matrix python version."""
+        return "${{ matrix.python-version }}"
 
     @classmethod
-    def get_repo_token(cls) -> str:
-        """Get the repository token."""
-        return "${{ secrets.REPO_TOKEN }}"
+    def insert_artifact_name(cls) -> str:
+        """Insert the artifact name."""
+        return f"{get_src_package().__name__}-{cls.insert_os()}"
+
+    # ifs
+    @classmethod
+    def if_matrix_is_os(cls, os: str) -> str:
+        """Insert the matrix os."""
+        return f"matrix.os == '{os}'"
+
+    @classmethod
+    def if_matrix_is_python_version(cls, python_version: str) -> str:
+        """Insert the matrix python version."""
+        return f"matrix.python-version == '{python_version}'"
+
+    @classmethod
+    def if_matrix_is_os_and_python_version(cls, os: str, python_version: str) -> str:
+        """Insert the matrix os and python version."""
+        return f"{cls.if_matrix_is_os(os)} && {cls.if_matrix_is_python_version(python_version)}"  # noqa: E501
+
+    @classmethod
+    def if_matrix_is_latest_python_version(cls) -> str:
+        """Insert the matrix latest python version."""
+        return cls.if_matrix_is_python_version(
+            str(PyprojectConfigFile.get_latest_possible_python_version())
+        )
+
+    @classmethod
+    def if_matrix_is_os_and_latest_python_version(cls, os: str) -> str:
+        """Insert the matrix os and latest python version."""
+        return cls.if_matrix_is_os_and_python_version(
+            os, str(PyprojectConfigFile.get_latest_possible_python_version())
+        )
+
+    @classmethod
+    def if_workflow_run_is_success(cls) -> str:
+        """Insert the if workflow run is success."""
+        return "${{ github.event.workflow_run.conclusion == 'success' }}"