ormlambda 3.35.3__py3-none-any.whl → 4.0.4__py3-none-any.whl

ormlambda/statements/statements.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 from typing import Concatenate, Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
 
-from ormlambda import ForeignKey
-
+from ormlambda.sql.types import ASTERISK
 
 if TYPE_CHECKING:
     from ormlambda.engine.base import Engine
@@ -11,16 +10,14 @@ if TYPE_CHECKING:
     from ormlambda.statements.types import OrderTypes
     from ormlambda.sql.types import ColumnType
     from ormlambda.statements.types import SelectCols
-    from ormlambda.statements.interfaces import IStatements_two_generic
     from ormlambda.statements.types import TypeExists
-    from ormlambda.sql.clause_info import IAggregate
     from ormlambda.statements.types import WhereTypes
+    from ormlambda.dialects import Dialect
 
+from ormlambda.statements.interfaces import IStatements
+from ormlambda.statements.base_statement import ClusterResponse
 
-from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.statements import BaseStatement
-
-from ormlambda import Table, Column
+from ormlambda import OrderType, Table
 from ormlambda.common.enums import JoinType
 from ormlambda.sql.clauses.join import JoinContext, TupleJoinType
 
@@ -40,23 +37,53 @@ def clear_list[T, **P](f: Callable[Concatenate[Statements, P], T]) -> Callable[P
         except Exception as err:
             raise err
         finally:
-            ForeignKey.stored_calls.clear()
             self._query_builder.clear()
 
     return wrapper
 
 
-class Statements[T: Table, TRepo](BaseStatement[T, None]):
+class Statements[T: Table](IStatements[T]):
     def __init__(self, model: T, engine: Engine) -> None:
-        super().__init__(model, engine)
-        self._query_builder = QueryBuilder(self.dialect)
+        self._query_builder = QueryBuilder()
+        self._engine = engine
+        self._dialect = engine.dialect
+        self._query: Optional[str] = None
+        self._model: T = model[0] if isinstance(model, Iterable) else model
+
+        if not issubclass(self._model, Table):
+            # Deben heredar de Table ya que es la forma que tenemos para identificar si estamos pasando una instancia del tipo que corresponde o no cuando llamamos a insert o upsert.
+            # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
+            raise Exception(f"'{model}' class does not inherit from Table class")
+
+    @property
+    def dialect(self) -> Dialect:
+        return self._dialect
+
+    @property
+    def engine(self) -> Engine:
+        return self._engine
+
+    @override
+    def table_exists(self) -> bool:
+        return self.engine.repository.table_exists(self._model.__table_name__)
+
+    def __repr__(self):
+        return f"<Model: {self.__class__.__name__}>"
+
+    @property
+    def query(self) -> str:
+        return self._query
+
+    @property
+    def model(self) -> Type[T]:
+        return self._model
 
     @override
     def create_table(self, if_exists: TypeExists = "fail") -> None:
         name: str = self._model.__table_name__
-        if self._repository.table_exists(name):
+        if self.engine.repository.table_exists(name):
             if if_exists == "replace":
-                self._repository.drop_table(name)
+                self.drop_table()
 
             elif if_exists == "fail":
                 raise ValueError(f"Table '{self._model.__table_name__}' already exists")
@@ -64,7 +91,7 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
             elif if_exists == "append":
                 counter: int = 0
                 char: str = ""
-                while self._repository.table_exists(name + char):
+                while self.engine.repository.table_exists(name + char):
                     counter += 1
                     char = f"_{counter}"
                 name += char
@@ -74,18 +101,25 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
                 return new_model.create_table(self.dialect)
 
         query = self.model.create_table(self.dialect)
-        self._repository.execute(query)
+        self.engine.repository.execute(query)
+        return None
+
+    @override
+    def drop_table(self) -> None:
+        q = self.model.drop_table(self.dialect)
+        self.engine.repository.execute(q)
         return None
 
     @override
     @clear_list
     def insert(self, instances: T | list[T]) -> None:
-        insert = clauses.Insert(self._model, self.repository, self._dialect)
+        insert = clauses.Insert(self._model, self.engine.repository, self._dialect)
         insert.insert(instances)
         insert.execute()
         return None
 
     @override
+    @clear_list
     def delete(self, instances: Optional[T | list[T]] = None) -> None:
         if instances is None:
             response = self.select()
@@ -95,7 +129,7 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
             # We always going to have a tuple of one element
             return self.delete(response)
 
-        delete = clauses.Delete(self._model, self._repository, engine=self._engine)
+        delete = clauses.Delete(self._model, self.engine.repository, engine=self._engine)
         delete.delete(instances)
         delete.execute()
         # not necessary to call self._query_builder.clear() because select() method already call it
@@ -104,7 +138,7 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
     @override
     @clear_list
     def upsert(self, instances: T | list[T]) -> None:
-        upsert = clauses.Upsert(self._model, self._repository, engine=self._engine)
+        upsert = clauses.Upsert(self._model, self.engine.repository, engine=self._engine)
         upsert.upsert(instances)
         upsert.execute()
         return None
@@ -112,107 +146,96 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
     @override
     @clear_list
     def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
-        update = clauses.Update(self._model, self._repository, self._query_builder.WHERE, engine=self._engine)
+        update = clauses.Update(self._model, self.engine.repository, self._query_builder.components.where, engine=self._engine)
         update.update(dicc)
         update.execute()
 
         return None
 
     @override
-    def limit(self, number: int) -> IStatements_two_generic[T, TRepo]:
-        limit = clauses.Limit(number, dialect=self._dialect)
+    def limit(self, number: int) -> IStatements[T]:
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
+        limit = clauses.Limit(number=number)
         self._query_builder.add_statement(limit)
         return self
 
     @override
-    def offset(self, number: int) -> IStatements_two_generic[T, TRepo]:
-        offset = clauses.Offset(number, dialect=self._dialect)
+    def offset(self, number: int) -> IStatements[T]:
+        offset = clauses.Offset(number=number)
         self._query_builder.add_statement(offset)
         return self
 
     @override
     def count[TProp](
         self,
-        selection: None | SelectCols[T, TProp] = lambda x: "*",
-        alias="count",
-        execute: bool = False,
+        selection: Optional[SelectCols[T, TProp] | str] = ASTERISK,
+        alias: AliasType = "count",
     ) -> Optional[int]:
-        if execute is True:
-            return self.select_one(self.count(selection, alias, False), flavour=dict)[alias]
-
-        selection = GlobalChecker.resolved_callback_object(selection, self.models)
-        return clauses.Count(
-            element=selection,
-            alias_clause=alias,
-            context=self._query_builder._context,
-            dialect=self._dialect,
-        )
+        if selection == ASTERISK:
+            return self.select_one(lambda x: clauses.Count(x, alias), flavour=dict)[alias]
+
+        # get first position because 'resolved_callback_object' return an, alway Iterable and we should only pass one column
+        res = GlobalChecker.resolved_callback_object(self.model, selection)[0]
+        return self.select_one(lambda x: clauses.Count(res, alias), flavour=dict)[alias]
 
     @override
-    def where(self, conditions: WhereTypes) -> IStatements_two_generic[T, TRepo]:
+    def where(self, conditions: WhereTypes[T], restrictive: bool = True) -> IStatements[T]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
+        result = GlobalChecker.resolved_callback_object(self.model, conditions)
 
-        conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
-        if not isinstance(conditions, Iterable):
-            conditions = (conditions,)
-        self._query_builder.add_statement(clauses.Where(*conditions))
+        where = clauses.Where(*result, restrictive=restrictive)
+        self._query_builder.add_statement(where)
         return self
 
     @override
-    def having(self, conditions: WhereTypes) -> IStatements_two_generic[T, TRepo]:
-        conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
-        if not isinstance(conditions, Iterable):
-            conditions = (conditions,)
-        self._query_builder.add_statement(clauses.Having(*conditions))
+    def having(self, conditions: ColumnType, restrictive: bool = True) -> IStatements[T]:
+        result = GlobalChecker.resolved_callback_object(self.model, conditions)
+        having = clauses.Having(*result, restrictive=restrictive)
+        self._query_builder.add_statement(having)
         return self
 
     @override
-    def order[TValue](self, columns: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, TRepo]:
-        query = GlobalChecker.resolved_callback_object(columns, self._models)
-        order = clauses.Order(query, order_type, dialect=self._dialect)
-        self._query_builder.add_statement(order)
-        return self
+    def order[TValue](self, columns: str | Callable[[T], TValue], order_type: OrderTypes = OrderType.ASC) -> IStatements[T]:
+        if isinstance(columns, str):
+            callable_func = lambda x: columns  # noqa: E731
+        else:
+            callable_func = columns
 
-    @override
-    def concat(self, selector: SelectCols[T, str], alias: str = "concat") -> IAggregate:
-        return func.Concat(values=selector, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
+        res = GlobalChecker.resolved_callback_object(self.model, callable_func)
+        deferred_op = clauses.Order(*res, order_type=order_type)
+        self._query_builder.add_statement(deferred_op)
+
+        return self
 
     @override
     def max[TProp](
         self,
         column: SelectCols[T, TProp],
-        alias: str = "max",
-        execute: bool = False,
+        alias: AliasType = "max",
     ) -> int:
-        column = GlobalChecker.resolved_callback_object(column, self.models)
-        if execute is True:
-            return self.select_one(self.max(column, alias, execute=False), flavour=dict)[alias]
-        return func.Max(elements=column, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
+        res = GlobalChecker.resolved_callback_object(self.model, column)[0]
+
+        return self.select_one(lambda x: func.Max(res, alias), flavour=dict)[alias]
 
     @override
     def min[TProp](
         self,
         column: SelectCols[T, TProp],
-        alias: str = "min",
-        execute: bool = False,
+        alias: AliasType = "min",
     ) -> int:
-        column = GlobalChecker.resolved_callback_object(column, self.models)
-        if execute is True:
-            return self.select_one(self.min(column, alias, execute=False), flavour=dict)[alias]
-        return func.Min(elements=column, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
+        res = GlobalChecker.resolved_callback_object(self.model, column)[0]
+
+        return self.select_one(lambda x: func.Min(res, alias), flavour=dict)[alias]
 
     @override
     def sum[TProp](
         self,
         column: SelectCols[T, TProp],
-        alias: str = "sum",
-        execute: bool = False,
+        alias: AliasType = "sum",
     ) -> int:
-        column = GlobalChecker.resolved_callback_object(column, self.models)
-        if execute is True:
-            return self.select_one(self.sum(column, alias, execute=False), flavour=dict)[alias]
-        return func.Sum(elements=column, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
+        res = GlobalChecker.resolved_callback_object(self.model, column)[0]
+
+        return self.select_one(lambda x: func.Sum(res, alias), flavour=dict)[alias]
 
     @override
     def join[LTable: Table, LProp, RTable: Table, RProp](self, joins: tuple[TupleJoinType[LTable, LProp, RTable, RProp]]) -> JoinContext[tuple[*TupleJoinType[LTable, LProp, RTable, RProp]]]:
@@ -226,39 +249,35 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
         *,
         flavour: Optional[Type[TFlavour]] = None,
         by: JoinType = JoinType.INNER_JOIN,
+        alias: Optional[AliasType[T]] = None,
+        avoid_duplicates: bool = False,
         **kwargs,
     ):
-        if "alias" in kwargs:
-            alias = kwargs.pop("alias")
-            kwargs["alias_clause"] = alias
-        select_clause = GlobalChecker.resolved_callback_object(selector, self._models)
-
         if selector is None:
             # COMMENT: if we do not specify any lambda function we assumed the user want to retreive only elements of the Model itself avoiding other models
-            result = self.select(selector=lambda x: x, flavour=flavour, by=by)
-            # COMMENT: Always we want to retrieve tuple[tuple[Any]]. That's the reason to return result[0] when we ensure the user want only objects of the first table.
-            # Otherwise, we wil return the result itself
-            if flavour:
-                return result
-            return () if not result else result[0]
+            result = self.select(
+                selector=lambda x: x,
+                flavour=flavour,
+                by=by,
+                avoid_duplicates=avoid_duplicates,
+                **kwargs,
+            )
+            return result
+        select_clause = GlobalChecker.resolved_callback_object(self.model, selector)
 
         select = clauses.Select(
-            self._models,
+            table=self.model,
             columns=select_clause,
-            dialect=self.dialect,
-            **kwargs,
+            alias=alias,
+            avoid_duplicates=avoid_duplicates,
         )
+
         self._query_builder.add_statement(select)
 
         self._query_builder.by = by
         self._query: str = self._query_builder.query(self._dialect)
 
-        if flavour:
-            result = self._return_flavour(self.query, flavour, select, **kwargs)
-            if issubclass(flavour, tuple) and isinstance(select_clause, Column | ClauseInfo):
-                return tuple([x[0] for x in result])
-            return result
-        return self._return_model(select, self.query)
+        return ClusterResponse(select, self._engine, flavour, self._query).cluster_data()
 
     @override
     def select_one[TValue, TFlavour, *Ts](
@@ -282,11 +301,8 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
         # select columns from different tables using a join query
         # FIXME [x]: before it was if len(response) == 1 and len(response[0]) == 1: return response[0][0]
         if len(response) == 1:
-            if isinstance(response[0], Iterable) and len(response[0]) == 1:
-                return response[0][0]
-            else:
-                return response[0]
-        return tuple([res[0] for res in response])
+            return response[0]
+        return response
 
     @override
     def first[TValue, TFlavour, *Ts](
@@ -305,22 +321,13 @@ class Statements[T: Table, TRepo](BaseStatement[T, None]):
         )
 
     @override
-    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T], Any]) -> IStatements_two_generic[T]:
-        column = GlobalChecker.resolved_callback_object(column, self.models)
-
-        groupby = clauses.GroupBy(column=column, context=self._query_builder._context, dialect=self.dialect)
-        # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
-        self._query_builder.add_statement(groupby)
+    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T], Any]) -> IStatements[T]:
+        result = GlobalChecker.resolved_callback_object(self.model, column)
+        deferred_op = clauses.GroupBy(*result)
+        self._query_builder.add_statement(deferred_op)
         return self
 
