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

ormlambda/{databases/my_sql → statements}/statements.py

@@ -1,57 +1,40 @@
 from __future__ import annotations
-from typing import Concatenate, Iterable, TypedDict, override, Type, TYPE_CHECKING, Any, Callable, Optional
-from mysql.connector import errors, errorcode
+from typing import Concatenate, Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
-from ormlambda.databases.my_sql.clauses.joins import JoinSelector
 from ormlambda import ForeignKey
 
-from ormlambda.common.interfaces import IQuery
-from mysql.connector import MySQLConnection
-
 
 if TYPE_CHECKING:
+    from ormlambda.engine.base import Engine
     from ormlambda.sql.types import AliasType
     from ormlambda import Table
     from ormlambda.statements.types import OrderTypes
     from ormlambda.sql.types import ColumnType
     from ormlambda.statements.types import SelectCols
-    from ormlambda.repository.interfaces import IRepositoryBase
     from ormlambda.statements.interfaces import IStatements_two_generic
-    from ormlambda.repository.interfaces.IRepositoryBase import TypeExists
+    from ormlambda.statements.types import TypeExists
     from ormlambda.sql.clause_info import IAggregate
     from ormlambda.statements.types import WhereTypes
 
 
 from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.statements import BaseStatement
-from .clauses import DeleteQuery
-from .clauses import InsertQuery
-from .clauses import Limit
-from .clauses import Offset
-from .clauses import Order
-from .clauses import Select
-
-from .clauses import UpsertQuery
-from .clauses import UpdateQuery
-from .clauses import Where
-from .clauses import Having
-from .clauses import Count
-from .clauses import GroupBy
-from .clauses import Alias
-
 
 from ormlambda import Table, Column
 from ormlambda.common.enums import JoinType
-from . import functions as func
-from .join_context import JoinContext, TupleJoinType
+from ormlambda.sql.clauses.join import JoinContext, TupleJoinType
+
 from ormlambda.common.global_checker import GlobalChecker
+from .query_builder import QueryBuilder
+
+from ormlambda.sql import clauses
+from ormlambda.sql import functions as func
 
 
 # COMMENT: It's so important to prevent information generated by other tests from being retained in the class.
 @staticmethod
-def clear_list[T, **P](f: Callable[Concatenate[MySQLStatements, P], T]) -> Callable[P, T]:
-    def wrapper(self: MySQLStatements, *args: P.args, **kwargs: P.kwargs) -> T:
+def clear_list[T, **P](f: Callable[Concatenate[Statements, P], T]) -> Callable[P, T]:
+    def wrapper(self: Statements, *args: P.args, **kwargs: P.kwargs) -> T:
         try:
             return f(self, *args, **kwargs)
         except Exception as err:
@@ -63,161 +46,20 @@ def clear_list[T, **P](f: Callable[Concatenate[MySQLStatements, P], T]) -> Calla
     return wrapper
 
 
