ormlambda 2.8.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

ormlambda/__init__.py

@@ -1,11 +1,20 @@
-# enums
-from .common.enums import (  # noqa: F401
-    JoinType,
-    ConditionType,
+# region enums
+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  # noqa: F401
-from .common.interfaces import IRepositoryBase  # noqa: F401
-from .utils import Table, Column, ForeignKey  # noqa: F401
-from .utils.lambda_disassembler import Disassembler, nameof  # noqa: F401
-from .model_base import BaseModel  # noqa: F401  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
+from .common.abstract_classes import AbstractSQLStatements as AbstractSQLStatements
+from .common.interfaces import IRepositoryBase as IRepositoryBase
+from .utils 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

ormlambda/common/abstract_classes/abstract_model.py

@@ -10,7 +10,6 @@ from ormlambda.common.interfaces.IAggregate import IAggregate
 
 if TYPE_CHECKING:
     from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
-    from ormlambda.components.select import ISelect
     from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
 
 
@@ -46,11 +45,11 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
     @override
     def repository(self) -> IRepositoryBase[TRepo]: ...
 
-    def _return_flavour[TValue](self, query, flavour: Type[TValue]) -> tuple[TValue]:
-        return self._repository.read_sql(query, flavour=flavour)
+    def _return_flavour[TValue](self, query, flavour: Type[TValue], select) -> tuple[TValue]:
+        return self._repository.read_sql(query, flavour=flavour, model=self._model, select=select)
 
-    def _return_model(self, select: ISelect, query: str):
-        response_sql = self._repository.read_sql(query, flavour=dict)  # store all columns of the SQL query
+    def _return_model(self, select, query: str):
+        response_sql = self._repository.read_sql(query, flavour=dict, model=self._model, select=select)  # store all columns of the SQL query
 
         if isinstance(response_sql, Iterable):
             return ClusterQuery[T](select, response_sql).clean_response()
@@ -66,7 +65,16 @@ class ClusterQuery[T]:
         self._select: DecompositionQueryBase[T] = select
         self._response_sql: tuple[dict[str, Any]] = response_sql
 
-    def loop_foo(self) -> dict[Type[Table], list[Table]]:
+    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table]]]:
+        tbl_dicc: dict[Type[Table], list[Table]] = self.__loop_foo()
+
+        # it not depend of flavour attr
+        for key, val in tbl_dicc.items():
+            tbl_dicc[key] = tuple(val)
+
+        return tuple(tbl_dicc.values())
+
+    def __loop_foo(self) -> dict[Type[Table], list[Table]]:
         #  We must ensure to get the valid attributes for each instance
         table_initialize = defaultdict(list)
 
@@ -75,7 +83,7 @@ class ClusterQuery[T]:
                 valid_attr: dict[str, Any] = {}
                 for clause in clauses:
                     if not hasattr(table, clause.column):
-                        agg_methods = self.get_all_aggregate_method(clauses)
+                        agg_methods = self.__get_all_aggregate_method(clauses)
                         raise ValueError(f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'.")
                     valid_attr[clause.column] = dicc_cols[clause.alias]
 
@@ -83,7 +91,7 @@ class ClusterQuery[T]:
                 table_initialize[table].append(table(**valid_attr))
         return table_initialize
 
-    def get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
+    def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
         res: set[str] = set()
 
         for clause in clauses:
@@ -91,12 +99,3 @@ class ClusterQuery[T]:
             if isinstance(row, IAggregate):
                 res.add(row.__class__.__name__)
         return ", ".join(res)
-
-    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table]]]:
-        tbl_dicc: dict[Type[Table], list[Table]] = self.loop_foo()
-
-        # it not depend of flavour attr
-        for key, val in tbl_dicc.items():
-            tbl_dicc[key] = tuple(val)
-
-        return tuple(tbl_dicc.values())

ormlambda/common/abstract_classes/decomposition_query.py

@@ -44,6 +44,13 @@ class ClauseInfo[T: tp.Type[Table]]:
     def query(self) -> str:
         return self._query
 
+    @property
+    def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]:
+        try:
+            return self._table.get_column(self.column).dtype
+        except ValueError:
+            return None
+
     def _resolve_column(self, data: ClauseDataType) -> str:
         if isinstance(data, property):
             return self._table.__properties_mapped__[data]
@@ -73,6 +80,17 @@ class ClauseInfo[T: tp.Type[Table]]:
 
 
 class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
+    @tp.overload
+    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]]) -> None: ...
+    @tp.overload
+    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ...) -> None: ...
+    @tp.overload
+    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ..., alias_name: tp.Optional[str] = ...) -> None: ...
+    @tp.overload
+    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ..., alias_name: tp.Optional[str] = ..., by: JoinType = ...) -> None: ...
+    @tp.overload
+    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ..., alias_name: tp.Optional[str] = ..., by: JoinType = ..., replace_asterisk_char: bool = ...) -> None: ...
+
     def __init__[*Ts](
         self,
         table: T,
@@ -98,6 +116,11 @@ class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
 
         self.__clauses_list_generetor(lambda_query)
 
+    def __getitem__(self, key: str) -> ClauseInfo:
+        for clause in self._all_clauses:
+            if clause.alias == key:
+                return clause
+
     def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
         DEFAULT_ALIAS: str = f"{clause_info._table.__table_name__}_{clause_info._column}"
 

ormlambda/common/interfaces/IStatements.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import Any, Callable, Iterable, Optional, Literal, Type, Union, overload, TYPE_CHECKING, TypeVar
 from enum import Enum
 from abc import abstractmethod, ABC
+import enum
 
 from .IRepositoryBase import IRepositoryBase
 from ormlambda.common.enums import JoinType
@@ -10,7 +11,15 @@ if TYPE_CHECKING:
     from ormlambda import Table
     from .IAggregate import IAggregate
 
-OrderType = Literal["ASC", "DESC"]
+
+class OrderType(enum.Enum):
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+OrderTypeString = Literal["ASC", "DESC"]
+
+OrderTypes = OrderTypeString | OrderType | Iterable[OrderType]
 
 # TODOH: This var is duplicated from 'src\ormlambda\databases\my_sql\clauses\create_database.py'
 TypeExists = Literal["fail", "replace", "append"]
@@ -109,7 +118,7 @@ class IStatements[T: Table](ABC):
     @overload
     def delete(self, instance: list[T]) -> None: ...
     @abstractmethod
-    def delete(self, instance: Optional[T | list[T]] = None) -> None: ...
+    def delete(self, instance: Optional[T | list[T]] = ...) -> None: ...
 
     # endregion
     # region join
@@ -155,9 +164,9 @@ class IStatements[T: Table](ABC):
     @overload
     def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
     @abstractmethod
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
 
     # endregion
     # region concat
@@ -196,62 +205,60 @@ class IStatements[T: Table](ABC):
     @overload
     def select(self) -> tuple[T, ...]: ...
     @overload
-    def select[T1](self, selector: Callable[[T], T1], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...]]: ...
+    def select[T1](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...]]: ...
     @overload
