datajunction 0.0.243__tar.gz → 0.0.245__tar.gz

{datajunction-0.0.243 → datajunction-0.0.245}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: datajunction
-Version: 0.0.243
+Version: 0.0.245
 Summary: DataJunction client library for connecting to a DataJunction server
 Project-URL: repository, https://github.com/DataJunction/dj
 Author-email: DataJunction Authors <yian.shang@gmail.com>

{datajunction-0.0.243 → datajunction-0.0.245}/datajunction/__about__.py

@@ -2,4 +2,4 @@
 Version for Hatch
 """
 
-__version__ = "0.0.243"
+__version__ = "0.0.245"

{datajunction-0.0.243 → datajunction-0.0.245}/datajunction/_internal.py

@@ -4,6 +4,7 @@
 import logging
 import os
 import platform
+import time
 from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, TypedDict, Union
 from urllib.parse import urljoin
@@ -235,13 +236,29 @@ class DJClient:
     def get_deployment_impact(self, deployment_spec: dict[str, Any]):
         """
         Get impact analysis for a deployment spec without deploying.
+
+        The endpoint is asynchronous: it submits a dry-run deployment and
+        returns immediately, so this polls ``check_deployment`` until the
+        deployment reaches a terminal status (success/failed).
         """
         response = self._session.post(
             "/deployments/impact",
             json=deployment_spec,
+            headers={"Prefer": "respond-async"},
             timeout=self._timeout,
         )
-        return response.json()
+        deployment_data = response.json()
+        deployment_uuid = deployment_data["uuid"]
+
+        timeout = time.time() + 300  # 5 minutes
+        while deployment_data.get("status") not in ("failed", "success"):
+            time.sleep(1)
+            deployment_data = self.check_deployment(deployment_uuid)
+            if time.time() > timeout:
+                raise DJClientException(
+                    "Deployment impact analysis timed out after 5 minutes",
+                )
+        return deployment_data
 
     @staticmethod
     def _primary_key_from_columns(columns) -> list[str]:

{datajunction-0.0.243 → datajunction-0.0.245}/datajunction/deployment.py

@@ -299,7 +299,7 @@ class DeploymentService:
         deployment = DeploymentInfo.from_dict(data)
         if display:
             print_results(
-                "dry_run",
+                data.get("uuid", "dry_run"),
                 deployment,
                 console,
                 verbose=verbose,

{datajunction-0.0.243 → datajunction-0.0.245}/datajunction/models.py

@@ -406,6 +406,9 @@ class DeploymentResult:
     deploy_type: str = ""
     change_tier: Literal["none", "minor", "major"] | None = None
     semantic_fingerprint: SemanticFingerprintValue | None = None
+    # True when the node was re-deployed only to retry a pre-existing failure.
+    # None on responses from servers that predate the field.
+    revalidation_only: bool | None = None
 
     @classmethod
     def from_dict(cls, d: dict) -> DeploymentResult:
@@ -419,6 +422,7 @@ class DeploymentResult:
             deploy_type=d.get("deploy_type", ""),
             change_tier=d.get("change_tier"),
             semantic_fingerprint=_parse_semantic_fingerprint(fingerprint),
+            revalidation_only=d.get("revalidation_only"),
         )
 
 

{datajunction-0.0.243 → datajunction-0.0.245}/tests/test__internal.py

@@ -38,6 +38,82 @@ class TestDJClient:  # pylint: disable=too-many-public-methods, protected-access
             json={"email": "foo", "username": "bar", "password": "baz"},
         )
 
+    def test_get_deployment_impact_polls_until_terminal(self, client):
+        """
+        `get_deployment_impact()` submits the dry-run with the required
+        `Prefer: respond-async` header, then polls `check_deployment()`
+        until the deployment reaches a terminal status.
+        """
+        client._session.post = MagicMock(
+            return_value=MagicMock(
+                json=MagicMock(
+                    return_value={
+                        "uuid": "abc-123",
+                        "namespace": "test.ns",
+                        "status": "pending",
+                    },
+                ),
+            ),
+        )
+        client.check_deployment = MagicMock(
+            side_effect=[
+                {"uuid": "abc-123", "namespace": "test.ns", "status": "running"},
+                {
+                    "uuid": "abc-123",
+                    "namespace": "test.ns",
+                    "status": "success",
+                    "results": [],
+                    "downstream_impacts": [],
+                },
+            ],
+        )
+
+        with patch("datajunction._internal.time.sleep"):
+            result = client.get_deployment_impact({"namespace": "test.ns", "nodes": []})
+
+        assert client._session.post.call_args == call(
+            "/deployments/impact",
+            json={"namespace": "test.ns", "nodes": []},
+            headers={"Prefer": "respond-async"},
+            timeout=client._timeout,
+        )
+        assert client.check_deployment.call_count == 2
+        assert result["status"] == "success"
+
+    def test_get_deployment_impact_times_out(self, client):
+        """
+        `get_deployment_impact()` raises if the deployment never reaches a
+        terminal status within the timeout window.
+        """
+        client._session.post = MagicMock(
+            return_value=MagicMock(
+                json=MagicMock(
+                    return_value={
+                        "uuid": "abc-123",
+                        "namespace": "test.ns",
+                        "status": "pending",
+                    },
+                ),
+            ),
+        )
+        client.check_deployment = MagicMock(
+            return_value={
+                "uuid": "abc-123",
+                "namespace": "test.ns",
+                "status": "running",
+            },
+        )
+
+        with (
+            patch("datajunction._internal.time.sleep"),
+            patch(
+                "datajunction._internal.time.time",
+                side_effect=[0, 0, 400],
+            ),
+        ):
+            with pytest.raises(DJClientException, match="timed out"):
+                client.get_deployment_impact({"namespace": "test.ns", "nodes": []})
+
     def test_basic_login(self, client):
         """
         Check that `client.basic_login()` works as expected.