-class OrderType(TypedDict):
-    Select: Select
-    JoinSelector: JoinSelector
-    Where: Where
-    Order: Order
-    GroupBy: GroupBy
-    Having: Having
-    Limit: Limit
-    Offset: Offset
-
-
-class QueryBuilder(IQuery):
-    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "GroupBy", "Having", "Order", "Limit", "Offset")
-
-    def __init__(self, by: JoinType = JoinType.INNER_JOIN):
-        self._context = ClauseInfoContext()
-        self._query_list: OrderType = {}
-        self._by = by
-
-        self._joins: Optional[IQuery] = None
-        self._select: Optional[IQuery] = None
-        self._where: Optional[IQuery] = None
-        self._order: Optional[IQuery] = None
-        self._group_by: Optional[IQuery] = None
-        self._limit: Optional[IQuery] = None
-        self._offset: Optional[IQuery] = None
-
-    def add_statement[T](self, clause: ClauseInfo[T]):
-        self.update_context(clause)
-        self._query_list[type(clause).__name__] = clause
-
-    @property
-    def by(self) -> JoinType:
-        return self._by
-
-    @by.setter
-    def by(self, value: JoinType) -> None:
-        self._by = value
-
-    @property
-    def JOINS(self) -> Optional[set[JoinSelector]]:
-        return self._joins
-
-    @property
-    def SELECT(self) -> IQuery:
-        return self._query_list.get("Select", None)
-
-    @property
-    def WHERE(self) -> IQuery:
-        where = self._query_list.get("Where", None)
-        if not isinstance(where, Iterable):
-            if not where:
-                return ()
-            return (where,)
-        return where
-
-    @property
-    def ORDER(self) -> IQuery:
-        return self._query_list.get("Order", None)
-
-    @property
-    def GROUP_BY(self) -> IQuery:
-        return self._query_list.get("GroupBy", None)
-
-    @property
-    def HAVING(self) -> IQuery:
-        where = self._query_list.get("Having", None)
-        if not isinstance(where, Iterable):
-            if not where:
-                return ()
-            return (where,)
-        return where
-
-    @property
-    def LIMIT(self) -> IQuery:
-        return self._query_list.get("Limit", None)
-
-    @property
-    def OFFSET(self) -> IQuery:
-        return self._query_list.get("Offset", None)
-
-    @property
-    def query(self) -> str:
-        # COMMENT: (select.query, query)We must first create an alias for 'FROM' and then define all the remaining clauses.
-        # This order is mandatory because it adds the clause name to the context when accessing the .query property of 'FROM'
-
-        extract_joins = self.pop_tables_and_create_joins_from_ForeignKey(self._by)
-
-        JOINS = self.stringify_foreign_key(extract_joins, " ")
-        query_list: tuple[str, ...] = (
-            self.SELECT.query,
-            JOINS,
-            Where.join_condition(self.WHERE, True, self._context) if self.WHERE else None,
-            self.GROUP_BY.query if self.GROUP_BY else None,
-            Having.join_condition(self.HAVING, True, self._context) if self.HAVING else None,
-            self.ORDER.query if self.ORDER else None,
-            self.LIMIT.query if self.LIMIT else None,
-            self.OFFSET.query if self.OFFSET else None,
-        )
-        return " ".join([x for x in query_list if x])
-
-    def stringify_foreign_key(self, joins: set[JoinSelector], sep: str = "\n") -> Optional[str]:
-        if not joins:
-            return None
-        sorted_joins = JoinSelector.sort_join_selectors(joins)
-        return f"{sep}".join([join.query for join in sorted_joins])
-
-    def pop_tables_and_create_joins_from_ForeignKey(self, by: JoinType = JoinType.INNER_JOIN) -> set[JoinSelector]:
-        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
-        if not ForeignKey.stored_calls:
-            return None
-
-        joins = set()
-        # Always it's gonna be a set of two
-        # FIXME [x]: Resolved when we get Compare object instead ClauseInfo. For instance, when we have multiples condition using '&' or '|'
-        for fk in ForeignKey.stored_calls.copy():
-            fk = ForeignKey.stored_calls.pop(fk)
-            self._context._add_table_alias(fk.tright, fk.alias)
-            join = JoinSelector(fk.resolved_function(self._context), by, context=self._context, alias=fk.alias)
-            joins.add(join)
-
-        return joins
-
-    def clear(self) -> None:
-        self.__init__()
-        return None
-
-    def update_context(self, clause: ClauseInfo) -> None:
-        if not hasattr(clause, "context"):
-            return None
-
-        if clause.context is not None:
-            self._context.update(clause.context)
-        clause.context = self._context
-
-
-class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
-    def __init__(self, model: tuple[T, *Ts], repository: IRepositoryBase) -> None:
-        super().__init__(model, repository=repository)
-        self._query_builder = QueryBuilder()
-
-    @property
-    @override
-    def repository(self) -> IRepositoryBase:
-        return self._repository
+class Statements[T: Table, TRepo](BaseStatement[T, None]):
+    def __init__(self, model: T, engine: Engine) -> None:
+        super().__init__(model, engine)
+        self._query_builder = QueryBuilder(self.dialect)
 
     @override
     def create_table(self, if_exists: TypeExists = "fail") -> None:
         name: str = self._model.__table_name__
         if self._repository.table_exists(name):
             if if_exists == "replace":
-                self._repository.drop_table(name)
+                self.drop_table()
 
             elif if_exists == "fail":
-                raise errors.ProgrammingError(msg=f"Table '{self._model.__table_name__}' already exists", errno=errorcode.ER_TABLE_EXISTS_ERROR)
+                raise ValueError(f"Table '{self._model.__table_name__}' already exists")
 
             elif if_exists == "append":
                 counter: int = 0
