datajunction 0.0.185__tar.gz → 0.0.186__tar.gz

{datajunction-0.0.185 → datajunction-0.0.186}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datajunction
-Version: 0.0.185
+Version: 0.0.186
 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.185 → datajunction-0.0.186}/datajunction/__about__.py

@@ -2,4 +2,4 @@
 Version for Hatch
 """
 
-__version__ = "0.0.185"
+__version__ = "0.0.186"

{datajunction-0.0.185 → datajunction-0.0.186}/datajunction/_internal.py

@@ -666,13 +666,6 @@ class DJClient:
         response = self._session.post(f"/nodes/{node_name}/refresh/")
         return response.json()
 
-    def _export_namespace(self, namespace):
-        """
-        Export an array of definitions contained within a namespace
-        """
-        response = self._session.get(f"/namespaces/{namespace}/export/")
-        return response.json()
-
     def _export_namespace_yaml_zip(
         self,
         namespace: str,

{datajunction-0.0.185 → datajunction-0.0.186}/datajunction/builder.py

@@ -4,7 +4,7 @@
 import re
 from dataclasses import fields
 from http import HTTPStatus
-from typing import TYPE_CHECKING, Dict, List, Optional
+from typing import Dict, List, Optional
 
 from datajunction import models
 from datajunction.client import DJClient
@@ -27,9 +27,6 @@ from datajunction.nodes import (
 )
 from datajunction.tags import Tag
 
-if TYPE_CHECKING:
-    from datajunction.compile import ColumnYAML  # pragma: no cover
-
 
 class DJBuilder(DJClient):  # pylint: disable=too-many-public-methods
     """
@@ -409,7 +406,7 @@ class DJBuilder(DJClient):  # pylint: disable=too-many-public-methods
         table: Optional[str] = None,
         display_name: Optional[str] = None,
         description: Optional[str] = None,
-        columns: Optional[List["ColumnYAML"]] = None,
+        columns: Optional[List["models.ColumnYAML"]] = None,
         primary_key: Optional[List[str]] = None,
         tags: Optional[List[str]] = None,
         mode: Optional[models.NodeMode] = models.NodeMode.PUBLISHED,

datajunction-0.0.186/datajunction/compile.py

@@ -0,0 +1,36 @@
+"""Deprecated: client-side compilation has moved server-side.
+
+Client-side YAML compilation (the old ``Project`` / ``CompiledProject`` flow)
+has been removed. YAML deployment is now handled entirely server-side: use
+:class:`datajunction.DeploymentService` (or the ``dj push`` / ``dj pull`` CLI),
+which reconstructs a deployment spec from local YAML files and POSTs it to the
+server's ``/deployments`` orchestrator.
+"""
+
+from datajunction.exceptions import DJClientException
+
+_MESSAGE = (
+    "datajunction.Project / client-side YAML compilation has been removed. "
+    "Deployment is now handled server-side — use datajunction.DeploymentService "
+    "(or the `dj push` CLI)."
+)
+
+
+class Project:  # pylint: disable=too-few-public-methods
+    """
+    Deprecated. Client-side project compilation has been removed; deployment is
+    now handled server-side via :class:`datajunction.DeploymentService`.
+    """
+
+    def __init__(self, *args, **kwargs):
+        raise DJClientException(_MESSAGE)
+
+    @classmethod
+    def load(cls, *args, **kwargs):
+        """Deprecated. Use ``datajunction.DeploymentService`` instead."""
+        raise DJClientException(_MESSAGE)
+
+    @classmethod
+    def load_current(cls, *args, **kwargs):
+        """Deprecated. Use ``datajunction.DeploymentService`` instead."""
+        raise DJClientException(_MESSAGE)

{datajunction-0.0.185 → datajunction-0.0.186}/datajunction/models.py

@@ -20,6 +20,19 @@ class Engine(SerializableMixin):
     version: Optional[str]
 
 