-    @override
-    def alias[TProp](self, column: SelectCols[T, TProp], alias: AliasType[ClauseInfo[T]]) -> clauses.Alias[T]:
-        column = GlobalChecker.resolved_callback_object(column, self.models)
-
-        return clauses.Alias(
-            table=column.table,
-            column=column,
-            alias_clause=alias,
-            context=self._query_builder._context,
-            dialect=self.dialect,
-        )
+    def compile(self) -> str:
+        if not self._query:
+            return self._query_builder.query(self._dialect)
+        return self._query

ormlambda/statements/types.py

@@ -7,50 +7,30 @@ from typing import (
     Union,
     TYPE_CHECKING,
 )
-import enum
 
 
 if TYPE_CHECKING:
     from ormlambda.common.enums import JoinType
     from ormlambda.sql.comparer import Comparer
     from ormlambda.sql.types import ColumnType
+    from ormlambda.common.enums import OrderType
 
 type OrderTypes = Literal["ASC", "DESC"] | OrderType | Iterable[OrderType]
 
 
-class OrderType(str, enum.Enum):
-    def __str__(self):
-        return super().__str__()
-
-    ASC = "ASC"
-    DESC = "DESC"
-
-
-type Tuple[T] = tuple[T, ...]
-
-type Select2[T1, T2] = tuple[Tuple[T1], Tuple[T2]]
-type Select3[T1, T2, T3] = tuple[*Select2[T1, T2], Tuple[T3]]
-type Select4[T1, T2, T3, T4] = tuple[*Select3[T1, T2, T3], Tuple[T4]]
-type Select5[T1, T2, T3, T4, T5] = tuple[*Select4[T1, T2, T3, T4], Tuple[T5]]
-type Select6[T1, T2, T3, T4, T5, T6] = tuple[*Select5[T1, T2, T3, T4, T5], Tuple[T6]]
-type Select7[T1, T2, T3, T4, T5, T6, T7] = tuple[*Select6[T1, T2, T3, T4, T5, T6], Tuple[T7]]
-type Select8[T1, T2, T3, T4, T5, T6, T7, T8] = tuple[*Select7[T1, T2, T3, T4, T5, T6, T7], Tuple[T8]]
-type Select9[T1, T2, T3, T4, T5, T6, T7, T8, T9] = tuple[*Select8[T1, T2, T3, T4, T5, T6, T7, T8], Tuple[T9]]
-type Select10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = tuple[*Select9[T1, T2, T3, T4, T5, T6, T7, T8, T9], Tuple[T10]]
-
+type Tuple[*T] = tuple[tuple[*T], ...]
 type WhereCondition[T, T1] = Callable[[T, T1], bool]
 type JoinCondition[T, T1] = tuple[T1, WhereCondition[T, T1], Optional[JoinType]]
 
 
