calkit-python 0.35.7__tar.gz → 0.36.0__tar.gz

{calkit_python-0.35.7 → calkit_python-0.36.0}/.gitignore

@@ -1,7 +1,7 @@
 dev.ipynb
 *.pyc
 .DS_Store
-.vscode
+.vscode/settings.json
 site
 .env
 .venv

calkit_python-0.36.0/.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Calkit VS Code Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "runtimeExecutable": "${execPath}",
+      "args": [
+        "--extensionDevelopmentPath=${workspaceFolder}/vscode-ext",
+        "--enable-proposed-api=calkit.calkit-vscode"
+      ],
+      "outFiles": ["${workspaceFolder}/vscode-ext/out/**/*.js"],
+      "preLaunchTask": "npm: compile (vscode-ext)"
+    }
+  ]
+}

calkit_python-0.36.0/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "shell",
+      "command": "npm",
+      "args": ["run", "dev:compile"],
+      "options": {
+        "cwd": "${workspaceFolder}/vscode-ext"
+      },
+      "label": "npm: compile (vscode-ext)",
+      "problemMatcher": ["$tsc"]
+    }
+  ]
+}

{calkit_python-0.35.7 → calkit_python-0.36.0}/PKG-INFO

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

{calkit_python-0.35.7 → calkit_python-0.36.0}/calkit/cli/main/core.py

@@ -249,6 +249,9 @@ def get_status(
             ),
         ),
     ] = None,
+    as_json: Annotated[
+        bool, typer.Option("--json", help="Output status as JSON.")
+    ] = False,
 ):
     """View status (project, version control, and/or pipeline)."""
     ck_info = calkit.load_calkit_info()
@@ -284,6 +287,78 @@ def get_status(
                 "Failed pipeline environment checks for: "
                 + ", ".join(pipeline_status.failed_environment_checks)
             )
+    if as_json:
+        status_dict = {}
+        if "project" in categories:
+            status = calkit.get_latest_project_status()
+            status_dict["project"] = (
+                None
+                if status is None
+                else {
+                    "status": status.status,
+                    "message": status.message,
+                    "timestamp": status.timestamp.isoformat(),
+                }
+            )
+        if "git" in categories:
+            try:
+                repo = git.Repo()
+                changed_files = calkit.git.get_changed_files(repo=repo)
+                staged_files = calkit.git.get_staged_files(repo=repo)
+                untracked_files = calkit.git.get_untracked_files(repo=repo)
+                if targets:
+                    target_prefixes = [
+                        Path(target).as_posix().rstrip("/")
+                        for target in targets
+                    ]
+
+                    def _matches_target(path: str) -> bool:
+                        path = Path(path).as_posix()
+                        return any(
+                            path == prefix or path.startswith(prefix + "/")
+                            for prefix in target_prefixes
+                        )
+
+                    changed_files = [
+                        path for path in changed_files if _matches_target(path)
+                    ]
+                    staged_files = [
+                        path for path in staged_files if _matches_target(path)
+                    ]
+                    untracked_files = [
+                        path
+                        for path in untracked_files
+                        if _matches_target(path)
+                    ]
+                status_dict["git"] = {
+                    "branch": None
+                    if repo.head.is_detached
+                    else repo.active_branch.name,
+                    "is_dirty": repo.is_dirty(untracked_files=True),
+                    "changed_files": changed_files,
+                    "staged_files": staged_files,
+                    "untracked_files": untracked_files,
+                }
+            except InvalidGitRepositoryError:
+                status_dict["git"] = {"error": "Not a Git repository"}
+        if "dvc" in categories:
+            try:
+                dvc_repo = calkit.dvc.get_dvc_repo()
+                data_status = dvc_repo.data_status()
+                if isinstance(data_status, dict):
+                    data_status.pop("git", None)
+                status_dict["dvc"] = data_status
+            except Exception as e:
+                status_dict["dvc"] = {"error": f"{e.__class__.__name__}: {e}"}
+        if "pipeline" in categories or "dvc" in categories:
+            if pipeline_status is None:
+                status_dict["pipeline"] = None
+            else:
+                status_dict["pipeline"] = pipeline_status.model_dump(
+                    mode="json"
+                )
+        print(json.dumps(status_dict, indent=2, default=str))
+        return
     if "project" in categories:
         print_sep("Project")
         # Print latest status