-    def select[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...]]: ...
+    def select[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...]]: ...
     @overload
-    def select[T1, T2](self, selector: Callable[[T], tuple[T1, T2]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...]]: ...
+    def select[T1, T2](self, selector: Callable[[T], tuple[T1, T2]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...]]: ...
     @overload
-    def select[T1, T2, T3](self, selector: Callable[[T], tuple[T1, T2, T3]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...]]: ...
+    def select[T1, T2, T3](self, selector: Callable[[T], tuple[T1, T2, T3]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...]]: ...
     @overload
-    def select[T1, T2, T3, T4](self, selector: Callable[[T], tuple[T1, T2, T3, T4]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...]]: ...
+    def select[T1, T2, T3, T4](self, selector: Callable[[T], tuple[T1, T2, T3, T4]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...]]: ...
     @overload
-    def select[T1, T2, T3, T4, T5](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...]]: ...
+    def select[T1, T2, T3, T4, T5](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...]]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...]]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6, T7](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6, T7](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...]]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6, T7, T8](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...]]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9](
-        self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]], *, by: Optional[Enum] = JoinType.INNER_JOIN
-    ) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...], tuple[T9, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...], tuple[T9, ...]]: ...
     @overload
     def select[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](
-        self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], *, by: Optional[Enum] = JoinType.INNER_JOIN
+        self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], *, by: Optional[Enum] = ...
     ) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...], tuple[T9, ...], tuple[T10, ...]]: ...
     @overload
