ormlambda 3.12.2__py3-none-any.whl → 3.34.0__py3-none-any.whl

ormlambda/__init__.py

@@ -1,3 +1,5 @@
+import ormlambda.env  # noqa: F401 Necesary to load all variables inside ormalambda.env
+
 # region enums
 from .common.enums import (
     JoinType as JoinType,

ormlambda/caster/__init__.py

@@ -1,3 +1,3 @@
 from .base_caster import BaseCaster  # noqa: F401
-from .caster import Caster, PLACEHOLDER  # noqa: F401
+from .caster import Caster  # noqa: F401
 from .interfaces import ICaster  # noqa: F401

ormlambda/caster/caster.py

@@ -1,24 +1,26 @@
 from __future__ import annotations
 
 
-from typing import Optional, Type, TYPE_CHECKING, Callable, overload
-
+from typing import ClassVar, Optional, Type, TYPE_CHECKING, Callable, overload, get_args
+from types import NoneType
+from ormlambda.caster.interfaces import ICaster
 from ormlambda.common.global_checker import GlobalChecker
 from ormlambda.sql.types import ColumnType
-from ormlambda.engine.template import RepositoryTemplateDict
+from ormlambda.caster import BaseCaster
+from ormlambda.sql.sqltypes import TypeEngine
+
 
 if TYPE_CHECKING:
     from ormlambda.caster import BaseCaster
-    from ormlambda.repository import IRepositoryBase
 
 
-PLACEHOLDER: str = "%s"
+class Caster(ICaster):
+    PLACEHOLDER: ClassVar[str] = "%s"
 
-
-class Caster:
-    def __init__(self, repository: IRepositoryBase):
-        self._repository: IRepositoryBase = repository
-        self._caster = RepositoryTemplateDict().get(repository).caster
+    @classmethod
+    def set_placeholder(cls, char: str) -> None:
+        cls.PLACEHOLDER = char
+        return None
 
     @overload
     def for_column[T, TProp](self, column: Callable[[T], TProp], instance: T) -> BaseCaster[TProp, Type[TProp]]: ...
@@ -36,7 +38,7 @@ class Caster:
             column_type = column.dtype
             value = instance[column]
 
-        return self._caster.cast(value, column_type)
+        return self.cast(value, column_type)
 
     @overload
     def for_value[TProp](self, value: TProp) -> BaseCaster[TProp, Type[TProp]]: ...
@@ -45,4 +47,19 @@ class Caster:
 
     def for_value[TProp, TType](self, value: TProp, value_type: Optional[TType] = None) -> BaseCaster[TProp, TType]:
         column_type = value_type if value_type else type(value)
-        return self._caster.cast(value, column_type)
+        return self.cast(value, column_type)
+
+    @classmethod
+    def cast[TProp, TType](cls, value: TProp, type_value: Optional[TypeEngine[TType]] = None) -> BaseCaster[TProp, TType]:
+        if len(args := get_args(type_value)) > 1:
+            args = [x for x in args if x != NoneType]
+
+            type_value = args[0]
+
+        if isinstance(type_value, TypeEngine):
+            column_type = type_value.python_type
+        elif not type_value:
+            column_type = type(value)
+        else:
+            column_type = type_value
+        return cls.CASTER_SELECTOR()[column_type](value, column_type)

ormlambda/common/abstract_classes/clause_info_converter.py

@@ -17,21 +17,13 @@ class ClauseInfoConverter[T, TProp](tp.Protocol):
 class ConvertFromAnyType(ClauseInfoConverter[None, None]):
     @classmethod
     def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
-        return [
-            ClauseInfo[None](
-                table=None,
-                column=data,
-                alias_table=alias_table,
-                alias_clause=kwargs.get("alias", None),
-                context=context,
-            )
-        ]
+        return [ClauseInfo[None](table=None, column=data, alias_table=alias_table, alias_clause=kwargs.get("alias", None), context=context, **kwargs)]
 
 
 class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
     @classmethod
     def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[RT]]:
-        return ConvertFromTable[RT].convert(data.tright, data.alias, context, **kwargs)
+        return ConvertFromTable[RT].convert(data.tright, data.get_alias(kwargs["dialect"]), context, **kwargs)
 
 
 class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