@@ -322,7 +397,11 @@ def get_status(
         print_sep("Pipeline")
         # Nicely format the results from pipeline status
         if pipeline_status and pipeline_status.errors:
-            typer.echo("Pipeline status unavailable due to errors.")
+            warn("Pipeline status unavailable due to errors.")
+            return
+        if pipeline_status and not pipeline_status.has_pipeline:
+            typer.echo("This project has no pipeline.")
+            return
         elif pipeline_status and pipeline_status.is_stale:
             for stage_name in pipeline_status.stale_stage_names:
                 stale_stage = pipeline_status.stale_stages.get(stage_name)
@@ -333,17 +412,17 @@ def get_status(
                 if stale_stage.stale_outputs:
                     typer.echo("  stale outputs:")
                     for output_path in stale_stage.stale_outputs:
-                        typer.echo(f"    - {output_path}")
+                        typer.echo(f"    {output_path}")
                 # Show modified outputs from this stage
                 if stale_stage.modified_outputs:
                     typer.echo("  modified outputs:")
                     for output_path in stale_stage.modified_outputs:
-                        typer.echo(f"    - {output_path}")
+                        typer.echo(f"    {output_path}")
                 # Show modified inputs making the stage stale
                 if stale_stage.modified_inputs:
                     typer.echo("  modified inputs:")
                     for input_path in stale_stage.modified_inputs:
-                        typer.echo(f"    - {input_path}")
+                        typer.echo(f"    {input_path}")
         elif pipeline_status:
             typer.echo("Pipeline is up to date.")
 

{calkit_python-0.35.7 → calkit_python-0.36.0}/calkit/cli/new.py

@@ -1333,6 +1333,75 @@ def new_uv_env(
             repo.git.commit(["-m", f"Add uv environment {name}"])
 
 
+@new_app.command("slurm-env")
+def new_slurm_env(
+    name: Annotated[
+        str, typer.Option("--name", "-n", help="Environment name.")
+    ],
+    host: Annotated[
+        str,
+        typer.Option("--host", help="Host where SLURM commands should run."),
+    ] = "localhost",
+    default_options: Annotated[
+        list[str],
+        typer.Option(
+            "--default-option",
+            help=(
+                "Default sbatch/srun option string (for example --gpus=1). "
+                "Repeat for multiple options."
+            ),
+        ),
+    ] = [],
+    description: Annotated[
+        str | None, typer.Option("--description", help="Description.")
+    ] = None,
+    overwrite: Annotated[
+        bool,
+        typer.Option(
+            "--overwrite",
+            "-f",
+            help="Overwrite any existing environment with this name.",
+        ),
+    ] = False,
+    no_commit: Annotated[
+        bool, typer.Option("--no-commit", help="Do not commit changes.")
+    ] = False,
+):
+    """Create a new SLURM environment."""
+    host = host.strip()
+    if not host:
+        raise_error("Host is required")
+    ck_info = calkit.load_calkit_info()
+    envs = ck_info.get("environments", {})
+    if isinstance(envs, list):
+        typer.echo("Converting environments from list to dict")
+        envs = {env.pop("name"): env for env in envs}
+    if name in envs and not overwrite:
+        raise_error(
+            f"Environment with name {name} already exists "
+            "(use -f to overwrite)"
+        )
+    normalized_default_options = [
+        opt.strip() for opt in default_options if opt.strip()
+    ]
+    env = {"kind": "slurm", "host": host}
+    if normalized_default_options:
+        env["default_options"] = normalized_default_options  # type: ignore
+    if description is not None:
+        env["description"] = description
+    envs[name] = env
+    ck_info["environments"] = envs
+    with open("calkit.yaml", "w") as f:
+        ryaml.dump(ck_info, f)
+    if not no_commit:
+        repo = git.Repo()
+        repo.git.add("calkit.yaml")
+        if repo.git.diff(["--staged", "calkit.yaml"]):
+            repo.git.commit(
+                ["calkit.yaml", "-m", f"Add SLURM environment {name}"]
+            )
+
+
 @new_app.command("uv-venv")
 def new_uv_venv(
     name: Annotated[
@@ -1615,21 +1684,29 @@ def new_pixi_env(
 @new_app.command("julia-env")
 def new_julia_env(
     packages: Annotated[
-        list[str],
-        typer.Argument(help="Packages to include in the environment."),
-    ],
+        list[str] | None,
+        typer.Argument(
+            help="Optional packages to include in the environment."
+        ),
+    ] = None,
     name: Annotated[
         str, typer.Option("--name", "-n", help="Environment name.")
-    ],
+    ] = "main",
     path: Annotated[
-        str, typer.Option("--path", help="Path for Project.toml file.")
-    ] = "Project.toml",
+        str | None,
+        typer.Option("--path", help="Path for Project.toml file."),
+    ] = None,
     description: Annotated[
         str | None, typer.Option("--description", help="Description.")
     ] = None,
     julia_version: Annotated[
-        str, typer.Option("--julia", "-j", help="Julia version.")
-    ] = "1.11",
+        str | None,
+        typer.Option(
+            "--julia",
+            "-j",
+            help="Julia version. Auto-detected if not supplied.",
+        ),
+    ] = None,
     overwrite: Annotated[
         bool,
         typer.Option(
@@ -1641,8 +1718,17 @@ def new_julia_env(
     no_commit: Annotated[
         bool, typer.Option("--no-commit", help="Do not commit changes.")
     ] = False,
+    no_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-check",
+            help="Do not check environment is up-to-date after creation.",
+        ),
+    ] = False,
 ):
-    """Create a new Julia environment."""
+    """Create a new Julia environment or add an existing one to calkit.yaml."""
+    if path is None:
+        path = "Project.toml"
     if not os.path.basename(path) == "Project.toml":
         raise_error(
             "Julia environment paths must point to a Project.toml file"
@@ -1665,27 +1751,57 @@ def new_julia_env(
             f"Environment with name {name} already exists "
             "(use -f to overwrite)"
         )
-    # Create the environment now
+    # Detect Julia version if not supplied
+    if julia_version is None:
+        try:
+            julia_version = calkit.julia.get_version()
+        except ValueError as e:
+            raise_error(
+                f"Failed to detect Julia version: {e}. "
+                "Use --julia to specify a version."
+            )
+    # Check for duplicate Julia environments with same path and version
+    for env_name, env_config in envs.items():
+        if (
+            env_config.get("kind") == "julia"
+            and env_config.get("path") == path
+            and env_config.get("julia") == julia_version
+        ):
+            raise_error(
+                f"Julia environment '{env_name}' already exists with path "
+                f"'{path}' and version '{julia_version}'; "
+                f"Use a different path, version, or --overwrite to replace it"
+            )
     env_dir = os.path.dirname(path)
     if env_dir:
         os.makedirs(env_dir, exist_ok=True)
     else:
         env_dir = "."
-    # First make sure the Julia version is installed
-    cmd = ["juliaup", "add", julia_version]
-    try:
-        subprocess.run(cmd, check=True)
-    except subprocess.CalledProcessError:
-        raise_error(f"Failed to install Julia version {julia_version}")
-    cmd = ["julia", f"+{julia_version}", f"--project={env_dir}", "-e"]
-    install_cmd = "using Pkg;"
-    for package in packages:
-        install_cmd += f' Pkg.add("{package}");'
-    cmd.append(install_cmd)
-    try:
-        subprocess.run(cmd, check=True)
-    except subprocess.CalledProcessError:
-        raise_error("Failed to create new Julia environment")
+    project_exists = os.path.isfile(path)
+    created_project_file = False
+    # If packages are provided, initialize via Julia/Pkg.
+    if packages:
+        # First make sure the Julia version is installed
+        cmd = ["juliaup", "add", julia_version]
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError:
+            raise_error(f"Failed to install Julia version {julia_version}")
+        cmd = ["julia", f"+{julia_version}", f"--project={env_dir}", "-e"]
+        install_cmd = f'using Pkg; Pkg.activate("{env_dir}");'
+        for package in packages or []:
+            install_cmd += f' Pkg.add("{package}");'
+        cmd.append(install_cmd)
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError:
+            raise_error("Failed to create new Julia environment")
+    elif not project_exists:
+        # Allow creating a Julia environment scaffold without requiring Julia
+        # tooling at creation time. IJulia or other packages can be added later.
+        with open(path, "w") as f:
+            f.write("[deps]\n")
+        created_project_file = True
     typer.echo("Adding environment to calkit.yaml")
     env = dict(kind="julia", path=path, julia=julia_version)
     if description is not None:
@@ -1694,11 +1810,18 @@ def new_julia_env(
     ck_info["environments"] = envs
     with open("calkit.yaml", "w") as f:
         ryaml.dump(ck_info, f)
-    repo.git.add(path)
-    repo.git.add(os.path.join(env_dir, "Manifest.toml"))
-    repo.git.add("calkit.yaml")
-    if not no_commit and repo.git.diff("--staged"):
-        repo.git.commit(["-m", f"Add Julia env {name}"])
+    if not no_commit:
+        repo.git.add("calkit.yaml")
+        if packages or created_project_file:
+            repo.git.add(path)
+        if packages:
+            repo.git.add(os.path.join(env_dir, "Manifest.toml"))
+        if not no_check and packages:
+            env_lock_fpath = check_environment(env_name=name)
+            if env_lock_fpath is not None:
+                repo.git.add(env_lock_fpath)
+        if repo.git.diff("--staged"):
+            repo.git.commit(["-m", f"Add Julia env {name}"])
 
 
 @new_app.command("renv")

{calkit_python-0.35.7 → calkit_python-0.36.0}/calkit/cli/notebooks.py

@@ -84,6 +84,39 @@ def _parse_params(params: list[str]) -> dict[str, Any]:
     return parameters
 
 
+def _check_ijulia_available(
+    julia_version: str,
+    env_dir: str,
+) -> bool:
+    ijulia_check_cmd = [
+        "julia",
+        f"+{julia_version}",
+        "--project=" + env_dir,
+        "-e",
+        (
+            "import Pkg; "
+            "deps = Pkg.project().dependencies; "
+            'if !haskey(deps, "IJulia"); '
+            'println("IJulia is not in this Julia project environment."); '
+            "exit(3); "
+            "end"
+        ),
+    ]
+    try:
+        ijulia_check_cmd_checked = calkit.julia.check_version_in_command(
+            ijulia_check_cmd
+        )
+    except Exception as e:
+        raise_error(f"Failed to check Julia version: {e}")
+        return False
+    res = subprocess.run(
+        ijulia_check_cmd_checked,
+        capture_output=True,
+        text=True,
+    )
+    return res.returncode == 0
+
+
 @notebooks_app.command("check-kernel")
 def check_env_kernel(
     env_name: Annotated[
@@ -115,10 +148,25 @@ def check_env_kernel(
     verbose: Annotated[
         bool, typer.Option("--verbose", "-v", help="Print verbose output.")
     ] = False,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output result as JSON."),
+    ] = False,
+    auto_add_deps: Annotated[
+        bool,
+        typer.Option(
+            "--auto-add-deps",
+            help=(
+                "Automatically install missing kernel dependencies "
+                "(e.g., IJulia for Julia environments)."
+            ),
+        ),
+    ] = False,
 ) -> tuple[str, str]:
     """Check that an environment has a registered Jupyter kernel."""
     from calkit.cli.check import check_environment
     from calkit.cli.main import run_in_env
+    from calkit.cli.update import update_environment
     from calkit.environments import language_from_env
 
     def get_env():
@@ -152,14 +200,24 @@ def check_env_kernel(
             "--display-name",
             display_name,
         ]
-        res = run_in_env(
-            cmd=cmd,
-            env_name=env_name,
-            no_check=no_check,
-            verbose=verbose,
-            relaxed_check=True,
-        )
-        return kernel_name, display_name
+        if json_output:
+            # For JSON output, run silently and don't show intermediate
+            # messages
+            res = run_in_env(
+                cmd=cmd,
+                env_name=env_name,
+                no_check=no_check,
+                verbose=False,
+                relaxed_check=True,
+            )
+        else:
+            res = run_in_env(
+                cmd=cmd,
+                env_name=env_name,
+                no_check=no_check,
+                verbose=verbose,
+                relaxed_check=True,
+            )
     elif language == "r":
         cmd = [
             "Rscript",
@@ -176,7 +234,6 @@ def check_env_kernel(
             verbose=verbose,
             relaxed_check=True,
         )
-        return kernel_name, display_name
     elif language == "julia":
         if not no_check:
             check_environment(env_name=env_name, verbose=verbose)
@@ -193,6 +250,43 @@ def check_env_kernel(
         if not env_dir:
             env_dir = "."
         env_dir_abs = os.path.abspath(env_dir)
+        # In reproducible Julia environments we disable global package loading,
+        # so IJulia must exist in the project environment itself.
+        ijulia_ok = _check_ijulia_available(
+            julia_version=julia_version,
+            env_dir=env_dir,
+        )
+        if not ijulia_ok:
+            should_install = auto_add_deps
+            if not should_install and sys.stdin.isatty() and not json_output:
+                should_install = typer.confirm(
+                    (
+                        "IJulia is not installed in this Julia environment. "
+                        "Install now with "
+                        f"'calkit update env --name {env_name} --add IJulia'?"
+                    ),
+                    default=True,
+                )
+            if not should_install:
+                raise_error(
+                    "IJulia is not installed in this Julia environment. "
+                    "Install it and retry, or pass --auto-add-deps to "
+                    "install automatically."
+                )
+            try:
+                update_environment(env_name=env_name, add_packages=["IJulia"])
+            except Exception as e:
+                raise_error(f"Failed to install IJulia: {e}")
+            ijulia_ok = _check_ijulia_available(
+                julia_version=julia_version,
+                env_dir=env_dir,
+            )
+            if not ijulia_ok:
+                raise_error(
+                    "IJulia installation completed but the dependency check "
+                    "still failed."
+                )
+        # Don't include version in display_name; IJulia appends it automatically
         julia_cmd = (
             "import IJulia;"
             "kp=IJulia.installkernel("
@@ -218,13 +312,25 @@ def check_env_kernel(
             raise_error(f"Failed to create kernel:\n{res.stdout}")
         kernel_path = res.stdout.strip()
         kernel_name = os.path.basename(kernel_path)
-        typer.echo(
-            f"Registered IJulia kernel '{kernel_name}' at: {kernel_path}"
-        )
-        return kernel_name, display_name
+        # Update display_name to include version for matching in VS Code
+        # The kernel name format is like: project_-env-X.Y or project_-env-X.Y.Z
+        # Extract version from kernel_name or use julia_version
+        display_name = f"{display_name} {julia_version}"
+        if not json_output:
+            typer.echo(
+                f"Registered IJulia kernel '{kernel_name}' at: {kernel_path}"
+            )
     else:
         raise_error(f"{language} not supported")
         return "", ""  # For typing analysis since raise_error exits
+    # Output result
+    if json_output:
+        result = {
+            "kernel_name": kernel_name,
+            "display_name": display_name,
+        }
+        typer.echo(json.dumps(result))
+    return kernel_name, display_name
 
 
 @notebooks_app.command("exec", help="Alias for 'execute'.")