industrial-model 0.1.32__py3-none-any.whl → 0.1.34__py3-none-any.whl

industrial_model/cognite_adapters/__init__.py

@@ -92,7 +92,9 @@ class CogniteAdapter:
             next_cursor = query_result.cursors.get(view_external_id)
             data.extend(page_result)
 
-            last_page = len(page_result) < statement.limit_ or not next_cursor
+            last_page = (
+                len(page_result) < statement.get_values().limit or not next_cursor
+            )
             next_cursor_ = None if last_page else next_cursor
             cognite_query.cursors = {view_external_id: next_cursor_}
 

industrial_model/cognite_adapters/aggregation_mapper.py

@@ -43,29 +43,33 @@ class AggregationMapper:
 
         root_view = self._view_mapper.get_view(root_node)
 
+        statement_values = statement.get_values()
         filters_ = (
-            filters.And(*self._filter_mapper.map(statement.where_clauses, root_view))
-            if statement.where_clauses
+            filters.And(
+                *self._filter_mapper.map(statement_values.where_clauses, root_view)
+            )
+            if statement_values.where_clauses
             else None
         )
+        aggregation_property = statement_values.aggregation_property.property
         metric_aggregation: MetricAggregation | None = None
         if statement.aggregate == "avg":
-            metric_aggregation = Avg(statement.aggregation_property.property)
+            metric_aggregation = Avg(aggregation_property)
         elif statement.aggregate == "min":
-            metric_aggregation = Min(statement.aggregation_property.property)
+            metric_aggregation = Min(aggregation_property)
         elif statement.aggregate == "max":
-            metric_aggregation = Max(statement.aggregation_property.property)
+            metric_aggregation = Max(aggregation_property)
         elif statement.aggregate == "sum":
-            metric_aggregation = Sum(statement.aggregation_property.property)
+            metric_aggregation = Sum(aggregation_property)
         elif statement.aggregate == "count":
-            metric_aggregation = Count(statement.aggregation_property.property)
+            metric_aggregation = Count(aggregation_property)
 
         if metric_aggregation is None:
-            raise ValueError(f"Unsupported aggregate function: {statement.aggregate_}")
+            raise ValueError(f"Unsupported aggregate function: {statement.aggregate}")
 
         group_by_columns = (
-            [prop.property for prop in statement.group_by_properties]
-            if statement.group_by_properties is not None
+            [prop.property for prop in statement_values.group_by_properties]
+            if statement_values.group_by_properties is not None
             else statement.entity.get_group_by_fields()
         )
         return AggregationQuery(
@@ -73,5 +77,5 @@ class AggregationMapper:
             metric_aggregation=metric_aggregation,
             filters=filters_,
             group_by_columns=group_by_columns,
-            limit=statement.limit_,
+            limit=statement_values.limit,
         )

industrial_model/cognite_adapters/filter_mapper.py

@@ -12,10 +12,10 @@ from industrial_model.cognite_adapters.utils import get_property_ref
 from industrial_model.models.entities import InstanceId
 from industrial_model.statements import (
     BoolExpression,
+    Column,
     Expression,
     LeafExpression,
 )
-from industrial_model.statements.expressions import Column
 from industrial_model.utils import datetime_to_ms_iso_timestamp
 
 from .view_mapper import ViewMapper

industrial_model/cognite_adapters/optimizer.py

@@ -30,7 +30,7 @@ class QueryOptimizer:
         if not instance_spaces and not instance_spaces_prefix:
             return
 
