datavo-cli 0.22.0__py3-none-any.whl

datavo_cli/render.py

@@ -0,0 +1,390 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import BaseModel
+from tabulate import tabulate
+
+
+def _to_payload(value: Any) -> Any:
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json", by_alias=True)
+    return value
+
+
+def _compact_keys(keys: list[str] | None, limit: int = 4) -> str:
+    keys = keys or []
+    if len(keys) <= limit:
+        return ", ".join(keys)
+    return ", ".join(keys[:limit]) + f" (+{len(keys) - limit})"
+
+
+def _owner_cell(item: dict) -> str:
+    """The owning team as a name, marking a personal team as such.
+
+    Prefers the name the server resolved and falls back to the id only when there is
+    none — an older server, or a person whose claims were never captured. The
+    ``personal:`` prefix is never stripped to manufacture a name: the fragment behind it
+    is the identity provider's object id, which is exactly what this column existed to
+    stop printing.
+    """
+    owner = item.get("owner_team_id")
+    if not owner:
+        return "-"
+    shown = item.get("owner_team_display_name") or owner
+    return f"{shown} (personal)" if str(owner).startswith("personal:") else str(shown)
+
+
+def render_output(value: Any, *, output_format: str = "plain") -> None:
+    payload = _to_payload(value)
+    if output_format == "json":
+        print(json.dumps(payload, indent=2))
+        return
+    _render_plain(payload)
+
+
+def _render_plain(payload: Any) -> None:
+    if isinstance(payload, dict):
+        if "candidate_count" in payload and "exclusive_group_count" in payload:
+            print(f"dataset_name: {payload.get('dataset_name')}")
+            print(f"candidate_count: {payload.get('candidate_count')}")
+            if payload.get("total_hours") is not None:
+                print(f"total_hours: {payload.get('total_hours')}")
+            print(f"exclusive_group_count: {payload.get('exclusive_group_count')}")
+            rows = [
+                [
+                    item.get("name"),
+                    item.get("selector_kind"),
+                    item.get("target_ratio"),
+                    item.get("assigned_count"),
+                    round(item["assigned_ratio"], 4) if item.get("assigned_ratio") is not None else None,
+                ]
+                for item in payload.get("splits", [])
+            ]
+            if rows:
+                print("splits:")
+                print(tabulate(rows, headers=["split", "selector", "target_ratio", "assigned", "assigned_ratio"]))
+            for summary in payload.get("rule_summaries", []):
+                print(f"rule: {summary}")
+            for warning in payload.get("warnings", []):
+                print(f"warning: {warning}")
+            return
+        if "parent_dataset" in payload and "definition" in payload:
+            print(f"name: {payload.get('name')}")
+            print(f"parent_dataset: {payload.get('parent_dataset')}")
+            print(f"lifecycle_state: {payload.get('lifecycle_state')}")
+            if payload.get("error_message"):
+                print(f"error_message: {payload.get('error_message')}")
+            rows = [
+                [
+                    item.get("split_name"),
+                    item.get("dataset_name"),
+                    item.get("sample_count"),
+                    item.get("shard_count"),
+                ]
+                for item in payload.get("datasets", [])
+            ]
+            if rows:
+                print("datasets:")
+                print(tabulate(rows, headers=["split", "dataset", "samples", "shards"]))
+            for summary in payload.get("rule_summaries", []):
+                print(f"rule: {summary}")
+            return
+        if "items" in payload and "dataset_name" in payload and "total" in payload:
+            print(f"dataset_name: {payload.get('dataset_name')}")
+            print(f"total: {payload.get('total')}")
+            rows = [
+                [
+                    item.get("name"),
+                    item.get("lifecycle_state"),
+                    ",".join(item.get("split_names", [])),
+                    item.get("sample_count"),
+                    _owner_cell(item),
+                    item.get("sharing") or "-",
+                ]
+                for item in payload["items"]
+            ]
+            if rows:
+                print(
+                    tabulate(
+                        rows,
+                        headers=["split_set", "state", "splits", "samples", "owner", "sharing"],
+                    )
+                )
+            return
+        if (
+            "items" in payload
+            and "total" in payload
+            and "offset" in payload
+            and "dataset_name" not in payload
+            and "dataset" not in payload
+        ):
+            # DatasetListResponse: items + total + paging, no parent dataset.
+            print(f"total: {payload.get('total')}")
+            rows = [
+                [
+                    item.get("name"),
+                    item.get("lifecycle_state"),
+                    item.get("sample_store"),
+                    item.get("sample_count"),
+                    item.get("shard_count"),
+                    _compact_keys(item.get("keys")),
+                    _owner_cell(item),
+                    item.get("sharing") or "-",
+                    item.get("created_at"),
+                ]
+                for item in payload["items"]
+            ]
+            if rows:
+                print(
+                    tabulate(
+                        rows,
+                        headers=[
+                            "name", "state", "store", "samples", "shards", "keys",
+                            "owner", "sharing", "created_at",
+                        ],
+                    )
+                )
+            else:
+                print("datasets: (none)")
+            return
+        if "operations" in payload and "sample_store" in payload:
+            # Store operation log (list_store_operations) or a single-op revert summary.
+            print(f"sample_store: {payload.get('sample_store')}")
+            rows = [
+                [
+                    op.get("id"),
+                    op.get("kind"),
+                    op.get("state"),
+                    op.get("operation_id"),
+                    op.get("summary"),
+                    op.get("created_at"),
+                ]
+                for op in payload.get("operations", [])
+            ]
+            if rows:
+                print(tabulate(rows, headers=["id", "kind", "state", "operation_id", "summary", "created_at"]))
+            else:
+                print("operations: (none)")
+            return
+        if "split_datasets" in payload:
+            if payload.get("parent_dataset") is not None:
+                print(f"parent_dataset: {payload.get('parent_dataset')}")
+            if payload.get("split_set"):
+                print(f"split_set: {payload.get('split_set')}")
+            rows = [
+                [
+                    item.get("split_set"),
+                    item.get("split_name"),
+                    item.get("dataset_name"),
+                    item.get("sample_count"),
+                    item.get("shard_count"),
+                ]
+                for item in payload.get("split_datasets", [])
+            ]
+            if rows:
+                print(tabulate(rows, headers=["split_set", "split", "dataset", "samples", "shards"]))
+            else:
+                print("split_datasets: (none)")
+            return
+        if "sample_stores" in payload and isinstance(payload.get("sample_stores"), list):
+            rows = [
+                [
+                    item.get("name"),
+                    item.get("sample_count"),
+                    item.get("catalog_visibility", "visible"),
+                    _owner_cell(item),
+                    item.get("sharing") or "-",
+                    item.get("created_at"),
+                ]
+                for item in payload["sample_stores"]
+            ]
+            # `visibility` and `sharing` are different things and both are shown: the first
+            # is the catalog listing hint a store was created with, the second is who can
+            # actually read it. Collapsing them would be the drift this design avoids.
+            print(
+                tabulate(
+                    rows,
+                    headers=["name", "sample_count", "visibility", "owner", "sharing", "created_at"],
+                )
+            )
+            return
+        if "state" in payload and "coverage" in payload and "missing_sample_count" in payload:
+            print(f"sample_store: {payload.get('sample_store')}")
+            print(f"producer_id: {payload.get('producer_id')}")
+            print(f"state: {payload.get('state')}")
+            print(f"missing_sample_count: {payload.get('missing_sample_count')}")
+            if payload.get("workset"):
+                workset = payload["workset"]
+                print(f"workset_id: {workset.get('workset_id')}")
+                print(f"workset_samples: {workset.get('sample_count')}")
+            if payload.get("processing_token"):
+                token = payload["processing_token"]
+                print(f"processing_token_id: {token.get('token_id')}")
+                print(f"expires_at: {token.get('expires_at')}")
+            return
+        if "producers" in payload and "sample_store" in payload:
+            print(f"sample_store: {payload.get('sample_store')}")
+            rows = [
+                [
+                    item.get("producer_id"),
+                    item.get("producer_kind"),
+                    item.get("maker"),
+                    item.get("producer_run_system"),
+                    item.get("producer_run_ref"),
+                    item.get("checkpoint_artifact_id"),
+                    ",".join(item.get("produced_keys", [])),
+                ]
+                for item in payload.get("producers", [])
+            ]
+            if rows:
+                print(tabulate(rows, headers=["producer", "kind", "maker", "run_system", "run_ref", "checkpoint", "keys"]))
+            else:
+                print("producers: (none)")
+            return
+        if "producer_id" in payload and "produced_keys" in payload and "producer_kind" in payload:
+            print(f"sample_store: {payload.get('sample_store')}")
+            print(f"producer_id: {payload.get('producer_id')}")
+            print(f"producer_kind: {payload.get('producer_kind')}")
+            print(f"maker: {payload.get('maker')}")
+            if payload.get("producer_run_system") or payload.get("producer_run_ref"):
+                print(f"producer_run: {payload.get('producer_run_system')}:{payload.get('producer_run_ref')}")
+            if payload.get("checkpoint_artifact_id"):
+                print(f"checkpoint_artifact_id: {payload.get('checkpoint_artifact_id')}")
+            print(f"producer_fingerprint: {payload.get('producer_fingerprint')}")
+            print(f"produced_keys: {', '.join(payload.get('produced_keys', []))}")
+            return
+        if "keys" in payload and "name" in payload and "sample_count" in payload:
+            print(f"name: {payload.get('name')}")
+            print(f"sample_count: {payload.get('sample_count')}")
+            print(f"catalog_visibility: {payload.get('catalog_visibility', 'visible')}")
+            if payload.get("created_at") is not None:
+                print(f"created_at: {payload.get('created_at')}")
+            rows = [
+                [item.get("key"), item.get("sample_count")]
+                for item in payload["keys"]
+            ]
+            if rows:
+                print("keys:")
+                print(tabulate(rows, headers=["key", "sample_count"]))
+            return
+        if "deleted_counts" in payload and "name" in payload:
+            print(f"name: {payload.get('name')}")
+            rows = [
+                [key, value]
+                for key, value in payload.get("deleted_counts", {}).items()
+            ]
+            if rows:
+                print("deleted_counts:")
+                print(tabulate(rows, headers=["item", "count"]))
+            return
+        if "available_keys" in payload and "latest_revisions" in payload and "sample_id" in payload:
+            print(f"sample_id: {payload.get('sample_id')}")
+            print(f"sample_store: {payload.get('sample_store')}")
+            if payload.get("tags"):
+                print("tags:")
+                for key, value in sorted(payload["tags"].items()):
+                    print(f"  {key}: {value}")
+            if payload.get("available_keys"):
+                print("available_keys:")
+                for key in payload["available_keys"]:
+                    print(f"  - {key}")
+            rows = [
+                [
+                    item.get("key"),
+                    item.get("producer_id"),
+                    item.get("revision_id"),
+                    "yes" if item.get("is_root") else "",
+                    item.get("ingested_at"),
+                ]
+                for item in payload["latest_revisions"]
+            ]
+            if rows:
+                print("latest_revisions:")
+                print(tabulate(rows, headers=["key", "producer", "revision", "root", "ingested_at"]))
+            return
+        if "shards" in payload and isinstance(payload.get("shards"), list):
+            summary = {
+                "dataset_name": payload.get("dataset_name"),
+                "lifecycle_state": payload.get("lifecycle_state"),
+                "sample_count": payload.get("sample_count"),
+                "shard_count": payload.get("shard_count"),
+            }
+            for key, value in summary.items():
+                if value is not None:
+                    print(f"{key}: {value}")
+            if payload.get("scalars"):
+                print("scalars:")
+                for key, value in sorted(payload["scalars"].items()):
+                    print(f"  {key}: {value}")
+            rows = [
+                [
+                    item.get("key_group"),
+                    item.get("shard_index"),
+                    item.get("content_hash"),
+                    item.get("size_bytes"),
+                ]
+                for item in payload["shards"]
+            ]
+            if rows:
+                print(tabulate(rows, headers=["group", "shard", "hash", "size_bytes"]))
+            return
+        if "profiles" in payload and isinstance(payload.get("profiles"), list):
+            rows = [
+                [item.get("name"), item.get("api_base_url"), "yes" if item.get("active") else ""]
+                for item in payload["profiles"]
+            ]
+            print(tabulate(rows, headers=["profile", "url", "active"]))
+            return
+        if "key_groups" in payload and isinstance(payload.get("key_groups"), list):
+            summary_keys = [
+                "name",
+                "sample_store",
+                "lifecycle_state",
+                "sample_count",
+                "shard_count",
+                "split_set",
+                "split_name",
+            ]
+            for key in summary_keys:
+                value = payload.get(key)
+                if value is not None:
+                    print(f"{key}: {value}")
+            if payload.get("scalars"):
+                print("scalars:")
+                for key, value in sorted(payload["scalars"].items()):
+                    print(f"  {key}: {value}")
+            rows = [
+                [item.get("name"), ",".join(item.get("keys", [])), item.get("manifest_ref")]
+                for item in payload["key_groups"]
+            ]
+            if rows:
+                print(tabulate(rows, headers=["group", "keys", "manifest"]))
+            return
+        if "datasets" in payload and isinstance(payload.get("datasets"), list):
+            print(f"name: {payload.get('name')}")
+            if payload.get("sample_store") is not None:
+                print(f"sample_store: {payload.get('sample_store')}")
+            if payload.get("created_at") is not None:
+                print(f"created_at: {payload.get('created_at')}")
+            print("datasets:")
+            for name in payload["datasets"]:
+                print(f"  - {name}")
+            return
+        for key, value in payload.items():
+            if isinstance(value, list) and value and all(isinstance(item, dict) for item in value):
+                print(f"{key}:")
+                print(tabulate(value, headers="keys"))
+                continue
+            if isinstance(value, dict):
+                print(f"{key}:")
+                for nested_key, nested_value in value.items():
+                    print(f"  {nested_key}: {nested_value}")
+                continue
+            print(f"{key}: {value}")
+        return
+    if isinstance(payload, list):
+        print(tabulate(payload, headers="keys"))
+        return
+    print(payload)

