ormlambda 2.8.0__tar.gz → 2.9.0__tar.gz

{ormlambda-2.8.0 → ormlambda-2.9.0}/PKG-INFO

@@ -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 → ormlambda-2.9.0}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "2.8.0"
+version = "2.9.0"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"
@@ -11,12 +11,14 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.12"
 mysql-connector-python= "^9.0.0"
-fluent-validation = "^3.1.0"
+fluent-validation = "4.3.1"
+shapely = "^2.0.6"
 
 [tool.poetry.group.test.dependencies]
 pandas = "^2.2.2"
 ruff = "^0.4.5"
 python-decouple = "^3.8"
+parameterized = "^0.9.0"
 
 
 [build-system]

ormlambda-2.9.0/src/ormlambda/__init__.py

@@ -0,0 +1,20 @@
+# 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 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-2.8.0 → ormlambda-2.9.0}/src/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-2.8.0 → ormlambda-2.9.0}/src/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-2.8.0 → ormlambda-2.9.0}/src/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-2.8.0 → ormlambda-2.9.0}/src/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-2.9.0/src/ormlambda/databases/my_sql/clauses/order.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+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.common.abstract_classes.decomposition_query import DecompositionQueryBase
+from ormlambda.common.interfaces.IStatements import OrderType
+
+
+class OrderQuery[T: Table](DecompositionQueryBase[T]):
+    ORDER = "ORDER BY"
+
+    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._order_type: list[OrderType] = [self.__cast_to_OrderType(x) for x in order_type]
+
+    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:
+        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-2.8.0 → ormlambda-2.9.0}/src/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-2.8.0 → ormlambda-2.9.0}/src/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-2.8.0 → ormlambda-2.9.0}/src/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)