-# TODOH [x]: This var is duplicated from 'src\ormlambda\databases\my_sql\clauses\create_database.py'
 type TypeExists = Literal["fail", "replace", "append"]
 
 
-type WhereTypes[LTable, LProp, RTable, RProp] = Union[
+type WhereTypes[LTable] = Union[
     bool,
     Comparer,
-    tuple[Comparer],
-    Callable[[LTable], WhereTypes[LTable, LProp, RTable, RProp]],
+    Callable[[LTable], WhereTypes[LTable]],
+    Iterable[WhereTypes[LTable]],
 ]
 
 

ormlambda/util/__init__.py

@@ -1,102 +1,9 @@
-from .module_tree import ModuleTree  # noqa: F401
-from .load_module import __load_module__  # noqa: F401
-import types
-import inspect
-from typing import Any, Literal, Optional, overload, get_origin, TypeGuard, TypeAliasType
-from ormlambda.util.typing import LITERAL_TYPES, _AnnotationScanType
-from .plugin_loader import PluginLoader  # noqa: F401
+from .preloaded import preload_module as preload_module
+from .preloaded import import_prefix as import_prefix
+from . import preloaded as preloaded
 
+from .langhelpers import get_cls_kwargs as get_cls_kwargs
+from .langhelpers import PluginLoader as PluginLoader
 
-def _inspect_func_args(fn) -> tuple[list[str], bool]:
-    try:
-        co_varkeywords = inspect.CO_VARKEYWORDS
-    except AttributeError:
-        # https://docs.python.org/3/library/inspect.html
-        # The flags are specific to CPython, and may not be defined in other
-        # Python implementations. Furthermore, the flags are an implementation
-        # detail, and can be removed or deprecated in future Python releases.
-        spec = inspect.getfullargspec(fn)
-        return spec[0], bool(spec[2])
-    else:
-        # use fn.__code__ plus flags to reduce method call overhead
-        co = fn.__code__
-        nargs = co.co_argcount
-        return (
-            list(co.co_varnames[:nargs]),
-            bool(co.co_flags & co_varkeywords),
-        )
-
-
-@overload
-def get_cls_kwargs(cls: type, *, _set: Optional[set[str]] = None, raiseerr: Literal[True] = ...) -> set[str]: ...
-
-
-@overload
-def get_cls_kwargs(cls: type, *, _set: Optional[set[str]] = None, raiseerr: Literal[False] = ...) -> Optional[set[str]]: ...
-
-
-def get_cls_kwargs(cls: type, *, _set: Optional[set[str]] = None, raiseerr: bool = False) -> Optional[set[str]]:
-    """
-    Get the keyword arguments for a class constructor.
-    Args:
-        cls: The class to inspect.
-        _set: A set to store the keyword arguments.
-        raiseerr: Whether to raise an error if the class is not found.
-    Returns:
-        A set of keyword arguments for the class constructor.
-    """
-    toplevel = _set is None
-    if toplevel:
-        _set = set()
-    assert _set is not None
-
-    ctr = cls.__dict__.get("__init__", False)
-
-    has_init = ctr and isinstance(ctr, types.FunctionType) and isinstance(ctr.__code__, types.CodeType)
-
-    if has_init:
-        names, has_kw = _inspect_func_args(ctr)
-        _set.update(names)
-
-        if not has_kw and not toplevel:
-            if raiseerr:
-                raise TypeError(f"given cls {cls} doesn't have an __init__ method")
-            else:
-                return None
-    else:
-        has_kw = False
-
-    if not has_init or has_kw:
-        for c in cls.__bases__:
-            if get_cls_kwargs(c, _set=_set) is None:
-                break
-
-    _set.discard("self")
-    return _set
-
-
-def avoid_sql_injection(name: str):
-    if any(char in name for char in [";", "--", "/*", "*/"]):
-        raise ValueError("SQL injection detected")
-
-
-def is_literal(type_: Any) -> bool:
-    return get_origin(type) in LITERAL_TYPES
-
-
-def is_pep695(type_: _AnnotationScanType) -> TypeGuard[TypeAliasType]:
-    return isinstance(type_, TypeAliasType)
-
-
-def make_hashable(item: Any) -> Any:
-    if isinstance(item, dict):
-        return tuple(sorted((k, make_hashable(x)) for k, x in item.items()))
-
-    if isinstance(item, (list | set)):
-        return tuple(make_hashable(x) for x in item)
-    if hasattr(item, "__iter__") and not isinstance(item, str | bytes):
-        try:
-            return tuple(make_hashable(x) for x in item)
-        except TypeError:
-            return item  # if it fails, it's already hashable
-    return item
+from .typing import is_literal as is_literal
+from .typing import is_pep695 as is_pep695

ormlambda/util/langhelpers.py

@@ -0,0 +1,102 @@
+import types
+import inspect
+from typing import Literal, Optional, overload, Callable
+from types import ModuleType
+from ormlambda import errors
+
+
+def _inspect_func_args(fn) -> tuple[list[str], bool]:
+    try:
+        co_varkeywords = inspect.CO_VARKEYWORDS
+    except AttributeError:
+        # https://docs.python.org/3/library/inspect.html
+        # The flags are specific to CPython, and may not be defined in other
+        # Python implementations. Furthermore, the flags are an implementation
+        # detail, and can be removed or deprecated in future Python releases.
+        spec = inspect.getfullargspec(fn)
+        return spec[0], bool(spec[2])
+    else:
+        # use fn.__code__ plus flags to reduce method call overhead
+        co = fn.__code__
+        nargs = co.co_argcount
+        return (
+            list(co.co_varnames[:nargs]),
+            bool(co.co_flags & co_varkeywords),
+        )
+
+
+@overload
+def get_cls_kwargs(cls: type, *, _set: Optional[set[str]] = None, raiseerr: Literal[True] = ...) -> set[str]: ...
+
+
+@overload
+def get_cls_kwargs(cls: type, *, _set: Optional[set[str]] = None, raiseerr: Literal[False] = ...) -> Optional[set[str]]: ...
+
+
+def get_cls_kwargs(cls: type, *, _set: Optional[set[str]] = None, raiseerr: bool = False) -> Optional[set[str]]:
+    """
+    Get the keyword arguments for a class constructor.
+    Args:
+        cls: The class to inspect.
+        _set: A set to store the keyword arguments.
+        raiseerr: Whether to raise an error if the class is not found.
+    Returns:
+        A set of keyword arguments for the class constructor.
+    """
+    toplevel = _set is None
+    if toplevel:
+        _set = set()
+    assert _set is not None
+
+    ctr = cls.__dict__.get("__init__", False)
+
+    has_init = ctr and isinstance(ctr, types.FunctionType) and isinstance(ctr.__code__, types.CodeType)
+
+    if has_init:
+        names, has_kw = _inspect_func_args(ctr)
+        _set.update(names)
+
+        if not has_kw and not toplevel:
+            if raiseerr:
+                raise TypeError(f"given cls {cls} doesn't have an __init__ method")
+            else:
+                return None
+    else:
+        has_kw = False
+
+    if not has_init or has_kw:
+        for c in cls.__bases__:
+            if get_cls_kwargs(c, _set=_set) is None:
+                break
+
+    _set.discard("self")
+    return _set
+
+
+class PluginLoader:
+    def __init__(self, group: str, auto_fn: Optional[Callable[..., ModuleType]] = None):
+        self.group = group
+        self.impls: dict[str, ModuleType] = {}
+        self.auto_fn = auto_fn
+
+    def clear(self):
+        self.impls.clear()
+
+    def load(self, name: str) -> Optional[ModuleType]:
+        if name in self.impls:
+            return self.impls[name]()
+        if self.auto_fn:
+            loader = self.auto_fn(name)
+            if loader:
+                self.impls[name] = loader
+                return loader()
+        raise errors.NoSuchModuleError(f"Can't load plugin: {self.group}:{name}")
+
+    def register(self, name: str, modulepath: str, objname: str) -> None:
+        def load():
+            mod = __import__(modulepath)
+            for token in modulepath.split(".")[1:]:
+                mod = getattr(mod, token)
+            return getattr(mod, objname)
+
+        self.impls[name] = load

ormlambda/util/module_tree/dynamic_module.py

@@ -236,7 +236,7 @@ class ModuleTree:
             # we need to ensure that the object we going to add in table_list is the same
             for name, obj in table_class:
                 if name == node.class_name:
-                    table_list.append(obj.create_table_query())
+                    table_list.append(obj.create_table())
         return tuple(table_list)
 
     @staticmethod