calkit-python 0.41.22__py3-none-any.whl → 0.41.24__py3-none-any.whl

calkit/cli/main/core.py

@@ -59,6 +59,7 @@ from calkit.cli.notebooks import notebooks_app
 from calkit.cli.office import office_app
 from calkit.cli.overleaf import overleaf_app
 from calkit.cli.scheduler import scheduler_app
+from calkit.cli.sync import sync_app
 from calkit.cli.update import update_app
 
 app = typer.Typer(
@@ -89,6 +90,7 @@ app.add_typer(
     help="Work with a job scheduler (SLURM or PBS).",
 )
 app.add_typer(dev_app, name="dev", help="Developer tools.", hidden=True)
+app.add_typer(sync_app, name="sync", help="Sync with external systems.")
 
 
 def _to_shell_cmd(cmd: list[str]) -> str:
@@ -1157,6 +1159,12 @@ def save(
 @app.command(name="pull")
 def pull(
     no_check_auth: Annotated[bool, typer.Option("--no-check-auth")] = False,
+    no_dvc: Annotated[
+        bool, typer.Option("--no-dvc", help="Do not pull from DVC.")
+    ] = False,
+    no_git: Annotated[
+        bool, typer.Option("--no-git", help="Do not pull from Git.")
+    ] = False,
     git_args: Annotated[
         list[str],
         typer.Option("--git-arg", help="Additional Git args."),
@@ -1181,58 +1189,62 @@ def pull(
     ] = False,
 ):
     """Pull with both Git and DVC."""
-    typer.echo("Git pulling")
     if force:
         if "-f" not in git_args and "--force" not in git_args:
             git_args.append("-f")
         if "-f" not in dvc_args and "--force" not in dvc_args:
             dvc_args.append("-f")
-    try:
-        git_cmd = ["git", "pull"]
-        if not no_recursive and "--recurse-submodules" not in git_args:
-            git_cmd.append("--recurse-submodules")
-        subprocess.check_call(git_cmd + git_args)
-    except subprocess.CalledProcessError:
-        raise_error("Git pull failed")
-    typer.echo("DVC pulling")
-    if not no_check_auth:
-        # Check that our dvc remotes all have our DVC token set for them
-        remotes = calkit.dvc.get_remotes()
-        for name, url in remotes.items():
-            if calkit.dvc.detect_calkit_remote_type(name, url) == "http":
-                typer.echo(f"Checking authentication for DVC remote: {name}")
-                calkit.dvc.set_remote_auth(remote_name=name)
-    if (
-        not no_recursive
-        and "--recursive" not in dvc_args
-        and "-R" not in dvc_args
-    ):
-        dvc_args.append("--recursive")
-    result = calkit.dvc.run_dvc_command(
-        ["pull"] + dvc_args,
-        lock_timeout=calkit.dvc.DEFAULT_RUN_LOCK_TIMEOUT,
-    )
-    if result != 0:
-        raise_error("DVC pull failed")
-    calkit.dvc.zip.sync_all(direction="to-workspace")
-    if not no_recursive:
-        # Pull DVC in isolated subprojects (those with their own .dvc folder)
-        ck_info = calkit.load_calkit_info()
-        for sp in ck_info.get("subprojects", []):
-            if not isinstance(sp, dict) or not sp.get("path"):
-                continue
-            sp_path = sp["path"]
-            if not os.path.isdir(os.path.join(sp_path, ".dvc")):
-                continue
-            typer.echo(f"DVC pulling subproject: {sp_path}")
-            sp_result = calkit.dvc.run_dvc_command(
-                ["pull"] + dvc_args,
-                cwd=sp_path,
-                lock_timeout=calkit.dvc.DEFAULT_RUN_LOCK_TIMEOUT,
-            )
-            if sp_result != 0:
-                raise_error(f"DVC pull failed for subproject: {sp_path}")
-            calkit.dvc.zip.sync_all(direction="to-workspace", wdir=sp_path)
+    if not no_git:
+        typer.echo("Git pulling")
+        try:
+            git_cmd = ["git", "pull"]
+            if not no_recursive and "--recurse-submodules" not in git_args:
+                git_cmd.append("--recurse-submodules")
+            subprocess.check_call(git_cmd + git_args)
+        except subprocess.CalledProcessError:
+            raise_error("Git pull failed")
+    if not no_dvc:
+        typer.echo("DVC pulling")
+        if not no_check_auth:
+            # Check that our dvc remotes all have our DVC token set for them
+            remotes = calkit.dvc.get_remotes()
+            for name, url in remotes.items():
+                if calkit.dvc.detect_calkit_remote_type(name, url) == "http":
+                    typer.echo(
+                        f"Checking authentication for DVC remote: {name}"
+                    )
+                    calkit.dvc.set_remote_auth(remote_name=name)
+        if (
+            not no_recursive
+            and "--recursive" not in dvc_args
+            and "-R" not in dvc_args
+        ):
+            dvc_args.append("--recursive")
+        result = calkit.dvc.run_dvc_command(
+            ["pull"] + dvc_args,
+            lock_timeout=calkit.dvc.DEFAULT_RUN_LOCK_TIMEOUT,
+        )
+        if result != 0:
+            raise_error("DVC pull failed")
+        calkit.dvc.zip.sync_all(direction="to-workspace")
+        if not no_recursive:
+            # Pull DVC in isolated subprojects (those with their own .dvc folder)
+            ck_info = calkit.load_calkit_info()
+            for sp in ck_info.get("subprojects", []):
+                if not isinstance(sp, dict) or not sp.get("path"):
+                    continue
+                sp_path = sp["path"]
+                if not os.path.isdir(os.path.join(sp_path, ".dvc")):
+                    continue
+                typer.echo(f"DVC pulling subproject: {sp_path}")
+                sp_result = calkit.dvc.run_dvc_command(
+                    ["pull"] + dvc_args,
+                    cwd=sp_path,
+                    lock_timeout=calkit.dvc.DEFAULT_RUN_LOCK_TIMEOUT,
+                )
+                if sp_result != 0:
+                    raise_error(f"DVC pull failed in subproject: {sp_path}")
+                calkit.dvc.zip.sync_all(direction="to-workspace", wdir=sp_path)
 
 
 @app.command(name="push")
@@ -1284,16 +1296,6 @@ def push(
             raise_error("Git push failed")
 
 
-@app.command(name="sync")
-def sync(
-    no_check_auth: Annotated[bool, typer.Option("--no-check-auth")] = False,
-):
-    """Sync the project repo by pulling and then pushing."""
-    # TODO: Walk users through merge conflicts if they arise
-    pull(no_check_auth=no_check_auth)
-    push(no_check_auth=no_check_auth)
-
-
 @app.command(name="ignore")
 def ignore(
     path: Annotated[str, typer.Argument(help="Path to ignore.")],
@@ -1685,6 +1687,29 @@ def _concurrent_scheduler_prepass(
                 )
 
 
+def _get_subproject_targets_for_run(
+    subproject_path: str,
+    targets: list[str] | None,
+    include_dvc_yaml_targets: bool = False,
+) -> tuple[bool, list[str] | None]:
+    """Return whether and which subproject stages a run target selects."""
+    if not targets:
+        return True, None
+    sp = Path(subproject_path).as_posix()
+    target_prefixes = {sp, Path(sp).name}
+    if include_dvc_yaml_targets:
+        target_prefixes.add(f"{sp}/dvc.yaml")
+    selected_stages = []
+    for target in targets:
+        target_prefix, separator, stage_name = target.partition(":")
+        if target_prefix not in target_prefixes:
+            continue
+        if not separator or not stage_name:
+            return True, None
+        selected_stages.append(stage_name)
+    return bool(selected_stages), selected_stages or None
+
+
 @app.command(name="run")
 def run(
     targets: Annotated[
@@ -1942,6 +1967,18 @@ def run(
             sp = Path(subproject["path"]).as_posix()
             if not os.path.isdir(sp):
                 continue
+            if single_item:
+                sp_selected, sp_targets = _get_subproject_targets_for_run(
+                    subproject_path=sp,
+                    targets=targets,
+                    include_dvc_yaml_targets=not os.path.isdir(
+                        os.path.join(sp, ".dvc")
+                    ),
+                )
+                if not sp_selected:
+                    continue
+            else:
+                sp_targets = None
             os.chdir(sp)
             try:
                 sp_ck_info = calkit.load_calkit_info()
@@ -1950,7 +1987,7 @@ def run(
                         f"📦 Checking environments for subproject: {sp}"
                     )
                 sp_env_results = calkit.environments.check_all_in_pipeline(
-                    ck_info=sp_ck_info, force=force
+                    ck_info=sp_ck_info, targets=sp_targets, force=force
                 )
                 for env_name, sp_result in sp_env_results.items():
                     if verbose:
@@ -2181,7 +2218,7 @@ def run(
     file_handler.setFormatter(formatter)
     dvc.log.logger.addHandler(file_handler)
     # Remove newline logging in dvc.repo.reproduce
-    dvc.repo.reproduce.logger.setLevel(logging.ERROR)
+    dvc.repo.reproduce.logger.setLevel(logging.WARNING)
     # Disable other misc DVC output
     dvc.ui.ui.write = lambda *args, **kwargs: None
     # Tell `calkit scheduler batch` to resubmit completed jobs under --force;

calkit/cli/overleaf.py

@@ -13,9 +13,24 @@ from typing_extensions import Annotated
 
 import calkit
 from calkit.cli import AliasGroup, raise_error, warn
+from calkit.cli.sync import sync_app
 
 overleaf_app = typer.Typer(cls=AliasGroup, no_args_is_help=True)
 
+# Shown when a pull from Overleaf fails, most commonly due to an invalid or
+# expired token. Calkit authenticates only with the token in its config, but a
+# stale token cached by the OS credential manager from an earlier version can
+# still interfere, so we point users there as a fallback.
+PULL_FAILED_MESSAGE = (
+    "Failed to pull from Overleaf; "
+    "check that your Overleaf token is valid\n"
+    "Run 'calkit config get overleaf_token' and ensure that it matches one in "
+    "your Overleaf account settings (https://overleaf.com/user/settings).\n"
+    "If it looks correct but pulling still fails, delete any saved "
+    "'git.overleaf.com' credential from your OS credential manager (Windows "
+    "Credential Manager, macOS Keychain, or your Linux keyring) and try again."
+)
+
 
 def _extract_title_from_tex(tex_file_path: str) -> str | None:
     """Extract the title from a LaTeX file."""
@@ -169,8 +184,6 @@ def import_publication(
     ] = False,
 ):
     """Import a publication from an Overleaf project."""
-    import git
-
     from calkit.cli.main import ignore as git_ignore
     from calkit.cli.new import new_latex_stage
 
@@ -202,16 +215,13 @@ def import_publication(
     overleaf_dir = os.path.join(".calkit", "overleaf")
     os.makedirs(overleaf_dir, exist_ok=True)
     git_ignore(overleaf_dir, no_commit=no_commit)
-    overleaf_project_dir = os.path.join(overleaf_dir, overleaf_project_id)
-    git_clone_url = calkit.overleaf.get_git_remote_url(
-        project_id=overleaf_project_id, token=overleaf_token
-    )
+    overleaf_project_dir = calkit.overleaf.get_project_dir(overleaf_project_id)
     if os.path.isdir(overleaf_project_dir):
         warn("This Overleaf project has already been cloned; removing")
         shutil.rmtree(overleaf_project_dir)
     # Clone the Overleaf project
     typer.echo("Cloning Overleaf project")
-    git.Repo.clone_from(git_clone_url, overleaf_project_dir)
+    calkit.overleaf.clone(overleaf_project_id, overleaf_token)
     # Detect target path if not specified
     if target_path is None:
         ol_contents = os.listdir(
@@ -353,6 +363,7 @@ def import_publication(
     sync(paths=[dest_dir], no_commit=no_commit, push_only=push_only)
 
 
+@sync_app.command(name="overleaf")
 @overleaf_app.command(name="sync")
 def sync(
     paths: Annotated[
@@ -428,8 +439,6 @@ def sync(
     ] = False,
 ):
     """Sync folders with Overleaf."""
-    import git
-
     # TODO: We should probably ensure the pipeline isn't stale
     # Read all synced folders, fixing legacy schema if applicable
     overleaf_info = calkit.overleaf.get_sync_info(fix_legacy=True)
@@ -504,32 +513,15 @@ def sync(
                     "or use --auto-commit/-a to automatically commit them."
                 )
         # Ensure we've cloned the Overleaf project
-        overleaf_project_dir = os.path.join(
-            ".calkit", "overleaf", overleaf_project_id
+        overleaf_repo = calkit.overleaf.get_repo(
+            overleaf_project_id, str(overleaf_token)
         )
-        overleaf_remote_url = calkit.overleaf.get_git_remote_url(
-            project_id=overleaf_project_id, token=str(overleaf_token)
-        )
-        if not os.path.isdir(overleaf_project_dir):
-            overleaf_repo = git.Repo.clone_from(
-                overleaf_remote_url, to_path=overleaf_project_dir
-            )
-        else:
-            overleaf_repo = calkit.git.get_repo(overleaf_project_dir)
         # Pull the latest version in the Overleaf project
         typer.echo("Pulling the latest version from Overleaf")
-        # Ensure that our current Overleaf remote URL is correct
-        overleaf_repo.git.remote("set-url", "origin", overleaf_remote_url)
         try:
             overleaf_repo.git.pull()
         except Exception:
-            raise_error(
-                "Failed to pull from Overleaf; "
-                "check that your Overleaf token is valid\n"
-                "Run 'calkit config get overleaf_token' and ensure that "
-                "it matches one in your Overleaf account settings "
-                "(https://overleaf.com/user/settings)"
-            )
+            raise_error(PULL_FAILED_MESSAGE)
         if resolve:
             last_sync_commit = resolving_info["last_overleaf_commit"]
         else:
@@ -608,8 +600,6 @@ def get_status(
     ] = None,
 ):
     """Check the status of folders synced with Overleaf in a project."""
-    import git
-
     # Read all synced folders, fixing legacy schema if applicable
     overleaf_info = calkit.overleaf.get_sync_info(fix_legacy=False)
     if not overleaf_info:
@@ -642,32 +632,18 @@ def get_status(
         )
         wdir = path_in_project
         # Ensure we've cloned the Overleaf project
-        overleaf_project_dir = os.path.join(
-            ".calkit", "overleaf", overleaf_project_id
+        overleaf_project_dir = calkit.overleaf.get_project_dir(
+            overleaf_project_id
         )
-        overleaf_remote_url = calkit.overleaf.get_git_remote_url(
-            project_id=overleaf_project_id, token=str(overleaf_token)
+        overleaf_repo = calkit.overleaf.get_repo(
+            overleaf_project_id, str(overleaf_token)
         )
-        if not os.path.isdir(overleaf_project_dir):
-            overleaf_repo = git.Repo.clone_from(
-                overleaf_remote_url, to_path=overleaf_project_dir
-            )
-        else:
-            overleaf_repo = calkit.git.get_repo(overleaf_project_dir)
         # Pull the latest version in the Overleaf project
         typer.echo("Pulling the latest version from Overleaf")
-        # Ensure that our current Overleaf remote URL is correct
-        overleaf_repo.git.remote("set-url", "origin", overleaf_remote_url)
         try:
             overleaf_repo.git.pull()
         except Exception:
-            raise_error(
-                "Failed to pull from Overleaf; "
-                "check that your Overleaf token is valid\n"
-                "Run 'calkit config get overleaf_token' and ensure that "
-                "it matches one in your Overleaf account settings "
-                "(https://overleaf.com/user/settings)"
-            )
+            raise_error(PULL_FAILED_MESSAGE)
         last_sync_commit = sync_data.get("last_sync_commit")
         if last_sync_commit:
             commits_since = calkit.overleaf.get_commits_since_last_sync(

calkit/cli/sync.py

@@ -0,0 +1,80 @@
+"""CLI for syncing."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+import typer
+from typing_extensions import Annotated
+
+import calkit
+from calkit.cli import AliasGroup, raise_error
+
+sync_app = typer.Typer(cls=AliasGroup, no_args_is_help=True)
+
+
+@sync_app.command(name="git")
+def sync_git(
+    no_check_auth: Annotated[bool, typer.Option("--no-check-auth")] = False,
+) -> None:
+    """Sync the Git repository by pulling and then pushing."""
+    from calkit.cli.main.core import pull, push
+
+    try:
+        repo = calkit.git.get_repo()
+    except Exception:
+        raise_error("No Git repository found. Run 'git init' first.")
+    if not repo.remotes:
+        raise_error(
+            "No Git remotes configured. Add a remote with "
+            "'git remote add <name> <url>'."
+        )
+    pull(no_dvc=True, no_check_auth=no_check_auth)
+    push(no_dvc=True, no_check_auth=no_check_auth)
+
+
+@sync_app.command(name="dvc")
+def sync_dvc(
+    no_check_auth: Annotated[bool, typer.Option("--no-check-auth")] = False,
+) -> None:
+    """Sync the DVC repository by pulling and then pushing."""
+    from calkit.cli.main.core import pull, push
+
+    try:
+        calkit.dvc.get_dvc_repo()
+    except Exception:
+        raise_error("No DVC repository found. Run 'calkit init' first.")
+    if not calkit.dvc.get_remotes():
+        raise_error(
+            "No DVC remotes configured. Add a remote with "
+            "'dvc remote add <name> <url>'."
+        )
+    pull(no_git=True, no_check_auth=no_check_auth)
+    push(no_git=True, no_check_auth=no_check_auth)
+
+
+@sync_app.command(name="all")
+def sync_all() -> None:
+    """Sync all registered systems."""
+    from calkit.cli.overleaf import sync as overleaf_sync
+
+    # Run each known target in a stable order, reporting and collecting any
+    # failures. Each target is responsible for raising a clear error if it is
+    # not configured, so users calling 'calkit sync <target>' directly get a
+    # helpful message.
+    sync_funcs: list[tuple[str, Callable[[], None]]] = [
+        ("git", sync_git),
+        ("dvc", sync_dvc),
+        ("overleaf", overleaf_sync),
+    ]
+    failures = []
+    for target_name, sync_func in sync_funcs:
+        typer.echo(f"Syncing {target_name}...")
+        try:
+            sync_func()
+        except Exception as e:
+            typer.echo(f"Failed to sync {target_name}: {e}", err=True)
+            failures.append(target_name)
+    # Exit with an error if any target failed so callers can react.
+    if failures:
+        raise typer.Exit(1)

calkit/overleaf.py

@@ -30,6 +30,69 @@ def get_git_remote_url(project_id: str, token: str) -> str:
     return f"https://git:{token}@git.overleaf.com/{project_id}"
 
 
+# Git config options that force authentication to use only the token embedded
+# in the Overleaf remote URL, never a credential saved in the operating
+# system's credential store (macOS Keychain, Windows Credential Manager, etc.).
+# An expired token can linger in that store and shadow a freshly set one, which
+# otherwise makes it impossible to recover a project after a token expires.
+_CREDENTIAL_CLONE_OPTIONS = [
+    "-c credential.helper=",
+    "-c credential.interactive=false",
+]
+
+
+def _disable_credential_store(repo: git.Repo) -> None:
+    """Configure a cloned Overleaf repo so git authenticates only with the
+    token embedded in its remote URL, ignoring the OS credential store.
+
+    Setting an empty ``credential.helper`` in the repo's local config resets
+    the list of helpers inherited from the system and global config, so no
+    stale token can be read from (or written to) the credential store.
+    """
+    repo.git.config("credential.helper", "")
+    repo.git.config("credential.interactive", "false")
+
+
+def get_project_dir(project_id: str) -> str:
+    """Return the local directory into which an Overleaf project is cloned,
+    relative to the Calkit project working directory.
+    """
+    return os.path.join(".calkit", "overleaf", project_id)
+
+
+def clone(project_id: str, token: str) -> git.Repo:
+    """Clone an Overleaf project, authenticating only with ``token``."""
+    repo = git.Repo.clone_from(
+        get_git_remote_url(project_id=project_id, token=token),
+        get_project_dir(project_id),
+        multi_options=_CREDENTIAL_CLONE_OPTIONS,
+        allow_unsafe_options=True,
+    )
+    _disable_credential_store(repo)
+    return repo
+
+
+def get_repo(project_id: str, token: str) -> git.Repo:
+    """Return the Overleaf repo for ``project_id``, cloning it if it does not
+    yet exist.
+
+    When the repo already exists, its remote URL is refreshed so a freshly set
+    token takes effect, and credential handling is reset so a stale token from
+    the OS credential store is never used.
+    """
+    dest = get_project_dir(project_id)
+    if not os.path.isdir(dest):
+        return clone(project_id, token)
+    repo = calkit.git.get_repo(dest)
+    repo.git.remote(
+        "set-url",
+        "origin",
+        get_git_remote_url(project_id=project_id, token=token),
+    )
+    _disable_credential_store(repo)
+    return repo
+
+
 def project_id_to_url(project_id: str) -> str:
     return f"https://www.overleaf.com/project/{project_id}"
 

calkit/tests/cli/main/test_core.py

@@ -22,6 +22,7 @@ import calkit.cli.main
 from calkit.cli.core import complete_stage_names
 from calkit.cli.main.core import (
     _get_running_pipeline_status,
+    _get_subproject_targets_for_run,
     _prune_run_logs,
     _run_dvc_repro,
     _stage_run_info_from_log_content,
@@ -45,6 +46,52 @@ skipif_windows_mock_scheduler = pytest.mark.skipif(
 )
 
 
+@pytest.mark.parametrize(
+    ("subproject_path", "targets", "include_dvc_yaml_targets", "expected"),
+    [
+        ("sub1", None, False, (True, None)),
+        ("sub1", ["parent-stage"], False, (False, None)),
+        ("sub1", ["sub1"], False, (True, None)),
+        ("nested/sub1", ["sub1:build"], False, (True, ["build"])),
+        (
+            "nested/sub1",
+            ["nested/sub1:build"],
+            False,
+            (True, ["build"]),
+        ),
+        (
+            "nested/sub1",
+            ["nested/sub1/dvc.yaml"],
+            True,
+            (True, None),
+        ),
+        (
+            "nested/sub1",
+            ["nested/sub1/dvc.yaml:build"],
+            True,
+            (True, ["build"]),
+        ),
+        (
+            "nested/sub1",
+            ["nested/sub1/dvc.yaml:build"],
+            False,
+            (False, None),
+        ),
+    ],
+)
+def test_get_subproject_targets_for_run(
+    subproject_path, targets, include_dvc_yaml_targets, expected
+):
+    assert (
+        _get_subproject_targets_for_run(
+            subproject_path,
+            targets,
+            include_dvc_yaml_targets=include_dvc_yaml_targets,
+        )
+        == expected
+    )
+
+
 def _repo_test_file(name: str) -> Path:
     """Find a file in the repository-level ``test`` directory."""
     for parent in Path(__file__).resolve().parents:

calkit/tests/cli/main/test_subprojects.py

@@ -115,6 +115,83 @@ def test_inline_subproject(tmp_dir):
         assert "v2" in f.read()
 
 
+def test_single_item_skips_unrelated_subproject_preparation(tmp_dir):
+    subprocess.check_call(["calkit", "init"])
+    os.makedirs("sub1")
+    write_ck_info(
+        "sub1/calkit.yaml",
+        {
+            "pipeline": {
+                "stages": {
+                    "subproject-only": make_stage(
+                        'echo "subproject" > subproject.txt'
+                    )
+                }
+            }
+        },
+    )
+    write_ck_info(
+        "calkit.yaml",
+        {
+            "subprojects": [{"path": "sub1"}],
+            "pipeline": {
+                "stages": {
+                    "parent-only": make_stage('echo "parent" > parent.txt')
+                }
+            },
+        },
+    )
+    result = subprocess.run(
+        ["calkit", "run", "--single-item", "parent-only"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    assert os.path.isfile("parent.txt")
+    assert "Checking environments for subproject" not in result.stdout
+    selected_subproject = subprocess.run(
+        ["calkit", "run", "--single-item", "sub1:subproject-only"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    assert os.path.isfile("sub1/subproject.txt")
+    assert "Checking environments for subproject: sub1" in (
+        selected_subproject.stdout
+    )
+
+    # A DVC-style inline target should still prepare the selected subproject.
+    write_ck_info(
+        "sub1/calkit.yaml",
+        {
+            "pipeline": {
+                "stages": {
+                    "subproject-only": make_stage(
+                        'echo "dvc target" > subproject.txt'
+                    )
+                }
+            }
+        },
+    )
+    calkit.pipeline.to_dvc(write=True, manage_gitignore=False)
+    selected_inline_dvc_target = subprocess.run(
+        [
+            "calkit",
+            "run",
+            "--single-item",
+            "sub1/dvc.yaml:subproject-only",
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    with open("sub1/subproject.txt") as f:
+        assert "dvc target" in f.read()
+    assert "Checking environments for subproject: sub1" in (
+        selected_inline_dvc_target.stdout
+    )
+
+
 def init_isolated_subproject(path, stages):
     os.makedirs(path, exist_ok=True)
     subprocess.check_call(["git", "init"], cwd=path)

calkit/tests/cli/test_overleaf.py

@@ -409,3 +409,35 @@ def test_overleaf_sync_trailing_slash_or_space(tmp_dir):
         text=True,
     )
     assert res2.returncode == 0, f"Trailing space sync failed: {res2.stderr}"
+
+
+def test_get_repo_disables_credential_store(tmp_dir):
+    # Set up a repo to act as the Overleaf remote (in the test env the remote
+    # URL is a local directory)
+    pid = str(uuid.uuid4())
+    _make_temp_overleaf_project(pid)
+    dest = calkit.overleaf.get_project_dir(pid)
+    # A fresh clone should reset the credential helper for that repo so only
+    # the token in its remote URL is used, never a stale one from the OS
+    # credential store
+    repo = calkit.overleaf.clone(pid, "sometoken")
+    assert os.path.isdir(os.path.join(dest, ".git"))
+    assert repo.git.config(["--local", "--get", "credential.helper"]) == ""
+    assert (
+        repo.git.config(["--local", "--get", "credential.interactive"])
+        == "false"
+    )
+    # Opening an already-cloned project should refresh the remote URL so an
+    # updated token takes effect, and keep the credential store disabled
+    repo2 = calkit.overleaf.get_repo(pid, "newtoken")
+    assert repo2.git.remote(
+        ["get-url", "origin"]
+    ) == calkit.overleaf.get_git_remote_url(pid, "newtoken")
+    assert repo2.git.config(["--local", "--get", "credential.helper"]) == ""
+    # A project that has not yet been cloned should be cloned
+    pid2 = str(uuid.uuid4())
+    _make_temp_overleaf_project(pid2)
+    calkit.overleaf.get_repo(pid2, "sometoken")
+    assert os.path.isdir(
+        os.path.join(calkit.overleaf.get_project_dir(pid2), ".git")
+    )

calkit/tests/cli/test_sync.py

@@ -0,0 +1,116 @@
+"""Tests for the sync CLI commands."""
+
+from unittest.mock import MagicMock, patch
+
+from typer.testing import CliRunner
+
+from calkit.cli.main import app
+
+runner = CliRunner()
+
+
+def test_sync_help():
+    result = runner.invoke(app, ["sync", "--help"])
+    assert result.exit_code == 0
+    assert "Sync with external systems" in result.output
+    assert "git" in result.output
+    assert "dvc" in result.output
+    assert "overleaf" in result.output
+    assert "all" in result.output
+
+
+def test_sync_git_calls_pull_and_push():
+    mock_repo = MagicMock()
+    mock_repo.remotes = ["origin"]
+    with patch("calkit.git.get_repo", return_value=mock_repo):
+        with patch("calkit.cli.main.core.pull") as mock_pull:
+            with patch("calkit.cli.main.core.push") as mock_push:
+                result = runner.invoke(app, ["sync", "git"])
+                assert result.exit_code == 0
+                mock_pull.assert_called_once_with(
+                    no_dvc=True, no_check_auth=False
+                )
+                mock_push.assert_called_once_with(
+                    no_dvc=True, no_check_auth=False
+                )
+
+
+def test_sync_git_errors_when_not_initialized():
+    with patch("calkit.git.get_repo", side_effect=Exception("not a repo")):
+        result = runner.invoke(app, ["sync", "git"])
+        assert result.exit_code != 0
+        assert "No Git repository found" in result.output
+
+
+def test_sync_dvc_calls_pull_and_push():
+    with patch("calkit.dvc.get_dvc_repo"):
+        with patch("calkit.dvc.get_remotes", return_value={"origin": "url"}):
+            with patch("calkit.cli.main.core.pull") as mock_pull:
+                with patch("calkit.cli.main.core.push") as mock_push:
+                    result = runner.invoke(app, ["sync", "dvc"])
+                    assert result.exit_code == 0
+                    mock_pull.assert_called_once_with(
+                        no_git=True, no_check_auth=False
+                    )
+                    mock_push.assert_called_once_with(
+                        no_git=True, no_check_auth=False
+                    )
+
+
+def test_sync_dvc_errors_when_not_initialized():
+    with patch(
+        "calkit.dvc.get_dvc_repo", side_effect=Exception("not a dvc repo")
+    ):
+        result = runner.invoke(app, ["sync", "dvc"])
+        assert result.exit_code != 0
+        assert "No DVC repository found" in result.output
+
+
+def test_sync_all_runs_all_targets():
+    def mock_sync_git():
+        print("Mock syncing git")
+
+    def mock_sync_dvc():
+        print("Mock syncing dvc")
+
+    def mock_sync_overleaf():
+        print("Mock syncing overleaf")
+
+    with patch("calkit.cli.sync.sync_git", mock_sync_git):
+        with patch("calkit.cli.sync.sync_dvc", mock_sync_dvc):
+            with patch("calkit.cli.overleaf.sync", mock_sync_overleaf):
+                result = runner.invoke(app, ["sync", "all"])
+                assert result.exit_code == 0
+                assert "Syncing git..." in result.output
+                assert "Mock syncing git" in result.output
+                assert "Syncing dvc..." in result.output
+                assert "Mock syncing dvc" in result.output
+                assert "Syncing overleaf..." in result.output
+                assert "Mock syncing overleaf" in result.output
+
+
+def test_sync_all_reports_target_failures():
+    def mock_sync_git():
+        print("Mock syncing git")
+
+    def mock_sync_dvc():
+        raise RuntimeError("dvc is broken")
+
+    with patch("calkit.cli.sync.sync_git", mock_sync_git):
+        with patch("calkit.cli.sync.sync_dvc", mock_sync_dvc):
+            with patch("calkit.cli.overleaf.sync"):
+                result = runner.invoke(app, ["sync", "all"])
+                assert result.exit_code == 1
+                assert "Syncing git..." in result.output
+                assert "Mock syncing git" in result.output
+                assert "Syncing dvc..." in result.output
+                assert "Failed to sync dvc: dvc is broken" in result.output
+
+
+def test_sync_overleaf_is_accessible():
+    # Since we can't easily mock the entire overleaf sync environment here
+    # without duplicating test_overleaf.py, we just test that the command
+    # is registered and displays its help correctly.
+    result = runner.invoke(app, ["sync", "overleaf", "--help"])
+    assert result.exit_code == 0
+    assert "Sync folders with Overleaf" in result.output

{calkit_python-0.41.22.dist-info → calkit_python-0.41.24.dist-info}/METADATA

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

{calkit_python-0.41.22.dist-info → calkit_python-0.41.24.dist-info}/RECORD

@@ -25,7 +25,7 @@ calkit/matlab.py,sha256=wa7tjD5m8Xghwfj9u0oaYbuZ702CScvgk7pItFeTXoU,26061
 calkit/notebooks.py,sha256=SGrVF_O5WmghMi7axr2WzHb4xLK7f6OmqTDMxQ5V5EY,8845
 calkit/office.py,sha256=mZqCxkIsmWthBAeJZ5SiGe21fn5zD2zXsy1E6nQIpWE,1291
 calkit/ops.py,sha256=lLlZAFeplU8uLeMavr99d__Iof-YYwKijus74WfLipk,854
-calkit/overleaf.py,sha256=5SI8HwglLVtVlzj7d15Bft_3ZC6AHn3IrAbqMKOAPX0,30170
+calkit/overleaf.py,sha256=zLKv5K0p02vkvfDT7kN-gDSkPICVItV6_FamQYNJfxQ,32528
 calkit/pipeline.py,sha256=mJsh_DhZGY0byO1pGLgZWNX6xhEx5OmVx5O-n37CLGA,73981
 calkit/releases.py,sha256=rLvvheYM7eC9qup4Ybnl5DgEuJ0y22Tc2kkKUDxL6RI,19227
 calkit/server.py,sha256=GQm1bI5Q1NLFNwQL-iP6j4iWKUpKpP3cLEyfj5IMwe4,22009
@@ -43,11 +43,12 @@ calkit/cli/list.py,sha256=jzkZC7dgbmYz8aCBfEWibu_ZRm6i0xwXmIgbUR4NZgA,12040
 calkit/cli/new.py,sha256=UDFUi3_MvQcI7q5VWFnRRrX7pW6KCoTcssmJtxkfXpw,137435
 calkit/cli/notebooks.py,sha256=mMNHE8yT0BDN0iJE07GCBFAseyDF0jSRshIm1CQjgrY,24645
 calkit/cli/office.py,sha256=jVSTvbl91TCzlglST5O2b8hdApZA_QHw_UiEQFJqxdc,1754
-calkit/cli/overleaf.py,sha256=xgcONFdyItlUHUfSD_iF-bhjddKO_-ObtHz_Khiz-xE,25384
+calkit/cli/overleaf.py,sha256=G4k4LdBDmuPvT3afVpb8QfWNYUSFiOhHc4vY7offDgA,24489
 calkit/cli/scheduler.py,sha256=OWJpW57G6Ebs5FTZ_nf2PpEG9QNd6WPe0mb3TmbVTyE,42402
+calkit/cli/sync.py,sha256=UGen0Yey6BARooI5K83eiArw4YN2ZQcRQjCocaGy6E4,2539
 calkit/cli/update.py,sha256=5Jjo-5uRTxd5UWHvOETPYFWtJJRr81qmKmsibthkLPk,43501
 calkit/cli/main/__init__.py,sha256=qu1POZPyqs33ZKfasOxv_Wc-EzVcEgK3Dt_vwFL8Bi8,65
-calkit/cli/main/core.py,sha256=OE2HrKSiY9BoxSz14h8_l0pbopvpe-QaljMJbebATcM,127668
+calkit/cli/main/core.py,sha256=FMNgp7yAyLcUAaFvpyNiUbdhYu5579D6j_ic8FNIIqQ,129246
 calkit/cli/main/xr.py,sha256=Bug5qJuiIq0tusmdu30t-ZdyaT_Sy5RwPSTiHvCtIqE,25600
 calkit/dvc/__init__.py,sha256=-B6tilCb_jw7QFmJ2srILez24wDhNKUzIBhZUMt01dE,381
 calkit/dvc/core.py,sha256=p42i_uCzgZD6ClGnLOn88zaiGTwrdSG09quL8Hb8Aas,30908
@@ -102,13 +103,14 @@ calkit/tests/cli/test_latex.py,sha256=3pG7o-56Rc9_kPbfkoCJ9DKojfNPTQY8yl5JB3SFh2
 calkit/tests/cli/test_list.py,sha256=bY74qAHlejgF04EIQgwR5RSdv0Oss3nUkLXcUiSoeFo,5491
 calkit/tests/cli/test_new.py,sha256=G1CpwlhV7a4oiGYep0DgolaAHOrdxQshxE7fE_EeD8M,53283
 calkit/tests/cli/test_notebooks.py,sha256=2t1KiGhEz9H9LcIdWy4jGM05REUxJpWiIg6fSpX12ME,10678
-calkit/tests/cli/test_overleaf.py,sha256=tgGCuOpic0owtOPD_CtZDnffPkknC_73CSDpOT9S3io,18159
+calkit/tests/cli/test_overleaf.py,sha256=D1fMB68s4zNKNY_OkfDlb2FyOcGIle2UOItePCnlwTo,19578
 calkit/tests/cli/test_scheduler.py,sha256=mE0KLwcb9gozOnylTLsaL_xYGAptlD9hB8ZiKpPhmcc,17934
+calkit/tests/cli/test_sync.py,sha256=jmhfgoMIjdihIuu9UVyHSizBDTF0hlBt2VWqEdVkAKk,4375
 calkit/tests/cli/test_update.py,sha256=bwRF0kpqbCVxNvGH777LHFX3oUP2DyN3XXUBDCEKNoc,6356
 calkit/tests/cli/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-calkit/tests/cli/main/test_core.py,sha256=_AX3xSmovVAL1lXB4NAPICZMl_kkmZKg-mMAzs5B0Ns,72681
+calkit/tests/cli/main/test_core.py,sha256=sIceEsGAHYSML9nPnIWdiMfw9d9sBvKU3TsQ2Z8np0g,73910
 calkit/tests/cli/main/test_lock.py,sha256=1iX8iSbGtr4O9OkaAi4d3gP3_QzNl6Rr6HLtbEpS6iU,9847
-calkit/tests/cli/main/test_subprojects.py,sha256=ZR2ZQvZ4XZOi-iW8nlZEYu_2CUyUWoc0MABmnFrF9DQ,12730
+calkit/tests/cli/main/test_subprojects.py,sha256=Hq_BsYdltXc3YaIMvRWGa8fbsMr1dojHj1dXz9WkaNo,14940
 calkit/tests/cli/main/test_xr.py,sha256=shk8LHS33bZpr_iAW5eA5sMD3nQDKm8fIwXlE6dA2uI,22527
 calkit/tests/dvc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/dvc/test_core.py,sha256=ywXBEyw1XpoSuu1EnMbFl-ebbdEJjpaBEPG157_3RBY,12914
@@ -123,22 +125,22 @@ calkit/tests/models/test_pipeline.py,sha256=9F0g6ij7vc8c2hIRIVTHpT0I-JHXC6i2NRB2
 calkit/agent_skills/add-pipeline-stage/SKILL.md,sha256=kpYYb-rJsS4B9p1Ub3gL21irCG5ZZ4DvWZpdJeEwPZk,3772
 calkit/agent_skills/conventions/SKILL.md,sha256=nAM2FjSMk6ED56Dr5zh2bL_dhfzDra-h2ZgzHU7ruS4,9524
 calkit/agent_skills/create-pipeline/SKILL.md,sha256=2FGw1iDQVRk5FUq79GP3lPdgvgof2Wi1O9O-abGGtgs,5422
-calkit_python-0.41.22.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/package.json,sha256=39PQEWOzw0qtqD7Kep3OPbUR113vI7CG5TeD84v7clM,6224
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=NBG3t7gFYb6_2J-yPU29qS7Ck9pYgm8-wC5Q1LrzQeI,6082
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.ac9035764d5b2adbb542.js,sha256=rJA1dk1bKtu1QkURrp5HEC2WCxzZppPV1SCYz-35GTc,8737
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
-calkit_python-0.41.22.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
-calkit_python-0.41.22.dist-info/METADATA,sha256=wDI3s5hGdJ4c1GBqKw-8I96N408xQVW_z2m-UsWqRIU,12567
-calkit_python-0.41.22.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-calkit_python-0.41.22.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
-calkit_python-0.41.22.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
-calkit_python-0.41.22.dist-info/RECORD,,
+calkit_python-0.41.24.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/package.json,sha256=39PQEWOzw0qtqD7Kep3OPbUR113vI7CG5TeD84v7clM,6224
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=NBG3t7gFYb6_2J-yPU29qS7Ck9pYgm8-wC5Q1LrzQeI,6082
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.ac9035764d5b2adbb542.js,sha256=rJA1dk1bKtu1QkURrp5HEC2WCxzZppPV1SCYz-35GTc,8737
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
+calkit_python-0.41.24.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
+calkit_python-0.41.24.dist-info/METADATA,sha256=QPiEwXWF7Hy-C7HxoWYBDX8jDzBC2MARv4V9n7q1Jp4,12567
+calkit_python-0.41.24.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+calkit_python-0.41.24.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
+calkit_python-0.41.24.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
+calkit_python-0.41.24.dist-info/RECORD,,