daggerml 0.1.6__tar.gz → 0.1.7__tar.gz

{daggerml-0.1.6 → daggerml-0.1.7}/CONTRIBUTING.md

@@ -95,6 +95,15 @@ requests and appreciate your help in improving this project.
 - Ensure your code passes all tests and does not decrease code coverage.
 - If your changes introduce new dependencies, please update `pyproject.toml`, but we prefer to keep the dependencies to a minimum.
 
+## Documentation
+
+- Docs explain concepts and how to extend the system. Omit anything obvious
+  from the code or help messages.
+- Help messages explain how to use commands; code comments explain
+  implementation details.
+- Describe the current system only, without version comparisons or migration
+  narratives.
+
 ## Documentation Build
 
 - Python, Node.js/npm, `uv`, Git, `curl`, `tar`, and the native package build

{daggerml-0.1.6 → daggerml-0.1.7}/DOC_MAP.md

@@ -32,7 +32,7 @@ Use this file to identify which project docs to read before editing a code path,
 
 ### CLI surface
 
-- Match: `src/daggerml/_cli.py`
+- Match: `src/daggerml/_core/cli.py`
 - Read:
   - the owning workflow under `docs/use/`
   - `src/daggerml/README.md`
@@ -85,7 +85,7 @@ Use this file to identify which project docs to read before editing a code path,
 
 ### Runtime and remote execution
 
-- Match: `src/daggerml/_core/dml.py`, `src/daggerml/_core/index.py`, `src/daggerml/_core/exec_state.py`, `src/daggerml/util.py`, `src/daggerml/_core/remote.py`, `src/daggerml/_core/s3_cas.py`
+- Match: `src/daggerml/_core/dml.py`, `src/daggerml/_core/index.py`, `src/daggerml/_core/exec_state.py`, `src/daggerml/util.py`, `src/daggerml/_core/aws.py`, `src/daggerml/_core/remote.py`, `src/daggerml/_core/s3_cas.py`
 - Read:
   - `docs/use/execution.qmd`
   - `docs/use/runtimes.qmd`

