entropy-data 0.3.0__py3-none-any.whl

entropy_data/commands/connection.py

@@ -0,0 +1,90 @@
+"""Connection management commands."""
+
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from entropy_data import config as cfg
+from entropy_data.output import console, print_error, print_success
+
+connection_app = typer.Typer(no_args_is_help=True)
+
+
+@connection_app.command("list")
+def list_connections() -> None:
+    """List all configured connections."""
+    connections = cfg.list_connections()
+    if not connections:
+        console.print("No connections configured. Run: entropy-data connection add <name>")
+        return
+
+    table = Table(show_header=True)
+    table.add_column("Name")
+    table.add_column("Host")
+    table.add_column("API Key")
+    table.add_column("Default")
+    for conn in connections:
+        table.add_row(
+            conn["name"],
+            conn["host"],
+            conn["api_key"],
+            "*" if conn["default"] else "",
+        )
+    console.print(table)
+
+
+@connection_app.command("add")
+def add_connection(
+    name: Annotated[str, typer.Argument(help="Connection name.")],
+    api_key: Annotated[str, typer.Option("--api-key", prompt="API key", help="The API key.")] = None,
+    host: Annotated[
+        str, typer.Option("--host", prompt="Host", prompt_required=False, help="API host URL.")
+    ] = cfg.DEFAULT_HOST,
+) -> None:
+    """Add or update a named connection."""
+    try:
+        cfg.add_connection(name, api_key, host)
+        print_success(f"Connection '{name}' saved.")
+    except cfg.ConfigurationError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@connection_app.command("remove")
+def remove_connection(
+    name: Annotated[str, typer.Argument(help="Connection name to remove.")],
+) -> None:
+    """Remove a named connection."""
+    try:
+        cfg.remove_connection(name)
+        print_success(f"Connection '{name}' removed.")
+    except cfg.ConfigurationError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@connection_app.command("set-default")
+def set_default(
+    name: Annotated[str, typer.Argument(help="Connection name to set as default.")],
+) -> None:
+    """Set the default connection."""
+    try:
+        cfg.set_default_connection(name)
+        print_success(f"Default connection set to '{name}'.")
+    except cfg.ConfigurationError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@connection_app.command("test")
+def test_connection() -> None:
+    """Test the current connection by calling the API."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.list_resources("teams", params={"p": "0"})
+        print_success("Connection successful.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/costs.py

@@ -0,0 +1,61 @@
+"""Costs commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, print_resource_list, print_success
+from entropy_data.util import read_body
+
+costs_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "costs"
+RESOURCE_TYPE = "costs"
+
+
+@costs_app.command("list")
+def list_costs(
+    data_product_id: Annotated[str, typer.Option("--data-product-id", help="Data product ID to list costs for.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all costs of a data product."""
+    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={"dataProductId": data_product_id})
+        print_resource_list(data, RESOURCE_TYPE, fmt)
+    except Exception as e:
+        handle_error(e)
+
+
+@costs_app.command("add")
+def add_cost(
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Add a cost."""
+    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("Cost added.")
+    except Exception as e:
+        handle_error(e)
+
+
+@costs_app.command("delete")
+def delete_cost(
+    id: Annotated[str, typer.Argument(help="Cost ID.")],
+) -> None:
+    """Delete a cost."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Cost '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/datacontracts.py

@@ -0,0 +1,115 @@
+"""Data contracts 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
+
+datacontracts_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "datacontracts"
+RESOURCE_TYPE = "datacontracts"
+
+
+@datacontracts_app.command("list")
+def list_datacontracts(
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number (0-indexed).")] = 0,
+    query: Annotated[Optional[str], typer.Option("--query", "-q", help="Search term.")] = None,
+    owner: Annotated[Optional[str], typer.Option("--owner", help="Filter by owner.")] = None,
+    tag: Annotated[Optional[str], typer.Option("--tag", help="Filter by tag.")] = None,
+    sort: Annotated[Optional[str], typer.Option("--sort", help="Sort field.")] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all data contracts."""
+    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 query:
+            params["q"] = query
+        if owner:
+            params["owner"] = owner
+        if tag:
+            params["tag"] = tag
+        if sort:
+            params["sort"] = sort
+        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)
+
+
+@datacontracts_app.command("get")
+def get_datacontract(
+    id: Annotated[str, typer.Argument(help="Data contract ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a data contract 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)
+
+
+@datacontracts_app.command("put")
+def put_datacontract(
+    id: Annotated[str, typer.Argument(help="Data contract ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update a data contract."""
+    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"Data contract '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@datacontracts_app.command("test")
+def test_datacontract(
+    id: Annotated[str, typer.Argument(help="Data contract ID.")],
+    server: Annotated[Optional[str], typer.Option("--server", "-s", help="Server name to test against.")] = None,
+) -> None:
+    """Run a data contract test."""
+    import json
+
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        params = {}
+        if server:
+            params["server"] = server
+        # Data contract tests can take a long time (up to 30 minutes)
+        data = client.post_action_json(RESOURCE_PATH, id, "test", params=params, timeout=1800)
+        print(json.dumps(data, indent=2))
+    except Exception as e:
+        handle_error(e)
+
+
+@datacontracts_app.command("delete")
+def delete_datacontract(
+    id: Annotated[str, typer.Argument(help="Data contract ID.")],
+) -> None:
+    """Delete a data contract."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Data contract '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/dataproducts.py

@@ -0,0 +1,93 @@
+"""Data products 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
+
+dataproducts_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "dataproducts"
+RESOURCE_TYPE = "dataproducts"
+
+
+@dataproducts_app.command("list")
+def list_dataproducts(
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number (0-indexed).")] = 0,
+    query: Annotated[Optional[str], typer.Option("--query", "-q", help="Search term.")] = None,
+    status: Annotated[Optional[str], typer.Option("--status", help="Filter by status.")] = None,
+    tag: Annotated[Optional[str], typer.Option("--tag", help="Filter by tag.")] = None,
+    sort: Annotated[Optional[str], typer.Option("--sort", help="Sort field.")] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all data products."""
+    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 query:
+            params["q"] = query
+        if status:
+            params["status"] = status
+        if tag:
+            params["tag"] = tag
+        if sort:
+            params["sort"] = sort
+        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)
+
+
+@dataproducts_app.command("get")
+def get_dataproduct(
+    id: Annotated[str, typer.Argument(help="Data product ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a data product 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)
+
+
+@dataproducts_app.command("put")
+def put_dataproduct(
+    id: Annotated[str, typer.Argument(help="Data product ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update a data product."""
+    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"Data product '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@dataproducts_app.command("delete")
+def delete_dataproduct(
+    id: Annotated[str, typer.Argument(help="Data product ID.")],
+) -> None:
+    """Delete a data product."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Data product '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/definitions.py

@@ -0,0 +1,80 @@
+"""Definitions 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
+
+definitions_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "definitions"
+RESOURCE_TYPE = "definitions"
+
+
+@definitions_app.command("list")
+def list_definitions(
+    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 definitions."""
+    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)
+
+
+@definitions_app.command("get")
+def get_definition(
+    id: Annotated[str, typer.Argument(help="Definition ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a definition 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)
+
+
+@definitions_app.command("put")
+def put_definition(
+    id: Annotated[str, typer.Argument(help="Definition ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update a definition."""
+    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"Definition '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@definitions_app.command("delete")
+def delete_definition(
+    id: Annotated[str, typer.Argument(help="Definition ID.")],
+) -> None:
+    """Delete a definition."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Definition '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/events.py

@@ -0,0 +1,32 @@
+"""Events commands."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, console, print_resource_list
+
+events_app = typer.Typer(no_args_is_help=True)
+
+
+@events_app.command("poll")
+def poll_events(
+    last_event_id: Annotated[
+        Optional[str], typer.Option("--last-event-id", help="Last event ID for incremental polling.")
+    ] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Poll for events."""
+    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_events(last_event_id=last_event_id)
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(data))
+        else:
+            print_resource_list(data, "events", fmt)
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/example_data.py

@@ -0,0 +1,83 @@
+"""Example data 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
+
+example_data_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "example-data"
+RESOURCE_TYPE = "example-data"
+
+
+@example_data_app.command("list")
+def list_example_data(
+    data_product_id: Annotated[Optional[str], typer.Option("--data-product-id", help="Filter by data product.")] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """List all example data entries."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        params = {}
+        if data_product_id:
+            params["dataProductId"] = data_product_id
+        data, has_next = client.list_resources(RESOURCE_PATH, params=params or None)
+        print_resource_list(data, RESOURCE_TYPE, fmt, has_next_page=has_next)
+    except Exception as e:
+        handle_error(e)
+
+
+@example_data_app.command("get")
+def get_example_data(
+    id: Annotated[str, typer.Argument(help="Example data ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get example data 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)
+
+
+@example_data_app.command("put")
+def put_example_data(
+    id: Annotated[str, typer.Argument(help="Example data ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update example data."""
+    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"Example data '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@example_data_app.command("delete")
+def delete_example_data(
+    id: Annotated[str, typer.Argument(help="Example data ID.")],
+) -> None:
+    """Delete example data."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Example data '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/import_export.py

@@ -0,0 +1,134 @@
+"""Import command for organization exports."""
+
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Annotated
+
+import typer
+import yaml
+
+from entropy_data.client import ApiError
+from entropy_data.output import console, error_console
+
+import_app = typer.Typer(no_args_is_help=True)
+
+# Import order respects resource dependencies:
+# teams (parent→child), tags (→teams), definitions (→teams),
+# assets (→teams), datacontracts (→teams, assets),
+# dataproducts (→teams, datacontracts, assets), access (→dataproducts)
+RESOURCE_ORDER = [
+    ("teams", "teams"),
+    ("tags", "tags"),
+    ("definitions", "definitions"),
+    ("assets", "assets"),
+    ("datacontracts", "datacontracts"),
+    ("dataproducts", "dataproducts"),
+    ("access", "access"),
+]
+
+
+def _import_teams(teams_dir: Path, client) -> tuple[int, int]:
+    """Import teams in topological order (parents before children), stripping members."""
+    teams = {}
+    for f in sorted(teams_dir.glob("*.yaml")):
+        data = yaml.safe_load(f.read_text())
+        data["members"] = []
+        teams[data["id"]] = {"data": data, "parent": data.get("parent")}
+
+    imported: set[str] = set()
+    success_count = 0
+    error_count = 0
+
+    while len(imported) < len(teams):
+        progress = False
+        for tid, t in teams.items():
+            if tid in imported:
+                continue
+            if t["parent"] is None or t["parent"] in imported:
+                try:
+                    client.put_resource("teams", tid, t["data"])
+                    console.print(f"  [green]OK[/green]   {tid}")
+                    success_count += 1
+                except ApiError as e:
+                    error_console.print(f"  [red]FAIL[/red] {tid}: {e}")
+                    error_count += 1
+                imported.add(tid)
+                progress = True
+
+        if not progress:
+            remaining = set(teams.keys()) - imported
+            error_console.print(f"  [red]ERROR: circular or broken parent references: {remaining}[/red]")
+            error_count += len(remaining)
+            break
+
+    return success_count, error_count
+
+
+def _import_simple(resource_dir: Path, api_path: str, client) -> tuple[int, int]:
+    """Import resources from a directory using PUT."""
+    success_count = 0
+    error_count = 0
+
+    for f in sorted(resource_dir.glob("*.yaml")):
+        data = yaml.safe_load(f.read_text())
+        resource_id = data["id"]
+        try:
+            client.put_resource(api_path, resource_id, data)
+            console.print(f"  [green]OK[/green]   {resource_id}")
+            success_count += 1
+        except ApiError as e:
+            error_console.print(f"  [red]FAIL[/red] {resource_id}: {e}")
+            error_count += 1
+
+    return success_count, error_count
+
+
+@import_app.command("zip")
+def import_zip(
+    file: Annotated[Path, typer.Argument(help="Path to the export zip file.")],
+) -> None:
+    """Import an organization export zip file."""
+    from entropy_data.cli import get_client, handle_error
+
+    if not file.is_file():
+        error_console.print(f"[red]Error: {file} not found[/red]")
+        raise typer.Exit(1)
+
+    if not zipfile.is_zipfile(file):
+        error_console.print(f"[red]Error: {file} is not a valid zip file[/red]")
+        raise typer.Exit(1)
+
+    try:
+        client = get_client()
+    except Exception as e:
+        handle_error(e)
+        return
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        export_dir = Path(tmpdir)
+        console.print(f"Extracting {file}...")
+        with zipfile.ZipFile(file) as zf:
+            zf.extractall(export_dir)
+
+        total_ok = 0
+        total_fail = 0
+
+        for directory, api_path in RESOURCE_ORDER:
+            resource_dir = export_dir / directory
+            if not resource_dir.is_dir():
+                continue
+
+            console.print(f"\n[bold]{api_path}[/bold]")
+
+            if directory == "teams":
+                ok, fail = _import_teams(resource_dir, client)
+            else:
+                ok, fail = _import_simple(resource_dir, api_path, client)
+
+            total_ok += ok
+            total_fail += fail
+
+        console.print(f"\n[bold]Summary:[/bold] {total_ok} succeeded, {total_fail} failed")
+        if total_fail > 0:
+            raise typer.Exit(1)