@@ -44,9 +36,9 @@ class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
             "alias_table": alias_table,
             "alias_clause": "{table}_{column}",
             "context": context,
-            **kwargs,
         }
-        clause_info = ClauseInfo[None](**attributes)
+        attributes.update(**kwargs)
+        clause_info = ClauseInfo(**attributes)
         return [clause_info]
 
 

ormlambda/common/abstract_classes/decomposition_query.py

@@ -27,6 +27,9 @@ type ValueType = tp.Union[
     tp.Type[ICustomAlias],
 ]
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
@@ -36,10 +39,20 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
     def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str, context: ClauseContextType = ...) -> None: ...
 
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str = "{table}", *, context: ClauseContextType = ClauseInfoContext(), **kwargs) -> None:
+    def __init__(
+        self,
+        tables: tuple[TableType[T]],
+        columns: tuple[ColumnType],
+        alias_table: str = "{table}",
+        *,
+        context: ClauseContextType = ClauseInfoContext(),
+        dialect: Dialect,
+        **kwargs,
+    ) -> None:
         self.kwargs = kwargs
         self._tables: tuple[TableType[T]] = tables if isinstance(tables, tp.Iterable) else (tables,)
 
+        self._dialect = dialect
         self._columns: tp.Callable[[T], tuple] = columns
         self._all_clauses: list[ClauseInfo | AggregateFunctionBase] = []
         self._context: ClauseContextType = context if context else ClauseInfoContext()
@@ -88,7 +101,9 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
             Table: ConvertFromTable[T],
         }
         classConverter = next((converter for obj, converter in VALUE_TYPE_MAPPED.items() if validation(data, obj)), ConvertFromAnyType)
-
+        self.kwargs.setdefault("dialect", self._dialect)
+        if "dialect" not in self.kwargs:
+            raise ValueError("You must specified 'dialect' variable")
         return classConverter.convert(data, alias_table=self._alias_table, context=self._context, **self.kwargs)
 
     def __add_clause[TTable: TableType](self, clauses: list[ClauseInfo[TTable]] | ClauseInfo[TTable]) -> None:

ormlambda/common/abstract_classes/non_query_base.py

@@ -1,22 +1,26 @@
 from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional, Type, override, TYPE_CHECKING
+from typing import Any, Optional, Type, TYPE_CHECKING
 
 from ormlambda.common.interfaces.INonQueryCommand import INonQueryCommand
 
 if TYPE_CHECKING:
     from ormlambda.repository import BaseRepository
+    from ormlambda.dialects import Dialect
     from ormlambda import Table
+    from ormlambda.engine import Engine
 
 
-class NonQueryBase[T: Type[Table], TRepo: BaseRepository](INonQueryCommand):
+class NonQueryBase[T: Type[Table], TRepo](INonQueryCommand):
     __slots__: tuple[str, ...] = ("_model", "_repository", "_values", "_query")
 
-    def __init__(self, model: T, repository: TRepo) -> None:
+    def __init__(self, model: T, repository: TRepo, **kwargs) -> None:
         self._model: T = model
-        self._repository: TRepo = repository
+        self._repository: BaseRepository[TRepo] = repository
         self._values: list[tuple[Any]] = []
         self._query: Optional[str] = None
+        self._dialect: Dialect = kwargs.get("dialect", None)
+        self._engine: Optional[Engine] = kwargs.get("engine", None)
 
     @property
     @abstractmethod
@@ -25,9 +29,7 @@ class NonQueryBase[T: Type[Table], TRepo: BaseRepository](INonQueryCommand):
     @abstractmethod
     def execute(self) -> None: ...
 
-    @property
-    @override
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         return self._query
 
     @property

ormlambda/common/abstract_classes/query_base.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from abc import abstractmethod
 from typing import TYPE_CHECKING
 
@@ -5,9 +6,10 @@ from ormlambda.common.interfaces import IQuery
 
 if TYPE_CHECKING:
     from ormlambda import Table
+    from ormlambda.dialects import Dialect
 
 
 class QueryBase[T: Table](IQuery):
     @property
     @abstractmethod
-    def query(self) -> str: ...
+    def query(self, dialect: Dialect, **kwargs) -> str: ...