{daggerml-0.1.6 → daggerml-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: daggerml
-Version: 0.1.6
+Version: 0.1.7
 Summary: DaggerML
 Author-Email: DaggerML <engineering@daggerml.com>
 License: MIT

{daggerml-0.1.6 → daggerml-0.1.7}/c/README.md

@@ -19,6 +19,10 @@ This document describes the current C implementation under `/c`.
 - Ref strings use `namespace:id` format (colon separator).
 - This tree does not currently include `c/bindings/cpython/py_module.c`.
 - The primary DB source file is `c/src/dml_db.c` (not `dml_core.c`).
+- Environment opening makes at most four attempts when LMDB returns `ENOENT`
+  while the directory and `data.mdb` still exist. Each retry uses a fresh
+  `MDB_env` so LMDB can recover from a concurrent last-user semaphore unlink on
+  macOS. Other errors and missing databases are not retried.
 
 ## `c/include/dml_db.h`
 

{daggerml-0.1.6 → daggerml-0.1.7}/c/src/dml_db.c

@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>
 
@@ -18,6 +19,7 @@
 #include "../include/dml_msgpack.h"
 
 #define DML_DB_REGISTRY_SIZE 10
+#define DML_DB_ENV_OPEN_ATTEMPTS 4
 #define DML_DB_RESIZE_MARKER_KEY "__daggerml_map_size__"
 
 typedef struct DmlDbHandle DmlDbHandle;
@@ -293,17 +295,40 @@ static int dml_db_assign_slot_locked(
     return 0;
 }
 
+static int dml_db_data_file_exists(const char *path) {
+    struct stat st;
+    size_t length = strlen(path);
+    char *data_path;
+    int exists;
+
+    if (stat(path, &st) != 0 || !S_ISDIR(st.st_mode)) {
+        return 0;
+    }
+    data_path = malloc(length + sizeof("/data.mdb"));
+    if (data_path == NULL) {
+        return 0;
+    }
+    memcpy(data_path, path, length);
+    memcpy(data_path + length, "/data.mdb", sizeof("/data.mdb"));
+    exists = stat(data_path, &st) == 0 && S_ISREG(st.st_mode);
+    free(data_path);
+    return exists;
+}
+
 static int dml_db_open_env_locked(DmlDbRegistryEntry *entry, int create_if_missing, size_t map_size) {
     MDB_env *env = NULL;
     MDB_txn *setup_txn = NULL;
     MDB_dbi *dbis = NULL;
     size_t open_map_size = map_size;
+    unsigned int attempt = 0;
     int rc;
 
     if (entry->env != NULL) {
         entry->env_refcount += 1;
         return 0;
     }
+retry_env_open:
+    attempt += 1;
     rc = mdb_env_create(&env);
     if (rc != MDB_SUCCESS) {
         return dml_map_lmdb_rc(rc);
@@ -323,6 +348,15 @@ static int dml_db_open_env_locked(DmlDbRegistryEntry *entry, int create_if_missi
     rc = mdb_env_open(env, entry->path, create_if_missing ? MDB_CREATE : 0, 0664);
     if (rc != MDB_SUCCESS) {
         mdb_env_close(env);
+        env = NULL;
+        /* On macOS, the last user can unlink LMDB's named semaphores
+         * between our failed exclusive lock and successful shared lock.
+         * Reopen from scratch so LMDB can initialize them under a new
+         * exclusive lock; do not hide a genuinely missing database.
+         */
+        if (rc == ENOENT && attempt < DML_DB_ENV_OPEN_ATTEMPTS && dml_db_data_file_exists(entry->path)) {
+            goto retry_env_open;
+        }
         return dml_map_lmdb_rc(rc);
     }
     dbis = (MDB_dbi *)calloc(entry->namespace_count, sizeof(MDB_dbi));

{daggerml-0.1.6 → daggerml-0.1.7}/docs/extend/adapters.qmd

@@ -9,6 +9,14 @@ An adapter is the executable boundary between DaggerML core and a backend. This
 page follows [Codecs](codecs.qmd); [Executors](executors.qmd) documents the
 optional contrib implementation used by the built-in adapters.
 
+## Extend the CLI
+
+Extend `dml` with a `daggerml-cli-<name>` executable on `PATH`, rather than
+adding optional integrations to core.
+
+Extensions own their parsing and help. `DML_CLI_CONTEXT` carries overrides,
+not resolved configuration, so extensions can choose whether to open a repository.
+
 ## DML executable request and response contract
 
 For a non-builtin `Runnable`, core locates `runnable.adapter` as an executable

daggerml-0.1.7/docs/extend/executors.qmd

@@ -0,0 +1,141 @@
+---
+title: Executors
+engine: jupyter
+jupyter: python3
+depends-on: extend/adapters
+---
+
+Executors are a contrib invention for implementing backend behavior behind an
+[AdapterBase](adapters.qmd) adapter. Core dispatches only to an adapter
+executable; it neither discovers executors nor imports `ExecutorBase`.
+
+## Registry, discovery, and lowering
+
+Executor lookup uses `(MyExecutor.adapter, MyExecutor.name)`, not the entry-point
+key. The authoring name can differ from the resolved target: `batch` under
+`lambda` resolves to the deployed `lambda_uri` and `dml-lambda-adapter`.
+
+<!-- docs:pseudocode: This metadata belongs in an installable executor distribution. -->
+```toml
+[project.entry-points."daggerml.contrib.executors"]
+example_backend = "my_package.executor:ExampleExecutor"
+```
+
+```{python}
+from daggerml.contrib.status import status
+
+
+executor_keys = {item["key"] for item in status()["executors"]}
+assert {"local:script", "local:docker", "local:ssh"} <= executor_keys
+```
+
+## Dispatch and lifecycle
+
+`ExecutorBase` creates a fresh instance for each call. Durable continuation must
+therefore be returned as state, not retained on the instance. Repeated invoke
+requests perform polling; there is no wire `poll` operation.
+
+```{python}
+from daggerml import Runnable, Uri
+from daggerml.contrib.executors import ExecutorBase
+
+
+class ExampleExecutor(ExecutorBase):
+    name = "example"
+    adapter = "example"
+
+    @classmethod
+    def resolve_runnable(cls, uri, kwargs, sub):
+        return Runnable(target=Uri(uri), kwargs=kwargs, sub=sub, adapter="example-adapter")
+
+    def start(self, cache_key, execution_id, runnable, remote, scratch_uri):
+        assert remote["root"] == "s3://example/root"
+        return {"status": "retry", "adapter_state": {"job": "1"}, "error": None}
+
+    def poll(self, cache_key, execution_id, runnable, state, remote, scratch_uri):
+        return {"status": "retry", "adapter_state": state, "error": None}
+
+
+payload = {
+    "operation": "invoke", "cache_key": "cache", "execution_id": "execution",
+    "remote": {"root": "s3://example/root"}, "runnable": {"target": {"uri": "example"}},
+    "adapter_state": None, "scratch_uri": "s3://example/scratch",
+}
+assert ExampleExecutor.handle(**payload)["adapter_state"] == {"job": "1"}
+assert ExampleExecutor.handle(**{**payload, "adapter_state": {"job": "1"}})["status"] == "retry"
+```
+
+This illustrates resolve-and-dispatch, not a complete deployable backend.
+Later calls may come from different processes or repositories; continuation
+must support safe status checks rather than repeated launches.
+
+The runtime owns result publication and lifecycle/cache updates. Required
+teardown belongs in `cleanup`, not only terminal polling: publication can stop
+further invokes. Cleanup must not alter the result, and returning a result does
+not wait for cleanup retries.
+
+Return `cancelled` only after confirmed teardown, not merely an accepted
+termination request. The runtime owns the transition to `canceled`; retain state
+and retry while teardown is incomplete.
+
+## Backend implementation and built-ins
+
+Script workers receive function source plus explicit `extra_objs` and
+`post_lines`, not the authoring module's imports or globals. Put dependencies
+inside the function or inject them explicitly.
+
+Script and Docker handles belong to their launching user and host. Foreign
+callers retry without touching local resources; hosts and containers must have
+distinct hostnames. Ownership is not authentication or automatic failover.
+
+Docker and Batch own wrapper resources independently of their nested adapter's
+outcome. Their nested `--poll` driver retains child continuation through cleanup.
+SSH forwards continuation to its destination; Batch has no local ownership
+restriction.
+
+Use the supplied remote scratch URI for detached input/output. Runtime records
+own execution coordination; `S3Store` under `remote.root/data/` is for artifacts.
+
+## Docker resource retention
+
+Docker retains completed containers and loaded images; cancellation stops work
+without deleting them. Use `dml contrib docker-gc --dry-run` to preview cleanup.
+Collection defaults to DML-owned resources; `--all` also includes other users'
+resources on the selected daemon. See `--help` for retention options and
+[Sharp bits](../sharp-bits-and-security.qmd#docker-archives-can-overwrite-local-image-tags)
+for archive tag collisions.
+
+Image age means creation time, not last use. Keep container retention longer than
+polling delays: collecting a completed container removes its local status handle.
+
+On Linux, `dml contrib install-docker-gc` enables an hourly systemd user timer.
+It captures the installer's Docker/cache settings and Python environment; keep
+that environment available and reinstall to change settings. The user manager
+must remain running for scheduled collection. On other Unix systems, schedule
+`dml contrib docker-gc` with cron or launchd.
+
+## Batch isolation
+
+`AWS_EC2_METADATA_DISABLED` is not a sandbox: job code can unset it or request
+metadata directly. EC2-backed Batch operators must block container access to
+host IMDS, including IPv6 when enabled. For Docker bridge networking, install
+these rules before admitting work and persist them across reboot:
+
+<!-- docs:pseudocode: Run only on an operator-owned Batch ECS host using Docker bridge networking; the documentation fixture does not administer hosts. -->
+```sh
+iptables -I DOCKER-USER 1 -d 169.254.169.254/32 -j DROP
+ip6tables -I DOCKER-USER 1 -d fd00:ec2::254/128 -j DROP
+```
+
+Other network modes need the corresponding ECS IMDS block. IMDSv2 alone is not
+container isolation. Preserve ECS task credentials at `169.254.170.2`, scope
+the task role to required remote/scratch prefixes, and restrict `iam:PassRole`
+to that role. Do not use host networking or privileged containers for untrusted
+work. EC2-backed containers share a kernel; mutually untrusted workloads need
+separate compute boundaries.
+
+Moto verifies control-plane requests and S3 handoff, not container execution,
+IAM enforcement, or network isolation. Verify IPv4/IPv6 IMDS requests fail and
+task-role S3 access succeeds inside a real job before claiming isolation.
+See AWS's [task role isolation guidance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)
+and [IMDS credential provider settings](https://docs.aws.amazon.com/sdkref/latest/guide/feature-imds-credentials.html).

{daggerml-0.1.6 → daggerml-0.1.7}/docs/sharp-bits-and-security.qmd

@@ -5,6 +5,19 @@ engine: knitr
 
 ## Sharp bits
 
+### Docker archives can overwrite local image tags
+
+The Docker executor loads archives unchanged, including all their tags. A tag
+already bound to another local image is reassigned by Docker; DaggerML does not
+preserve or restore the previous binding. `docker_build` uses unique
+`daggerml-archive:<uuid>` tags to avoid ordinary collisions, but the executor also
+accepts archives from other sources. Use unique tags or a dedicated Docker daemon
+when loading those archives. Execution uses the loaded image's ID, not its tags.
+
+Docker resources are retained until separately collected. The optional
+`dml contrib install-docker-gc --all` timer applies to the entire selected daemon,
+not just DaggerML resources; prefer its DML-only default on shared hosts.
+
 ### A repository without `remote.root` is read-only
 
 A `Dml` instance without a configured `remote.root` supports read-only inspection. Runtime authoring and mutation methods require `remote.root`; configure one before creating, staging, committing, or executing a DAG.

{daggerml-0.1.6 → daggerml-0.1.7}/pyproject.toml

@@ -36,10 +36,11 @@ dashboard = [
 ]
 
 [project.scripts]
-dml = "daggerml._cli:cli"
+dml = "daggerml._core.cli:cli"
 dml-dashboard = "daggerml.dashboard.cli:main"
 dml-local-adapter = "daggerml.contrib.adapters:LocalAdapter.cli"
 dml-lambda-adapter = "daggerml.contrib.adapters:LambdaAdapter.cli"
+daggerml-cli-contrib = "daggerml.contrib.status:cli"
 
 [project.entry-points."daggerml.contrib.adapters"]
 local = "daggerml.contrib.adapters:LocalAdapter"
@@ -83,6 +84,7 @@ template = "__version__ = \"${version}\"\n"
 
 [tool.uv]
 cache-keys = [
+  { file = "pyproject.toml" },
   { file = "c/**/*.c" },
   { file = "c/**/*.h" },
   { file = "src/**/*.pyx" },

{daggerml-0.1.6 → daggerml-0.1.7}/src/daggerml/README.md

@@ -1,6 +1,6 @@
 # DaggerML Python Package
 
-`api.py` exposes Python DAG and node authoring; `_cli.py` derives the `dml`
+`api.py` exposes Python DAG and node authoring; `_core/cli.py` derives the `dml`
 command from the public `Dml` surface. `contrib/` contains optional adapters,
 executors, codecs, and extension helpers. `_core/` owns repository semantics;
 callers use its package-level public exports rather than its implementation

{daggerml-0.1.6 → daggerml-0.1.7}/src/daggerml/__about__.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.6'
-__version_tuple__ = version_tuple = (0, 1, 6)
+__version__ = version = '0.1.7'
+__version_tuple__ = version_tuple = (0, 1, 7)
 
-__commit_id__ = commit_id = 'g9ad05a153'
+__commit_id__ = commit_id = 'g82209db38'

{daggerml-0.1.6 → daggerml-0.1.7}/src/daggerml/_core/README.md

@@ -12,6 +12,9 @@ package-level exports. Normative storage, execution, remote, and lifecycle
 contracts are owned by the relevant OpenSpec capabilities listed in
 [`openspec/spec-overview.md`](../../../openspec/spec-overview.md).
 
+Core runtime modules do not import the Python authoring API, contrib, or other
+package namespaces.
+
 ## Execution records
 
 Remote execution state is split by ownership. Immutable metadata records cache,

{daggerml-0.1.6 → daggerml-0.1.7}/src/daggerml/_core/__init__.py

@@ -1,5 +1,6 @@
 """DML Repository Native Implementation."""
 
+from .aws import get_client
 from .dml import Dml, DmlRepoError
 from .exec_state import (
     AdapterCancelRequest,
@@ -34,6 +35,7 @@ __all__ = [
     "CleanupRecord",
     "dml_dumps",
     "dml_loads",
+    "get_client",
     "Error",
     "ExecutionDriver",
     "ExecutionMetadata",

daggerml-0.1.6/src/daggerml/util.py → daggerml-0.1.7/src/daggerml/_core/aws.py

@@ -1,10 +1,9 @@
+"""AWS client construction shared by core and optional integrations."""
+
 import json
 import logging
 import os
-import time
 import urllib.request
-from dataclasses import dataclass
-from random import randint
 
 import boto3
 from botocore.client import Config
@@ -13,25 +12,6 @@ from botocore.exceptions import BotoCoreError, NoRegionError
 logger = logging.getLogger(__name__)
 
 
-def current_time_millis():
-    return round(time.time() * 1000)
-
-
-@dataclass
-class BackoffWithJitter:
-    min: int = 100
-    max: int = 10000
-    k: int = 2
-    state: int = 0
-
-    def __call__(self):
-        if self.state == 0:
-            self.state = randint(self.min, self.min * 2)
-            return self.state
-        self.state = min(self.max, randint(self.min, max(self.min, self.state) * self.k))
-        return self.state
-
-
 def _get_region_from_metadata():
     """
     Attempts to retrieve the AWS region from ECS or EC2 metadata.
@@ -54,6 +34,8 @@ def _get_region_from_metadata():
         except Exception as e:
             logger.warning("Failed to get region from ECS metadata: %s", e)
     # EC2 fallback: use IMDSv2
+    if os.environ.get("AWS_EC2_METADATA_DISABLED", "").lower() == "true":
+        return None
     try:
         token_req = urllib.request.Request(
             "http://169.254.169.254/latest/api/token",

daggerml-0.1.6/src/daggerml/_cli.py → daggerml-0.1.7/src/daggerml/_core/cli.py

@@ -4,17 +4,22 @@ import argparse
 import inspect
 import json
 import logging
+import os
+import re
+import shutil
+import subprocess
 import sys
 import types
 import typing
 from dataclasses import dataclass
 from enum import Enum
+from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 from typing import Annotated, Any, Callable, Literal, Union, cast, get_args, get_origin
 
 try:
-    from daggerml.__about__ import __version__
-except ImportError:
+    __version__ = version("daggerml")
+except PackageNotFoundError:
     __version__ = "local"
 
 from daggerml._core import Dml, Error, Ref, Runnable, Uri, dml_dumps, dml_loads
@@ -112,6 +117,33 @@ CLI_SERDE_PRIORITY = ("none", "dml", "json", "float", "int", "bool", "str", "ref
 CLI_COLLECTION_TYPES = (dict, list)
 CLI_LITERAL_SCALARS = {float, int, bool, str}
 
+EXTERNAL_COMMAND_PREFIX = "daggerml-cli-"
+_CONTEXT_ENV_NAMES = {
+    "db_map_size_headroom": "DML_DEFAULT_DB_MAP_SIZE_HEADROOM",
+    "db_map_size_max": "DML_DEFAULT_DB_MAP_SIZE_MAX",
+    "default_branch_name": "DML_DEFAULT_BRANCH_NAME",
+}
+
+
+def _external_commands() -> dict[str, str]:
+    commands = {}
+    for directory in os.get_exec_path():
+        try:
+            entries = list(Path(directory or ".").iterdir())
+        except OSError:
+            continue
+        for entry in entries:
+            if not entry.name.startswith(EXTERNAL_COMMAND_PREFIX):
+                continue
+            name = entry.name[len(EXTERNAL_COMMAND_PREFIX) :]
+            if not re.fullmatch(r"[a-zA-Z0-9][a-zA-Z0-9_-]*", name):
+                continue
+            if name not in commands and entry.is_file() and os.access(entry, os.X_OK):
+                executable = shutil.which(entry.name)
+                if executable:
+                    commands[name] = executable
+    return dict(sorted(commands.items()))
+
 
 def _union_members(typ: Any) -> tuple[Any, ...]:
     origin = get_origin(typ)
@@ -227,6 +259,7 @@ class PrettyHelpFormatter(argparse.ArgumentDefaultsHelpFormatter):
         groups = (
             ("command", "commands"),
             ("namespace", "namespaces"),
+            ("external", "external"),
         )
         for category, heading in groups:
             subactions = [
@@ -298,12 +331,15 @@ class MethodCLI:
         *,
         prog: str | None = None,
         parsers: dict[Any, Callable[[str], Any]] | None = None,
+        external_commands: bool = False,
     ) -> None:
         if not isinstance(cls, type):
             raise TypeError("MethodCLI expects a class, not an instance")
         self.cls = cls
         self.parsers = dict(parsers or {})
         self._constructor_params = self._constructor_param_metadata()
+        self._external_commands = {}
+        self._external_dispatch = external_commands
         self.parser = PrettyArgumentParser(
             prog=prog or self._kebab(cls.__name__),
             formatter_class=PrettyHelpFormatter,
@@ -319,6 +355,16 @@ class MethodCLI:
         self.parser.add_argument("--version", action="version", version=f"%(prog)s, version {__version__}")
         self._add_constructor_args(self.parser)
         self._build_namespace_from_type(cls, self.parser, path=())
+        if external_commands:
+            subparsers = next(
+                action for action in self.parser._actions if isinstance(action, argparse._SubParsersAction)
+            )
+            for name, executable in _external_commands().items():
+                if name not in subparsers.choices:
+                    self._external_commands[name] = executable
+                    subparsers.add_parser(
+                        name, category="external", help=f"External command ({EXTERNAL_COMMAND_PREFIX}{name})."
+                    )
 
     def main(self, argv: list[str] | None = None) -> int:
         try:
@@ -332,6 +378,40 @@ class MethodCLI:
             return 1
 
     def run(self, argv: list[str] | None = None) -> int:
+        argv = list(sys.argv[1:] if argv is None else argv)
+        if self._external_dispatch:
+            # Parse only the root prefix. Everything after the command belongs
+            # to the executable, including --help and unknown option names.
+            prefix = PrettyArgumentParser(prog=self.parser.prog, add_help=False, allow_abbrev=False)
+            prefix.add_argument("-h", "--help", action="store_true")
+            prefix.add_argument("--version", action="store_true")
+            prefix.add_argument("-v", dest="_verbosity", action="count", default=0)
+            self._add_constructor_args(prefix)
+            prefix.add_argument("_command", nargs="?")
+            prefix.add_argument("_args", nargs=argparse.REMAINDER)
+            root = vars(prefix.parse_args(argv))
+            if not root["help"] and not root["version"] and root["_command"] in self._external_commands:
+                env = os.environ.copy()
+                for param in self._constructor_params.values():
+                    value = root.get(param.dest)
+                    if value is not None:
+                        key = _CONTEXT_ENV_NAMES.get(param.name, f"DML_{param.name.upper()}")
+                        env[key] = str(value)
+                env["DML_CLI_CONTEXT"] = json.dumps(
+                    {
+                        "version": 1,
+                        "options": {
+                            param.name: root[param.dest]
+                            for param in self._constructor_params.values()
+                            if root.get(param.dest) is not None
+                        },
+                        "verbosity": root["_verbosity"],
+                    }
+                )
+                completed = subprocess.run(
+                    [self._external_commands[root["_command"]], *root["_args"]], env=env, check=False
+                )
+                return completed.returncode if completed.returncode >= 0 else 128 - completed.returncode
         ns = self.parser.parse_args(argv)
         data = vars(ns)
         verbosity = data.pop("_verbosity", 0)
@@ -810,4 +890,4 @@ class _Namespace:
 
 
 def cli() -> None:
-    raise SystemExit(MethodCLI(Dml, prog="dml").main())
+    raise SystemExit(MethodCLI(Dml, prog="dml", external_commands=True).main())

{daggerml-0.1.6 → daggerml-0.1.7}/src/daggerml/_core/dml.py

@@ -8,8 +8,9 @@ from importlib import resources
 from importlib.resources.abc import Traversable
 from pathlib import Path
 from time import time
-from typing import Annotated, Any, Literal, Mapping, NotRequired, TypedDict, cast, overload
+from typing import Annotated, Any, Literal, Mapping, TypedDict, cast, overload
 
+from daggerml._core.aws import get_client
 from daggerml._core.commit import (
     CommitDescription,
     CommitDiffPayload,
@@ -32,7 +33,6 @@ from daggerml._core.index import IndexOps
 from daggerml._core.remote import Remote
 from daggerml._core.s3_cas import CasItemConflict
 from daggerml._core.types import DmlDB, DmlRepoError, Error, FrozenIndex, Index, TxnWithValid
-from daggerml.util import get_client
 
 
 def _format_graph_age(seconds: int | float | None) -> str:
@@ -304,21 +304,15 @@ class ConfigStatus(TypedDict):
     remote: RemoteConfig
     user: str
     config_home: str
-    contrib: NotRequired[dict]
 
 
 @dataclass(frozen=True)
 class _ConfigNamespace:
     _dml: "Dml"
 
-    def show(self, *, contrib: Annotated[bool, "Include contrib runtime status."] = False) -> ConfigStatus:
+    def show(self) -> ConfigStatus:
         """Return the resolved runtime configuration."""
-        payload = asdict(self._dml._config)
-        if contrib:
-            from daggerml.contrib import status as contrib_status
-
-            payload["contrib"] = contrib_status.status()
-        return cast(ConfigStatus, payload)
+        return cast(ConfigStatus, asdict(self._dml._config))
 
     def get(self, key: Annotated[str, "Flattened config key to read."]) -> str | int | None:
         """Return one resolved config value by flattened key."""

{daggerml-0.1.6 → daggerml-0.1.7}/src/daggerml/_core/exec_state.py

@@ -14,6 +14,7 @@ from dataclasses import InitVar, asdict, dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, Literal, Sequence, TypedDict, cast
 from uuid import uuid4
 
+from daggerml._core.aws import get_client
 from daggerml._core.remote import Remote
 from daggerml._core.s3_cas import CasItem, CasItemConflict, S3Remote
 from daggerml._core.types import (
@@ -27,7 +28,6 @@ from daggerml._core.types import (
     Runnable,
 )
 from daggerml._core.util import uuid7
-from daggerml.util import get_client
 
 if TYPE_CHECKING:
     import boto3