industrial-model 0.1.21__tar.gz → 0.1.22__tar.gz

{industrial_model-0.1.21 → industrial_model-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: industrial-model
-Version: 0.1.21
+Version: 0.1.22
 Summary: Industrial Model ORM
 Author-email: Lucas Alves <lucasrosaalves@gmail.com>
 Classifier: Programming Language :: Python
@@ -63,6 +63,7 @@ from industrial_model import (
     col,
     or_,
     select,
+    search,
 )
 
 # Define entities (view instances)
@@ -245,6 +246,25 @@ person = engine.query_all_pages(statement)[0]
 
 engine.delete([person])
 
+
+# 10. Search
+
+#  Notes:
+#     External ID searches work as prefix searches.
+#     This method does not include edges or direct relations in the result model.
+#     Filter does not support nested properties.
+
+class Entity(ViewInstance):
+    view_config = ViewInstanceConfig(
+        view_external_id="Person"
+    )
+    name: str
+
+
+statement = search(Entity).query_by("Lucas", [Entity.name])
+person = engine.search(statement)
+
+
 ```
 
 ---

{industrial_model-0.1.21 → industrial_model-0.1.22}/README.md

@@ -43,6 +43,7 @@ from industrial_model import (
     col,
     or_,
     select,
+    search,
 )
 
 # Define entities (view instances)
@@ -225,6 +226,25 @@ person = engine.query_all_pages(statement)[0]
 
 engine.delete([person])
 
+
+# 10. Search
+
+#  Notes:
+#     External ID searches work as prefix searches.
+#     This method does not include edges or direct relations in the result model.
+#     Filter does not support nested properties.
+
+class Entity(ViewInstance):
+    view_config = ViewInstanceConfig(
+        view_external_id="Person"
+    )
+    name: str
+
+
+statement = search(Entity).query_by("Lucas", [Entity.name])
+person = engine.search(statement)
+
+
 ```
 
 ---

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/__init__.py

@@ -13,7 +13,7 @@ from .models import (
     ViewInstanceConfig,
     WritableViewInstance,
 )
-from .statements import aggregate, and_, col, not_, or_, select
+from .statements import aggregate, and_, col, not_, or_, search, select
 
 __all__ = [
     "aggregate",
@@ -23,6 +23,7 @@ __all__ = [
     "col",
     "not_",
     "select",
+    "search",
     "ViewInstance",
     "InstanceId",
     "TViewInstance",

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/__init__.py

@@ -16,7 +16,11 @@ from industrial_model.models import (
     TViewInstance,
     TWritableViewInstance,
 )
-from industrial_model.statements import AggregationStatement, Statement
+from industrial_model.statements import (
+    AggregationStatement,
+    SearchStatement,
+    Statement,
+)
 
 from .aggregation_mapper import AggregationMapper
 from .optimizer import QueryOptimizer
@@ -24,6 +28,7 @@ from .query_mapper import QueryMapper
 from .query_result_mapper import (
     QueryResultMapper,
 )
+from .search_mapper import SearchMapper
 from .upsert_mapper import UpsertMapper
 from .utils import (
     append_nodes_and_edges,
@@ -34,9 +39,7 @@ from .view_mapper import ViewMapper
 
 
 class CogniteAdapter:
-    def __init__(
-        self, cognite_client: CogniteClient, data_model_id: DataModelId
-    ):
+    def __init__(self, cognite_client: CogniteClient, data_model_id: DataModelId):
         self._cognite_client = cognite_client
 
         view_mapper = ViewMapper(cognite_client, data_model_id)
@@ -45,6 +48,20 @@ class CogniteAdapter:
         self._result_mapper = QueryResultMapper(view_mapper)
         self._upsert_mapper = UpsertMapper(view_mapper)
         self._aggregation_mapper = AggregationMapper(view_mapper)
+        self._search_mapper = SearchMapper(view_mapper)
+
+    def search(self, statement: SearchStatement[TViewInstance]) -> list[dict[str, Any]]:
+        search_query = self._search_mapper.map(statement)
+        data = self._cognite_client.data_modeling.instances.search(
+            view=search_query.view.as_id(),
+            query=search_query.query,
+            filter=search_query.filter,
+            properties=search_query.query_properties,
+            limit=search_query.limit,
+            sort=search_query.sort,
+        )
+
+        return self._result_mapper.nodes_to_dict(data)
 
     def query(
         self, statement: Statement[TViewInstance], all_pages: bool
@@ -111,18 +128,14 @@ class CogniteAdapter:
         operation = self._upsert_mapper.map(entries)
 
         for node_chunk in operation.chunk_nodes():
-            logger.debug(
-                f"Upserting {len(node_chunk)} nodes (replace={replace})"
-            )
+            logger.debug(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.debug(
-                f"Upserting {len(edge_chunk)} edges (replace={replace})"
-            )
+            logger.debug(f"Upserting {len(edge_chunk)} edges (replace={replace})")
             self._cognite_client.data_modeling.instances.apply(
                 edges=edge_chunk,
                 replace=replace,
@@ -151,9 +164,7 @@ class CogniteAdapter:
         if not new_query:
             return None
 
-        new_query_result = self._cognite_client.data_modeling.instances.query(
-            new_query
-        )
+        new_query_result = self._cognite_client.data_modeling.instances.query(new_query)
 
         result = map_nodes_and_edges(new_query_result, new_query)
 

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/aggregation_mapper.py

@@ -44,9 +44,7 @@ class AggregationMapper:
         root_view = self._view_mapper.get_view(root_node)
 
         filters_ = (
-            filters.And(
-                *self._filter_mapper.map(statement.where_clauses, root_view)
-            )
+            filters.And(*self._filter_mapper.map(statement.where_clauses, root_view))
             if statement.where_clauses
             else None
         )
@@ -63,9 +61,7 @@ class AggregationMapper:
             metric_aggregation = Count(statement.aggregation_property.property)
 
         if metric_aggregation is None:
-            raise ValueError(
-                f"Unsupported aggregate function: {statement.aggregate_}"
-            )
+            raise ValueError(f"Unsupported aggregate function: {statement.aggregate_}")
         return AggregationQuery(
             view=root_view,
             metric_aggregation=metric_aggregation,

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/filter_mapper.py

@@ -73,9 +73,7 @@ class FilterMapper:
         elif expression.operator == "<=":
             return cdf_filters.Range(property_ref, lte=value_)
         elif expression.operator == "nested":
-            target_view = self._get_nested_target_view(
-                expression.property, root_view
-            )
+            target_view = self._get_nested_target_view(expression.property, root_view)
 
             assert isinstance(value_, Expression)
 
@@ -91,9 +89,7 @@ class FilterMapper:
             return cdf_filters.ContainsAll(property_ref, value_)
         elif expression.operator == "containsAny":
             return cdf_filters.ContainsAny(property_ref, value_)
-        raise NotImplementedError(
-            f"Operator {expression.operator} not implemented"
-        )
+        raise NotImplementedError(f"Operator {expression.operator} not implemented")
 
     def _get_nested_target_view(self, property: str, root_view: View) -> View:
         view_definiton = root_view.properties[property]

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/optimizer.py

@@ -16,9 +16,7 @@ SPACE_PROPERTY = "space"
 
 
 class QueryOptimizer:
-    def __init__(
-        self, cognite_client: CogniteClient, data_model_id: DataModelId
-    ):
+    def __init__(self, cognite_client: CogniteClient, data_model_id: DataModelId):
         self._all_spaces = data_model_id.instance_spaces
         self._cognite_client = cognite_client
         self._lock = Lock()
@@ -36,9 +34,7 @@ class QueryOptimizer:
             return
 
         filter_spaces = (
-            self._find_spaces(instance_spaces_prefix)
-            if instance_spaces_prefix
-            else []
+            self._find_spaces(instance_spaces_prefix) if instance_spaces_prefix else []
         )
         if instance_spaces:
             filter_spaces.extend(instance_spaces)
@@ -48,9 +44,9 @@ class QueryOptimizer:
 
     def _has_space_filter(self, where_clauses: list[Expression]) -> bool:
         for where_clause in where_clauses:
-            if isinstance(
-                where_clause, BoolExpression
-            ) and self._has_space_filter(where_clause.filters):
+            if isinstance(where_clause, BoolExpression) and self._has_space_filter(
+                where_clause.filters
+            ):
                 return True
             elif (
                 isinstance(where_clause, LeafExpression)
@@ -64,9 +60,7 @@ class QueryOptimizer:
         all_spaces = self._load_spaces()
 
         return [
-            space
-            for space in all_spaces
-            if space.startswith(instance_spaces_prefix)
+            space for space in all_spaces if space.startswith(instance_spaces_prefix)
         ]
 
     def _load_spaces(self) -> list[str]:

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/query_mapper.py

@@ -43,13 +43,9 @@ class QueryMapper:
         root_view = self._view_mapper.get_view(root_node)
         root_view_id = root_view.as_id()
 
-        filters_: list[filters.Filter] = [
-            filters.HasData(views=[root_view_id])
-        ]
+        filters_: list[filters.Filter] = [filters.HasData(views=[root_view_id])]
 
-        filters_.extend(
-            self._filter_mapper.map(statement.where_clauses, root_view)
-        )
+        filters_.extend(self._filter_mapper.map(statement.where_clauses, root_view))
 
         with_: dict[str, ResultSetExpression] = {
             root_node: NodeResultSetExpression(
@@ -60,9 +56,7 @@ class QueryMapper:
         }
         select_: dict[str, Select] = {}
 
-        relations = get_schema_properties(
-            statement.entity, NESTED_SEP, root_node
-        )
+        relations = get_schema_properties(statement.entity, NESTED_SEP, root_node)
 
         properties = self._include_statements(
             root_node, root_view, relations, with_, select_
@@ -76,9 +70,7 @@ class QueryMapper:
 
     def _get_select(self, view_id: ViewId, properties: list[str]) -> Select:
         return (
-            Select(
-                sources=[SourceSelector(source=view_id, properties=properties)]
-            )
+            Select(sources=[SourceSelector(source=view_id, properties=properties)])
             if properties
             else Select()
         )
@@ -118,9 +110,7 @@ class QueryMapper:
                         through=view.as_property_ref(property_name),
                         limit=MAX_LIMIT,
                     )
-                    select_[property_key] = self._get_select(
-                        property.source, props
-                    )
+                    select_[property_key] = self._get_select(property.source, props)
 
             elif (
                 isinstance(property, MultiReverseDirectRelation)
@@ -138,27 +128,21 @@ class QueryMapper:
                 with_[property_key] = NodeResultSetExpression(
                     from_=key,
                     direction="inwards",
-                    through=property.source.as_property_ref(
-                        property.through.property
-                    ),
+                    through=property.source.as_property_ref(property.through.property),
                     limit=MAX_LIMIT,
                 )
 
                 if property.through.property not in props:
                     props.append(property.through.property)
 
-                select_[property_key] = self._get_select(
-                    property.source, props
-                )
+                select_[property_key] = self._get_select(property.source, props)
             elif isinstance(property, EdgeConnection) and property.source:
                 edge_property_key = f"{property_key}{NESTED_SEP}{EDGE_MARKER}"
 
                 with_[edge_property_key] = EdgeResultSetExpression(
                     from_=key,
                     max_distance=1,
-                    filter=filters.Equals(
-                        ["edge", "type"], property.type.dump()
-                    ),
+                    filter=filters.Equals(["edge", "type"], property.type.dump()),
                     direction=property.direction,
                     limit=MAX_LIMIT,
                 )
@@ -176,8 +160,6 @@ class QueryMapper:
                     with_,
                     select_,
                 )
-                select_[property_key] = self._get_select(
-                    property.source, props
-                )
+                select_[property_key] = self._get_select(property.source, props)
 
         return select_properties

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/query_result_mapper.py

@@ -7,6 +7,7 @@ from cognite.client.data_classes.data_modeling import (
     EdgeConnection,
     MappedProperty,
     Node,
+    NodeList,
     View,
 )
 from cognite.client.data_classes.data_modeling.views import (
@@ -41,9 +42,7 @@ class QueryResultMapper:
         self, root_node: str, query_result: dict[str, list[Node | Edge]]
     ) -> list[dict[str, Any]]:
         if root_node not in query_result:
-            raise ValueError(
-                f"{root_node} is not available in the query result"
-            )
+            raise ValueError(f"{root_node} is not available in the query result")
 
         root_view = self._view_mapper.get_view(root_node)
 
@@ -51,14 +50,13 @@ class QueryResultMapper:
         if not values:
             return []
 
-        data = [
-            node
-            for nodes in values.values()
-            for node in self._nodes_to_dict(nodes)
-        ]
+        data = [node for nodes in values.values() for node in self.nodes_to_dict(nodes)]
 
         return data
 
+    def nodes_to_dict(self, nodes: list[Node] | NodeList[Node]) -> list[dict[str, Any]]:
+        return [self._node_to_dict(node) for node in nodes]
+
     def _map_node_property(
         self,
         key: str,
@@ -79,9 +77,7 @@ class QueryResultMapper:
 
             entry = properties.get(result_property_key)
             if not isinstance(entry, dict):
-                raise ValueError(
-                    f"Invalid result property key {result_property_key}"
-                )
+                raise ValueError(f"Invalid result property key {result_property_key}")
 
             return entry.get("space", ""), entry.get("externalId", "")
 
@@ -124,15 +120,11 @@ class QueryResultMapper:
                 if not node_entries:
                     continue
 
-                entry_data = self._nodes_to_dict(node_entries)
-                properties[mapping_key] = (
-                    entry_data if is_list else entry_data[0]
-                )
+                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
-                    )
+                    edges_mapping[mapping_key] = self._edges_to_model(edge_entries)
             properties["_edges"] = edges_mapping
 
             node.properties[view_id] = properties
@@ -155,9 +147,7 @@ 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
-            )
+            connection_type: ConnectionTypeEnum = ConnectionTypeEnum.DIRECT_RELATION
 
             if isinstance(property, MappedProperty) and property.source:
                 nodes = self._map_node_property(
@@ -167,10 +157,7 @@ class QueryResultMapper:
                 )
                 is_list = False
                 connection_type = ConnectionTypeEnum.DIRECT_RELATION
-            elif (
-                isinstance(property, SingleReverseDirectRelation)
-                and property.source
-            ):
+            elif isinstance(property, SingleReverseDirectRelation) and property.source:
                 nodes = self._map_node_property(
                     property_key,
                     self._view_mapper.get_view(property.source.external_id),
@@ -179,10 +166,7 @@ class QueryResultMapper:
                 )
                 is_list = False
                 connection_type = ConnectionTypeEnum.REVERSE_DIRECT_RELATION
-            elif (
-                isinstance(property, MultiReverseDirectRelation)
-                and property.source
-            ):
+            elif isinstance(property, MultiReverseDirectRelation) and property.source:
                 nodes = self._map_node_property(
                     property_key,
                     self._view_mapper.get_view(property.source.external_id),
@@ -231,12 +215,8 @@ class QueryResultMapper:
             return None, None
 
         visited: set[tuple[str, str]] = set()
-        nodes_result: defaultdict[tuple[str, str], list[Node]] = defaultdict(
-            list
-        )
-        edges_result: defaultdict[tuple[str, str], list[Edge]] = 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:
@@ -257,17 +237,12 @@ class QueryResultMapper:
 
         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]]] = (
-            entry.pop("properties") or {}
-        )
+        properties: dict[str, dict[str, dict[str, Any]]] = entry.pop("properties") or {}
         for space_mapping in properties.values():
             for view_mapping in space_mapping.values():
                 entry.update(view_mapping)

industrial_model-0.1.22/industrial_model/cognite_adapters/search_mapper.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+
+import cognite.client.data_classes.filters as filters
+from cognite.client.data_classes.data_modeling import InstanceSort, View
+
+from industrial_model.models import TViewInstance
+from industrial_model.statements import SearchStatement
+
+from .filter_mapper import (
+    FilterMapper,
+)
+from .sort_mapper import SortMapper
+from .view_mapper import ViewMapper
+
+
+@dataclass
+class SearchQuery:
+    view: View
+    filter: filters.Filter | None
+    query: str | None
+    query_properties: list[str] | None
+    limit: int
+    sort: list[InstanceSort]
+
+
+class SearchMapper:
+    def __init__(self, view_mapper: ViewMapper):
+        self._view_mapper = view_mapper
+        self._filter_mapper = FilterMapper(view_mapper)
+        self._sort_mapper = SortMapper()
+
+    def map(self, statement: SearchStatement[TViewInstance]) -> SearchQuery:
+        root_node = statement.entity.get_view_external_id()
+
+        root_view = self._view_mapper.get_view(root_node)
+
+        filters_ = self._filter_mapper.map(statement.where_clauses, root_view)
+
+        sort_clauses = self._sort_mapper.map(statement.sort_clauses, root_view)
+        for item in sort_clauses:
+            item.nulls_first = None
+
+        return SearchQuery(
+            view=root_view,
+            filter=filters.And(*filters_) if filters_ else None,
+            query=statement.query,
+            query_properties=statement.query_properties,
+            limit=statement.limit_,
+            sort=sort_clauses,
+        )

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/upsert_mapper.py

@@ -31,19 +31,14 @@ class UpsertMapper:
         edges_to_delete: dict[tuple[str, str], EdgeContainer] = {}
 
         for instance in instances:
-            entry_nodes, entry_edges, entry_edges_to_delete = (
-                self._map_instance(instance)
+            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.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
-                }
+                {(item.space, item.external_id): item for item in entry_edges_to_delete}
             )
 
         return UpsertOperation(
@@ -76,9 +71,7 @@ class UpsertMapper:
                     if isinstance(entry, datetime.datetime)
                     else entry
                 )
-            elif isinstance(property, EdgeConnection) and isinstance(
-                entry, list
-            ):
+            elif isinstance(property, EdgeConnection) and isinstance(entry, list):
                 possible_entries = self._map_edges(instance, property, entry)
 
                 previous_edges = {
@@ -104,9 +97,7 @@ class UpsertMapper:
         node = NodeApply(
             external_id=instance.external_id,
             space=instance.space,
-            sources=[
-                NodeOrEdgeData(source=view.as_id(), properties=properties)
-            ],
+            sources=[NodeOrEdgeData(source=view.as_id(), properties=properties)],
         )
 
         return node, edges, edges_to_delete

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/utils.py

@@ -43,9 +43,7 @@ def get_property_ref(
 def get_cognite_instance_ids(
     instance_ids: list[TViewInstance],
 ) -> list[dict[str, str]]:
-    return [
-        get_cognite_instance_id(instance_id) for instance_id in instance_ids
-    ]
+    return [get_cognite_instance_id(instance_id) for instance_id in instance_ids]
 
 
 def get_cognite_instance_id(instance_id: TViewInstance) -> dict[str, str]:
@@ -115,9 +113,7 @@ def _create_query(
         valid_keys = parent.union(children)
         valid_keys.add(cursor_key)
 
-        with_.update(
-            {k: v for k, v in previous_query.with_.items() if k in valid_keys}
-        )
+        with_.update({k: v for k, v in previous_query.with_.items() if k in valid_keys})
         select_.update(
             {k: v for k, v in previous_query.select.items() if k in valid_keys}
         )

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/cognite_adapters/view_mapper.py

@@ -9,9 +9,7 @@ from industrial_model.config import DataModelId
 
 
 class ViewMapper:
-    def __init__(
-        self, cognite_client: CogniteClient, data_model_id: DataModelId
-    ):
+    def __init__(self, cognite_client: CogniteClient, data_model_id: DataModelId):
         self._cognite_client = cognite_client
         self._data_model_id = data_model_id
         self._views_as_dict: dict[str, View] | None = None
@@ -26,9 +24,7 @@ class ViewMapper:
     def get_view(self, view_external_id: str) -> View:
         views = self._load_views()
         if view_external_id not in views:
-            raise ValueError(
-                f"View {view_external_id} is not available in data model"
-            )
+            raise ValueError(f"View {view_external_id} is not available in data model")
 
         return views[view_external_id]
 

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/engines/async_engine.py

@@ -8,7 +8,11 @@ from industrial_model.models import (
     TWritableViewInstance,
     ValidationMode,
 )
-from industrial_model.statements import AggregationStatement, Statement
+from industrial_model.statements import (
+    AggregationStatement,
+    SearchStatement,
+    Statement,
+)
 from industrial_model.utils import run_async
 
 from .engine import Engine
@@ -22,6 +26,19 @@ class AsyncEngine:
     ):
         self._engine = Engine(cognite_client, data_model_id)
 
+    async def search_async(
+        self,
+        statement: SearchStatement[TViewInstance],
+        validation_mode: ValidationMode = "raiseOnError",
+    ) -> list[TViewInstance]:
+        """
+        Note:
+            External ID searches work as prefix searches.
+            This method does not include edges or direct relations in the result model.
+            Filter does not support nested properties.
+        """
+        return await run_async(self._engine.search, statement, validation_mode)
+
     async def query_async(
         self,
         statement: Statement[TViewInstance],
@@ -34,9 +51,7 @@ class AsyncEngine:
         statement: Statement[TViewInstance],
         validation_mode: ValidationMode = "raiseOnError",
     ) -> list[TViewInstance]:
-        return await run_async(
-            self._engine.query_all_pages, statement, validation_mode
-        )
+        return await run_async(self._engine.query_all_pages, statement, validation_mode)
 
     async def aggregate_async(
         self, statement: AggregationStatement[TAggregatedViewInstance]

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/engines/engine.py

@@ -12,7 +12,11 @@ from industrial_model.models import (
     TWritableViewInstance,
     ValidationMode,
 )
-from industrial_model.statements import AggregationStatement, Statement
+from industrial_model.statements import (
+    AggregationStatement,
+    SearchStatement,
+    Statement,
+)
 
 
 class Engine:
@@ -23,6 +27,20 @@ class Engine:
     ):
         self._cognite_adapter = CogniteAdapter(cognite_client, data_model_id)
 
+    def search(
+        self,
+        statement: SearchStatement[TViewInstance],
+        validation_mode: ValidationMode = "raiseOnError",
+    ) -> list[TViewInstance]:
+        """
+        Note:
+            External ID searches work as prefix searches.
+            This method does not include edges or direct relations in the result model.
+            Filter does not support nested properties.
+        """
+        data = self._cognite_adapter.search(statement)
+        return self._validate_data(statement.entity, data, validation_mode)
+
     def query(
         self,
         statement: Statement[TViewInstance],

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/models/entities.py

@@ -88,9 +88,7 @@ class AggregatedViewInstance(RootModel, metaclass=DBModelMetaclass):
 
 
 TViewInstance = TypeVar("TViewInstance", bound=ViewInstance)
-TWritableViewInstance = TypeVar(
-    "TWritableViewInstance", bound=WritableViewInstance
-)
+TWritableViewInstance = TypeVar("TWritableViewInstance", bound=WritableViewInstance)
 TAggregatedViewInstance = TypeVar(
     "TAggregatedViewInstance", bound=AggregatedViewInstance
 )

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/models/schemas.py

@@ -38,8 +38,7 @@ def get_parent_and_children_nodes(
     for key in keys:
         key_parts = key.split(NESTED_SEP)
         parent_paths = {
-            NESTED_SEP.join(key_parts[:i])
-            for i in range(len(key_parts) - 1, 0, -1)
+            NESTED_SEP.join(key_parts[:i]) for i in range(len(key_parts) - 1, 0, -1)
         }
 
         valid_paths: set[str] = set()
@@ -142,17 +141,13 @@ def _flatten_dict_keys(
 ) -> list[str]:
     paths: set[str] = set()
     for key, value in data.items():
-        full_key = (
-            f"{parent_key}{nested_separator}{key}" if parent_key else key
-        )
+        full_key = f"{parent_key}{nested_separator}{key}" if parent_key else key
         paths.add(full_key)
         if isinstance(value, dict) and value:
             paths.update(_flatten_dict_keys(value, full_key, nested_separator))
         elif isinstance(value, str):
             paths.add(f"{full_key}{nested_separator}{value}")
         elif isinstance(value, list | set):
-            paths.update(
-                [f"{full_key}{nested_separator}{item}" for item in value]
-            )
+            paths.update([f"{full_key}{nested_separator}{item}" for item in value])
 
     return sorted(paths)

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/queries/models.py

@@ -5,9 +5,7 @@ from .params import NestedQueryParam, QueryParam, SortParam
 
 
 class BaseQuery(RootModel):
-    def to_statement(
-        self, entity: type[TViewInstance]
-    ) -> Statement[TViewInstance]:
+    def to_statement(self, entity: type[TViewInstance]) -> Statement[TViewInstance]:
         statement = Statement(entity)
 
         for key, item in self.__class__.model_fields.items():
@@ -27,9 +25,7 @@ class BasePaginatedQuery(BaseQuery):
     limit: int = 1000
     cursor: str | None = None
 
-    def to_statement(
-        self, entity: type[TViewInstance]
-    ) -> Statement[TViewInstance]:
+    def to_statement(self, entity: type[TViewInstance]) -> Statement[TViewInstance]:
         statement = super().to_statement(entity)
         statement.limit(self.limit)
         statement.cursor(self.cursor)

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/statements/__init__.py

@@ -15,6 +15,7 @@ from .expressions import (
 )
 
 T = TypeVar("T")
+AggregateTypes = Literal["count", "avg", "min", "max", "sum"]
 
 
 def _create_column(property: str | Column | Any) -> Column:
@@ -22,14 +23,13 @@ def _create_column(property: str | Column | Any) -> Column:
 
 
 @dataclass
-class Statement(Generic[T]):
+class BaseStatement(Generic[T]):
     entity: type[T] = field(init=True)
     where_clauses: list[Expression] = field(init=False, default_factory=list)
     sort_clauses: list[tuple[Column, SORT_DIRECTION]] = field(
         init=False, default_factory=list
     )
     limit_: int = field(init=False, default=DEFAULT_LIMIT)
-    cursor_: str | None = field(init=False, default=None)
 
     def where(self, *expressions: bool | Expression) -> Self:
         for expression in expressions:
@@ -37,15 +37,17 @@ class Statement(Generic[T]):
             self.where_clauses.append(expression)
         return self
 
+    def limit(self, limit: int) -> Self:
+        self.limit_ = limit
+        return self
+
     def asc(self, property: str | Column | Any) -> Self:
         return self.sort(property, "ascending")
 
     def desc(self, property: str | Column | Any) -> Self:
         return self.sort(property, "descending")
 
-    def sort(
-        self, property: str | Column | Any, direction: SORT_DIRECTION
-    ) -> Self:
+    def sort(self, property: str | Column | Any, direction: SORT_DIRECTION) -> Self:
         self.sort_clauses.append(
             (
                 _create_column(property),
@@ -54,16 +56,40 @@ class Statement(Generic[T]):
         )
         return self
 
-    def limit(self, limit: int) -> Self:
-        self.limit_ = limit
-        return self
+
+@dataclass
+class Statement(BaseStatement[T]):
+    cursor_: str | None = field(init=False, default=None)
 
     def cursor(self, cursor: str | None) -> Self:
         self.cursor_ = cursor
         return self
 
 
-AggregateTypes = Literal["count", "avg", "min", "max", "sum"]
+@dataclass
+class SearchStatement(BaseStatement[T]):
+    query: str | None = field(init=False, default=None)
+    query_properties: list[str] | None = field(init=False, default=None)
+
+    def query_by(
+        self,
+        query: str,
+        query_properties: list[Column | str | Any] | None = None,
+    ) -> Self:
+        self.query = query
+        self.query_properties = (
+            [
+                prop
+                if isinstance(prop, str)
+                else prop.property
+                if isinstance(prop, Column)
+                else str(prop)
+                for prop in query_properties
+            ]
+            if query_properties
+            else None
+        )
+        return self
 
 
 @dataclass
@@ -71,9 +97,7 @@ class AggregationStatement(Generic[T]):
     entity: type[T] = field(init=True)
     aggregate: AggregateTypes = field(init=True)
 
-    aggregation_property: Column = field(
-        init=False, default=Column("externalId")
-    )
+    aggregation_property: Column = field(init=False, default=Column("externalId"))
     where_clauses: list[Expression] = field(init=False, default_factory=list)
     limit_: int = field(init=False, default=-1)
 
@@ -103,11 +127,17 @@ def aggregate(
     return AggregationStatement(entity=entity, aggregate=aggregate)
 
 
+def search(entity: type[T]) -> SearchStatement[T]:
+    return SearchStatement(entity)
+
+
 __all__ = [
     "aggregate",
     "AggregationStatement",
     "Statement",
     "select",
+    "search",
+    "SearchStatement",
     "Column",
     "col",
     "Expression",

{industrial_model-0.1.21 → industrial_model-0.1.22}/industrial_model/statements/expressions.py

@@ -9,9 +9,7 @@ from industrial_model.constants import (
 )
 
 RANGE_SUPPORTED_VALUES = str | int | float
-LIST_SUPPORTED_VALUES = (
-    list[str] | list[int] | list[float] | list[dict[str, str]]
-)
+LIST_SUPPORTED_VALUES = list[str] | list[int] | list[float] | list[dict[str, str]]
 SUPPORTED_VALUES = (
     RANGE_SUPPORTED_VALUES | bool | dict[str, str] | LIST_SUPPORTED_VALUES
 )
@@ -49,9 +47,7 @@ class LeafExpression(Expression):
 class Column:
     def __init__(self, property: Any):
         assert isinstance(property, str | Column)
-        property_ = (
-            property.property if isinstance(property, Column) else property
-        )
+        property_ = property.property if isinstance(property, Column) else property
         self.property: str = property_
 
     def __hash__(self) -> int:
@@ -120,23 +116,17 @@ class Column:
             filters=[self._compare(operator, other)],  # type: ignore
         )
 
-    def nested_(
-        self, expression: bool | LeafExpression | BoolExpression
-    ) -> bool:
+    def nested_(self, expression: bool | LeafExpression | BoolExpression) -> bool:
         if not isinstance(expression, Expression):
             raise ValueError("Invalid expression")
 
         return self._compare("nested", expression)
 
-    def _compare(
-        self, operator: LEAF_EXPRESSION_OPERATORS, value: Any
-    ) -> bool:
+    def _compare(self, operator: LEAF_EXPRESSION_OPERATORS, value: Any) -> bool:
         if isinstance(value, Column):
             raise ValueError("can not compare two columns in a graphdb")
 
-        return LeafExpression(
-            property=self.property, operator=operator, value=value
-        )  # type: ignore
+        return LeafExpression(property=self.property, operator=operator, value=value)  # type: ignore
 
 
 def _unwrap_expressions(
@@ -150,21 +140,15 @@ def _unwrap_expressions(
 
 
 def and_(*expressions: bool | LeafExpression | BoolExpression) -> bool:
-    return BoolExpression(
-        operator="and", filters=_unwrap_expressions(*expressions)
-    )  # type: ignore
+    return BoolExpression(operator="and", filters=_unwrap_expressions(*expressions))  # type: ignore
 
 
 def or_(*expressions: bool | LeafExpression | BoolExpression) -> bool:
-    return BoolExpression(
-        operator="or", filters=_unwrap_expressions(*expressions)
-    )  # type: ignore
+    return BoolExpression(operator="or", filters=_unwrap_expressions(*expressions))  # type: ignore
 
 
 def not_(*expressions: bool | LeafExpression | BoolExpression) -> bool:
-    return BoolExpression(
-        operator="not", filters=_unwrap_expressions(*expressions)
-    )  # type: ignore
+    return BoolExpression(operator="not", filters=_unwrap_expressions(*expressions))  # type: ignore
 
 
 def col(property: Any) -> Column:

{industrial_model-0.1.21 → industrial_model-0.1.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "industrial-model"
-version = "0.1.21"
+version = "0.1.22"
 description = "Industrial Model ORM"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -36,7 +36,7 @@ dev-dependencies = [
 strict = true
 
 [tool.ruff]
-line-length = 79
+line-length = 88
 
 [tool.ruff.lint]
 select = [

{industrial_model-0.1.21 → industrial_model-0.1.22}/tests/hubs.py

@@ -15,8 +15,7 @@ def generate_config(
 ) -> dict[str, dict[str, Any]]:
     load_dotenv(override=True)
     file_path = Path(
-        config_file_path
-        or f"{os.path.dirname(__file__)}/cognite-sdk-config.yaml"
+        config_file_path or f"{os.path.dirname(__file__)}/cognite-sdk-config.yaml"
     )
     env_sub_template = Template(file_path.read_text())
     file_env_parsed = env_sub_template.substitute(dict(os.environ))

{industrial_model-0.1.21 → industrial_model-0.1.22}/tests/models.py

@@ -52,6 +52,14 @@ class Event(ViewInstance):
     ]
 
 
+class SearchEvent(ViewInstance):
+    view_config = ViewInstanceConfig(view_external_id="OEEEvent")
+
+    start_date_time: datetime.datetime
+    event_definition: str
+    ref_site: InstanceId
+
+
 class Msdp(ViewInstance):
     view_config = ViewInstanceConfig(
         view_external_id="OEEMSDP",

{industrial_model-0.1.21 → industrial_model-0.1.22}/tests/test_schema.py

@@ -29,9 +29,7 @@ class SuperNestedModel(DescribableEntity):
 def test_get_schema_properties() -> None:
     for entity, expected_schema in _get_test_schema().items():
         schema = get_schema_properties(entity, SEP)
-        assert schema == expected_schema, (
-            f"Expected {expected_schema}, got {schema}"
-        )
+        assert schema == expected_schema, f"Expected {expected_schema}, got {schema}"
 
 
 def _get_test_schema() -> dict[type[BaseModel], list[str]]:

industrial_model-0.1.22/tests/tests_adapter.py

@@ -0,0 +1,42 @@
+import datetime
+import json
+
+from industrial_model import col, select
+
+from .hubs import generate_engine
+from .models import DescribableEntity, Event, Msdp
+
+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(100).where(filter).asc(Event.start_date_time)
+
+    result = [
+        item.model_dump(mode="json") for item in adapter.query_all_pages(statement)
+    ]
+    print(len(result))
+    json.dump(result, open("events.json", "w"), indent=2)
+
+    result_paginated = adapter.query(statement)
+    print(len(result_paginated.data))
+    json.dump(
+        result_paginated.model_dump(mode="json"),
+        open("events_paginated.json", "w"),
+        indent=2,
+    )
+
+    statement_msdp = (
+        select(Msdp).limit(2500).where(Msdp.effective_date >= datetime.date(2022, 5, 1))
+    )
+
+    result_msdp = [
+        item.model_dump(mode="json") for item in adapter.query_all_pages(statement_msdp)
+    ]
+    print(len(result_msdp))
+    json.dump(result_msdp, open("msdp.json", "w"), indent=2)

industrial_model-0.1.22/tests/tests_search.py

@@ -0,0 +1,28 @@
+import datetime
+import json
+
+from industrial_model import col, search
+
+from .hubs import generate_engine
+from .models import Event, SearchEvent
+
+if __name__ == "__main__":
+    adapter = generate_engine()
+
+    filter = col(SearchEvent.start_date_time).gt_(datetime.datetime(2025, 3, 1)) & (
+        col(SearchEvent.start_date_time) < datetime.datetime(2025, 6, 1)
+    )
+
+    statement = (
+        search(SearchEvent)
+        .limit(-1)
+        .where(filter)
+        .desc(Event.start_date_time)
+        .query_by("not runn", [SearchEvent.event_definition])
+    )
+
+    items = adapter.search(statement)
+
+    result = [item.model_dump(mode="json") for item in items]
+    print(len(result))
+    json.dump(result, open("search.json", "w"), indent=2)

{industrial_model-0.1.21 → industrial_model-0.1.22}/tests/tests_upsert_mapper.py

@@ -17,9 +17,7 @@ if __name__ == "__main__":
     item = engine.query(statement).data[0]
 
     item.ref_oee_event_detail.clear()
-    item.ref_oee_event_detail.append(
-        EventDetail(external_id="test", space="test")
-    )
+    item.ref_oee_event_detail.append(EventDetail(external_id="test", space="test"))
 
     operation = upsert_mapper.map([item])
 

{industrial_model-0.1.21 → industrial_model-0.1.22}/uv.lock

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

industrial_model-0.1.21/tests/tests_adapter.py

@@ -1,42 +0,0 @@
-import datetime
-import json
-
-from industrial_model import col, select
-
-from .hubs import generate_engine
-from .models import DescribableEntity, Event, Msdp
-
-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(2500).where(filter).asc(Event.start_date_time)
-    )
-
-    result = [
-        item.model_dump(mode="json")
-        for item in adapter.query_all_pages(statement)
-    ]
-    print(len(result))
-    json.dump(result, open("events.json", "w"), indent=2)
-
-    statement_msdp = (
-        select(Msdp)
-        .limit(2500)
-        .where(Msdp.effective_date >= datetime.date(2022, 5, 1))
-    )
-
-    result_msdp = [
-        item.model_dump(mode="json")
-        for item in adapter.query_all_pages(statement_msdp)
-    ]
-    print(len(result_msdp))
-    json.dump(result_msdp, open("msdp.json", "w"), indent=2)