ormlambda 3.11.2__tar.gz → 3.34.0__tar.gz

ormlambda-3.34.0/AUTHORS

@@ -0,0 +1,32 @@
+ormlambda was created by Pablo hernandez.
+
+Some files was originally written by other authors from sqlalchemy library and rewritten by Pablo Hernandez
+
+Major contributing authors include:
+
+- Pablo Hernandez
+- Jason Kirtland
+- Michael Trier
+- Diana Clarke
+- Gaetan de Menten
+- Lele Gaifax
+- Jonathan Ellis
+- Gord Thompson
+- Federico Caselli
+- Philip Jenvey
+- Rick Morrison
+- Chris Withers
+- Ants Aasma
+- Sheila Allen
+- Paul Johnston
+- Tony Locke
+- Hajime Nakagami
+- Vraj Mohan
+- Robert Leftwich
+- Taavi Burns
+- Jonathan Vanasco
+- Jeff Widman
+- Scott Dugas
+- Dobes Vandermeer
+- Ville Skytta
+- Rodrigo Menezes

{ormlambda-3.11.2 → ormlambda-3.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ormlambda
-Version: 3.11.2
+Version: 3.34.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
@@ -316,7 +316,7 @@ res = AddressModel.count(Address.address_id, execute=True)
 
 The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
 
-#### Usage
+### Usage
 
 ```python
 response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
@@ -347,6 +347,60 @@ As you can see in the response, the result is a dictionary where the keys are a
 
 Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
 
+
+## 2. Group by
+
+The `groupby` method is used to filter results based on aggregate functions.
+
+### Usage
+```python
+from ormlambda import Column, ORM, create_engine
+from test.config import DATABASE_URL
+
+
+class Response(BaseModel):
+    district: str
+    count: int
+
+engine= create_engine(DATABASE_URL)
+model = ORM(Address,engine)
+
+count_name = Column(column_name="count")
+
+res = (
+    self.model
+    .groupby(Address.district)
+    .select(
+        (
+            Address.district,
+            self.model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+## 3. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+### Usage
+```python
+res = (
+    model
+    .groupby(Address.district)
+    .having(count_name > 4)
+    .select(
+        (
+            Address.district,
+            model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+
 ## Using BaseModel for Custom Responses (Pydantic)
 
 You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
@@ -391,14 +445,6 @@ print(select.city)
 print(select.country)
 ```
 
-
-<!-- ### 2. Having
-
-The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
-
-#### Usage -->
-
-
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python

{ormlambda-3.11.2 → ormlambda-3.34.0}/README.md

@@ -302,7 +302,7 @@ res = AddressModel.count(Address.address_id, execute=True)
 
 The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
 
-#### Usage
+### Usage
 
 ```python
 response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
@@ -333,6 +333,60 @@ As you can see in the response, the result is a dictionary where the keys are a
 
 Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
 
+
+## 2. Group by
+
+The `groupby` method is used to filter results based on aggregate functions.
+
+### Usage
+```python
+from ormlambda import Column, ORM, create_engine
+from test.config import DATABASE_URL
+
+
+class Response(BaseModel):
+    district: str
+    count: int
+
+engine= create_engine(DATABASE_URL)
+model = ORM(Address,engine)
+
+count_name = Column(column_name="count")
+
+res = (
+    self.model
+    .groupby(Address.district)
+    .select(
+        (
+            Address.district,
+            self.model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+## 3. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+### Usage
+```python
+res = (
+    model
+    .groupby(Address.district)
+    .having(count_name > 4)
+    .select(
+        (
+            Address.district,
+            model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+
 ## Using BaseModel for Custom Responses (Pydantic)
 
 You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
@@ -377,14 +431,6 @@ print(select.city)
 print(select.country)
 ```
 
-
-<!-- ### 2. Having
-
-The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
-
-#### Usage -->
-
-
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python

{ormlambda-3.11.2 → ormlambda-3.34.0}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.11.2"
+version = "3.34.0"
 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"
@@ -20,6 +20,7 @@ pandas = "^2.2.2"
 ruff = "^0.4.5"
 parameterized = "^0.9.0"
 pydantic = "^2.11.1"
+sqlserver = "^0.0.17.1"
 
 
 [build-system]

{ormlambda-3.11.2 → ormlambda-3.34.0}/src/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,
@@ -21,4 +23,4 @@ from .model.base_model import (
     ORM as ORM,
 )  # 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 .engine import create_engine, URL, make_url  # noqa: F401

{ormlambda-3.11.2 → ormlambda-3.34.0}/src/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-3.11.2 → ormlambda-3.34.0}/src/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-3.34.0/src/ormlambda/common/abstract_classes/clause_info_converter.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+import typing as tp
+from ormlambda import Table
+
+from ormlambda.sql.clause_info import ClauseInfo, AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+from ormlambda import ForeignKey
+
+from ormlambda.sql.types import AliasType, TableType, ColumnType
+
+
+class ClauseInfoConverter[T, TProp](tp.Protocol):
+    @classmethod
+    def convert(cls, data: T, alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]: ...
+
+
+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, **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.get_alias(kwargs["dialect"]), context, **kwargs)
+
+
+class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
+    @classmethod
+    def convert(cls, data: ColumnType[TProp], alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        # COMMENT: if the property belongs to the main class, the columnn name in not prefixed. This only done if the property comes from any join.
+        attributes = {
+            "table": data.table,
+            "column": data,
+            "alias_table": alias_table,
+            "alias_clause": "{table}_{column}",
+            "context": context,
+        }
+        attributes.update(**kwargs)
+        clause_info = ClauseInfo(**attributes)
+        return [clause_info]
+
+
+class ConvertFromIAggregate(ClauseInfoConverter[None, None]):
+    @classmethod
+    def convert(cls, data: AggregateFunctionBase, alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        return [data]
+
+
+class ConvertFromTable[T: Table](ClauseInfoConverter[T, None]):
+    @classmethod
+    def convert(cls, data: T, alias_table: AliasType[ColumnType] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]:
+        """
+        if the data is Table, means that we want to retrieve all columns
+        """
+        return cls._extract_all_clauses(data, alias_table, context, **kwargs)
+
+    @staticmethod
+    def _extract_all_clauses(table: TableType[T], alias_table: AliasType[ColumnType], context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[TableType[T]]]:
+        # all columns
+        column_clauses = []
+        for column in table.get_columns():
+            column_clauses.extend(ConvertFromColumn.convert(column, alias_table=alias_table, context=context, **kwargs))
+        return column_clauses

{ormlambda-3.11.2 → ormlambda-3.34.0}/src/ormlambda/common/abstract_classes/decomposition_query.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 import typing as tp
-import abc
 from ormlambda import Table, Column
 
 from ormlambda.common.interfaces import IDecompositionQuery, ICustomAlias
@@ -10,8 +9,15 @@ from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, Cla
 from ormlambda import ForeignKey
 from ormlambda.common.global_checker import GlobalChecker
 
-from ormlambda.sql.types import AliasType, TableType, ColumnType
-
+from ormlambda.sql.types import TableType, ColumnType
+from .clause_info_converter import (
+    ClauseInfoConverter,
+    ConvertFromAnyType,
+    ConvertFromForeignKey,
+    ConvertFromColumn,
+    ConvertFromIAggregate,
+    ConvertFromTable,
+)
 
 type TableTupleType[T, *Ts] = tuple[T:TableType, *Ts]
 type ValueType = tp.Union[
@@ -21,68 +27,8 @@ type ValueType = tp.Union[
     tp.Type[ICustomAlias],
 ]
 
-
-class ClauseInfoConverter[T, TProp](abc.ABC):
-    @classmethod
-    @abc.abstractmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[T]]: ...
-
-
-class ConvertFromAnyType(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        return [
-            ClauseInfo[None](
-                table=None,
-                column=data,
-                alias_table=alias_table,
-                alias_clause=None,
-                context=context,
-            )
-        ]
-
-
-class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
-    @classmethod
-    def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None) -> list[ClauseInfo[RT]]:
-        return ConvertFromTable[RT].convert(data.tright, data.alias, context)
-
-
-class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
-    @classmethod
-    def convert(cls, data: ColumnType[TProp], alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        # COMMENT: if the property belongs to the main class, the columnn name in not prefixed. This only done if the property comes from any join.
-        clause_info = ClauseInfo[None](
-            table=data.table,
-            column=data,
-            alias_table=alias_table,
-            alias_clause="{table}_{column}",
-            context=context,
-        )
-        return [clause_info]
-
-
-class ConvertFromIAggregate(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: AggregateFunctionBase, alias_table=None, context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        return [data]
-
-
-class ConvertFromTable[T: Table](ClauseInfoConverter[T, None]):
-    @classmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[T]]:
-        """
-        if the data is Table, means that we want to retrieve all columns
-        """
-        return cls._extract_all_clauses(data, alias_table, context)
-
-    @staticmethod
-    def _extract_all_clauses(table: TableType[T], alias_table: AliasType[ColumnType], context: ClauseContextType = None) -> list[ClauseInfo[TableType[T]]]:
-        # all columns
-        column_clauses = []
-        for column in table.get_columns():
-            column_clauses.extend(ConvertFromColumn.convert(column, alias_table=alias_table, context=context))
-        return column_clauses
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
 
 
 class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
@@ -93,9 +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()) -> 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()
@@ -144,8 +101,10 @@ 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)
-
-        return classConverter.convert(data, alias_table=self._alias_table, context=self._context)
+        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:
         if not isinstance(clauses, tp.Iterable):

{ormlambda-3.11.2 → ormlambda-3.34.0}/src/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 IRepositoryBase
+    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: IRepositoryBase](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: IRepositoryBase](INonQueryCommand):
     @abstractmethod
     def execute(self) -> None: ...
 
-    @property
-    @override
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         return self._query
 
     @property

{ormlambda-3.11.2 → ormlambda-3.34.0}/src/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-3.34.0/src/ormlambda/common/errors/__init__.py

@@ -0,0 +1,50 @@
+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)
+        self.expected_params = expected_params
+        self.found_param: tuple[str, ...] = tuple(inspect.signature(function).parameters)
+
+    def __str__(self) -> str:
+        return f"Unmatched number of parameters in lambda function with the number of tables: Expected {self.expected_params} parameters but found {str(self.found_param)}."
+
+
+class NotKeysInIAggregateError(Exception):
+    def __init__(self, match_regex: list[str], *args: object) -> None:
+        super().__init__(*args)
+        self._match_regex: list[str] = match_regex
+
+    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-3.11.2 → ormlambda-3.34.0}/src/ormlambda/common/interfaces/ICustomAlias.py

@@ -1,4 +1,4 @@
-from ormlambda.common.interfaces import IDecompositionQuery
+# from ormlambda.common.interfaces import IDecompositionQuery
 
 
 class ICustomAlias[T, *Ts]: ...

{ormlambda-3.11.2 → ormlambda-3.34.0}/src/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-3.34.0/src/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)