calkit-python 0.34.6__tar.gz → 0.35.0__tar.gz

{calkit_python-0.34.6 → calkit_python-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.34.6
+Version: 0.35.0
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -26,8 +26,9 @@ Requires-Dist: arithmeval
 Requires-Dist: bibtexparser
 Requires-Dist: checksumdir
 Requires-Dist: docx2pdf
-Requires-Dist: dvc==3.64.2
+Requires-Dist: dvc==3.66.1
 Requires-Dist: fastapi
+Requires-Dist: fsspec>=2026.2.0
 Requires-Dist: gitpython
 Requires-Dist: json2latex>=0.0.3
 Requires-Dist: jupyterlab>=4.4.5
@@ -47,11 +48,13 @@ Requires-Dist: sqlitedict>=2.1.0
 Requires-Dist: texsoup>=0.3.1
 Requires-Dist: toml>=0.10.2
 Requires-Dist: tqdm>=4.67.1
-Requires-Dist: typer==0.21.1
+Requires-Dist: typer==0.24.1
 Requires-Dist: uvicorn
 Provides-Extra: data
 Requires-Dist: pandas>=2.2.3; extra == 'data'
 Requires-Dist: polars>=1.18.0; extra == 'data'
+Provides-Extra: xet
+Requires-Dist: xet>=0.0.1; extra == 'xet'
 Description-Content-Type: text/markdown
 
 <p align="center">

{calkit_python-0.34.6 → calkit_python-0.35.0}/calkit/__init__.py

@@ -6,6 +6,7 @@ from .core import *  # noqa: F403, I001
 from . import git  # noqa: F401
 from . import dvc  # noqa: F401
 from . import cloud  # noqa: F401
+from . import fs  # noqa: F401
 from . import jupyter  # noqa: F401
 from . import config  # noqa: F401
 from . import models  # noqa: F401
@@ -19,6 +20,7 @@ from . import invenio  # noqa: F401
 from . import releases  # noqa: F401
 from . import licenses  # noqa: F401
 from . import overleaf  # noqa: F401
+from . import julia  # noqa: F401
 from .notebooks import declare_notebook  # noqa: F401
 from .jupyterlab.routes import setup_route_handlers
 

{calkit_python-0.34.6 → calkit_python-0.35.0}/calkit/cli/check.py

@@ -196,13 +196,27 @@ def check_environment(
                 "Julia environments require a path pointing to Project.toml"
             )
         # First ensure the Julia version exists
-        cmd = ["juliaup", "add", julia_version]
-        if verbose:
-            typer.echo(f"Running command: {cmd}")
-        try:
-            subprocess.run(cmd, check=True)
-        except subprocess.CalledProcessError:
-            raise_error(f"Failed to install Julia version {julia_version}")
+        if shutil.which("juliaup") is not None:
+            cmd = ["juliaup", "add", julia_version]
+            if verbose:
+                typer.echo(f"Running command: {cmd}")
+            try:
+                subprocess.run(cmd, check=True)
+            except subprocess.CalledProcessError:
+                raise_error(f"Failed to install Julia version {julia_version}")
+        else:
+            try:
+                compatible = calkit.julia.current_version_is_compatible(
+                    julia_version
+                )
+            except ValueError as e:
+                raise_error(str(e))
+            if not compatible:
+                raise_error(
+                    f"Current Julia version is not compatible with required "
+                    f"version ({julia_version}), and juliaup is not available to "
+                    "install it"
+                )
         env_dir = os.path.dirname(env_path)
         if not env_dir:
             env_dir = "."
@@ -253,6 +267,10 @@ def check_environment(
                 "-e",
                 f"using Pkg; Pkg.add([{pkg_list}]);",
             ]
+            try:
+                cmd = calkit.julia.check_version_in_command(cmd)
+            except Exception as e:
+                raise_error(f"Failed to check Julia version: {e}")
             try:
                 subprocess.check_call(
                     cmd,
@@ -267,6 +285,10 @@ def check_environment(
             "-e",
             "using Pkg; Pkg.instantiate();",
         ]
+        try:
+            cmd = calkit.julia.check_version_in_command(cmd)
+        except Exception as e:
+            raise_error(f"Failed to check Julia version: {e}")
         try:
             subprocess.check_call(
                 cmd, env=os.environ.copy() | {"JULIA_LOAD_PATH": "@:@stdlib"}

{calkit_python-0.34.6 → calkit_python-0.35.0}/calkit/cli/config.py

@@ -113,8 +113,9 @@ def setup_remote_auth():
         remotes = get_remotes()
     except Exception:
         raise_error("Cannot list DVC remotes; check DVC config for errors")
+    ck_remote_name = calkit.config.get_app_name()
     for name, url in remotes.items():
-        if name == "calkit" or name.startswith("calkit:"):
+        if name == ck_remote_name or name.startswith(f"{ck_remote_name}:"):
             typer.echo(f"Setting up authentication for DVC remote: {name}")
             set_remote_auth(remote_name=name)
 

{calkit_python-0.34.6 → calkit_python-0.35.0}/calkit/cli/import_.py

@@ -6,8 +6,6 @@ import base64
 import fnmatch
 import json
 import os
-import subprocess
-import sys
 from copy import deepcopy
 from typing import Annotated
 
@@ -19,6 +17,7 @@ from tqdm import tqdm
 import calkit
 import calkit.invenio
 from calkit.cli import raise_error
+from calkit.dvc import run_dvc_command
 from calkit.models.core import _ImportedFromProject
 
 import_app = typer.Typer(no_args_is_help=True)
@@ -209,7 +208,9 @@ def import_dataset(
     if not no_dvc_pull and dvc_import is not None:
         # Run dvc pull
         typer.echo("Running dvc pull")
-        subprocess.call([sys.executable, "-m", "dvc", "pull", dvc_fpath])
+        result = run_dvc_command(["pull", dvc_fpath])
+        if result != 0:
+            raise_error("Failed to pull from DVC")
 
 
 @import_app.command(name="environment")
@@ -423,10 +424,8 @@ def import_from_zenodo(
     commit_paths = []
     if storage is None:
         if calkit.get_size(dest_dir) > calkit.DVC_SIZE_THRESH_BYTES:
-            res = subprocess.run(
-                [sys.executable, "-m", "dvc", "add"], check=False
-            )
-            if res.returncode != 0:
+            result = run_dvc_command(["add"])
+            if result != 0:
                 raise_error("Failed to DVC add")
             # Git add the .dvc file
             dvc_file = dest_dir + ".dvc"
@@ -436,10 +435,8 @@ def import_from_zenodo(
             repo.git.add(dest_dir)
             commit_paths.append(dest_dir)
     elif storage.lower() == "dvc":
-        res = subprocess.run(
-            [sys.executable, "-m", "dvc", "add", dest_dir], check=False
-        )
-        if res.returncode != 0:
+        result = run_dvc_command(["add", dest_dir])
+        if result != 0:
             raise_error("Failed to DVC add")
         # Git add the .dvc file
         dvc_file = dest_dir + ".dvc"

{calkit_python-0.34.6 → calkit_python-0.35.0}/calkit/cli/main.py

@@ -55,6 +55,7 @@ from calkit.cli.office import office_app
 from calkit.cli.overleaf import overleaf_app
 from calkit.cli.slurm import slurm_app
 from calkit.cli.update import update_app
+from calkit.dvc import register_ck_scheme, run_dvc_command
 from calkit.environments import get_env_lock_fpath
 from calkit.models import Procedure
 
@@ -125,14 +126,13 @@ def init(
 ):
     """Initialize the current working directory."""
     subprocess.run(["git", "init"])
-    dvc_cmd = [sys.executable, "-m", "dvc", "init"]
-    if force:
-        dvc_cmd.append("-f")
-    subprocess.run(dvc_cmd)
+    result = run_dvc_command(["init"] + (["--force"] if force else []))
+    if result != 0:
+        raise_error("Failed to initialize DVC")
     # Ensure autostage is enabled for DVC
-    subprocess.call(
-        [sys.executable, "-m", "dvc", "config", "core.autostage", "true"]
-    )
+    result = run_dvc_command(["config", "core.autostage", "true"])
+    if result != 0:
+        raise_error("Failed to configure DVC autostage")
     # Commit the newly created .dvc directory
     repo = git.Repo()
     repo.git.add(".dvc")
@@ -220,13 +220,24 @@ def clone(
     # DVC pull
     if not no_dvc_pull:
         try:
-            subprocess.check_call([sys.executable, "-m", "dvc", "pull"])
-        except subprocess.CalledProcessError:
-            raise_error("Failed to pull from DVC remote(s)")
+            result = run_dvc_command(["pull"])
+            if result != 0:
+                raise_error("Failed to pull from DVC remote(s)")
+        except Exception as e:
+            raise_error(f"Failed to pull from DVC remote(s): {e}")
 
 
 @app.command(name="status")
 def get_status(
+    targets: Annotated[
+        list[str] | None,
+        typer.Argument(
+            help=(
+                "Optional targets to check status for. These may be "
+                "pipeline stage names or repo paths."
+            ),
+        ),
+    ] = None,
     categories: Annotated[
         list[str] | None,
         typer.Option(
@@ -282,15 +293,24 @@ def get_status(
         typer.echo()
     if "git" in categories:
         print_sep("Git")
-        run_cmd(["git", "status"])
+        git_cmd = ["git", "status"]
+        if targets:
+            git_cmd += ["--"] + targets
+        run_cmd(git_cmd)
         typer.echo()
     if "dvc" in categories:
         print_sep("DVC")
-        run_cmd([sys.executable, "-m", "dvc", "data", "status"])
+        dvc_data_cmd = ["data", "status"]
+        if targets:
+            dvc_data_cmd += targets
+        run_dvc_command(dvc_data_cmd)
         typer.echo()
     if "pipeline" in categories or "dvc" in categories:
         print_sep("Pipeline")
-        run_cmd([sys.executable, "-m", "dvc", "status"])
+        dvc_pipeline_cmd = ["status"]
+        if targets:
+            dvc_pipeline_cmd += targets
+        run_dvc_command(dvc_pipeline_cmd)
 
 
 @app.command(name="diff")
@@ -309,7 +329,7 @@ def diff(
         git_cmd.append("--staged")
     run_cmd(git_cmd)
     print_sep("Pipeline (DVC)")
-    run_cmd([sys.executable, "-m", "dvc", "diff"])
+    run_dvc_command(["diff"])
 
 
 @app.command(name="add")
@@ -383,13 +403,18 @@ def add(
             raise_error("Not currently in a Git repo; run `calkit init` first")
         repo = git.Repo()
     try:
+        register_ck_scheme()
         dvc_repo = dvc.repo.Repo()
     except NotDvcRepoError:
         warn("DVC not initialized yet; initializing")
         dvc_repo = dvc.repo.Repo.init()
     # Ensure autostage is enabled for DVC
-    subprocess.call(
-        [sys.executable, "-m", "dvc", "config", "core.autostage", "true"]
+    run_dvc_command(
+        [
+            "config",
+            "core.autostage",
+            "true",
+        ]
     )
     subprocess.call(["git", "add", ".dvc/config"])
     dvc_paths = calkit.dvc.list_paths()
@@ -404,7 +429,7 @@ def add(
         if to == "git":
             subprocess.call(["git", "add"] + paths)
         elif to == "dvc":
-            subprocess.call([sys.executable, "-m", "dvc", "add"] + paths)
+            run_dvc_command(["add"] + paths)
         else:
             raise_error(f"Invalid option for 'to': {to}")
     else:
@@ -465,15 +490,15 @@ def add(
                 typer.echo(
                     f"Adding {path} to DVC since it's already tracked with DVC"
                 )
-                subprocess.call([sys.executable, "-m", "dvc", "add", path])
+                run_dvc_command(["add", path])
             elif os.path.splitext(path)[-1] in DVC_EXTENSIONS:
                 typer.echo(f"Adding {path} to DVC per its extension")
-                subprocess.call([sys.executable, "-m", "dvc", "add", path])
+                run_dvc_command(["add", path])
             elif calkit.get_size(path) > DVC_SIZE_THRESH_BYTES:
                 typer.echo(
                     f"Adding {path} to DVC since it's greater than 1 MB"
                 )
-                subprocess.call([sys.executable, "-m", "dvc", "add", path])
+                run_dvc_command(["add", path])
             else:
                 typer.echo(f"Adding {path} to Git")
                 subprocess.call(["git", "add", path])
@@ -694,13 +719,15 @@ def pull(
     if not no_check_auth:
         # Check that our dvc remotes all have our DVC token set for them
         remotes = calkit.dvc.get_remotes()
+        ck_remote_name = calkit.config.get_app_name()
         for name, url in remotes.items():
-            if name == "calkit" or name.startswith("calkit:"):
+            if (
+                name == ck_remote_name or name.startswith(f"{ck_remote_name}:")
+            ) and url.startswith("http"):
                 typer.echo(f"Checking authentication for DVC remote: {name}")
                 calkit.dvc.set_remote_auth(remote_name=name)
-    try:
-        subprocess.check_call([sys.executable, "-m", "dvc", "pull"] + dvc_args)
-    except subprocess.CalledProcessError:
+    result = run_dvc_command(["pull"] + dvc_args)
+    if result != 0:
         raise_error("DVC pull failed")
 
 
@@ -734,17 +761,18 @@ def push(
         if not no_check_auth:
             # Check that our dvc remotes all have our DVC token set for them
             remotes = calkit.dvc.get_remotes()
+            ck_remote_name = calkit.config.get_app_name()
             for name, url in remotes.items():
-                if name == "calkit" or name.startswith("calkit:"):
+                if (
+                    name == ck_remote_name
+                    or name.startswith(f"{ck_remote_name}:")
+                ) and url.startswith("http"):
                     typer.echo(
                         f"Checking authentication for DVC remote: {name}"
                     )
                     calkit.dvc.set_remote_auth(remote_name=name)
-        try:
-            subprocess.check_call(
-                [sys.executable, "-m", "dvc", "push"] + dvc_args
-            )
-        except subprocess.CalledProcessError:
+        result = run_dvc_command(["push"] + dvc_args)
+        if result != 0:
             raise_error("DVC push failed")
 
 
@@ -1109,12 +1137,16 @@ def run(
             os.environ.pop("CALKIT_PIPELINE_RUNNING", None)
             raise_error(f"Pipeline compilation failed: {e}")
     # Initialize DVC repo if necessary
+    # Register the ck:// scheme before accessing DVC repo
+    register_ck_scheme()
     try:
         dvc.repo.Repo()
     except Exception:
         if not quiet:
             typer.echo("Initializing DVC repo")
-        dvc.repo.Repo.init()
+        result = run_dvc_command(["init"])
+        if result != 0:
+            raise_error("Failed to initialize DVC repo")
     # Convert deps into target stage names
     # TODO: This could probably be merged back upstream into DVC
     if dvc_stages is None:
@@ -1169,6 +1201,7 @@ def run(
         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
+        register_ck_scheme()
         dvc_repo = dvc.repo.Repo()
         dvc_status_before = dvc_repo.status()
         dvc_data_status_before = dvc_repo.data_status()
@@ -1616,11 +1649,18 @@ def run_in_env(
         # calling julia
         if cmd[0] == "julia":
             cmd = cmd[1:]
+        # If there are any --project= args, remove them since we are already
+        # specifying the project
+        cmd = [arg for arg in cmd if not arg.startswith("--project=")]
         julia_cmd = [
             "julia",
             f"+{julia_version}",
             "--project=" + env_dir,
         ] + cmd
+        try:
+            julia_cmd = calkit.julia.check_version_in_command(julia_cmd)
+        except Exception as e:
+            raise_error(f"Failed to check Julia version: {e}")
         if verbose:
             typer.echo(f"Running command: {julia_cmd}")
         try:
@@ -2592,8 +2632,8 @@ def call_dvc(
     Useful if Calkit is installed as a tool, e.g., with `uv tool` or `pipx`,
     and DVC is not installed.
     """
-    process = subprocess.run([sys.executable, "-m", "dvc"] + sys.argv[2:])
-    sys.exit(process.returncode)
+    result = run_dvc_command(sys.argv[2:])
+    sys.exit(result)
 
 
 @app.command(

{calkit_python-0.34.6 → calkit_python-0.35.0}/calkit/cli/new.py

@@ -7,7 +7,6 @@ import os
 import pathlib
 import shutil
 import subprocess
-import sys
 import zipfile
 from enum import Enum
 
@@ -23,6 +22,7 @@ from calkit.cli.check import check_environment
 from calkit.cli.update import update_devcontainer
 from calkit.core import ryaml
 from calkit.docker import LAYERS
+from calkit.dvc import run_dvc_command
 from calkit.environments import DEFAULT_PYTHON_VERSION
 from calkit.models.pipeline import LatexStage, StageIteration
 
@@ -141,15 +141,14 @@ def new_project(
         if not os.path.isfile(os.path.join(abs_path, ".dvc", "config")):
             typer.echo("Initializing DVC repository")
             try:
-                subprocess.run(
-                    [sys.executable, "-m", "dvc", "init", "-q"],
+                result = run_dvc_command(
+                    ["init", "-q"],
                     cwd=abs_path,
-                    capture_output=True,
-                    check=True,
-                    text=True,
                 )
+                if result != 0:
+                    raise subprocess.CalledProcessError(result, "dvc init")
             except subprocess.CalledProcessError as e:
-                raise_error(f"Failed to initialize DVC repository: {e.stderr}")
+                raise_error(f"Failed to initialize DVC repository: {e}")
             # Commit the DVC init changes
             if not no_commit:
                 repo.git.add(".dvc")
@@ -330,18 +329,12 @@ def new_project(
                 "You will need to manually run `git remote add origin` "
                 "and `calkit config remote`"
             )
-            subprocess.call(
-                [
-                    sys.executable,
-                    "-m",
-                    "dvc",
-                    "remote",
-                    "remove",
-                    "calkit",
-                    "-q",
-                ],
+            result = run_dvc_command(
+                ["remote", "remove", "calkit", "-q"],
                 cwd=abs_path,
             )
+            if result != 0:
+                warn("Failed to remove DVC remote")
         try:
             calkit.dvc.set_remote_auth(wdir=abs_path)
         except Exception:
@@ -361,9 +354,12 @@ def new_project(
     repo = git.Repo(abs_path)
     if not os.path.isfile(os.path.join(abs_path, ".dvc", "config")):
         typer.echo("Initializing DVC repository")
-        subprocess.run(
-            [sys.executable, "-m", "dvc", "init", "-q"], cwd=abs_path
+        result = run_dvc_command(
+            ["init", "-q"],
+            cwd=abs_path,
         )
+        if result != 0:
+            raise_error("Failed to initialize DVC repository")
     # Create calkit.yaml file
     ck_info = calkit.load_calkit_info(wdir=abs_path)
     ck_info = dict(name=name, title=title, description=description) | ck_info
@@ -493,13 +489,20 @@ def new_figure(
         outs_cmd = []
         for out in outs:
             outs_cmd += ["-o", out]
-        subprocess.check_call(
-            [sys.executable, "-m", "dvc", "stage", "add", "-n", stage_name]
+        result = run_dvc_command(
+            [
+                "stage",
+                "add",
+                "-n",
+                stage_name,
+            ]
             + (["-f"] if overwrite else [])
             + deps_cmd
             + outs_cmd
             + [cmd]
         )
+        if result != 0:
+            raise_error(f"Failed to add figure {obj}")
     figures.append(obj)
     ck_info["figures"] = figures
     with open("calkit.yaml", "w") as f:
@@ -910,13 +913,20 @@ def new_dataset(
         outs_cmd = []
         for out in outs:
             outs_cmd += ["-o", out]
-        subprocess.check_call(
-            [sys.executable, "-m", "dvc", "stage", "add", "-n", stage_name]
+        result = run_dvc_command(
+            [
+                "stage",
+                "add",
+                "-n",
+                stage_name,
+            ]
             + (["-f"] if overwrite else [])
             + deps_cmd
             + outs_cmd
             + [cmd]
         )
+        if result != 0:
+            raise_error(f"Failed to add dataset {obj}")
     datasets.append(obj)
     ck_info["datasets"] = datasets
     with open("calkit.yaml", "w") as f:
@@ -2977,144 +2987,3 @@ def new_release(
             # TODO: Upload assets for GitHub release if they're not too big?
     typer.echo(f"New {release_type} release {name} successfully created")
     return release
-
-
-@new_app.command(name="stage")
-def new_stage(
-    name: StageArgs.name,
-    kind: Annotated[
-        StageKind, typer.Option("--kind", help="What kind of stage to create.")
-    ],
-    target: Annotated[
-        str,
-        typer.Option(
-            "--target", "-t", help="Target file, e.g., the script to run."
-        ),
-    ],
-    environment: Annotated[
-        str | None,
-        typer.Option(
-            "--environment", "-e", help="Environment to use to run the stage."
-        ),
-    ] = None,
-    deps: Annotated[
-        list[str],
-        typer.Option("--dep", "-d", help="A path on which the stage depends."),
-    ] = [],
-    outs: Annotated[
-        list[str],
-        typer.Option(
-            "--out", "-o", help="A path that is produced by the stage."
-        ),
-    ] = [],
-    outs_persist: Annotated[
-        list[str],
-        typer.Option(
-            "--out-persist",
-            help="An output that should not be deleted before running.",
-        ),
-    ] = [],
-    outs_no_cache: Annotated[
-        list[str],
-        typer.Option(
-            "--out-git",
-            help="An output that should be tracked with Git instead of DVC.",
-        ),
-    ] = [],
-    outs_persist_no_cache: Annotated[
-        list[str],
-        typer.Option(
-            "--out-git-persist",
-            help=(
-                "An output that should be tracked with Git instead of DVC, "
-                "and also should not be deleted before running stage."
-            ),
-        ),
-    ] = [],
-    overwrite: Annotated[
-        bool,
-        typer.Option(
-            "--overwrite",
-            "--force",
-            "-f",
-            help="Overwrite an existing stage with this name if necessary.",
-        ),
-    ] = False,
-    no_check: Annotated[
-        bool,
-        typer.Option(
-            "--no-check",
-            help="Do not check if the target, deps, environment, etc., exist.",
-        ),
-    ] = False,
-    no_commit: Annotated[
-        bool, typer.Option("--no-commit", help="Do not commit changes to Git.")
-    ] = False,
-):
-    """Create a new DVC pipeline stage (deprecated)."""
-    ck_info = calkit.load_calkit_info(process_includes="environments")
-    environments = ck_info.get("environments", {})
-    if environment is None:
-        warn("No environment is specified")
-        cmd = ""
-    else:
-        if environment not in environments and not no_check:
-            raise_error(f"Environment '{environment}' does not exist")
-        cmd = f"calkit xenv -n {environment} -- "
-        # Add environment path as a dependency if applicable
-        env_path = environments.get(environment, {}).get("path")
-        if env_path is not None and env_path not in deps:
-            deps = [env_path] + deps
-    if not os.path.exists(target) and not no_check:
-        raise_error(f"Target '{target}' does not exist")
-    if kind.value == "python-script":
-        cmd += f"python {target}"
-    elif kind.value == "latex":
-        cmd = f"calkit latex build {target}"
-        if environment is not None:
-            cmd += f" --environment {environment}"
-        out_target = target.removesuffix(".tex") + ".pdf"
-        if out_target not in (
-            outs + outs_no_cache + outs_persist + outs_persist_no_cache
-        ):
-            outs = [out_target] + outs
-    elif kind.value == "matlab-script":
-        cmd += f"matlab -noFigureWindows -batch \"run('{target}');\""
-    elif kind.value == "sh-script":
-        cmd += f"sh {target}"
-    elif kind.value == "bash-script":
-        cmd += f"bash {target}"
-    elif kind.value == "zsh-script":
-        cmd += f"zsh {target}"
-    elif kind.value == "r-script":
-        cmd += f"Rscript {target}"
-    add_cmd = [sys.executable, "-m", "dvc", "stage", "add", "-n", name]
-    if target not in deps:
-        deps = [target] + deps
-    for dep in deps:
-        add_cmd += ["-d", dep]
-    for out in outs:
-        add_cmd += ["-o", out]
-    for out in outs_no_cache:
-        add_cmd += ["--outs-no-cache", out]
-    for out in outs_persist:
-        add_cmd += ["--outs-persist", out]
-    for out in outs_persist_no_cache:
-        add_cmd += ["--outs-persist-no-cache", out]
-    if overwrite:
-        add_cmd.append("-f")
-    add_cmd.append(cmd)
-    try:
-        subprocess.check_call(add_cmd)
-    except subprocess.CalledProcessError:
-        raise_error("Failed to create stage")
-    if not no_commit:
-        try:
-            repo = git.Repo()
-        except InvalidGitRepositoryError:
-            raise_error("Can't commit because this is not a Git repo")
-        repo.git.add("dvc.yaml")
-        if "dvc.yaml" in calkit.git.get_staged_files():
-            repo.git.commit(
-                ["dvc.yaml", "-m", f"Add {kind.value} pipeline stage '{name}'"]
-            )