datajunction 0.0.1a68.dev0__tar.gz → 0.0.1a68.dev1__tar.gz

{datajunction-0.0.1a68.dev0 → datajunction-0.0.1a68.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datajunction
-Version: 0.0.1a68.dev0
+Version: 0.0.1a68.dev1
 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.1a68.dev1/datajunction/__about__.py

@@ -0,0 +1,4 @@
+"""
+Version for Hatch
+"""
+__version__ = "0.0.1a68.dev1"

{datajunction-0.0.1a68.dev0 → datajunction-0.0.1a68.dev1}/datajunction/builder.py

@@ -46,7 +46,7 @@ class DJBuilder(DJClient):  # pylint: disable=too-many-public-methods
     def create_namespace(
         self,
         namespace: str,
-        skip_if_exists: bool = False,
+        update_if_exists: bool = False,
     ) -> "Namespace":
         """
         Create a namespace with a given name.
@@ -56,7 +56,7 @@ class DJBuilder(DJClient):  # pylint: disable=too-many-public-methods
             timeout=self._timeout,
         )
         json_response = response.json()
-        if response.status_code == 409 and not skip_if_exists:
+        if response.status_code == 409 and not update_if_exists:
             raise DJNamespaceAlreadyExists(json_response["message"])
         return Namespace(namespace=namespace, dj_client=self)
 
@@ -152,24 +152,24 @@ class DJBuilder(DJClient):  # pylint: disable=too-many-public-methods
                 # This check is for the unit tests, which don't raise an exception
                 # for >= 400 status codes
                 if "name" in cube_dict:
-                    existing_node_dict["metrics"] = cube_dict["cube_node_metrics"]
-                    existing_node_dict["dimensions"] = cube_dict["cube_node_dimensions"]
+                    data["metrics"] = cube_dict["cube_node_metrics"]
+                    data["dimensions"] = cube_dict["cube_node_dimensions"]
         except DJClientException as e:  # pragma: no cover # pytest fixture doesn't raise
             if re.search(r"node .* does not exist", str(e)):
                 existing_node_dict = None
             else:
                 raise
 
-        # Checking for "name" in existing_node_dict is a workaround
+        # pylint: disable=fixme
+        # TODO: checking for "name" in existing_node_dict is a workaround
         #   to accommodate pytest mock client, which return a error message dict (no "name")
         #   instead of raising like the real client.
         if existing_node_dict and "name" in existing_node_dict:
             # update
             if update_if_exists:
-                existing_node_dict.update(data)
                 new_node = self.make_node_of_type(
                     type_=type_,
-                    data=existing_node_dict,
+                    data=data,
                 )
                 new_node._update_tags()
                 new_node._update()
@@ -487,7 +487,7 @@ class DJBuilder(DJClient):  # pylint: disable=too-many-public-methods
         description: Optional[str],
         tag_metadata: Dict,
         tag_type: str,
-        skip_if_exists: bool = False,
+        update_if_exists: bool = False,
     ) -> Tag:
         """
         Create a tag with a given name.
@@ -502,7 +502,7 @@ class DJBuilder(DJClient):  # pylint: disable=too-many-public-methods
         try:
             self._create_tag(tag=new_tag)
         except DJTagAlreadyExists as exc:
-            if not skip_if_exists:
+            if not update_if_exists:
                 raise exc
         new_tag.refresh()
         return new_tag

{datajunction-0.0.1a68.dev0 → datajunction-0.0.1a68.dev1}/datajunction/compile.py

@@ -28,11 +28,7 @@ from rich.live import Live
 from rich.table import Table
 
 from datajunction import DJBuilder
-from datajunction.exceptions import (
-    DJClientException,
-    DJDeploymentFailure,
-    DJNamespaceAlreadyExists,
-)
+from datajunction.exceptions import DJClientException, DJDeploymentFailure
 from datajunction.models import Column, NodeMode, NodeType
 from datajunction.tags import Tag
 
@@ -606,7 +602,7 @@ class CompiledProject(Project):
                     *[
                         prefixed_name,
                         "[b][#3A4F6C]tag",
-                        f"[green]Tag {prefixed_name} successfully created (or updated)",
+                        f"[green]Tag {prefixed_name} successfully created",
                     ]
                 )
             except DJClientException as exc:  # pragma: no cover
