industrial-model 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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.dist-info → industrial_model-0.1.10.dist-info}/METADATA

@@ -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.dist-info → industrial_model-0.1.10.dist-info}/RECORD

@@ -1,28 +1,30 @@
-industrial_model/__init__.py,sha256=qst1HvSXw7ytYTvi_hgg8989rSqKXF3n_8jv3wO73x8,525
+industrial_model/__init__.py,sha256=LJRHjaQvFZC-rvDubXvI9VaM9me0fqi4DG2mC0pEzC0,635
 industrial_model/config.py,sha256=wzSKVKHIdGlxCRtu0PIeL3SLYvnQBR4Py46CcETxa8U,238
 industrial_model/constants.py,sha256=wtFdxkR9gojqekwXeyVCof6VUkJYuqjjgAgVVKrcxaw,450
 industrial_model/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-industrial_model/utils.py,sha256=OuuAkIqu-551axsZJPuqHu5d9iReGcfY9ROBFtHIwkY,933
-industrial_model/cognite_adapters/__init__.py,sha256=SjI-cO8tsZpd1uBSyP6nt3WvWbMHnWzf3v1X5oDTNvw,3436
+industrial_model/utils.py,sha256=oh4AxwxXaWgIC2uolkCbvkgo0ququHB6yAPVIXy45Ts,663
+industrial_model/cognite_adapters/__init__.py,sha256=xRLmfPctoEvjRiXqD9Nd_e0uwDD_2VrsvjG-aJXmuR0,4658
 industrial_model/cognite_adapters/filter_mapper.py,sha256=NqH-OW7_iKFY9POCG8W3KjkwXUgrZP1d_yxDx1J0fXM,3859
+industrial_model/cognite_adapters/models.py,sha256=2j2IS01uPkQEp9WdVk8seYzEqGcDdWFnpzXhusHB2zk,945
 industrial_model/cognite_adapters/optimizer.py,sha256=G8I07jJ9tarE5GZXXUSpTMKUei6ptV-cudJSLsoykX4,2223
 industrial_model/cognite_adapters/query_mapper.py,sha256=3fEcaLsGjLKIh-g1BbMcffQ6rp99JeCW555iJo8JW44,6260
-industrial_model/cognite_adapters/query_result_mapper.py,sha256=SRlqGSfsF5JaPXTAa0bXsRbTonZnrO5ZxlcdVrA20P4,7156
+industrial_model/cognite_adapters/query_result_mapper.py,sha256=lsKz0wiqMOo54MVEw_YqLcHXa_HWYgAbSLnBbbdVupw,8451
 industrial_model/cognite_adapters/sort_mapper.py,sha256=RJUAYlZGXoYzK0PwX63cibRF_L-MUq9g2ZsC2EeNIF4,696
+industrial_model/cognite_adapters/upsert_mapper.py,sha256=tWEiBJQeeNz1HDu0AoBIfCw_LL156Zg4h7ORKlZ__uw,4870
 industrial_model/cognite_adapters/utils.py,sha256=rztCtS10ZTQmXfBv0nLgDiQIMWemhdSFK-SwrbRjVxM,4792
 industrial_model/cognite_adapters/view_mapper.py,sha256=lnv64KezSQTAr6XdcExa8d92GU5Ll9K9HfMcQGzhX6k,488
 industrial_model/engines/__init__.py,sha256=7aGHrUm2MxIq39vR8h0xu3i1zNOuT9H9U-q4lV3nErQ,102
-industrial_model/engines/async_engine.py,sha256=3Y4Ao14CDJJAZFbgTX9I6LOJUxfe8nwOOukGVeiw914,1070
-industrial_model/engines/engine.py,sha256=8-wfktRLZpad_V7_F1Vz7vtjE_bQhga_jXXjuwSgfrE,1897
-industrial_model/models/__init__.py,sha256=q2cI-WutiT-gmRlwC5CnacWqtQo0oSIr7Ohn9hK9jes,474
+industrial_model/engines/async_engine.py,sha256=jnNGBVoD0xL52UEOZ2SzTU3Eogx_EJQXklPJu22iN0I,1325
+industrial_model/engines/engine.py,sha256=J7JlTN0V8H259Aidh7RkBc34UK04J5iTEsWLSHV-hzg,2834
+industrial_model/models/__init__.py,sha256=TVlMUoK7IThiZmH9CYe0pSqfJfVJ4-DmG9vFdUILKtU,624
 industrial_model/models/base.py,sha256=jbiaICJ0R1mmxXtDqxxlVdq-tTX4RLdqnLTgs9HLm_4,1279
-industrial_model/models/entities.py,sha256=NrFV_a3ZP6Y4b1M2PFl_746qcCsexsyO2cuB0snZhkw,1319
+industrial_model/models/entities.py,sha256=iLZ4gYGPlNCQJ33s0d6TenjMFuCR8TsvQPEpRAhzvlQ,2378
 industrial_model/models/schemas.py,sha256=LKNPDnUy1jtMyOHDf28En9vThhdzOSswewIcjC_y-6U,4393
 industrial_model/queries/__init__.py,sha256=7aheTE5qs03rxWm9fmGWptbz_p9OIXXYD8if56cqs18,227
 industrial_model/queries/models.py,sha256=iiHQ7-cfg0nukEv5PoCx9QPF-w1gVSnoNbXBOK9Mzeo,1185
 industrial_model/queries/params.py,sha256=ehgCoR5n6E-tkEuoymZ2lkLcSzMaBAx_HnyJ7sWpqz0,964
 industrial_model/statements/__init__.py,sha256=9fD-qpNXIkrjoahxC_R6hS4DKSVelehimvRPKbpYfA0,1775
 industrial_model/statements/expressions.py,sha256=Sar1cIvy3sYi7tkWJN3ylHlZ252oN2mZJpZ1TX9jN3s,4940
-industrial_model-0.1.8.dist-info/METADATA,sha256=2qsQk_WtDH_QVjdhAEFESXIwv-BF5q-L_NRNLVz1pXA,4806
-industrial_model-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-industrial_model-0.1.8.dist-info/RECORD,,
+industrial_model-0.1.10.dist-info/METADATA,sha256=o0eF-e97Jrv_Z5e55btU-7jmfeZ5q-025Yy4H-isGVM,5698
+industrial_model-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+industrial_model-0.1.10.dist-info/RECORD,,