entropy-data 0.3.4__tar.gz → 0.3.5__tar.gz

{entropy_data-0.3.4 → entropy_data-0.3.5}/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [0.3.5]
+
+- Add `entropy-data semantics search <namespace> <query> [--kind <kind>] [--limit <n>]` for case-insensitive substring search across concept id, name, and description in a namespace. Implemented client-side over the existing `GET /api/semantics/experimental/namespaces/{ns}/concepts` endpoint.
+- Add `entropy-data access request <data-product-id> <output-port-id> --purpose <text> --consumer-team|--consumer-user|--consumer-dataproduct <id> [--roles <comma-list>] [--id <agreement-id>]` to submit an access request for a provider output port. Wraps `PUT /api/access/{id}` and auto-generates a UUID when `--id` is omitted.
+
 ## [0.3.4]
 
 - Add `entropy-data datacontracts yaml <id>` to fetch a data contract as ODCS YAML (writes to stdout or `--file`). Backed by `GET /api/datacontracts/{id}.yaml`.

{entropy_data-0.3.4 → entropy_data-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entropy-data
-Version: 0.3.4
+Version: 0.3.5
 Summary: CLI for Entropy Data
 Project-URL: Homepage, https://entropy-data.com
 Project-URL: Documentation, https://docs.entropy-data.com

{entropy_data-0.3.4 → entropy_data-0.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "entropy-data"
-version = "0.3.4"
+version = "0.3.5"
 description = "CLI for Entropy Data"
 requires-python = ">=3.11"
 license = "MIT"

{entropy_data-0.3.4 → entropy_data-0.3.5}/src/entropy_data/commands/access.py

@@ -1,5 +1,6 @@
 """Access (data usage agreements) commands."""
 
+import uuid
 from pathlib import Path
 from typing import Annotated, Optional
 
@@ -126,3 +127,77 @@ def cancel_access(
         print_link(location)
     except Exception as e:
         handle_error(e)
+
+
+@access_app.command("request")
+def request_access(
+    data_product_id: Annotated[str, typer.Argument(help="Provider data product ID.")],
+    output_port_id: Annotated[str, typer.Argument(help="Provider output port ID.")],
+    purpose: Annotated[str, typer.Option("--purpose", help="Business justification for the access.")] = ...,
+    consumer_team: Annotated[
+        Optional[str],
+        typer.Option("--consumer-team", help="Consumer team ID (request on behalf of a team)."),
+    ] = None,
+    consumer_user: Annotated[
+        Optional[str],
+        typer.Option("--consumer-user", help="Consumer user ID (request on behalf of a user)."),
+    ] = None,
+    consumer_dataproduct: Annotated[
+        Optional[str],
+        typer.Option("--consumer-dataproduct", help="Consumer data product ID (cross-product agreement)."),
+    ] = None,
+    roles: Annotated[
+        Optional[str],
+        typer.Option("--roles", help="Comma-separated list of roles to request (e.g. analyst,data_engineer)."),
+    ] = None,
+    id: Annotated[
+        Optional[str],
+        typer.Option("--id", help="Agreement ID. Auto-generated UUID if not provided."),
+    ] = None,
+) -> None:
+    """Submit an access request for a provider data product output port.
+
+    Creates a new access agreement in 'requested' state via PUT /api/access/{id}. Exactly
+    one of --consumer-team / --consumer-user / --consumer-dataproduct must be specified.
+    """
+    from entropy_data.cli import get_client, handle_error
+    from entropy_data.output import error_console
+
+    consumer_count = sum(c is not None for c in (consumer_team, consumer_user, consumer_dataproduct))
+    if consumer_count != 1:
+        error_console.print(
+            "[red]Error: provide exactly one of --consumer-team, --consumer-user, "
+            "or --consumer-dataproduct.[/red]"
+        )
+        raise SystemExit(2)
+
+    agreement_id = id or str(uuid.uuid4())
+    consumer: dict = {}
+    if consumer_team is not None:
+        consumer["teamId"] = consumer_team
+    if consumer_user is not None:
+        consumer["userId"] = consumer_user
+    if consumer_dataproduct is not None:
+        consumer["dataProductId"] = consumer_dataproduct
+
+    body: dict = {
+        "id": agreement_id,
+        "provider": {
+            "dataProductId": data_product_id,
+            "outputPortId": output_port_id,
+        },
+        "consumer": consumer,
+        "info": {
+            "purpose": purpose,
+        },
+    }
+    if roles:
+        body["roles"] = [r.strip() for r in roles.split(",") if r.strip()]
+
+    try:
+        client = get_client()
+        location = client.put_resource(RESOURCE_PATH, agreement_id, body)
+        print_success(f"Access request '{agreement_id}' submitted.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)

{entropy_data-0.3.4 → entropy_data-0.3.5}/src/entropy_data/commands/semantics.py

@@ -257,6 +257,52 @@ def delete_relationship(
         handle_error(e)
 
 
+@semantics_app.command("search")
+def search_concepts(
+    namespace: Annotated[str, typer.Argument(help="Namespace ID.")],
+    query: Annotated[str, typer.Argument(help="Search query (case-insensitive substring).")],
+    kind: Annotated[
+        Optional[str],
+        typer.Option("--kind", help="Filter by kind: entity, metric, group, shared_property, property."),
+    ] = None,
+    limit: Annotated[int, typer.Option("--limit", help="Max results.")] = 50,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Search concepts in a namespace by case-insensitive substring against id, name, description.
+
+    Implemented client-side: fetches all concepts in the namespace via the experimental list
+    endpoint, then filters in memory. The platform has no dedicated search endpoint.
+    """
+    from entropy_data.cli import get_client, get_output_format, handle_error
+    from entropy_data.output import error_console
+
+    fmt = output or get_output_format()
+    q = query.strip().lower()
+    if not q:
+        error_console.print("[red]Error: query must not be empty.[/red]")
+        raise SystemExit(2)
+
+    try:
+        client = get_client()
+        all_concepts, _ = client.list_resources(_concepts_path(namespace))
+
+        def matches(c: dict) -> bool:
+            haystack = " ".join(
+                [
+                    c.get("id") or "",
+                    c.get("name") or "",
+                    c.get("description") or "",
+                ]
+            ).lower()
+            return q in haystack
+
+        filtered = [c for c in all_concepts if matches(c) and (kind is None or c.get("kind") == kind)]
+        truncated = filtered[: max(1, limit)]
+        print_resource_list(truncated, "semantic-concepts", fmt)
+    except Exception as e:
+        handle_error(e)
+
+
 semantics_app.add_typer(namespaces_app, name="namespaces", help="Manage semantic namespaces.")
 semantics_app.add_typer(concepts_app, name="concepts", help="Manage semantic concepts.")
 semantics_app.add_typer(relationships_app, name="relationships", help="Manage semantic relationships.")

entropy_data-0.3.5/tests/commands/test_access_request.py

@@ -0,0 +1,118 @@
+"""Tests for the `access request` command."""
+
+import json
+import re
+
+import responses
+from typer.testing import CliRunner
+
+import entropy_data.config as cfg
+from entropy_data.cli import app
+
+runner = CliRunner()
+BASE_URL = "https://api.entropy-data.com"
+
+UUID_RE = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
+
+
+def _setup(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+
+
+@responses.activate
+def test_request_with_consumer_team(monkeypatch, tmp_path):
+    _setup(monkeypatch, tmp_path)
+    captured: dict = {}
+
+    def _capture(request):
+        captured["body"] = json.loads(request.body)
+        return (200, {}, "")
+
+    responses.add_callback(responses.PUT, re.compile(rf"{BASE_URL}/api/access/.+"), callback=_capture)
+
+    result = runner.invoke(
+        app,
+        [
+            "access",
+            "request",
+            "dp_account_master",
+            "accounts",
+            "--purpose",
+            "Building churn model.",
+            "--consumer-team",
+            "customer-success",
+        ],
+    )
+    assert result.exit_code == 0
+    assert "submitted" in result.output
+    body = captured["body"]
+    assert body["provider"] == {"dataProductId": "dp_account_master", "outputPortId": "accounts"}
+    assert body["consumer"] == {"teamId": "customer-success"}
+    assert body["info"] == {"purpose": "Building churn model."}
+    assert UUID_RE.match(body["id"])
+
+
+@responses.activate
+def test_request_with_explicit_id_and_roles(monkeypatch, tmp_path):
+    _setup(monkeypatch, tmp_path)
+    captured: dict = {}
+
+    def _capture(request):
+        captured["body"] = json.loads(request.body)
+        return (200, {}, "")
+
+    responses.add_callback(responses.PUT, f"{BASE_URL}/api/access/req-001", callback=_capture)
+
+    result = runner.invoke(
+        app,
+        [
+            "access",
+            "request",
+            "dp_a",
+            "op_a",
+            "--purpose",
+            "x",
+            "--consumer-user",
+            "alice@example.com",
+            "--roles",
+            "analyst, data_engineer",
+            "--id",
+            "req-001",
+        ],
+    )
+    assert result.exit_code == 0
+    body = captured["body"]
+    assert body["id"] == "req-001"
+    assert body["consumer"] == {"userId": "alice@example.com"}
+    assert body["roles"] == ["analyst", "data_engineer"]
+
+
+def test_request_missing_consumer(monkeypatch, tmp_path):
+    _setup(monkeypatch, tmp_path)
+    result = runner.invoke(
+        app,
+        ["access", "request", "dp_a", "op_a", "--purpose", "x"],
+    )
+    assert result.exit_code == 2
+    assert "consumer" in result.output.lower()
+
+
+def test_request_multiple_consumers(monkeypatch, tmp_path):
+    _setup(monkeypatch, tmp_path)
+    result = runner.invoke(
+        app,
+        [
+            "access",
+            "request",
+            "dp_a",
+            "op_a",
+            "--purpose",
+            "x",
+            "--consumer-team",
+            "t1",
+            "--consumer-user",
+            "u1",
+        ],
+    )
+    assert result.exit_code == 2

{entropy_data-0.3.4 → entropy_data-0.3.5}/tests/commands/test_semantics.py

@@ -24,6 +24,27 @@ CONCEPT = {
     "status": "active",
 }
 
+CONCEPTS_FOR_SEARCH = [
+    {
+        "id": "customer",
+        "name": "Customer",
+        "kind": "entity",
+        "description": "A person or organization that purchases.",
+    },
+    {
+        "id": "account",
+        "name": "Account",
+        "kind": "entity",
+        "description": "An ongoing relationship with a customer.",
+    },
+    {
+        "id": "mrr",
+        "name": "Monthly Recurring Revenue",
+        "kind": "metric",
+        "description": "Monthly revenue from active subscriptions.",
+    },
+]
+
 RELATIONSHIP = {
     "id": "customer-has-orders",
     "name": "Customer has Orders",
@@ -216,7 +237,60 @@ def test_semantics_relationships_delete(monkeypatch, tmp_path):
         ["semantics", "relationships", "delete", "main", "customer-has-orders"],
     )
     assert result.exit_code == 0
-    assert "deleted" in result.output
+
+
+# Search
+
+
+@responses.activate
+def test_semantics_search_substring(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+    responses.add(responses.GET, f"{NS_URL}/main/concepts", json=CONCEPTS_FOR_SEARCH, status=200)
+    result = runner.invoke(
+        app, ["semantics", "search", "main", "customer", "--output", "json"]
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    ids = {c["id"] for c in data}
+    # 'customer' matches both the customer concept and the account description
+    assert ids == {"customer", "account"}
+
+
+@responses.activate
+def test_semantics_search_kind_filter(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+    responses.add(responses.GET, f"{NS_URL}/main/concepts", json=CONCEPTS_FOR_SEARCH, status=200)
+    result = runner.invoke(
+        app,
+        ["semantics", "search", "main", "revenue", "--kind", "metric", "--output", "json"],
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert len(data) == 1
+    assert data[0]["id"] == "mrr"
+
+
+@responses.activate
+def test_semantics_search_limit(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+    responses.add(responses.GET, f"{NS_URL}/main/concepts", json=CONCEPTS_FOR_SEARCH, status=200)
+    result = runner.invoke(
+        app,
+        ["semantics", "search", "main", "a", "--limit", "1", "--output", "json"],
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert len(data) == 1
+
+
+def test_semantics_search_empty_query(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+    result = runner.invoke(app, ["semantics", "search", "main", "   "])
+    assert result.exit_code == 2
 
 
 def test_semantics_help():