@@ -620,53 +616,30 @@ class CompiledProject(Project):
         """
         Deploy namespaces
         """
-        namespaces_to_create = self.namespaces
-        if prefix:  # pragma: no cover
-            namespaces_to_create = [prefix] + [
-                f"{prefix}.{ns}" for ns in list(self.namespaces)
-            ]
-        for namespace in namespaces_to_create:
+        for namespace in list(self.namespaces) + [prefix]:
+            prefixed_name = f"{prefix}.{namespace}" if namespace != prefix else prefix
             try:
-                print(f"Creating namespace {namespace}")
                 client.create_namespace(
-                    namespace=namespace,
+                    namespace=prefixed_name,
+                    update_if_exists=True,
                 )
-                print(f"Created namespace {namespace}")
                 table.add_row(
                     *[
-                        namespace,
+                        prefixed_name,
                         "[b][#3A4F6C]namespace",
-                        f"[green]Namespace {namespace} successfully created",
-                    ]
-                )
-            except DJNamespaceAlreadyExists:
-                table.add_row(
-                    *[
-                        namespace,
-                        "namespace",
-                        f"[i][yellow]Namespace {namespace} already exists",
+                        f"[green]Namespace {prefixed_name} successfully created",
                     ]
                 )
             except DJClientException as exc:
-                # This is a just-in-case code for some older client versions.
-                if "already exists" in str(exc):
-                    table.add_row(
-                        *[
-                            namespace,
-                            "namespace",
-                            f"[i][yellow]Namespace {namespace} already exists",
-                        ]
-                    )
-                else:
-                    # pragma: no cover
-                    table.add_row(*[namespace, "namespace", f"[i][red]{str(exc)}"])
-                    self.errors.append(
-                        {
-                            "name": namespace,
-                            "type": "namespace",
-                            "error": str(exc),
-                        },
-                    )
+                # pragma: no cover
+                table.add_row(*[namespace, "namespace", f"[i][red]{str(exc)}"])
+                self.errors.append(
+                    {
+                        "name": prefixed_name,
+                        "type": "namespace",
+                        "error": str(exc),
+                    },
+                )
         return table
 
     def _deploy_nodes(
@@ -722,7 +695,7 @@ class CompiledProject(Project):
                     *[
                         prefixed_name,
                         f"{style}{created_node.type}",
-                        f"[green]Node {created_node.name} successfully created (or updated)",
+                        f"[green]Node {created_node.name} successfully created",
                     ]
                 )
             except DJClientException as exc:

{datajunction-0.0.1a68.dev0 → datajunction-0.0.1a68.dev1}/datajunction/exceptions.py

@@ -13,10 +13,6 @@ class DJNamespaceAlreadyExists(DJClientException):
     Raised when a namespace to be created already exists.
     """
 
-    def __init__(self, ns_name: str, *args) -> None:
-        self.message = f"Namespace `{ns_name}` already exists."
-        super().__init__(self.message, *args)
-
 
 class DJTagAlreadyExists(DJClientException):
     """

{datajunction-0.0.1a68.dev0 → datajunction-0.0.1a68.dev1}/datajunction/nodes.py

@@ -383,8 +383,9 @@ class Source(Node):
         When `catalog` is a dictionary, parse out the catalog's
         name, otherwise just return the string.
         """
-        if self.catalog and isinstance(self.catalog, dict):
-            self.catalog = self.catalog["name"]
+        if self.catalog:
+            if isinstance(self.catalog, dict):
+                self.catalog = self.catalog["name"]
 
     def _update(self) -> requests.Response:
         """

{datajunction-0.0.1a68.dev0 → datajunction-0.0.1a68.dev1}/tests/test_builder.py

@@ -359,11 +359,11 @@ class TestDJBuilder:  # pylint: disable=too-many-public-methods, protected-acces
         with pytest.raises(DJClientException):
             account_type_table = client.create_source(
                 name="default.account_type_table",
-                description="new description",
+                description="New description",
                 update_if_exists=False,
             )
 
