ormlambda 3.34.1__tar.gz → 3.34.5__tar.gz

{ormlambda-3.34.1 → ormlambda-3.34.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.34.1
+Version: 3.34.5
 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

{ormlambda-3.34.1 → ormlambda-3.34.5}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.34.1"
+version = "3.34.5"
 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"

{ormlambda-3.34.1 → ormlambda-3.34.5}/src/ormlambda/__init__.py

@@ -24,3 +24,36 @@ from .model.base_model import (
 )  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
 
 from .engine import create_engine, URL, make_url  # noqa: F401
+
+from .sql.sqltypes import (  # noqa: F401
+    JSON as JSON,
+    UUID as UUID,
+    NullType as NullType,
+    INTEGER as INTEGER,
+    INT as INT,
+    SMALLINTEGER as SMALLINTEGER,
+    BIGINTEGER as BIGINTEGER,
+    NUMERIC as NUMERIC,
+    FLOAT as FLOAT,
+    REAL as REAL,
+    DOUBLE as DOUBLE,
+    DECIMAL as DECIMAL,
+    STRING as STRING,
+    TEXT as TEXT,
+    UNICODE as UNICODE,
+    UNICODETEXT as UNICODETEXT,
+    CHAR as CHAR,
+    NCHAR as NCHAR,
+    BLOB as BLOB,
+    VARCHAR as VARCHAR,
+    NVARCHAR as NVARCHAR,
+    DATE as DATE,
+    TIME as TIME,
+    DATETIME as DATETIME,
+    TIMESTAMP as TIMESTAMP,
+    BOOLEAN as BOOLEAN,
+    LARGEBINARY as LARGEBINARY,
+    VARBINARY as VARBINARY,
+    ENUM as ENUM,
+    POINT as POINT,
+)

{ormlambda-3.34.1 → ormlambda-3.34.5}/src/ormlambda/dialects/mysql/base.py

@@ -10,7 +10,10 @@ if TYPE_CHECKING:
 
 from .types import (
     _NumericType,
+    _NumericCommonType,
     _StringType,
+    VARCHAR,
+    CHAR,
     NUMERIC,
     DECIMAL,
     DOUBLE,
@@ -36,7 +39,15 @@ from .types import (
     MEDIUMBLOB,
     LONGBLOB,
 )
-from ormlambda.sql.sqltypes import BLOB
+from ormlambda.sql.sqltypes import (
+    LARGEBINARY,
+    BLOB,
+    BOOLEAN,
+    DATE,
+    UUID,
+    VARBINARY,
+)
+
 
 from ormlambda.databases.my_sql import MySQLRepository, MySQLCaster
 
@@ -73,7 +84,7 @@ class MySQLCompiler(compiler.SQLCompiler):
     """Overridden from base SQLCompiler value"""
 
     def visit_select(self, select: Select, **kw):
-        return f"{select.CLAUSE} {select.COLUMNS} FROM {select.FROM.query(self.dialect,**kw)}"
+        return f"{select.CLAUSE} {select.COLUMNS} FROM {select.FROM.query(self.dialect, **kw)}"
 
     def visit_group_by(self, groupby: GroupBy, **kw):
         column = groupby._create_query(self.dialect, **kw)
@@ -110,7 +121,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         context = ClauseInfoContext(table_context=order._context._table_context, clause_context=None) if order._context else None
         for index, clause in enumerate(order._convert_into_clauseInfo(columns, context, dialect=self.dialect)):
             clause.alias_clause = None
-            string_columns.append(f"{clause.query(self.dialect,**kw)} {str(order._order_type[index])}")
+            string_columns.append(f"{clause.query(self.dialect, **kw)} {str(order._order_type[index])}")
 
         return f"{order.FUNCTION_NAME()} {', '.join(string_columns)}"
 
@@ -122,7 +133,7 @@ class MySQLCompiler(compiler.SQLCompiler):
 
 class MySQLDDLCompiler(compiler.DDLCompiler):
     def get_column_specification(self, column: Column, **kwargs):
-        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dtype)
+        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dbtype)
         default = self.get_column_default_string(column)
         if default is not None:
             colspec += " DEFAULT " + default
@@ -164,7 +175,7 @@ class MySQLTypeCompiler(compiler.GenericTypeCompiler):
             return getattr(type_, name, defaults.get(name))
 
         if attr("charset"):
-            charset = f"CHARACTER SET {attr("charset")}"
+            charset = f"CHARACTER SET {attr('charset')}"
         elif attr("ascii"):
             charset = "ASCII"
         elif attr("unicode"):