+@dataclass
+class ColumnYAML(SerializableMixin):
+    """
+    Represents a column
+    """
+
+    name: str
+    type: str
+    display_name: Optional[str] = None
+    description: Optional[str] = None
+    attributes: Optional[List[str]] = None
+
+
 class MetricDirection(str, enum.Enum):
     """
     The direction of the metric that's considered good, i.e., higher is better

{datajunction-0.0.185 → datajunction-0.0.186}/datajunction/seed/init_system_nodes.py

@@ -1,6 +1,7 @@
 import logging
+from pathlib import Path
 
-from datajunction import DJBuilder, Project
+from datajunction import DJBuilder, DeploymentService
 from datajunction.exceptions import DJClientException
 from datajunction._internal import RequestsSessionWithEndpoint
 
@@ -35,14 +36,14 @@ for table in tables:
             logger.error("Error registering tables: %s", exc)
 logger.info("Finished registering DJ system metadata tables")
 
-logger.info("Loading DJ system nodes...")
-project = Project.load("nodes")
-logger.info("Finished loading DJ system nodes.")
-
-logger.info("Compiling DJ system nodes...")
-compiled_project = project.compile()
-logger.info("Finished compiling DJ system nodes.")
-
 logger.info("Deploying DJ system nodes...")
-compiled_project.deploy(client=dj)
+# Deployment is handled server-side: DeploymentService reconstructs a deployment
+# spec from the YAML files under `nodes/` and POSTs it to the `/deployments`
+# orchestrator. The explicit namespace (matching the project's `prefix:` in
+# dj.yaml) marks this as the bootstrap/system-seed case, which skips git config.
+# Resolve the seed dir relative to this file so the script works regardless of
+# the caller's working directory.
+nodes_dir = Path(__file__).parent / "nodes"
+service = DeploymentService(client=dj)
+service.push(nodes_dir, namespace="system.dj")
 logger.info("Finished deploying DJ system nodes.")

{datajunction-0.0.185 → datajunction-0.0.186}/datajunction/tags.py

@@ -69,7 +69,7 @@ class Tag(ClientEntity):
                 raise DJClientException(
                     f"Error creating new tag `{self.name}`: {response.text}",
                 )
-            response_json = response.json()
+            response_json = response.json()  # pragma: no cover
         return response_json
 
     def refresh(self):

{datajunction-0.0.185 → datajunction-0.0.186}/tests/test__internal.py

@@ -122,3 +122,38 @@ class TestDJClient:  # pylint: disable=too-many-public-methods, protected-access
             json={},
             timeout=client._timeout,
         )
+
+    def test__link_dimension_to_node_with_column(self, client):
+        """
+        When a `dimension_column` is supplied, it is included in the request params.
+        """
+        client._session.post = MagicMock(
+            return_value=MagicMock(json=MagicMock(return_value={"ok": True})),
+        )
+        result = client._link_dimension_to_node(
+            "my.node",
+            "col",
+            "my.dimension",
+            "dim_col",
+        )
+        assert result == {"ok": True}
+        client._session.post.assert_called_once_with(
+            "/nodes/my.node/columns/col/",
+            timeout=client._timeout,
+            params={"dimension": "my.dimension", "dimension_column": "dim_col"},
+        )
+
+    def test__link_dimension_to_node_without_column(self, client):
+        """
+        When no `dimension_column` is supplied, only the dimension param is sent.
+        """
+        client._session.post = MagicMock(
+            return_value=MagicMock(json=MagicMock(return_value={"ok": True})),
+        )
+        result = client._link_dimension_to_node("my.node", "col", "my.dimension", None)
+        assert result == {"ok": True}
+        client._session.post.assert_called_once_with(
+            "/nodes/my.node/columns/col/",
+            timeout=client._timeout,
+            params={"dimension": "my.dimension"},
+        )

{datajunction-0.0.185 → datajunction-0.0.186}/tests/test_base.py

@@ -4,12 +4,70 @@ Test serializable mixin for dict to dataclass conversion
 
 from dataclasses import dataclass
 from datetime import datetime
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from datajunction._base import SerializableMixin
 from datajunction._internal import DJClient
 
 
+@dataclass
+class CandidateA(SerializableMixin):
+    """A union member that only accepts items discriminated by ``kind == 'a'``."""
+
+    kind: str
+    a_value: str
+
+    @classmethod
+    def from_dict(cls, dj_client, data):
+        if data.get("kind") != "a":
+            raise TypeError("not a CandidateA")
+        return super().from_dict(dj_client, data)
+
+
+@dataclass
+class CandidateB(SerializableMixin):
+    """A union member that only accepts items discriminated by ``kind == 'b'``."""
+
+    kind: str
+    b_value: str
+
+    @classmethod
+    def from_dict(cls, dj_client, data):
+        if data.get("kind") != "b":
+            raise TypeError("not a CandidateB")
+        return super().from_dict(dj_client, data)
+
+
+@dataclass
+class UnionListHolder(SerializableMixin):
+    """Holds a list whose inner type is a discriminated union of dataclasses."""
+
+    items: List[Union[CandidateA, CandidateB]]
+
+
+def test_serialize_union_list_fallback():
+    """
+    When a list's inner type is a union of candidates, each item is tried
+    against every candidate; a candidate that raises TypeError/AttributeError
+    is skipped in favor of the next one that accepts the item.
+    """
+    holder = UnionListHolder.from_dict(
+        dj_client=None,
+        data={
+            "items": [
+                {"kind": "a", "a_value": "x"},
+                {"kind": "b", "b_value": "y"},
+            ],
+        },
+    )
+    assert holder == UnionListHolder(
+        items=[
+            CandidateA(kind="a", a_value="x"),
+            CandidateB(kind="b", b_value="y"),
+        ],
+    )
+
+
 @dataclass
 class DataClassSimple(SerializableMixin):
     """Simple dataclass"""

datajunction-0.0.186/tests/test_compile.py

@@ -0,0 +1,29 @@
+"""
+Tests for the deprecated client-side compilation module.
+
+Client-side YAML compilation has moved server-side (see DeploymentService).
+The ``Project`` symbol is kept as a deprecation shim that errors when used.
+"""
+
+import pytest
+
+from datajunction import Project
+from datajunction.exceptions import DJClientException
+
+
+def test_project_instantiation_raises():
+    """Instantiating the deprecated Project raises a clear error."""
+    with pytest.raises(DJClientException, match="handled server-side"):
+        Project()
+
+
+def test_project_load_raises():
+    """Project.load is deprecated and raises."""
+    with pytest.raises(DJClientException, match="handled server-side"):
+        Project.load("nodes")
+
+
+def test_project_load_current_raises():
+    """Project.load_current is deprecated and raises."""
+    with pytest.raises(DJClientException, match="handled server-side"):
+        Project.load_current()

{datajunction-0.0.185 → datajunction-0.0.186}/tests/test_deploy.py

@@ -601,6 +601,47 @@ def test_reconstruct_deployment_spec(tmp_path):
     assert spec["nodes"][0]["name"] == "foo.bar"
 
 
+def test_system_seed_matches_server_deployment_spec():
+    """
+    The bundled system-node seed is deployed at bootstrap by
+    ``init_system_nodes`` via ``DeploymentService.push`` -> the server
+    ``/deployments`` orchestrator. This guards that the seed YAML stays in the
+    server's ``DeploymentSpec`` format: it reconstructs the spec exactly as
+    ``push`` does, then validates it against the server pydantic model (the same
+    gate the orchestrator applies). Catches field-name drift between the seed
+    and the deployment schema without needing a live deploy.
+    """
+    # Imported here (not at module top) so the conftest server bootstrap has
+    # resolved the server package's import order first.
+    from datajunction_server.models.deployment import (
+        DeploymentSpec,
+        DimensionJoinLinkSpec,
+    )
+
+    seed_dir = Path(__file__).parent.parent / "datajunction" / "seed" / "nodes"
+    svc = DeploymentService(MagicMock())
+    spec_dict, warnings = svc._reconstruct_deployment_spec(seed_dir)
+    spec_dict["namespace"] = "system.dj"
+
+    # No filename/node-name mismatches in the bundled seed.
+    assert warnings == []
+
+    # Parses cleanly into the server's DeploymentSpec (raises on any drift).
+    spec = DeploymentSpec(**spec_dict)
+    assert spec.namespace == "system.dj"
+    assert len(spec.nodes) == len(spec_dict["nodes"])
+
+    # Dimension links resolve to the typed join subclass via the `type`
+    # discriminator (the seed uses `type: join`).
+    linked = [n for n in spec.nodes if getattr(n, "dimension_links", None)]
+    assert linked, "expected seed nodes with dimension links"
+    assert all(
+        isinstance(link, DimensionJoinLinkSpec)
+        for node in linked
+        for link in node.dimension_links
+    )
+
+
 @pytest.mark.timeout(2)
 def test_push_waits_until_success(monkeypatch, tmp_path):
     # Create a fake project structure so _reconstruct_deployment_spec returns something

{datajunction-0.0.185 → datajunction-0.0.186}/tests/test_integration.py

@@ -9,7 +9,7 @@ from time import sleep
 import pytest
 
 from datajunction import DJBuilder, models
-from datajunction.compile import ColumnYAML
+from datajunction.models import ColumnYAML
 from datajunction.exceptions import DJClientException
 
 _logger = logging.getLogger(__name__)

datajunction-0.0.186/tests/test_models.py

@@ -0,0 +1,47 @@
+"""Tests for models."""
+
+from datajunction.models import (
+    MetricDirection,
+    MetricMetadata,
+    MetricUnit,
+    QueryState,
+)
+
+
+def test_metric_metadata_from_dict():
+    """
+    Check that MetricMetadata deserializes a server payload, normalizing the
+    direction/unit casing and reading the nested unit name.
+    """
+    metadata = MetricMetadata.from_dict(
+        dj_client=None,
+        data={
+            "direction": "HIGHER_IS_BETTER",
+            "unit": {"name": "DOLLAR"},
+            "significant_digits": 2,
+            "min_decimal_exponent": -3,
+            "max_decimal_exponent": 5,
+        },
+    )
+    assert metadata == MetricMetadata(
+        direction=MetricDirection.HIGHER_IS_BETTER,
+        unit=MetricUnit.DOLLAR,
+        significant_digits=2,
+        min_decimal_exponent=-3,
+        max_decimal_exponent=5,
+    )
+
+
+def test_enum_list():
+    """
+    Check list of query states works
+    """
+    assert QueryState.list() == [
+        "UNKNOWN",
+        "ACCEPTED",
+        "SCHEDULED",
+        "RUNNING",
+        "FINISHED",
+        "CANCELED",
+        "FAILED",
+    ]