-        # ... should work since update_if_exists is set to True
+        # ... should work since update_if_exists is set to True by default
         account_type_table = client.create_source(
             name="default.account_type_table",
             description="new description",
@@ -657,17 +657,13 @@ class TestDJBuilder:  # pylint: disable=too-many-public-methods, protected-acces
         )
         assert cube_one.name == "default.cube_one"
         assert cube_one.status == "valid"
-        assert cube_one.metrics == ["default.number_of_account_types"]
         assert [tag["name"] for tag in cube_one.tags] == ["foo"]
 
         # Test updating cube node
         cube_one = client.create_cube(
             name="default.cube_one",
             description="Ice cubes!",
-            metrics=[
-                "default.number_of_account_types",
-                "default.number_of_account_types2",
-            ],
+            metrics=["default.number_of_account_types"],
             dimensions=["default.account_type.account_type_name"],
             mode=NodeMode.PUBLISHED,
             tags=[],
@@ -675,10 +671,6 @@ class TestDJBuilder:  # pylint: disable=too-many-public-methods, protected-acces
         )
         assert cube_one.name == "default.cube_one"
         assert cube_one.description == "Ice cubes!"
-        assert cube_one.metrics == [
-            "default.number_of_account_types",
-            "default.number_of_account_types2",
-        ]
         assert [tag["name"] for tag in cube_one.tags] == []
 
     def test_link_unlink_dimension(self, client):  # pylint: disable=unused-argument
@@ -1043,15 +1035,15 @@ class TestDJBuilder:  # pylint: disable=too-many-public-methods, protected-acces
             tag_type="test",
             tag_metadata={"foo": "bar"},
         )
-        # skip if a tag exists
+        # update the same tag
         client.create_tag(
             name="foo.two",
             description="Foo Bar",
             tag_type="test",
             tag_metadata={"foo": "bar"},
-            skip_if_exists=True,
+            update_if_exists=True,
         )
-        # fail if a tag exists
+        # create a new tag with the same name
         with pytest.raises(DJTagAlreadyExists) as exc_info:
             client.create_tag(
                 name="foo.two",

{datajunction-0.0.1a68.dev0 → datajunction-0.0.1a68.dev1}/tests/test_compile.py

@@ -4,7 +4,7 @@ Test YAML project related things
 # pylint: disable=unused-argument
 import os
 from typing import Callable
-from unittest.mock import MagicMock, call
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -14,50 +14,25 @@ from datajunction.exceptions import DJClientException, DJDeploymentFailure
 from datajunction.models import NodeMode
 
 
-def test_compiled_project_deploy_namespaces():
+def test_compiled_project__deploy_namespaces():
     """
     Test deploying a namespace.
     """
-    mock_table = MagicMock()
     cp = CompiledProject(
         name="foo",
         prefix="foo.fix",
+        mode=NodeMode.DRAFT,
         root_path="/foo",
-        namespaces=["foo", "bar"],
     )
-    # namespace creation random error
     builder_client = MagicMock(
         create_namespace=MagicMock(side_effect=DJClientException("foo error")),
     )
     cp._deploy_namespaces(  # pylint: disable=protected-access
         prefix="foo",
-        table=mock_table,
+        table=MagicMock(),
         client=builder_client,
     )
     assert cp.errors[0]["error"] == "foo error"
-    # namespace already exists, not an error
-    cp = CompiledProject(
-        name="foo",
-        prefix="foo.fix",
-        root_path="/foo",
-        namespaces=["foo", "bar"],
-    )
-    builder_client = MagicMock(
-        create_namespace=MagicMock(
-            side_effect=DJClientException("foo bar already exists"),
-        ),
-    )
-    cp._deploy_namespaces(  # pylint: disable=protected-access
-        prefix="foo",
-        table=mock_table,
-        client=builder_client,
-    )
-    assert cp.errors == []
-    assert mock_table.add_row.call_args == call(
-        "foo.bar",
-        "namespace",
-        "[i][yellow]Namespace foo.bar already exists",
-    )
 
 
 def test_compiled_project__cleanup_namespace():

datajunction-0.0.1a68.dev0/datajunction/__about__.py

@@ -1,4 +0,0 @@
-"""
-Version for Hatch
-"""
-__version__ = "0.0.1a68.dev0"