-        if self._has_space_filter(statement.where_clauses):
+        if self._has_space_filter(statement.get_values().where_clauses):
             return
 
         filter_spaces = (

industrial_model/cognite_adapters/query_mapper.py

@@ -45,13 +45,16 @@ class QueryMapper:
 
         filters_: list[filters.Filter] = [filters.HasData(views=[root_view_id])]
 
-        filters_.extend(self._filter_mapper.map(statement.where_clauses, root_view))
+        statement_values = statement.get_values()
+        filters_.extend(
+            self._filter_mapper.map(statement_values.where_clauses, root_view)
+        )
 
         with_: dict[str, ResultSetExpression] = {
             root_node: NodeResultSetExpression(
                 filter=filters.And(*filters_),
-                sort=self._sort_mapper.map(statement.sort_clauses, root_view),
-                limit=statement.limit_,
+                sort=self._sort_mapper.map(statement_values.sort_clauses, root_view),
+                limit=statement_values.limit,
             )
         }
         select_: dict[str, Select] = {}
@@ -59,7 +62,7 @@ class QueryMapper:
         relations = get_schema_properties(statement.entity, NESTED_SEP, root_node)
 
         edge_filters = self._filter_mapper.map_edges(
-            statement.where_edge_clauses, root_view, NESTED_SEP
+            statement_values.where_edge_clauses, root_view, NESTED_SEP
         )
 
         properties = self._include_statements(
@@ -69,7 +72,9 @@ class QueryMapper:
         select_[root_node] = self._get_select(root_view_id, properties)
 
         return CogniteQuery(
-            with_=with_, select=select_, cursors={root_node: statement.cursor_}
+            with_=with_,
+            select=select_,
+            cursors={root_node: statement_values.cursor},
         )
 
     def _get_select(self, view_id: ViewId, properties: list[str]) -> Select:

industrial_model/cognite_adapters/search_mapper.py

@@ -31,20 +31,20 @@ class SearchMapper:
 
     def map(self, statement: SearchStatement[TViewInstance]) -> SearchQuery:
         root_node = statement.entity.get_view_external_id()
-
+        statement_values = statement.get_values()
         root_view = self._view_mapper.get_view(root_node)
 
-        filters_ = self._filter_mapper.map(statement.where_clauses, root_view)
+        filters_ = self._filter_mapper.map(statement_values.where_clauses, root_view)
 
-        sort_clauses = self._sort_mapper.map(statement.sort_clauses, root_view)
+        sort_clauses = self._sort_mapper.map(statement_values.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_,
+            query=statement_values.query,
+            query_properties=statement_values.query_properties,
+            limit=statement_values.limit,
             sort=sort_clauses,
         )

industrial_model/cognite_adapters/upsert_mapper.py

@@ -102,10 +102,10 @@ class UpsertMapper:
             return DirectRelationReference(
                 space=entry.space, external_id=entry.external_id
             )
-        if isinstance(entry, datetime.date):
-            return entry.strftime("%Y-%m-%d")
         if isinstance(entry, datetime.datetime):
             return datetime_to_ms_iso_timestamp(entry)
+        if isinstance(entry, datetime.date):
+            return entry.strftime("%Y-%m-%d")
         return entry
 
     def _map_edges(

industrial_model/engines/engine.py

@@ -59,7 +59,7 @@ class Engine:
         statement: Statement[TViewInstance],
         validation_mode: ValidationMode = "raiseOnError",
     ) -> list[TViewInstance]:
-        if statement.cursor_:
+        if statement.get_values().cursor:
             raise ValueError("Cursor should be none when querying all pages")
 
         data, _ = self._cognite_adapter.query(statement, True)

industrial_model/statements/__init__.py

@@ -23,22 +23,36 @@ def _create_column(property: str | Column | Any) -> Column:
 
 
 @dataclass
-class BaseStatement(Generic[T]):
-    entity: type[T] = field(init=True)
+class BaseStatementValues:
     where_clauses: list[Expression] = field(init=False, default_factory=list)
+    where_edge_clauses: list[tuple[Column, 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)
+    limit: int = field(init=False, default=DEFAULT_LIMIT)
+    cursor: str | None = field(init=False, default=None)
+
+    query: str | None = field(init=False, default=None)
+    query_properties: list[str] | None = field(init=False, default=None)
+
+
+@dataclass
+class BaseStatement(Generic[T]):
+    entity: type[T] = field(init=True)
+    _values: BaseStatementValues = field(
+        init=False, default_factory=lambda: BaseStatementValues()
+    )
 
     def where(self, *expressions: bool | Expression) -> Self:
         for expression in expressions:
             assert isinstance(expression, Expression)
-            self.where_clauses.append(expression)
+            self._values.where_clauses.append(expression)
         return self
 
     def limit(self, limit: int) -> Self:
-        self.limit_ = limit
+        self._values.limit = limit
         return self
 
     def asc(self, property: str | Column | Any) -> Self:
@@ -48,7 +62,7 @@ class BaseStatement(Generic[T]):
         return self.sort(property, "descending")
 
     def sort(self, property: str | Column | Any, direction: SORT_DIRECTION) -> Self:
-        self.sort_clauses.append(
+        self._values.sort_clauses.append(
             (
                 _create_column(property),
                 direction,
@@ -56,16 +70,14 @@ class BaseStatement(Generic[T]):
         )
         return self
 
+    def get_values(self) -> BaseStatementValues:
+        return self._values
+
 
 @dataclass
 class Statement(BaseStatement[T]):
-    cursor_: str | None = field(init=False, default=None)
-    where_edge_clauses: list[tuple[Column, list[Expression]]] = field(
-        init=False, default_factory=list
-    )
-
     def cursor(self, cursor: str | None) -> Self:
-        self.cursor_ = cursor
+        self._values.cursor = cursor
         return self
 
     def where_edge(
@@ -79,7 +91,7 @@ class Statement(BaseStatement[T]):
             assert isinstance(expression, Expression)
             expressions_.append(expression)
 
-        self.where_edge_clauses.append(
+        self._values.where_edge_clauses.append(
             (
                 _create_column(property),
                 expressions_,
@@ -90,16 +102,13 @@ class Statement(BaseStatement[T]):
 
 @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] | list[str] | list[Any] | None = None,
     ) -> Self:
-        self.query = query
-        self.query_properties = (
+        self._values.query = query
+        self._values.query_properties = (
             [
                 prop
                 if isinstance(prop, str)
@@ -114,34 +123,44 @@ class SearchStatement(BaseStatement[T]):
         return self
 
 
+@dataclass
+class AggregationStatementValues:
+    group_by_properties: list[Column] | None = field(init=False, default=None)
+    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)
+
+
 @dataclass
 class AggregationStatement(Generic[T]):
     entity: type[T] = field(init=True)
     aggregate: AggregateTypes = field(init=True)
 
-    group_by_properties: list[Column] | None = field(init=False, default=None)
-    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)
+    _values: AggregationStatementValues = field(
+        init=False, default_factory=lambda: AggregationStatementValues()
+    )
 
     def group_by(self, *property: str | Column | Any) -> Self:
-        self.group_by_properties = [_create_column(prop) for prop in property]
+        self._values.group_by_properties = [_create_column(prop) for prop in property]
         return self
 
     def aggregate_by(self, property: str | Column | Any) -> Self:
-        self.aggregation_property = _create_column(property)
+        self._values.aggregation_property = _create_column(property)
         return self
 
     def where(self, *expressions: bool | Expression) -> Self:
         for expression in expressions:
             assert isinstance(expression, Expression)
-            self.where_clauses.append(expression)
+            self._values.where_clauses.append(expression)
         return self
 
     def limit(self, limit: int) -> Self:
-        self.limit_ = limit
+        self._values.limit = limit
         return self
 
+    def get_values(self) -> AggregationStatementValues:
+        return self._values
+
 
 def select(entity: type[T]) -> Statement[T]:
     return Statement(entity)

{industrial_model-0.1.32.dist-info → industrial_model-0.1.34.dist-info}/METADATA

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

{industrial_model-0.1.32.dist-info → industrial_model-0.1.34.dist-info}/RECORD

@@ -3,21 +3,21 @@ industrial_model/config.py,sha256=LseCZ8JvewFejjElPUQWdmIQQUU2wnd43McDid_Rixs,47
 industrial_model/constants.py,sha256=wtFdxkR9gojqekwXeyVCof6VUkJYuqjjgAgVVKrcxaw,450
 industrial_model/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 industrial_model/utils.py,sha256=oh4AxwxXaWgIC2uolkCbvkgo0ququHB6yAPVIXy45Ts,663
-industrial_model/cognite_adapters/__init__.py,sha256=cKPW5y-wWiyWYLPDaNjhqc5zdsgdLc40vunIlz2Debg,6246
-industrial_model/cognite_adapters/aggregation_mapper.py,sha256=qglWUnyhgSPG005HzIRyjYkt9V2WKsab5y4ruwuKLcA,2503
-industrial_model/cognite_adapters/filter_mapper.py,sha256=mo-SmUzeNYPKdO8Ed_Kz02RWXMRqsZP7VVjKPWQtn4g,5308
+industrial_model/cognite_adapters/__init__.py,sha256=-cUnErbtDV4XOT_p5xAp28IiH9DPFhE8lsoPa_foq1o,6290
+industrial_model/cognite_adapters/aggregation_mapper.py,sha256=CYbOR7Eh447PEwCtPKFCHYh3-K6akwLTJdQ-oeSYvKo,2599
+industrial_model/cognite_adapters/filter_mapper.py,sha256=eSrEYdEKZHQuJ98gblBYy1qCe5VYpq3fjLSUg8614fk,5261
 industrial_model/cognite_adapters/models.py,sha256=2j2IS01uPkQEp9WdVk8seYzEqGcDdWFnpzXhusHB2zk,945
-industrial_model/cognite_adapters/optimizer.py,sha256=EQfCe-4mSeXhYa2kcqJerPXYsCRgMJPA1AIf1o1KNH0,2415
-industrial_model/cognite_adapters/query_mapper.py,sha256=ui-FhF7ixsJU8jAFNotdZ8vfSKtnjzZYkvLNgMU27Jc,6467
+industrial_model/cognite_adapters/optimizer.py,sha256=kdRlliYacNkONxSHC84U3EjONkIfP7h-OOSL_T5Okg8,2428
+industrial_model/cognite_adapters/query_mapper.py,sha256=tpRdrEW6i0NKy5h6bYrIIP96nanPSokK-s5-1d0PES8,6597
 industrial_model/cognite_adapters/query_result_mapper.py,sha256=KaBqYr5l1t8sQMxEoX_F3J2prypKIPaDJxSzGF_fMB8,10203
-industrial_model/cognite_adapters/search_mapper.py,sha256=dh69Te8oiDIRPbEMTcof-ZJ4XD-xB5iiBHUR0UETzho,1504
+industrial_model/cognite_adapters/search_mapper.py,sha256=zRe5FgucTWHX2VVbh3iLmzM7FmUAFhJG5t42gXnnJrE,1587
 industrial_model/cognite_adapters/sort_mapper.py,sha256=RJUAYlZGXoYzK0PwX63cibRF_L-MUq9g2ZsC2EeNIF4,696
-industrial_model/cognite_adapters/upsert_mapper.py,sha256=fIz2WLnn0YpsgotGH2MXAa9QYWjQehpWsX3MAKhvRkw,4951
+industrial_model/cognite_adapters/upsert_mapper.py,sha256=jzelnmECFcuVkQY7dgZG-xL19yD9kxtYvx827InIMO8,4951
 industrial_model/cognite_adapters/utils.py,sha256=-9NUG84r49cKvmmzoUinxNF1zhHIlmoWFypUCD_WTeM,4800
 industrial_model/cognite_adapters/view_mapper.py,sha256=fihoxyLKvq8xa1oArdCCkukqVpOexFcBDnEyMACpHF8,1430
 industrial_model/engines/__init__.py,sha256=7aGHrUm2MxIq39vR8h0xu3i1zNOuT9H9U-q4lV3nErQ,102
 industrial_model/engines/async_engine.py,sha256=-sQv2vn93bBmTZOxY_C1r40YP7IMl1ND2gCN2GE9BqY,2188
-industrial_model/engines/engine.py,sha256=lECOpjN6fGvKt28b441isT_u4UNF3LeLiJH-zwHmkYw,3798
+industrial_model/engines/engine.py,sha256=Pwg8A3PFVdRExiLGyhcs8hhiGyKgKi6piOmiLgvCL50,3810
 industrial_model/models/__init__.py,sha256=AzJ0CyPK5PvUCX45FFtybl13tkukUvk2UAF_90s_LQ8,742
 industrial_model/models/base.py,sha256=iGhDjXqA5ULEQIFHtkMi7WYJl0nQq1wi8_zqOr-Ep78,1649
 industrial_model/models/entities.py,sha256=XugtGFCJrHnxR4UX7FWFumB2tNZGB7mNjM4skznnmdQ,4704
@@ -26,8 +26,8 @@ industrial_model/queries/__init__.py,sha256=lA83zOxMRgBgkseWJgK9kCr1vD8D8iSWs9NG
 industrial_model/queries/models.py,sha256=VK69c4L0b0miPrKvOQBB8A01SPxZXYThrquv6gw5OGY,2544
 industrial_model/queries/params.py,sha256=50qY5BO5onLsXorhcv-7qCKhJaMO94UzhKLCmZKY55s,1667
 industrial_model/queries/utils.py,sha256=uP6PLh9IVHDK6J8x444zHWPmyV4PkxdLO-PMc6qWItc,1505
-industrial_model/statements/__init__.py,sha256=dNEFceuirobo3c9b8KB-3qgKihZ4yfnUj5U-1978eBM,4856
+industrial_model/statements/__init__.py,sha256=3Et9PM7AMbIS7Fh9051Q0u3qUpX6588d1yuNrvdd4wI,5429
 industrial_model/statements/expressions.py,sha256=4ZZOcZroI5-4xRw4PXIRlufi0ARndE5zSbbxLDpR2Ec,4816
-industrial_model-0.1.32.dist-info/METADATA,sha256=SgEMILIv7zqrEK1Wyb-l-74ixnL2s9KHvcUrOvvHeHo,6858
-industrial_model-0.1.32.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-industrial_model-0.1.32.dist-info/RECORD,,
+industrial_model-0.1.34.dist-info/METADATA,sha256=9rtluwI-0-GwC1dqVlIUaCSPL8jdx6DNEVSIXhJ0qVU,6858
+industrial_model-0.1.34.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+industrial_model-0.1.34.dist-info/RECORD,,