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

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

@@ -1,5 +1,9 @@
 # Changelog
 
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entropy-data
-Version: 0.3.1
+Version: 0.3.2
 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.2}/pyproject.toml

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

{entropy_data-0.3.1 → entropy_data-0.3.2}/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.1 → entropy_data-0.3.2}/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.2}/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.2/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.2/tests/commands/test_gitconnections.py

@@ -0,0 +1,255 @@
+"""Tests for git connection subcommands on dataproducts and datacontracts."""
+
+import json
+
+import pytest
+import responses
+from typer.testing import CliRunner
+
+import entropy_data.config as cfg
+from entropy_data.cli import app
+
+runner = CliRunner()
+BASE_URL = "https://api.entropy-data.com"
+
+
+CONNECTION_RESPONSE = {
+    "gitConnectionId": "11111111-1111-1111-1111-111111111111",
+    "gitConnectionType": "github",
+    "repositoryUrl": "https://github.com/acme/contracts",
+    "repositoryBranch": "main",
+    "repositoryPath": "contracts/orders.yaml",
+    "syncStatus": "UP_TO_DATE",
+    "webLink": "https://github.com/acme/contracts/blob/main/contracts/orders.yaml",
+    "lastHash": "abc123",
+}
+
+
+@pytest.fixture
+def configured(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_get(configured, resource):
+    responses.add(
+        responses.GET,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection",
+        json=CONNECTION_RESPONSE,
+        status=200,
+    )
+    result = runner.invoke(app, [resource, "gitconnection", "get", "orders"])
+    assert result.exit_code == 0
+    assert "github.com/acme/contracts" in result.output
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_put(configured, resource):
+    responses.add(
+        responses.PUT,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection",
+        json=CONNECTION_RESPONSE,
+        status=200,
+    )
+    result = runner.invoke(
+        app,
+        [
+            resource,
+            "gitconnection",
+            "put",
+            "orders",
+            "--repository-url",
+            "https://github.com/acme/contracts",
+            "--repository-path",
+            "contracts/orders.yaml",
+            "--git-connection-type",
+            "github",
+        ],
+    )
+    assert result.exit_code == 0
+    assert "saved" in result.output
+    sent = json.loads(responses.calls[-1].request.body)
+    assert sent["repositoryUrl"] == "https://github.com/acme/contracts"
+    assert sent["repositoryPath"] == "contracts/orders.yaml"
+    assert sent["gitConnectionType"] == "github"
+
+
+def test_gitconnection_put_requires_credential_or_type(configured):
+    result = runner.invoke(
+        app,
+        [
+            "dataproducts",
+            "gitconnection",
+            "put",
+            "orders",
+            "--repository-url",
+            "https://github.com/acme/contracts",
+            "--repository-path",
+            "contracts/orders.yaml",
+        ],
+    )
+    assert result.exit_code != 0
+
+
+def test_gitconnection_put_rejects_invalid_type(configured):
+    result = runner.invoke(
+        app,
+        [
+            "dataproducts",
+            "gitconnection",
+            "put",
+            "orders",
+            "--repository-url",
+            "https://github.com/acme/contracts",
+            "--repository-path",
+            "contracts/orders.yaml",
+            "--git-connection-type",
+            "svn",
+        ],
+    )
+    assert result.exit_code != 0
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_put_with_credential_external_id(configured, resource):
+    responses.add(
+        responses.PUT,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection",
+        json=CONNECTION_RESPONSE,
+        status=200,
+    )
+    result = runner.invoke(
+        app,
+        [
+            resource,
+            "gitconnection",
+            "put",
+            "orders",
+            "--repository-url",
+            "https://github.com/acme/contracts",
+            "--repository-path",
+            "contracts/orders.yaml",
+            "--git-credential-external-id",
+            "acme-ci",
+        ],
+    )
+    assert result.exit_code == 0
+    sent = json.loads(responses.calls[-1].request.body)
+    assert sent["gitCredentialExternalId"] == "acme-ci"
+    assert "gitConnectionType" not in sent
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_delete(configured, resource):
+    responses.add(
+        responses.DELETE,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection",
+        status=200,
+    )
+    result = runner.invoke(app, [resource, "gitconnection", "delete", "orders"])
+    assert result.exit_code == 0
+    assert "deleted" in result.output
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_pull(configured, resource):
+    responses.add(
+        responses.POST,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection/pull",
+        json=CONNECTION_RESPONSE,
+        status=200,
+    )
+    result = runner.invoke(app, [resource, "gitconnection", "pull", "orders"])
+    assert result.exit_code == 0
+    assert "pulled" in result.output
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_push(configured, resource):
+    responses.add(
+        responses.POST,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection/push",
+        json=CONNECTION_RESPONSE,
+        status=200,
+    )
+    result = runner.invoke(
+        app,
+        [resource, "gitconnection", "push", "orders", "--commit-message", "update orders"],
+    )
+    assert result.exit_code == 0
+    assert "pushed" in result.output
+    sent = json.loads(responses.calls[-1].request.body)
+    assert sent["commitMessage"] == "update orders"
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_push_no_body(configured, resource):
+    responses.add(
+        responses.POST,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection/push",
+        json=CONNECTION_RESPONSE,
+        status=200,
+    )
+    result = runner.invoke(app, [resource, "gitconnection", "push", "orders"])
+    assert result.exit_code == 0
+    assert responses.calls[-1].request.body in (None, b"null", "null")
+
+
+@pytest.mark.parametrize("resource", ["dataproducts", "datacontracts"])
+@responses.activate
+def test_gitconnection_push_pr(configured, resource):
+    responses.add(
+        responses.POST,
+        f"{BASE_URL}/api/{resource}/orders/gitconnection/push-pr",
+        json=CONNECTION_RESPONSE,
+        status=200,
+    )
+    result = runner.invoke(
+        app,
+        [
+            resource,
+            "gitconnection",
+            "push-pr",
+            "orders",
+            "--branch-name",
+            "feat/orders",
+            "--title",
+            "Update orders",
+            "--commit-message",
+            "update orders",
+            "--comment",
+            "ci push",
+        ],
+    )
+    assert result.exit_code == 0
+    sent = json.loads(responses.calls[-1].request.body)
+    assert sent["branchName"] == "feat/orders"
+    assert sent["title"] == "Update orders"
+    assert sent["commitMessage"] == "update orders"
+    assert sent["comment"] == "ci push"
+
+
+def test_gitconnection_help_under_dataproducts():
+    result = runner.invoke(app, ["dataproducts", "gitconnection", "--help"])
+    assert result.exit_code == 0
+    assert "get" in result.output
+    assert "put" in result.output
+    assert "delete" in result.output
+    assert "pull" in result.output
+    assert "push" in result.output
+    assert "push-pr" in result.output
+
+
+def test_gitconnection_help_under_datacontracts():
+    result = runner.invoke(app, ["datacontracts", "gitconnection", "--help"])
+    assert result.exit_code == 0
+    assert "get" in result.output
+    assert "push-pr" in result.output