ormlambda/common/errors/__init__.py

@@ -1,7 +1,12 @@
+from __future__ import annotations
 import inspect
 import typing as tp
 
 
+if tp.TYPE_CHECKING:
+    from ormlambda.sql.clause_info import ClauseInfo
+
+
 class UnmatchedLambdaParameterError(Exception):
     def __init__(self, expected_params: int, function: tp.Callable[..., tp.Any], *args: object) -> None:
         super().__init__(*args)
@@ -19,3 +24,27 @@ class NotKeysInIAggregateError(Exception):
 
     def __str__(self) -> str:
         return f"We cannot use placeholders in IAggregate class. You used {self._match_regex}"
+
+
+class AggregateFunctionError[T](Exception):
+    def __init__(self, clause: ClauseInfo[T], *args):
+        self.clause = clause
+        super().__init__(*args)
+
+    def __str__(self):
+        agg_methods = self.__get_all_aggregate_method(self.clause)
+        return f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'."
+
+    def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
+        """
+        Get the class name of those classes that inherit from 'AggregateFunctionBase' class in order to create a better error message.
+        """
+        from ormlambda.sql.clause_info import AggregateFunctionBase
+
+        res: set[str] = set()
+        if not isinstance(clauses, tp.Iterable):
+            return clauses.__class__.__name__
+        for clause in clauses:
+            if isinstance(clause, AggregateFunctionBase):
+                res.add(clause.__class__.__name__)
+        return ", ".join(res)

ormlambda/common/interfaces/IQueryCommand.py

