calkit-python 0.41.10__py3-none-any.whl → 0.41.12__py3-none-any.whl

calkit/cli/describe.py

@@ -3,10 +3,13 @@
 from __future__ import annotations
 
 import json
+from typing import Annotated
 
 import typer
 
 import calkit
+from calkit.cli import raise_error
+from calkit.environments import get_env_lock_fpath
 
 describe_app = typer.Typer(no_args_is_help=True)
 
@@ -16,3 +19,45 @@ def describe_system():
     """Describe the system."""
     system_info = calkit.get_system_info()
     typer.echo(json.dumps(system_info, indent=2))
+
+
+@describe_app.command(name="env")
+def describe_env(
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Environment name."),
+    ],
+):
+    """Describe a single environment, including spec and lock file paths."""
+    ck_info = calkit.load_calkit_info()
+    envs: dict = ck_info.get("environments", {})
+    if name not in envs:
+        raise_error(f"Environment '{name}' not found.")
+    env = envs[name]
+    lock_path = get_env_lock_fpath(env=env, env_name=name)
+    result = {
+        "kind": env.get("kind"),
+        "spec_path": env.get("path"),
+        "lock_path": lock_path,
+        "prefix": env.get("prefix"),
+        "python": env.get("python"),
+    }
+    typer.echo(json.dumps(result, indent=2))
+
+
+@describe_app.command(name="envs")
+def describe_envs():
+    """Describe all environments, including spec and lock file paths."""
+    ck_info = calkit.load_calkit_info()
+    envs: dict = ck_info.get("environments", {})
+    result = {}
+    for env_name, env in envs.items():
+        lock_path = get_env_lock_fpath(env=env, env_name=env_name)
+        result[env_name] = {
+            "kind": env.get("kind"),
+            "spec_path": env.get("path"),
+            "lock_path": lock_path,
+            "prefix": env.get("prefix"),
+            "python": env.get("python"),
+        }
+    typer.echo(json.dumps(result, indent=2))

calkit/cli/list.py

@@ -2,16 +2,43 @@
 
 from __future__ import annotations
 
+import json
 from typing import Annotated, Literal
 
 import typer
 
 import calkit
-from calkit.cli import AliasGroup, warn
+from calkit.cli import AliasGroup, raise_error, warn
 
 list_app = typer.Typer(cls=AliasGroup, no_args_is_help=True)
 
 
