entropy-data 0.3.0__py3-none-any.whl

entropy_data/commands/lineage.py

@@ -0,0 +1,107 @@
+"""Lineage commands (OpenLineage events)."""
+
+import json
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, console, print_resource_list, print_success
+from entropy_data.util import read_body
+
+lineage_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "v1/lineage"
+RESOURCE_TYPE = "lineage"
+
+
+@lineage_app.command("list")
+def list_lineage(
+    job_namespace: Annotated[Optional[str], typer.Option("--job-namespace", help="Filter by job namespace.")] = None,
+    job_name: Annotated[Optional[str], typer.Option("--job-name", help="Filter by job name.")] = None,
+    run_id: Annotated[Optional[str], typer.Option("--run-id", help="Filter by run ID.")] = None,
+    event_type: Annotated[
+        Optional[str],
+        typer.Option("--event-type", help="Filter by event type (START, RUNNING, COMPLETE, ABORT, FAIL)."),
+    ] = None,
+    data_product_id: Annotated[
+        Optional[str], typer.Option("--data-product-id", help="Filter by data product ID.")
+    ] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List OpenLineage events."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        params = {}
+        if job_namespace:
+            params["jobNamespace"] = job_namespace
+        if job_name:
+            params["jobName"] = job_name
+        if run_id:
+            params["runId"] = run_id
+        if event_type:
+            params["eventType"] = event_type
+        if data_product_id:
+            params["dataProductId"] = data_product_id
+        client = get_client()
+        data, _ = client.list_resources(RESOURCE_PATH, params=params)
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(data))
+        else:
+            print_resource_list(data, RESOURCE_TYPE, fmt)
+    except Exception as e:
+        handle_error(e)
+
+
+@lineage_app.command("submit")
+def submit_lineage(
+    file: Annotated[
+        Path, typer.Option("--file", "-f", help="JSON or YAML file with OpenLineage RunEvent (use - for stdin).")
+    ] = ...,
+    data_product_id: Annotated[
+        Optional[str], typer.Option("--data-product-id", help="Data product ID to associate the event with.")
+    ] = None,
+    output_port_name: Annotated[
+        Optional[str], typer.Option("--output-port-name", help="Output port name within the data product.")
+    ] = None,
+) -> None:
+    """Submit an OpenLineage RunEvent."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        body = read_body(file)
+        params = {}
+        if data_product_id:
+            params["dataProductId"] = data_product_id
+        if output_port_name:
+            params["outputPortName"] = output_port_name
+        client = get_client()
+        client.post_resource(RESOURCE_PATH, body, params=params or None)
+        print_success("Lineage event submitted.")
+    except Exception as e:
+        handle_error(e)
+
+
+@lineage_app.command("delete")
+def delete_lineage(
+    run_id: Annotated[Optional[str], typer.Option("--run-id", help="Delete by run ID.")] = None,
+    job_namespace: Annotated[Optional[str], typer.Option("--job-namespace", help="Delete by job namespace.")] = None,
+    job_name: Annotated[Optional[str], typer.Option("--job-name", help="Delete by job name.")] = None,
+) -> None:
+    """Delete OpenLineage events."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        params = {}
+        if run_id:
+            params["runId"] = run_id
+        if job_namespace:
+            params["jobNamespace"] = job_namespace
+        if job_name:
+            params["jobName"] = job_name
+        client = get_client()
+        client.delete_resources(RESOURCE_PATH, params=params or None)
+        print_success("Lineage events deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/search.py

@@ -0,0 +1,55 @@
+"""Search commands."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, console
+
+search_app = typer.Typer(no_args_is_help=True)
+
+
+@search_app.command("query")
+def search_query(
+    query: Annotated[str, typer.Argument(help="Search query.")],
+    resource_type: Annotated[
+        Optional[str], typer.Option("--resource-type", "-t", help="Filter by resource type.")
+    ] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Search across all resources."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        params = {}
+        if resource_type:
+            params["resourceType"] = resource_type
+        data = client.search(query, **params)
+
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(data))
+            return
+
+        # Table output for search results
+        results = data if isinstance(data, list) else data.get("results", data.get("items", [data]))
+        if isinstance(results, list):
+            from rich.table import Table
+
+            table = Table(show_header=True, title="Search Results")
+            table.add_column("Type")
+            table.add_column("ID")
+            table.add_column("Title")
+            for item in results:
+                table.add_row(
+                    str(item.get("resourceType", item.get("type", ""))),
+                    str(item.get("id", "")),
+                    str(item.get("title", item.get("name", ""))),
+                )
+            console.print(table)
+        else:
+            console.print_json(json.dumps(data))
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/settings.py

@@ -0,0 +1,68 @@
+"""Settings commands."""
+
+import json
+import sys
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, console, print_success
+
+settings_app = typer.Typer(no_args_is_help=True)
+
+
+@settings_app.command("get-customization")
+def get_customization(
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get organization customization settings."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+    from entropy_data.client import REQUEST_TIMEOUT, _raise_for_status
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        accept = "application/json" if fmt == OutputFormat.json else "application/yaml"
+        response = client.session.get(
+            f"{client.base_url}/api/settings/customization",
+            headers={"Accept": accept},
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(response.json()))
+        else:
+            console.print(response.text)
+    except Exception as e:
+        handle_error(e)
+
+
+@settings_app.command("put-customization")
+def put_customization(
+    file: Annotated[Path, typer.Option("--file", "-f", help="YAML or JSON file (use - for stdin).")] = ...,
+) -> None:
+    """Update organization customization settings."""
+    from entropy_data.cli import get_client, handle_error
+    from entropy_data.client import REQUEST_TIMEOUT, _raise_for_status
+
+    try:
+        if str(file) == "-":
+            content = sys.stdin.read()
+        else:
+            content = file.read_text()
+
+        client = get_client()
+        # Detect content type from file extension or content
+        is_json = str(file).endswith(".json") or content.lstrip().startswith("{")
+        content_type = "application/json" if is_json else "application/yaml"
+        response = client.session.put(
+            f"{client.base_url}/api/settings/customization",
+            data=content.encode(),
+            headers={"Content-Type": content_type},
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+        print_success("Customization updated.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/sourcesystems.py

@@ -0,0 +1,80 @@
+"""Source systems commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data.util import read_body
+
+sourcesystems_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "sourcesystems"
+RESOURCE_TYPE = "sourcesystems"
+
+
+@sourcesystems_app.command("list")
+def list_sourcesystems(
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number (0-indexed).")] = 0,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all source systems."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        data, has_next = client.list_resources(RESOURCE_PATH, params={"p": page})
+        print_resource_list(data, RESOURCE_TYPE, fmt, has_next_page=has_next, page=page)
+    except Exception as e:
+        handle_error(e)
+
+
+@sourcesystems_app.command("get")
+def get_sourcesystem(
+    id: Annotated[str, typer.Argument(help="Source system ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a source system by ID."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        data = client.get_resource(RESOURCE_PATH, id)
+        print_resource(data, RESOURCE_TYPE, fmt)
+    except Exception as e:
+        handle_error(e)
+
+
+@sourcesystems_app.command("put")
+def put_sourcesystem(
+    id: Annotated[str, typer.Argument(help="Source system ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update a source system."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        body = read_body(file)
+        client = get_client()
+        location = client.put_resource(RESOURCE_PATH, id, body)
+        print_success(f"Source system '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@sourcesystems_app.command("delete")
+def delete_sourcesystem(
+    id: Annotated[str, typer.Argument(help="Source system ID.")],
+) -> None:
+    """Delete a source system."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Source system '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/tags.py

@@ -0,0 +1,84 @@
+"""Tags commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data.util import read_body
+
+tags_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "tags"
+RESOURCE_TYPE = "tags"
+
+
+@tags_app.command("list")
+def list_tags(
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number (0-indexed).")] = 0,
+    owner: Annotated[Optional[str], typer.Option("--owner", help="Filter by owner (team name).")] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all tags."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        params = {"p": page}
+        if owner:
+            params["owner"] = owner
+        client = get_client()
+        data, has_next = client.list_resources(RESOURCE_PATH, params=params)
+        print_resource_list(data, RESOURCE_TYPE, fmt, has_next_page=has_next, page=page)
+    except Exception as e:
+        handle_error(e)
+
+
+@tags_app.command("get")
+def get_tag(
+    id: Annotated[str, typer.Argument(help="Tag ID (e.g. 'Governance/PII').")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a tag by ID."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        data = client.get_resource(RESOURCE_PATH, id)
+        print_resource(data, RESOURCE_TYPE, fmt)
+    except Exception as e:
+        handle_error(e)
+
+
+@tags_app.command("put")
+def put_tag(
+    id: Annotated[str, typer.Argument(help="Tag ID (e.g. 'Governance/PII').")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update a tag."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        body = read_body(file)
+        client = get_client()
+        location = client.put_resource(RESOURCE_PATH, id, body)
+        print_success(f"Tag '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@tags_app.command("delete")
+def delete_tag(
+    id: Annotated[str, typer.Argument(help="Tag ID (e.g. 'Governance/PII').")],
+) -> None:
+    """Delete a tag."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Tag '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/teams.py

@@ -0,0 +1,80 @@
+"""Teams commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data.util import read_body
+
+teams_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "teams"
+RESOURCE_TYPE = "teams"
+
+
+@teams_app.command("list")
+def list_teams(
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number (0-indexed).")] = 0,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all teams."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        data, has_next = client.list_resources(RESOURCE_PATH, params={"p": page})
+        print_resource_list(data, RESOURCE_TYPE, fmt, has_next_page=has_next, page=page)
+    except Exception as e:
+        handle_error(e)
+
+
+@teams_app.command("get")
+def get_team(
+    id: Annotated[str, typer.Argument(help="Team ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a team by ID."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        data = client.get_resource(RESOURCE_PATH, id)
+        print_resource(data, RESOURCE_TYPE, fmt)
+    except Exception as e:
+        handle_error(e)
+
+
+@teams_app.command("put")
+def put_team(
+    id: Annotated[str, typer.Argument(help="Team ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update a team."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        body = read_body(file)
+        client = get_client()
+        location = client.put_resource(RESOURCE_PATH, id, body)
+        print_success(f"Team '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@teams_app.command("delete")
+def delete_team(
+    id: Annotated[str, typer.Argument(help="Team ID.")],
+) -> None:
+    """Delete a team."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Team '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/test_results.py

@@ -0,0 +1,85 @@
+"""Test results commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data.util import read_body
+
+test_results_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "test-results"
+RESOURCE_TYPE = "test-results"
+
+
+@test_results_app.command("list")
+def list_test_results(
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number (0-indexed).")] = 0,
+    data_contract_id: Annotated[
+        Optional[str], typer.Option("--data-contract-id", help="Filter by data contract.")
+    ] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all test results."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        params = {"p": page}
+        if data_contract_id:
+            params["dataContractId"] = data_contract_id
+        data, has_next = client.list_resources(RESOURCE_PATH, params=params)
+        print_resource_list(data, RESOURCE_TYPE, fmt, has_next_page=has_next, page=page)
+    except Exception as e:
+        handle_error(e)
+
+
+@test_results_app.command("get")
+def get_test_result(
+    id: Annotated[str, typer.Argument(help="Test result ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a test result by ID."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        data = client.get_resource(RESOURCE_PATH, id)
+        print_resource(data, RESOURCE_TYPE, fmt)
+    except Exception as e:
+        handle_error(e)
+
+
+@test_results_app.command("publish")
+def publish_test_results(
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Publish test results."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        body = read_body(file)
+        client = get_client()
+        location = client.post_resource(RESOURCE_PATH, body)
+        print_success("Test results published.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@test_results_app.command("delete")
+def delete_test_result(
+    id: Annotated[str, typer.Argument(help="Test result ID.")],
+) -> None:
+    """Delete a test result."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Test result '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/usage.py

@@ -0,0 +1,99 @@
+"""Usage commands (OpenTelemetry traces)."""
+
+import json
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, console, print_resource_list, print_success
+from entropy_data.util import read_body
+
+usage_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "v1/traces"
+RESOURCE_TYPE = "usage"
+
+
+@usage_app.command("list")
+def list_usage(
+    scope_name: Annotated[
+        Optional[str], typer.Option("--scope-name", help="Filter by scope name (e.g., 'usage').")
+    ] = None,
+    data_product_id: Annotated[
+        Optional[str], typer.Option("--data-product-id", help="Filter by data product ID.")
+    ] = None,
+    data_contract_id: Annotated[
+        Optional[str], typer.Option("--data-contract-id", help="Filter by data contract ID.")
+    ] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List usage traces."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        params = {}
+        if scope_name:
+            params["scopeName"] = scope_name
+        if data_product_id:
+            params["dataProductId"] = data_product_id
+        if data_contract_id:
+            params["dataContractId"] = data_contract_id
+        client = get_client()
+        data, _ = client.list_resources(RESOURCE_PATH, params=params)
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(data))
+        else:
+            print_resource_list(data, RESOURCE_TYPE, fmt)
+    except Exception as e:
+        handle_error(e)
+
+
+@usage_app.command("submit")
+def submit_usage(
+    file: Annotated[
+        Path, typer.Option("--file", "-f", help="JSON or YAML file with OTLP/JSON traces (use - for stdin).")
+    ] = ...,
+) -> None:
+    """Submit OpenTelemetry traces in OTLP/JSON format."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        body = read_body(file)
+        client = get_client()
+        client.post_resource(RESOURCE_PATH, body)
+        print_success("Usage traces submitted.")
+    except Exception as e:
+        handle_error(e)
+
+
+@usage_app.command("delete")
+def delete_usage(
+    scope_name: Annotated[Optional[str], typer.Option("--scope-name", help="Delete by scope name.")] = None,
+    data_product_id: Annotated[
+        Optional[str], typer.Option("--data-product-id", help="Delete by data product ID.")
+    ] = None,
+    data_contract_id: Annotated[
+        Optional[str], typer.Option("--data-contract-id", help="Delete by data contract ID.")
+    ] = None,
+    span_id: Annotated[Optional[str], typer.Option("--span-id", help="Delete a specific trace by span ID.")] = None,
+) -> None:
+    """Delete usage traces."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        params = {}
+        if scope_name:
+            params["scopeName"] = scope_name
+        if data_product_id:
+            params["dataProductId"] = data_product_id
+        if data_contract_id:
+            params["dataContractId"] = data_contract_id
+        if span_id:
+            params["spanId"] = span_id
+        client = get_client()
+        result = client.delete_resources(RESOURCE_PATH, params=params or None)
+        deleted = result.get("deletedCount", "unknown")
+        print_success(f"Usage traces deleted ({deleted} deleted).")
+    except Exception as e:
+        handle_error(e)