calkit-python 0.30.4__tar.gz → 0.30.6__tar.gz

{calkit_python-0.30.4 → calkit_python-0.30.6}/PKG-INFO

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

{calkit_python-0.30.4 → calkit_python-0.30.6}/calkit/__init__.py

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

{calkit_python-0.30.4 → calkit_python-0.30.6}/calkit/cli/main.py

@@ -9,6 +9,7 @@ import logging
 import os
 import platform as _platform
 import posixpath
+import shutil
 import subprocess
 import sys
 import time
@@ -1828,20 +1829,41 @@ def set_env_var(
 @app.command(name="upgrade")
 def upgrade():
     """Upgrade Calkit."""
-    if calkit.check_dep_exists("pipx"):
-        cmd = ["pipx", "upgrade", "calkit-python"]
-    elif calkit.check_dep_exists("uv"):
+    # First detect how Calkit is installed
+    # If installed with uv tool, calkit will be located at something like
+    # ~/.local/bin/calkit
+    which_calkit = shutil.which("calkit")
+    if which_calkit is None:
+        raise_error("Calkit is not installed")
+    split_path = os.path.normpath(str(which_calkit)).split(os.sep)
+    if (
+        ".local" in split_path
+        and "bin" in split_path
+        and calkit.check_dep_exists("uv")
+    ):
+        # This is a uv tool install
         cmd = [
             "uv",
-            "pip",
+            "tool",
             "install",
-            "--system",
             "--upgrade",
             "calkit-python",
         ]
+    elif "pipx" in split_path and calkit.check_dep_exists("pipx"):
+        cmd = ["pipx", "upgrade", "calkit-python"]
     else:
-        cmd = ["pip", "install", "--upgrade", "calkit-python"]
-    subprocess.run(cmd)
+        cmd = [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--upgrade",
+            "calkit-python",
+        ]
+    res = subprocess.run(cmd)
+    if res.returncode != 0:
+        raise_error("Upgrade failed")
+    typer.echo("Success!")
 
 
 @app.command(name="switch-branch")

{calkit_python-0.30.4 → calkit_python-0.30.6}/calkit/cli/notebooks.py

@@ -89,28 +89,104 @@ def check_env_kernel(
             "--no-check", help="Do not check environment before executing."
         ),
     ] = False,
+    language: Annotated[
+        str | None,
+        typer.Option(
+            "--language",
+            "-l",
+            help=(
+                "Notebook language; if 'matlab', MATLAB kernel must be "
+                "available in environment."
+            ),
+        ),
+    ] = None,
     verbose: Annotated[
         bool, typer.Option("--verbose", "-v", help="Print verbose output.")
     ] = False,
 ):
     """Check that an environment has a registered kernel."""
+    from calkit.cli.check import check_environment
     from calkit.cli.main import run_in_env
 
+    def get_env():
+        ck_info = calkit.load_calkit_info()
+        envs = ck_info.get("environments", {})
+        if env_name not in envs:
+            raise_error(
+                f"No environment '{env_name}' defined for this project"
+            )
+        return envs[env_name]
+
+    env = None
+    # Detect language from environment
+    if language is None:
+        env = get_env()
+        if env.get("kind") == "julia":
+            language = "julia"
+        else:
+            language = "python"
     project_name = calkit.detect_project_name(prepend_owner=False)
     kernel_name = calkit.to_kebab_case(f"{project_name}-{env_name}")
-    cmd = [
-        "python",
-        "-m",
-        "ipykernel",
-        "install",
-        "--user",
-        "--name",
-        kernel_name,
-        "--display-name",
-        f"{project_name}: {env_name}",
-    ]
-    run_in_env(cmd=cmd, env_name=env_name, no_check=no_check, verbose=verbose)
-    return kernel_name
+    display_name = f"{project_name}: {env_name}"
+    if language == "python":
+        cmd = [
+            "python",
+            "-m",
+            "ipykernel",
+            "install",
+            "--user",
+            "--name",
+            kernel_name,
+            "--display-name",
+            display_name,
+        ]
+        res = run_in_env(
+            cmd=cmd,
+            env_name=env_name,
+            no_check=no_check,
+            verbose=verbose,
+        )
+        return kernel_name
+    elif language == "julia":
+        if not no_check:
+            check_environment(env_name=env_name, verbose=verbose)
+        if env is None:
+            env = get_env()
+        env_path = env.get("path")
+        julia_version = env.get("julia")
+        env_fname = os.path.basename(env_path)
+        if not env_fname == "Project.toml":
+            raise_error(
+                "Julia environments require a path pointing to Project.toml"
+            )
+        env_dir = os.path.dirname(env_path)
+        if not env_dir:
+            env_dir = "."
+        julia_cmd = (
+            "import IJulia;"
+            "kp=IJulia.installkernel("
+            f'"{display_name}",'
+            '"--project=@.",'
+            'env=Dict("JULIA_LOAD_PATH" => "@:@stdlib")'
+            ");"
+            "println(kp);"
+        )
+        cmd = [
+            "julia",
+            f"+{julia_version}",
+            "--project=" + env_dir,
+            "-e",
+            julia_cmd,
+        ]
+        res = subprocess.run(cmd, capture_output=True, text=True)
+        if res.returncode != 0:
+            raise_error(f"Failed to create kernel:\n{res.stdout}")
+        kernel_path = res.stdout.strip()
+        typer.echo(f"Registered IJulia kernel at: {kernel_path}")
+        kernel_name = os.path.basename(kernel_path)
+        return kernel_name
+    else:
+        raise_error(f"{language} not supported")
 
 
 @notebooks_app.command("execute")