-    def select[Ts](self, selector: Optional[Callable[[T], Ts]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[Ts, ...]: ...
+    def select[Ts](self, selector: Optional[Callable[[T], Ts]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ...) -> tuple[Ts, ...]: ...
     @overload
-    def select[Ts](self, selector: Optional[Callable[[T], tuple[Ts]]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[Ts, ...]: ...
+    def select[Ts](self, selector: Optional[Callable[[T], tuple[Ts]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ...) -> tuple[Ts, ...]: ...
     @overload
-    def select[*Ts](self, selector: Optional[Callable[[T], tuple[*Ts]]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[*Ts]]: ...
+    def select[*Ts](self, selector: Optional[Callable[[T], tuple[*Ts]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ...) -> tuple[tuple[*Ts]]: ...
     @overload
-    def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = None, *, flavour: Type[TFlavour], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[TFlavour]: ...
+    def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ...) -> tuple[TFlavour]: ...
     @abstractmethod
-    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = None, by: JoinType = JoinType.INNER_JOIN): ...
+    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = ..., *, flavour: Type[TFlavour] = ..., by: JoinType = ...): ...
 
     # endregion
     # region select_one
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one[TFlavour](self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...
+    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
     @overload
-    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> T1: ...
+    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
     @overload
-    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[*Ts]: ...
+    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = ...) -> tuple[*Ts]: ...
     @overload
-    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type) -> T1: ...
+    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type) -> T1: ...
     @overload
-    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> T1: ...
+    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> T1: ...
     @overload
-    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple[*Ts]: ...
+    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = ..., flavour: Type[tuple]) -> tuple[*Ts]: ...
     @overload
-    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...
+    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
     @abstractmethod
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = None, by: Optional[Enum] = JoinType.INNER_JOIN): ...
+    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = ..., by: Optional[Enum] = ...): ...
 
     # endregion
     # region group_by

ormlambda/databases/my_sql/clauses/insert.py

@@ -1,4 +1,4 @@
-from typing import Any, override, Iterable
+from typing import override, Iterable
 from mysql.connector import MySQLConnection
 
 from ormlambda import Table
@@ -24,13 +24,24 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
 
     @override
     def insert(self, instances: T | list[T]) -> None:
-        new_dict_list: list[dict[str, Any]] = []
-        self.__fill_dict_list(new_dict_list, instances)
-        cols_tuple = new_dict_list[0].keys()
-        join_cols = ", ".join(cols_tuple)
-        unknown_rows = f'({", ".join(["%s"]*len(cols_tuple))})'  # The number of "%s" must match the dict 'dicc_0' length
+        valid_cols: list[list[Column]] = []
+        self.__fill_dict_list(valid_cols, instances)
 
-        self._values = [tuple(x.values()) for x in new_dict_list]
+        col_names: list[str] = []
+        wildcards: list[str] = []
+        col_values: list[list[str]] = []
+        for i, cols in enumerate(valid_cols):
+            col_values.append([])
+            for col in cols:
+                if i == 0:
+                    col_names.append(col.column_name)
+                    wildcards.append(col.placeholder)
+                col_values[-1].append(col.column_value_to_query)
+
+        join_cols = ", ".join(col_names)
+        unknown_rows = f'({", ".join(wildcards)})'  # The number of "%s" must match the dict 'dicc_0' length
+
+        self._values = [tuple(x) for x in col_values]
         self._query = f"{self.CLAUSE} {self._model.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
         return None
 
@@ -55,17 +66,18 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
             return False
         return True
 
-    def __fill_dict_list(self, list_dict: list[dict], values: T | list[T]):
+    def __fill_dict_list[TProp](self, list_dict: list[str, TProp], values: T | list[T]) -> list[Column]:
         if issubclass(values.__class__, Table):
-            dicc: dict = {}
+            new_list = []
             for col in values.__dict__.values():
                 if isinstance(col, Column) and self.__is_valid(col):
-                    dicc.update({col.column_name: col.column_value})
-            list_dict.append(dicc)
-            return list_dict
+                    new_list.append(col)
+
+            list_dict.append(new_list)
 
         elif isinstance(values, Iterable):
             for x in values:
                 self.__fill_dict_list(list_dict, x)
         else:
             raise Exception(f"Tipo de dato'{type(values)}' no esperado")
+        return None

ormlambda/databases/my_sql/clauses/order.py

@@ -1,33 +1,47 @@
 from __future__ import annotations
-from typing import override, Callable, TYPE_CHECKING
+from typing import override, Callable, TYPE_CHECKING, Any, Iterable
+
+from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+
 
 if TYPE_CHECKING:
     from ormlambda import Table
 
-from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction
-from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
 from ormlambda.common.interfaces.IStatements import OrderType
 
-ASC = "ASC"
-DESC = "DESC"
 
-
-class OrderQuery[T:Table](IQuery):
+class OrderQuery[T: Table](DecompositionQueryBase[T]):
     ORDER = "ORDER BY"
 
-    def __init__(self, instance: T, order_lambda: Callable[[T], None], order_type: OrderType) -> None:
-        if not self._valid_order_type(order_type):
-            raise Exception("order_type only can be 'ASC' or 'DESC'")
+    def __init__[*Ts](self, instance: T, lambda_query: Callable[[Any], tuple[*Ts]], order_type: Iterable[OrderType]) -> None:
+        super().__init__(instance, lambda_query)
+
+        if isinstance(order_type, str) or not isinstance(order_type, Iterable):
+            order_type = (order_type,)
 
-        self._instance: T = instance
-        self._order_lambda: Callable[[T], None] = order_lambda
-        self._order_type: str = order_type
-        self._column: str = TreeInstruction(order_lambda).to_list()[0].nested_element.name
+        self._order_type: list[OrderType] = [self.__cast_to_OrderType(x) for x in order_type]
 
-    def _valid_order_type(self, _value: str) -> bool:
-        return _value in (ASC, DESC)
+    def __cast_to_OrderType(self, _value: Any) -> Iterable[OrderType]:
+        if isinstance(_value, OrderType):
+            return _value
+
+        if isinstance(_value, str):
+            try:
+                return OrderType(_value)
+            except Exception:
+                pass
+        raise Exception(f"order_type param only can be 'ASC' or 'DESC' string or '{OrderType.__name__}' enum")
+
+    def alias_children_resolver[Tclause](self, clause_info: ClauseInfo[Tclause]):
+        return None
 
     @override
     @property
     def query(self) -> str:
-        return f"{self.ORDER} {self._instance.__table_name__}.{self._column} {self._order_type}"
+        assert len(self.all_clauses) == len(self._order_type)
+
+        query: list[str] = []
+        for index, x in enumerate(self.all_clauses):
+            query.append(f"{x.query} {self._order_type[index].value}")
+        return f"{self.ORDER} {", ".join(query)}"

ormlambda/databases/my_sql/clauses/select.py

@@ -3,6 +3,7 @@ from typing import override, Type, Callable, TYPE_CHECKING
 from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
 from ormlambda.common.enums.join_type import JoinType
 from ormlambda.common.interfaces.IAggregate import IAggregate
+import shapely as shp
 
 if TYPE_CHECKING:
     from ormlambda import Table
@@ -32,17 +33,20 @@ class Select[T: Type[Table]](DecompositionQueryBase[T]):
     # def alias_children_resolver[Tclause: Type[Table]](self, clause_info: ClauseInfo[Tclause]):
     #     return f"{clause.table.__table_name__}_{name}"
 
+    # TODOL: see who to deal when we will have to add more mysql methods
     @override
     @property
     def query(self) -> str:
-        cols:list[str] = []
+        cols: list[str] = []
         for x in self.all_clauses:
-            cols.append(x.query)
+            if x.dtype is shp.Point:
+                cols.append(x.concat_with_alias(f"ST_AsText({self._table.__table_name__}.{x.column})"))
+            else:
+                cols.append(x.query)
 
-            if isinstance(x._row_column,IAggregate) and x._row_column.has_foreign_keys:
+            if isinstance(x._row_column, IAggregate) and x._row_column.has_foreign_keys:
                 self._fk_relationship.update(x._row_column.fk_relationship)
 
-
         col: str = ", ".join(cols)
         query: str = f"{self.CLAUSE} {col} FROM {self._table.__table_name__}"
         alias = ""

ormlambda/databases/my_sql/clauses/update.py

@@ -27,26 +27,20 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase[MySQLConnec
         if not isinstance(dicc, dict):
             raise TypeError
 
-        name_cols: list[str] = []
+        name_cols: list[Column] = []
 
         for col, value in dicc.items():
-            if isinstance(col, str):
-                string_col = col
-            else:
-                string_col = self._model.__properties_mapped__.get(col, None)
-                if not string_col:
-                    raise KeyError(f"Class '{self._model.__name__}' has not {col} mapped.")
-            if self.__is_valid__(string_col, value):
-                name_cols.append(string_col)
-                self._values.append(value)
-
-        set_query: str = ",".join(["=".join([col, "%s"]) for col in name_cols])
+            col: Column = self._model.get_column(col, value)
+
+            if self.__is_valid__(col):
+                name_cols.append(col)
+                self._values.append(col.column_value_to_query)
+
+        set_query: str = ",".join(["=".join([col.column_name, col.placeholder]) for col in name_cols])
 
         self._query = f"{self.CLAUSE} {self._model.__table_name__} SET {set_query}"
+        self._values = tuple(self._values)
         return None
 
-    def __is_valid__(self, col: str, value: Any) -> bool:
-        instance_table: Table = self._model(**{col: value})
-
-        column: Column = getattr(instance_table, f"_{col}")
-        return not column.is_auto_generated
+    def __is_valid__(self, col: Column) -> bool:
+        return not col.is_auto_generated

ormlambda/databases/my_sql/repository.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 from pathlib import Path
-from typing import Any, Optional, Type, override, Callable
+from typing import Any, Optional, Type, override, Callable, TYPE_CHECKING
 import functools
+import shapely as shp
 
 # from mysql.connector.pooling import MySQLConnectionPool
 from mysql.connector import MySQLConnection, Error  # noqa: F401
@@ -16,12 +17,20 @@ from .clauses import DropDatabase
 from .clauses import DropTable
 
 
+if TYPE_CHECKING:
+    from src.ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+    from ormlambda import Table
+    from src.ormlambda.databases.my_sql.clauses.select import Select
+
+
 class Response[TFlavour, *Ts]:
-    def __init__(self, response_values: list[tuple[*Ts]], columns: tuple[str], flavour: Type[TFlavour], **kwargs) -> None:
+    def __init__(self, response_values: list[tuple[*Ts]], columns: tuple[str], flavour: Type[TFlavour], model: Optional[Table] = None, select: Optional[Select] = None, **kwargs) -> None:
         self._response_values: list[tuple[*Ts]] = response_values
         self._columns: tuple[str] = columns
         self._flavour: Type[TFlavour] = flavour
         self._kwargs: dict[str, Any] = kwargs
+        self._model: Table = model
+        self._select: Select = select
 
         self._response_values_index: int = len(self._response_values)
         # self.select_values()
@@ -42,8 +51,10 @@ class Response[TFlavour, *Ts]:
     def response(self) -> tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]:
         if not self.is_there_response:
             return tuple([])
-
-        return tuple(self._cast_to_flavour(self._response_values))
+        clean_response = self._response_values
+        if self._select is not None:
+            clean_response = self._parser_response()
+        return tuple(self._cast_to_flavour(clean_response))
 
     def _cast_to_flavour(self, data: list[tuple[*Ts]]) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
         def _dict() -> list[dict[str, tuple[*Ts]]]:
@@ -73,6 +84,38 @@ class Response[TFlavour, *Ts]:
 
         return selector.get(self._flavour, _default)()
 
+    def _parser_response(self) -> TFlavour:
+        new_response: list[list] = []
+        for row in self._response_values:
+            new_row: list = []
+            for i, data in enumerate(row):
+                alias = self._columns[i]
+                clause_info = self._select[alias]
+                if not self._is_parser_required(clause_info):
+                    new_row = row
+                    break
+                else:
+                    parser_data = self.parser_data(clause_info, data)
+                    new_row.append(parser_data)
+            if not isinstance(new_row, tuple):
+                new_row = tuple(new_row)
+
+            new_response.append(new_row)
+        return new_response
+
+    @staticmethod
+    def _is_parser_required[T: Table](clause_info: ClauseInfo[T]) -> bool:
+        if clause_info is None:
+            return False
+
+        return clause_info.dtype is shp.Point
+
+    @staticmethod
+    def parser_data[T: Table, TProp](clause_info: ClauseInfo[T], data: TProp):
+        if clause_info.dtype is shp.Point:
+            return shp.from_wkt(data)
+        return data
+
 
 class MySQLRepository(IRepositoryBase[MySQLConnection]):
     def get_connection(func: Callable[..., Any]):
@@ -107,11 +150,19 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
             - flavour: Type[TFlavour]: Useful to return tuple of any Iterable type as dict,set,list...
         """
 
+        def get_and_drop_key(key: str) -> Optional[Any]:
+            if key in kwargs:
+                return kwargs.pop(key)
+            return None
+
+        model: Table = get_and_drop_key("model")
+        select: Select = get_and_drop_key("select")
+
         with cnx.cursor(buffered=True) as cursor:
             cursor.execute(query)
             values: list[tuple] = cursor.fetchall()
             columns: tuple[str] = cursor.column_names
-            return Response[TFlavour](response_values=values, columns=columns, flavour=flavour, **kwargs).response
+            return Response[TFlavour](model=model, response_values=values, columns=columns, flavour=flavour, select=select, **kwargs).response
 
     # FIXME [ ]: this method does not comply with the implemented interface
     @get_connection
@@ -192,7 +243,6 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     def create_database(self, name: str, if_exists: TypeExists = "fail") -> None:
         return CreateDatabase(self).execute(name, if_exists)
 
-
     @property
     def database(self) -> Optional[str]:
         return self._data_config.get("database", None)

ormlambda/databases/my_sql/statements.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 from typing import Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
 import inspect
 from mysql.connector import MySQLConnection, errors, errorcode
-
+import functools
 
 if TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.components.where.abstract_where import AbstractWhere
-    from ormlambda.common.interfaces.IStatements import OrderType
+    from ormlambda.common.interfaces.IStatements import OrderTypes
     from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
     from ormlambda.common.interfaces.IRepositoryBase import TypeExists
     from ormlambda.common.interfaces import IAggregate
@@ -34,6 +34,18 @@ from ormlambda.common.enums import JoinType
 from . import functions as func
 
 
+# COMMENT: It's so important to prevent information generated by other tests from being retained in the class.
+def clear_list(f: Callable[..., Any]):
+    @functools.wraps(f)
+    def wrapper(self: MySQLStatements, *args, **kwargs):
+        try:
+            return f(self, *args, **kwargs)
+        finally:
+            self._query_list.clear()
+
+    return wrapper
+
+
 class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
     def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
         super().__init__(model, repository=repository)
@@ -71,11 +83,11 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return self._repository.table_exists(self._model.__table_name__)
 
     @override
+    @clear_list
     def insert(self, instances: T | list[T]) -> None:
         insert = InsertQuery(self._model, self._repository)
         insert.insert(instances)
         insert.execute()
-        self._query_list.clear()
         return None
 
     @override
@@ -95,36 +107,33 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return None
 
     @override
+    @clear_list
     def upsert(self, instances: T | list[T]) -> None:
         upsert = UpsertQuery(self._model, self._repository)
         upsert.upsert(instances)
         upsert.execute()
-        self._query_list.clear()
         return None
 
     @override
+    @clear_list
     def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
         update = UpdateQuery(self._model, self._repository, self._query_list["where"])
         update.update(dicc)
         update.execute()
-        self._query_list.clear()
+
         return None
 
     @override
     def limit(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
         limit = LimitQuery(number)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
-        limit_list = self._query_list["limit"]
-        if len(limit_list) > 0:
-            self._query_list["limit"] = [limit]
-        else:
-            self._query_list["limit"].append(limit)
+        self._query_list["limit"] = [limit]
         return self
 
     @override
     def offset(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
         offset = OffsetQuery(number)
-        self._query_list["offset"].append(offset)
+        self._query_list["offset"] = [offset]
         return self
 
     @override
@@ -157,7 +166,7 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return self
 
     @override
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements_two_generic[T, MySQLConnection]:
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, MySQLConnection]:
         order = OrderQuery[T](self._model, _lambda_col, order_type)
         self._query_list["order"].append(order)
         return self
@@ -193,7 +202,7 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
 
         query: str = self._build()
         if flavour:
-            result = self._return_flavour(query, flavour)
+            result = self._return_flavour(query, flavour, select)
             if issubclass(flavour, tuple) and isinstance(selector(self._model), property):
                 return tuple([x[0] for x in result])
             return result
@@ -227,9 +236,9 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return self
 
     @override
+    @clear_list
     def _build(self) -> str:
-        query: str = ""
-
+        query_list: list[str] = []
         for x in self.__order__:
             sub_query: Optional[list[IQuery]] = self._query_list.get(x, None)
             if sub_query is None:
@@ -256,9 +265,8 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
             else:
                 query_ = "\n".join([x.query for x in sub_query])
 
-            query += f"\n{query_}" if query != "" else query_
-        self._query_list.clear()
-        return query
+            query_list.append(query_)
+        return "\n".join(query_list)
 
     def __build_where_clause(self, where_condition: list[AbstractWhere]) -> str:
         query: str = where_condition[0].query

ormlambda/utils/column.py

@@ -1,7 +1,14 @@
-from typing import Type
+from __future__ import annotations
+from typing import Type, Optional, Callable, TYPE_CHECKING, Any
+import shapely as sph
+
+if TYPE_CHECKING:
+    from .table_constructor import Field
 
 
 class Column[T]:
+    CHAR: str = "%s"
+
     __slots__ = (
         "dtype",
         "column_name",
@@ -31,22 +38,54 @@ class Column[T]:
         self.is_auto_increment: bool = is_auto_increment
         self.is_unique: bool = is_unique
 
+    @property
+    def column_value_to_query(self) -> T:
+        """
+        This property must ensure that any variable requiring casting by different database methods is properly wrapped.
+        """
+        if self.dtype is sph.Point:
+            return sph.to_wkt(self.column_value, -1)
+        return self.column_value
+
+    @property
+    def placeholder(self) -> str:
+        return self.placeholder_resolutor(self.dtype)
+
+    @property
+    def placeholder_resolutor(self) -> Callable[[Type, T], str]:
+        return self.__fetch_wrapped_method
+
+    # FIXME [ ]: this method is allocating the Column class with MySQL database
+    @classmethod
+    def __fetch_wrapped_method(cls, type_: Type) -> Optional[str]:
+        """
+        This method must ensure that any variable requiring casting by different database methods is properly wrapped.
+        """
+        caster: dict[Type[Any], Callable[[str], str]] = {
+            sph.Point: lambda x: f"ST_GeomFromText({x})",
+        }
+        return caster.get(type_, lambda x: x)(cls.CHAR)
+
     def __repr__(self) -> str:
-        return f"<Column: {self.column_name}>"
+        return f"<Column: {self.dtype}>"
 
-    def __to_string__(self, name: str, var_name: T, type_: str):
-        dicc: dict = {
-            "dtype": type_,
-            "column_name": f"'{name}'",
-            "column_value": var_name,  # must be the same variable name as the instance variable name in Table's __init__ class
+    def __to_string__(self, field: Field):
+        column_class_string: str = f"{Column.__name__}[{field.type_name}]("
+
+        dicc: dict[str, Callable[[Field], str]] = {
+            "dtype": lambda field: field.type_name,
+            "column_name": lambda field: f"'{field.name}'",
+            "column_value": lambda field: field.name,  # must be the same variable name as the instance variable name in Table's __init__ class
         }
-        exec_str: str = f"{Column.__name__}[{type_}]("
-        for x in self.__slots__:
-            self_value = getattr(self, x)
+        for self_var in self.__init__.__annotations__:
+            if not hasattr(self, self_var):
+                continue
+
+            self_value = dicc.get(self_var, lambda field: getattr(self, self_var))(field)
+            column_class_string += f" {self_var}={self_value}, "
 
-            exec_str += f"  {x}={dicc.get(x,self_value)},\n"
-        exec_str += ")"
-        return exec_str
+        column_class_string += ")"
+        return column_class_string
 
     def __hash__(self) -> int:
         return hash(

ormlambda/utils/dtypes.py

@@ -48,8 +48,10 @@ MySQL 8.0 does not support year in two-digit format.
 """
 
 from decimal import Decimal
-import datetime
 from typing import Any, Literal
+import datetime
+
+from shapely import Point
 import numpy as np
 
 from .column import Column
@@ -66,17 +68,7 @@ DATE = Literal["DATE", "DATETIME(fsp)", "TIMESTAMP(fsp)", "TIME(fsp)", "YEAR"]
 def transform_py_dtype_into_query_dtype(dtype: Any) -> str:
     # TODOL: must be found a better way to convert python data type into SQL clauses
     # float -> DECIMAL(5,2) is an error
-    dicc: dict[Any, str] = {
-        int: "INTEGER",
-        float: "FLOAT(5,2)",
-        Decimal: "FLOAT",
-        datetime.datetime: "DATETIME",
-        datetime.date: "DATE",
-        bytes: "BLOB",
-        bytearray: "BLOB",
-        str: "VARCHAR(255)",
-        np.uint64: "BIGINT UNSIGNED",
-    }
+    dicc: dict[Any, str] = {int: "INTEGER", float: "FLOAT(5,2)", Decimal: "FLOAT", datetime.datetime: "DATETIME", datetime.date: "DATE", bytes: "BLOB", bytearray: "BLOB", str: "VARCHAR(255)", np.uint64: "BIGINT UNSIGNED", Point: "Point"}
 
     res = dicc.get(dtype, None)
     if res is None:

ormlambda/utils/fields.py

@@ -0,0 +1,60 @@
+import typing as tp
+from .column import Column
+
+__all__ = ["get_fields"]
+
+MISSING = lambda: Column()  # COMMENT: Very Important to avoid reusing the same variable across different classes.  # noqa: E731
+
+
+class Field[TProp: tp.AnnotatedAny]:
+    def __init__(self, name: str, type_: tp.Type, default: Column[TProp]) -> None:
+        self.name: str = name
+        self.type_: tp.Type[TProp] = type_
+        self.default: Column[TProp] = default
+
+    def __repr__(self) -> str:
+        return f"{Field.__name__}(name = {self.name}, type_ = {self.type_}, default = {self.default})"
+
+    @property
+    def has_default(self) -> bool:
+        return self.default is not MISSING()
+
+    @property
+    def init_arg(self) -> str:
+        default = f"={self.default_name}"  # if self.has_default else ""}"
+        return f"{self.name}: {self.type_name}{default}"
+
+    @property
+    def default_name(self) -> str:
+        return f"_dflt_{self.name}"
+
+    @property
+    def type_name(self) -> str:
+        return f"_type_{self.name}"
+
+    @property
+    def assginment(self) -> str:
+        return f"self._{self.name} = {self.default.__to_string__(self)}"
+
+
+def get_fields[T, TProp](cls: tp.Type[T]) -> tp.Iterable[Field]:
+    # COMMENT: Used the 'get_type_hints' method to resolve typing when 'from __future__ import annotations' is in use
+    annotations = {key: val for key, val in tp.get_type_hints(cls).items() if not key.startswith("_")}
+
+    # delete_special_variables(annotations)
+    fields = []
+    for name, type_ in annotations.items():
+        if hasattr(type_, "__origin__") and type_.__origin__ is Column:  # __origin__ to get type of Generic value
+            field_type = type_.__args__[0]
+        else:
+            # type_ must by Column object
+            field_type: TProp = type_
+
+        default: Column = getattr(cls, name, MISSING())
+
+        default.dtype = field_type  # COMMENT: Useful for setting the dtype variable after instantiation.
+        fields.append(Field[TProp](name, field_type, default))
+
+        # Update __annotations__ to create Columns
+        cls.__annotations__[name] = default
+    return fields

ormlambda/utils/table_constructor.py

@@ -1,75 +1,21 @@
+from __future__ import annotations
+from decimal import Decimal
+from typing import Any, Optional, Type, dataclass_transform, overload, TYPE_CHECKING
 import base64
 import datetime
-from decimal import Decimal
-from typing import Any, Iterable, Optional, Type, dataclass_transform, get_type_hints
 import json
 
-from .dtypes import get_query_clausule
-from .module_tree.dfs_traversal import DFSTraversal
-from .column import Column
-
-from .foreign_key import ForeignKey, TableInfo
-
-MISSING = Column()
-
-
-class Field:
-    def __init__(self, name: str, type_: Type, default: object) -> None:
-        self.name: str = name
-        self.type_: Type = type_
-        self.default: Column = default
-
-    def __repr__(self) -> str:
-        return f"{Field.__name__}(name = {self.name}, type_ = {self.type_}, default = {self.default})"
-
-    @property
-    def has_default(self) -> bool:
-        return self.default is not MISSING
+import shapely as sph
 
-    @property
-    def init_arg(self) -> str:
-        # default = f"={self.default_name if self.has_default else None}"
-        default = f"={None}"
 
-        return f"{self.name}: {self.type_name}{default}"
-
-    @property
-    def default_name(self) -> str:
-        return f"_dflt_{self.name}"
-
-    @property
-    def type_name(self) -> str:
-        return f"_type_{self.name}"
-
-    @property
-    def assginment(self) -> str:
-        return f"self._{self.name} = {self.default.__to_string__(self.name,self.name,self.type_name)}"
-
-
-def delete_special_variables(dicc: dict[str, object]) -> None:
-    keys = tuple(dicc.keys())
-    for key in keys:
-        if key.startswith("__"):
-            del dicc[key]
-
-
-def get_fields[T](cls: Type[T]) -> Iterable[Field]:
-    # COMMENT: Used the 'get_type_hints' method to resolve typing when 'from __future__ import annotations' is in use
-    annotations = {key: val for key, val in get_type_hints(cls).items() if not key.startswith("_")}
-
-    # delete_special_variables(annotations)
-    fields = []
-    for name, type_ in annotations.items():
-        # type_ must by Column object
-        field_type = type_
-        if hasattr(type_, "__origin__") and type_.__origin__ is Column:  # __origin__ to get type of Generic value
-            field_type = type_.__args__[0]
-        default: Column = getattr(cls, name, MISSING)
-        fields.append(Field(name, field_type, default))
+from .column import Column
+from .dtypes import get_query_clausule
+from .fields import get_fields
+from .foreign_key import ForeignKey, TableInfo
+from .module_tree.dfs_traversal import DFSTraversal
 
-        # Update __annotations__ to create Columns
-        cls.__annotations__[name] = Column[field_type]
-    return fields
+if TYPE_CHECKING:
+    from .fields import Field
 
 
 @dataclass_transform()
@@ -78,23 +24,32 @@ def __init_constructor__[T](cls: Type[T]) -> Type[T]:
     # TODOL: I don't know if it's better to create a global dictionary like in commit '7de69443d7a8e7264b8d5d604c95da0e5d7e9cc0'
     setattr(cls, "__properties_mapped__", {})
     fields = get_fields(cls)
-    locals_ = {}
-    init_args = []
+
+    locals_: dict[str, Any] = {}
+    init_args: list[str] = ["self"]
+    assignments: list[str] = []
 
     for field in fields:
-        if not field.name.startswith("__"):
-            locals_[field.type_name] = field.type_
+        if field.name.startswith("__"):
+            continue
+
+        locals_[field.type_name] = field.type_
+        locals_[field.default_name] = field.default.column_value
 
-            init_args.append(field.init_arg)
-            locals_[field.default_name] = None  # field.default.column_value
-            __create_properties(cls, field)
+        init_args.append(field.init_arg)
+        assignments.append(field.assginment)
+        __create_properties(cls, field)
+
+    string_locals_ = ", ".join(locals_)
+    string_init_args = ", ".join(init_args)
+    string_assignments = "\n\t\t".join(assignments)
 
     wrapper_fn = "\n".join(
         [
-            f"def wrapper({', '.join(locals_.keys())}):",
-            f" def __init__(self, {', '.join(init_args)}):",
-            "\n".join([f"  {f.assginment}" for f in fields]) or "  pass",
-            " return __init__",
+            f"def wrapper({string_locals_}):",
+            f"\n\tdef __init__({string_init_args}):",
+            f"\n\t\t{string_assignments}",
+            "\treturn __init__",
         ]
     )
 
@@ -109,11 +64,11 @@ def __init_constructor__[T](cls: Type[T]) -> Type[T]:
 
 def __create_properties(cls: Type["Table"], field: Field) -> property:
     _name: str = f"_{field.name}"
-    type_ = field.type_
+
     # we need to get Table attributes (Column class) and then called __getattribute__ or __setattr__ to make changes inside of Column
     prop = property(
-        fget=lambda self: __transform_getter(getattr(self, _name), type_),
-        fset=lambda self, value: __transform_setter(getattr(self, _name), value, type_),
+        fget=lambda self: getattr(self, _name).__getattribute__("column_value"),
+        fset=lambda self, value: getattr(self, _name).__setattr__("column_value", value),
     )
 
     # set property in public name
@@ -122,22 +77,6 @@ def __create_properties(cls: Type["Table"], field: Field) -> property:
     return None
 
 
-def __transform_getter[T](obj: object, type_: T) -> T:
-    return obj.__getattribute__("column_value")
-
-    # if type_ is str and isinstance(eval(obj), Iterable):
-    #     getter = eval(obj)
-    # return getter
-
-
-def __transform_setter[T](obj: object, value: Any, type_: T) -> None:
-    return obj.__setattr__("column_value", value)
-
-    # if type_ is list:
-    #     setter = str(setter)
-    # return None
-
-
 class TableMeta(type):
     def __new__[T](cls: "Table", name: str, bases: tuple, dct: dict[str, Any]) -> Type[T]:
         """
@@ -244,6 +183,7 @@ class Table(metaclass=TableMeta):
             Decimal: str,
             bytes: byte_to_string,
             set: list,
+            sph.Point: lambda x: sph.to_wkt(x, rounding_precision=-1),
         }
 
         if (dtype := type(_value)) in transform_map:
@@ -324,3 +264,35 @@ class Table(metaclass=TableMeta):
                 )
             )
         return False
+
+    @classmethod
+    def get_property_name(cls, _property: property) -> str:
+        name: str = cls.__properties_mapped__.get(_property, None)
+        if not name:
+            raise KeyError(f"Class '{cls.__name__}' has not propery '{_property}' mapped.")
+        return name
+
+    @overload
+    @classmethod
+    def get_column(cls, column: str) -> Column: ...
+    @overload
+    @classmethod
+    def get_column(cls, column: property) -> Column: ...
+    @overload
+    @classmethod
+    def get_column[TProp](cls, column: property, value: TProp) -> Column[TProp]: ...
+    @overload
+    @classmethod
+    def get_column[TProp](cls, column: str, value: TProp) -> Column[TProp]: ...
+    @classmethod
+    def get_column[TProp](cls, column: str | property, value: Optional[TProp] = None) -> Column[TProp]:
+        if isinstance(column, property):
+            _column = cls.get_property_name(column)
+        elif isinstance(column, str) and column in cls.get_columns():
+            _column = column
+        else:
+            raise ValueError(f"'Column' param with value'{column}' is not expected.")
+
+        instance_table: Table = cls(**{_column: value})
+
+        return getattr(instance_table, f"_{_column}")

{ormlambda-2.8.0.dist-info → ormlambda-2.9.0.dist-info}/METADATA

@@ -1,14 +1,15 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.8.0
+Version: 2.9.0
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: fluent-validation (>=3.1.0,<4.0.0)
+Requires-Dist: fluent-validation (==4.3.1)
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
+Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown
 
 ![PyPI version](https://img.shields.io/pypi/v/ormlambda.svg)

{ormlambda-2.8.0.dist-info → ormlambda-2.9.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-ormlambda/__init__.py,sha256=L-Enc4FPmW3ldBMnWOU3gLn9i4FEc7sQzLWy2mIEti8,538
+ormlambda/__init__.py,sha256=lWQxjf2cQ2bXenNaDpoy2Bar6imiPlzc4nK0hkIYhC0,723
 ormlambda/common/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 ormlambda/common/abstract_classes/__init__.py,sha256=tk2J4Mn_nD-1ZjtMVBE5FH7KR_8ppN_1Kx1s6c38GjM,167
-ormlambda/common/abstract_classes/abstract_model.py,sha256=0mGoW-MF0bX1VrAp2AJZ8Nk_BV7N_2NtzZoUFCg5Wm4,4595
-ormlambda/common/abstract_classes/decomposition_query.py,sha256=c-Vo0f2dnVCv9Qsmqt9AZaZAYvyYhtZFdc3HKyHCMZ0,11396
+ormlambda/common/abstract_classes/abstract_model.py,sha256=W7E3DDeFeQbnBX0ccLqmhUX3dCHHDCADK3bT2wyPEtk,4618
+ormlambda/common/abstract_classes/decomposition_query.py,sha256=0k1cTFftZZaRmjuYOEnZ-r7nqljTwcSlz1ZbEElnlbk,12586
 ormlambda/common/abstract_classes/non_query_base.py,sha256=5jhvyT7OZaJxlGp9XMP3vQ4ei5QQZBn-fFtJnD640mE,980
 ormlambda/common/abstract_classes/query_base.py,sha256=6qUFPwsVx45kUW3b66pHiSyjhcH4mzbdkddlGeUnG7c,266
 ormlambda/common/enums/__init__.py,sha256=4lVKCHi1JalwgNzjsAXqX-C54NJEH83y2v5baMO8fN4,103
@@ -13,7 +13,7 @@ ormlambda/common/interfaces/IDecompositionQuery.py,sha256=dHdCxezbWwy-c4U4po2hQB
 ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
 ormlambda/common/interfaces/IQueryCommand.py,sha256=hfzCosK4-n8RJIb2PYs8b0qU3TNmfYluZXBf47KxxKs,331
 ormlambda/common/interfaces/IRepositoryBase.py,sha256=zGm7tDrFLKj3FMYN-MWI-em3INws27g2yByNYYMx0qk,1126
-ormlambda/common/interfaces/IStatements.py,sha256=df3pGRFSwyBcFct0ntMy8E9RNCHreXTO-qirdetS05M,10674
+ormlambda/common/interfaces/IStatements.py,sha256=XJ0hCp7_7wMclPvZmavpdr7unQshOXKZDasgVk6RfwU,10409
 ormlambda/common/interfaces/__init__.py,sha256=00ca9a-u_A8DzyEyxPfBMxfqLKFzzUgJaeNmoRitAbA,360
 ormlambda/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ormlambda/components/delete/IDelete.py,sha256=06ZEdbKBxsHSwsGMBu0E1om4WJjojZAm-L3b95eQrcc,139
@@ -39,13 +39,13 @@ ormlambda/databases/my_sql/clauses/delete.py,sha256=nUKNQgwF5YUfzk2icWpecYjrGk5D
 ormlambda/databases/my_sql/clauses/drop_database.py,sha256=nMM0YUbcH0D9X3bU70Uc6S_dsIrAZy-IrYuIKrQZNrg,505
 ormlambda/databases/my_sql/clauses/drop_table.py,sha256=meX4e-pVPQ7UwlPSHV5e9HHRblI1BlkLSc7ssl8WUiI,592
 ormlambda/databases/my_sql/clauses/group_by.py,sha256=xG8YhdaDWBm99EFMkzCsBJNhHOJy5lvXmpaHu3jClro,1042
-ormlambda/databases/my_sql/clauses/insert.py,sha256=LO9H8VVK3j62dICXqpEUXKxOHPxkD1LGvogmDq2zmho,2805
+ormlambda/databases/my_sql/clauses/insert.py,sha256=mnOy62U4go0Ub6tmmgn8DRRWvPN12WRE5lqpCNbyR70,3136
 ormlambda/databases/my_sql/clauses/joins.py,sha256=U6JnUvQo7AXyEeK-X1jMvckXefgAB7ugSmJCZhH1XQI,3058
 ormlambda/databases/my_sql/clauses/limit.py,sha256=a4lI8FVRKpfXwBQTXdkbVtlQkmzcjE20ymiCy1IaSc4,391
 ormlambda/databases/my_sql/clauses/offset.py,sha256=81170JhsQndjKlDfQj1ll-tiYHQbW8SuU4IE3mhQF7Y,395
-ormlambda/databases/my_sql/clauses/order.py,sha256=RVqyEtD0InnOPAmRvjtNJ-vrAy0V9OHMLoFB8TkpX0I,1137
-ormlambda/databases/my_sql/clauses/select.py,sha256=unJBteFK5D360KnIPyqz8OMaVJqXJlI5Kkp6u0JJ1vU,1574
-ormlambda/databases/my_sql/clauses/update.py,sha256=3Htw0_PT3EckEiF214-V2r63lcNoRBroKZI9yg48Ddg,1867
+ormlambda/databases/my_sql/clauses/order.py,sha256=XTMtR5ObAJxq8eTHp392rykQD991ecJ95dyXXLUpgeU,1680
+ormlambda/databases/my_sql/clauses/select.py,sha256=o0gjCt8cZfTkMsJwZcCt0XkSeFa2rlKz-0Ymi7XL5xU,1833
+ormlambda/databases/my_sql/clauses/update.py,sha256=d2nSLiGe8OUk0ASgGxchit_1DL-Yg8U-DUtBbgpfkto,1571
 ormlambda/databases/my_sql/clauses/upsert.py,sha256=eW2pQ4ax-GKuXiaWKoSRSS1GrHuILJBsmj83ADbBQ34,1951
 ormlambda/databases/my_sql/clauses/where_condition.py,sha256=UgU5vnTqFAx91wKwnECpww5tETDZ9F7IdC_SiZOgZhI,8336
 ormlambda/databases/my_sql/functions/__init__.py,sha256=hA8t3mUpV2p-pO4TVp5rjC5Yp7aIkWPsS8NpLi3DUh0,171
@@ -53,12 +53,13 @@ ormlambda/databases/my_sql/functions/concat.py,sha256=cZztl5eSATpYMKVKfyPbul6Ooc
 ormlambda/databases/my_sql/functions/max.py,sha256=zrO_RBKsHhyokEmSpPI6Yg5OY6Jf4GGp2RveBJdOuuA,1190
 ormlambda/databases/my_sql/functions/min.py,sha256=SEVuUdIJNz9zM5za1kLTWalFkhErjsjyBb8SU8n0F94,1190
 ormlambda/databases/my_sql/functions/sum.py,sha256=akKYr2dI8TZS5MDvybfHn_idhPOvEH0cj6mDRQIHe-M,1188
-ormlambda/databases/my_sql/repository.py,sha256=fSAAmO_T5mC1bodOVZn5CY9JSfRq4VhsdlWT1JLl7Zw,6927
-ormlambda/databases/my_sql/statements.py,sha256=inUEyLUl3Z6TxE7PpJUWw0SZBoO_JbnrS_XL_wCyHn4,11873
+ormlambda/databases/my_sql/repository.py,sha256=fj_RcMY6QhANvKRyfAnu6PEfvkrpiBXrlTvmeXUf5Vo,8823
+ormlambda/databases/my_sql/statements.py,sha256=ukP8ypxegCnxOuIEH99pNgWVUyOP-ELHD6GzfLEWUx4,12045
 ormlambda/model_base.py,sha256=RrAATQWX_bHJ0ZQ5sCHyJKA4NiR7ZJY4I6dqhnGWWAc,1216
 ormlambda/utils/__init__.py,sha256=ywMdWqmA2jHj19-W-S04yfaYF5hv4IZ1lZDq0B8Jnjs,142
-ormlambda/utils/column.py,sha256=5FAGzCU4yvNS4MhwJJ5i73h7RvHD5UCVox0NdzMsMiE,1945
-ormlambda/utils/dtypes.py,sha256=1kRsT5JggNS1DMWgSUdBb67CefQHnZ-VTN1WI7nN2yQ,7879
+ormlambda/utils/column.py,sha256=SqbX8N63_RwXNrMXuVMOpatDw--aLc47o3kG1sEXhNs,3413
+ormlambda/utils/dtypes.py,sha256=Ji4QOyKD0n9bKe7yXIIduy9uEX5BaXolQSIsx0NXYJY,7843
+ormlambda/utils/fields.py,sha256=jyUJXJKblhLGqFGgAXkWJeE0FYLd5Ywd7H2pjQsfz8c,2128
 ormlambda/utils/foreign_key.py,sha256=ewGLPtf1MrFogvwGm_jsSnOLAH2G9virXvLcc3co36I,2973
 ormlambda/utils/lambda_disassembler/__init__.py,sha256=q23_F2Vp1_XgVpQSbWQPM5wxzRCZOr7ZMb9X5VG_YxU,229
 ormlambda/utils/lambda_disassembler/dis_types.py,sha256=Myuo9-KSBIJSyr9jfLSDDe1jbrzyOqZNLufv6ODHm98,4824
@@ -70,8 +71,8 @@ ormlambda/utils/lambda_disassembler/tree_instruction.py,sha256=QUnhG89WKJyAlEWAj
 ormlambda/utils/module_tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ormlambda/utils/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkjptDbK3IugXm8iU,1425
 ormlambda/utils/module_tree/dynamic_module.py,sha256=zwvjU3U2cz6H2CDp9Gncs5D5bSAyfITNa2SDqFDl8rw,8551
-ormlambda/utils/table_constructor.py,sha256=8Apm44K6MiYMK3PQyK74MUV18OatbFI9eDLAVklQO0w,11660
-ormlambda-2.8.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
-ormlambda-2.8.0.dist-info/METADATA,sha256=HV3vUXqD2StgsPEk4VwRtPLp44DRjIUgSoMTRsWAkNw,8428
-ormlambda-2.8.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ormlambda-2.8.0.dist-info/RECORD,,
+ormlambda/utils/table_constructor.py,sha256=ch1geCSJIQnnv_D_uzfYk6do533kjtZyeCIh2t0_dkU,10863
+ormlambda-2.9.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-2.9.0.dist-info/METADATA,sha256=t2WNOq0P72brj6Qr1h_PXY0oXRJ85NjY6oYbn7l2REs,8461
+ormlambda-2.9.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-2.9.0.dist-info/RECORD,,