calkit-python 0.28.3__tar.gz → 0.29.0__tar.gz

{calkit_python-0.28.3 → calkit_python-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.28.3
+Version: 0.29.0
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.28.3"
+__version__ = "0.29.0"
 
 from .core import *  # noqa: F403, I001
 from . import git  # noqa: F401

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/cli/config.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 import subprocess
 
 import git
@@ -82,11 +83,17 @@ def setup_remote(
         configure_remote()
         set_remote_auth()
     except subprocess.CalledProcessError:
-        raise_error("DVC remote config failed; have you run `dvc init`?")
+        if not os.path.isfile(".dvc/config"):
+            raise_error(
+                "DVC remote config failed; have you run `calkit init`?"
+            )
+        raise_error(
+            "Failed to configure DVC remote; check DVC config for errors"
+        )
     except InvalidGitRepositoryError:
         raise_error("Current directory is not a Git repository")
-    except ValueError as e:
-        raise_error(e)
+    except (ValueError, RuntimeError) as e:
+        raise_error(f"Failed to set up DVC remote: {e}")
     if not no_commit:
         repo = git.Repo()
         repo.git.add(".dvc/config")
@@ -101,7 +108,10 @@ def setup_remote_auth():
     """Store a Calkit cloud token in the local DVC config for all Calkit
     remotes.
     """
-    remotes = get_remotes()
+    try:
+        remotes = get_remotes()
+    except Exception:
+        raise_error("Cannot list DVC remotes; check DVC config for errors")
     for name, url in remotes.items():
         if name == "calkit" or name.startswith("calkit:"):
             typer.echo(f"Setting up authentication for DVC remote: {name}")

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/cli/main.py

@@ -981,22 +981,23 @@ def run(
         except Exception as e:
             os.environ.pop("CALKIT_PIPELINE_RUNNING", None)
             raise_error(f"Pipeline compilation failed: {e}")
-    # Get status of Git repo before running
-    repo = git.Repo()
-    git_rev = repo.head.commit.hexsha
-    try:
-        git_branch = repo.active_branch.name
-    except TypeError:
-        # If no branch is checked out, we are in a detached HEAD state
-        git_branch = None
-    git_changed_files_before = calkit.git.get_changed_files(repo=repo)
-    git_staged_files_before = calkit.git.get_staged_files(repo=repo)
-    git_untracked_files_before = calkit.git.get_untracked_files(repo=repo)
-    # Get status of DVC repo before running
-    dvc_repo = dvc.repo.Repo()
-    dvc_status_before = dvc_repo.status()
-    dvc_data_status_before = dvc_repo.data_status()
-    dvc_data_status_before.pop("git", None)  # Remove git status
+    if save_log:
+        # Get status of Git repo before running
+        repo = git.Repo()
+        git_rev = repo.head.commit.hexsha
+        try:
+            git_branch = repo.active_branch.name
+        except TypeError:
+            # If no branch is checked out, we are in a detached HEAD state
+            git_branch = None
+        git_changed_files_before = calkit.git.get_changed_files(repo=repo)
+        git_staged_files_before = calkit.git.get_staged_files(repo=repo)
+        git_untracked_files_before = calkit.git.get_untracked_files(repo=repo)
+        # Get status of DVC repo before running
+        dvc_repo = dvc.repo.Repo()
+        dvc_status_before = dvc_repo.status()
+        dvc_data_status_before = dvc_repo.data_status()
+        dvc_data_status_before.pop("git", None)  # Remove git status
     if targets is None:
         targets = []
     args = deepcopy(targets)
@@ -1855,3 +1856,51 @@ def run_jupyter(
     """Run a command with the Jupyter CLI."""
     process = subprocess.run([sys.executable, "-m", "jupyter"] + sys.argv[2:])
     sys.exit(process.returncode)
+
+
+@app.command(name="latexmk")
+def run_latexmk(
+    tex_file: Annotated[str, typer.Argument(help="The .tex file to compile.")],
+    environment: Annotated[
+        str | None,
+        typer.Option(
+            "--env",
+            "-e",
+            help=("Environment in which to run latexmk, if applicable."),
+        ),
+    ] = None,
+):
+    """Compile a LaTeX document with latexmk.
+
+    If a Calkit environment is not specified, latexmk will be run in the
+    system environment if available. If not available, a TeX Live Docker
+    container will be used.
+    """
+    latexmk_cmd = [
+        "latexmk",
+        "-pdf",
+        "-cd",
+        "-silent",
+        "-synctex=1",
+        "-interaction=nonstopmode",
+        tex_file,
+    ]
+    if environment is not None:
+        cmd = ["calkit", "xenv", "--name", environment] + latexmk_cmd
+    elif calkit.check_dep_exists("latexmk"):
+        cmd = latexmk_cmd
+    else:
+        cmd = [
+            "docker",
+            "run",
+            "--rm",
+            "-v",
+            f"{os.getcwd()}:/work",
+            "-w",
+            "/work",
+            "texlive/texlive:latest-full",
+        ] + latexmk_cmd
+    try:
+        subprocess.check_call(cmd)
+    except subprocess.CalledProcessError:
+        raise_error("latexmk failed")

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/cli/new.py

@@ -157,10 +157,16 @@ def new_project(
                 repo.git.commit(["-m", "Initialize DVC"])
     ck_info_fpath = os.path.join(abs_path, "calkit.yaml")
     if os.path.isfile(ck_info_fpath) and not overwrite:
-        raise_error(
+        ck_info = calkit.load_calkit_info(wdir=abs_path)
+        name = ck_info.get("name", name)
+        title = ck_info.get("title", title)
+        description = ck_info.get("description", description)
+        typer.echo(
             "Destination is already a Calkit project; "
-            "use --overwrite to continue"
+            "will use existing project info where possible"
         )
+    else:
+        ck_info = {}
     if os.path.isdir(abs_path) and os.listdir(abs_path) and repo is None:
         warn(f"{abs_path} is not empty")
     if name is None:
@@ -224,7 +230,29 @@ def new_project(
                     )
                 repo.git.add("calkit.yaml")
                 if not no_commit:
-                    repo.git.commit(["-m", "Create calkit.yaml"])
+                    repo.git.commit(
+                        ["calkit.yaml", "-m", "Create calkit.yaml"]
+                    )
+            else:
+                # Merge with existing project info in calkit.yaml
+                typer.echo("Updating existing calkit.yaml file")
+                ck_info = (
+                    dict(
+                        owner=resp["owner_account_name"],
+                        name=resp["name"],
+                        title=resp["title"],
+                        description=resp["description"],
+                        git_repo_url=resp["git_repo_url"],
+                    )
+                    | ck_info
+                )
+                with open(calkit_fpath, "w") as f:
+                    ryaml.dump(ck_info, f)
+                repo.git.add("calkit.yaml")
+                if not no_commit and repo.git.diff("--staged"):
+                    repo.git.commit(
+                        ["calkit.yaml", "-m", "Update calkit.yaml"]
+                    )
         try:
             calkit.dvc.configure_remote(wdir=abs_path)
         except Exception:

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/cli/notebooks.py

@@ -163,6 +163,17 @@ def execute_notebook(
             ),
         ),
     ] = None,
+    language: Annotated[
+        str,
+        typer.Option(
+            "--language",
+            "-l",
+            help=(
+                "Notebook language; if 'matlab', MATLAB kernel must be "
+                "available in environment."
+            ),
+        ),
+    ] = "python",
     verbose: Annotated[
         bool, typer.Option("--verbose", "-v", help="Print verbose output.")
     ] = False,
@@ -176,10 +187,24 @@ def execute_notebook(
 
     if os.path.isabs(path):
         raise ValueError("Path must be relative")
+    if language.lower() not in ["python", "matlab", "julia"]:
+        raise ValueError(
+            "Language must be one of 'python', 'matlab', or 'julia'"
+        )
     # First, ensure the specified environment has a kernel we can use
-    kernel_name = check_env_kernel(
-        env_name=env_name, no_check=no_check, verbose=verbose
-    )
+    # We need to check the environment type and create the kernel if needed
+    if language.lower() == "python":
+        kernel_name = check_env_kernel(
+            env_name=env_name, no_check=no_check, verbose=verbose
+        )
+    elif language.lower() == "matlab":
+        kernel_name = "jupyter_matlab_kernel"
+    else:
+        raise_error(f"Language '{language}' not yet supported")
+    # We can't handle parameters unless language is Python
+    if language.lower() != "python":
+        if params or params_json is not None or params_base64 is not None:
+            raise_error("Parameters can only be passed to Python notebooks")
     # Parse parameters
     if params:
         try:
@@ -214,14 +239,34 @@ def execute_notebook(
         typer.echo(f"Using kernel: {kernel_name}")
         typer.echo(f"Running with cwd: {notebook_dir}")
         typer.echo(f"Output will be saved to: {fpath_out_exec}")
-    papermill.execute_notebook(
-        input_path=path,
-        output_path=fpath_out_exec,
-        kernel_name=kernel_name,
-        log_output=True,
-        parameters=parsed_params,
-        cwd=notebook_dir,
-    )
+    # If this is a Python or Julia notebook, we can use Papermill
+    # If it's a MATLAB notebook, we need to use the MATLAB kernel inside the
+    # specified environment
+    if language.lower() in ["python", "julia"]:
+        papermill.execute_notebook(
+            input_path=path,
+            output_path=fpath_out_exec,
+            kernel_name=kernel_name,
+            log_output=True,
+            parameters=parsed_params,
+            cwd=notebook_dir,
+        )
+    elif language.lower() == "matlab":
+        # Use nbconvert to execute the notebook with the MATLAB kernel
+        cmd = [
+            "python",
+            "-m",
+            "jupyter",
+            "nbconvert",
+            "--to",
+            "notebook",
+            "--execute",
+            f"--ExecutePreprocessor.kernel_name={kernel_name}",
+            "--output",
+            fpath_out_exec,
+            path,
+        ]
+        run_in_env(cmd, env_name=env_name, no_check=no_check, verbose=verbose)
     for to_fmt in to:
         if to_fmt != "notebook":
             try:
@@ -250,6 +295,6 @@ def execute_notebook(
                 fname_out,
             ]
             typer.echo(f"Exporting {to_fmt}")
-            run_in_env(
-                cmd=cmd, env_name=env_name, no_check=True, verbose=verbose
-            )
+            p = subprocess.run(cmd)
+            if p.returncode != 0:
+                raise_error(f"nbconvert failed for format '{to_fmt}'")

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/dvc.py

@@ -18,7 +18,7 @@ logger = logging.getLogger(__package__)
 logger.setLevel(logging.INFO)
 
 
-def configure_remote(wdir: str = None):
+def configure_remote(wdir: str | None = None):
     try:
         project_name = calkit.detect_project_name(wdir=wdir)
     except ValueError as e:
@@ -70,7 +70,9 @@ def configure_remote(wdir: str = None):
 
 
 def set_remote_auth(
-    remote_name: str = None, always_auth: bool = False, wdir: str = None
+    remote_name: str | None = None,
+    always_auth: bool = False,
+    wdir: str | None = None,
 ):
     """Get a token and set it in the local DVC config so we can interact with
     the cloud as an HTTP remote.
@@ -85,7 +87,7 @@ def set_remote_auth(
         )["access_token"]
         settings.dvc_token = token
         settings.write()
-    subprocess.check_call(
+    p1 = subprocess.run(
         [
             sys.executable,
             "-m",
@@ -99,7 +101,7 @@ def set_remote_auth(
         ],
         cwd=wdir,
     )
-    subprocess.check_call(
+    p2 = subprocess.run(
         [
             sys.executable,
             "-m",
@@ -113,6 +115,10 @@ def set_remote_auth(
         ],
         cwd=wdir,
     )
+    if p1.returncode != 0 or p2.returncode != 0:
+        raise RuntimeError(
+            f"Failed to set DVC remote authentication for {remote_name}"
+        )
 
 
 def add_external_remote(owner_name: str, project_name: str) -> dict:
@@ -159,13 +165,15 @@ def get_remotes(wdir: str | None = None) -> dict[str, str]:
     """Get a dictionary of DVC remotes, keyed by name, with URL as the
     value.
     """
-    out = (
-        subprocess.check_output(
-            [sys.executable, "-m", "dvc", "remote", "list"], cwd=wdir
-        )
-        .decode()
-        .strip()
+    p = subprocess.run(
+        [sys.executable, "-m", "dvc", "remote", "list"],
+        cwd=wdir,
+        capture_output=True,
+        text=True,
     )
+    if p.returncode != 0:
+        raise RuntimeError(f"Error getting DVC remotes: {p.stderr.strip()}")
+    out = p.stdout.strip()
     if not out:
         return {}
     resp = {}
@@ -182,12 +190,14 @@ def get_remotes(wdir: str | None = None) -> dict[str, str]:
     return resp
 
 
-def list_paths(wdir: str = None, recursive=False) -> list[str]:
+def list_paths(wdir: str | None = None, recursive=False) -> list[str]:
     """List paths tracked with DVC."""
-    return [p.get("path") for p in list_files(wdir=wdir, recursive=recursive)]
+    return [
+        p.get("path", "") for p in list_files(wdir=wdir, recursive=recursive)
+    ]
 
 
-def list_files(wdir: str = None, recursive=True) -> list[dict]:
+def list_files(wdir: str | None = None, recursive=True) -> list[dict]:
     """Return a list with all files in DVC, including their path and md5
     checksum.
     """

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/models/pipeline.py

@@ -113,6 +113,7 @@ class Stage(BaseModel):
         "python-script",
         "latex",
         "matlab-script",
+        "matlab-command",
         "docker-command",
         "shell-command",
         "shell-script",
@@ -164,7 +165,9 @@ class Stage(BaseModel):
 
     @property
     def xenv_cmd(self) -> str:
-        return f"calkit xenv -n {self.environment} --no-check"
+        if self.environment == "_system":
+            return ""
+        return f"calkit xenv -n {self.environment} --no-check --"
 
     def to_dvc(self) -> dict:
         """Convert to a DVC stage.
@@ -193,7 +196,7 @@ class PythonScriptStage(Stage):
 
     @property
     def dvc_cmd(self) -> str:
-        cmd = f"{self.xenv_cmd} -- python {self.script_path}"
+        cmd = f"{self.xenv_cmd} python {self.script_path}"
         for arg in self.args:
             cmd += f" {arg}"
         return cmd
@@ -212,7 +215,7 @@ class LatexStage(Stage):
 
     @property
     def dvc_cmd(self) -> str:
-        cmd = f"{self.xenv_cmd} -- latexmk -cd -interaction=nonstopmode"
+        cmd = f"{self.xenv_cmd} latexmk -cd -interaction=nonstopmode"
         if not self.verbose:
             cmd += " -silent"
         if self.force:
@@ -247,7 +250,26 @@ class MatlabScriptStage(Stage):
 
     @property
     def dvc_cmd(self) -> str:
-        return f"{self.xenv_cmd} -- \"run('{self.script_path}');\""
+        cmd = self.xenv_cmd
+        if self.environment == "_system":
+            cmd += "matlab -batch"
+        cmd += f" \"run('{self.script_path}');\""
+        return cmd
+
+
+class MatlabCommandStage(Stage):
+    kind: Literal["matlab-command"] = "matlab-command"
+    command: str
+
+    @property
+    def dvc_cmd(self) -> str:
+        # We need to escape quotes in the command
+        matlab_cmd = self.command.replace('"', '\\"')
+        cmd = self.xenv_cmd
+        if self.environment == "_system":
+            cmd += "matlab -batch"
+        cmd += f' "{matlab_cmd}"'
+        return cmd
 
 
 class ShellCommandStage(Stage):
@@ -257,14 +279,12 @@ class ShellCommandStage(Stage):
 
     @property
     def dvc_cmd(self) -> str:
-        cmd = ""
-        if self.environment != "_system":
-            cmd = f"{self.xenv_cmd} -- "
+        cmd = self.xenv_cmd
         if self.shell == "zsh":
             norc_args = "-f"
         else:
             norc_args = "--noprofile --norc"
-        cmd += f'{self.shell} {norc_args} -c "{self.command}"'
+        cmd += f' {self.shell} {norc_args} -c "{self.command}"'
         return cmd
 
 
@@ -280,14 +300,12 @@ class ShellScriptStage(Stage):
 
     @property
     def dvc_cmd(self) -> str:
-        cmd = ""
-        if self.environment != "_system":
-            cmd = f"{self.xenv_cmd} -- "
+        cmd = self.xenv_cmd
         if self.shell == "zsh":
             norc_args = "-f"
         else:
             norc_args = "--noprofile --norc"
-        cmd += f"{self.shell} {norc_args} {self.script_path}"
+        cmd += f" {self.shell} {norc_args} {self.script_path}"
         for arg in self.args:
             cmd += f" {arg}"
         return cmd
@@ -327,7 +345,7 @@ class JuliaScriptStage(Stage):
 
     @property
     def dvc_cmd(self) -> str:
-        cmd = f'{self.xenv_cmd} -- "include(\\"{self.script_path}\\")"'
+        cmd = f'{self.xenv_cmd} "include(\\"{self.script_path}\\")"'
         return cmd
 
     @property
@@ -343,7 +361,7 @@ class JuliaCommandStage(Stage):
     def dvc_cmd(self) -> str:
         # We need to escape quotes in the command
         julia_cmd = self.command.replace('"', '\\"')
-        cmd = f'{self.xenv_cmd} -- "{julia_cmd}"'
+        cmd = f'{self.xenv_cmd} "{julia_cmd}"'
         return cmd
 
 
@@ -373,6 +391,7 @@ class JupyterNotebookStage(Stage):
     executed_ipynb_storage: Literal["git", "dvc"] | None = "dvc"
     html_storage: Literal["git", "dvc"] | None = "dvc"
     parameters: dict[str, Any] = {}
+    language: Literal["python", "matlab", "julia"] = "python"
 
     def update_parameters(self, params: dict) -> None:
         """If we have any templated parameters, update those, e.g., from
@@ -430,7 +449,10 @@ class JupyterNotebookStage(Stage):
 
     @property
     def dvc_cmd(self) -> str:
-        cmd = f"calkit nb execute --environment {self.environment} --no-check"
+        cmd = (
+            f"calkit nb execute --environment {self.environment} "
+            f"--no-check --language {self.language}"
+        )
         if self.html_storage:
             cmd += " --to html"
         if self.parameters:
@@ -533,6 +555,7 @@ class Pipeline(BaseModel):
                 PythonScriptStage
                 | LatexStage
                 | MatlabScriptStage
+                | MatlabCommandStage
                 | ShellCommandStage
                 | ShellScriptStage
                 | DockerCommandStage

{calkit_python-0.28.3 → calkit_python-0.29.0}/calkit/tests/models/test_pipeline.py

@@ -7,6 +7,7 @@ from calkit.models.pipeline import (
     JuliaCommandStage,
     JupyterNotebookStage,
     LatexStage,
+    MatlabCommandStage,
     PythonScriptStage,
     StageIteration,
     WordToPdfStage,
@@ -131,3 +132,18 @@ def test_juliacommandstage():
     assert sd["cmd"] == (
         'calkit xenv -n j1 --no-check -- "println(\\"sup\\")"'
     )
+
+
+def test_matlabcommandstage():
+    s = MatlabCommandStage(environment="m1", command='disp("Hello, MATLAB!");')
+    sd = s.to_dvc()
+    print(sd)
+    assert sd["cmd"] == (
+        'calkit xenv -n m1 --no-check -- "disp(\\"Hello, MATLAB!\\");"'
+    )
+    s = MatlabCommandStage(
+        environment="_system", command='disp("Hello, MATLAB!");'
+    )
+    sd = s.to_dvc()
+    print(sd)
+    assert sd["cmd"] == 'matlab -batch "disp(\\"Hello, MATLAB!\\");"'

{calkit_python-0.28.3 → calkit_python-0.29.0}/docs/notebooks.md

@@ -322,4 +322,4 @@ pipeline:
         - results/param1={param1}/param2={param2}/results.csv
 ```
 
-For more information, see [pipeline iteration](/pipeline#iteration).
+For more information, see [pipeline iteration](pipeline/index.md#iteration).

{calkit_python-0.28.3 → calkit_python-0.29.0}/docs/quickstart.md

@@ -25,7 +25,7 @@ If you're using Conda for environment management,
 e.g., with an `environment.yml` file,
 you can use the `calkit new conda-env` command.
 
-Next, we can start building our [pipeline](pipeline.md).
+Next, we can start building our [pipeline](pipeline/index.md).
 Let's say we have a Jupyter notebook called `collect-data.ipynb`
 that produces raw data at `data/raw.h5`.
 We can add a pipeline stage to run this notebook in the `main` environment

calkit_python-0.29.0/docs/tutorials/github-actions.md

@@ -0,0 +1,83 @@
+# Running Calkit in GitHub Actions
+
+A project can be set up to automatically run the pipeline every time a
+change is pushed, either to the main branch or on a pull request,
+using GitHub Actions.
+The latter allows for inspection of outputs before merging into main.
+
+To get started, generate a DVC token and set it in your GitHub Actions
+secrets as `CALKIT_DVC_TOKEN`,
+either at your account or project level.
+On calkit.io, there are shortcuts on the project page for managing both
+Calkit tokens and GitHub Actions secrets:
+
+![Project quick actions links](img/quick-actions.png)
+
+![DVC token](img/latex-codespaces/new-token.png)
+
+![Actions repo secrets](img/actions-repo-secrets.png)
+
+Next, add a workflow to the project in the `.github/workflows` folder.
+For example, we can put the content below into `.github/workflows/run.yml`:
+
+```yaml
+name: Run pipeline
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: write
+
+# Make sure we only ever run one per branch so we don't have issues pushing
+# after running the pipeline
+concurrency:
+  group: calkit-run-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  main:
+    name: Run
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # For PRs, checkout the head ref to avoid detached HEAD
+          ref: ${{ github.head_ref || github.ref_name }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Configure Git credentials
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+      - name: Install Calkit
+        run: uv tool install calkit-python
+      - name: Run Calkit
+        uses: calkit/run-action@v1
+        with:
+          dvc_token: ${{ secrets.CALKIT_DVC_TOKEN }}
+```
+
+This particular example installs Calkit with uv,
+meaning `uv` and `uv-venv` environment types will work without any additional
+configuration.
+Docker is also installed by default on the `ubuntu-latest` machine.
+If other environment types are used in the project,
+setup steps may be necessary for those, e.g.,
+[`setup-miniconda`](https://github.com/marketplace/actions/setup-miniconda)
+or [`install-juliaup`](https://github.com/marketplace/actions/install-juliaup).
+
+By default, the Calkit GitHub Action will run the pipeline and save results.
+This is why the workflow needs write permissions and configures Git
+credentials to act as the GitHub Actions bot.
+The workflow also limits concurrency so multiple jobs don't attempt to push
+to the same branch at the same time.
+
+It's possible to configure the action to not save results, e.g., if you
+just want to check that the pipeline can run without errors.
+See the [documentation](https://github.com/marketplace/actions/run-calkit)
+for all available options.

{calkit_python-0.28.3 → calkit_python-0.29.0}/docs/tutorials/index.md

@@ -10,3 +10,4 @@
 - [Adding a new LaTeX-based publication with its own Docker build environment](adding-latex-pub-docker.md)
 - [A reproducible workflow using Microsoft Office (Word and Excel)](office.md)
 - [Using Calkit with MATLAB](matlab.md)
+- [Automation with GitHub Actions](github-actions.md)