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

ormlambda/statements/interfaces/IStatements.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import Any, Callable, Optional, Type, overload, TYPE_CHECKING
 from enum import Enum
-from abc import abstractmethod, ABC
+from abc import abstractmethod
 
 
 if TYPE_CHECKING:
@@ -9,12 +9,11 @@ if TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.sql.clause_info import IAggregate
     from ormlambda.sql.types import TupleJoinType, ColumnType
-    from ormlambda.components.join import JoinContext
+    from ormlambda.sql.clauses.join import JoinContext
     from ormlambda.common.enums import JoinType
     from ormlambda.sql.clause_info import ClauseInfo
     from ormlambda.sql.types import AliasType
 
-
 from ..types import (
     OrderTypes,
     Tuple,
@@ -31,9 +30,10 @@ from ..types import (
     WhereTypes,
     SelectCols,
 )
+from ormlambda.sql.elements import Element
 
 
-class IStatements[T: Table](ABC):
+class IStatements[T: Table](Element):
     @abstractmethod
     def create_table(self, if_exists: TypeExists = "fail") -> None: ...
 
@@ -334,6 +334,7 @@ class IStatements_two_generic[T, TPool](IStatements[T]):
     def repository(self) -> BaseRepository[TPool]: ...
 
     @property
+    @abstractmethod
     def query(self) -> str: ...
 
     @property

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

@@ -1,25 +1,29 @@
 from __future__ import annotations
-from typing import Iterable, TypedDict, Optional
+from typing import Iterable, TypedDict, Optional, TYPE_CHECKING
 
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
-from ormlambda.databases.my_sql.clauses.joins import JoinSelector
+from ormlambda.sql.clauses import JoinSelector
 from ormlambda import ForeignKey
 
 from ormlambda.common.interfaces import IQuery
 
 
 from ormlambda.sql.clause_info import ClauseInfo
-from .clauses import Limit
-from .clauses import Offset
-from .clauses import Order
-from .clauses import Select
 
-from .clauses import Where
-from .clauses import Having
-from .clauses import GroupBy
+if TYPE_CHECKING:
+    from ..sql.clauses import Limit as Limit
+    from ..sql.clauses import Offset as Offset
+    from ..sql.clauses import Order as Order
+    from ..sql.clauses import Select as Select
 
+    from ..sql.clauses import GroupBy as GroupBy
 
+    from ormlambda.dialects import Dialect
+
+from ..sql.clauses import Where as Where
+from ..sql.clauses import Having as Having
 from ormlambda.common.enums import JoinType
+from ormlambda.sql.elements import ClauseElement
 
 
 class OrderType(TypedDict):
@@ -36,7 +40,8 @@ class OrderType(TypedDict):
 class QueryBuilder(IQuery):
     __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "GroupBy", "Having", "Order", "Limit", "Offset")
 
-    def __init__(self, by: JoinType = JoinType.INNER_JOIN):
+    def __init__(self, dialect: Dialect, by: JoinType = JoinType.INNER_JOIN):
+        self.dialect = dialect
         self._context = ClauseInfoContext()
         self._query_list: OrderType = {}
         self._by = by
@@ -66,11 +71,11 @@ class QueryBuilder(IQuery):
         return self._joins
 
     @property
-    def SELECT(self) -> IQuery:
+    def SELECT(self) -> ClauseElement:
         return self._query_list.get("Select", None)
 
     @property
-    def WHERE(self) -> IQuery:
+    def WHERE(self) -> ClauseElement:
         where = self._query_list.get("Where", None)
         if not isinstance(where, Iterable):
             if not where:
@@ -79,15 +84,15 @@ class QueryBuilder(IQuery):
         return where
 
     @property
-    def ORDER(self) -> IQuery:
+    def ORDER(self) -> ClauseElement:
         return self._query_list.get("Order", None)
 
     @property
-    def GROUP_BY(self) -> IQuery:
+    def GROUP_BY(self) -> ClauseElement:
         return self._query_list.get("GroupBy", None)
 
     @property
-    def HAVING(self) -> IQuery:
+    def HAVING(self) -> ClauseElement:
         where = self._query_list.get("Having", None)
         if not isinstance(where, Iterable):
             if not where:
@@ -96,15 +101,14 @@ class QueryBuilder(IQuery):
         return where
 
     @property
-    def LIMIT(self) -> IQuery:
+    def LIMIT(self) -> ClauseElement:
         return self._query_list.get("Limit", None)
 
     @property
