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

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,21 @@ 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
+
+type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
+
+
 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) -> 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()
@@ -38,21 +48,28 @@ class Response[TFlavour, *Ts]:
     def is_many(self) -> bool:
         return self._response_values_index > 1
 
-    @property
-    def response(self) -> tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]:
+    def response(self, _tuple: bool, **kwargs) -> TResponse[TFlavour, *Ts]:
         if not self.is_there_response:
             return tuple([])
+        cleaned_response = self._response_values
+
+        if self._select is not None:
+            cleaned_response = self._parser_response()
 
-        return tuple(self._cast_to_flavour(self._response_values))
+        cast_flavour = self._cast_to_flavour(cleaned_response, **kwargs)
+        if _tuple is not True:
+            return cast_flavour
 
-    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]]]:
+        return tuple(cast_flavour)
+
+    def _cast_to_flavour(self, data: list[tuple[*Ts]], **kwargs) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
+        def _dict(**kwargs) -> list[dict[str, tuple[*Ts]]]:
             return [dict(zip(self._columns, x)) for x in data]
 
-        def _tuple() -> list[tuple[*Ts]]:
+        def _tuple(**kwargs) -> list[tuple[*Ts]]:
             return data
 
-        def _set() -> list[set]:
+        def _set(**kwargs) -> list[set]:
             for d in data:
                 n = len(d)
                 for i in range(n):
@@ -62,16 +79,52 @@ class Response[TFlavour, *Ts]:
                         raise TypeError(f"unhashable type '{type(d[i])}' found in '{type(d)}' when attempting to cast the result into a '{set.__name__}' object")
             return [set(x) for x in data]
 
-        def _default() -> list[TFlavour]:
-            return [self._flavour(x, **self._kwargs) for x in data]
+        def _list(**kwargs) -> list[list]:
+            return [list(x) for x in data]
+
+        def _default(**kwargs) -> list[TFlavour]:
+            return self._flavour(data, **kwargs)
 
         selector: dict[Type[object], Any] = {
             dict: _dict,
             tuple: _tuple,
             set: _set,
+            list: _list,
         }
 
-        return selector.get(self._flavour, _default)()
+        return selector.get(self._flavour, _default)(**kwargs)
+
+    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]):
@@ -80,8 +133,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         def wrapper(self: MySQLRepository, *args, **kwargs):
             with self._pool.get_connection() as cnx:
                 try:
-                    foo = func(self, cnx._cnx, *args, **kwargs)
-                    return foo
+                    return func(self, cnx._cnx, *args, **kwargs)
                 except Exception as e:
                     cnx._cnx.rollback()
                     raise e
@@ -97,7 +149,13 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
 
     @override
     @get_connection
-    def read_sql[TFlavour](self, cnx: MySQLConnection, query: str, flavour: Type[TFlavour] = tuple, **kwargs) -> tuple[TFlavour]:
+    def read_sql[TFlavour](
+        self,
+        cnx: MySQLConnection,
+        query: str,
+        flavour: Type[TFlavour] = tuple,
+        **kwargs,
+    ) -> tuple[TFlavour]:
         """
         Return tuple of tuples by default.
 
@@ -107,11 +165,15 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
             - flavour: Type[TFlavour]: Useful to return tuple of any Iterable type as dict,set,list...
         """
 
+        model: Table = kwargs.pop("model", None)
+        select: Select = kwargs.pop("select", None)
+        cast_to_tuple: bool = kwargs.pop("cast_to_tuple", True)
+
         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).response(_tuple=cast_to_tuple, **kwargs)
 
     # FIXME [ ]: this method does not comply with the implemented interface
     @get_connection
@@ -192,7 +254,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,17 +2,20 @@ 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
     from ormlambda.common.interfaces.IStatements import WhereTypes
 
+from ormlambda.utils.foreign_key import ForeignKey
+
 from ormlambda import AbstractSQLStatements
 from .clauses import DeleteQuery
 from .clauses import InsertQuery
@@ -29,13 +32,25 @@ from .clauses import Count
 from .clauses import GroupBy
 
 
-from ormlambda.utils import ForeignKey, Table
+from ormlambda.utils import Table
 from ormlambda.common.enums import JoinType
 from . import functions as func
 
 
-class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
-    def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
+# 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, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnection]):
+    def __init__(self, model: tuple[T, *Ts], repository: IRepositoryBase[MySQLConnection]) -> None:
         super().__init__(model, repository=repository)
 
     @property
@@ -71,11 +86,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 +110,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
@@ -132,24 +144,17 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         self,
         selection: Callable[[T], tuple] = lambda x: "*",
         alias=True,
-        alias_name=None,
+        alias_name="count",
     ) -> IQuery:
         return Count[T](self._model, selection, alias=alias, alias_name=alias_name)
 
-    @override
-    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements_two_generic[T, MySQLConnection]:
-        where = ForeignKey.MAPPED[table_left.__table_name__][table_right.__table_name__]
-        join_query = JoinSelector[table_left, Table](table_left, table_right, JoinType(by), where=where)
-        self._query_list["join"].append(join_query)
-        return self
-
     @override
     def where(self, conditions: WhereTypes = lambda: None, **kwargs) -> IStatements_two_generic[T, MySQLConnection]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
 
         if isinstance(conditions, Iterable):
             for x in conditions:
-                self._query_list["where"].append(WhereCondition[T](function=x, instances=(self._model,), **kwargs))
+                self._query_list["where"].append(WhereCondition[T](function=x, instances=self._models, **kwargs))
             return self
 
         where_query = WhereCondition[T](function=conditions, instances=(self._model,), **kwargs)
@@ -157,7 +162,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
@@ -179,7 +184,19 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return func.Sum[T](self._model, column=column, alias=alias, alias_name=alias_name)
 
     @override
-    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+    def join[*FKTables](self, joins) -> IStatements_two_generic[T, *FKTables, MySQLConnection]:
+        if not isinstance(joins[0], tuple):
+            joins = (joins,)
+        new_tables: list[Type[Table]] = [self._model]
+        for table, where in joins:
+            new_tables.append(table)
+            join_query = JoinSelector[T, type(table)](self._model, table, by=JoinType.INNER_JOIN, where=where)
+            self._query_list["join"].append(join_query)
+        self._models = new_tables
+        return self
+
+    @override
+    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN, **kwargs):
         if len(inspect.signature(selector).parameters) == 0:
             # COMMENT: if we do not specify any lambda function we assumed the user want to retreive only elements of the Model itself avoiding other models
             result = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
@@ -188,19 +205,28 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
             if flavour:
                 return result
             return () if not result else result[0]
-        select = Select[T](self._model, lambda_query=selector, by=by, alias=False)
+
+        joins = self._query_list.pop("join", None)
+        select = Select[T, *Ts](
+            self._models,
+            lambda_query=selector,
+            by=by,
+            alias=False,
+            joins=joins,
+        )
         self._query_list["select"].append(select)
 
-        query: str = self._build()
+        self._query: str = self._build()
+        
         if flavour:
-            result = self._return_flavour(query, flavour)
-            if issubclass(flavour, tuple) and isinstance(selector(self._model), property):
+            result = self._return_flavour(self.query, flavour, select, **kwargs)
+            if issubclass(flavour, tuple) and isinstance(selector(*self._models), property):
                 return tuple([x[0] for x in result])
             return result
-        return self._return_model(select, query)
+        return self._return_model(select, self.query)
 
     @override
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
         self.limit(1)
         if len(inspect.signature(selector).parameters) == 0:
             response = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
@@ -217,48 +243,42 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return tuple([res[0] for res in response])
 
     @override
-    def group_by[*Ts](self, column: str | Callable[[T], Any]) -> IStatements_two_generic[T, MySQLConnection]:
+    def group_by(self, column: str | Callable[[T, *Ts], Any]):
         if isinstance(column, str):
-            groupby = GroupBy[T, tuple[*Ts]](self._model, lambda x: column)
+            groupby = GroupBy[T, tuple[*Ts]](self._models, lambda x: column)
         else:
-            groupby = GroupBy[T, tuple[*Ts]](self._model, column)
+            groupby = GroupBy[T, tuple[*Ts]](self._models, column)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
         self._query_list["group by"].append(groupby)
         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 len(self._query_list) == 0:
+                break
+
+            sub_query: Optional[list[IQuery]] = self._query_list.pop(x, None)
             if sub_query is None:
                 continue
 
             if isinstance(sub_query[0], WhereCondition):
                 query_ = self.__build_where_clause(sub_query)
 
-            # we must check if any join already exists on query string
-            elif isinstance(sub_query[0], JoinSelector):
-                select_query: str = self._query_list["select"][0].query
-                query_ = ""
-                for join in sub_query:
-                    if join.query not in select_query:
-                        query_ += f"\n{join.query}"
-
             elif isinstance((select := sub_query[0]), Select):
                 query_: str = ""
                 where_joins = self.__create_necessary_inner_join()
                 if where_joins:
-                    select._fk_relationship.update(where_joins)
+                    select._joins.update(where_joins)
                 query_ = select.query
 
             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
@@ -269,18 +289,21 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
             query += f" {and_} ({clause})"
         return query
 
-    def __create_necessary_inner_join(self) -> Optional[set[tuple[Type[Table], Type[Table]]]]:
+    def __create_necessary_inner_join(self) -> Optional[set[JoinSelector]]:
         # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
         if "where" not in self._query_list:
             return None
 
-        res = []
         for where in self._query_list["where"]:
             where: AbstractWhere
 
             tables = where.get_involved_tables()
 
             if tables:
-                [res.append(x) for x in tables]
-
-        return set(res)
+                # FIXME [ ]: Refactor to avoid copy and paste the same code of the '_add_fk_relationship' method
+                joins = []
+                for ltable, rtable in tables:
+                    lambda_relationship = ForeignKey.MAPPED[ltable.__table_name__].referenced_tables[rtable.__table_name__].relationship
+                    joins.append(JoinSelector(ltable, rtable, JoinType.INNER_JOIN, where=lambda_relationship))
+                return set(joins)
+        return None

ormlambda/model_base.py

@@ -10,20 +10,20 @@ from .databases.my_sql import MySQLStatements, MySQLRepository
 # endregion
 
 
-class BaseModel[T: Type[Table]]:
+class BaseModel[T: Type[Table], *Ts]:
     """
     Class to select the correct AbstractSQLStatements class depends on the repository.
 
     Contiene los metodos necesarios para hacer consultas a una tabla
     """
 
-    statements_dicc: dict[Type[IRepositoryBase], Type[AbstractSQLStatements[T, IRepositoryBase]]] = {
+    statements_dicc: dict[Type[IRepositoryBase], Type[AbstractSQLStatements[T, *Ts, IRepositoryBase]]] = {
         MySQLRepository: MySQLStatements,
     }
 
     # region Constructor
 
-    def __new__[TRepo](cls, model: T, repository: IRepositoryBase[TRepo]) -> IStatements_two_generic[T, TRepo]:
+    def __new__[TRepo](cls, model: tuple[T, *Ts], repository: IRepositoryBase[TRepo]) -> IStatements_two_generic[T, *Ts, TRepo]:
         if repository is None:
             raise ValueError("`None` cannot be passed to the `repository` attribute when calling the `BaseModel` class")
         cls: AbstractSQLStatements[T, TRepo] = cls.statements_dicc.get(type(repository), None)

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