industrial-model 0.1.34__tar.gz → 0.1.36__tar.gz

{industrial_model-0.1.34 → industrial_model-0.1.36}/PKG-INFO

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

{industrial_model-0.1.34 → industrial_model-0.1.36}/industrial_model/engines/engine.py

@@ -5,12 +5,12 @@ from cognite.client import CogniteClient
 from industrial_model.cognite_adapters import CogniteAdapter
 from industrial_model.config import DataModelId
 from industrial_model.models import (
-    EdgeContainer,
     PaginatedResult,
     TAggregatedViewInstance,
     TViewInstance,
     TWritableViewInstance,
     ValidationMode,
+    include_edges,
 )
 from industrial_model.statements import (
     AggregationStatement,
@@ -96,24 +96,10 @@ class Engine:
         for item in data:
             try:
                 validated_item = entity.model_validate(item)
-                self._include_edges(item, validated_item)
+                include_edges(item, validated_item)
                 result.append(validated_item)
             except Exception:
                 if validation_mode == "ignoreOnError":
                     continue
                 raise
         return result
-
-    def _include_edges(
-        self, item: dict[str, Any], validated_item: TViewInstance
-    ) -> None:
-        if "_edges" not in item or not isinstance(item["_edges"], dict):
-            return
-        entries: dict[str, list[EdgeContainer]] = {}
-        for property_, edges in item["_edges"].items():
-            if not edges or not isinstance(edges, list):
-                continue
-
-            assert isinstance(edges[0], EdgeContainer)
-            entries[property_] = edges
-        validated_item._edges = entries

{industrial_model-0.1.34 → industrial_model-0.1.36}/industrial_model/models/__init__.py

@@ -13,12 +13,14 @@ from .entities import (
     WritableViewInstance,
 )
 from .schemas import get_parent_and_children_nodes, get_schema_properties
+from .utils import include_edges
 
 __all__ = [
     "AggregatedViewInstance",
     "RootModel",
     "EdgeContainer",
     "InstanceId",
+    "include_edges",
     "TAggregatedViewInstance",
     "TViewInstance",
     "TWritableViewInstance",

{industrial_model-0.1.34 → industrial_model-0.1.36}/industrial_model/models/base.py

@@ -55,3 +55,14 @@ class RootModel(BaseModel):
                 return key
 
         return None
+
+    def get_field_alias(self, field_name_or_alias: str) -> str | None:
+        entry = self.__class__.model_fields.get(field_name_or_alias)
+        if entry:
+            return entry.alias
+
+        for _, field_info in self.__class__.model_fields.items():
+            if field_info.alias == field_name_or_alias:
+                return field_info.alias
+
+        return None

{industrial_model-0.1.34 → industrial_model-0.1.36}/industrial_model/models/entities.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from datetime import date, datetime
+from datetime import UTC, date, datetime
 from typing import (
     Any,
     ClassVar,
@@ -9,7 +9,7 @@ from typing import (
     TypeVar,
 )
 
-from pydantic import PrivateAttr
+from pydantic import PrivateAttr, computed_field
 
 from industrial_model.statements import Column
 
@@ -39,6 +39,18 @@ class EdgeContainer(InstanceId):
     type: InstanceId
     start_node: InstanceId
     end_node: InstanceId
+    last_updated_time: int
+    created_time: int
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def created_time_as_datetime(self) -> datetime:
+        return datetime.fromtimestamp(self.created_time / 1000, tz=UTC)
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def last_updated_time_as_datetime(self) -> datetime:
+        return datetime.fromtimestamp(self.last_updated_time / 1000, tz=UTC)
 
 
 TInstanceId = TypeVar("TInstanceId", bound=InstanceId)
@@ -60,6 +72,19 @@ class ViewInstance(InstanceId):
     def get_view_external_id(cls) -> str:
         return cls.view_config.get("view_external_id") or cls.__name__
 
+    def get_edge_metadata(self, property: Column | str | Any) -> list[EdgeContainer]:
+        assert isinstance(property, Column | str), (
+            f"Expected property to be Column, or str, got {type(property).__name__}"
+        )
+        identifier = property.property if isinstance(property, Column) else property
+
+        edge_map_key = self.get_field_alias(identifier) or self.get_field_name(
+            identifier
+        )
+        if not edge_map_key:
+            return []
+        return self._edges.get(edge_map_key, [])
+
     def generate_model_id(
         self,
         fields: list[str] | list[Column] | list[Any],

industrial_model-0.1.36/industrial_model/models/utils.py

@@ -0,0 +1,58 @@
+from typing import Any
+
+from .entities import EdgeContainer, TViewInstance, ViewInstance
+
+
+def include_edges(
+    root_item: dict[str, Any], validated_root_item: TViewInstance
+) -> None:
+    if not isinstance(root_item, dict) or not isinstance(
+        validated_root_item, ViewInstance
+    ):
+        return
+
+    for property_, value in root_item.items():
+        field_key = validated_root_item.get_field_name(property_)
+        if not field_key:
+            continue
+        _handle_edge_property(validated_root_item, value, field_key)
+    _include_edges(root_item, validated_root_item)
+
+
+def _handle_edge_property(
+    validated_root_item: TViewInstance, value: Any, field_key: str
+) -> None:
+    attr_value = getattr(validated_root_item, field_key, None)
+
+    if isinstance(value, dict):
+        _handle_dict_property(value, attr_value)
+        return
+
+    if (
+        not isinstance(value, list)
+        or not isinstance(attr_value, list)
+        or len(value) != len(attr_value)
+    ):
+        return
+
+    for index, value_item in enumerate(value):
+        entry = attr_value[index]
+        _handle_dict_property(value_item, entry)
+
+
+def _handle_dict_property(value: Any, attr_value: Any) -> None:
+    if isinstance(value, dict) and isinstance(attr_value, ViewInstance):
+        include_edges(value, attr_value)
+
+
+def _include_edges(item: dict[str, Any], validated_item: TViewInstance) -> None:
+    if "_edges" not in item or not isinstance(item["_edges"], dict):
+        return
+    entries: dict[str, list[EdgeContainer]] = {}
+    for property_, edges in item["_edges"].items():
+        if not edges or not isinstance(edges, list):
+            continue
+
+        assert isinstance(edges[0], EdgeContainer)
+        entries[property_] = edges
+    validated_item._edges = entries

{industrial_model-0.1.34 → industrial_model-0.1.36}/pyproject.toml

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