industrial-model 0.1.0__py3-none-any.whl

industrial_model/statements/expressions.py

@@ -0,0 +1,165 @@
+import datetime
+from abc import ABC
+from dataclasses import dataclass
+from typing import Any
+
+from industrial_model.constants import (
+    BOOL_EXPRESSION_OPERATORS,
+    LEAF_EXPRESSION_OPERATORS,
+)
+
+RANGE_SUPPORTED_VALUES = str | int | float
+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
+)
+
+
+class Expression(ABC):
+    operator: str
+
+
+@dataclass(frozen=True)
+class BoolExpression(Expression):
+    filters: list[Expression]
+    operator: BOOL_EXPRESSION_OPERATORS
+
+    def __and__(self, other: "BoolExpression | LeafExpression") -> bool:
+        return and_(self, other)
+
+    def __or__(self, other: "BoolExpression | LeafExpression") -> bool:
+        return or_(self, other)
+
+
+@dataclass(frozen=True)
+class LeafExpression(Expression):
+    property: str
+    operator: LEAF_EXPRESSION_OPERATORS
+    value: Any
+
+    def __and__(self, other: "BoolExpression | LeafExpression") -> bool:
+        return and_(self, other)
+
+    def __or__(self, other: "BoolExpression | LeafExpression") -> bool:
+        return or_(self, other)
+
+
+class Column:
+    def __init__(self, property: Any):
+        assert isinstance(property, str | Column)
+        property_ = (
+            property.property if isinstance(property, Column) else property
+        )
+        self.property: str = property_
+
+    def __hash__(self) -> int:
+        return hash(self.property)
+
+    def __eq__(self, other: Any) -> bool:
+        if other is None:
+            return self.not_exists_()
+
+        return self.equals_(other)
+
+    def __ne__(self, other: Any) -> bool:
+        if other is None:
+            return self.exists_()
+
+        return self.not_("==", other)
+
+    def __lt__(self, other: Any) -> bool:
+        return self.lt_(other)
+
+    def __le__(self, other: Any) -> bool:
+        return self.lte_(other)
+
+    def __gt__(self, other: Any) -> bool:
+        return self.gt_(other)
+
+    def __ge__(self, other: Any) -> bool:
+        return self.gte_(other)
+
+    def equals_(self, other: SUPPORTED_VALUES) -> bool:
+        return self._compare("==", other)
+
+    def prefix(self, other: str) -> bool:
+        return self._compare("prefix", other)
+
+    def lt_(self, other: RANGE_SUPPORTED_VALUES | datetime.datetime) -> bool:
+        return self._compare("<", other)
+
+    def lte_(self, other: RANGE_SUPPORTED_VALUES | datetime.datetime) -> bool:
+        return self._compare("<=", other)
+
+    def gt_(self, other: RANGE_SUPPORTED_VALUES | datetime.datetime) -> bool:
+        return self._compare(">", other)
+
+    def gte_(self, other: RANGE_SUPPORTED_VALUES | datetime.datetime) -> bool:
+        return self._compare(">=", other)
+
+    def in_(self, other: LIST_SUPPORTED_VALUES) -> bool:
+        return self._compare("in", other)
+
+    def contains_all_(self, other: LIST_SUPPORTED_VALUES) -> bool:
+        return self._compare("containsAll", other)
+
+    def contains_any_(self, other: LIST_SUPPORTED_VALUES) -> bool:
+        return self._compare("containsAny", other)
+
+    def exists_(self) -> bool:
+        return self._compare("exists", None)
+
+    def not_exists_(self) -> bool:
+        return self.not_("exists", None)
+
+    def not_(self, operator: LEAF_EXPRESSION_OPERATORS, other: Any) -> bool:
+        return BoolExpression(
+            operator="not",
+            filters=[self._compare(operator, other)],  # type: ignore
+        )
+
+    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:
+        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
+
+
+def _unwrap_expressions(
+    *expressions: bool | LeafExpression | BoolExpression,
+) -> list[Expression]:
+    filters: list[Expression] = []
+    for expression in expressions:
+        assert isinstance(expression, Expression)
+        filters.append(expression)
+    return filters
+
+
+def and_(*expressions: bool | LeafExpression | BoolExpression) -> bool:
+    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
+
+
+def col(property: Any) -> Column:
+    return Column(property)

industrial_model/utils.py

@@ -0,0 +1,38 @@
+from collections.abc import Callable, Generator
+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")
+
+
+def datetime_to_ms_iso_timestamp(dt: datetime) -> str:
+    if not isinstance(dt, datetime):
+        raise ValueError(f"Expected datetime object, got {type(dt)}")
+    if dt.tzinfo is None:
+        dt = dt.astimezone()
+    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,
+    cancellable: bool = False,
+) -> T_Retval:
+    return await to_thread.run_sync(func, *args, cancellable=cancellable)

industrial_model-0.1.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: industrial-model
+Version: 0.1.0
+Summary: Industrial Model ORM
+Author-email: Lucas Alves <lucasrosaalves@gmail.com>
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4.9.0
+Requires-Dist: cognite-sdk>=7.75.0
+Requires-Dist: pydantic>=2.11.4
+Description-Content-Type: text/markdown
+
+# capybara
+
+![My Image](./assets/logo.jpeg)

industrial_model-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+industrial_model/__init__.py,sha256=EDOULHjsfkh_XJVHVajSpQycMWLsQ3STmVj_WoKfiWc,507
+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=9N4oT7tWZx5wjVr7q64Ef5FLT75Omep48xGYv1PhxV8,1917
+industrial_model/cognite_adapters/filter_mapper.py,sha256=NqH-OW7_iKFY9POCG8W3KjkwXUgrZP1d_yxDx1J0fXM,3859
+industrial_model/cognite_adapters/optimizer.py,sha256=msOXAU2nY2-7U0-AlST3_SWuLHnyQ9wNa5_BzMRQfdw,2166
+industrial_model/cognite_adapters/query_mapper.py,sha256=lYKRiIEmFiX7CQUnrOh5_-t1UkAMcT3dr9ORgErDXOY,6233
+industrial_model/cognite_adapters/query_result_mapper.py,sha256=jUreXqsaLnq7hp6T_JZQNRtL8TL8hoLSFvD4SkJ4TEE,7002
+industrial_model/cognite_adapters/schemas.py,sha256=5sR0HPBWx9o11p_EN2sZR58XHovsfeoMsKwFHJAHrFI,3352
+industrial_model/cognite_adapters/sort_mapper.py,sha256=RJUAYlZGXoYzK0PwX63cibRF_L-MUq9g2ZsC2EeNIF4,696
+industrial_model/cognite_adapters/utils.py,sha256=nBYHK8697L2yGEAcyKjQV9NEZQmWy_aSGq_iMl7gofM,907
+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=j8e54oDCY_rh6GOyacK9UtjjI4nwKLpsy3r5GSJTXpY,334
+industrial_model/models/base.py,sha256=jbiaICJ0R1mmxXtDqxxlVdq-tTX4RLdqnLTgs9HLm_4,1279
+industrial_model/models/entities.py,sha256=NrFV_a3ZP6Y4b1M2PFl_746qcCsexsyO2cuB0snZhkw,1319
+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=mqPIvfQ-XZ_IILwha7RbkdIKH_MRAdAvfrw80pCKU1c,1753
+industrial_model/statements/expressions.py,sha256=bsUnkFDGVHpOQ1RUtEbSPE1nfVkF0zC3m5-9JFkSqu8,4751
+industrial_model-0.1.0.dist-info/METADATA,sha256=jZmhsTJkulF0xz4IMktuaiizIgVOTriD2G7zimsmozw,763
+industrial_model-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+industrial_model-0.1.0.dist-info/RECORD,,

industrial_model-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any