calkit-python 0.9.0__tar.gz → 0.9.2__tar.gz

{calkit_python-0.9.0 → calkit_python-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: calkit-python
-Version: 0.9.0
+Version: 0.9.2
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://github.com/calkit/calkit
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -106,8 +106,8 @@ If you want to use [Docker](https://docker.com) containers,
 which is typically a good idea,
 that should also be installed.
 For Python, we recommend
-[Mambaforge](https://conda-forge.org/miniforge/).
-If you're a Windows user and decide to install Mambaforge or any other
+[Miniforge](https://conda-forge.org/miniforge/).
+If you're a Windows user and decide to install Miniforge or any other
 Conda-based distribution,
 e.g., Anaconda, you'll probably want to ensure that environment is
 [activated by default in Git Bash](https://discuss.codecademy.com/t/setting-up-conda-in-git-bash/534473).

{calkit_python-0.9.0 → calkit_python-0.9.2}/README.md

@@ -75,8 +75,8 @@ If you want to use [Docker](https://docker.com) containers,
 which is typically a good idea,
 that should also be installed.
 For Python, we recommend
-[Mambaforge](https://conda-forge.org/miniforge/).
-If you're a Windows user and decide to install Mambaforge or any other
+[Miniforge](https://conda-forge.org/miniforge/).
+If you're a Windows user and decide to install Miniforge or any other
 Conda-based distribution,
 e.g., Anaconda, you'll probably want to ensure that environment is
 [activated by default in Git Bash](https://discuss.codecademy.com/t/setting-up-conda-in-git-bash/534473).

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.9.0"
+__version__ = "0.9.2"
 
 from .core import *
 from . import git

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/cli/config.py

@@ -57,3 +57,11 @@ def setup_remote_auth():
         if name == "calkit" or name.startswith("calkit:"):
             typer.echo(f"Setting up authentication for DVC remote: {name}")
             set_remote_auth(remote_name=name)
+
+
+@config_app.command(name="list")
+def list_config_keys():
+    """List keys in the config."""
+    cfg = config.read()
+    for key in cfg.model_dump():
+        typer.echo(key)

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/cli/main.py

@@ -23,6 +23,7 @@ from calkit.cli.list import list_app
 from calkit.cli.new import new_app
 from calkit.cli.notebooks import notebooks_app
 from calkit.cli.office import office_app
+from calkit.cli.update import update_app
 from calkit.models import Procedure
 
 app = typer.Typer(
@@ -42,6 +43,7 @@ app.add_typer(notebooks_app, name="nb", help="Work with Jupyter notebooks.")
 app.add_typer(list_app, name="list", help="List Calkit objects.")
 app.add_typer(import_app, name="import", help="Import objects.")
 app.add_typer(office_app, name="office", help="Work with Microsoft Office.")
+app.add_typer(update_app, name="update", help="Update objects.")
 
 
 @app.callback()
@@ -291,26 +293,57 @@ def save(
         push()
 
 
-@app.command(name="pull", help="Pull with both Git and DVC.")
-def pull():
+@app.command(name="pull")
+def pull(
+    no_check_auth: Annotated[bool, typer.Option("--no-check-auth")] = False
+):
+    """Pull with both Git and DVC."""
     typer.echo("Git pulling")
-    subprocess.call(["git", "pull"])
+    try:
+        subprocess.check_call(["git", "pull"])
+    except subprocess.CalledProcessError:
+        raise_error("Git pull failed")
     typer.echo("DVC pulling")
-    subprocess.call(["dvc", "pull"])
+    if not no_check_auth:
+        # Check that our dvc remotes all have our DVC token set for them
+        remotes = calkit.dvc.get_remotes()
+        for name, url in remotes.items():
+            if name == "calkit" or name.startswith("calkit:"):
+                typer.echo(f"Checking authentication for DVC remote: {name}")
+                calkit.dvc.set_remote_auth(remote_name=name)
+    try:
+        subprocess.check_call(["dvc", "pull"])
+    except subprocess.CalledProcessError:
+        raise_error("DVC pull failed")
 
 
-@app.command(name="push", help="Push with both Git and DVC.")
-def push():
+@app.command(name="push")
+def push(
+    no_check_auth: Annotated[bool, typer.Option("--no-check-auth")] = False
+):
+    """Push with both Git and DVC."""
     typer.echo("Pushing to Git remote")
-    subprocess.call(["git", "push"])
+    try:
+        subprocess.check_call(["git", "push"])
+    except subprocess.CalledProcessError:
+        raise_error("Git push failed")
     typer.echo("Pushing to DVC remote")
-    subprocess.call(["dvc", "push"])
+    if not no_check_auth:
+        # Check that our dvc remotes all have our DVC token set for them
+        remotes = calkit.dvc.get_remotes()
+        for name, url in remotes.items():
+            if name == "calkit" or name.startswith("calkit:"):
+                typer.echo(f"Checking authentication for DVC remote: {name}")
+                calkit.dvc.set_remote_auth(remote_name=name)
+    try:
+        subprocess.check_call(["dvc", "push"])
+    except subprocess.CalledProcessError:
+        raise_error("DVC push failed")
 
 
-@app.command(
-    name="local-server", help="Run the local server to interact over HTTP."
-)
+@app.command(name="local-server")
 def run_local_server():
+    """Run the local server to interact over HTTP."""
     import uvicorn
 
     uvicorn.run(

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/cli/new.py

@@ -216,7 +216,7 @@ def new_docker_env(
     layers: Annotated[
         list[str],
         typer.Option(
-            "--add-layer", help="Add a layer (options: mambaforge, foampy)."
+            "--add-layer", help="Add a layer (options: miniforge, foampy)."
         ),
     ] = [],
     wdir: Annotated[
@@ -575,7 +575,12 @@ def new_publication(
     if env_name is not None and template_type != "latex":
         raise_error("Environments can only be created for latex templates")
     if env_name is not None and env_name in envs and not overwrite:
-        raise_error(f"Environment '{env_name}' already exists")
+        typer.echo(
+            typer.style(
+                f"Environment '{env_name}' already exists; overwriting",
+                fg="yellow",
+            )
+        )
     if template_type is not None:
         try:
             template_obj = calkit.templates.get_template(template)
@@ -623,9 +628,8 @@ def new_publication(
         envs[env_name] = env
         env_remote = dict(
             kind="docker",
-            image="kjarosh/latex:2024.4",
-            description="TeXlive full from kjarosh.",
-            platform="linux/amd64",
+            image="texlive/texlive:latest-full",
+            description="TeXlive full.",
         )
         with open(env_path, "w") as f:
             calkit.ryaml.dump(env_remote, f)
@@ -644,7 +648,10 @@ def new_publication(
         repo.git.add(path)
     # Create stage if applicable
     if stage_name is not None and template_type == "latex":
-        cmd = f"cd {path} && latexmk -pdf {template_obj.target}"
+        cmd = (
+            f"cd {path} && latexmk -interaction=nonstopmode "
+            f"-pdf {template_obj.target}"
+        )
         if env_name is not None:
             cmd = f'calkit runenv -n {env_name} "{cmd}"'
         target_dep = os.path.join(path, template_obj.target)

calkit_python-0.9.2/calkit/cli/update.py

@@ -0,0 +1,39 @@
+"""CLI for updating objects."""
+
+from __future__ import annotations
+
+import os
+
+import requests
+import typer
+from typing_extensions import Annotated
+
+update_app = typer.Typer(no_args_is_help=True)
+
+
+@update_app.command(name="devcontainer")
+def update_devcontainer(
+    wdir: Annotated[
+        str,
+        typer.Option(
+            "--wdir",
+            help=(
+                "Working directory. "
+                "By default will run current working directory."
+            ),
+        ),
+    ] = None,
+):
+    """Update a project's devcontainer to match the latest Calkit spec."""
+    url = (
+        "https://raw.githubusercontent.com/calkit/devcontainer/"
+        "refs/heads/main/devcontainer.json"
+    )
+    typer.echo(f"Downloading {url}")
+    resp = requests.get(url)
+    out_dir = os.path.join(wdir or ".", ".devcontainer")
+    os.makedirs(out_dir, exist_ok=True)
+    out_fpath = os.path.join(out_dir, "devcontainer.json")
+    typer.echo(f"Writing to {out_fpath}")
+    with open(out_fpath, "w") as f:
+        f.write(resp.text)

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/config.py

@@ -7,8 +7,14 @@ from typing import Literal
 
 import keyring
 import yaml
+from keyring.errors import NoKeyringError
 from pydantic import computed_field
-from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+)
 
 
 def get_env() -> Literal["local", "staging", "production"]:
@@ -21,9 +27,9 @@ def set_env(name: Literal["local", "staging", "production"]) -> None:
     os.environ[f"{__package__.upper()}_ENV"] = name
 
 
-def get_env_suffix() -> str:
+def get_env_suffix(sep: str = "-") -> str:
     if get_env() != "production":
-        return "-" + get_env()
+        return sep + get_env()
     return ""
 
 
@@ -39,16 +45,35 @@ class Settings(BaseSettings):
             f"config{get_env_suffix()}.yaml",
         ),
         extra="ignore",
+        env_prefix="CALKIT" + get_env_suffix(sep="_") + "_",
     )
     username: str | None = None
     token: str | None = None
     dvc_token: str | None = None
     dataframe_engine: Literal["pandas", "polars"] = "pandas"
 
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource]:
+        return (
+            init_settings,
+            env_settings,
+            YamlConfigSettingsSource(settings_cls),
+        )
+
     @computed_field
     @property
-    def password(self) -> str:
-        return keyring.get_password(get_app_name(), self.username)
+    def password(self) -> str | None:
+        try:
+            return keyring.get_password(get_app_name(), self.username)
+        except NoKeyringError:
+            return None
 
     @password.setter
     def password(self, value: str) -> None:
@@ -66,8 +91,4 @@ class Settings(BaseSettings):
 
 def read() -> Settings:
     """Read the config."""
-    fpath = Settings.model_config["yaml_file"]
-    if not os.path.isfile(fpath):
-        return Settings()
-    with open(fpath) as f:
-        return Settings.model_validate(yaml.safe_load(f))
+    return Settings()

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/docker.py

@@ -1,9 +1,9 @@
 """Functionality for working with Docker."""
 
-MAMBAFORGE_LAYER_TXT = r"""
+MINIFORGE_LAYER_TXT = r"""
 # Install Miniforge
-ARG MINIFORGE_NAME=Mambaforge
-ARG MINIFORGE_VERSION=24.3.0-0
+ARG MINIFORGE_NAME=Miniforge3
+ARG MINIFORGE_VERSION=24.9.2-0
 ARG TARGETPLATFORM
 
 ENV CONDA_DIR=/opt/conda
@@ -47,6 +47,7 @@ RUN pip install --no-cache-dir numpy pandas matplotlib h5py \
 """.strip()
 
 LAYERS = {
-    "mambaforge": MAMBAFORGE_LAYER_TXT,
+    "mambaforge": MINIFORGE_LAYER_TXT,
+    "miniforge": MINIFORGE_LAYER_TXT,
     "foampy": FOAMPY_LAYER_TEXT,
 }

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/templates/latex/core.py

@@ -7,5 +7,6 @@ GITIGNORE = """
 *.log
 *.pdf
 *.out
+*.gz
 *.DS_Store
 """

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/tests/cli/test_main.py

@@ -17,7 +17,7 @@ def test_run_in_env(tmp_dir):
         "--name my-image "
         "--stage build-image "
         "--from ubuntu "
-        "--add-layer mambaforge "
+        "--add-layer miniforge "
         "--description 'This is a test image'",
         shell=True,
     )
@@ -37,7 +37,7 @@ def test_run_in_env(tmp_dir):
         "--stage build-image-2 "
         "--path Dockerfile.2 "
         "--from ubuntu "
-        "--add-layer mambaforge "
+        "--add-layer miniforge "
         "--add-layer foampy "
         "--description 'This is a test image 2'",
         shell=True,

{calkit_python-0.9.0 → calkit_python-0.9.2}/calkit/tests/cli/test_new.py

@@ -167,5 +167,5 @@ def test_new_publication(tmp_dir):
     stage = dvc_pipeline["stages"]["build-latex-article"]
     assert stage["cmd"] == (
         "calkit runenv -n my-latex-env "
-        '"cd my-paper && latexmk -pdf paper.tex"'
+        '"cd my-paper && latexmk -interaction=nonstopmode -pdf paper.tex"'
     )

{calkit_python-0.9.0 → calkit_python-0.9.2}/docs/tutorials/conda-envs.md

@@ -69,16 +69,17 @@ If you run something like:
 
 ```sh
 calkit new conda-env \
-    -n my-project-py11 \
+    -n my-project-py311 \
     python=3.11 \
     pip \
     matplotlib \
     pandas \
     jupyter \
-    --pip tensorflow \
-    --stage check-conda-env
+    --pip tensorflow
 ```
 
-Calkit will create an environment definition in `calkit.yaml` for use with
-`calkit runenv`, and since `--stage` was specified, Calkit will also add
-an environment check stage to the pipeline automatically.
+Calkit will create an environment definition in `calkit.yaml`,
+which enables running a command in this environment with
+`calkit runenv -n my-project-py311 my-command-here`.
+That call will automatically create or update the Conda environment on the fly
+as needed and export a lock file describing the actual environment.