@@ -1,12 +1,16 @@
+from __future__ import annotations
 from abc import abstractmethod, ABC
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
 
 
 class IQuery(ABC):
     """Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
 
-    @property
     @abstractmethod
-    def query(self) -> str: ...
+    def query(self, dialect: Dialect, **kwargs) -> str: ...
 
     def __repr__(self) -> str:
         return f"{IQuery.__name__}: {self.__class__.__name__}"

ormlambda/dialects/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from typing import Callable, Optional, Type, TYPE_CHECKING
+from ormlambda import util
+import importlib
+
+if TYPE_CHECKING:
+    from .interface import Dialect
+
+
+__all__ = ("mysql", "sqlite")
+
+
+def _auto_fn(name: str) -> Optional[Callable[[], Type[Dialect]]]:
+    """default dialect importer.
+
+    plugs into the :class:`.PluginLoader`
+    as a first-hit system.
+
+    """
+    if "." in name:
+        dialect, driver = name.split(".")
+    else:
+        dialect = name
+        driver = "base"
+
+    try:
+        module = importlib.import_module(f"ormlambda.dialects.{dialect}")
+
+    except ImportError:
+        return None
+
+    if hasattr(module, driver):
+        module = getattr(module, driver)
+        return lambda: module.dialect
+    else:
+        return None
+
+
+registry = util.PluginLoader("ormlambda.dialects", auto_fn=_auto_fn)

ormlambda/dialects/default/__init__.py

@@ -0,0 +1 @@
+from .base import DefaultDialect

ormlambda/dialects/default/base.py

@@ -0,0 +1,39 @@
+from ormlambda.dialects.interface import Dialect
+from ormlambda.sql import compiler
+from typing import Optional, Any
+from types import ModuleType
+from ormlambda import BaseRepository
+
+
+class DefaultDialect(Dialect):
+    """Default implementation of Dialect"""
+
+    statement_compiler = compiler.SQLCompiler
+    ddl_compiler = compiler.DDLCompiler
+    type_compiler_cls = compiler.GenericTypeCompiler
+    repository_cls = BaseRepository
+    default_paramstyle = "named"
+
+    def __init__(
+        self,
+        dbapi: Optional[ModuleType] = None,  # type: ignore
+        **kwargs: Any,
+    ):
+        self.dbapi = dbapi
+
+        if self.dbapi is not None:
+            self.paramstyle = self.dbapi.paramstyle
+        else:
+            self.paramstyle = self.default_paramstyle
+        self.positional = self.paramstyle in (
+            "qmark",
+            "format",
+            "numeric",
+            "numeric_dollar",
+        )
+
+        tt_callable = self.type_compiler_cls
+
+        self.type_compiler_instance = self.type_compiler = tt_callable(self)
+
+        super().__init__(**kwargs)

ormlambda/dialects/interface/__init__.py

@@ -0,0 +1 @@
+from .dialect import Dialect  # noqa: F401

ormlambda/dialects/interface/dialect.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import abc
+from typing import ClassVar, Optional, Type, TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from ormlambda.caster.caster import Caster
+    from ormlambda.repository.interfaces.IRepositoryBase import DBAPIConnection
+    from ormlambda.sql.types import DDLCompiler, SQLCompiler, TypeCompiler
+    from ormlambda import BaseRepository
+
+
+class Dialect(abc.ABC):
+    """
+    Abstract base class for all database dialects.
+    """
+
+    dbapi: Optional[DBAPIConnection]
+    """A reference to the DBAPI module object itself.
+
+    Ormlambda dialects import DBAPI modules using the classmethod
+    :meth:`.Dialect.import_dbapi`. The rationale is so that any dialect
+    module can be imported and used to generate SQL statements without the
+    need for the actual DBAPI driver to be installed.  Only when an
+    :class:`.Engine` is constructed using :func:`.create_engine` does the
+    DBAPI get imported; at that point, the creation process will assign
+    the DBAPI module to this attribute.
+
+    Dialects should therefore implement :meth:`.Dialect.import_dbapi`
+    which will import the necessary module and return it, and then refer
+    to ``self.dbapi`` in dialect code in order to refer to the DBAPI module
+    contents.
+
+    .. versionchanged:: The :attr:`.Dialect.dbapi` attribute is exclusively
+       used as the per-:class:`.Dialect`-instance reference to the DBAPI
+       module.   The previous not-fully-documented ``.Dialect.dbapi()``
+       classmethod is deprecated and replaced by :meth:`.Dialect.import_dbapi`.
+
+    """
+
+    name: ClassVar[str]
+    """The name of the dialect, e.g. 'sqlite', 'postgresql', etc."""
+    driver: ClassVar[str]
+    """The driver used by the dialect, e.g. 'sqlite3', 'psycopg2', etc."""
+
+    ddl_compiler: ClassVar[Type[DDLCompiler]]
+    """The DDL compiler class used by the dialect."""
+
+    statement_compiler: ClassVar[Type[SQLCompiler]]
+    """The statement compiler class used by the dialect."""
+
+    type_compiler_cls: ClassVar[Type[TypeCompiler]]
+    """The type compiler class used by the dialect."""
+
+    type_compiler_instance: ClassVar[TypeCompiler]
+    """The instance of the type compiler class used by the dialect."""
+
+    repository_cls: ClassVar[Type[BaseRepository]]
+    """The repository class used by the dialect."""
+
+    caster: ClassVar[Type[Caster]]
+
+    @classmethod
+    def get_dialect_cls(cls) -> Type[Dialect]:
+        return cls
+
+    @classmethod
+    @abc.abstractmethod
+    def import_dbapi(cls) -> DBAPIConnection:
+        """
+        Import the DB API module for the dialect.
+        This method should be implemented by subclasses to import the
+        appropriate DB API module for the dialect.
+        """
+        ...
+
+    def __repr__(self):
+        return f"{Dialect.__name__}: {type(self).__name__}"

ormlambda/dialects/mysql/__init__.py

@@ -0,0 +1,38 @@
+from . import base
+from . import mysqlconnector
+
+from .types import (  # noqa: F401
+    NUMERIC,
+    DECIMAL,
+    DOUBLE,
+    REAL,
+    FLOAT,
+    INTEGER,
+    BIGINT,
+    MEDIUMINT,
+    TINYINT,
+    SMALLINT,
+    BIT,
+    TIME,
+    TIMESTAMP,
+    DATETIME,
+    YEAR,
+    TEXT,
+    TINYTEXT,
+    MEDIUMTEXT,
+    LONGTEXT,
+    VARCHAR,
+    CHAR,
+    NVARCHAR,
+    NCHAR,
+    TINYBLOB,
+    MEDIUMBLOB,
+    LONGBLOB,
+)
+
+
+from .repository import MySQLRepository  # noqa: F401
+from .caster import MySQLCaster  # noqa: F401
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect