ormlambda 2.11.2__py3-none-any.whl → 3.7.1__py3-none-any.whl

ormlambda/__init__.py

@@ -3,18 +3,20 @@ from .common.enums import (
     JoinType as JoinType,
     ConditionType as ConditionType,
 )
-from ormlambda.common.interfaces.IStatements import OrderType as OrderType
 # endregion
 
-from .common.abstract_classes import AbstractSQLStatements as AbstractSQLStatements
-from .common.interfaces import IRepositoryBase as IRepositoryBase
-from .utils import (
+# region sql
+from .sql import (
     Table as Table,
     Column as Column,
     ForeignKey as ForeignKey,
 )
-from .utils.lambda_disassembler import (
-    Disassembler as Disassembler,
-    nameof as nameof,
-)
-from .model_base import BaseModel as BaseModel  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
+# endregion
+
+from .repository import BaseRepository as BaseRepository
+from .statements import BaseStatement as BaseStatement
+from .statements.types import OrderType as OrderType
+from .model.base_model import (
+    BaseModel as BaseModel,
+    ORM as ORM,
+)  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler

ormlambda/caster/__init__.py

@@ -0,0 +1,3 @@
+from .base_caster import BaseCaster  # noqa: F401
+from .caster import Caster, PLACEHOLDER  # noqa: F401
+from .interfaces import ICaster  # noqa: F401

ormlambda/caster/base_caster.py

@@ -0,0 +1,69 @@
+from typing import Type, Callable, Optional, overload
+import abc
+
+
+class BaseCaster[TProp, TType](abc.ABC):
+    def __init__(self, value: TProp, type_value: TType):
+        self._value: TProp = value
+        self._type_value: TType = type_value
+
+    def __repr__(self):
+        return f"{BaseCaster.__name__}: [{type(self._value).__name__}] -> [{self.type_to_cast.__name__}]"
+
+    @overload
+    def wildcard_to_select(self, value: str) -> str: ...
+    @overload
+    def wildcard_to_select(self) -> str: ...
+    
+    @abc.abstractmethod
+    def wildcard_to_select(self) -> str: ...
+
+    @overload
+    def wildcard_to_where(self, value: str) -> str: ...
+    @overload
+    def wildcard_to_where(self) -> str: ...
+    
+    @abc.abstractmethod
+    def wildcard_to_where(self) -> str: ...
+
+    @overload
+    def wildcard_to_insert(self, value: str) -> str: ...
+    @overload
+    def wildcard_to_insert(self) -> str: ...
+    
+    @abc.abstractmethod
+    def wildcard_to_insert(self) -> str: ...
+
+    @property
+    @abc.abstractmethod
+    def to_database(self) -> Type[TProp]: ...
+
+    @property
+    @abc.abstractmethod
+    def from_database(self) -> TProp: ...
+
+    @property
+    @abc.abstractmethod
+    def string_data(self) -> str: ...
+
+    @property
+    def value(self) -> TProp:
+        return self._value
+
+    @property
+    def value_type(self) -> Type[TProp]:
+        return type(self._value)
+
+    @property
+    def type_to_cast(self) -> TType:
+        return self._type_value
+
+    @staticmethod
+    def return_value_if_exists[TType, **P](func: Callable[P, Optional[TType]]) -> Callable[P, Optional[TType]]:
+        def wrapped(self: "BaseCaster") -> Optional[TType]:
+            if self._value is None:
+                return None
+
+            return func(self)
+
+        return wrapped

ormlambda/caster/caster.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+
+from typing import Optional, Type, TYPE_CHECKING, Callable, overload
+
+from ormlambda.common.global_checker import GlobalChecker
+from ormlambda.sql.types import ColumnType
+from ormlambda.engine.template import RepositoryTemplateDict
+
+if TYPE_CHECKING:
+    from ormlambda.caster import BaseCaster
+    from ormlambda.repository import IRepositoryBase
+
+
+PLACEHOLDER: str = "%s"
+
+
+class Caster[TRepo]:
+    def __init__(self, repository: IRepositoryBase):
+        self._repository: IRepositoryBase = repository
+        self._caster = RepositoryTemplateDict().get(repository).caster
+
+    @overload
+    def for_column[T, TProp](self, column: Callable[[T], TProp], instance: T) -> BaseCaster[TProp, Type[TProp]]: ...
+    @overload
+    def for_column[T, TProp](self, column: TProp, instance: T) -> BaseCaster[TProp, Type[TProp]]: ...
+
+    def for_column[T, TProp: ColumnType](self, column: TProp | Callable[[T], TProp], instance: Optional[T]) -> BaseCaster[TProp]:
+        if not instance:
+            raise ValueError("You must specified an instance variable on the constructor before calling 'for_column' method")
+
+        if GlobalChecker.is_lambda_function(column):
+            column_type = column(type(instance)).dtype
+            value = column(instance)
+        else:
+            column_type = column.dtype
+            value = instance[column]
+
+        return self._caster.cast(value, column_type)
+
+    @overload
+    def for_value[TProp](self, value: TProp) -> BaseCaster[TProp, Type[TProp]]: ...
+    @overload
+    def for_value[TProp, TType](self, value: TProp, value_type: TType) -> BaseCaster[TProp, TType]: ...
+
+    def for_value[TProp, TType](self, value: TProp, value_type: Optional[TType] = None) -> BaseCaster[TProp, TType]:
+        column_type = value_type if value_type else type(value)
+        return self._caster.cast(value, column_type)

ormlambda/caster/interfaces/ICaster.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+import abc
+from typing import overload, TYPE_CHECKING, Type
+
+if TYPE_CHECKING:
+    from ormlambda.caster import BaseCaster
+    from shapely import Point
+    from types import NoneType
+    from datetime import datetime
+
+
+type ValidTypes = Type[str] | Type[int] | Type[float] | Type[Point] | Type[NoneType] | Type[datetime]
+
+
+class ICaster(abc.ABC):
+    @abc.abstractmethod
+    @overload
+    @classmethod
+    def cast[TProp](cls, value: TProp) -> BaseCaster[TProp, Type[TProp]]: ...
+    @overload
+    @classmethod
+    def cast[TProp, TType](cls, value: TProp, type_value: TType) -> BaseCaster[TProp, TType]: ...
+
+    @classmethod
+    @abc.abstractmethod
+    def CASTER_SELECTOR(cls) -> dict[ValidTypes, Type[BaseCaster]]: ...

ormlambda/caster/interfaces/__init__.py

@@ -0,0 +1 @@
+from .ICaster import ICaster  # noqa: F401

ormlambda/common/__init__.py

@@ -1 +1 @@
-
+from .global_checker import GlobalChecker as GlobalChecker

ormlambda/common/abstract_classes/__init__.py

@@ -1,3 +1,3 @@
-from .non_query_base import NonQueryBase  # noqa: F401
-from .abstract_model import AbstractSQLStatements  # noqa: F401
-from .query_base import QueryBase  # noqa: F401
+from .non_query_base import NonQueryBase as NonQueryBase
+from .query_base import QueryBase as QueryBase
+from .decomposition_query import DecompositionQueryBase as DecompositionQueryBase