ormlambda 4.4.0__tar.gz → 4.4.14__tar.gz

{ormlambda-4.4.0 → ormlambda-4.4.14}/PKG-INFO

@@ -1,12 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ormlambda
-Version: 4.4.0
+Version: 4.4.14
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
+License-File: AUTHORS
+License-File: LICENSE
 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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 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
@@ -76,7 +80,7 @@ db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
 AddressModel = ORM(Address, db)
 
-result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
+result = AddressModel.where(lambda x: x.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
         address,
         address.City,
@@ -104,7 +108,7 @@ result = AddressModel.where(
 Additionally, we can filter by others tables. For example, we can return all addresses for each city where `country_id` = 87 (Spain)
 
 ```python
-result = AddressModel.where(Address.City.Country.country_id  == 87).select()
+result = AddressModel.where(lambda x: x.City.Country.country_id  == 87).select()
 ```
 
 We can also return `Address`, `City` or `Country` if needed.

{ormlambda-4.4.0 → ormlambda-4.4.14}/README.md

@@ -63,7 +63,7 @@ db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
 AddressModel = ORM(Address, db)
 
-result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
+result = AddressModel.where(lambda x: x.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
         address,
         address.City,
@@ -91,7 +91,7 @@ result = AddressModel.where(
 Additionally, we can filter by others tables. For example, we can return all addresses for each city where `country_id` = 87 (Spain)
 
 ```python
-result = AddressModel.where(Address.City.Country.country_id  == 87).select()
+result = AddressModel.where(lambda x: x.City.Country.country_id  == 87).select()
 ```
 
 We can also return `Address`, `City` or `Country` if needed.

{ormlambda-4.4.0 → ormlambda-4.4.14}/pyproject.toml

@@ -1,9 +1,6 @@
-[tool.ruff]
-line-length = 320
-
 [tool.poetry]
 name = "ormlambda"
-version = "4.4.0"
+version = "4.4.14"
 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"
@@ -21,8 +18,27 @@ ruff = "^0.4.5"
 parameterized = "^0.9.0"
 pydantic = "^2.11.1"
 sqlserver = "^0.0.17.1"
+pytest = "^8.4.2"
+
+[tool.ruff]
+line-length = 320
 
+[tool.pytest.ini_options]
+testpaths = ["src/test"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-v",                    # verbose output
+    "--strict-markers",      # error on unknown markers
+    "--tb=short",           # shorter traceback format
+]
+
+markers = [
+    "slow: Slow test (deselect with '-m \"not slow\"')",
+]
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/__init__.py

@@ -80,4 +80,16 @@ from .sql import functions as functions
 from .sql.functions import *  # noqa: F403
 from . import util as _util
 
+
+from .sql.column.metadata import PrimaryKey as PrimaryKey
+from .sql.column.metadata import AutoGenerated as AutoGenerated
+from .sql.column.metadata import AutoIncrement as AutoIncrement
+from .sql.column.metadata import Unique as Unique
+from .sql.column.metadata import CheckTypes as CheckTypes
+from .sql.column.metadata import Default as Default
+from .sql.column.metadata import NotNull as NotNull
+
+from ormlambda.statements.interfaces import IStatements as IStatements
+from ormlambda.engine import Engine as Engine
+
 _util.import_prefix("ormlambda")

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/common/__init__.py

@@ -1 +1,2 @@
 from .global_checker import GlobalChecker as GlobalChecker
+from .constants import DOT as DOT

ormlambda-4.4.14/src/ormlambda/common/constants.py

@@ -0,0 +1 @@
+DOT = "."

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/common/enums/union_type.py

@@ -6,4 +6,4 @@ class UnionEnum(str, enum.Enum):
     OR = "OR"
 
     def __str__(self):
-        return super().__str__()
+        return super().__str__()

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/common/errors/__init__.py

@@ -6,6 +6,17 @@ from ormlambda import util
 
 if tp.TYPE_CHECKING:
     from ormlambda.sql.clause_info import ClauseInfo
+    from ormlambda.sql import Column
+
+
+class ReplacePlaceholderError(ValueError):
+    def __init__(self, placeholder: str, attribute: str, *args):
+        super().__init__(*args)
+        self.placeholder: str = placeholder
+        self.attr: str = attribute
+
+    def __str__(self):
+        return "You cannot use {" + self.placeholder + "} placeholder without using '" + self.attr + "' attribute"
 
 
 class UnmatchedLambdaParameterError(Exception):
@@ -42,7 +53,7 @@ class FunctionFunctionError[T](Exception):
         Get the class name of those classes that inherit from 'IFunction' class in order to create a better error message.
         """
 
-        IFunction = util.preloaded.sql_functions.IFunction 
+        IFunction = util.preloaded.sql_functions.IFunction
         res: set[str] = set()
         if not isinstance(clauses, tp.Iterable):
             return clauses.__class__.__name__
@@ -58,3 +69,44 @@ class NotCallableError(ValueError):
 
     def __str__(self) -> str:
         return f"You must provide a function or callable to proceed with the query creation. Passed '{self.args[0].__class__.__name__}' "
+
+
+class CompileError(Exception):
+    """Exception raised for errors in the compilation process."""
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return f"CompileError: {self.message}"
+
+
+class NoSuchModuleError(Exception):
+    """Raised when a dynamically-loaded module (usually a database dialect)
+    of a particular name cannot be located."""
+
+    def __str__(self):
+        return f"NoSuchModuleError: {self.args[0]}"
+
+
+class DuplicatedClauseNameError(Exception):
+    def __init__(self, names: tuple[str], **kw):
+        self.names = names
+        super().__init__(**kw)
+
+    def __str__(self):
+        return f"Some clauses has the same alias. {self.names}\nTry wrapping the clause with the 'Alias' class first or setting 'avoid_duplicates' param as 'True'"
+
+
+class ColumnError(ValueError):
+    def __init__(self, column: Column, *args):
+        super().__init__(*args)
+        self.column = column
+        self.clause: str = ""
+
+    def set_clause(self, value: str) -> None:
+        self.clause = value
+
+    def __str__(self):
+        return f"The column '{self.column.column_name}' does not exist. Check the name you used inside of '{self.clause}' clause."

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/common/global_checker.py

@@ -29,7 +29,7 @@ class GlobalChecker[T: TableProxy]:
         try:
             table_proxy = TableProxy(table)
 
-            if not callable(lambda_func): 
+            if not callable(lambda_func):
                 raise NotCallableError(lambda_func)
 
             if isinstance(lambda_func, Iterable):

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/dialects/mysql/base.py

@@ -11,15 +11,6 @@ from .. import default
 from typing import TYPE_CHECKING, Any, Iterable, Type
 from ormlambda.sql.comparer import Comparer, ComparerCluster
 
-if TYPE_CHECKING:
-    from ormlambda.sql.functions.interface import IFunction
-    from ormlambda.sql.types import ColumnType
-    from test.test_clause_info import ST_Contains
-    from ormlambda import JoinSelector
-    from ormlambda.sql.column.column import Column
-    from mysql import connector
-    from ormlambda.dialects.mysql.clauses import ST_AsText
-
 from .types import (
     _NumericType,
     _NumericCommonType,
@@ -64,6 +55,14 @@ from .repository import MySQLRepository
 
 
 if TYPE_CHECKING:
+    from ormlambda.sql.functions.interface import IFunction
+    from ormlambda.sql.types import ColumnType
+    from test.test_clause_info import ST_Contains
+    from ormlambda import JoinSelector
+    from ormlambda.sql.column.column import Column
+    from mysql import connector
+    from ormlambda.dialects.mysql.clauses import ST_AsText
+
     from ormlambda.sql.clauses import (
         Select,
         Insert,
@@ -103,10 +102,10 @@ class MySQLCompiler(compiler.SQLCompiler):
 
     def visit_table_proxy(self, table: TableProxy, **kw) -> str:
         param = {
-            "table": None,
-            "column": table._table_class.__table_name__,
-            "dialect": self.dialect,
+            "table": table._table_class,
+            "column": None,
             "alias_clause": alias if (alias := table.get_table_chain()) else None,
+            "dialect": self.dialect,
             **kw,
         }
         return ClauseInfo(**param).query(dialect=self.dialect)
@@ -129,7 +128,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         params = {
             "table": column.table,
             "column": column,
-            "alias_table": alias_table if alias_table else "{table}",
+            "alias_table": alias_table,
             "alias_clause": column.alias or "{column}",
             "dtype": column._column.dtype,
             "dialect": self.dialect,
@@ -167,7 +166,7 @@ class MySQLCompiler(compiler.SQLCompiler):
 
         return f"{lcond} {comparer.compare} {rcond}"
 
-    def visit_where(self, where: Where) -> str:
+    def visit_where(self, where: Where, sep: str = " ", **kw) -> str:
         assert (n := len(where.comparers)) == len(where.restrictive)
 
         if not where.comparers:
@@ -178,17 +177,17 @@ class MySQLCompiler(compiler.SQLCompiler):
         for i in range(n):
             comp = where.comparers[i]
 
-            string = comp.compile(self.dialect).string
+            string = comp.compile(self.dialect, **kw).string
 
             condition = f"({string})" if isinstance(comp, ComparerCluster) else string
 
-            union = f" {where.restrictive[i + 1]} " if i != n - 1 else ""
+            union = f" {where.restrictive[i + 1]}{sep}" if i != n - 1 else ""
 
             condition += union
             cond.append(condition)
-        return f" WHERE {"".join(cond)}"
+        return f"WHERE{sep}{''.join(cond)}"
 
-    def visit_having(self, having: Having) -> str:
+    def visit_having(self, having: Having, sep: str = " ", **kw) -> str:
         assert (n := len(having.comparers)) == len(having.restrictive)
 
         if not having.comparers:
@@ -199,23 +198,23 @@ class MySQLCompiler(compiler.SQLCompiler):
         for i in range(n):
             comp = having.comparers[i]
 
-            string = comp.compile(self.dialect).string
+            string = comp.compile(self.dialect, **kw).string
 
             condition = f"({string})" if isinstance(comp, ComparerCluster) else string
 
-            union = f" {having.restrictive[i + 1]} " if i != n - 1 else ""
+            union = f" {having.restrictive[i + 1]}{sep}" if i != n - 1 else ""
 
             condition += union
             cond.append(condition)
-        return f" HAVING {"".join(cond)}"
+        return f"HAVING{sep}{''.join(cond)}"
 
     def visit_join(self, join: JoinSelector) -> str:
         rt = join.rcon.table
         rtable = TableProxy(table_class=rt, path=join.rcon.path)
 
-        from_clause = rtable.compile(self.dialect, alias_clause=join.alias).string
+        from_clause = rtable.compile(self.dialect, alias_table=join.alias, first_apperance=True).string
         left_table_clause = join.lcon.compile(self.dialect, alias_clause=None).string
-        right_table_clause = join.rcon.compile(self.dialect, alias_table=join.alias, alias_clause=None).string
+        right_table_clause = join.rcon.compile(self.dialect, alias_clause=None).string
         list_ = [
             join._by.value,  # inner join
             from_clause,
@@ -226,7 +225,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         ]
         return " ".join([x for x in list_ if x is not None])
 
-    def visit_select(self, select: Select):
+    def visit_select(self, select: Select, sep: str = " ", **kw):
         params = {}
 
         # COMMENT: when passing alias into 'select' method, we gonna replace the current aliases of columns with the generic one.
@@ -236,15 +235,17 @@ class MySQLCompiler(compiler.SQLCompiler):
         elif select.alias:
             params["alias_clause"] = select.alias
 
-        columns = ClauseInfo.join_clauses(select.columns, ",", dialect=self.dialect, **params)
+        columns = ClauseInfo.join_clauses(select.columns, sep, dialect=self.dialect, **params)
+
         from_ = ClauseInfo(
-            select._table,
-            None,
-            alias_table=select._alias_table,
+            table=select._table,
+            column=None,
+            alias_table="{table}",
             dialect=self.dialect,
+            first_apperance=True,
         ).query(self.dialect)
 
-        return f"SELECT {columns} FROM {from_}"
+        return f"SELECT{sep}{columns}{sep}FROM {from_}"
 
     def visit_group_by(self, groupby: GroupBy):
         column = ", ".join(x.compile(self.dialect, alias_clause=None).string for x in groupby.column)
@@ -320,11 +321,18 @@ class MySQLCompiler(compiler.SQLCompiler):
         unknown_rows = f"({', '.join(wildcards)})"  # The number of "%s" must match the dict 'dicc_0' length
 
         insert.cleaned_values = [tuple(x) for x in col_values]
-        query = f"INSERT INTO {insert.table.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
+        query = f"INSERT INTO {self.visit_table(insert.table)} {f'({join_cols})'} VALUES {unknown_rows}"
         return query
 
     def visit_delete(self, delete: Delete, **kw) -> str:
-        return f"DELETE FROM {delete.table.__table_name__}"
+        query = f"DELETE FROM {self.visit_table(delete.table)}"
+
+        if delete.where.comparers:
+            # COMMENT: We need to change the Where.restrictive due to if we use more than one where, we want to use "OR" instead "AND"
+            for x in range(len(delete.where.restrictive)):
+                delete.where.restrictive[x] = "OR"
+            query += " " + delete.where.compile(self.dialect).string
+        return query
 
     def visit_upsert(self, upsert: Upsert, **kw) -> str:
         """
@@ -436,6 +444,11 @@ class MySQLCompiler(compiler.SQLCompiler):
         set_query: str = ",".join(["=".join(col_data) for col_data in col_names])
 
         query = f"UPDATE {update.table.__table_name__} SET {set_query}"
+
+        if update.where.comparers:
+            where_string = update.where.compile(self.dialect).string
+
+            query += " " + where_string
         update.cleaned_values = tuple(update.cleaned_values)
         return query
 
@@ -452,7 +465,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         else:
             column = count.column
 
-        return ClauseInfo.concat_alias_and_column(f"COUNT({column})", count.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"COUNT({column})", count.alias)
 
     def visit_order(self, order: Order, **kw) -> str:
         ORDER = "ORDER BY"
@@ -499,10 +512,10 @@ class MySQLCompiler(compiler.SQLCompiler):
         clause_info = ClauseInfo(
             table=None,
             column=f"CONCAT({', '.join(columns)})",
-            alias_clause=concat.alias,
             dialect=self.dialect,
+            literal=True
         )
-        return clause_info.query(self.dialect)
+        return f"{clause_info.query(self.dialect)} AS {ClauseInfo.wrapped_with_quotes(concat.alias)}" 
 
     def visit_max(self, obj: Max, **kw) -> str:
         return self._compile_aggregate_method("MAX", obj, **kw)
@@ -531,7 +544,7 @@ class MySQLCompiler(compiler.SQLCompiler):
     def visit_pow(self, obj: Pow, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = obj.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"POW({column}, {obj._exponent})", obj.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"POW({column}, {obj._exponent})", obj.alias)
 
     def visit_sqrt(self, obj: Sqrt, **kw) -> str:
         return self._compile_aggregate_method("SQRT", obj, **kw)
@@ -539,7 +552,7 @@ class MySQLCompiler(compiler.SQLCompiler):
     def visit_mod(self, obj: Mod, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = obj.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"MOD({column}, {obj._divisor})", obj.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"MOD({column}, {obj._divisor})", obj.alias)
 
     def visit_rand(self, obj: Rand, **kw) -> str:
         return self._compile_aggregate_method("RAND", obj, **kw)
@@ -547,28 +560,30 @@ class MySQLCompiler(compiler.SQLCompiler):
     def visit_truncate(self, obj: Truncate, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = obj.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"TRUNCATE({column}, {obj._decimal})", obj.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"TRUNCATE({column}, {obj._decimal})", obj.alias)
 
     def _compile_aggregate_method(self, name: str, function: IFunction, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = function.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"{name}({column})", function.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"{name}({column})", function.alias)
 
     def visit_st_astext(self, st_astext: ST_AsText) -> str:
         # avoid use placeholder when using IFunction because no make sense.
         if st_astext.alias and (found := ClauseInfo._keyRegex.findall(st_astext.alias)):
             raise NotKeysInIFunctionError(found)
-        return ClauseInfo.concat_alias_and_column(f"ST_AsText({st_astext.column.compile(self.dialect, alias_clause=None).string})", st_astext.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"ST_AsText({st_astext.column.compile(self.dialect, alias_clause=None).string})", st_astext.alias)
 
     def visit_st_contains(self, st_contains: ST_Contains) -> str:
+        # FIXME [ ]: It's not working as expected. Should be something like
+        # ST_Contains(`table_type`.points, ST_GeomFromText(%s))
         attr1 = st_contains.column.compile(self.dialect, alias_clause=None).string
-        attr2 = ClauseInfo(None, st_contains.point, dialect=self.dialect).query(self.dialect, alias_clause=None)
+        attr2 = ClauseInfo(None, st_contains.point, dialect=self.dialect).query(self.dialect)
         return f"ST_Contains({attr1}, {attr2})"
 
 
 class MySQLDDLCompiler(compiler.DDLCompiler):
     def get_column_specification(self, column: Column, **kwargs):
-        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dbtype)
+        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dtype)
         default = self.get_column_default_string(column)
         if default is not None:
             colspec += " DEFAULT " + default
@@ -587,7 +602,8 @@ class MySQLDDLCompiler(compiler.DDLCompiler):
         compare = fk.resolved_function()
         lcon = compare.left_condition
         rcon = compare.right_condition
-        return f"FOREIGN KEY ({lcon.column_name}) REFERENCES {rcon.table.__table_name__}({rcon.column_name})"
+        rdb = f"{ClauseInfo.wrapped_with_quotes(db)}." if (db := compare.right_condition.table.__db_name__) else ""
+        return f"FOREIGN KEY ({lcon.column_name}) REFERENCES {rdb}{rcon.table.__table_name__}({rcon.column_name})"
 
 
 class MySQLTypeCompiler(compiler.GenericTypeCompiler):

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/dialects/mysql/caster/caster.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from typing import Union
 from ormlambda.caster.caster import Caster
 
 
@@ -41,5 +42,6 @@ class MySQLCaster(Caster):
             list: IterableCaster,
             bool: BooleanCaster,
             Decimal: DecimalCaster,
-            dict:JsonCaster
+            dict: JsonCaster,
+            Union[list | dict]: JsonCaster,
         }

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/dialects/mysql/caster/types/__init__.py

@@ -9,4 +9,4 @@ from .iterable import IterableCaster as IterableCaster
 from .boolean import BooleanCaster as BooleanCaster
 from .date import DateCaster as DateCaster
 from .decimal import DecimalCaster as DecimalCaster
-from .json import JsonCaster as JsonCaster 
+from .json import JsonCaster as JsonCaster

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/dialects/mysql/caster/types/json.py

@@ -2,6 +2,7 @@ from typing import Optional
 from ormlambda.caster import BaseCaster, Caster
 import json
 
+
 class JsonCaster[TType](BaseCaster[dict, TType]):
     def __init__(self, value: dict, type_value: TType):
         super().__init__(value, type_value)

ormlambda-4.4.14/src/ormlambda/dialects/mysql/repository/__init__.py

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

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/dialects/mysql/repository/repository.py

@@ -187,8 +187,6 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
     @override
     def table_exists(self, name: str) -> bool:
         with self.get_connection() as cnx:
-            if not cnx.database:
-                raise Exception("No database selected")
             with cnx.cursor(buffered=True) as cursor:
                 cursor.execute(f"SHOW TABLES LIKE {Caster.PLACEHOLDER};", (name,))
             res = cursor.fetchmany(1)

{ormlambda-4.4.0 → ormlambda-4.4.14}/src/ormlambda/repository/response.py

@@ -5,8 +5,10 @@ import shapely as shp
 
 # Custom libraries
 from ormlambda.sql.clauses import Alias
+from ormlambda import ColumnProxy
 
 if TYPE_CHECKING:
+    from ormlambda.sql.types import SelectCol
     from ormlambda.sql.clause_info import ClauseInfo
     from ormlambda import Table
     from ormlambda.sql.clauses import Select
@@ -69,12 +71,11 @@ class Response[TFlavour, *Ts]:
             nonlocal data
             result = []
             for value in data:
-                if len(value) ==1:
+                if len(value) == 1:
                     result.append(value[0])
                     continue
                 result.append(value)
 
-
             return result
 
         def _set(**kwargs) -> list[set]:
@@ -130,7 +131,7 @@ class Response[TFlavour, *Ts]:
             for i, data in enumerate(row):
                 alias = self._columns[i]
                 clause = self._select[alias]
-                dtype = clause.dtype if hasattr(clause, "dtype") else None
+                dtype = self.get_python_type(clause)
                 parse_data = self._caster.for_value(data, value_type=dtype).from_database
                 new_row.append(parse_data)
             new_row = tuple(new_row)
@@ -146,3 +147,12 @@ class Response[TFlavour, *Ts]:
             return False
 
         return clause_info.dtype is shp.Point
+
+    @staticmethod
+    def get_python_type[T](value: SelectCol) -> Type[T]:
+        if isinstance(value, ColumnProxy):
+            return value.dtype.python_type
+
+        if hasattr(value, "dtype"):
+            return value.dtype
+        return None