industrial-model 0.1.8__tar.gz → 0.1.10__tar.gz

{industrial_model-0.1.8 → industrial_model-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: industrial-model
-Version: 0.1.8
+Version: 0.1.10
 Summary: Industrial Model ORM
 Author-email: Lucas Alves <lucasrosaalves@gmail.com>
 Classifier: Programming Language :: Python
@@ -181,6 +181,40 @@ statement = select(Person).where(
 )
 all_results = engine.query_all_pages(statement)
 
+
+# 7. Data Ingestion
+
+from industrial_model import (
+    WritableViewInstance  # necessary for data ingestion
+)
+
+
+class WritablePerson(WritableViewInstance):
+    name: str
+    lives_in: InstanceId
+    cars: list[InstanceId]
+
+    # You need to implement the end_id_factory so the model can build the edge ids automatically.
+    def edge_id_factory(
+        self, target_node: InstanceId, edge_type: InstanceId
+    ) -> InstanceId:
+        return InstanceId(
+            external_id=f"{self.external_id}-{target_node.external_id}-{edge_type.external_id}",
+            space=self.space,
+        )
+
+statement = select(WritablePerson).where(
+    (WritablePerson.external_id == "Lucas") 
+)
+
+person = engine.query_all_pages(statement)[0]
+
+person.lives_in = InstanceId(external_id="br", space="data-space")
+person.cars.clear() # Gonna remove all car edges from the person
+
+engine.upsert([person])
+
 ```
 
+
 ---

{industrial_model-0.1.8 → industrial_model-0.1.10}/README.md

@@ -161,6 +161,40 @@ statement = select(Person).where(
 )
 all_results = engine.query_all_pages(statement)
 
+
+# 7. Data Ingestion
+
+from industrial_model import (
+    WritableViewInstance  # necessary for data ingestion
+)
+
+
+class WritablePerson(WritableViewInstance):
+    name: str
+    lives_in: InstanceId
+    cars: list[InstanceId]
+
+    # You need to implement the end_id_factory so the model can build the edge ids automatically.
+    def edge_id_factory(
+        self, target_node: InstanceId, edge_type: InstanceId
+    ) -> InstanceId:
+        return InstanceId(
+            external_id=f"{self.external_id}-{target_node.external_id}-{edge_type.external_id}",
+            space=self.space,
+        )
+
+statement = select(WritablePerson).where(
+    (WritablePerson.external_id == "Lucas") 
+)
+
+person = engine.query_all_pages(statement)[0]
+
+person.lives_in = InstanceId(external_id="br", space="data-space")
+person.cars.clear() # Gonna remove all car edges from the person
+
+engine.upsert([person])
+
 ```
 
+
 ---

{industrial_model-0.1.8 → industrial_model-0.1.10}/industrial_model/__init__.py

@@ -4,9 +4,11 @@ from .models import (
     InstanceId,
     PaginatedResult,
     TViewInstance,
+    TWritableViewInstance,
     ValidationMode,
     ViewInstance,
     ViewInstanceConfig,
+    WritableViewInstance,
 )
 from .statements import and_, col, not_, or_, select
 
@@ -20,9 +22,11 @@ __all__ = [
     "InstanceId",
     "TViewInstance",
     "DataModelId",
+    "TWritableViewInstance",
     "ValidationMode",
     "Engine",
     "AsyncEngine",
     "PaginatedResult",
     "ViewInstanceConfig",
+    "WritableViewInstance",
 ]

{industrial_model-0.1.8 → industrial_model-0.1.10}/industrial_model/cognite_adapters/__init__.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Any
 
 from cognite.client import CogniteClient
@@ -9,15 +10,16 @@ from cognite.client.data_classes.data_modeling.query import (
     QueryResult as CogniteQueryResult,
 )
 
-from industrial_model.cognite_adapters.optimizer import QueryOptimizer
 from industrial_model.config import DataModelId
-from industrial_model.models import TViewInstance
+from industrial_model.models import TViewInstance, TWritableViewInstance
 from industrial_model.statements import Statement
 
+from .optimizer import QueryOptimizer
 from .query_mapper import QueryMapper
 from .query_result_mapper import (
     QueryResultMapper,
 )
+from .upsert_mapper import UpsertMapper
 from .utils import (
     append_nodes_and_edges,
     get_query_for_dependencies_pagination,
@@ -39,6 +41,7 @@ class CogniteAdapter:
         view_mapper = ViewMapper(dm.views)
         self._query_mapper = QueryMapper(view_mapper)
         self._result_mapper = QueryResultMapper(view_mapper)
+        self._upsert_mapper = UpsertMapper(view_mapper)
         self._optmizer = QueryOptimizer(cognite_client)
 
     def query(
@@ -77,6 +80,36 @@ class CogniteAdapter:
             if not all_pages or last_page:
                 return data, next_cursor_
 
+    def upsert(
+        self, entries: list[TWritableViewInstance], replace: bool = False
+    ) -> None:
+        logger = logging.getLogger(__name__)
+        operation = self._upsert_mapper.map(entries)
+
+        for node_chunk in operation.chunk_nodes():
+            logger.info(
+                f"Upserting {len(node_chunk)} nodes (replace={replace})"
+            )
+            self._cognite_client.data_modeling.instances.apply(
+                nodes=node_chunk,
+                replace=replace,
+            )
+
+        for edge_chunk in operation.chunk_edges():
+            logger.info(
+                f"Upserting {len(edge_chunk)} edges (replace={replace})"
+            )
+            self._cognite_client.data_modeling.instances.apply(
+                edges=edge_chunk,
+                replace=replace,
+            )
+
+        for edges_to_remove_chunk in operation.chunk_edges_to_delete():
+            logger.info(f"Deleting {len(edges_to_remove_chunk)} edges")
+            self._cognite_client.data_modeling.instances.delete(
+                edges=[item.as_tuple() for item in edges_to_remove_chunk],
+            )
+
     def _query_dependencies_pages(
         self,
         cognite_query: CogniteQuery,

industrial_model-0.1.10/industrial_model/cognite_adapters/models.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from typing import Any
+
+from cognite.client.data_classes.data_modeling import (
+    EdgeApply,
+    NodeApply,
+)
+
+from industrial_model.models.entities import EdgeContainer
+
+_PAGE_SIZE = 1000
+
+
+@dataclass
+class UpsertOperation:
+    nodes: list[NodeApply]
+    edges: list[EdgeApply]
+    edges_to_delete: list[EdgeContainer]
+
+    def chunk_nodes(self) -> list[list[NodeApply]]:
+        return self._chunk_list(self.nodes)
+
+    def chunk_edges(self) -> list[list[EdgeApply]]:
+        return self._chunk_list(self.edges)
+
+    def chunk_edges_to_delete(self) -> list[list[EdgeContainer]]:
+        return self._chunk_list(self.edges_to_delete)
+
+    def _chunk_list(self, entries: list[Any]) -> list[list[Any]]:
+        data: list[list[Any]] = []
+        for i in range(0, len(entries), _PAGE_SIZE):
+            start = i
+            end = i + _PAGE_SIZE
+            data.append(entries[start:end])
+        return data

{industrial_model-0.1.8 → industrial_model-0.1.10}/industrial_model/cognite_adapters/query_result_mapper.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any
+from typing import Any, TypedDict
 
 from cognite.client.data_classes.data_modeling import (
     Edge,
@@ -14,10 +14,17 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 
 from industrial_model.constants import EDGE_DIRECTION, EDGE_MARKER, NESTED_SEP
+from industrial_model.models import EdgeContainer
 
 from .view_mapper import ViewMapper
 
 
+class _PropertyMapping(TypedDict):
+    is_list: bool
+    nodes: dict[tuple[str, str], list[Node]]
+    edges: dict[tuple[str, str], list[Edge]]
+
+
 class QueryResultMapper:
     def __init__(self, view_mapper: ViewMapper):
         self._view_mapper = view_mapper
@@ -79,25 +86,36 @@ class QueryResultMapper:
 
             visited.add(identify)
             properties = node.properties.get(view_id, {})
+
+            edges_mapping: dict[str, list[EdgeContainer]] = {}
             node_id = get_node_id(node)
-            for mapping_key, (values, is_list) in mappings.items():
+            for mapping_key, mapping_value in mappings.items():
                 element = properties.get(mapping_key)
 
                 element_key: tuple[str, str] = (
                     (element.get("space", ""), element.get("externalId", ""))
                     if isinstance(element, dict)
-                    else node_id
+                    else (node.space, node.external_id)
                 )
 
-                entries = values.get(element_key)
-                if not entries:
+                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
 
-                entry_data = self._nodes_to_dict(entries)
+                entry_data = self._nodes_to_dict(node_entries)
                 properties[mapping_key] = (
                     entry_data if is_list else entry_data[0]
                 )
-
+                edge_entries = mapping_edges.get(element_key)
+                if edge_entries:
+                    edges_mapping[mapping_key] = self._edges_to_model(
+                        edge_entries
+                    )
+            properties["_edges"] = edges_mapping
             node.properties[view_id] = properties
 
             result[node_id].append(node)
@@ -109,19 +127,18 @@ class QueryResultMapper:
         key: str,
         view: View,
         query_result: dict[str, list[Node | Edge]],
-    ) -> dict[str, tuple[dict[tuple[str, str], list[Node]], bool]]:
-        mappings: dict[
-            str, tuple[dict[tuple[str, str], list[Node]], bool]
-        ] = {}
+    ) -> dict[str, _PropertyMapping]:
+        mappings: dict[str, _PropertyMapping] = {}
 
         for property_name, property in view.properties.items():
             property_key = f"{key}{NESTED_SEP}{property_name}"
 
-            entry: dict[tuple[str, str], list[Node]] | None = None
+            nodes: dict[tuple[str, str], list[Node]] | None = None
+            edges: dict[tuple[str, str], list[Edge]] | None = None
             is_list = False
 
             if isinstance(property, MappedProperty) and property.source:
-                entry = self._map_node_property(
+                nodes = self._map_node_property(
                     property_key,
                     self._view_mapper.get_view(property.source.external_id),
                     query_result,
@@ -131,7 +148,7 @@ class QueryResultMapper:
                 isinstance(property, SingleReverseDirectRelation)
                 and property.source
             ):
-                entry = self._map_node_property(
+                nodes = self._map_node_property(
                     property_key,
                     self._view_mapper.get_view(property.source.external_id),
                     query_result,
@@ -142,7 +159,7 @@ class QueryResultMapper:
                 isinstance(property, MultiReverseDirectRelation)
                 and property.source
             ):
-                entry = self._map_node_property(
+                nodes = self._map_node_property(
                     property_key,
                     self._view_mapper.get_view(property.source.external_id),
                     query_result,
@@ -151,7 +168,7 @@ class QueryResultMapper:
                 is_list = True
 
             elif isinstance(property, EdgeConnection) and property.source:
-                entry = self._map_edge_property(
+                nodes, edges = self._map_edge_property(
                     property_key,
                     self._view_mapper.get_view(property.source.external_id),
                     query_result,
@@ -159,8 +176,10 @@ class QueryResultMapper:
                 )
                 is_list = True
 
-            if entry:
-                mappings[property_name] = entry, is_list
+            if nodes:
+                mappings[property_name] = _PropertyMapping(
+                    is_list=is_list, nodes=nodes, edges=edges or {}
+                )
 
         return mappings
 
@@ -170,17 +189,25 @@ class QueryResultMapper:
         view: View,
         query_result: dict[str, list[Node | Edge]],
         edge_direction: EDGE_DIRECTION,
-    ) -> dict[tuple[str, str], list[Node]] | None:
+    ) -> tuple[
+        dict[tuple[str, str], list[Node]] | None,
+        dict[tuple[str, str], list[Edge]] | None,
+    ]:
         edge_key = f"{key}{NESTED_SEP}{EDGE_MARKER}"
         if key not in query_result or edge_key not in query_result:
-            return None
+            return None, None
 
         nodes = self._map_node_property(key, view, query_result)
         if not nodes:
-            return None
+            return None, None
 
         visited: set[tuple[str, str]] = set()
-        result: defaultdict[tuple[str, str], list[Node]] = defaultdict(list)
+        nodes_result: defaultdict[tuple[str, str], list[Node]] = defaultdict(
+            list
+        )
+        edges_result: defaultdict[tuple[str, str], list[Edge]] = defaultdict(
+            list
+        )
         for edge in query_result[edge_key]:
             identify = (edge.space, edge.external_id)
             if not isinstance(edge, Edge) or identify in visited:
@@ -195,15 +222,18 @@ class QueryResultMapper:
                 if edge_direction == "inwards"
                 else (edge.start_node.as_tuple(), edge.end_node.as_tuple())
             )
-
+            edges_result[entry_key].append(edge)
             if node_item := nodes.get(node_key):
-                result[entry_key].extend(node_item)
+                nodes_result[entry_key].extend(node_item)
 
-        return dict(result)
+        return dict(nodes_result), dict(edges_result)
 
     def _nodes_to_dict(self, nodes: list[Node]) -> list[dict[str, Any]]:
         return [self._node_to_dict(node) for node in nodes]
 
+    def _edges_to_model(self, edges: list[Edge]) -> list[EdgeContainer]:
+        return [EdgeContainer.model_validate(edge) for edge in edges]
+
     def _node_to_dict(self, node: Node) -> dict[str, Any]:
         entry = node.dump()
         properties: dict[str, dict[str, dict[str, Any]]] = (

industrial_model-0.1.10/industrial_model/cognite_adapters/upsert_mapper.py

@@ -0,0 +1,146 @@
+import datetime
+from typing import Any
+
+from cognite.client.data_classes.data_modeling import (
+    DirectRelationReference,
+    EdgeApply,
+    EdgeConnection,
+    MappedProperty,
+    NodeApply,
+    NodeOrEdgeData,
+)
+
+from industrial_model.cognite_adapters.models import UpsertOperation
+from industrial_model.models import (
+    EdgeContainer,
+    InstanceId,
+    TWritableViewInstance,
+)
+from industrial_model.utils import datetime_to_ms_iso_timestamp
+
+from .view_mapper import ViewMapper
+
+
+class UpsertMapper:
+    def __init__(self, view_mapper: ViewMapper):
+        self._view_mapper = view_mapper
+
+    def map(self, instances: list[TWritableViewInstance]) -> UpsertOperation:
+        nodes: dict[tuple[str, str], NodeApply] = {}
+        edges: dict[tuple[str, str], EdgeApply] = {}
+        edges_to_delete: dict[tuple[str, str], EdgeContainer] = {}
+
+        for instance in instances:
+            entry_nodes, entry_edges, entry_edges_to_delete = (
+                self._map_instance(instance)
+            )
+
+            nodes[instance.as_tuple()] = entry_nodes
+            edges.update(
+                {(item.space, item.external_id): item for item in entry_edges}
+            )
+            edges_to_delete.update(
+                {
+                    (item.space, item.external_id): item
+                    for item in entry_edges_to_delete
+                }
+            )
+
+        return UpsertOperation(
+            nodes=list(nodes.values()),
+            edges=list(edges.values()),
+            edges_to_delete=list(edges_to_delete.values()),
+        )
+
+    def _map_instance(
+        self, instance: TWritableViewInstance
+    ) -> tuple[NodeApply, list[EdgeApply], list[EdgeContainer]]:
+        view = self._view_mapper.get_view(instance.get_view_external_id())
+
+        edges: list[EdgeApply] = []
+        edges_to_delete: list[EdgeContainer] = []
+        properties: dict[str, Any] = {}
+        for property_name, property in view.properties.items():
+            property_key = instance.get_field_name(property_name)
+            if not property_key:
+                continue
+            entry = instance.__getattribute__(property_key)
+
+            if isinstance(property, MappedProperty):
+                properties[property_name] = (
+                    DirectRelationReference(
+                        space=entry.space, external_id=entry.external_id
+                    )
+                    if isinstance(entry, InstanceId)
+                    else datetime_to_ms_iso_timestamp(entry)
+                    if isinstance(entry, datetime.datetime)
+                    else entry
+                )
+            elif isinstance(property, EdgeConnection) and isinstance(
+                entry, list
+            ):
+                possible_entries = self._map_edges(instance, property, entry)
+
+                previous_edges = {
+                    item.as_tuple(): item
+                    for item in instance._edges.get(property_name, [])
+                }
+
+                new_entries = [
+                    edge
+                    for edge_id, edge in possible_entries.items()
+                    if edge_id not in previous_edges
+                ]
+                edges_to_delete.extend(
+                    [
+                        previous_edges[edge_id]
+                        for edge_id in previous_edges
+                        if edge_id not in possible_entries
+                    ]
+                )
+
+                edges.extend(new_entries)
+
+        node = NodeApply(
+            external_id=instance.external_id,
+            space=instance.space,
+            sources=[
+                NodeOrEdgeData(source=view.as_id(), properties=properties)
+            ],
+        )
+
+        return node, edges, edges_to_delete
+
+    def _map_edges(
+        self,
+        instance: TWritableViewInstance,
+        property: EdgeConnection,
+        values: list[Any],
+    ) -> dict[tuple[str, str], EdgeApply]:
+        edge_type = InstanceId.model_validate(property.type)
+
+        result: dict[tuple[str, str], EdgeApply] = {}
+        for value in values:
+            if not isinstance(value, InstanceId):
+                raise ValueError(
+                    f"""Invalid value for edge property {property.name}:
+                        Received {type(value)} | Expected: InstanceId"""
+                )
+
+            start_node, end_node = (
+                (instance, value)
+                if property.direction == "outwards"
+                else (value, instance)
+            )
+
+            edge_id = instance.edge_id_factory(value, edge_type)
+
+            result[edge_id.as_tuple()] = EdgeApply(
+                external_id=edge_id.external_id,
+                space=edge_id.space,
+                type=property.type,
+                start_node=start_node.as_tuple(),
+                end_node=end_node.as_tuple(),
+            )
+
+        return result

{industrial_model-0.1.8 → industrial_model-0.1.10}/industrial_model/engines/async_engine.py

@@ -6,6 +6,7 @@ from industrial_model.models import (
     TViewInstance,
     ValidationMode,
 )
+from industrial_model.models.entities import TWritableViewInstance
 from industrial_model.statements import Statement
 from industrial_model.utils import run_async
 
@@ -35,3 +36,8 @@ class AsyncEngine:
         return await run_async(
             self._engine.query_all_pages, statement, validation_mode
         )
+
+    async def upsert_async(
+        self, entries: list[TWritableViewInstance], replace: bool = False
+    ) -> None:
+        return await run_async(self._engine.upsert, entries, replace)

{industrial_model-0.1.8 → industrial_model-0.1.10}/industrial_model/engines/engine.py

@@ -9,6 +9,10 @@ from industrial_model.models import (
     TViewInstance,
     ValidationMode,
 )
+from industrial_model.models.entities import (
+    EdgeContainer,
+    TWritableViewInstance,
+)
 from industrial_model.statements import Statement
 
 
@@ -45,6 +49,14 @@ class Engine:
 
         return self._validate_data(statement.entity, data, validation_mode)
 
+    def upsert(
+        self, entries: list[TWritableViewInstance], replace: bool = False
+    ) -> None:
+        if not entries:
+            return
+
+        return self._cognite_adapter.upsert(entries, replace)
+
     def _validate_data(
         self,
         entity: type[TViewInstance],
@@ -54,9 +66,25 @@ class Engine:
         result: list[TViewInstance] = []
         for item in data:
             try:
-                result.append(entity.model_validate(item))
+                validated_item = entity.model_validate(item)
+                self._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.8 → industrial_model-0.1.10}/industrial_model/models/__init__.py

@@ -1,22 +1,28 @@
 from .base import RootModel
 from .entities import (
+    EdgeContainer,
     InstanceId,
     PaginatedResult,
     TViewInstance,
+    TWritableViewInstance,
     ValidationMode,
     ViewInstance,
     ViewInstanceConfig,
+    WritableViewInstance,
 )
 from .schemas import get_parent_and_children_nodes, get_schema_properties
 
 __all__ = [
     "RootModel",
+    "EdgeContainer",
     "InstanceId",
     "TViewInstance",
+    "TWritableViewInstance",
     "ViewInstance",
     "ValidationMode",
     "PaginatedResult",
     "ViewInstanceConfig",
     "get_schema_properties",
     "get_parent_and_children_nodes",
+    "WritableViewInstance",
 ]

{industrial_model-0.1.8 → industrial_model-0.1.10}/industrial_model/models/entities.py

@@ -1,3 +1,4 @@
+from abc import abstractmethod
 from typing import (
     Any,
     ClassVar,
@@ -7,6 +8,8 @@ from typing import (
     TypeVar,
 )
 
+from pydantic import PrivateAttr
+
 from .base import DBModelMetaclass, RootModel
 
 
@@ -29,6 +32,15 @@ class InstanceId(RootModel):
         return (self.space, self.external_id)
 
 
+class EdgeContainer(InstanceId):
+    type: InstanceId
+    start_node: InstanceId
+    end_node: InstanceId
+
+
+TInstanceId = TypeVar("TInstanceId", bound=InstanceId)
+
+
 class ViewInstanceConfig(TypedDict, total=False):
     view_external_id: str | None
     instance_spaces: list[str] | None
@@ -38,12 +50,38 @@ class ViewInstanceConfig(TypedDict, total=False):
 class ViewInstance(InstanceId, metaclass=DBModelMetaclass):
     view_config: ClassVar[ViewInstanceConfig] = ViewInstanceConfig()
 
+    _edges: dict[str, list[EdgeContainer]] = PrivateAttr(default_factory=dict)
+
     @classmethod
     def get_view_external_id(cls) -> str:
         return cls.view_config.get("view_external_id") or cls.__name__
 
+    def get_field_name(self, field_name_or_alias: str) -> str | None:
+        entry = self.__class__.model_fields.get(field_name_or_alias)
+        if entry:
+            return field_name_or_alias
+
+        for key, field_info in self.__class__.model_fields.items():
+            if field_info.alias == field_name_or_alias:
+                return key
+
+        return None
+
+
+class WritableViewInstance(ViewInstance):
+    @abstractmethod
+    def edge_id_factory(
+        self, target_node: TInstanceId, edge_type: InstanceId
+    ) -> InstanceId:
+        raise NotImplementedError(
+            "edge_id_factory method must be implemented in subclasses"
+        )
+
 
 TViewInstance = TypeVar("TViewInstance", bound=ViewInstance)
+TWritableViewInstance = TypeVar(
+    "TWritableViewInstance", bound=WritableViewInstance
+)
 
 
 class PaginatedResult(RootModel, Generic[TViewInstance]):

{industrial_model-0.1.8 → industrial_model-0.1.10}/industrial_model/utils.py

@@ -1,14 +1,12 @@
-from collections.abc import Callable, Generator
+from collections.abc import Callable
 from datetime import datetime
 from typing import (
-    Any,
     ParamSpec,
     TypeVar,
 )
 
 from anyio import to_thread
 
-TAny = TypeVar("TAny")
 T_Retval = TypeVar("T_Retval")
 P = ParamSpec("P")
 
@@ -21,15 +19,6 @@ def datetime_to_ms_iso_timestamp(dt: datetime) -> str:
     return dt.isoformat(timespec="milliseconds")
 
 
-def chunk_list(
-    entries: list[TAny], chunk_size: int
-) -> Generator[list[TAny], Any, None]:
-    for i in range(0, len(entries), chunk_size):
-        start = i
-        end = i + chunk_size
-        yield entries[start:end]
-
-
 async def run_async(
     func: Callable[..., T_Retval],
     *args: object,

{industrial_model-0.1.8 → industrial_model-0.1.10}/pyproject.toml

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

industrial_model-0.1.10/scripts/format.sh

@@ -0,0 +1,2 @@
+ruff check industrial_model tests --fix
+ruff format industrial_model tests

industrial_model-0.1.10/scripts/lint.sh

@@ -0,0 +1,3 @@
+mypy industrial_model tests
+ruff check industrial_model tests
+ruff format industrial_model tests --check

industrial_model-0.1.8/tests/tests_adapter.py → industrial_model-0.1.10/tests/models.py

@@ -1,12 +1,14 @@
 import datetime
-import json
 from typing import Annotated
 
 from pydantic import Field
 
-from industrial_model import ViewInstance, ViewInstanceConfig, col, select
-
-from .hubs import generate_engine
+from industrial_model import (
+    InstanceId,
+    ViewInstance,
+    ViewInstanceConfig,
+    WritableViewInstance,
+)
 
 
 class DescribableEntity(ViewInstance):
@@ -32,7 +34,8 @@ class EventDetail(ViewInstance):
 
 class Event(ViewInstance):
     view_config = ViewInstanceConfig(
-        view_external_id="OEEEvent", instance_spaces_prefix="OEE-"
+        view_external_id="OEEEvent",
+        instance_spaces_prefix="OEE-",
     )
 
     start_date_time: datetime.datetime | None = None
@@ -49,22 +52,24 @@ class Event(ViewInstance):
     ]
 
 
-adapter = generate_engine()
-
-filter = (
-    col(Event.start_date_time).gt_(datetime.datetime(2025, 3, 1))
-    & col(Event.ref_site).nested_(DescribableEntity.external_id == "STS-CLK")
-    & (Event.start_date_time < datetime.datetime(2025, 6, 1))
-)
-
+class WritableEvent(WritableViewInstance):
+    view_config = ViewInstanceConfig(
+        view_external_id="OEEEvent",
+        instance_spaces_prefix="OEE-",
+    )
 
-statement = select(Event).limit(50).where(filter)
+    start_date_time: datetime.datetime | None = None
+    ref_site: ReportingSite | None = None
+    ref_reporting_line: DescribableEntity | None = None
+    ref_oee_event_detail: Annotated[
+        list[EventDetail],
+        Field(default_factory=list, alias="refOEEEventDetail"),
+    ]
 
-result = [
-    item.model_dump(mode="json") for item in adapter.query_all_pages(statement)
-]
-print(len(result))
-json.dump(
-    result,
-    open("test.json", "w"),
-)
+    def edge_id_factory(
+        self, target_node: InstanceId, edge_type: InstanceId
+    ) -> InstanceId:
+        return InstanceId(
+            external_id=f"{self.external_id}-{target_node.external_id}-{edge_type.external_id}",
+            space=self.space,
+        )

industrial_model-0.1.10/tests/test_upsert_mapper.py

@@ -0,0 +1,39 @@
+import json
+
+from industrial_model.cognite_adapters.upsert_mapper import UpsertMapper
+from industrial_model.statements import select
+from tests.hubs import generate_engine
+from tests.models import EventDetail, WritableEvent
+
+if __name__ == "__main__":
+    engine = generate_engine()
+
+    view_mapper = engine._cognite_adapter._query_mapper._view_mapper
+
+    upsert_mapper = UpsertMapper(view_mapper)
+
+    statement = select(WritableEvent).limit(1)
+
+    item = engine.query(statement).data[0]
+
+    item.ref_oee_event_detail.clear()
+    item.ref_oee_event_detail.append(
+        EventDetail(external_id="test", space="test")
+    )
+
+    operation = upsert_mapper.map([item])
+
+    data = {
+        "nodes": [node.dump() for node in operation.nodes],
+        "edges": [edge.dump() for edge in operation.edges],
+        "edges_to_delete": [
+            edge_to_delete.model_dump(mode="json")
+            for edge_to_delete in operation.edges_to_delete
+        ],
+    }
+
+    json.dump(
+        data,
+        open("upsert.json", "w"),
+        indent=4,
+    )

industrial_model-0.1.10/tests/tests_adapter.py

@@ -0,0 +1,27 @@
+import datetime
+import json
+
+from industrial_model import col, select
+
+from .hubs import generate_engine
+from .models import DescribableEntity, Event
+
+if __name__ == "__main__":
+    adapter = generate_engine()
+
+    filter = (
+        col(Event.start_date_time).gt_(datetime.datetime(2025, 3, 1))
+        & col(Event.ref_site).nested_(
+            DescribableEntity.external_id == "STS-CLK"
+        )
+        & (col(Event.start_date_time) < datetime.datetime(2025, 6, 1))
+    )
+
+    statement = select(Event).limit(50).where(filter)
+
+    result = [
+        item.model_dump(mode="json")
+        for item in adapter.query_all_pages(statement)
+    ]
+    print(len(result))
+    json.dump(result, open("entities.json", "w"), indent=2)

{industrial_model-0.1.8 → industrial_model-0.1.10}/uv.lock

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

industrial_model-0.1.8/scripts/format.sh

@@ -1,2 +0,0 @@
-ruff check industrial_model --fix
-ruff format industrial_model 

industrial_model-0.1.8/scripts/lint.sh

@@ -1,3 +0,0 @@
-mypy industrial_model
-ruff check industrial_model
-ruff format industrial_model  --check