-    def OFFSET(self) -> IQuery:
+    def OFFSET(self) -> ClauseElement:
         return self._query_list.get("Offset", None)
 
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> 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'
 
@@ -112,14 +116,14 @@ class QueryBuilder(IQuery):
 
         JOINS = self.stringify_foreign_key(extract_joins, " ")
         query_list: tuple[str, ...] = (
-            self.SELECT.query,
+            self.SELECT.compile(dialect).string,
             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,
+            Where.join_condition(self.WHERE, True, self._context, dialect=dialect) if self.WHERE else None,
+            self.GROUP_BY.compile(dialect).string if self.GROUP_BY else None,
+            Having.join_condition(self.HAVING, True, self._context, dialect=dialect) if self.HAVING else None,
+            self.ORDER.compile(dialect).string if self.ORDER else None,
+            self.LIMIT.compile(dialect).string if self.LIMIT else None,
+            self.OFFSET.compile(dialect).string if self.OFFSET else None,
         )
         return " ".join([x for x in query_list if x])
 
@@ -127,7 +131,7 @@ class QueryBuilder(IQuery):
         if not joins:
             return None
         sorted_joins = JoinSelector.sort_join_selectors(joins)
-        return f"{sep}".join([join.query for join in sorted_joins])
+        return f"{sep}".join([join.query(self.dialect) 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.
@@ -139,14 +143,15 @@ class QueryBuilder(IQuery):
         # 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)
+            fk_alias = fk.get_alias(self.dialect)
+            self._context._add_table_alias(fk.tright, fk_alias)
+            join = JoinSelector(fk.resolved_function(self._context), by, context=self._context, alias=fk_alias, dialect=self.dialect)
             joins.add(join)
 
         return joins
 
     def clear(self) -> None:
-        self.__init__()
+        self.__init__(self.dialect, self.by)
         return None
 
     def update_context(self, clause: ClauseInfo) -> None:

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

@@ -1,19 +1,16 @@
 from __future__ import annotations
 from typing import Concatenate, Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
-from mysql.connector import errors, errorcode
 
 from ormlambda import ForeignKey
 
-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 import BaseRepository
     from ormlambda.statements.interfaces import IStatements_two_generic
     from ormlambda.statements.types import TypeExists
     from ormlambda.sql.clause_info import IAggregate
@@ -22,35 +19,22 @@ if TYPE_CHECKING:
 
 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 ormlambda.components.join 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:
@@ -62,10 +46,10 @@ def clear_list[T, **P](f: Callable[Concatenate[MySQLStatements, P], T]) -> Calla
     return wrapper
 
 
-class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
-    def __init__(self, model: tuple[T, *Ts], repository: BaseRepository) -> None:
-        super().__init__(model, repository=repository)
-        self._query_builder = QueryBuilder()
+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:
@@ -75,7 +59,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
                 self._repository.drop_table(name)
 
             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
@@ -84,16 +68,19 @@ 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
     @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
@@ -108,7 +95,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
@@ -117,7 +104,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
@@ -125,22 +112,22 @@ 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
 
@@ -155,40 +142,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](
@@ -200,7 +188,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](
@@ -212,7 +200,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](
@@ -224,11 +212,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
@@ -254,15 +242,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)
@@ -316,21 +305,22 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         )
 
     @override
-    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T, *Ts], Any]) -> IStatements_two_generic[T]:
+    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T], Any]) -> IStatements_two_generic[T]:
         column = GlobalChecker.resolved_callback_object(column, self.models)
 
-        groupby = GroupBy(column=column, context=self._query_builder._context)
+        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: SelectCols[T, TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]:
+    def alias[TProp](self, column: SelectCols[T, TProp], alias: AliasType[ClauseInfo[T]]) -> clauses.Alias[T]:
         column = GlobalChecker.resolved_callback_object(column, self.models)
 
-        return Alias(
+        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,88 @@
+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, Sequence, 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/util/load_module.py

@@ -0,0 +1,21 @@
+import logging
+import importlib
+from typing import Any, Optional
+
+log = logging.getLogger(__name__)
+
+
+def __load_module__(module_path: str, dialect_name: Optional[str] = None) -> Optional[Any]:
+    """
+    Load a module by its path and return the module object.
+    Returns None if the module cannot be imported
+    Args:
+        module_path: The dot-separated path to the module
+
+    Returns:
+        The loaded module or None if import fails
+    """
+    try:
+        return importlib.import_module(module_path)
+    except ImportError:
+        log.error(f"{module_path.split('.')[-1] if not dialect_name else dialect_name} dialect not available")