@@ -226,20 +68,25 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
                     counter += 1
                     char = f"_{counter}"
                 name += char
-                self._model.__table_name__ = name
 
-        query = self._model.create_table_query()
+                new_model = self._model
+                new_model.__table_name__ = name
+                return new_model.create_table(self.dialect)
+
+        query = self.model.create_table(self.dialect)
         self._repository.execute(query)
         return None
 
     @override
-    def table_exists(self) -> bool:
-        return self._repository.table_exists(self._model.__table_name__)
+    def drop_table(self)->None:
+        q = self.model.drop_table(self.dialect)
+        self._repository.execute(q)
+        return None
 
     @override
     @clear_list
     def insert(self, instances: T | list[T]) -> None:
-        insert = InsertQuery(self._model, self._repository)
+        insert = clauses.Insert(self._model, self.repository, self._dialect)
         insert.insert(instances)
         insert.execute()
         return None
@@ -254,7 +101,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
             # We always going to have a tuple of one element
             return self.delete(response)
 
-        delete = DeleteQuery(self._model, self._repository)
+        delete = clauses.Delete(self._model, self._repository, engine=self._engine)
         delete.delete(instances)
         delete.execute()
         # not necessary to call self._query_builder.clear() because select() method already call it
@@ -263,7 +110,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     @clear_list
     def upsert(self, instances: T | list[T]) -> None:
-        upsert = UpsertQuery(self._model, self._repository)
+        upsert = clauses.Upsert(self._model, self._repository, engine=self._engine)
         upsert.upsert(instances)
         upsert.execute()
         return None
@@ -271,29 +118,29 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     @clear_list
     def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
-        update = UpdateQuery(self._model, self._repository, self._query_builder.WHERE)
+        update = clauses.Update(self._model, self._repository, self._query_builder.WHERE, engine=self._engine)
         update.update(dicc)
         update.execute()
 
         return None
 
     @override