@@ -164,7 +240,7 @@ def execute_notebook(
         ),
     ] = None,
     language: Annotated[
-        str,
+        str | None,
         typer.Option(
             "--language",
             "-l",
@@ -173,7 +249,7 @@ def execute_notebook(
                 "available in environment."
             ),
         ),
-    ] = "python",
+    ] = None,
     verbose: Annotated[
         bool, typer.Option("--verbose", "-v", help="Print verbose output.")
     ] = False,
@@ -187,22 +263,34 @@ def execute_notebook(
 
     if os.path.isabs(path):
         raise ValueError("Path must be relative")
+    # Detect language from environment
+    if language is None:
+        ck_info = calkit.load_calkit_info()
+        envs = ck_info.get("environments", {})
+        if env_name not in envs:
+            raise_error(
+                f"No environment '{env_name}' defined for this project"
+            )
+        env = envs[env_name]
+        if env.get("kind") == "julia":
+            language = "julia"
+        else:
+            language = "python"
+        typer.echo(f"Using {language} as notebook language")
     if language.lower() not in ["python", "matlab", "julia"]:
         raise ValueError(
             "Language must be one of 'python', 'matlab', or 'julia'"
         )
     # First, ensure the specified environment has a kernel we can use
     # We need to check the environment type and create the kernel if needed
-    if language.lower() == "python":
+    if language.lower() in ["python", "julia"]:
         kernel_name = check_env_kernel(
             env_name=env_name, no_check=no_check, verbose=verbose
         )
     elif language.lower() == "matlab":
         kernel_name = "jupyter_matlab_kernel"
-    else:
-        raise_error(f"Language '{language}' not yet supported")
-    # We can't handle parameters unless language is Python
-    if language.lower() != "python":
+    # We can't handle parameters unless language is Python or Julia
+    if language.lower() not in ["python", "julia"]:
         if params or params_json is not None or params_base64 is not None:
             raise_error("Parameters can only be passed to Python notebooks")
     # Parse parameters

{calkit_python-0.30.4 → calkit_python-0.30.6}/calkit/config.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import platform
+import warnings
 from typing import Any, Literal
 from typing import get_args as get_type_args
 
@@ -38,6 +39,9 @@ def supports_keyring() -> bool:
     except keyring.errors.InitError:
         # Backend failed to initialize (e.g., user dismissed prompt)
         return False
+    except keyring.errors.KeyringLocked:
+        warnings.warn("Keyring is locked; will use YAML config file")
+        return False
     except keyring.errors.KeyringError as e:
         # Check if the underlying exception indicates no backend
         if "No backend found" in str(e):

{calkit_python-0.30.4 → calkit_python-0.30.6}/calkit/tests/cli/test_notebooks.py

@@ -135,3 +135,38 @@ def test_execute_notebook(tmp_dir):
     assert params_out["my_value"] == project_params["my_project_value"]
     assert params_out["my_list"] == list(range(1, 6))
     assert params_out["my_dict"] == params["my_dict"]
+
+
+def test_execute_notebook_julia(tmp_dir):
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "project",
+            ".",
+            "-n",
+            "cool-project",
+            "--title",
+            "Cool project",
+        ]
+    )
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "julia-env",
+            "--name",
+            "main",
+            "--julia",
+            "1.11",
+            "IJulia",
+        ]
+    )
+    nb_fpath = os.path.join(
+        os.path.dirname(__file__), "..", "..", "..", "test", "nb-julia.ipynb"
+    )
+    os.makedirs("notebooks")
+    shutil.copy(nb_fpath, "notebooks/main.ipynb")
+    subprocess.check_call(
+        ["calkit", "nb", "execute", "-e", "main", "notebooks/main.ipynb"]
+    )

calkit_python-0.30.6/test/nb-julia.ipynb

@@ -0,0 +1,25 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0",
+   "metadata": {
+    "vscode": {
+     "languageId": "julia"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "println(\"Hello from Julia!\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}