datavo_cli/utils.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, TypeVar
+
+import yaml
+from pydantic import BaseModel
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+
+
+def parse_key_value_pairs(values: list[str] | None) -> dict[str, str]:
+    parsed: dict[str, str] = {}
+    for value in values or []:
+        if "=" not in value:
+            raise RuntimeError(f"Expected KEY=VALUE, got: {value}")
+        key, raw_value = value.split("=", 1)
+        key = key.strip()
+        if not key:
+            raise RuntimeError(f"Expected KEY=VALUE, got: {value}")
+        parsed[key] = raw_value
+    return parsed
+
+
+def load_spec(path: str) -> Any:
+    if path == "-":
+        import sys
+
+        raw_text = sys.stdin.read()
+    else:
+        raw_text = Path(path).read_text(encoding="utf-8")
+    if not raw_text.strip():
+        raise RuntimeError("Spec input is empty.")
+    try:
+        return yaml.safe_load(raw_text)
+    except yaml.YAMLError as exc:
+        raise RuntimeError(f"Failed to parse spec: {exc}") from exc
+
+
+def load_model(path: str, model_type: type[ModelT]) -> ModelT:
+    payload = load_spec(path)
+    return model_type.model_validate(payload)
+
+
+def write_json(path: str | Path, payload: Any) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def model_payload(value: Any) -> Any:
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json", by_alias=True)
+    return value