-    def limit(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
-        limit = Limit(number)
+    def limit(self, number: int) -> IStatements_two_generic[T, TRepo]:
+        limit = clauses.Limit(number, dialect=self._dialect)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
         self._query_builder.add_statement(limit)
         return self
 
     @override
-    def offset(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
-        offset = Offset(number)
+    def offset(self, number: int) -> IStatements_two_generic[T, TRepo]:
+        offset = clauses.Offset(number, dialect=self._dialect)
         self._query_builder.add_statement(offset)
         return self
 
     @override
     def count[TProp](
         self,
-        selection: None | SelectCols[T,TProp] = lambda x: "*",
+        selection: None | SelectCols[T, TProp] = lambda x: "*",
         alias="count",
         execute: bool = False,
     ) -> Optional[int]:
@@ -301,40 +148,41 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
             return self.select_one(self.count(selection, alias, False), flavour=dict)[alias]
 
         selection = GlobalChecker.resolved_callback_object(selection, self.models)
-        return Count(element=selection, alias_clause=alias, context=self._query_builder._context)
+        return clauses.Count(
+            element=selection,
+            alias_clause=alias,
+            context=self._query_builder._context,
+            dialect=self._dialect,
+        )
 
     @override
-    def where(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
+    def where(self, conditions: WhereTypes) -> IStatements_two_generic[T, TRepo]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
 
         conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
         if not isinstance(conditions, Iterable):
             conditions = (conditions,)
-        self._query_builder.add_statement(Where(*conditions))
+        self._query_builder.add_statement(clauses.Where(*conditions))
         return self
 
     @override
-    def having(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
+    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(Having(*conditions))
+        self._query_builder.add_statement(clauses.Having(*conditions))
         return self
 
     @override
-    def order[TValue](self, columns: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, MySQLConnection]:
+    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 = Order(query, order_type)
+        order = clauses.Order(query, order_type, dialect=self._dialect)
         self._query_builder.add_statement(order)
         return self
 
     @override
     def concat(self, selector: SelectCols[T, str], alias: str = "concat") -> IAggregate:
-        return func.Concat[T](
-            values=selector,
-            alias_clause=alias,
-            context=self._query_builder._context,
-        )
+        return func.Concat(values=selector, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
 
     @override
     def max[TProp](
@@ -346,7 +194,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         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)
+        return func.Max(elements=column, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
 
     @override
     def min[TProp](
@@ -358,7 +206,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         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)
+        return func.Min(elements=column, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
 
     @override
     def sum[TProp](
@@ -370,11 +218,11 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         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)
+        return func.Sum(elements=column, alias_clause=alias, context=self._query_builder._context, dialect=self._dialect)
 
     @override
     def join[LTable: Table, LProp, RTable: Table, RProp](self, joins: tuple[TupleJoinType[LTable, LProp, RTable, RProp]]) -> JoinContext[tuple[*TupleJoinType[LTable, LProp, RTable, RProp]]]:
-        return JoinContext(self, joins, self._query_builder._context)
+        return JoinContext(self, joins, self._query_builder._context, self._dialect)
 
     @override
     @clear_list
@@ -386,6 +234,9 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         by: JoinType = JoinType.INNER_JOIN,
         **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:
@@ -397,14 +248,16 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
                 return result
             return () if not result else result[0]
 
-        select = Select[T, *Ts](
+        select = clauses.Select(
             self._models,
             columns=select_clause,
+            dialect=self.dialect,
+            **kwargs,
         )
         self._query_builder.add_statement(select)
 
         self._query_builder.by = by
-        self._query: str = self._query_builder.query
+        self._query: str = self._query_builder.query(self._dialect)
 
         if flavour:
             result = self._return_flavour(self.query, flavour, select, **kwargs)
@@ -458,17 +311,22 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         )
 
     @override
-    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T, *Ts], Any]):
-        groupby = GroupBy(column=column, context=self._query_builder._context)
+    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)
         return self
 
     @override
-    def alias[TProp](self, column: ColumnType[TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]:
-        return Alias(
+    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,
         )

ormlambda/statements/types.py

@@ -48,8 +48,8 @@ type TypeExists = Literal["fail", "replace", "append"]
 
 type WhereTypes[LTable, LProp, RTable, RProp] = Union[
     bool,
-    Comparer[LTable, LProp, RTable, RProp],
-    tuple[Comparer[LTable, LProp, RTable, RProp], ...],
+    Comparer,
+    tuple[Comparer],
     Callable[[LTable], WhereTypes[LTable, LProp, RTable, RProp]],
 ]
 

ormlambda/types/__init__.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+
+from .metadata import (
+    PrimaryKey,
+    AutoGenerated,
+    AutoIncrement,
+    Unique,
+    CheckTypes,
+    Default,
+    NotNull,
+)
+
+
+__all__ = [
+    "PrimaryKey",
+    "AutoGenerated",
+    "AutoIncrement",
+    "Unique",
+    "CheckTypes",
+    "Default",
+    "NotNull",
+    "Binary",
+]

ormlambda/types/metadata.py

@@ -0,0 +1,42 @@
+class PrimaryKey:
+    """Marks a column as a primary key"""
+
+    ...
+
+
+class AutoGenerated:
+    """Marks a column as auto-generated"""
+
+    ...
+
+
+class AutoIncrement:
+    """Marks a column as auto-increment"""
+
+    ...
+
+
+class Unique:
+    """Marks a column as unique"""
+
+    ...
+
+
+class CheckTypes:
+    """Controls type checking for this column"""
+
+    def __init__(self, enabled: bool = True):
+        self.enabled: bool = enabled
+
+
+class Default[T]:
+    """Sets a default value for a column"""
+
+    def __init__(self, value: T):
+        self.value: T = value
+
+
+class NotNull:
+    """Marks a column as not-null"""
+
+    ...

ormlambda/util/__init__.py

@@ -0,0 +1,87 @@
+from .module_tree import ModuleTree  # 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
+
+
+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)

ormlambda/{utils → util}/module_tree/dynamic_module.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 import sys
 from pathlib import Path
 from typing import Optional, Type, TYPE_CHECKING
-from collections import defaultdict
+
+# from collections import defaultdict
 import importlib.util
 import inspect
 import re
@@ -12,7 +13,7 @@ if TYPE_CHECKING:
 
 
 # from ormlambda import ForeignKey
-from .dfs_traversal import DFSTraversal
+# from .dfs_traversal import DFSTraversal
 
 
 class Node:
@@ -235,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

ormlambda/util/plugin_loader.py

@@ -0,0 +1,32 @@
+from typing import Callable, Optional
+from types import ModuleType
+from ormlambda import errors
+
+
+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