@@ -184,183 +195,238 @@ class MySQLTypeCompiler(compiler.GenericTypeCompiler):
             return " ".join([c for c in ("NATIONAL", spec, collation) if c is not None])
         return " ".join([c for c in (spec, charset, collation) if c is not None])
 
-    def visit_INTEGER(self, type_: INTEGER, **kw):
-        if self.mysql_type(type_) and type_.display_width is not None:
+    def _mysql_type(self, type_, **kw):
+        return isinstance(type, _StringType | _NumericCommonType)
+
+    def visit_NUMERIC(self, type_: NUMERIC, **kw):
+        if type_.precision is None:
+            return self._extend_numeric(type_, "NUMERIC")
+        elif type_.scale is None:
             return self._extend_numeric(
                 type_,
-                f"INTEGER(%({type_.display_width})s)",
+                f"NUMERIC({type_.precision})",
             )
         else:
-            return self._extend_numeric(type_, "INTEGER")
-
-    def visit_VARCHAR(self, type_, **kw):
-        if type_.length is None:
-            raise ValueError("VARCHAR requires a length on dialect %s" % self.dialect.name)
-        return self._extend_string(type_, {}, "VARCHAR(%d)" % type_.length)
-
-    def visit_CHAR(self, type_, **kw):
-        if type_.length is not None:
-            return self._extend_string(type_, {}, "CHAR(%(length)s)" % {"length": type_.length})
-        else:
-            return self._extend_string(type_, {}, "CHAR")
-
-    def visit_NUMERIC(self, type_: NUMERIC, **kw):
-        return "NUMERIC"
+            return self._extend_numeric(
+                type_,
+                f"NUMERIC({type_.precision}, {type_.scale})",
+            )
 
     def visit_DECIMAL(self, type_: DECIMAL, **kw):
-        return "DECIMAL"
+        if type_.precision is None:
+            return self._extend_numeric(type_, "DECIMAL")
+        elif type_.scale is None:
+            return self._extend_numeric(
+                type_,
+                f"DECIMAL({type_.precision})",
+            )
+        else:
+            return self._extend_numeric(
+                type_,
+                f"DECIMAL({type_.precision}, {type_.scale})",
+            )
 
     def visit_DOUBLE(self, type_: DOUBLE, **kw):
-        return "DOUBLE"
+        if type_.precision is not None and type_.scale is not None:
+            return self._extend_numeric(
+                type_,
+                f"DOUBLE({type_.precision}, {type_.scale})",
+            )
+        else:
+            return self._extend_numeric(type_, "DOUBLE")
 
     def visit_REAL(self, type_: REAL, **kw):
-        return "REAL"
+        if type_.precision is not None and type_.scale is not None:
+            return self._extend_numeric(
+                type_,
+                f"REAL({type_.precision}, {type_.scale})",
+            )
+        else:
+            return self._extend_numeric(type_, "REAL")
 
     def visit_FLOAT(self, type_: FLOAT, **kw):
-        return "FLOAT"
+        if self._mysql_type(type_) and type_.scale is not None and type_.precision is not None:
+            return self._extend_numeric(type_, f"FLOAT({type_.precision}, {type_.scale})")
+        elif type_.precision is not None:
+            return self._extend_numeric(type_, f"FLOAT({type_.precision})")
+        else:
+            return self._extend_numeric(type_, "FLOAT")
+
+    def visit_INTEGER(self, type_: INTEGER, **kw):
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"INTEGER({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "INTEGER")
 
     def visit_BIGINT(self, type_: BIGINT, **kw):
