entropy-data 0.3.1__tar.gz → 0.3.3__tar.gz

{entropy_data-0.3.1 → entropy_data-0.3.3}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.3.3]
+
+- Add `entropy-data organization get` to fetch organization settings (vanity URL, host, full name, plan, SSO) for the API key in use. Backed by the new `GET /api/organization/settings` endpoint.
+- Add `entropy-data connection get [name]` to inspect a stored connection. API key is masked by default; pass `--show-api-key` to print it in clear text. Use `-o json` for scripting.
+- `entropy-data connection add` auto-fetches the organization vanity URL via `/api/organization/settings` and stores it on the connection. Best-effort: older servers or network errors fall back to no vanity URL.
+- `connection list` surfaces the stored vanity URL.
+
+## [0.3.2]
+
+- Add `git-connection` subcommands to `dataproducts` and `datacontracts`
+
 ## [0.3.1]
 
 - Support Python 3.11 (lowered minimum from 3.12)

{entropy_data-0.3.1 → entropy_data-0.3.3}/PKG-INFO

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

{entropy_data-0.3.1 → entropy_data-0.3.3}/pyproject.toml

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

{entropy_data-0.3.1 → entropy_data-0.3.3}/src/entropy_data/cli.py

@@ -103,6 +103,7 @@ 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.organization import organization_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
@@ -125,6 +126,7 @@ 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(organization_app, name="organization", help="Get organization details.")
 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).")

{entropy_data-0.3.1 → entropy_data-0.3.3}/src/entropy_data/client.py

@@ -121,12 +121,15 @@ class EntropyDataClient:
         _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:
+    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,
+            f"{self.base_url}/api/{path}/{resource_id}/{action}",
+            params=params,
+            timeout=timeout,
         )
         _raise_for_status(response)
         return response.json()
@@ -155,6 +158,53 @@ class EntropyDataClient:
         _raise_for_status(response)
         return response.json()
 
