@sanderegg review: decouple model adapters

Author: pcrespov

packages/postgres-database/src/simcore_postgres_database/utils_projects_nodes.py

@@ -71,24 +71,6 @@ class ProjectNodeCreate(BaseModel):
     def get_field_names(cls, *, exclude: set[str]) -> set[str]:
         return cls.model_fields.keys() - exclude
 
-    def model_dump_as_node(self) -> dict[str, Any]:
-        """Converts a ProjectNode from the database to a Node model for the API.
-
-        Handles field mapping and excludes database-specific fields that are not
-        part of the Node model.
-
-        NOTE: tested in services/web/server/tests/unit/isolated/test_models.py
-        """
-        # Get all ProjectNode fields except those that don't belong in Node
-        exclude_fields = {"node_id", "required_resources"}
-        return self.model_dump(
-            # NOTE: this setup ensures using the defaults provided in Node model when the db does not
-            # provide them, e.g. `state`
-            exclude=exclude_fields,
-            exclude_none=True,
-            exclude_unset=True,
-        )
-
     model_config = ConfigDict(frozen=True)
 
 
@@ -98,24 +80,6 @@ class ProjectNode(ProjectNodeCreate):
 
     model_config = ConfigDict(from_attributes=True)
 
-    def model_dump_as_node(self) -> dict[str, Any]:
-        """Converts a ProjectNode from the database to a Node model for the API.
-
-        Handles field mapping and excludes database-specific fields that are not
-        part of the Node model.
-
-        NOTE: tested in services/web/server/tests/unit/isolated/test_models.py
-        """
-        # Get all ProjectNode fields except those that don't belong in Node
-        exclude_fields = {"node_id", "required_resources", "created", "modified"}
-        return self.model_dump(
-            # NOTE: this setup ensures using the defaults provided in Node model when the db does not
-            # provide them, e.g. `state`
-            exclude=exclude_fields,
-            exclude_none=True,
-            exclude_unset=True,
-        )
-
 
 @dataclass(frozen=True, kw_only=True)
 class ProjectNodesRepo:

services/web/server/src/simcore_service_webserver/projects/_nodes_models_adapters.py

@@ -0,0 +1,70 @@
+"""
+Collection of free function adapters between Node-like pydantic models
+
+- The tricky part here is to deal with alias in Node model which are not present in the DB models
+
+"""
+
+from datetime import datetime
+from typing import Any
+from uuid import UUID
+
+from models_library.projects_nodes import Node
+from simcore_postgres_database.utils_projects_nodes import (
+    ProjectNode,
+    ProjectNodeCreate,
+)
+
+
+def node_from_project_node_create(project_node_create: ProjectNodeCreate) -> Node:
+    """
+    Adapter: Converts a ProjectNodeCreate instance to a Node model.
+    """
+    exclude_fields = {"node_id", "required_resources"}
+
+    assert set(ProjectNodeCreate.model_fields).issuperset(exclude_fields)  # nosec
+
+    node_data: dict[str, Any] = project_node_create.model_dump(
+        exclude=exclude_fields,
+        exclude_none=True,
+        exclude_unset=True,
+    )
+    return Node.model_validate(node_data, by_name=True)
+
+
+def node_from_project_node(project_node: ProjectNode) -> Node:
+    """
+    Adapter: Converts a ProjectNode instance to a Node model.
+    """
+    exclude_fields = {"node_id", "required_resources", "created", "modified"}
+    assert set(ProjectNode.model_fields).issuperset(exclude_fields)  # nosec
+
+    node_data: dict[str, Any] = project_node.model_dump(
+        exclude=exclude_fields,
+        exclude_none=True,
+        exclude_unset=True,
+    )
+    return Node.model_validate(node_data, by_name=True)
+
+
+def project_node_create_from_node(node: Node, node_id: UUID) -> ProjectNodeCreate:
+    """
+    Adapter: Converts a Node model and node_id to a ProjectNodeCreate instance.
+    """
+    node_data: dict[str, Any] = node.model_dump(by_alias=False, mode="json")
+    return ProjectNodeCreate(node_id=node_id, **node_data)
+
+
+def project_node_from_node(
+    node: Node, node_id: UUID, created: datetime, modified: datetime
+) -> ProjectNode:
+    """
+    Adapter: Converts a Node model, node_id, created, and modified to a ProjectNode instance.
+    """
+    node_data: dict[str, Any] = node.model_dump(by_alias=False, mode="json")
+    return ProjectNode(
+        node_id=node_id,
+        created=created,
+        modified=modified,
+        **node_data,
+    )

services/web/server/tests/unit/isolated/test_models.py

@@ -7,13 +7,8 @@
 
 import pytest
 from faker import Faker
-from models_library.projects_nodes import Node
 from pydantic import TypeAdapter, ValidationError
 from pytest_simcore.helpers.faker_factories import random_phone_number
-from simcore_postgres_database.utils_projects_nodes import (
-    ProjectNode,
-    ProjectNodeCreate,
-)
 from simcore_service_webserver.users._controller.rest._rest_schemas import (
     MyPhoneRegister,
     PhoneNumberStr,
@@ -72,40 +67,3 @@ def test_invalid_phone_numbers(phone: str):
     # This test is used to tune options of PhoneNumberValidator
     with pytest.raises(ValidationError):
         MyPhoneRegister.model_validate({"phone": phone})
-
-
-_node_domain_model_dict_examples = Node.model_json_schema()["examples"]
-
-
-@pytest.mark.parametrize(
-    "node_data",
-    _node_domain_model_dict_examples,
-    ids=[f"example-{i}" for i in range(len(_node_domain_model_dict_examples))],
-)
-def test_adapters_between_different_node_models(node_data: dict, faker: Faker):
-    """
-    NOTE: This test is here because it checks models from models_library and simcore_postgres_database
-    which are in different packages and should not depend on each other.
-    """
-    # dict -> to Node (from models_library)
-    node_id = faker.uuid4()
-    node = Node.model_validate(node_data)
-
-    # -> to ProjectNodeCreate and ProjectNode (from simcore_postgres_database)
-    project_node_create = ProjectNodeCreate(
-        node_id=node_id,
-        **node.model_dump(by_alias=False, mode="json"),
-    )
-    project_node = ProjectNode(
-        node_id=node_id,
-        created=faker.date_time(),
-        modified=faker.date_time(),
-        **node.model_dump(by_alias=False, mode="json"),
-    )
-
-    # -> to Node (from models_library)
-    assert (
-        Node.model_validate(project_node_create.model_dump_as_node(), by_name=True)
-        == node
-    )
-    assert Node.model_validate(project_node.model_dump_as_node(), by_name=True) == node

services/web/server/tests/unit/isolated/test_projects__nodes_models_adapters.py

@@ -0,0 +1,62 @@
+# pylint: disable=protected-access
+# pylint: disable=redefined-outer-name
+# pylint: disable=too-many-arguments
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+
+
+from typing import Any
+from uuid import UUID
+
+import pytest
+from faker import Faker
+from models_library.projects_nodes import Node
+from simcore_postgres_database.utils_projects_nodes import (
+    ProjectNode,
+    ProjectNodeCreate,
+)
+from simcore_service_webserver.projects import _nodes_models_adapters
+
+_NODE_DOMAIN_MODEL_DICT_EXAMPLES = Node.model_json_schema()["examples"]
+
+
+@pytest.mark.parametrize(
+    "node_data",
+    _NODE_DOMAIN_MODEL_DICT_EXAMPLES,
+    ids=[f"example-{i}" for i in range(len(_NODE_DOMAIN_MODEL_DICT_EXAMPLES))],
+)
+def test_adapters_between_different_node_models(
+    node_data: dict[str, Any], faker: Faker
+):
+    # dict -> to Node (from models_library)
+    node_id = UUID(faker.uuid4())
+    node = Node.model_validate(node_data)
+
+    # Node -> ProjectNodeCreate (from simcore_postgres_database) using adapters
+    project_node_create = _nodes_models_adapters.project_node_create_from_node(
+        node, node_id
+    )
+    assert isinstance(project_node_create, ProjectNodeCreate)
+    assert project_node_create.node_id == node_id
+
+    # Node -> ProjectNode (from simcore_postgres_database) using adapters
+    project_node = _nodes_models_adapters.project_node_from_node(
+        node,
+        node_id,
+        created=faker.date_time(),
+        modified=faker.date_time(),
+    )
+
+    assert isinstance(project_node, ProjectNode)
+    assert project_node.node_id == node_id
+    assert project_node.created != project_node.modified
+    assert project_node_create.node_id == node_id
+
+    # ProjectNodeCreate -> Node (from models_library) using adapters
+    assert (
+        _nodes_models_adapters.node_from_project_node_create(project_node_create)
+        == node
+    )
+
+    # ProjectNode -> Node (from models_library) using adapters
+    assert _nodes_models_adapters.node_from_project_node(project_node) == node