-        return "BIGINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"BIGINT({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "BIGINT")
 
     def visit_MEDIUMINT(self, type_: MEDIUMINT, **kw):
-        return "MEDIUMINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"MEDIUMINT({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "MEDIUMINT")
 
     def visit_TINYINT(self, type_: TINYINT, **kw):
-        return "TINYINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(type_, f"TINYINT({type_.display_width})")
+        else:
+            return self._extend_numeric(type_, "TINYINT")
 
     def visit_SMALLINT(self, type_: SMALLINT, **kw):
-        return "SMALLINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"SMALLINT({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "SMALLINT")
 
     def visit_BIT(self, type_: BIT, **kw):
-        return "BIT"
+        if type_.length is not None:
+            return f"BIT({type_.length})"
+        else:
+            return "BIT"
+
+    def visit_DATETIME(self, type_: DATETIME, **kw):
+        if getattr(type_, "fsp", None):
+            return f"DATETIME({type_.fsp})"
+        else:
+            return "DATETIME"
+
+    def visit_DATE(self, type_: DATE, **kw):
+        return "DATE"
 
     def visit_TIME(self, type_: TIME, **kw):
-        return "TIME"
+        if getattr(type_, "fsp", None):
+            return f"TIME({type_.fsp})"
+        else:
+            return "TIME"
 
     def visit_TIMESTAMP(self, type_: TIMESTAMP, **kw):
-        return "TIMESTAMP"
-
-    def visit_DATETIME(self, type_: DATETIME, **kw):
-        return "DATETIME"
+        if getattr(type_, "fsp", None):
+            return f"TIMESTAMP({type_.fsp})"
+        else:
+            return "TIMESTAMP"
 
     def visit_YEAR(self, type_: YEAR, **kw):
-        return "YEAR"
+        if type_.display_width is None:
+            return "YEAR"
+        else:
+            return f"YEAR({type_.display_width})"
 
     def visit_TEXT(self, type_: TEXT, **kw):
         if type_.length is not None:
             return self._extend_string(type_, {}, f"TEXT({type_.length})")
-        return self._extend_string(type_, {}, "TEXT")
+        else:
+            return self._extend_string(type_, {}, "TEXT")
 
     def visit_TINYTEXT(self, type_: TINYTEXT, **kw):
-        return "TINYTEXT"
+        return self._extend_string(type_, {}, "TINYTEXT")
 
     def visit_MEDIUMTEXT(self, type_: MEDIUMTEXT, **kw):
-        return "MEDIUMTEXT"
+        return self._extend_string(type_, {}, "MEDIUMTEXT")
 
     def visit_LONGTEXT(self, type_: LONGTEXT, **kw):
-        return "LONGTEXT"
-
-    def visit_NVARCHAR(self, type_: NVARCHAR, **kw):
-        return "NVARCHAR"
-
-    def visit_NCHAR(self, type_: NCHAR, **kw):
-        return "NCHAR"
-
-    def visit_TINYBLOB(self, type_: TINYBLOB, **kw):
-        return "TINYBLOB"
-
-    def visit_BLOB(self, type_: BLOB, **kw) -> str:
-        blob = "BLOB"
-        blob += f"({type_.length})" if type_.length is not None else ""
-        return blob
-
-    def visit_MEDIUMBLOB(self, type_: MEDIUMBLOB, **kw):
-        return "MEDIUMBLOB"
-
-    def visit_LONGBLOB(self, type_: LONGBLOB, **kw):
-        return "LONGBLOB"
-
-    # region visit lowercase
-
-    def visit_integer(self, type_: INTEGER, **kw):
-        return self.visit_INTEGER(type_, **kw)
-
-    def visit_varchar(self, type_, **kw):
-        return self.visit_VARCHAR(type_, **kw)
-
-    def visit_char(self, type_, **kw):
-        return self.visit_CHAR(type_, **kw)
-
-    def visit_numeric(self, type_: NUMERIC, **kw):
-        return self.visit_NUMERIC(type_, **kw)
-
-    def visit_decimal(self, type_: DECIMAL, **kw):
-        return self.visit_DECIMAL(type_, **kw)
-
-    def visit_double(self, type_: DOUBLE, **kw):
-        return self.visit_DOUBLE(type_, **kw)
+        return self._extend_string(type_, {}, "LONGTEXT")
 
-    def visit_real(self, type_: REAL, **kw):
-        return self.visit_REAL(type_, **kw)
-
-    def visit_float(self, type_: FLOAT, **kw):
-        return self.visit_FLOAT(type_, **kw)
-
-    def visit_bigint(self, type_: BIGINT, **kw):
-        return self.visit_BIGINT(type_, **kw)
-
-    def visit_mediumint(self, type_: MEDIUMINT, **kw):
-        return self.visit_MEDIUMINT(type_, **kw)
-
-    def visit_tinyint(self, type_: TINYINT, **kw):
-        return self.visit_TINYINT(type_, **kw)
+    def visit_VARCHAR(self, type_: VARCHAR, **kw):
+        if type_.length is not None:
+            return self._extend_string(type_, {}, f"VARCHAR({type_.length})")
+        else:
+            raise ValueError(f"VARCHAR requires a length on dialect {self.dialect.name}")
 
-    def visit_smallint(self, type_: SMALLINT, **kw):
-        return self.visit_SMALLINT(type_, **kw)
+    def visit_CHAR(self, type_: CHAR, **kw):
+        if type_.length is not None:
+            return self._extend_string(type_, {}, f"CHAR({type_.length})")
+        else:
+            return self._extend_string(type_, {}, "CHAR")
 
-    def visit_bit(self, type_: BIT, **kw):
-        return self.visit_BIT(type_, **kw)
+    def visit_NVARCHAR(self, type_: NVARCHAR, **kw):
+        # We'll actually generate the equiv. "NATIONAL VARCHAR" instead
+        # of "NVARCHAR".
+        if type_.length is not None:
+            return self._extend_string(
+                type_,
+                {"national": True},
+                f"VARCHAR({type_.length})",
+            )
+        else:
+            raise ValueError(f"NVARCHAR requires a length on dialect {self.dialect.name}")
 
-    def visit_time(self, type_: TIME, **kw):
-        return self.visit_TIME(type_, **kw)
+    def visit_NCHAR(self, type_: NCHAR, **kw):
+        # We'll actually generate the equiv.
+        # "NATIONAL CHAR" instead of "NCHAR".
+        if type_.length is not None:
+            return self._extend_string(
+                type_,
+                {"national": True},
+                f"CHAR({type_.length})",
+            )
+        else:
+            return self._extend_string(type_, {"national": True}, "CHAR")
 
-    def visit_timestamp(self, type_: TIMESTAMP, **kw):
-        return self.visit_TIMESTAMP(type_, **kw)
+    def visit_UUID(self, type_: UUID, **kw):
+        return "UUID"
 
-    def visit_datetime(self, type_: DATETIME, **kw):
-        return self.visit_DATETIME(type_, **kw)
+    def visit_VARBINARY(self, type_: VARBINARY, **kw):
+        return f"VARBINARY({type_.length})"
 
-    def visit_year(self, type_: YEAR, **kw):
-        return self.visit_YEAR(type_, **kw)
+    def visit_JSON(self, type_, **kw):
+        return "JSON"
 
-    def visit_text(self, type_: TEXT, **kw):
-        return self.visit_TEXT(type_, **kw)
+    def visit_large_binary(self, type_: LARGEBINARY, **kw):
+        return self.visit_BLOB(type_)
 
-    def visit_tinytext(self, type_: TINYTEXT, **kw):
-        return self.visit_TINYTEXT(type_, **kw)
+    def visit_enum(self, type_, **kw):
+        if not type_.native_enum:
+            return super().visit_enum(type_)
+        else:
+            return self.visit_ENUM(type_, type_.enums)
 
-    def visit_mediumtext(self, type_: MEDIUMTEXT, **kw):
-        return self.visit_MEDIUMTEXT(type_, **kw)
+    def visit_BLOB(self, type_: BLOB, **kw):
+        if type_.length is not None:
+            return f"BLOB({type_.length})"
+        else:
+            return "BLOB"
 
-    def visit_longtext(self, type_: LONGTEXT, **kw):
-        return self.visit_LONGTEXT(type_, **kw)
+    def visit_TINYBLOB(self, type_: TINYBLOB, **kw):
+        return "TINYBLOB"
 
-    def visit_nvarchar(self, type_: NVARCHAR, **kw):
-        return self.visit_NVARCHAR(type_, **kw)
+    def visit_MEDIUMBLOB(self, type_: MEDIUMBLOB, **kw):
+        return "MEDIUMBLOB"
 
-    def visit_nchar(self, type_: NCHAR, **kw):
-        return self.visit_NCHAR(type_, **kw)
+    def visit_LONGBLOB(self, type_: LONGBLOB, **kw):
+        return "LONGBLOB"
 
-    def visit_tinyblob(self, type_: TINYBLOB, **kw):
-        return self.visit_TINYBLOB(type_, **kw)
+    def _visit_enumerated_values(self, name, type_, enumerated_values):
+        quoted_enums = []
+        for e in enumerated_values:
+            if self.dialect.identifier_preparer._double_percents:
+                e = e.replace("%", "%%")
+            quoted_enums.append(f"'{e.replace("'", "''")}'")
+        return self._extend_string(type_, {}, f"{name}({','.join(quoted_enums)})")
 
-    def visit_mediumblob(self, type_: MEDIUMBLOB, **kw):
-        return self.visit_MEDIUMBLOB(type_, **kw)
+    def visit_ENUM(self, type_, **kw):
+        return self._visit_enumerated_values("ENUM", type_, type_.enums)
 
-    def visit_longblob(self, type_: LONGBLOB, **kw):
-        return self.visit_LONGBLOB(type_, **kw)
+    def visit_SET(self, type_, **kw):
+        return self._visit_enumerated_values("SET", type_, type_.values)
 
-    # endregion
+    def visit_BOOLEAN(self, type_: BOOLEAN, **kw):
+        return "BOOL"
 
 
 class MySQLDialect(default.DefaultDialect):

{ormlambda-3.34.1 → ormlambda-3.34.5}/src/ormlambda/dialects/mysql/types.py

@@ -32,7 +32,7 @@ class _NumericType(_NumericCommonType, sqltypes.Numeric): ...
 class _FloatType(_NumericCommonType, sqltypes.Float):
     def __init__(self, precision=None, scale=None, asdecimal=True, **kw):
         if isinstance(self, (REAL, DOUBLE)) and ((precision is None and scale is not None) or (precision is not None and scale is None)):
-            raise AttributeError("You must specify both precision and scale or omit " "both altogether.")
+            raise AttributeError("You must specify both precision and scale or omit both altogether.")
         super().__init__(precision=precision, asdecimal=asdecimal, **kw)
         self.scale = scale
 
@@ -42,6 +42,9 @@ class _IntegerType(_NumericCommonType, sqltypes.Integer):
         self.display_width = display_width
         super().__init__(**kw)
 
+    def __repr__(self):
+        return f"{type(self).__name__}({self.display_width})"
+
 
 class _StringType(sqltypes.String):
     """Base for MySQL string types."""

{ormlambda-3.34.1 → ormlambda-3.34.5}/src/ormlambda/sql/clause_info/clause_info.py

@@ -9,6 +9,7 @@ from ormlambda.sql.types import (
     TableType,
     ColumnType,
     AliasType,
+    TypeEngine,
 )
 from .interface import IClauseInfo
 from ormlambda.sql import ForeignKey
@@ -166,6 +167,18 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._column
         return type(self._column)
 
+    @property
+    def dbtype(self)->tp.Optional[TypeEngine]:
+        if self._dtype is not None:
+            return self._dtype
+
+        if isinstance(self._column, Column):
+            return self._column.dbtype
+
+        if isinstance(self._column, type):
+            return self._column
+        return type(self._column)
+
     def query(self, dialect: Dialect, **kwargs) -> str:
         return self._create_query(dialect, **kwargs)
 

{ormlambda-3.34.1 → ormlambda-3.34.5}/src/ormlambda/sql/column/column.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 import abc
-from typing import Annotated, Any, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
+from typing import Annotated, Any, ClassVar, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
 from ormlambda.sql.types import TableType, ComparerType, ColumnType
 from ormlambda import ConditionType
+from ormlambda.sql.type_api import TypeEngine
 
 if TYPE_CHECKING:
     import re
     from ormlambda import Table
     from ormlambda.sql.comparer import Comparer, Regex, Like
-    from ormlambda.sql.type_api import TypeEngine
 
 
 from ormlambda.types import (
@@ -24,10 +24,13 @@ from ormlambda.types import (
 
 
 class Column[TProp]:
-    PRIVATE_CHAR: str = "_"
+    PRIVATE_CHAR: ClassVar[str] = "_"
+
+    _dbtype: Optional[TypeEngine]
 
     __slots__ = (
-        "dtype",
+        "_dtype",
+        "_dbtype",
         "column_name",
         "table",
         "is_primary_key",
@@ -111,7 +114,8 @@ class Column[TProp]:
 
     def __set__(self, obj, value):
         if self._check and value is not None:
-            if not isinstance(value, self.dtype):
+            type_ = self.dtype if not isinstance(self.dtype, TypeEngine) else self.dtype.python_type
+            if not isinstance(value, type_):
                 raise ValueError(f"The '{self.column_name}' Column from '{self.table.__table_name__}' table expected '{str(self.dtype)}' type. You passed '{type(value).__name__}' type")
         setattr(obj, self.__private_name, value)
 
@@ -132,8 +136,6 @@ class Column[TProp]:
     def _fill_from_annotations[T: Table](self, obj: Type[T], name: str) -> None:
         """Read the metada when using Annotated typing class, and set the attributes accordingly"""
 
-        from ormlambda.sql.type_api import TypeEngine
-
         annotations = get_type_hints(obj, include_extras=True)
         if name in annotations:
             annotation = annotations[name]
@@ -163,6 +165,23 @@ class Column[TProp]:
                         self.is_not_null = True
         return None
 
+    @property
+    def dtype(self) -> Type[TProp]:
+        return self._dtype
+
+    @dtype.setter
+    def dtype(self, value: Type[TProp] | TypeEngine) -> None:
+        if isinstance(value, TypeEngine):
+            self._dtype = value.python_type
+            self._dbtype = value
+        else:
+            self._dtype = value
+            self._dbtype = None
+
+    @property
+    def dbtype(self) -> TypeEngine[TProp]:
+        return self._dbtype if self._dbtype else self.dtype
+
     @abc.abstractmethod
     def __comparer_creator(self, other: ColumnType, compare: ComparerType) -> Comparer:
         from ormlambda.sql.comparer import Comparer

{ormlambda-3.34.1 → ormlambda-3.34.5}/src/ormlambda/sql/sqltypes.py

@@ -10,6 +10,7 @@ import ormlambda.util as util
 from uuid import UUID as _python_UUID
 from shapely import Point as _python_Point
 
+
 class _NoArg(enum.Enum):
     NO_ARG = 0
 
@@ -391,7 +392,7 @@ class Enum(String, TypeEngine[EnumType]):
             enum_args = get_args(pt)
             bad_args = [arg for arg in enum_args if not isinstance(arg, str)]
             if bad_args:
-                raise ValueError(f"Can't create string-based Enum datatype from non-string " f"values: {', '.join(repr(x) for x in bad_args)}.  Please " f"provide an explicit Enum datatype for this Python type")
+                raise ValueError(f"Can't create string-based Enum datatype from non-string values: {', '.join(repr(x) for x in bad_args)}.  Please provide an explicit Enum datatype for this Python type")
             native_enum = False
             return enum_args, native_enum
 
@@ -407,7 +408,7 @@ class Enum(String, TypeEngine[EnumType]):
         elif util.is_pep695(python_type):
             value = python_type.__value__
             if not util.is_literal(value):
-                raise ValueError(f"Can't associate TypeAliasType '{python_type}' to an " "Enum since it's not a direct alias of a Literal. Only " "aliases in this form `type my_alias = Literal['a', " "'b']` are supported when generating Enums.")
+                raise ValueError(f"Can't associate TypeAliasType '{python_type}' to an Enum since it's not a direct alias of a Literal. Only aliases in this form `type my_alias = Literal['a', 'b']` are supported when generating Enums.")
             enum_args, native_enum = process_literal(value)
 
         elif isinstance(python_type, type) and issubclass(python_type, enum.Enum):
@@ -439,13 +440,15 @@ class Enum(String, TypeEngine[EnumType]):
 
         self._valid_lookup.update([(value, self._valid_lookup[self._object_lookup[value]]) for value in values])
 
+
 class Point(TypeEngine[_python_Point]):
-    __visit_name__ = 'point'
+    __visit_name__ = "point"
 
     @property
-    def python_type(self)->Type[_python_Point]:
+    def python_type(self) -> Type[_python_Point]:
         return _python_Point
-    
+
+
 class JSON(TypeEngine[Any]):
     """JSON data type."""
 
@@ -597,6 +600,7 @@ class VARBINARY(Varbinary):
 class ENUM(Enum):
     __visit_name__ = "ENUM"
 
+
 class POINT(Point):
     __visit_name__ = "POINT"
 
@@ -623,13 +627,15 @@ _type_dicc: dict[Any, TypeEngine[Any]] = {
     float: Float(),
     NoneType: NULLTYPE,
     dt.datetime: Datetime(timezone=False),
+    dt.date: DATE(),
     bytes: _BINARY,
     bytearray: _BINARY,
     bool: Boolean(),
     enum.Enum: _ENUM,
     Literal: _ENUM,
     _python_UUID: UUID(),
-    _python_Point: POINT()
+    _python_Point: POINT(),
+    decimal.Decimal: DECIMAL(),
 }
 # enderegion
 

{ormlambda-3.34.1 → ormlambda-3.34.5}/src/ormlambda/sql/type_api.py

@@ -33,3 +33,6 @@ class TypeEngine[T: Any](Element, abc.ABC):
         if _coerced_type is NULLTYPE:
             return self
         return _coerced_type
+
+    def __repr__(self):
+        return f"{TypeEngine.__name__}: {super().__repr__()}"