entropy-data 0.3.0__py3-none-any.whl

entropy_data/__init__.py

@@ -0,0 +1,5 @@
+"""Entropy Data CLI — command-line interface for Entropy Data."""
+
+from importlib.metadata import version
+
+__version__ = version("entropy-data")

entropy_data/__main__.py

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

entropy_data/cli.py

@@ -0,0 +1,133 @@
+"""Entropy Data CLI — main application entry point."""
+
+import logging
+import sys
+from typing import Annotated, Optional
+
+import typer
+from dotenv import load_dotenv
+from rich.console import Console
+
+from entropy_data import __version__
+from entropy_data.client import ApiError, EntropyDataClient
+from entropy_data.config import ConfigurationError, resolve_connection
+from entropy_data.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
+    load_dotenv()
+    _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.commands.access import access_app  # noqa: E402
+from entropy_data.commands.api_keys import api_keys_app  # noqa: E402
+from entropy_data.commands.assets import assets_app  # noqa: E402
+from entropy_data.commands.certifications import certifications_app  # noqa: E402
+from entropy_data.commands.connection import connection_app  # noqa: E402
+from entropy_data.commands.costs import costs_app  # noqa: E402
+from entropy_data.commands.datacontracts import datacontracts_app  # noqa: E402
+from entropy_data.commands.dataproducts import dataproducts_app  # noqa: E402
+from entropy_data.commands.definitions import definitions_app  # noqa: E402
+from entropy_data.commands.events import events_app  # noqa: E402
+from entropy_data.commands.example_data import example_data_app  # noqa: E402
+from entropy_data.commands.import_export import import_app  # noqa: E402
+from entropy_data.commands.lineage import lineage_app  # noqa: E402
+from entropy_data.commands.search import search_app  # noqa: E402
+from entropy_data.commands.settings import settings_app  # noqa: E402
+from entropy_data.commands.sourcesystems import sourcesystems_app  # noqa: E402
+from entropy_data.commands.tags import tags_app  # noqa: E402
+from entropy_data.commands.teams import teams_app  # noqa: E402
+from entropy_data.commands.test_results import test_results_app  # noqa: E402
+from entropy_data.commands.usage import usage_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(costs_app, name="costs", help="Manage costs.")
+app.add_typer(assets_app, name="assets", help="Manage data assets.")
+app.add_typer(tags_app, name="tags", help="Manage tags.")
+app.add_typer(api_keys_app, name="api-keys", help="Manage API keys.")
+app.add_typer(settings_app, name="settings", help="Manage organization settings.")
+app.add_typer(events_app, name="events", help="Poll events.")
+app.add_typer(lineage_app, name="lineage", help="Manage lineage (OpenLineage events).")
+app.add_typer(search_app, name="search", help="Search across resources.")
+app.add_typer(usage_app, name="usage", help="Manage usage (OpenTelemetry traces).")
+app.add_typer(import_app, name="import", help="Import organization exports.")

entropy_data/client.py

@@ -0,0 +1,163 @@
+"""HTTP client for the Entropy Data API."""
+
+import json
+import re
+
+import requests
+
+from entropy_data.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_action_json(self, path: str, resource_id: str, action: str, params: dict | None = None,
+                         timeout: int = REQUEST_TIMEOUT) -> dict:
+        """POST /api/{path}/{id}/{action} with query params. Returns response JSON."""
+        _validate_resource_id(resource_id)
+        response = self.session.post(
+            f"{self.base_url}/api/{path}/{resource_id}/{action}", params=params, timeout=timeout,
+        )
+        _raise_for_status(response)
+        return response.json()
+
+    def post_resource(self, path: str, body: dict, params: dict | None = None) -> str | None:
+        """POST /api/{path}. Returns location-html URL if present."""
+        response = self.session.post(f"{self.base_url}/api/{path}", json=body, params=params, timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        return response.headers.get(RESPONSE_HEADER_LOCATION_HTML)
+
+    def delete_resources(self, path: str, params: dict | None = None) -> dict:
+        """DELETE /api/{path} with query params. Returns response JSON."""
+        response = self.session.delete(f"{self.base_url}/api/{path}", params=params, timeout=REQUEST_TIMEOUT)
+        _raise_for_status(response)
+        try:
+            return response.json()
+        except Exception:
+            return {}
+
+    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/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.output import OutputFormat, print_link, print_resource, print_resource_list, print_success
+from entropy_data.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 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 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 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 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 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 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 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/commands/api_keys.py

@@ -0,0 +1,65 @@
+"""API Keys commands."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, console, print_success
+
+api_keys_app = typer.Typer(no_args_is_help=True)
+RESOURCE_PATH = "api-keys"
+
+
+@api_keys_app.command("create")
+def create_api_key(
+    scope: Annotated[str, typer.Option("--scope", help="Scope: 'team' (read/write) or 'team_read' (read-only).")],
+    team_id: Annotated[str, typer.Option("--team-id", help="Team ID to scope the key to.")],
+    display_name: Annotated[
+        Optional[str], typer.Option("--display-name", help="Human-readable name for the key.")
+    ] = None,
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Create a team-scoped API key."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+
+    fmt = output or get_output_format()
+    try:
+        body = {"scope": scope, "teamId": team_id}
+        if display_name:
+            body["displayName"] = display_name
+        client = get_client()
+        response = client.session.post(
+            f"{client.base_url}/api/{RESOURCE_PATH}",
+            json=body,
+            timeout=30,
+        )
+        from entropy_data.client import _raise_for_status
+
+        _raise_for_status(response)
+        data = response.json()
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(data))
+        else:
+            print_success(f"API key created: {data.get('organizationApiKeyId')}")
+            key = data.get("key")
+            if key:
+                console.print(f"[bold]Key:[/bold] {key}")
+                console.print("[dim]This key is only shown once. Store it securely.[/dim]")
+    except Exception as e:
+        handle_error(e)
+
+
+@api_keys_app.command("delete")
+def delete_api_key(
+    id: Annotated[str, typer.Argument(help="API key ID.")],
+) -> None:
+    """Delete a team-scoped API key."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.delete_resource(RESOURCE_PATH, id)
+        print_success(f"API key '{id}' deleted.")
+    except Exception as e:
+        handle_error(e)

entropy_data/commands/assets.py

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

entropy_data/commands/certifications.py

@@ -0,0 +1,80 @@
+"""Certifications 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
+
+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 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 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 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 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)