+    def get_gitconnection(self, path: str, resource_id: str) -> dict:
+        """GET /api/{path}/{id}/gitconnection."""
+        _validate_resource_id(resource_id)
+        response = self.session.get(
+            f"{self.base_url}/api/{path}/{resource_id}/gitconnection",
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+        return response.json()
+
+    def put_gitconnection(self, path: str, resource_id: str, body: dict) -> dict:
+        """PUT /api/{path}/{id}/gitconnection."""
+        _validate_resource_id(resource_id)
+        response = self.session.put(
+            f"{self.base_url}/api/{path}/{resource_id}/gitconnection",
+            json=body,
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+        return response.json()
+
+    def delete_gitconnection(self, path: str, resource_id: str) -> None:
+        """DELETE /api/{path}/{id}/gitconnection."""
+        _validate_resource_id(resource_id)
+        response = self.session.delete(
+            f"{self.base_url}/api/{path}/{resource_id}/gitconnection",
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+
+    def gitconnection_action(
+        self,
+        path: str,
+        resource_id: str,
+        action: str,
+        body: dict | None = None,
+    ) -> dict:
+        """POST /api/{path}/{id}/gitconnection/{action}. action ∈ {pull, push, push-pr}."""
+        _validate_resource_id(resource_id)
+        response = self.session.post(
+            f"{self.base_url}/api/{path}/{resource_id}/gitconnection/{action}",
+            json=body if body is not None else None,
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+        return response.json()
+
     def search(self, query: str, **params) -> dict:
         """GET /api/search."""
         params["query"] = query

entropy_data-0.3.3/src/entropy_data/commands/connection.py

@@ -0,0 +1,190 @@
+"""Connection management commands."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+from rich.table import Table
+
+from entropy_data import config as cfg
+from entropy_data.output import OutputFormat, console, print_error, print_success
+
+connection_app = typer.Typer(no_args_is_help=True)
+
+
+def _mask_api_key(api_key: str) -> str:
+    """Mask an API key for display (first/last 4 visible)."""
+    if len(api_key) > 8:
+        return api_key[:4] + "..." + api_key[-4:]
+    return "****"
+
+
+def _fetch_vanity_url(api_key: str, host: str) -> str | None:
+    """Best-effort fetch of the org vanity URL via /api/organization/settings.
+
+    Returns None on any failure (older server, network error, etc.) so callers
+    can fall back to None instead of failing the whole `connection add`.
+    """
+    from entropy_data.client import REQUEST_TIMEOUT, EntropyDataClient
+
+    try:
+        client = EntropyDataClient(cfg.ConnectionConfig(api_key=api_key, host=host))
+        response = client.session.get(
+            f"{client.base_url}/api/organization/settings",
+            timeout=REQUEST_TIMEOUT,
+        )
+        if response.ok:
+            return response.json().get("vanityUrl")
+    except Exception:
+        return None
+    return None
+
+
+@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("Vanity URL")
+    table.add_column("API Key")
+    table.add_column("Default")
+    for conn in connections:
+        table.add_row(
+            conn["name"],
+            conn["host"],
+            conn.get("vanity_url") or "",
+            conn["api_key"],
+            "*" if conn["default"] else "",
+        )
+    console.print(table)
+
+
+@connection_app.command("get")
+def get_connection(
+    name: Annotated[
+        Optional[str],
+        typer.Argument(help="Connection name. Defaults to the default connection."),
+    ] = None,
+    show_api_key: Annotated[
+        bool,
+        typer.Option("--show-api-key", help="Print the API key in clear text (default: masked)."),
+    ] = False,
+    output: Annotated[
+        Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")
+    ] = None,
+) -> None:
+    """Get details of a named connection (use --show-api-key to reveal the key)."""
+    from entropy_data.cli import get_output_format
+
+    config = cfg.load_config()
+    connections = config.get("connections", {})
+
+    resolved_name = name or config.get("default_connection_name")
+    if resolved_name is None:
+        print_error(
+            "No connection specified and no default set. "
+            "Run: entropy-data connection set-default <name>"
+        )
+        raise typer.Exit(1)
+    if resolved_name not in connections:
+        print_error(f"Connection '{resolved_name}' not found.")
+        raise typer.Exit(1)
+
+    conn = connections[resolved_name]
+    api_key_value = conn.get("api_key", "")
+    displayed_key = api_key_value if show_api_key else _mask_api_key(api_key_value)
+    is_default = config.get("default_connection_name") == resolved_name
+
+    fmt = output or get_output_format()
+    if fmt == OutputFormat.json:
+        payload = {
+            "name": resolved_name,
+            "host": conn.get("host", cfg.DEFAULT_HOST),
+            "vanity_url": conn.get("vanity_url"),
+            "api_key": displayed_key,
+            "default": is_default,
+        }
+        console.print_json(json.dumps(payload))
+        return
+
+    table = Table(show_header=False)
+    table.add_column("Field", style="cyan")
+    table.add_column("Value")
+    table.add_row("name", resolved_name)
+    table.add_row("host", conn.get("host", cfg.DEFAULT_HOST))
+    if conn.get("vanity_url"):
+        table.add_row("vanity_url", conn["vanity_url"])
+    table.add_row("api_key", displayed_key)
+    if is_default:
+        table.add_row("default", "yes")
+    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.
+
+    The organization vanity URL is read from /api/organization/settings using the
+    provided API key. Fetching is best-effort: older servers or network errors
+    fall back to no vanity URL on the stored connection.
+    """
+    try:
+        vanity_url = _fetch_vanity_url(api_key, host)
+        if vanity_url:
+            console.print(f"Fetched organization vanity URL '[cyan]{vanity_url}[/cyan]' from {host}.")
+        cfg.add_connection(name, api_key, host, vanity_url=vanity_url)
+        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-0.3.1 → entropy_data-0.3.3}/src/entropy_data/commands/datacontracts.py

@@ -113,3 +113,12 @@ def delete_datacontract(
         print_success(f"Data contract '{id}' deleted.")
     except Exception as e:
         handle_error(e)
+
+
+from entropy_data.commands.gitconnections import make_gitconnection_app  # noqa: E402
+
+datacontracts_app.add_typer(
+    make_gitconnection_app(RESOURCE_PATH, "Data contract"),
+    name="gitconnection",
+    help="Manage the git connection.",
+)

{entropy_data-0.3.1 → entropy_data-0.3.3}/src/entropy_data/commands/dataproducts.py

@@ -91,3 +91,12 @@ def delete_dataproduct(
         print_success(f"Data product '{id}' deleted.")
     except Exception as e:
         handle_error(e)
+
+
+from entropy_data.commands.gitconnections import make_gitconnection_app  # noqa: E402
+
+dataproducts_app.add_typer(
+    make_gitconnection_app(RESOURCE_PATH, "Data product"),
+    name="gitconnection",
+    help="Manage the git connection.",
+)

entropy_data-0.3.3/src/entropy_data/commands/gitconnections.py

@@ -0,0 +1,183 @@
+"""Git connection subcommands. Used as a sub-typer of dataproducts and datacontracts."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+
+from entropy_data.output import OutputFormat, print_link, print_success
+
+GIT_CONNECTION_TYPES = ("github", "gitlab", "bitbucket", "azuredevops")
+
+
+def make_gitconnection_app(resource_path: str, resource_label: str) -> typer.Typer:
+    """Build a Typer app exposing /api/{resource_path}/{id}/gitconnection operations.
+
+    `resource_path` is the URL segment ("dataproducts" or "datacontracts").
+    `resource_label` is the human-readable name shown in success messages.
+    """
+
+    app = typer.Typer(no_args_is_help=True)
+
+    @app.command("get")
+    def get_(
+        id: Annotated[str, typer.Argument(help=f"{resource_label} ID.")],
+        output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+    ) -> None:
+        """Get the git connection."""
+        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_gitconnection(resource_path, id)
+            if fmt == OutputFormat.json:
+                print(json.dumps(data, indent=2))
+            else:
+                print(json.dumps(data, indent=2))
+        except Exception as e:
+            handle_error(e)
+
+    @app.command("put")
+    def put_(
+        id: Annotated[str, typer.Argument(help=f"{resource_label} ID.")],
+        repository_url: Annotated[str, typer.Option("--repository-url", help="URL of the Git repository.")] = ...,
+        repository_path: Annotated[
+            str, typer.Option("--repository-path", help="Path to the YAML file in the repository.")
+        ] = ...,
+        repository_branch: Annotated[
+            Optional[str],
+            typer.Option("--repository-branch", help="Branch to use. Defaults to 'main'."),
+        ] = None,
+        git_connection_type: Annotated[
+            Optional[str],
+            typer.Option(
+                "--git-connection-type",
+                help=f"Git provider type. One of: {', '.join(GIT_CONNECTION_TYPES)}.",
+            ),
+        ] = None,
+        host: Annotated[
+            Optional[str],
+            typer.Option("--host", help="Host of a self-hosted git provider. Omit for SaaS."),
+        ] = None,
+        git_credential_external_id: Annotated[
+            Optional[str],
+            typer.Option(
+                "--git-credential-external-id",
+                help="External ID of a stored git credential to use.",
+            ),
+        ] = None,
+    ) -> None:
+        """Create or update the git connection."""
+        from entropy_data.cli import get_client, handle_error
+
+        if git_connection_type and git_connection_type not in GIT_CONNECTION_TYPES:
+            raise typer.BadParameter(
+                f"Must be one of: {', '.join(GIT_CONNECTION_TYPES)}",
+                param_hint="--git-connection-type",
+            )
+        if not git_connection_type and not git_credential_external_id:
+            raise typer.BadParameter(
+                "At least one of --git-connection-type or --git-credential-external-id must be provided.",
+            )
+
+        body: dict = {"repositoryUrl": repository_url, "repositoryPath": repository_path}
+        if repository_branch:
+            body["repositoryBranch"] = repository_branch
+        if git_connection_type:
+            body["gitConnectionType"] = git_connection_type
+        if host:
+            body["host"] = host
+        if git_credential_external_id:
+            body["gitCredentialExternalId"] = git_credential_external_id
+
+        try:
+            client = get_client()
+            data = client.put_gitconnection(resource_path, id, body)
+            print_success(f"Git connection saved for {resource_label.lower()} '{id}'.")
+            print_link(data.get("webLink"))
+        except Exception as e:
+            handle_error(e)
+
+    @app.command("delete")
+    def delete_(
+        id: Annotated[str, typer.Argument(help=f"{resource_label} ID.")],
+    ) -> None:
+        """Delete the git connection."""
+        from entropy_data.cli import get_client, handle_error
+
+        try:
+            client = get_client()
+            client.delete_gitconnection(resource_path, id)
+            print_success(f"Git connection deleted for {resource_label.lower()} '{id}'.")
+        except Exception as e:
+            handle_error(e)
+
+    @app.command("pull")
+    def pull_(
+        id: Annotated[str, typer.Argument(help=f"{resource_label} ID.")],
+    ) -> None:
+        """Pull the file from Git into Entropy Data."""
+        from entropy_data.cli import get_client, handle_error
+
+        try:
+            client = get_client()
+            data = client.gitconnection_action(resource_path, id, "pull")
+            print_success(f"{resource_label} '{id}' pulled from Git.")
+            print_link(data.get("webLink"))
+        except Exception as e:
+            handle_error(e)
+
+    @app.command("push")
+    def push_(
+        id: Annotated[str, typer.Argument(help=f"{resource_label} ID.")],
+        commit_message: Annotated[
+            Optional[str], typer.Option("--commit-message", help="Custom commit message.")
+        ] = None,
+    ) -> None:
+        """Push the current Entropy Data file to Git."""
+        from entropy_data.cli import get_client, handle_error
+
+        body: dict | None = {"commitMessage": commit_message} if commit_message else None
+        try:
+            client = get_client()
+            data = client.gitconnection_action(resource_path, id, "push", body)
+            print_success(f"{resource_label} '{id}' pushed to Git.")
+            print_link(data.get("webLink"))
+        except Exception as e:
+            handle_error(e)
+
+    @app.command("push-pr")
+    def push_pr(
+        id: Annotated[str, typer.Argument(help=f"{resource_label} ID.")],
+        commit_message: Annotated[
+            Optional[str], typer.Option("--commit-message", help="Custom commit message.")
+        ] = None,
+        branch_name: Annotated[Optional[str], typer.Option("--branch-name", help="Name of the new branch.")] = None,
+        title: Annotated[Optional[str], typer.Option("--title", help="Pull request title.")] = None,
+        comment: Annotated[
+            Optional[str],
+            typer.Option("--comment", help="Pull request description / comment."),
+        ] = None,
+    ) -> None:
+        """Push the current Entropy Data file to Git as a pull/merge request."""
+        from entropy_data.cli import get_client, handle_error
+
+        body: dict = {}
+        if commit_message:
+            body["commitMessage"] = commit_message
+        if branch_name:
+            body["branchName"] = branch_name
+        if title:
+            body["title"] = title
+        if comment:
+            body["comment"] = comment
+        try:
+            client = get_client()
+            data = client.gitconnection_action(resource_path, id, "push-pr", body or None)
+            print_success(f"{resource_label} '{id}' pushed to Git as pull request.")
+            print_link(data.get("webLink"))
+        except Exception as e:
+            handle_error(e)
+
+    return app

entropy_data-0.3.3/src/entropy_data/commands/organization.py

@@ -0,0 +1,51 @@
+"""Organization commands."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+from rich.table import Table
+
+from entropy_data.output import OutputFormat, console
+
+organization_app = typer.Typer(no_args_is_help=True)
+
+
+@organization_app.command("get")
+def get_organization(
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get settings of the organization the current API key is bound to."""
+    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()
+        response = client.session.get(
+            f"{client.base_url}/api/organization/settings",
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+        data = response.json()
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(data))
+            return
+
+        table = Table(show_header=False)
+        table.add_column("Field", style="cyan")
+        table.add_column("Value")
+        for key in ("vanityUrl", "host", "fullName", "logoUrl", "supportEmailAddress", "brand", "plan"):
+            value = data.get(key)
+            if value:
+                table.add_row(key, str(value))
+        sso = data.get("sso")
+        if sso:
+            table.add_row("sso.issuer", sso.get("issuer", ""))
+            if sso.get("tenant"):
+                table.add_row("sso.tenant", sso["tenant"])
+            if sso.get("autoJoin") is not None:
+                table.add_row("sso.autoJoin", str(sso["autoJoin"]))
+        console.print(table)
+    except Exception as e:
+        handle_error(e)

{entropy_data-0.3.1 → entropy_data-0.3.3}/src/entropy_data/config.py

@@ -21,6 +21,7 @@ class ConfigurationError(Exception):
 class ConnectionConfig:
     api_key: str
     host: str = DEFAULT_HOST
+    vanity_url: str | None = None
 
 
 def load_config() -> dict:
@@ -47,6 +48,7 @@ def resolve_connection(
     """Resolve connection with precedence: CLI options > env vars > config file."""
     api_key = cli_api_key
     host = cli_host
+    vanity_url: str | None = None
 
     # Layer 2: environment variables
     if api_key is None:
@@ -68,6 +70,7 @@ def resolve_connection(
                 api_key = conn.get("api_key")
             if host is None:
                 host = conn.get("host")
+            vanity_url = conn.get("vanity_url")
 
     # Default host
     if host is None:
@@ -78,17 +81,20 @@ def resolve_connection(
             "No API key found. Set ENTROPY_DATA_API_KEY, use --api-key, or run: entropy-data connection add <name>"
         )
 
-    return ConnectionConfig(api_key=api_key, host=host)
+    return ConnectionConfig(api_key=api_key, host=host, vanity_url=vanity_url)
 
 
-def add_connection(name: str, api_key: str, host: str = DEFAULT_HOST) -> None:
+def add_connection(name: str, api_key: str, host: str = DEFAULT_HOST, vanity_url: str | None = None) -> None:
     """Add or update a named connection."""
     if not name or not name.strip():
         raise ConfigurationError("Connection name must not be empty.")
     config = load_config()
     if "connections" not in config:
         config["connections"] = {}
-    config["connections"][name] = {"api_key": api_key, "host": host}
+    entry: dict = {"api_key": api_key, "host": host}
+    if vanity_url:
+        entry["vanity_url"] = vanity_url
+    config["connections"][name] = entry
     # Set as default if it's the first connection
     if "default_connection_name" not in config:
         config["default_connection_name"] = name
@@ -134,6 +140,7 @@ def list_connections() -> list[dict]:
             {
                 "name": name,
                 "host": conn.get("host", DEFAULT_HOST),
+                "vanity_url": conn.get("vanity_url"),
                 "api_key": masked,
                 "default": name == default_name,
             }