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

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

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

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

@@ -62,10 +62,16 @@ class AggregationMapper:
 
         if metric_aggregation is None:
             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
+            else statement.entity.get_group_by_fields()
+        )
         return AggregationQuery(
             view=root_view,
             metric_aggregation=metric_aggregation,
             filters=filters_,
-            group_by_columns=statement.entity.get_group_by_fields(),
+            group_by_columns=group_by_columns,
             limit=statement.limit_,
         )

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

@@ -1,9 +1,11 @@
 from datetime import date, datetime
+from typing import Any
 
 import cognite.client.data_classes.filters as cdf_filters
 from cognite.client.data_classes.data_modeling import MappedProperty, View
 
 from industrial_model.cognite_adapters.utils import get_property_ref
+from industrial_model.models.entities import InstanceId
 from industrial_model.statements import (
     BoolExpression,
     Expression,
@@ -54,11 +56,8 @@ class FilterMapper:
         property_ref = get_property_ref(expression.property, root_view)
 
         value_ = expression.value
-        if isinstance(value_, datetime):
-            value_ = datetime_to_ms_iso_timestamp(value_)
 
-        if isinstance(value_, date):
-            value_ = value_.strftime("%Y-%m-%d")
+        value_ = self._handle_type_value_convertion(value_)
 
         if expression.operator == "==":
             return cdf_filters.Equals(property_ref, value_)
@@ -96,3 +95,14 @@ class FilterMapper:
         assert isinstance(view_definiton, MappedProperty)
         assert view_definiton.source
         return self._view_mapper.get_view(view_definiton.source.external_id)
+
+    def _handle_type_value_convertion(self, value_: Any) -> Any:
+        if isinstance(value_, datetime):
+            return datetime_to_ms_iso_timestamp(value_)
+        elif isinstance(value_, date):
+            return value_.strftime("%Y-%m-%d")
+        elif isinstance(value_, InstanceId):
+            return value_.model_dump(mode="json", by_alias=True)
+        elif isinstance(value_, list):
+            return [self._handle_type_value_convertion(v) for v in value_]
+        return value_

{industrial_model-0.1.22 → industrial_model-0.1.24}/industrial_model/queries/__init__.py

@@ -1,9 +1,11 @@
-from .models import BasePaginatedQuery, BaseQuery
+from .models import BaseAggregationQuery, BasePaginatedQuery, BaseQuery, BaseSearchQuery
 from .params import NestedQueryParam, QueryParam, SortParam
 
 __all__ = [
     "BaseQuery",
     "BasePaginatedQuery",
+    "BaseSearchQuery",
+    "BaseAggregationQuery",
     "SortParam",
     "QueryParam",
     "NestedQueryParam",

industrial_model-0.1.24/industrial_model/queries/models.py

@@ -0,0 +1,98 @@
+from typing import Any
+
+from industrial_model.models import RootModel, TAggregatedViewInstance, TViewInstance
+from industrial_model.statements import (
+    AggregateTypes,
+    AggregationStatement,
+    SearchStatement,
+    Statement,
+    aggregate,
+)
+
+from .params import NestedQueryParam, QueryParam, SortParam
+
+
+class BaseQuery(RootModel):
+    def to_statement(self, entity: type[TViewInstance]) -> Statement[TViewInstance]:
+        statement = Statement(entity)
+
+        for key, item in self.__class__.model_fields.items():
+            values = getattr(self, key)
+            if not values:
+                continue
+            for metadata_item in item.metadata:
+                if isinstance(metadata_item, SortParam):
+                    statement.sort(values, metadata_item.direction)
+                elif isinstance(metadata_item, QueryParam | NestedQueryParam):
+                    statement.where(metadata_item.to_expression(values))
+
+        return statement
+
+
+class BasePaginatedQuery(BaseQuery):
+    limit: int = 1000
+    cursor: str | None = None
+
+    def to_statement(self, entity: type[TViewInstance]) -> Statement[TViewInstance]:
+        statement = super().to_statement(entity)
+        statement.limit(self.limit)
+        statement.cursor(self.cursor)
+
+        return statement
+
+
+class BaseSearchQuery(RootModel):
+    query: str | None = None
+    query_properties: list[str] | list[Any] | None = None
+    limit: int = 1000
+
+    def to_statement(
+        self, entity: type[TViewInstance]
+    ) -> SearchStatement[TViewInstance]:
+        statement = SearchStatement(entity)
+
+        for key, item in self.__class__.model_fields.items():
+            values = getattr(self, key)
+            if not values:
+                continue
+            for metadata_item in item.metadata:
+                if isinstance(metadata_item, SortParam):
+                    statement.sort(values, metadata_item.direction)
+                elif isinstance(metadata_item, QueryParam | NestedQueryParam):
+                    statement.where(metadata_item.to_expression(values))
+        if self.query:
+            statement.query_by(self.query, self.query_properties)
+        statement.limit(self.limit)
+
+        return statement
+
+
+class BaseAggregationQuery(RootModel):
+    aggregate: AggregateTypes | None = None
+    group_by_properties: list[str] | list[Any] | None = None
+    aggregation_property: str | None = None
+    limit: int | None = None
+
+    def to_statement(
+        self, entity: type[TAggregatedViewInstance]
+    ) -> AggregationStatement[TAggregatedViewInstance]:
+        statement = aggregate(entity, self.aggregate)
+
+        for key, item in self.__class__.model_fields.items():
+            values = getattr(self, key)
+            if not values:
+                continue
+            for metadata_item in item.metadata:
+                if isinstance(metadata_item, QueryParam | NestedQueryParam):
+                    statement.where(metadata_item.to_expression(values))
+
+        if self.group_by_properties:
+            statement.group_by(*self.group_by_properties)
+
+        if self.aggregation_property:
+            statement.aggregate_by(self.aggregation_property)
+
+        if self.limit:
+            statement.limit(self.limit)
+
+        return statement

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

@@ -74,7 +74,7 @@ class SearchStatement(BaseStatement[T]):
     def query_by(
         self,
         query: str,
-        query_properties: list[Column | str | Any] | None = None,
+        query_properties: list[Column] | list[str] | list[Any] | None = None,
     ) -> Self:
         self.query = query
         self.query_properties = (
@@ -97,10 +97,15 @@ 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)
 
+    def group_by(self, *property: str | Column | Any) -> Self:
+        self.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)
         return self
@@ -122,9 +127,9 @@ def select(entity: type[T]) -> Statement[T]:
 
 def aggregate(
     entity: type[T],
-    aggregate: AggregateTypes = "count",
+    aggregate: AggregateTypes | None = "count",
 ) -> AggregationStatement[T]:
-    return AggregationStatement(entity=entity, aggregate=aggregate)
+    return AggregationStatement(entity=entity, aggregate=aggregate or "count")
 
 
 def search(entity: type[T]) -> SearchStatement[T]:

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

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

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

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

industrial_model-0.1.22/industrial_model/queries/models.py

@@ -1,33 +0,0 @@
-from industrial_model.models import RootModel, TViewInstance
-from industrial_model.statements import Statement
-
-from .params import NestedQueryParam, QueryParam, SortParam
-
-
-class BaseQuery(RootModel):
-    def to_statement(self, entity: type[TViewInstance]) -> Statement[TViewInstance]:
-        statement = Statement(entity)
-
-        for key, item in self.__class__.model_fields.items():
-            values = getattr(self, key)
-            if not values:
-                continue
-            for metadata_item in item.metadata:
-                if isinstance(metadata_item, SortParam):
-                    statement.sort(values, metadata_item.direction)
-                elif isinstance(metadata_item, QueryParam | NestedQueryParam):
-                    statement.where(metadata_item.to_expression(values))
-
-        return statement
-
-
-class BasePaginatedQuery(BaseQuery):
-    limit: int = 1000
-    cursor: str | None = None
-
-    def to_statement(self, entity: type[TViewInstance]) -> Statement[TViewInstance]:
-        statement = super().to_statement(entity)
-        statement.limit(self.limit)
-        statement.cursor(self.cursor)
-
-        return statement