calkit-python 0.10.1__tar.gz → 0.11.1__tar.gz

{calkit_python-0.10.1 → calkit_python-0.11.1}/.gitignore

@@ -1,3 +1,4 @@
 dev.ipynb
 *.pyc
 .DS_Store
+.vscode

{calkit_python-0.10.1 → calkit_python-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.10.1
+Version: 0.11.1
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://github.com/calkit/calkit
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -10,6 +10,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
+Requires-Dist: arithmeval
 Requires-Dist: docx2pdf
 Requires-Dist: dvc
 Requires-Dist: eval-type-backport; python_version < '3.10'
@@ -90,23 +91,51 @@ management interface and a DVC remote for easily storing all versions of your
 data/code/figures/publications, interacting with your collaborators,
 reusing others' research artifacts, etc.
 
-After signing up, visit the [settings](https://calkit.io/settings) page
-and create a token.
+After signing up, visit the
+[settings](https://calkit.io/settings?tab=tokens)
+page and create a token for use with the API.
 Then run
 
 ```sh
 calkit config set token ${YOUR_TOKEN_HERE}
 ```
 
-Then, inside a project repo you'd like to connect to the cloud, run
+## Quickstart
+
+After installing Calkit and setting your token as described above, run:
+
+```sh
+calkit new project calkit-project-1 \
+    --title "My first Calkit project" \
+    --template calkit/example-basic \
+    --cloud \
+    --public
+```
+
+This will create a new project from the
+[`calkit/example-basic`](https://github.com/calkit/example-basic)
+template,
+creating it in the cloud and cloning to `calkit-project-1`.
+You should now be able to run:
+
+```sh
+cd calkit-project-1
+calkit run
+```
+
+This will reproduce the project's pipeline.
+Next, you can start adding stages to the pipeline,
+modifying the Python environments and scripts,
+and editing the paper.
+All will be kept in sync with the `calkit run` command.
+
+To back up all of your work, execute:
 
 ```sh
-calkit config setup-remote
+calkit save -am "Run pipeline"
 ```
 
-This will setup the Calkit DVC remote, such that commands like `dvc push` will
-allow you to push versions of your data or pipeline outputs to the cloud
-for safe storage and sharing with your collaborators.
+This will commit and push to both GitHub and the Calkit Cloud.
 
 ## Tutorials
 

{calkit_python-0.10.1 → calkit_python-0.11.1}/README.md

@@ -58,23 +58,51 @@ management interface and a DVC remote for easily storing all versions of your
 data/code/figures/publications, interacting with your collaborators,
 reusing others' research artifacts, etc.
 
-After signing up, visit the [settings](https://calkit.io/settings) page
-and create a token.
+After signing up, visit the
+[settings](https://calkit.io/settings?tab=tokens)
+page and create a token for use with the API.
 Then run
 
 ```sh
 calkit config set token ${YOUR_TOKEN_HERE}
 ```
 
-Then, inside a project repo you'd like to connect to the cloud, run
+## Quickstart
+
+After installing Calkit and setting your token as described above, run:
+
+```sh
+calkit new project calkit-project-1 \
+    --title "My first Calkit project" \
+    --template calkit/example-basic \
+    --cloud \
+    --public
+```
+
+This will create a new project from the
+[`calkit/example-basic`](https://github.com/calkit/example-basic)
+template,
+creating it in the cloud and cloning to `calkit-project-1`.
+You should now be able to run:
+
+```sh
+cd calkit-project-1
+calkit run
+```
+
+This will reproduce the project's pipeline.
+Next, you can start adding stages to the pipeline,
+modifying the Python environments and scripts,
+and editing the paper.
+All will be kept in sync with the `calkit run` command.
+
+To back up all of your work, execute:
 
 ```sh
-calkit config setup-remote
+calkit save -am "Run pipeline"
 ```
 
-This will setup the Calkit DVC remote, such that commands like `dvc push` will
-allow you to push versions of your data or pipeline outputs to the cloud
-for safe storage and sharing with your collaborators.
+This will commit and push to both GitHub and the Calkit Cloud.
 
 ## Tutorials
 

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.10.1"
+__version__ = "0.11.1"
 
 from .core import *
 from . import git
@@ -10,3 +10,5 @@ from . import models
 from . import office
 from . import templates
 from . import conda
+from . import calc
+from . import check

calkit_python-0.11.1/calkit/calc.py

@@ -0,0 +1,255 @@
+"""Functionality for calculations."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import arithmetic_eval
+import requests
+from pydantic import BaseModel, model_validator
+
+DTYPES = {"int": int, "float": float, "str": str}
+DEFAULT_IN_TYPE = "float"
+DEFAULT_OUT_TYPE = "float"
+
+
+class Input(BaseModel):
+    name: str
+    description: str | None = None
+    dtype: Literal["int", "float", "str"] = DEFAULT_IN_TYPE
+    min: int | float | None = None
+    max: int | float | None = None
+
+
+class Output(BaseModel):
+    name: str
+    description: str | None = None
+    dtype: Literal["int", "float", "str"] = DEFAULT_OUT_TYPE
+    template: str | None = None
+
+
+class Calculation(BaseModel):
+    kind: str
+    params: dict = {}
+    name: str | None = None
+    description: str | None = None
+    inputs: list[Input] | list[str]
+    output: Output | str
+
+    @model_validator(mode="after")
+    def validate_model(self) -> Calculation:
+        input_names = self.input_names
+        if self.output_name in input_names:
+            raise ValueError("Output name must not overlap with input names")
+        if len(set(input_names)) != len(input_names):
+            raise ValueError("Input names must be unique")
+        return self
+
+    @property
+    def input_names(self) -> list[str]:
+        input_names = []
+        for i in self.inputs:
+            if isinstance(i, Input):
+                input_names.append(i.name)
+            else:
+                input_names.append(i)
+        return input_names
+
+    @property
+    def inputs_dict(self) -> dict[str, Input]:
+        res = {}
+        for i in self.inputs:
+            if isinstance(i, str):
+                res[i] = Input(name=i)
+            else:
+                res[i.name] = i
+        return res
+
+    @property
+    def output_name(self) -> str:
+        if isinstance(self.output, Output):
+            return self.output.name
+        return self.output
+
+    def check_inputs(self, **inputs) -> dict:
+        """Check that the supplied inputs match those declared and do type
+        coercion.
+        """
+        inputs_dict = self.inputs_dict
+        for k in inputs_dict:
+            if k not in inputs:
+                raise ValueError(f"Missing input {k}")
+        for k, v in inputs.items():
+            if k not in inputs_dict:
+                raise ValueError(f"{k} is not in declared inputs")
+            input_def = inputs_dict[k]
+            v = DTYPES[input_def.dtype](v)
+            inputs[k] = v
+            if input_def.min is not None and v < input_def.min:
+                raise ValueError(f"Input value {k} = {v} it too small")
+            if input_def.max is not None and v > input_def.max:
+                raise ValueError(f"Input value {k} = {v} is too large")
+        return inputs
+
+    def calculate(self, **inputs):
+        """This is the method to override to implement custom logic.
+
+        Input and output type coercion will be handled outside.
+        """
+        raise NotImplementedError
+
+    def evaluate(self, **inputs):
+        inputs = self.check_inputs(**inputs)
+        out = self.calculate(**inputs)
+        return self.coerce_output(out)
+
+    def coerce_output(self, val):
+        if isinstance(self.output, Output):
+            return DTYPES[self.output.dtype](val)
+        else:
+            return DTYPES[DEFAULT_OUT_TYPE](val)
+
+    def evaluate_and_format(self, **inputs) -> str:
+        res = self.evaluate(**inputs)
+        if isinstance(self.output, Output):
+            out_name = self.output.name
+            template = self.output.template
+        else:
+            out_name = self.output
+            template = None
+        if template is None:
+            template = "For input "
+            for input_name in inputs:
+                template += input_name + "={" + input_name + "}, "
+            template += "the output is "
+            template += out_name + "={" + out_name + "}."
+        return template.format(**(inputs | {out_name: res}))
+
+
+class FormulaParams(BaseModel):
+    formula: str
+
+
+class Formula(Calculation):
+    kind: str = "formula"
+    params: FormulaParams
+
+    def calculate(self, **inputs):
+        inputs = self.check_inputs(**inputs)
+        return arithmetic_eval.evaluate(self.params.formula, inputs)
+
+
+class LinearParams(BaseModel):
+    coeffs: dict[str, float]
+    offset: float = 0.0
+
+
+class Linear(Calculation):
+    """Calculation for a simple linear relationship."""
+
+    kind: str = "linear"
+    params: LinearParams
+
+    @model_validator(mode="after")
+    def validate_model(self) -> Linear:
+        if set(self.input_names) != set(self.params.coeffs.keys()):
+            raise ValueError("Coefficients must have same keys as input names")
+        return self
+
+    def calculate(self, **inputs):
+        val = self.params.offset
+        for input_name, input_val in inputs.items():
+            val += self.params.coeffs[input_name] * input_val
+        return val
+
+
+class LookupTableParams(BaseModel):
+    x_values: list[float]
+    y_values: list[float]
+    method: Literal["floor", "ceil", "round", "interpolate"] = "interpolate"
+
+
+class LookupTable(Calculation):
+    """A 1-D lookup table."""
+
+    kind: str = "lookup-table"
+    params: LookupTableParams
+
+
+class HttpRequestParams(BaseModel):
+    url: str
+    inputs_as_params: bool = True  # Otherwise, use body
+    method: Literal["get", "post", "put"] = "get"
+    as_json: bool = True  # Otherwise, return raw text
+
+
+class HttpRequest(Calculation):
+    """Make an HTTP request and return the result.
+
+    This should not be run on a web server since it can be insecure.
+    For example, it could make requests to private services and return
+    sensitive data.
+    """
+
+    kind: str = "http"
+    params: HttpRequestParams
+
+    def calculate(self, **inputs):
+        func = getattr(requests, self.params.method)
+        if self.params.inputs_as_params:
+            kws = {"params": inputs}
+        else:
+            kws = {"json", inputs}
+        resp: requests.Response = func(url=self.params.url, **kws)
+        resp.raise_for_status()
+        if self.params.as_json:
+            return resp.json()
+        else:
+            return resp.text
+
+
+class XGBoostModelParams(BaseModel):
+    path: str
+    type: Literal["classifier", "regressor"]
+
+
+class XGBoostModel(Calculation):
+    """Make predictions with an XGBoost model saved as JSON.
+
+    This is currently just a prototype and should not be expected to work.
+
+    One input, ``data``, should be defined to be passed to the model's
+    ``predict`` method.
+    """
+
+    kind: str = "xgboost"
+    params: XGBoostModelParams
+
+    def calculate(self, **inputs):
+        # Load model from JSON
+        import xgboost
+
+        # Convert model path to something that can be loaded if running on the
+        # Calkit Cloud
+        types = {
+            "classifier": xgboost.XGBClassifier,
+            "regressor": xgboost.XGBRegressor,
+        }
+        model = types[self.params.type]().load_model(self.params.path)
+        return model.predict(**inputs)
+
+
+def parse(data: dict) -> Calculation:
+    if isinstance(data, BaseModel):
+        data = data.model_dump()
+    # Automatically take keys not in the `kind` and move them into `params`?
+    kinds = {"formula": Formula, "lookup-table": LookupTable, "linear": Linear}
+    return kinds[data["kind"]].model_validate(data)
+
+
+def evaluate(calc_def: dict | Calculation, **inputs) -> dict:
+    return parse(calc_def).evaluate(**inputs)
+
+
+def evaluate_and_format(calc_def: dict | Calculation, **inputs) -> str:
+    return parse(calc_def).evaluate_and_format(**inputs)

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/check.py

@@ -68,7 +68,7 @@ class ReproCheck(BaseModel):
         if not self.n_dvc_remotes:
             return (
                 "No DVC remotes have been defined. "
-                "Run `calkit config setup-remote` or `dvc remote add` next."
+                "Run `calkit config remote` or `dvc remote add` next."
             )
         if not self.has_pipeline:
             return (

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/cli/config.py

@@ -42,7 +42,8 @@ def get_config_value(key: str) -> None:
         print()
 
 
-@config_app.command(name="setup-remote")
+@config_app.command(name="setup-remote", help="Alias for 'remote'.")
+@config_app.command(name="remote")
 def setup_remote():
     """Setup the Calkit cloud as the default DVC remote and store a token in
     the local config.
@@ -56,7 +57,8 @@ def setup_remote():
         raise_error("Current directory is not a Git repository")
 
 
-@config_app.command(name="setup-remote-auth")
+@config_app.command(name="setup-remote-auth", help="Alias for 'remote-auth'.")
+@config_app.command(name="remote-auth")
 def setup_remote_auth():
     """Store a Calkit cloud token in the local DVC config for all Calkit
     remotes.

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/cli/core.py

@@ -23,6 +23,10 @@ def run_cmd(cmd: list[str]):
         pty.spawn(cmd, lambda fd: os.read(fd, 1024))
 
 
-def raise_error(txt):
-    typer.echo(typer.style(txt, fg="red"), err=txt)
+def raise_error(txt: str):
+    typer.echo(typer.style("Error: " + txt, fg="red"), err=txt)
     raise typer.Exit(1)
+
+
+def warn(txt: str):
+    typer.echo(typer.style("Warning: " + txt, fg="yellow"))

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/cli/main.py

@@ -978,3 +978,42 @@ def check_conda_env(
         log_func=log_func,
         relaxed=relaxed,
     )
+
+
+@app.command(name="calc")
+def run_calculation(
+    name: Annotated[str, typer.Argument(help="Calculation name.")],
+    inputs: Annotated[
+        list[str],
+        typer.Option(
+            "--input", "-i", help="Inputs defined like x=1 (with no spaces.)"
+        ),
+    ] = [],
+    no_formatting: Annotated[
+        bool,
+        typer.Option(
+            "--no-format", help="Do not format output before printing"
+        ),
+    ] = False,
+):
+    """Run a project's calculation."""
+    ck_info = calkit.load_calkit_info()
+    calcs = ck_info.get("calculations", {})
+    if name not in calcs:
+        raise_error(f"Calculation '{name}' not defined in calkit.yaml")
+    try:
+        calc = calkit.calc.parse(calcs[name])
+    except Exception as e:
+        raise_error(f"Invalid calculation: {e}")
+    # Parse inputs
+    parsed_inputs = {}
+    for i in inputs:
+        iname, ival = i.split("=")
+        parsed_inputs[iname] = ival
+    try:
+        if no_formatting:
+            typer.echo(calc.evaluate(**parsed_inputs))
+        else:
+            typer.echo(calc.evaluate_and_format(**parsed_inputs))
+    except Exception as e:
+        raise_error(f"Calculation failed: {e}")

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/cli/new.py

@@ -3,21 +3,277 @@
 from __future__ import annotations
 
 import os
+import re
 import shutil
 import subprocess
 
 import git
 import typer
+from git.exc import InvalidGitRepositoryError
 from typing_extensions import Annotated
 
 import calkit
-from calkit.cli import raise_error
+from calkit.cli import raise_error, warn
+from calkit.cli.update import update_devcontainer
 from calkit.core import ryaml
 from calkit.docker import LAYERS
 
 new_app = typer.Typer(no_args_is_help=True)
 
 
+@new_app.command(name="project")
+def new_project(
+    path: Annotated[str, typer.Argument(help="Where to create the project.")],
+    name: Annotated[
+        str,
+        typer.Option(
+            "--name",
+            "-n",
+            help=(
+                "Project name. Will be inferred as kebab-cased directory "
+                "name if not provided."
+            ),
+        ),
+    ] = None,
+    title: Annotated[
+        str, typer.Option("--title", help="Project title.")
+    ] = None,
+    description: Annotated[
+        str, typer.Option("--description", help="Project description.")
+    ] = None,
+    cloud: Annotated[
+        bool,
+        typer.Option(
+            "--cloud",
+            help=("Create this project in the cloud (Calkit and GitHub.)"),
+        ),
+    ] = False,
+    public: Annotated[
+        bool,
+        typer.Option(
+            "--public",
+            help="Create as a public project if --cloud is selected.",
+        ),
+    ] = False,
+    git_repo_url: Annotated[
+        str,
+        typer.Option(
+            "--git-url",
+            help=(
+                "Git repo URL. "
+                "Usually https://github.com/{your_name}/{project_name}."
+            ),
+        ),
+    ] = None,
+    template: Annotated[
+        str,
+        typer.Option(
+            "--template",
+            "-t",
+            help=(
+                "Template from which to derive the project, e.g., "
+                "'calkit/example-basic'."
+            ),
+        ),
+    ] = None,
+    no_commit: Annotated[
+        bool, typer.Option("--no-commit", help="Do not commit changes to Git.")
+    ] = None,
+    overwrite: Annotated[
+        bool,
+        typer.Option(
+            "--overwrite",
+            "-f",
+            help="Overwrite project if one already exists.",
+        ),
+    ] = False,
+):
+    """Create a new project."""
+    # TODO: Update this when there is a real docs site up
+    docs_url = "https://github.com/calkit/calkit?tab=readme-ov-file#tutorials"
+    success_message = (
+        "\nCongrats on creating your new Calkit project!\n\n"
+        "Next, you'll probably want to start building your pipeline.\n\n"
+        f"Check out the docs at {docs_url}."
+    )
+    abs_path = os.path.abspath(path)
+    if (cloud or template) and os.path.exists(abs_path):
+        raise_error(
+            "Must specify a new directory if using --cloud or --template"
+        )
+    ck_info_fpath = os.path.join(abs_path, "calkit.yaml")
+    if os.path.isfile(ck_info_fpath) and not overwrite:
+        raise_error(
+            "Destination is already a Calkit project; "
+            "use --overwrite to continue"
+        )
+    if os.path.isdir(abs_path) and os.listdir(abs_path):
+        warn(f"{abs_path} is not empty")
+    if name is None:
+        name = re.sub(r"[-_,\.\ ]", "-", os.path.basename(abs_path).lower())
+    if " " in name:
+        warn("Invalid name; replacing spaces with hyphens")
+        name = name.replace(" ", "-")
+    typer.echo(f"Creating project {name}")
+    if title is None:
+        title = typer.prompt("Enter a title (ex: 'My research project')")
+    typer.echo(f"Using title: {title}")
+    if cloud:
+        # Cloud should allow None, which will allow us to post just the name
+        # NOTE: This will fail if the user hasn't logged into GitHub in a
+        # while, and their token stored in the Calkit cloud is expired
+        try:
+            resp = calkit.cloud.post(
+                "/projects",
+                json=dict(
+                    name=name,
+                    title=title,
+                    description=description,
+                    git_repo_url=git_repo_url,
+                    is_public=public,
+                    template=template,
+                ),
+            )
+        except Exception as e:
+            raise_error(f"Posting new project to cloud failed: {e}")
+        # Now clone here and that's about
+        subprocess.run(["git", "clone", resp["git_repo_url"], abs_path])
+        try:
+            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)
+        add_msg = f"\n\nYou can view your project at https://calkit.io/{prj}"
+        typer.echo(success_message + add_msg)
+        return
+    # If using a template, clone it first
+    if template:
+        # TODO: If the template is not a Git repo URL, make a request to the
+        # Calkit Cloud to get it?
+        # For now, assume consistency between Calkit Cloud projects and
+        # GitHub repo URLs
+        if "github.com" in template:
+            template_git_url = template
+            template_name = template.split("github.com")[-1][1:].removesuffix(
+                ".git"
+            )
+        else:
+            template_name = template
+            template_git_url = f"https://github.com/{template}"
+        # Now clone it
+        subprocess.run(["git", "clone", template_git_url, abs_path])
+        # Templates should always have DVC initialized, so no need to do that
+        repo = git.Repo(abs_path)
+        git_rev = repo.git.rev_parse("HEAD")
+        # Rename origin remote as upstream
+        typer.echo("Renaming template remote as upstream")
+        repo.git.remote(["rename", "origin", "upstream"])
+        # Set git repo URL if provided
+        if git_repo_url:
+            typer.echo("Setting origin remote URL")
+            repo.git.remote(["add", "origin", git_repo_url])
+        # Update Calkit info in this project
+        ck_info = calkit.load_calkit_info(wdir=abs_path)
+        ck_info = ck_info | dict(
+            name=name,
+            title=title,
+            description=description,
+            git_repo_url=git_repo_url,
+            derived_from=dict(
+                project=template_name,
+                git_repo_url=template_git_url,
+                git_rev=git_rev,
+            ),
+        )
+        # Remove questions and owner if they're there
+        _ = ck_info.pop("questions", None)
+        _ = ck_info.pop("owner", None)
+        # Write Calkit info
+        with open(os.path.join(abs_path, "calkit.yaml"), "w") as f:
+            ryaml.dump(ck_info, f)
+        # Update README
+        readme_fpath = os.path.join(abs_path, "README.md")
+        typer.echo("Generating README.md")
+        readme_txt = calkit.make_readme_content(
+            project_name=name,
+            project_title=title,
+            project_description=description,
+        )
+        with open(readme_fpath, "w") as f:
+            f.write(readme_txt)
+        # Update DVC remote
+        # TODO: This will fail because we don't know this user's account name
+        typer.echo("Updating Calkit DVC remote")
+        try:
+            calkit.dvc.configure_remote(wdir=abs_path)
+        except ValueError:
+            warn(
+                "Could not update Calkit DVC remote since "
+                "no Git repo URL was provided"
+            )
+            warn(
+                "You will need to manually run `git remote add origin` "
+                "and `calkit config remote`"
+            )
+            subprocess.call(
+                ["dvc", "remote", "remove", "calkit", "-q"], cwd=abs_path
+            )
+        try:
+            calkit.dvc.set_remote_auth(wdir=abs_path)
+        except Exception:
+            warn("Could not set authentication for Calkit DVC remote")
+        # Commit this stuff to Git
+        repo.git.add(".")
+        if repo.git.diff("--staged"):
+            repo.git.commit(["-m", f"Create new project from {template_name}"])
+        typer.echo(success_message)
+        return
+    os.makedirs(abs_path, exist_ok=True)
+    try:
+        repo = git.Repo(abs_path)
+    except InvalidGitRepositoryError:
+        typer.echo("Initializing Git repository")
+        subprocess.run(["git", "init", "-q"], cwd=abs_path)
+    repo = git.Repo(abs_path)
+    if not os.path.isfile(os.path.join(abs_path, ".dvc", "config")):
+        typer.echo("Initializing DVC repository")
+        subprocess.run(["dvc", "init", "-q"], cwd=abs_path)
+    # Create calkit.yaml file
+    ck_info = calkit.load_calkit_info(wdir=abs_path)
+    ck_info = dict(name=name, title=title, description=description) | ck_info
+    with open(os.path.join(abs_path, "calkit.yaml"), "w") as f:
+        ryaml.dump(ck_info, f)
+    # Create dev container spec
+    update_devcontainer(wdir=abs_path)
+    # Create README
+    readme_fpath = os.path.join(abs_path, "README.md")
+    if os.path.isfile(readme_fpath) and not overwrite:
+        warn("README.md already exists; not modifying")
+    else:
+        typer.echo("Generating README.md")
+        readme_txt = calkit.make_readme_content(
+            project_name=name,
+            project_title=title,
+            project_description=description,
+        )
+        with open(readme_fpath, "w") as f:
+            f.write(readme_txt)
+    if git_repo_url and not repo.remotes:
+        typer.echo(f"Adding Git remote {git_repo_url}")
+        repo.git.remote(["add", "origin", git_repo_url])
+    elif not git_repo_url and not repo.remotes:
+        warn("No Git remotes are configured")
+    # Setup Calkit Cloud DVC remote
+    if repo.remotes:
+        typer.echo("Setting up Calkit Cloud DVC remote")
+        calkit.dvc.configure_remote(wdir=abs_path)
+        calkit.dvc.set_remote_auth(wdir=abs_path)
+    repo.git.add(".")
+    if repo.git.diff("--staged") and not no_commit:
+        repo.git.commit(["-m", "Initialize Calkit project"])
+    typer.echo(success_message)
+
+
 @new_app.command(name="figure")
 def new_figure(
     path: str,
@@ -533,6 +789,7 @@ def new_publication(
         str,
         typer.Option(
             "--template",
+            "-t",
             help=(
                 "Template with which to create the source files. "
                 "Should be in the format {type}/{name}."

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/conda.py

@@ -2,14 +2,43 @@
 
 import json
 import os
+import re
 import subprocess
 
+from packaging.specifiers import SpecifierSet
+from packaging.version import Version
 from pydantic import BaseModel
 
 import calkit
 from calkit import ryaml
 
 
+def _check_single(req: str, actual: str, conda: bool = False) -> bool:
+    """Helper function for checking actual versions against requirements."""
+    req_name = re.split("[=<>]", req)[0]
+    req_spec = req.removeprefix(req_name)
+    if conda and req_spec.startswith("="):
+        req_spec = "=" + req_spec
+        if not req_spec.endswith(".*"):
+            req_spec += ".*"
+    actual_name, actual_vers = re.split("[=<>]+", actual, maxsplit=1)
+    if actual_name != req_name:
+        return False
+    actual_spec = actual.removeprefix(actual_name)
+    if conda and actual_spec.startswith("="):
+        actual_spec = "=" + actual_spec
+    version = Version(actual_vers)
+    spec = SpecifierSet(req_spec)
+    return spec.contains(version)
+
+
+def _check_list(req: str, actual: list[str], conda: bool = False) -> bool:
+    for installed in actual:
+        if _check_single(req, installed, conda=conda):
+            return True
+    return False
+
+
 class EnvCheckResult(BaseModel):
     env_exists: bool | None = None
     env_needs_export: bool | None = None
@@ -127,45 +156,23 @@ def check_env(
                 required_conda_deps.append(dep.replace("==", "="))
         log_func("Checking conda dependencies")
         for dep in required_conda_deps:
-            dep_split = dep.split("=")
-            package = dep_split[0]
-            if len(dep_split) > 1:
-                version = dep_split[1]
-            else:
-                version = None
-            if version is not None and dep not in existing_conda_deps:
+            is_okay = _check_list(
+                req=dep, actual=existing_conda_deps, conda=True
+            )
+            if not is_okay:
                 log_func(f"Found missing dependency: {dep}")
                 env_needs_rebuild = True
                 break
-            elif version is None:
-                # TODO: This does not handle specification of only major or
-                # major+minor version
-                if package not in [
-                    d.split("=")[0] for d in existing_conda_deps
-                ]:
-                    log_func(f"Found missing dependency: {dep}")
-                    env_needs_rebuild = True
-                    break
         if not env_needs_rebuild and not relaxed:
             log_func("Checking pip dependencies")
             for dep in required_pip_deps:
-                dep_split = dep.split("==")
-                package = dep_split[0]
-                if len(dep_split) > 1:
-                    version = dep_split[1]
-                else:
-                    version = None
-                if version is not None and dep not in existing_pip_deps:
+                is_okay = _check_list(
+                    req=dep, actual=existing_pip_deps, conda=False
+                )
+                if not is_okay:
                     env_needs_rebuild = True
                     log_func(f"Found missing dependency: {dep}")
                     break
-                elif version is None:
-                    if package not in [
-                        d.split("==")[0] for d in existing_pip_deps
-                    ]:
-                        log_func(f"Found missing dependency: {dep}")
-                        env_needs_rebuild = True
-                        break
     if env_needs_rebuild:
         res.env_needs_rebuild = True
         log_func(f"Rebuilding {env_name} since it does not match spec")

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/core.py

@@ -209,3 +209,13 @@ def save_notebook_stage_out(
         obj.write_parquet(fpath)
     else:
         raise ValueError(f"Unsupported format '{fmt}' for engine '{engine}'")
+
+
+def make_readme_content(
+    project_name: str, project_title: str, project_description: str | None
+) -> str:
+    """Create Markdown content for a Calkit project README."""
+    txt = f"# {project_title}\n\n"
+    if project_description is not None:
+        txt += f"\n{project_description}\n"
+    return txt

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/dvc.py

@@ -13,19 +13,23 @@ logger = logging.getLogger(__package__)
 logger.setLevel(logging.INFO)
 
 
-def configure_remote():
-    project_name = calkit.git.detect_project_name()
+def configure_remote(wdir: str = None):
+    project_name = calkit.git.detect_project_name(path=wdir)
     base_url = calkit.cloud.get_base_url()
     remote_url = f"{base_url}/projects/{project_name}/dvc"
     subprocess.check_call(
-        ["dvc", "remote", "add", "-d", "-f", get_app_name(), remote_url]
+        ["dvc", "remote", "add", "-d", "-f", get_app_name(), remote_url],
+        cwd=wdir,
     )
     subprocess.check_call(
-        ["dvc", "remote", "modify", get_app_name(), "auth", "custom"]
+        ["dvc", "remote", "modify", get_app_name(), "auth", "custom"],
+        cwd=wdir,
     )
 
 
-def set_remote_auth(remote_name: str = None, always_auth: bool = False):
+def set_remote_auth(
+    remote_name: str = None, always_auth: bool = False, wdir: str = None
+):
     """Get a token and set it in the local DVC config so we can interact with
     the cloud as an HTTP remote.
     """
@@ -48,7 +52,8 @@ def set_remote_auth(remote_name: str = None, always_auth: bool = False):
             remote_name,
             "custom_auth_header",
             "Authorization",
-        ]
+        ],
+        cwd=wdir,
     )
     subprocess.check_call(
         [
@@ -59,7 +64,8 @@ def set_remote_auth(remote_name: str = None, always_auth: bool = False):
             remote_name,
             "password",
             f"Bearer {settings.dvc_token}",
-        ]
+        ],
+        cwd=wdir,
     )
 
 

calkit_python-0.11.1/calkit/git.py

@@ -0,0 +1,22 @@
+"""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")
+    url = git.Repo(path=path).remote().url
+    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.11.1/calkit/tests/test_calc.py

@@ -0,0 +1,69 @@
+"""Tests for ``calkit.calc``."""
+
+import pytest
+
+import calkit
+
+
+def test_formula():
+    calc = calkit.calc.Formula(
+        params=dict(formula="0.2151 * x + y**2"),
+        inputs=["x", "y"],
+        output=calkit.calc.Output(
+            name="z", description="The value", template="The value is {z:.1f}."
+        ),
+    )
+    assert calc.evaluate(x=10.2, y=0.1) == 2.20402
+    res = calkit.calc.evaluate_and_format(calc, x=5, y=1)
+    assert res == "The value is 2.1."
+    with pytest.raises(ValueError):
+        calc.evaluate(x=5)
+    with pytest.raises(ValueError):
+        calc.evaluate(z=5)
+    with pytest.raises(ValueError):
+        calc = calkit.calc.Formula(
+            params=dict(formula="0.2151 * x + y**2"),
+            inputs=["x", "x"],
+            output=calkit.calc.Output(
+                name="z",
+                description="The value",
+                template="The value is {z:.1f}.",
+            ),
+        )
+    with pytest.raises(ValueError):
+        calc = calkit.calc.Formula(
+            params=dict(formula="0.2151 * x + y**2"),
+            inputs=["x", "y"],
+            output=calkit.calc.Output(
+                name="x",
+                description="The value",
+                template="The value is {z:.1f}.",
+            ),
+        )
+
+
+def test_lookuptable():
+    calc = calkit.calc.LookupTable(
+        inputs=["x"],
+        output="something",
+        params=calkit.calc.LookupTableParams(
+            x_values=[1, 2, 3], y_values=[4, 5, 6]
+        ),
+    )
+    # TODO: Implement this
+
+
+def test_linear():
+    calc = calkit.calc.Linear(
+        params=calkit.calc.LinearParams(
+            coeffs=dict(input_voltage=1.1), offset=0.01
+        ),
+        inputs=[{"name": "input_voltage", "dtype": "float"}],
+        output="load_lbf",
+    )
+    res = calc.evaluate(input_voltage=1.534)
+    assert round(res, ndigits=3) == 1.697
+    res2 = calkit.calc.evaluate_and_format(calc, input_voltage=-0.5)
+    assert (
+        res2 == "For input input_voltage=-0.5, the output is load_lbf=-0.54."
+    )

{calkit_python-0.10.1 → calkit_python-0.11.1}/calkit/tests/test_conda.py

@@ -5,7 +5,25 @@ import uuid
 
 import pytest
 
-from calkit.conda import check_env
+from calkit.conda import _check_list, _check_single, check_env
+
+
+def test_check_single():
+    assert _check_single("python=3.12", "python=3.12.18", conda=True)
+    assert _check_single("python=3", "python=3.12.18", conda=True)
+    assert _check_single("python=3.12.18", "python=3.12.18", conda=True)
+    assert _check_single("python>=3.12,<3.13", "python==3.12.18", conda=False)
+
+
+def test_check_list():
+    installed = ["python=3.12.1", "numpy=1.0.11"]
+    assert _check_list("python=3", installed, conda=True)
+    assert _check_list("numpy", installed, conda=True)
+    assert not _check_list("pandas", installed, conda=True)
+    installed = ["python==3.12.1", "numpy==1.0.11"]
+    assert _check_list("python>=3", installed, conda=False)
+    assert _check_list("numpy", installed, conda=False)
+    assert not _check_list("pandas", installed, conda=False)
 
 
 def delete_env(name: str):
@@ -124,3 +142,22 @@ def test_check_env(tmp_dir, env_name):
     )
     res = check_env(relaxed=True)
     assert not res.env_needs_rebuild
+    # Make sure we can handle other ways of specifying versions
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "conda-env",
+            "--overwrite",
+            "-n",
+            env_name,
+            "python=3.12",
+            "--pip",
+            "numpy>=1",
+        ]
+    )
+    res = check_env()
+    assert res.env_needs_rebuild
+    res = check_env()
+    assert not res.env_needs_export
+    assert not res.env_needs_rebuild

{calkit_python-0.10.1 → calkit_python-0.11.1}/pyproject.toml

@@ -12,6 +12,7 @@ classifiers = [
   "Operating System :: OS Independent",
 ]
 dependencies = [
+  "arithmeval",
   "docx2pdf",
   "dvc",
   "eval-type-backport; python_version < '3.10'",

calkit_python-0.10.1/calkit/git.py

@@ -1,17 +0,0 @@
-"""Git-related functionality."""
-
-from __future__ import annotations
-
-import git
-
-
-def detect_project_name(path=None) -> str:
-    """Read the project owner and name from the remote.
-
-    TODO: Currently only works with GitHub remotes where the GitHub repo
-    name is identical to the Calkit project name, which is not guaranteed.
-    We should probably look inside ``calkit.yaml`` at ``name``
-    first, and fallback to the GitHub remote URL if we can't find that.
-    """
-    url = git.Repo(path=path).remote().url
-    return url.split("github.com")[-1][1:].removesuffix(".git")