entropy-data-cli 0.2.0__py3-none-any.whl

entropy_data_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Entropy Data CLI — command-line interface for Entropy Data."""
+
+__version__ = "0.2.0"

entropy_data_cli/__main__.py

@@ -0,0 +1,3 @@
+from entropy_data_cli.cli import app
+
+app()

entropy_data_cli/cli.py

@@ -0,0 +1,115 @@
+"""Entropy Data CLI — main application entry point."""
+
+import logging
+import sys
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+
+from entropy_data_cli import __version__
+from entropy_data_cli.client import ApiError, EntropyDataClient
+from entropy_data_cli.config import ConfigurationError, resolve_connection
+from entropy_data_cli.output import OutputFormat
+
+# Global state shared across commands
+_connection_name: str | None = None
+_cli_api_key: str | None = None
+_cli_host: str | None = None
+_output_format: OutputFormat = OutputFormat.table
+_debug: bool = False
+
+error_console = Console(stderr=True)
+
+
+def get_client() -> EntropyDataClient:
+    """Create an API client from the resolved connection config."""
+    config = resolve_connection(
+        connection_name=_connection_name,
+        cli_api_key=_cli_api_key,
+        cli_host=_cli_host,
+    )
+    return EntropyDataClient(config)
+
+
+def get_output_format() -> OutputFormat:
+    return _output_format
+
+
+def handle_error(e: Exception) -> None:
+    """Handle errors with appropriate output and exit codes."""
+    if _debug:
+        raise e
+    if isinstance(e, ConfigurationError):
+        error_console.print(f"[red]Configuration error: {e}[/red]")
+        raise SystemExit(2)
+    if isinstance(e, ApiError):
+        error_console.print(f"[red]API error: {e}[/red]")
+        raise SystemExit(1)
+    error_console.print(f"[red]Error: {e}[/red]")
+    raise SystemExit(1)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        print(f"entropy-data {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="entropy-data",
+    help="CLI for Entropy Data.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        Optional[bool],
+        typer.Option("--version", "-v", help="Show version and exit.", callback=version_callback, is_eager=True),
+    ] = None,
+    connection: Annotated[Optional[str], typer.Option("--connection", "-c", help="Named connection to use.")] = None,
+    api_key: Annotated[Optional[str], typer.Option("--api-key", help="API key (overrides config and env).")] = None,
+    host: Annotated[Optional[str], typer.Option("--host", help="API host URL (overrides config and env).")] = None,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format.")] = OutputFormat.table,
+    debug: Annotated[bool, typer.Option("--debug", help="Enable debug output.")] = False,
+) -> None:
+    """Entropy Data CLI — manage your data platform from the command line."""
+    global _connection_name, _cli_api_key, _cli_host, _output_format, _debug
+    _connection_name = connection
+    _cli_api_key = api_key
+    _cli_host = host
+    _output_format = output
+    _debug = debug
+    if debug:
+        logging.basicConfig(level=logging.DEBUG, stream=sys.stderr)
+
+
+# Register command groups
+from entropy_data_cli.commands.access import access_app  # noqa: E402
+from entropy_data_cli.commands.certifications import certifications_app  # noqa: E402
+from entropy_data_cli.commands.connection import connection_app  # noqa: E402
+from entropy_data_cli.commands.datacontracts import datacontracts_app  # noqa: E402
+from entropy_data_cli.commands.dataproducts import dataproducts_app  # noqa: E402
+from entropy_data_cli.commands.definitions import definitions_app  # noqa: E402
+from entropy_data_cli.commands.events import events_app  # noqa: E402
+from entropy_data_cli.commands.example_data import example_data_app  # noqa: E402
+from entropy_data_cli.commands.search import search_app  # noqa: E402
+from entropy_data_cli.commands.sourcesystems import sourcesystems_app  # noqa: E402
+from entropy_data_cli.commands.teams import teams_app  # noqa: E402
+from entropy_data_cli.commands.test_results import test_results_app  # noqa: E402
+
+app.add_typer(connection_app, name="connection", help="Manage connections.")
+app.add_typer(teams_app, name="teams", help="Manage teams.")
+app.add_typer(dataproducts_app, name="dataproducts", help="Manage data products.")
+app.add_typer(datacontracts_app, name="datacontracts", help="Manage data contracts.")
+app.add_typer(access_app, name="access", help="Manage access (data usage agreements).")
+app.add_typer(sourcesystems_app, name="sourcesystems", help="Manage source systems.")
+app.add_typer(definitions_app, name="definitions", help="Manage definitions.")
+app.add_typer(certifications_app, name="certifications", help="Manage certifications.")
+app.add_typer(example_data_app, name="example-data", help="Manage example data.")
+app.add_typer(test_results_app, name="test-results", help="Manage test results.")
+app.add_typer(events_app, name="events", help="Poll events.")
+app.add_typer(search_app, name="search", help="Search across resources.")

entropy_data_cli/client.py

@@ -0,0 +1,146 @@
+"""HTTP client for the Entropy Data API."""
+
+import json
+import re
+
+import requests
+
+from entropy_data_cli.config import ConnectionConfig
+
+RESPONSE_HEADER_LOCATION_HTML = "location-html"
+REQUEST_TIMEOUT = 30
+
+
+class ApiError(Exception):
+    """HTTP error from the Entropy Data API."""
+
+    def __init__(self, status_code: int, message: str, url: str):
+        self.status_code = status_code
+        self.url = url
+        super().__init__(f"HTTP {status_code} from {url}: {message}")
+
+
+class NotFoundError(ApiError):
+    """404 from the API."""
+
+
+class ValidationError(ApiError):
+    """422 from the API."""
+
+
+def _raise_for_status(response: requests.Response) -> None:
+    """Raise appropriate ApiError subclass for non-2xx responses."""
+    if response.ok:
+        return
+    message = response.text
+    try:
+        body = response.json()
+        message = body.get("detail") or body.get("message") or body.get("title") or response.text
+    except (json.JSONDecodeError, AttributeError):
+        # If the response is HTML, extract a useful message instead of dumping raw markup
+        if "<html" in message.lower():
+            match = re.search(r"<title>([^<]+)</title>", message, re.IGNORECASE)
+            message = match.group(1).strip() if match else response.reason or "Server error"
+    if response.status_code == 404:
+        raise NotFoundError(response.status_code, message, response.url)
+    if response.status_code == 422:
+        raise ValidationError(response.status_code, message, response.url)
+    raise ApiError(response.status_code, message, response.url)
+
+
+def _has_next_page(response: requests.Response) -> bool:
+    """Check if the Link header contains rel="next"."""
+    link = response.headers.get("Link", "")
+    return bool(re.search(r'rel="next"', link))
+
+
+MAX_RESOURCE_ID_LENGTH = 256
+
+
+def _validate_resource_id(resource_id: str) -> None:
+    """Reject empty, too-long, or path-traversal resource IDs."""
+    if not resource_id:
+        raise ValueError("Resource ID must not be empty.")
+    if len(resource_id) > MAX_RESOURCE_ID_LENGTH:
+        raise ValueError(f"Resource ID must not exceed {MAX_RESOURCE_ID_LENGTH} characters.")
+    if ".." in resource_id.split("/"):
+        raise ValueError(f"Resource ID must not contain path traversal: '{resource_id}'")
+
+
+def _validate_page(page: int) -> None:
+    """Reject negative page numbers."""
+    if page < 0:
+        raise ValueError(f"Page number must not be negative: {page}")
+
+
+class EntropyDataClient:
+    def __init__(self, config: ConnectionConfig):
+        self.base_url = config.host.rstrip("/")
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "x-api-key": config.api_key,
+                "Content-Type": "application/json",
+            }
+        )
+
+    def list_resources(self, path: str, params: dict | None = None) -> tuple[list[dict], bool]:
+        """GET /api/{path}. Returns (items, has_next_page)."""
+        if params and "p" in params:
+            _validate_page(int(params["p"]))
+        response = self.session.get(f"{self.base_url}/api/{path}", params=params, timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        return response.json(), _has_next_page(response)
+
+    def get_resource(self, path: str, resource_id: str) -> dict:
+        """GET /api/{path}/{id}."""
+        _validate_resource_id(resource_id)
+        response = self.session.get(f"{self.base_url}/api/{path}/{resource_id}", timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        return response.json()
+
+    def put_resource(self, path: str, resource_id: str, body: dict) -> str | None:
+        """PUT /api/{path}/{id}. Returns location-html URL if present."""
+        _validate_resource_id(resource_id)
+        if "id" in body and body["id"] != resource_id:
+            body = {**body, "id": resource_id}
+        response = self.session.put(f"{self.base_url}/api/{path}/{resource_id}", json=body, timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        return response.headers.get(RESPONSE_HEADER_LOCATION_HTML)
+
+    def delete_resource(self, path: str, resource_id: str) -> None:
+        """DELETE /api/{path}/{id}."""
+        _validate_resource_id(resource_id)
+        response = self.session.delete(f"{self.base_url}/api/{path}/{resource_id}", timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+
+    def post_action(self, path: str, resource_id: str, action: str) -> str | None:
+        """POST /api/{path}/{id}/{action}. Returns location-html URL if present."""
+        _validate_resource_id(resource_id)
+        response = self.session.post(
+            f"{self.base_url}/api/{path}/{resource_id}/{action}", timeout=REQUEST_TIMEOUT
+        )
+        _raise_for_status(response)
+        return response.headers.get(RESPONSE_HEADER_LOCATION_HTML)
+
+    def post_resource(self, path: str, body: dict) -> str | None:
+        """POST /api/{path}. Returns location-html URL if present."""
+        response = self.session.post(f"{self.base_url}/api/{path}", json=body, timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        return response.headers.get(RESPONSE_HEADER_LOCATION_HTML)
+
+    def get_events(self, last_event_id: str | None = None) -> list[dict]:
+        """GET /api/events. Returns list of events."""
+        params = {}
+        if last_event_id:
+            params["lastEventId"] = last_event_id
+        response = self.session.get(f"{self.base_url}/api/events", params=params, timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        return response.json()
+
+    def search(self, query: str, **params) -> dict:
+        """GET /api/search."""
+        params["query"] = query
+        response = self.session.get(f"{self.base_url}/api/search", params=params, timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        return response.json()

entropy_data_cli/commands/access.py

@@ -0,0 +1,128 @@
+"""Access (data usage agreements) commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data_cli.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data_cli.util import read_body
+
+access_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "access"
+RESOURCE_TYPE = "access"
+
+
+@access_app.command("list")
+def list_access(
+    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 access agreements."""
+    from entropy_data_cli.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)
+
+
+@access_app.command("get")
+def get_access(
+    id: Annotated[str, typer.Argument(help="Access agreement ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get an access agreement by ID."""
+    from entropy_data_cli.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)
+
+
+@access_app.command("put")
+def put_access(
+    id: Annotated[str, typer.Argument(help="Access agreement ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update an access agreement."""
+    from entropy_data_cli.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"Access agreement '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@access_app.command("delete")
+def delete_access(
+    id: Annotated[str, typer.Argument(help="Access agreement ID.")],
+) -> None:
+    """Delete an access agreement."""
+    from entropy_data_cli.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Access agreement '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)
+
+
+@access_app.command("approve")
+def approve_access(
+    id: Annotated[str, typer.Argument(help="Access agreement ID.")],
+) -> None:
+    """Approve an access agreement."""
+    from entropy_data_cli.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        location = client.post_action(RESOURCE_PATH, id, "approve")
+        print_success(f"Access agreement '{id}' approved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@access_app.command("reject")
+def reject_access(
+    id: Annotated[str, typer.Argument(help="Access agreement ID.")],
+) -> None:
+    """Reject an access agreement."""
+    from entropy_data_cli.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        location = client.post_action(RESOURCE_PATH, id, "reject")
+        print_success(f"Access agreement '{id}' rejected.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@access_app.command("cancel")
+def cancel_access(
+    id: Annotated[str, typer.Argument(help="Access agreement ID.")],
+) -> None:
+    """Cancel an access agreement."""
+    from entropy_data_cli.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        location = client.post_action(RESOURCE_PATH, id, "cancel")
+        print_success(f"Access agreement '{id}' cancelled.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)

entropy_data_cli/commands/certifications.py

@@ -0,0 +1,80 @@
+"""Certifications commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data_cli.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data_cli.util import read_body
+
+certifications_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "certifications"
+RESOURCE_TYPE = "certifications"
+
+
+@certifications_app.command("list")
+def list_certifications(
+    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 certifications."""
+    from entropy_data_cli.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)
+
+
+@certifications_app.command("get")
+def get_certification(
+    id: Annotated[str, typer.Argument(help="Certification ID.")],
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get a certification by ID."""
+    from entropy_data_cli.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)
+
+
+@certifications_app.command("put")
+def put_certification(
+    id: Annotated[str, typer.Argument(help="Certification ID.")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="JSON or YAML file (use - for stdin).")] = ...,
+) -> None:
+    """Create or update a certification."""
+    from entropy_data_cli.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"Certification '{id}' saved.")
+        print_link(location)
+    except Exception as e:
+        handle_error(e)
+
+
+@certifications_app.command("delete")
+def delete_certification(
+    id: Annotated[str, typer.Argument(help="Certification ID.")],
+) -> None:
+    """Delete a certification."""
+    from entropy_data_cli.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"Certification '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data_cli/commands/connection.py

@@ -0,0 +1,90 @@
+"""Connection management commands."""
+
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from entropy_data_cli import config as cfg
+from entropy_data_cli.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.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_cli/commands/datacontracts.py

@@ -0,0 +1,93 @@
+"""Data contracts commands."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data_cli.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data_cli.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.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.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.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("delete")
+def delete_datacontract(
+    id: Annotated[str, typer.Argument(help="Data contract ID.")],
+) -> None:
+    """Delete a data contract."""
+    from entropy_data_cli.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)