calkit-python 0.31.2__tar.gz → 0.31.4__tar.gz

{calkit_python-0.31.2 → calkit_python-0.31.4}/PKG-INFO

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

{calkit_python-0.31.2 → calkit_python-0.31.4}/calkit/__init__.py

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

{calkit_python-0.31.2 → calkit_python-0.31.4}/calkit/cli/check.py

@@ -307,10 +307,10 @@ def check_docker_env(
             "Lock file output path must be provided if input Dockerfile is not"
         )
 
-    def get_docker_inspect() -> dict:
+    def get_docker_inspect(obj_id: str = tag) -> dict:
         # This command returns a list, of which we want the first object
         out = json.loads(
-            subprocess.check_output(["docker", "inspect", tag]).decode()
+            subprocess.check_output(["docker", "inspect", obj_id]).decode()
         )
         # Remove some keys that can change without the important aspects of
         # the image changing
@@ -411,15 +411,18 @@ def check_docker_env(
         if lock and "RepoDigests" in lock:
             repo_digests = lock["RepoDigests"]
             if repo_digests:
-                tag_with_digest = repo_digests[0]
-                typer.echo(f"Pulling image by digest: {tag_with_digest}")
-                cmd = ["docker", "pull", tag_with_digest]
+                image_with_digest = repo_digests[0]
+                typer.echo(f"Pulling image by digest: {image_with_digest}")
+                cmd = ["docker", "pull", image_with_digest]
+                tag_cmd = ["docker", "tag", image_with_digest, tag]
                 try:
                     subprocess.check_output(cmd)
+                    # Now tag the pulled image
+                    subprocess.check_output(tag_cmd)
                     pulled = True
                 except subprocess.CalledProcessError:
                     warn(
-                        f"Failed to pull image by digest: {tag_with_digest}; "
+                        f"Failed to pull image by digest: {image_with_digest}; "
                         "falling back to pulling by tag"
                     )
                     pulled = False
@@ -432,6 +435,9 @@ def check_docker_env(
                 raise_error(f"Failed to pull image: {tag}")
     # Write the lock file
     inspect = get_docker_inspect()
+    # Ensure repo tags only have the tag we wanted, not the digest, so we
+    # don't cause stages to rerun from lock file change
+    inspect["RepoTags"] = [tag]
     inspect["DockerfileMD5"] = dockerfile_md5
     inspect["DepsMD5s"] = deps_md5s
     if platform is not None:

{calkit_python-0.31.2 → calkit_python-0.31.4}/calkit/cli/main.py

@@ -259,6 +259,11 @@ def clone(
 @app.command(name="status")
 def get_status():
     """Get a unified Git and DVC status."""
+    ck_info = calkit.load_calkit_info()
+    try:
+        calkit.pipeline.to_dvc(ck_info=ck_info, write=True)
+    except Exception as e:
+        warn(f"Failed to compile pipeline: {e.__class__.__name__}: {e}")
     print_sep("Project")
     # Print latest status
     status = calkit.get_latest_project_status()

{calkit_python-0.31.2 → calkit_python-0.31.4}/calkit/environments.py

@@ -31,7 +31,7 @@ def get_env_lock_dir(wdir: str | None = None) -> str:
     return env_lock_dir
 
 
-def _conda_venv_subdir() -> str:
+def _conda_venv_platform() -> str:
     sys = platform.system().lower()
     mach = platform.machine().lower()
     if sys == "darwin":
@@ -85,10 +85,9 @@ def get_all_docker_lock_fpaths(
     legacy handling is performed separately.
     """
     env_lock_dir = get_env_lock_dir(wdir=wdir)
-    docker_dir = os.path.join(env_lock_dir, "docker")
+    docker_dir = os.path.join(env_lock_dir, env_name)
     fpaths = [
-        os.path.join(docker_dir, arch, env_name + ".json")
-        for arch in DOCKER_ARCHS
+        os.path.join(docker_dir, arch + ".json") for arch in DOCKER_ARCHS
     ]
     if as_posix:
         fpaths = [PurePosixPath(p).as_posix() for p in fpaths]
@@ -104,10 +103,9 @@ def get_all_conda_lock_fpaths(
     architecture.
     """
     env_lock_dir = get_env_lock_dir(wdir=wdir)
-    conda_dir = os.path.join(env_lock_dir, "conda")
+    env_lock_dir = os.path.join(env_lock_dir, env_name)
     fpaths = [
-        os.path.join(conda_dir, arch, env_name + ".yml")
-        for arch in CONDA_VENV_ARCHS
+        os.path.join(env_lock_dir, arch + ".yml") for arch in CONDA_VENV_ARCHS
     ]
     if as_posix:
         fpaths = [PurePosixPath(p).as_posix() for p in fpaths]
@@ -123,10 +121,9 @@ def get_all_venv_lock_fpaths(
     architecture.
     """
     env_lock_dir = get_env_lock_dir(wdir=wdir)
-    venv_dir = os.path.join(env_lock_dir, "venvs")
+    venv_dir = os.path.join(env_lock_dir, env_name)
     fpaths = [
-        os.path.join(venv_dir, arch, env_name + ".txt")
-        for arch in CONDA_VENV_ARCHS
+        os.path.join(venv_dir, arch + ".txt") for arch in CONDA_VENV_ARCHS
     ]
     if as_posix:
         fpaths = [PurePosixPath(p).as_posix() for p in fpaths]
@@ -139,8 +136,14 @@ def get_env_lock_fpath(
     wdir: str | None = None,
     as_posix: bool = True,
     legacy: bool = False,
+    for_dvc: bool = False,
 ) -> str | None:
-    """Create the environment lock file path."""
+    """Create the environment lock file path.
+
+    If `for_dvc` is True, return the directory containing the lock file
+    instead of the lock file itself for Docker, venv, and conda environments,
+    which store a separate lock file for each platform/architecture.
+    """
     env_lock_dir = get_env_lock_dir(wdir=wdir)
     env_kind = env.get("kind")
     lock_fpath = os.path.join(env_lock_dir, env_name)
@@ -149,8 +152,10 @@ def get_env_lock_fpath(
             lock_fpath += ".json"
         else:
             lock_fpath = os.path.join(
-                env_lock_dir, "docker", _docker_platform(), env_name + ".json"
+                env_lock_dir, env_name, _docker_platform() + ".json"
             )
+            if for_dvc:
+                lock_fpath = os.path.dirname(lock_fpath)
     elif env_kind == "uv":
         env_dir = os.path.dirname(env.get("path", ""))
         if env_dir:
@@ -163,20 +168,22 @@ def get_env_lock_fpath(
         else:
             lock_fpath = os.path.join(
                 env_lock_dir,
-                "venvs",
-                _conda_venv_subdir(),
-                env_name + ".txt",
+                env_name,
+                _conda_venv_platform() + ".txt",
             )
+            if for_dvc:
+                lock_fpath = os.path.dirname(lock_fpath)
     elif env_kind == "conda":
         if legacy:
             lock_fpath += ".yml"
         else:
             lock_fpath = os.path.join(
                 env_lock_dir,
-                "conda",
-                _conda_venv_subdir(),
-                env_name + ".yml",
+                env_name,
+                _conda_venv_platform() + ".yml",
             )
+            if for_dvc:
+                lock_fpath = os.path.dirname(lock_fpath)
     elif env_kind == "matlab":
         lock_fpath += ".json"
     elif env_kind == "julia":

{calkit_python-0.31.2 → calkit_python-0.31.4}/calkit/pipeline.py

@@ -73,11 +73,11 @@ def to_dvc(
             continue
         env_fpath = env.get("path")
         lock_fpath = get_env_lock_fpath(
-            env=env, env_name=env_name, as_posix=True
+            env=env, env_name=env_name, as_posix=True, for_dvc=True
         )
-        cmd = f"calkit check environment --name {env_name}"
         if lock_fpath is None:
             continue
+        cmd = f"calkit check environment --name {env_name}"
         deps = []
         outs = []
         if env_fpath is not None:

{calkit_python-0.31.2 → calkit_python-0.31.4}/calkit/tests/cli/test_new.py

@@ -507,7 +507,7 @@ def test_new_python_script_stage(tmp_dir):
         "calkit xenv -n py --no-check -- python script.py"
     )
     env_lock_fpath = get_env_lock_fpath(
-        calkit.load_calkit_info()["environments"]["py"], "py"
+        calkit.load_calkit_info()["environments"]["py"], "py", for_dvc=True
     )
     assert set(pipeline["stages"]["run-script"]["deps"]) == set(
         ["script.py", env_lock_fpath]
@@ -588,7 +588,7 @@ def test_new_latex_stage(tmp_dir):
     )
     ck_info = calkit.load_calkit_info()
     env = ck_info["environments"]["tex"]
-    env_lock_fpath = get_env_lock_fpath(env, "tex")
+    env_lock_fpath = get_env_lock_fpath(env, "tex", for_dvc=True)
     assert set(pipeline["stages"]["build-paper"]["deps"]) == set(
         ["paper.tex", env_lock_fpath]
     )
@@ -635,7 +635,9 @@ def test_new_matlab_script_stage(tmp_dir):
         "calkit xenv -n matlab1 --no-check -- \"run('scripts/script.m');\""
     )
     env_lock_fpath = get_env_lock_fpath(
-        calkit.load_calkit_info()["environments"]["matlab1"], "matlab1"
+        calkit.load_calkit_info()["environments"]["matlab1"],
+        "matlab1",
+        for_dvc=True,
     )
     assert set(pipeline["stages"]["run-script1"]["deps"]) == set(
         ["scripts/script.m", env_lock_fpath]

{calkit_python-0.31.2 → calkit_python-0.31.4}/calkit/tests/test_pipeline.py

@@ -45,7 +45,9 @@ def test_to_dvc():
     assert stage["desc"].startswith("Automatically generated")
     out = stage["outs"][0]
     out_path = list(out.keys())[0]
-    env_lock_fpath = get_env_lock_fpath(ck_info["environments"]["py"], "py")
+    env_lock_fpath = get_env_lock_fpath(
+        ck_info["environments"]["py"], "py", for_dvc=True
+    )
     assert out_path == env_lock_fpath
     assert not out[out_path]["cache"]
     # TODO: Test other stage types