+def _echo_object(obj: dict) -> None:
+    """Print a single object in the human-readable YAML-ish listing format."""
+    # Copy so popping 'path' doesn't mutate the caller's dict.
+    obj = dict(obj)
+    path = obj.pop("path", None)
+    typer.echo(f"- path: {path}")
+    for k, v in obj.items():
+        if isinstance(v, dict):
+            typer.echo(f"    {k}:")
+            for k1, v1 in v.items():
+                typer.echo(f"      {k1}: {v1}")
+        elif isinstance(v, list):
+            typer.echo(f"    {k}:")
+            for item in v:
+                if isinstance(item, dict):
+                    for n, (k1, v1) in enumerate(item.items()):
+                        if n == 0:
+                            typer.echo(f"      - {k1}: {v1}")
+                        else:
+                            typer.echo(f"        {k1}: {v1}")
+                else:
+                    typer.echo(f"        - {item}")
+        else:
+            typer.echo(f"  {k}: {v}")
+
+
 def _list_objects(
     kind: Literal[
         "notebooks",
@@ -21,33 +48,44 @@ def _list_objects(
         "publications",
     ],
 ):
-    """List objects.
+    """List objects."""
+    ck_info = calkit.load_calkit_info()
+    for obj in ck_info.get(kind, []) or []:
+        _echo_object(obj)
+
+
+def _list_artifacts(
+    kind: Literal["figures", "datasets"],
+    json_output: bool,
+    declared_only: bool,
+):
+    """List figures or datasets, optionally including auto-detected ones.
 
-    TODO: This should probably just use some library to dump YAML to string.
+    By default, artifacts declared in ``calkit.yaml`` are merged with any
+    auto-detected from the project's files; ``--declared-only`` returns just the
+    declared ones. Each entry carries a ``detected`` flag so callers can tell
+    declared and auto-detected artifacts apart.
     """
     ck_info = calkit.load_calkit_info()
-    objects = ck_info.get(kind, [])
-    for obj in objects:
-        path = obj.pop("path")
-        typer.echo(f"- path: {path}")
-        for k, v in obj.items():
-            if isinstance(v, dict):
-                typer.echo(f"    {k}:")
-                for k1, v1 in v.items():
-                    typer.echo(f"      {k1}: {v1}")
-            elif isinstance(v, list):
-                typer.echo(f"    {k}:")
-                for item in v:
-                    if isinstance(item, dict):
-                        for n, (k1, v1) in enumerate(item.items()):
-                            if n == 0:
-                                typer.echo(f"      - {k1}: {v1}")
-                            else:
-                                typer.echo(f"        {k1}: {v1}")
-                    else:
-                        typer.echo(f"        - {item}")
-            else:
-                typer.echo(f"  {k}: {v}")
+    declared = ck_info.get(kind, []) or []
+    declared_paths = {o.get("path") for o in declared if isinstance(o, dict)}
+    detected: list[dict] = []
+    if not declared_only:
+        found = calkit.detect.detect_project_artifacts(ck_info=ck_info)
+        for path in found.get(kind, []):
+            if path not in declared_paths:
+                detected.append({"path": path})
+    if json_output:
+        result = [
+            {**o, "detected": False} for o in declared if isinstance(o, dict)
+        ]
+        result += [{**o, "detected": True} for o in detected]
+        typer.echo(json.dumps(result))
+        return
+    for obj in declared:
+        _echo_object(obj)
+    for obj in detected:
+        _echo_object({**obj, "detected": True})
 
 
 @list_app.command(name="notebooks|nb")
@@ -57,15 +95,43 @@ def list_notebooks():
 
 
 @list_app.command(name="figures|figs")
-def list_figures():
+def list_figures(
+    json_output: Annotated[
+        bool, typer.Option("--json", help="Output result as JSON.")
+    ] = False,
+    declared_only: Annotated[
+        bool,
+        typer.Option(
+            "--declared-only",
+            help=(
+                "Only list figures declared in calkit.yaml; "
+                "skip auto-detection."
+            ),
+        ),
+    ] = False,
+):
     """List figures in the project."""
-    _list_objects("figures")
+    _list_artifacts("figures", json_output, declared_only)
 
 
 @list_app.command(name="datasets")
-def list_datasets():
+def list_datasets(
+    json_output: Annotated[
+        bool, typer.Option("--json", help="Output result as JSON.")
+    ] = False,
+    declared_only: Annotated[
+        bool,
+        typer.Option(
+            "--declared-only",
+            help=(
+                "Only list datasets declared in calkit.yaml; "
+                "skip auto-detection."
+            ),
+        ),
+    ] = False,
+):
     """List datasets in the project."""
-    _list_objects("datasets")
+    _list_artifacts("datasets", json_output, declared_only)
 
 
 @list_app.command(name="publications|pubs")
@@ -167,12 +233,28 @@ def list_stages(
         list[str] | None,
         typer.Option("--kind", "-k", help="Filter stages by kind."),
     ] = None,
+    stale_only: Annotated[
+        bool, typer.Option("--stale", help="Show only stale stages.")
+    ] = False,
 ):
     """List pipeline stages."""
-    stages = calkit.load_calkit_info().get("pipeline", {}).get("stages", {})
+    ck_info = calkit.load_calkit_info()
+    stages = ck_info.get("pipeline", {}).get("stages", {})
+    # If we only want stale stages, we need to get the status first.
+    # This compiles the pipeline, cleans notebooks, and checks environments,
+    # all of which can affect whether a stage is stale, so we don't skip them.
+    if stale_only:
+        status = calkit.pipeline.get_status(ck_info=ck_info)
+        if status.errors:
+            raise_error(
+                "Failed to determine stale stages: " + "; ".join(status.errors)
+            )
+        stale_stage_names = status.stale_stage_names
     for name, stage in stages.items():
         if kinds is not None and stage.get("kind") not in kinds:
             continue
+        if stale_only and name not in stale_stage_names:
+            continue
         typer.echo(name)
 
 

calkit/cli/main/core.py

@@ -196,7 +196,12 @@ def init(
     repo = calkit.git.get_repo()
     repo.git.add(".dvc")
     repo.git.commit("-m", "Initialize DVC")
-    # TODO: Initialize `calkit.yaml`
+    # Create an empty calkit.yaml if one doesn't already exist
+    if not os.path.isfile("calkit.yaml"):
+        with open("calkit.yaml", "w"):
+            pass
+        repo.git.add("calkit.yaml")
+        repo.git.commit("-m", "Initialize Calkit")
     # TODO: Initialize `dvc.yaml`
     # TODO: Add a sane .gitignore file
     # TODO: Add a sane LICENSE file?