{datajunction-0.0.243 → datajunction-0.0.245}/tests/test_cli.py

@@ -1221,8 +1221,8 @@ class TestImpactAnalysis:
                 main(builder_client=builder_client)
 
         captured = capsys.readouterr()
-        # Panel title includes "dry_run" and namespace
-        assert "dry_run" in captured.out
+        # Header shows the "dry run" mode
+        assert "dry run" in captured.out
 
     def test_deploy_dryrun_json_format(
         self,
@@ -1272,7 +1272,7 @@ class TestImpactAnalysis:
                 main(builder_client=builder_client)
 
         captured = capsys.readouterr()
-        assert "dry_run" in captured.out
+        assert "dry run" in captured.out
 
     def test_push_dryrun_json_format(
         self,
@@ -1329,7 +1329,7 @@ class TestImpactAnalysis:
                 main(builder_client=builder_client)
 
         captured = capsys.readouterr()
-        assert "dry_run" in captured.out
+        assert "dry run" in captured.out
 
     def test_dryrun_shows_downstream_impacts_in_panel(self, capsys):
         """Downstream impacts appear inside the results panel when predicted_status is invalid."""

{datajunction-0.0.243 → datajunction-0.0.245}/tests/test_deploy.py

@@ -1418,6 +1418,7 @@ class TestGetImpact:
                         "version": 1,
                         "digest": "a" * 64,
                     },
+                    "revalidation_only": True,
                 },
             ],
             "downstream_impacts": [
@@ -1448,6 +1449,7 @@ class TestGetImpact:
         parsed = DeploymentInfo.from_dict(result)
         assert parsed.results[0].deploy_type == "node"
         assert parsed.results[0].change_tier == "none"
+        assert parsed.results[0].revalidation_only is True
         assert parsed.results[0].semantic_fingerprint == SemanticFingerprint(
             digest="a" * 64,
         )