datavo_cli-0.22.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: datavo-cli
+Version: 0.22.0
+Summary: Datavo command line interface
+License-Expression: Apache-2.0
+Project-URL: Documentation, https://altavo.github.io/datavo/
+Project-URL: Homepage, https://altavo.github.io/datavo/
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argcomplete>=3.4
+Requires-Dist: datavo-sdk[entra]==0.22.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: tabulate>=0.9
+Dynamic: license-file
+
+# datavo-cli
+
+Command-line interface for **[Datavo](https://altavo.github.io/datavo/)**, the
+dataset store. Installs the `datavo` command and the `datavo_sdk` Python client
+together, with Microsoft Entra sign-in.
+
+## Install
+
+```bash
+pip install datavo-cli
+```
+
+## Quickstart
+
+```bash
+datavo auth login                                    # sign in (defaults to https://prod.datavo.io)
+datavo sample-store list                             # first authorized round-trip
+datavo dataset list                                  # browse datasets (--query, --key to filter)
+datavo dataset pull voice_train_v1 --output-dir ./data   # pull a dataset to disk
+```
+
+Point at another instance with a named profile:
+
+```bash
+datavo config set dev --url https://dev.datavo.io
+datavo config use dev
+```
+
+## Documentation
+
+Full guide, reference, and runnable examples: **https://altavo.github.io/datavo/**

datavo_cli-0.22.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+datavo_cli/__init__.py,sha256=3ZANNzjxXIsBXP5B3WP0-uZNGqY7pm32g1LLQDB_AqE,50
+datavo_cli/client_factory.py,sha256=KGc1mmSR8oAYOW55x-S_9EENSVUHV1u12tFBwziP0fA,6257
+datavo_cli/config_store.py,sha256=VI3_M1PS9T3s80DQUx3l4lZ1d0CZfTRSbjSoOCaOiFU,7731
+datavo_cli/diagnostics.py,sha256=_XlXqAPHhUPcVVCr9wJo-jOaAnB8yIBPxcglQHQRw6s,2744
+datavo_cli/errors.py,sha256=qBVQvHSnYSvdG7DEYd6pU3nnvNSI0nAQWvZgHB5vhAQ,1719
+datavo_cli/main.py,sha256=fNFyeBbtHWhvP6p4pdlsk11SsYdD-JJT6rcgBjkZ3oo,2893
+datavo_cli/parsers.py,sha256=pvM6HZ6IczySQI8R8ahH1CTV3n5AdU6W3C7dINZMPlU,24324
+datavo_cli/render.py,sha256=IXERl2KzR3jdGDYitd8CGZeJN9A-zGyv-g0iptLgjoE,16808
+datavo_cli/utils.py,sha256=J87pMyoQLf5u3DjekCoiF-pce5e-hqc71vEkqiCMF1w,1541
+datavo_cli/commands/__init__.py,sha256=49KcaQcSN_6W5EoLnI9BTHabEo6ZqeJ4VgMyagIEeAQ,1159
+datavo_cli/commands/auth.py,sha256=j6R_pqCFpMagH1bSZRGUUd3SbFwyuGCtdIqxKiSj760,3457
+datavo_cli/commands/config.py,sha256=rzi9V0vF04uj-qHMbCplAJR_jbH1W3nyUsOuO-BkdvE,3693
+datavo_cli/commands/dataset.py,sha256=LoZhvNMuH5syPt9Qw5MzYRgQlBKC2_eh0vrzMqLKibw,8816
+datavo_cli/commands/events.py,sha256=dErqXCPoGGSQE1n6_YU-AkyfCnZ2uHQEaHaFsaHh4r0,1735
+datavo_cli/commands/jobpool.py,sha256=4HIgL2wf3Q0vCXl3Gf0t2O8yY8DsVHTZjdGPO_5tMCI,1490
+datavo_cli/commands/sample.py,sha256=veEQqBHBbD2rELWpqNX33EoazgcCxSHxa5CAtVkTBNE,986
+datavo_cli/commands/sample_store.py,sha256=7bYtouhmKAsE6_CdyxdAAKnhEq2CS0HKz2XS1xlatjg,4147
+datavo_cli/commands/source_import.py,sha256=VA_nz41m3RwxGNzkS1p-22MV-lIZ8B8rtWkhJvX9TSk,1916
+datavo_cli/commands/split_set.py,sha256=QKRSFp6it5auQH3Ufd1Y6kIktUYeZK1bEsdvhO5D7Fo,3482
+datavo_cli/commands/stats.py,sha256=AiUQtdGgFa0O9xjMxMhcCQpJaJWEHASr-fi3vNPJTmM,716
+datavo_cli/commands/team.py,sha256=KXWsnPKH2A9WjkYb9qfbSMUMacsbgUdm7p4ZaEj1Kac,7853
+datavo_cli/commands/user.py,sha256=4V7aEdDiDVoeWXAlPuFc-v_aJvWnx4UWYMe70OS-m9Q,2701
+datavo_cli-0.22.0.dist-info/licenses/LICENSE,sha256=5-AUJrHm4TQmwicX7lFZfJu0i7oDs9vvMhDmrenJFeI,11341
+datavo_cli-0.22.0.dist-info/METADATA,sha256=mjpQX8duSlpvpi921B1JvdOHMZnvEseLPOkH9_gFEtk,1541
+datavo_cli-0.22.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+datavo_cli-0.22.0.dist-info/entry_points.txt,sha256=0M-1L1oSSP5B3CyNwmBgulK8X7yrtW19k0wErk7erDQ,48
+datavo_cli-0.22.0.dist-info/top_level.txt,sha256=YTkid9eYLDrFLGj-zDz6fIRREPAm8Vs1VS1YyfnO6uk,11
+datavo_cli-0.22.0.dist-info/RECORD,,

datavo_cli-0.22.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

datavo_cli-0.22.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+datavo = datavo_cli.main:main