calkit-python 0.20.2__tar.gz → 0.20.4__tar.gz

{calkit_python-0.20.2 → calkit_python-0.20.4}/PKG-INFO

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

{calkit_python-0.20.2 → calkit_python-0.20.4}/calkit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.20.2"
+__version__ = "0.20.4"
 
 from .core import *
 from . import git

{calkit_python-0.20.2 → calkit_python-0.20.4}/calkit/cli/import_.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import base64
 import os
 import subprocess
+from copy import deepcopy
 from typing import Annotated
 
 import git
@@ -208,7 +209,7 @@ def import_dataset(
 
 @import_app.command(name="environment")
 def import_environment(
-    src_path: Annotated[
+    src: Annotated[
         str,
         typer.Argument(
             help=(
@@ -236,12 +237,66 @@ def import_environment(
             help="Force adding the dataset even if it already exists.",
         ),
     ] = False,
+    no_commit: Annotated[
+        bool, typer.Option("--no-commit", help="Do not commit changes.")
+    ] = False,
 ) -> None:
-    project, env_name = src_path.split(":")
+    """Import an environment from another project."""
+    raise_error(
+        "This command is not yet implemented; "
+        "please thumbs-up this issue if you'd like to see "
+        "it finished: https://github.com/calkit/calkit/issues/239"
+    )
+    try:
+        project, env_name = src.split(":")
+    except ValueError:
+        raise_error("Invalid source environment specification")
     if os.path.isdir(project):
-        cloud = False
-        typer.echo("Importing from local project directory")
+        typer.echo(f"Importing from local project directory: {project}")
+        src_ck_info = calkit.load_calkit_info(
+            wdir=project, process_includes=True
+        )
+        environments = src_ck_info.get("environments", {})
+        if env_name not in environments:
+            raise_error(f"Environment {env_name} not found in project")
+        src_env = environments[env_name]
+        if "path" in src_env:
+            env_path = src_env["path"]
+        try:
+            src_project_name = calkit.detect_project_name(project)
+        except Exception as e:
+            raise_error(f"Could not detect source project name: {e}")
     else:
-        cloud = True
         typer.echo("Importing from Cloud project")
-    raise_error("Not yet implemented")  # TODO
+        try:
+            resp = calkit.cloud.get(
+                f"/projects/{project}/environments/{env_name}"
+            )
+        except Exception as e:
+            raise_error(f"Failed to fetch environment info from cloud: {e}")
+        src_project_name = project
+        # TODO: Parse information we need from the response
+    # Write environment into current Calkit info
+    ck_info = calkit.load_calkit_info()
+    environments = ck_info.get("environments", {})
+    # Check if an environment with this name already exists
+    if dest_name is None:
+        dest_name = env_name
+    if dest_name in environments and not overwrite:
+        raise_error("An environment with this name already exists")
+    # If source env is imported, don't update that field
+    new_env = deepcopy(src_env)
+    if "imported_from" not in new_env:
+        new_env["imported_from"]["project"] = src_project_name
+    if dest_path is not None and "path" in new_env:
+        new_env["path"] = dest_path
+    # TODO: Write the environment content to file if necessary
+    new_env = dict(imported_from=dict(project=project))
+    environments[dest_name] = new_env
+    ck_info["environments"] = environments
+    with open("calkit.yaml", "w") as f:
+        calkit.ryaml.dump(ck_info, f)
+    repo = git.Repo()
+    repo.git.add("calkit.yaml")
+    if not no_commit and calkit.git.get_staged_files():
+        repo.git.commit(["-m", f"Import environment {src}"])

{calkit_python-0.20.2 → calkit_python-0.20.4}/calkit/cli/main.py

@@ -856,6 +856,8 @@ def run_in_env(
         ]
         if platform:
             docker_cmd += ["--platform", platform]
+        if docker_user := env.get("user"):
+            docker_cmd += ["--user", docker_user]
         docker_cmd += env.get("args", [])
         docker_cmd += [
             "-it" if sys.stdin.isatty() else "-i",

{calkit_python-0.20.2 → calkit_python-0.20.4}/calkit/cli/new.py

@@ -159,7 +159,7 @@ def new_project(
             calkit.dvc.set_remote_auth(wdir=abs_path)
         except Exception:
             warn("Failed to setup Calkit DVC remote auth")
-        prj = calkit.git.detect_project_name(path=abs_path)
+        prj = calkit.detect_project_name(wdir=abs_path)
         add_msg = f"\n\nYou can view your project at https://calkit.io/{prj}"
         typer.echo(success_message + add_msg)
         return
@@ -498,6 +498,12 @@ def new_docker_env(
     wdir: Annotated[
         str, typer.Option("--wdir", help="Working directory.")
     ] = "/work",
+    user: Annotated[
+        str,
+        typer.Option(
+            "--user", help="User account to use to run the container."
+        ),
+    ] = None,
     platform: Annotated[
         str, typer.Option("--platform", help="Which platform(s) to build for.")
     ] = None,
@@ -563,6 +569,8 @@ def new_docker_env(
         env["layers"] = layers
     if platform:
         env["platform"] = platform
+    if user:
+        env["user"] = user
     envs[name] = env
     ck_info["environments"] = envs
     with open("calkit.yaml", "w") as f:
@@ -1604,7 +1612,7 @@ def new_release(
     # Is there already a deposition for this release, which indicates we should
     # create a new version?
     zenodo_dep_id = None
-    project_name = calkit.git.detect_project_name()
+    project_name = calkit.detect_project_name()
     zenodo_metadata = dict(
         title=title,
         description=description,

{calkit_python-0.20.2 → calkit_python-0.20.4}/calkit/core.py

@@ -12,10 +12,10 @@ import pickle
 import re
 import subprocess
 
-from calkit.models import ProjectStatus
-
 import requests
 
+from calkit.models import ProjectStatus
+
 try:
     from datetime import UTC
 except ImportError:
@@ -107,9 +107,12 @@ def load_calkit_info(
                 for obj_name, obj in info[kind].items():
                     if "_include" in obj:
                         include_fpath = obj.pop("_include")
-                        with open(include_fpath) as f:
-                            include_data = ryaml.load(f)
-                        info[kind][obj_name] |= include_data
+                        if wdir is not None:
+                            include_fpath = os.path.join(wdir, include_fpath)
+                        if os.path.isfile(include_fpath):
+                            with open(include_fpath) as f:
+                                include_data = ryaml.load(f)
+                            info[kind][obj_name] |= include_data
     if as_pydantic:
         return ProjectInfo.model_validate(info)
     return info
@@ -417,3 +420,22 @@ def get_latest_project_status(wdir: str = None) -> ProjectStatus | None:
     statuses = get_project_status_history(wdir=wdir)
     if statuses:
         return statuses[-1]
+
+
+def detect_project_name(wdir: str = None) -> str:
+    """Detect a Calkit project owner and name."""
+    ck_info = load_calkit_info(wdir=wdir)
+    name = ck_info.get("name")
+    owner = ck_info.get("owner")
+    if name is None or owner is None:
+        try:
+            url = Repo(path=wdir).remote().url
+        except ValueError:
+            raise ValueError("No Git remote set with name 'origin'")
+        from_url = url.split("github.com")[-1][1:].removesuffix(".git")
+        owner_name, project_name = from_url.split("/")
+    if name is None:
+        name = project_name
+    if owner is None:
+        owner = owner_name
+    return f"{owner}/{name}"

{calkit_python-0.20.2 → calkit_python-0.20.4}/calkit/dvc.py

@@ -19,7 +19,7 @@ logger.setLevel(logging.INFO)
 
 def configure_remote(wdir: str = None):
     try:
-        project_name = calkit.git.detect_project_name(path=wdir)
+        project_name = calkit.detect_project_name(wdir=wdir)
     except ValueError as e:
         raise ValueError(f"Can't detect project name: {e}")
     # If Git origin is not set, set that

calkit_python-0.20.4/calkit/git.py

@@ -0,0 +1,15 @@
+"""Git-related functionality."""
+
+from __future__ import annotations
+
+import git
+
+
+def get_staged_files(path: str = None) -> list[str]:
+    repo = git.Repo(path)
+    cmd = ["--staged", "--name-only"]
+    if path is not None:
+        cmd.append(path)
+    diff = repo.git.diff(cmd)
+    paths = diff.split("\n")
+    return paths

{calkit_python-0.20.2 → calkit_python-0.20.4}/calkit/server.py

@@ -79,7 +79,7 @@ def get_root(get_jupyter_servers: bool = True) -> list[LocalProject]:
     for pdir in project_dirs:
         logger.info(f"Inspecting {pdir}")
         try:
-            project = calkit.git.detect_project_name(path=pdir)
+            project = calkit.detect_project_name(wdir=pdir)
         except ValueError:
             logger.warning(f"Can't detect project name in {pdir}")
             continue

calkit_python-0.20.4/calkit/tests/test_core.py

@@ -0,0 +1,60 @@
+"""Tests for the ``core`` module."""
+
+import os
+import subprocess
+
+import git
+
+import calkit
+
+
+def test_find_project_dirs():
+    calkit.find_project_dirs()
+    assert calkit.find_project_dirs(relative=False)
+
+
+def test_to_kebab_case():
+    assert calkit.to_kebab_case("THIS IS") == "this-is"
+    assert calkit.to_kebab_case("this_is_my-Project") == "this-is-my-project"
+
+
+def test_detect_project_name(tmp_dir):
+    subprocess.check_output(["calkit", "init"])
+    repo = git.Repo()
+    repo.create_remote("origin", "https://github.com/someone/some-repo.git")
+    assert calkit.detect_project_name() == "someone/some-repo"
+    with open("calkit.yaml", "w") as f:
+        f.write("owner: someone-else\nname: some-project\n")
+    assert calkit.detect_project_name() == "someone-else/some-project"
+
+
+def test_load_calkit_info(tmp_dir):
+    subpath = "some/project"
+    os.makedirs(subpath)
+    os.makedirs(subpath + "/.calkit/environments")
+    with open(subpath + "/.calkit/environments/env2.yaml", "w") as f:
+        calkit.ryaml.dump({"kind": "docker", "image": "openfoam"}, f)
+    with open(subpath + "/calkit.yaml", "w") as f:
+        calkit.ryaml.dump(
+            {
+                "name": "some-project",
+                "owner": "someone",
+                "environments": {
+                    "env1": {"kind": "docker", "image": "ubuntu"},
+                    "env2": {"_include": ".calkit/environments/env2.yaml"},
+                },
+            },
+            f,
+        )
+    ck_info = calkit.load_calkit_info(wdir=subpath)
+    assert ck_info["environments"]["env1"]["image"] == "ubuntu"
+    assert ck_info["environments"]["env2"] == {
+        "_include": ".calkit/environments/env2.yaml"
+    }
+    ck_info = calkit.load_calkit_info(wdir=subpath, process_includes=True)
+    assert ck_info["environments"]["env1"]["image"] == "ubuntu"
+    assert ck_info["environments"]["env2"]["image"] == "openfoam"
+    os.chdir(subpath)
+    ck_info = calkit.load_calkit_info(process_includes=True)
+    assert ck_info["environments"]["env1"]["image"] == "ubuntu"
+    assert ck_info["environments"]["env2"]["image"] == "openfoam"

{calkit_python-0.20.2 → calkit_python-0.20.4}/docs/pipeline/index.md

@@ -35,3 +35,6 @@ stages:
         title: The raw data
         description: Raw voltage, collected from the sensor.
 ```
+
+To learn more, see
+[DVC's pipeline documentation](https://dvc.org/doc/start/data-pipelines/data-pipelines).

{calkit_python-0.20.2 → calkit_python-0.20.4}/pyproject.toml

@@ -53,6 +53,7 @@ dev = [
   "kaleido==0.2.1",
   "numpy",
   "pandas>=2.2.3",
+  "polars>=1.18.0",
   "plotly",
   "pre-commit",
   "pyarrow",

{calkit_python-0.20.2 → calkit_python-0.20.4}/uv.lock

@@ -396,7 +396,7 @@ css = [
 
 [[package]]
 name = "calkit-python"
-version = "0.20.0"
+version = "0.20.3"
 source = { editable = "." }
 dependencies = [
     { name = "arithmeval" },
@@ -440,6 +440,7 @@ dev = [
     { name = "numpy", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "pandas" },
     { name = "plotly" },
+    { name = "polars" },
     { name = "pre-commit" },
     { name = "pyarrow" },
     { name = "pytest" },
@@ -485,6 +486,7 @@ dev = [
     { name = "numpy" },
     { name = "pandas", specifier = ">=2.2.3" },
     { name = "plotly" },
+    { name = "polars", specifier = ">=1.18.0" },
     { name = "pre-commit" },
     { name = "pyarrow" },
     { name = "pytest" },

calkit_python-0.20.2/calkit/git.py

@@ -1,36 +0,0 @@
-"""Git-related functionality."""
-
-from __future__ import annotations
-
-import git
-
-import calkit
-
-
-def detect_project_name(path: str = None) -> str:
-    """Read the project owner and name from the remote."""
-    ck_info = calkit.load_calkit_info(wdir=path)
-    name = ck_info.get("name")
-    owner = ck_info.get("owner")
-    if name is None or owner is None:
-        try:
-            url = git.Repo(path=path).remote().url
-        except ValueError:
-            raise ValueError("No Git remote set with name 'origin'")
-        from_url = url.split("github.com")[-1][1:].removesuffix(".git")
-        owner_name, project_name = from_url.split("/")
-    if name is None:
-        name = project_name
-    if owner is None:
-        owner = owner_name
-    return f"{owner}/{name}"
-
-
-def get_staged_files(path: str = None) -> list[str]:
-    repo = git.Repo(path)
-    cmd = ["--staged", "--name-only"]
-    if path is not None:
-        cmd.append(path)
-    diff = repo.git.diff(cmd)
-    paths = diff.split("\n")
-    return paths

calkit_python-0.20.2/calkit/tests/test_core.py

@@ -1,13 +0,0 @@
-"""Tests for the ``core`` module."""
-
-import calkit
-
-
-def test_find_project_dirs():
-    calkit.find_project_dirs()
-    assert calkit.find_project_dirs(relative=False)
-
-
-def test_to_kebab_case():
-    assert calkit.to_kebab_case("THIS IS") == "this-is"
-    assert calkit.to_kebab_case("this_is_my-Project") == "this-is-my-project"