calkit-python 0.49.0__tar.gz → 0.49.2__tar.gz

{calkit_python-0.49.0 → calkit_python-0.49.2}/PKG-INFO

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

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/__init__.py

@@ -13,7 +13,6 @@ if TYPE_CHECKING:
         conda,
         config,
         datasets,
-        dependencies,
         detect,
         docker,
         docx,
@@ -44,6 +43,7 @@ if TYPE_CHECKING:
         questions,
         releases,
         reproducibility,
+        requirements,
         resources,
         schema,
         server,
@@ -60,7 +60,6 @@ _SUBMODULES = {
     "conda",
     "config",
     "datasets",
-    "dependencies",
     "detect",
     "docker",
     "docx",
@@ -91,6 +90,7 @@ _SUBMODULES = {
     "questions",
     "releases",
     "reproducibility",
+    "requirements",
     "resources",
     "schema",
     "server",

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/cli/check.py

@@ -2053,7 +2053,7 @@ def check_venv(
             )
         # Last, so an interrupted relock isn't taken as current
         calkit.environments.write_env_spec_hash(
-            lock_fpath, path, python=python, wdir=wdir
+            lock_fpath, spec_hash, wdir=wdir
         )
         # Delete legacy lock file after use
         if used_legacy_lock:
@@ -2199,7 +2199,7 @@ def check_project_requirements(
     typer.echo("Checking project requirements")
     dotenv.load_dotenv(dotenv_path=".env", verbose=verbose)
     if no_cache:
-        calkit.dependencies.cache_clear()
+        calkit.requirements.cache_clear()
     try:
         calkit.check_requirements(use_cache=not no_cache)
     except Exception as e:
@@ -2240,7 +2240,9 @@ def check_stage_runs() -> None:
         recorded = stage_runs.get(name)
         if not isinstance(recorded, dict):
             problems.append(f"Stage '{name}' has no recorded run")
-        elif recorded.get("dvc_lock") != calkit.dvc.stage_lock_md5(locked):
+        elif recorded.get("dvc_lock_hash") != calkit.dvc.stage_lock_hash(
+            locked
+        ):
             problems.append(
                 f"Stage '{name}' has changed in dvc.lock since its last "
                 "recorded run"
@@ -2263,28 +2265,20 @@ def check_env_vars(
     ] = False,
 ) -> None:
     """Check that the project's required environmental variables exist."""
+    from calkit.core import _normalize_requirement
+
     typer.echo("Checking project environmental variables")
     dotenv.load_dotenv(dotenv_path=".env")
     ck_info = calkit.load_calkit_info()
-    deps = calkit.get_requirements(ck_info)
-    env_var_dep_names = calkit.get_env_var_dep_names(ck_info)
-    for name in env_var_dep_names:
+    for raw in calkit.get_requirements(ck_info):
+        req = _normalize_requirement(raw)
+        if req["kind"] != "env-var":
+            continue
+        name = req["name"]
         if verbose:
             typer.echo(f"Checking for environmental variable '{name}'")
-        # Pull the dep's attrs to honor any per-var default.
-        attrs: dict = {}
-        for dep in deps:
-            if isinstance(dep, dict) and dep.get("name") == name:
-                attrs = dep
-                break
-            if isinstance(dep, dict) and list(dep.keys()) == [name]:
-                attrs = dep[name] or {}
-                break
         if name not in os.environ:
-            typer.echo(f"Missing env var '{name}'")
-            value = calkit.dependencies.prompt_and_store_env_var(
-                name, default=attrs.get("default")
-            )
+            value = calkit.requirements.prompt_for_env_var_req(req)
             if value is None:
                 raise_error(f"No value provided for '{name}'")
     message = "✅ All set!"

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/cli/core.py

@@ -6,7 +6,7 @@ import os
 import re
 import subprocess
 from enum import Enum
-from typing import TYPE_CHECKING, Any, NoReturn
+from typing import Any, NoReturn
 
 import typer
 from typer.core import TyperCommand, TyperGroup
@@ -28,10 +28,6 @@ class EnvDefaultsModeChoice(str, Enum):
     merge = "merge"
 
 
-if TYPE_CHECKING:
-    import click
-
-
 class AliasGroup(TyperGroup):
     """TyperGroup that resolves command aliases defined with '|' in the name."""
 
@@ -87,21 +83,19 @@ class OptionalValueCommand(TyperCommand):
 
 
 def complete_stage_names(
-    ctx: "click.Context | None",
-    param: "click.Parameter | None",
-    incomplete: str,
-) -> list:
+    ctx: object, param: object, incomplete: str
+) -> list[str]:
     """Return pipeline stage names for shell tab-completion.
 
     ``ctx`` and ``param`` are part of the Click completion-callback signature
-    but are unused here, so they accept ``None`` (e.g. when called directly in
-    tests).
+    but are unused here, so they accept anything, e.g., ``None`` when called
+    directly in tests. Typer bundles its own Click, so its types would only
+    tie this to that copy.
     """
     if not os.path.isfile("calkit.yaml"):
         return []
     try:
         import ruamel.yaml
-        from click.shell_completion import CompletionItem
 
         ryaml = ruamel.yaml.YAML()
         with open("calkit.yaml") as f:
@@ -122,11 +116,7 @@ def complete_stage_names(
                 sp_stages = sp_info.get("pipeline", {}).get("stages", {})
                 for stage in sp_stages:
                     candidates.append(f"{sp_name}:{stage}")
-        return [
-            CompletionItem(name)
-            for name in candidates
-            if name.startswith(incomplete)
-        ]
+        return [name for name in candidates if name.startswith(incomplete)]
     except Exception:
         return []
 

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/cli/list.py

@@ -394,6 +394,73 @@ def list_environments(
             typer.echo(f"    {k}: {v}")
 
 
+@list_app.command(name="requirements|reqs")
+def list_requirements(
+    json_output: Annotated[
+        bool, typer.Option("--json", help="Output result as JSON.")
+    ] = False,
+) -> None:
+    """List what a machine needs to run the project.
+
+    That's the project's requirements, then those of each environment and
+    stage, each with where it was declared. Nothing is checked; use
+    'calkit check reqs' for that.
+    """
+    from calkit.core import _normalize_requirement
+
+    ck_info = calkit.load_calkit_info()
+    sources: list[tuple[str, list]] = [
+        ("project", calkit.get_requirements(ck_info))
+    ]
+    for name, env in (ck_info.get("environments") or {}).items():
+        if not isinstance(env, dict):
+            continue
+        if env.get("requirements"):
+            sources.append((f"environment '{name}'", env["requirements"]))
+        # An option a switch defines in place is named after its position
+        for n, option in enumerate(env.get("switch") or [], start=1):
+            use = option.get("use") if isinstance(option, dict) else None
+            if isinstance(use, dict) and use.get("requirements"):
+                sources.append(
+                    (f"environment '{name}.{n}'", use["requirements"])
+                )
+    stages = (ck_info.get("pipeline") or {}).get("stages") or {}
+    for name, stage in stages.items():
+        if isinstance(stage, dict) and stage.get("requirements"):
+            sources.append((f"stage '{name}'", stage["requirements"]))
+    result = []
+    for source, reqs in sources:
+        for raw in reqs:
+            try:
+                req = _normalize_requirement(raw)
+            except ValueError as e:
+                raise_error(f"In {source}: {e}")
+            result.append({"source": source, **req})
+    if json_output:
+        echo_json(result)
+        return
+    property_kinds = calkit.system_property_requirement_kinds()
+    last_source = None
+    for req in result:
+        req = dict(req)
+        source = req.pop("source")
+        if source != last_source:
+            if last_source is not None:
+                typer.echo()
+            typer.echo(source[0].upper() + source[1:] + ":")
+            last_source = source
+        name = req.pop("name")
+        kind = req.pop("kind")
+        # A property requirement's name is its kind
+        typer.echo(
+            f"  - {name}" if kind in property_kinds else f"  - {name} ({kind})"
+        )
+        for k, v in req.items():
+            if isinstance(v, str):
+                v = " ".join(v.split())
+            typer.echo(f"      {k}: {v}")
+
+
 @list_app.command(name="templates")
 def list_templates(
     kind: Annotated[

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/cli/main/core.py

@@ -211,7 +211,7 @@ def _exec_with_version(version_spec: str) -> None:
     Strips ``--use-version`` from ``sys.argv`` before re-invoking so the
     child process doesn't loop. Requires ``uv`` to be available on PATH.
     """
-    from calkit.dependencies import _format_uvx_from
+    from calkit.requirements import _format_uvx_from
 
     if shutil.which("uvx") is None:
         raise_error(
@@ -548,7 +548,7 @@ def get_status(
     # than enforces, so anything still unset is a warning: it must not stop
     # the rest of the status from being shown.
     if ck_info:
-        missing_env_vars = calkit.dependencies.resolve_env_var_deps(ck_info)
+        missing_env_vars = calkit.requirements.resolve_env_var_deps(ck_info)
         if missing_env_vars:
             warn(
                 "Missing environmental variable(s): "
@@ -2082,10 +2082,13 @@ def _tell_hub_we_pushed(targets: list[str], git_args: list[str]) -> None:
         # The remote git actually pushed to: whatever was named on the
         # command line, else the branch's own upstream, else origin.
         named = [a for a in git_args if not a.startswith("-")]
+        upstream = repo.active_branch.tracking_branch()
         if named:
             body["remote"] = named[0]
+        elif upstream is not None:
+            body["remote"] = upstream.remote_name
         else:
-            body["remote"] = repo.active_branch.tracking_branch().remote_name
+            body["remote"] = "origin"
     except Exception:
         body.setdefault("remote", "origin")
     try:
@@ -3673,7 +3676,7 @@ def run(
             if lock_dir not in lock_stages:
                 lock_stages[lock_dir] = calkit.dvc.read_lock_stages(lock_dir)
             if isinstance(lock_stages[lock_dir].get(lock_name), dict):
-                entry["dvc_lock"] = calkit.dvc.stage_lock_md5(
+                entry["dvc_lock_hash"] = calkit.dvc.stage_lock_hash(
                     lock_stages[lock_dir][lock_name]
                 )
             entry["calkit_version"] = system_info.get("calkit_version")

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/conda.py

@@ -995,7 +995,7 @@ def check_env(
             relock=spec_changed and recorded_hash is not None,
         )
     # Last, so an interrupted relock isn't taken as current
-    write_env_spec_hash(lock_fpath, env_fpath)
+    write_env_spec_hash(lock_fpath, spec_hash)
     return res
 
 

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/core.py

@@ -790,7 +790,9 @@ def _normalize_requirement(req) -> dict:
     required there. A ``setup`` requirement may omit it, since a single
     anonymous setup step is common and forcing users to invent a name adds
     friction; a stable one is synthesized from a short hash of
-    ``check_command``. A machine-property requirement has no name at all --
+    ``check_command``. An ``aws-credentials`` requirement may omit it too,
+    and is named after its profile and account. A machine-property
+    requirement has no name at all --
     ``kind: cpu-count`` already says everything there is to say about which
     property it constrains -- so the kind is used as the name in messages.
     """
@@ -802,12 +804,11 @@ def _normalize_requirement(req) -> dict:
             "'kind', e.g., '- kind: env-var' with 'name: TOKEN'"
         )
 
-    dep = req
-    if isinstance(dep, str):
+    if isinstance(req, str):
         # Split on the first version operator so a string like
         # ``calkit>=0.38`` produces both a clean name and a version spec
         # the caller can validate.
-        m = re.match(r"^([A-Za-z0-9_.\-]+)(.*)$", dep.strip())
+        m = re.match(r"^([A-Za-z0-9_.\-]+)(.*)$", req.strip())
         if m is None:
             raise malformed()
         out: dict = {"name": m.group(1), "kind": "app"}
@@ -815,14 +816,14 @@ def _normalize_requirement(req) -> dict:
         if spec:
             out["version_spec"] = spec
         return out
-    if not isinstance(dep, dict):
+    if not isinstance(req, dict):
         raise malformed()
-    keys = list(dep.keys())
+    keys = list(req.keys())
     # Flat form with explicit kind: only requires ``name`` for kinds where
     # name is the identity (app, env-var). Setup requirements may omit it,
     # and property requirements have none to give.
     if "kind" in keys:
-        out = dict(dep)
+        out = dict(req)
         if "name" not in out:
             kind = out["kind"]
             if kind in system_property_requirement_kinds():
@@ -833,18 +834,27 @@ def _normalize_requirement(req) -> dict:
                     check_command.encode("utf-8")
                 ).hexdigest()[:8]
                 out["name"] = f"setup-{short}"
+            elif kind == "aws-credentials":
+                out["name"] = "-".join(
+                    ["aws-credentials"]
+                    + [
+                        str(out[key])
+                        for key in ("profile", "account_id")
+                        if out.get(key)
+                    ]
+                )
             else:
-                raise ValueError(f"Requirement missing required 'name': {dep}")
+                raise ValueError(f"Requirement missing required 'name': {req}")
         return out
     if "name" in keys:
-        out = dict(dep)
+        out = dict(req)
         out.setdefault("kind", "app")
         return out
     if len(keys) != 1:
         raise malformed()
     # Single-key form: {name: {kind: ..., ...}}
     name = keys[0]
-    attrs = dep[name] or {}
+    attrs = req[name] or {}
     if not isinstance(attrs, dict):
         raise malformed()
     out = dict(attrs)
@@ -1118,24 +1128,26 @@ def check_requirements(
     machine it names.
 
     ``setup`` requirements are verified via
-    :func:`calkit.dependencies.check_setup_dep`, which runs the
+    :func:`calkit.requirements.check_setup_dep`, which runs the
     ``check_command`` and -- on an interactive TTY -- optionally runs the
     declared ``setup_command`` after asking the user. Non-interactive
     failures abort with the fix-it command printed for the user to run.
+    ``aws-credentials`` requirements are checked the same way, by
+    :func:`calkit.requirements.check_aws_credentials_req`.
     """
     if requirements is not None:
         # An environment's own list is checked exactly as declared: it
         # describes a machine that runs stages, which is a smaller claim
         # than being where the project lives.
-        deps = list(requirements)
+        reqs = list(requirements)
     else:
         if ck_info is None:
             ck_info = load_calkit_info(wdir=wdir)
-        deps = get_requirements(ck_info)
+        reqs = get_requirements(ck_info)
         # Git is how a project exists at all, so the host needs it whether
         # or not anyone wrote it down.
-        if "git" not in deps:
-            deps.append("git")
+        if "git" not in reqs:
+            reqs.append("git")
     # Resolve TTY interactivity once so a single per-call answer drives
     # every prompt (env-var, app installer, setup step).
     if interactive is None:
@@ -1145,7 +1157,8 @@ def check_requirements(
     # before we start installing things on it, then env-vars (some
     # installers and setup commands read from them), then apps (env
     # managers like pixi / uv need to exist before setup steps that run
-    # inside an env), then setup steps last. The setup-step
+    # inside an env), then setup steps, then AWS credentials, which need
+    # the AWS CLI and may be set up by a step. The setup-step
     # ``check_command`` typically wraps ``calkit xenv``, which validates
     # its own environment, so we don't need a separate env-check phase.
     property_kinds = system_property_requirement_kinds()
@@ -1154,19 +1167,20 @@ def check_requirements(
         "env-var": [],
         "app": [],
         "setup": [],
+        "aws-credentials": [],
     }
-    for raw_dep in deps:
-        dep = _normalize_requirement(raw_dep)
-        kind = dep["kind"]
+    for raw in reqs:
+        req = _normalize_requirement(raw)
+        kind = req["kind"]
         if kind in property_kinds:
-            buckets["_property"].append(dep)
+            buckets["_property"].append(req)
         elif kind not in buckets:
             # Unknown / legacy kinds (e.g., ``calkit-config``) fall through
             # to ``check_dep_exists`` in original order so we don't change
             # behavior for them silently.
-            buckets.setdefault("_other", []).append(dep)
+            buckets.setdefault("_other", []).append(req)
         else:
-            buckets[kind].append(dep)
+            buckets[kind].append(req)
     if buckets["_property"]:
         # Read the machine only when something asks about it; describing a
         # system shells out for a version from every package manager it can
@@ -1177,43 +1191,45 @@ def check_requirements(
             if system_info is not None
             else get_machine_properties()
         )
-        for dep in buckets["_property"]:
-            check_property_requirement(dep, info, described_as=described_as)
-    for dep in buckets["env-var"]:
-        dep_name = dep["name"]
-        if dep_name in os.environ:
+        for req in buckets["_property"]:
+            check_property_requirement(req, info, described_as=described_as)
+    for req in buckets["env-var"]:
+        req_name = req["name"]
+        if req_name in os.environ:
             continue
         # On a TTY, prompt the user and persist to .env so the very next
         # ``calkit run`` works without a separate setup step. Non-TTY
         # (CI) falls through to the legacy "not found" abort.
         if interactive:
-            from calkit.dependencies import prompt_and_store_env_var
+            from calkit.requirements import prompt_for_env_var_req
 
-            print(f"Missing env var '{dep_name}'")
-            value = prompt_and_store_env_var(
-                dep_name, default=dep.get("default")
-            )
-            if value is not None:
+            if prompt_for_env_var_req(req) is not None:
                 continue
-        raise ValueError(f"env-var '{dep_name}' not found")
-    for dep in buckets["app"]:
-        dep_name = dep["name"]
+        msg = f"env-var '{req_name}' not found"
+        if req.get("setup_command"):
+            msg += (
+                f"; get a value with '{req['setup_command']}' and set it "
+                f"with 'calkit set-env-var {req_name} <value>'"
+            )
+        raise ValueError(msg)
+    for req in buckets["app"]:
+        req_name = req["name"]
         # The ``calkit`` app is always satisfied by the running process,
         # but a declared ``version_spec`` (e.g. ``calkit>=0.38``) is
         # checked against the installed version so projects can pin a
         # minimum CLI without writing a custom setup step.
-        if dep_name == "calkit":
-            spec = dep.get("version_spec")
+        if req_name == "calkit":
+            spec = req.get("version_spec")
             if spec:
-                from calkit.dependencies import check_calkit_version
+                from calkit.requirements import check_calkit_version
 
                 check_calkit_version(spec)
             continue
-        spec = dep.get("version_spec")
-        if check_dep_exists(dep_name, "app", system_info=system_info):
+        spec = req.get("version_spec")
+        if check_dep_exists(req_name, "app", system_info=system_info):
             if spec:
                 check_app_version(
-                    dep_name,
+                    req_name,
                     spec,
                     system_info=system_info,
                     described_as=described_as,
@@ -1222,14 +1238,14 @@ def check_requirements(
         # Offer the registered native installer when we have one.
         from calkit import install as _install
 
-        if _install.get_installer(dep_name) is not None:
-            print(f"App '{dep_name}' is not installed.")
+        if _install.get_installer(req_name) is not None:
+            print(f"App '{req_name}' is not installed.")
             if _install.prompt_and_install(
-                dep_name, interactive=interactive
-            ) and check_dep_exists(dep_name, "app", system_info=system_info):
+                req_name, interactive=interactive
+            ) and check_dep_exists(req_name, "app", system_info=system_info):
                 if spec:
                     check_app_version(
-                        dep_name,
+                        req_name,
                         spec,
                         system_info=system_info,
                         described_as=described_as,
@@ -1237,28 +1253,41 @@ def check_requirements(
                 continue
         # Some apps have no installer here but a known way in, e.g., a
         # system package manager on Linux
-        hint = _install.get_unsupported_message(dep_name)
+        hint = _install.get_unsupported_message(req_name)
         raise ValueError(
-            f"app '{dep_name}' not found on {described_as}"
+            f"app '{req_name}' not found on {described_as}"
             + (f"; {hint}" if hint else "")
         )
-    for dep in buckets.get("_other", []):
-        dep_name = dep["name"]
-        dep_kind = dep["kind"]
-        if not check_dep_exists(dep_name, dep_kind, system_info=system_info):
-            raise ValueError(f"{dep_kind} '{dep_name}' not found")
-    for dep in buckets["setup"]:
-        from calkit.dependencies import check_setup_dep
+    for req in buckets.get("_other", []):
+        req_name = req["name"]
+        req_kind = req["kind"]
+        if not check_dep_exists(req_name, req_kind, system_info=system_info):
+            raise ValueError(f"{req_kind} '{req_name}' not found")
+    for req in buckets["setup"]:
+        from calkit.requirements import check_setup_dep
 
         ok = check_setup_dep(
-            dep,
+            req,
+            interactive=interactive,
+            use_cache=use_cache,
+            wdir=wdir,
+        )
+        if not ok:
+            raise ValueError(
+                f"setup requirement '{req['name']}' is not satisfied"
+            )
+    for req in buckets["aws-credentials"]:
+        from calkit.requirements import check_aws_credentials_req
+
+        ok = check_aws_credentials_req(
+            req,
             interactive=interactive,
             use_cache=use_cache,
             wdir=wdir,
         )
         if not ok:
             raise ValueError(
-                f"setup requirement '{dep['name']}' is not satisfied"
+                f"aws-credentials requirement '{req['name']}' is not satisfied"
             )
 
 
@@ -1272,12 +1301,12 @@ def get_env_var_dep_names(ck_info: dict | None = None) -> list[str]:
     if ck_info is None:
         ck_info = load_calkit_info()
     env_vars = []
-    for dep in get_requirements(ck_info):
+    for req in get_requirements(ck_info):
         # Delegate shape-parsing to ``_normalize_requirement`` so this stays
         # in lockstep with ``check_requirements`` -- string entries,
         # single-key dicts, flat dicts, and nameless setup steps all flow
         # through one path.
-        normalized = _normalize_requirement(dep)
+        normalized = _normalize_requirement(req)
         if normalized["kind"] == "env-var":
             env_vars.append(normalized["name"])
     return env_vars

{calkit_python-0.49.0 → calkit_python-0.49.2}/calkit/dvc/core.py

@@ -949,7 +949,7 @@ def split_lock_stage_name(stage_name: str) -> tuple[str | None, str]:
     return None, stage_name
 
 
-def stage_lock_md5(entry: dict) -> str:
+def stage_lock_hash(entry: dict) -> str:
     """A checksum of what a stage's ``dvc.lock`` entry says it ran and made.
 
     Built from its command, params, and each dep's and out's path and hash,
@@ -974,7 +974,7 @@ def stage_lock_md5(entry: dict) -> str:
         "outs": files("outs"),
     }
     content = json.dumps(data, sort_keys=True, default=str).encode()
-    return "md5:" + hashlib.md5(content).hexdigest()
+    return "sha256:" + hashlib.sha256(content).hexdigest()
 
 
 def configure_autostage(wdir: str | None = None) -> int: