industrial-model 0.1.15__tar.gz → 0.1.17__tar.gz

{industrial_model-0.1.15 → industrial_model-0.1.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: industrial-model
-Version: 0.1.15
+Version: 0.1.17
 Summary: Industrial Model ORM
 Author-email: Lucas Alves <lucasrosaalves@gmail.com>
 Classifier: Programming Language :: Python

{industrial_model-0.1.15 → industrial_model-0.1.17}/industrial_model/cognite_adapters/query_result_mapper.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
-from typing import Any, TypedDict
+from enum import StrEnum
+from typing import Any, Literal, TypedDict
 
 from cognite.client.data_classes.data_modeling import (
     Edge,
@@ -19,8 +20,15 @@ from industrial_model.models import EdgeContainer
 from .view_mapper import ViewMapper
 
 
+class ConnectionTypeEnum(StrEnum):
+    DIRECT_RELATION = "DirectRelation"
+    REVERSE_DIRECT_RELATION = "ReverseDirectRelation"
+    EDGE = "Edge"
+
+
 class _PropertyMapping(TypedDict):
     is_list: bool
+    connection_type: ConnectionTypeEnum
     nodes: dict[tuple[str, str], list[Node]]
     edges: dict[tuple[str, str], list[Edge]]
 
@@ -92,16 +100,26 @@ class QueryResultMapper:
             for mapping_key, mapping_value in mappings.items():
                 element = properties.get(mapping_key)
 
+                mapping_nodes = mapping_value.get("nodes", {})
+                mapping_edges = mapping_value.get("edges", {})
+                is_list = mapping_value.get("is_list", False)
+                connection_type = mapping_value.get(
+                    "connection_type",
+                    ConnectionTypeEnum.DIRECT_RELATION,
+                )
+
+                if (
+                    element is None
+                    and connection_type == ConnectionTypeEnum.DIRECT_RELATION
+                ):
+                    continue
+
                 element_key: tuple[str, str] = (
                     (element.get("space", ""), element.get("externalId", ""))
                     if isinstance(element, dict)
                     else (node.space, node.external_id)
                 )
 
-                mapping_nodes = mapping_value.get("nodes", {})
-                mapping_edges = mapping_value.get("edges", {})
-                is_list = mapping_value.get("is_list", False)
-
                 node_entries = mapping_nodes.get(element_key)
                 if not node_entries:
                     continue
@@ -116,6 +134,7 @@ class QueryResultMapper:
                         edge_entries
                     )
             properties["_edges"] = edges_mapping
+
             node.properties[view_id] = properties
 
             result[node_id].append(node)
@@ -136,6 +155,9 @@ class QueryResultMapper:
             nodes: dict[tuple[str, str], list[Node]] | None = None
             edges: dict[tuple[str, str], list[Edge]] | None = None
             is_list = False
+            connection_type: ConnectionTypeEnum = (
+                ConnectionTypeEnum.DIRECT_RELATION
+            )
 
             if isinstance(property, MappedProperty) and property.source:
                 nodes = self._map_node_property(
@@ -144,6 +166,7 @@ class QueryResultMapper:
                     query_result,
                 )
                 is_list = False
+                connection_type = ConnectionTypeEnum.DIRECT_RELATION
             elif (
                 isinstance(property, SingleReverseDirectRelation)
                 and property.source
@@ -155,6 +178,7 @@ class QueryResultMapper:
                     property.through.property,
                 )
                 is_list = False
+                connection_type = ConnectionTypeEnum.REVERSE_DIRECT_RELATION
             elif (
                 isinstance(property, MultiReverseDirectRelation)
                 and property.source
@@ -166,6 +190,7 @@ class QueryResultMapper:
                     property.through.property,
                 )
                 is_list = True
+                connection_type = ConnectionTypeEnum.REVERSE_DIRECT_RELATION
 
             elif isinstance(property, EdgeConnection) and property.source:
                 nodes, edges = self._map_edge_property(
@@ -175,10 +200,14 @@ class QueryResultMapper:
                     property.direction,
                 )
                 is_list = True
+                connection_type = ConnectionTypeEnum.EDGE
 
             if nodes:
                 mappings[property_name] = _PropertyMapping(
-                    is_list=is_list, nodes=nodes, edges=edges or {}
+                    is_list=is_list,
+                    connection_type=connection_type,
+                    nodes=nodes,
+                    edges=edges or {},
                 )
 
         return mappings

{industrial_model-0.1.15 → industrial_model-0.1.17}/industrial_model/models/schemas.py

@@ -57,17 +57,21 @@ def get_parent_and_children_nodes(
 
 
 def _get_type_properties(
-    cls: type[BaseModel], visited_count: defaultdict[type, int] | None = None
+    cls: type[BaseModel],
+    parent_type: type[BaseModel] | None = None,
+    visited_count: defaultdict[type, int] | None = None,
 ) -> dict[str, Any] | None:
     if visited_count is not None:
-        if visited_count[cls] > 2:
+        if visited_count[cls] > 1:
             return None
-        visited_count[cls] += 1
+        elif parent_type == cls:
+            visited_count[cls] += 1
 
     hints = get_type_hints(cls)
     origins = {
         key: _get_field_type(
             type_hint,
+            cls,
             visited_count or defaultdict(lambda: 0),
         )
         for key, type_hint in hints.items()
@@ -81,13 +85,15 @@ def _get_type_properties(
 
 
 def _get_field_type(
-    type_hint: type, visited_count: defaultdict[type, int]
+    type_hint: type,
+    parent_type: type[BaseModel],
+    visited_count: defaultdict[type, int],
 ) -> tuple[bool, dict[str, Any] | None]:
     should_iter = _type_is_list_or_union(type_hint)
 
     if not should_iter:
         return _get_field_relations(
-            [_cast_base_model(type_hint)], visited_count
+            [_cast_base_model(type_hint)], parent_type, visited_count
         )
 
     entries: list[type[BaseModel] | None] = []
@@ -96,11 +102,12 @@ def _get_field_type(
             return _get_field_type(arg, visited_count)
         entries.append(_cast_base_model(arg))
 
-    return _get_field_relations(entries, visited_count)
+    return _get_field_relations(entries, parent_type, visited_count)
 
 
 def _get_field_relations(
     entries: list[type[TBaseModel] | None],
+    parent_type: type[BaseModel],
     visited_count: defaultdict[type, int],
 ) -> tuple[bool, dict[str, Any] | None]:
     entry_type = next((type_ for type_ in entries if type_ is not None), None)
@@ -108,7 +115,7 @@ def _get_field_relations(
     if not entry_type:
         return False, None
 
-    properties = _get_type_properties(entry_type, visited_count)
+    properties = _get_type_properties(entry_type, parent_type, visited_count)
 
     return True, properties
 

{industrial_model-0.1.15 → industrial_model-0.1.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "industrial-model"
-version = "0.1.15"
+version = "0.1.17"
 description = "Industrial Model ORM"
 readme = "README.md"
 requires-python = ">=3.11"

{industrial_model-0.1.15 → industrial_model-0.1.17}/uv.lock

@@ -215,7 +215,7 @@ wheels = [
 
 [[package]]
 name = "industrial-model"
-version = "0.1.15"
+version = "0.1.17"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },