ormlambda 2.7.2__py3-none-any.whl → 2.9.0__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,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,44 +107,43 @@ 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
-    def count(self, selection: Callable[[T], tuple] = lambda x: "*") -> int:
-        count_select: IQuery = Select[T](self._model, lambda x: Count[T](self._model, selection))
-        self._query_list["select"].append(count_select)
-        query = self._build()
-        return self.repository.read_sql(query)[0][0]
+    def count(
+        self,
+        selection: Callable[[T], tuple] = lambda x: "*",
+        alias=True,
+        alias_name=None,
+    ) -> 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]:
@@ -155,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
@@ -172,6 +183,10 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
     def min[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "min") -> TProp:
         return func.Min[T](self._model, column=column, alias=alias, alias_name=alias_name)
 
+    @override
+    def sum[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "sum") -> TProp:
+        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):
         if len(inspect.signature(selector).parameters) == 0:
@@ -187,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
@@ -211,13 +226,19 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return tuple([res[0] for res in response])
 
     @override
-    def group_by[TRepo, *Ts](self, column: Callable[[T], TRepo], select_query: Callable[[T], tuple[*Ts]]) -> tuple[tuple[*Ts]]:
-        return GroupBy[T, TRepo, tuple[*Ts]](self._model, column, select_query)
+    def group_by[*Ts](self, column: str | Callable[[T], Any]) -> IStatements_two_generic[T, MySQLConnection]:
+        if isinstance(column, str):
+            groupby = GroupBy[T, tuple[*Ts]](self._model, lambda x: column)
+        else:
+            groupby = GroupBy[T, tuple[*Ts]](self._model, 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 sub_query is None:
@@ -244,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.7.2.dist-info → ormlambda-2.9.0.dist-info}/METADATA

@@ -1,14 +1,15 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.7.2
+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)