ormlambda 2.11.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

ormlambda/common/interfaces/IStatements.py

@@ -1,348 +0,0 @@
-from __future__ import annotations
-from typing import Any, Callable, Iterable, Optional, Literal, Type, Union, overload, TYPE_CHECKING
-from enum import Enum
-from abc import abstractmethod, ABC
-import enum
-
-from .IRepositoryBase import IRepositoryBase
-from ormlambda.common.enums import JoinType
-
-if TYPE_CHECKING:
-    from ormlambda import Table
-    from .IAggregate import IAggregate
-
-
-class OrderType(enum.Enum):
-    ASC = "ASC"
-    DESC = "DESC"
-
-
-type OrderTypes = Literal["ASC", "DESC"] | OrderType | Iterable[OrderType]
-
-
-type Tuple[T] = tuple[T, ...]
-
-type SelectRes1[T1] = tuple[Tuple[T1]]
-type SelectRes2[T1, T2] = tuple[*SelectRes1[T1], Tuple[T2]]
-type SelectRes3[T1, T2, T3] = tuple[*SelectRes2[T1, T2], Tuple[T3]]
-type SelectRes4[T1, T2, T3, T4] = tuple[*SelectRes3[T1, T2, T3], Tuple[T4]]
-type SelectRes5[T1, T2, T3, T4, T5] = tuple[*SelectRes4[T1, T2, T3, T4], Tuple[T5]]
-type SelectRes6[T1, T2, T3, T4, T5, T6] = tuple[*SelectRes5[T1, T2, T3, T4, T5], Tuple[T6]]
-type SelectRes7[T1, T2, T3, T4, T5, T6, T7] = tuple[*SelectRes6[T1, T2, T3, T4, T5, T6], Tuple[T7]]
-type SelectRes8[T1, T2, T3, T4, T5, T6, T7, T8] = tuple[*SelectRes7[T1, T2, T3, T4, T5, T6, T7], Tuple[T8]]
-type SelectRes9[T1, T2, T3, T4, T5, T6, T7, T8, T9] = tuple[*SelectRes8[T1, T2, T3, T4, T5, T6, T7, T8], Tuple[T9]]
-type SelectRes10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = tuple[*SelectRes9[T1, T2, T3, T4, T5, T6, T7, T8, T9], Tuple[T10]]
-
-
-type WhereCondition[T, T1] = Callable[[T, T1], bool]
-type JoinCondition[T, T1] = tuple[T1, WhereCondition[T, T1], Optional[JoinType]]
-
-type TupleJoins1[T, T1] = tuple[JoinCondition[T, T1]]
-type TupleJoins2[T, T1, T2] = tuple[*TupleJoins1[T, T1], JoinCondition[T, T2]]
-type TupleJoins3[T, T1, T2, T3] = tuple[*TupleJoins2[T, T1, T2], JoinCondition[T, T3]]
-type TupleJoins4[T, T1, T2, T3, T4] = tuple[*TupleJoins3[T, T1, T2, T3], JoinCondition[T, T4]]
-type TupleJoins5[T, T1, T2, T3, T4, T5] = tuple[*TupleJoins4[T, T1, T2, T3, T4], JoinCondition[T, T5]]
-type TupleJoins6[T, T1, T2, T3, T4, T5, T6] = tuple[*TupleJoins5[T, T1, T2, T3, T4, T5], JoinCondition[T, T6]]
-
-
-# TODOH: This var is duplicated from 'src\ormlambda\databases\my_sql\clauses\create_database.py'
-TypeExists = Literal["fail", "replace", "append"]
-
-type WhereTypes[T, *Ts] = Union[Callable[[T, *Ts], bool], Iterable[Callable[[T, *Ts], bool]]]
-
-
-class IStatements[T, *Ts](ABC):
-    @abstractmethod
-    def create_table(self, if_exists: TypeExists) -> None: ...
-
-    # #TODOL [ ]: We must to implement this mehtod
-    # @abstractmethod
-    # def drop_table(self)->None: ...
-
-    @abstractmethod
-    def table_exists(self) -> bool: ...
-
-    # region insert
-    @overload
-    def insert(self, values: T) -> None:
-        """
-        PARAMS
-        ------
-        - values: Recieves a single object that must match the model's type
-        """
-        ...
-
-    @overload
-    def insert(self, values: list[T]) -> None:
-        """
-        PARAMS
-        ------
-        - values: Recieves a list of the same objects as the model
-        """
-        ...
-
-    @abstractmethod
-    def insert(self, values: T | list[T]) -> None: ...
-
-    # endregion
-    # region upsert
-    @overload
-    def upsert(self, values: T) -> None:
-        """
-        PARAMS
-        ------
-        - values: Recieves a single object that must match the model's type
-        """
-        ...
-
-    @overload
-    def upsert(self, values: list[T]) -> None:
-        """
-        PARAMS
-        ------
-        - values: Recieves a list of the same objects as the model
-        """
-        ...
-
-    @abstractmethod
-    def upsert(self, values: list[T]) -> None:
-        """
-        Try to insert new values in the table, if they exist, update them
-        """
-        ...
-
-    @abstractmethod
-    def update(self, dicc: dict[str | property, Any]) -> None: ...
-
-    # endregion
-    # region limit
-    @abstractmethod
-    def limit(self, number: int) -> IStatements[T]: ...
-
-    # endregion
-    # region offset
-    @abstractmethod
-    def offset(self, number: int) -> IStatements[T]: ...
-
-    # endregion
-    # region count
-    @abstractmethod
-    def count(
-        self,
-        selection: Callable[[T], property],
-        alias: bool = ...,
-        alias_name: Optional[str] = ...,
-    ) -> int: ...
-
-    # endregion
-    # region delete
-    @overload
-    def delete(self) -> None: ...
-
-    @overload
-    def delete(self, instance: T) -> None: ...
-
-    @overload
-    def delete(self, instance: list[T]) -> None: ...
-    @abstractmethod
-    def delete(self, instance: Optional[T | list[T]] = ...) -> None: ...
-
-    # endregion
-
-    # region where
-    @overload
-    def where(self, conditions: Iterable[Callable[[T, *Ts], bool]]) -> IStatements[T, *Ts]:
-        """
-        This method creates where clause by passing the Iterable in lambda function
-        EXAMPLE
-        -
-        mb = BaseModel()
-        mb.where(lambda a: (a.city, ConditionType.REGEXP, r"^B"))
-        """
-        ...
-
-    @overload
-    def where(self, conditions: Callable[[T, *Ts], bool], **kwargs) -> IStatements[T, *Ts]:
-        """
-        PARAM
-        -
-
-        -kwargs: Use this when you need to replace variables inside a lambda method. When working with lambda methods, all variables will be replaced by their own variable names. To avoid this, we need to pass key-value parameters  to specify which variables we want to replace with their values.
-
-        EXAMPLE
-        -
-        mb = BaseModel()
-
-        external_data = "
-        mb.where(lambda a: a.city_id > external_data)
-        """
-        ...
-
-    @abstractmethod
-    def where(self, conditions: WhereTypes[T, *Ts] = lambda: None, **kwargs) -> IStatements[T, *Ts]: ...
-
-    # endregion
-    # region order
-    @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
-    @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
-    @abstractmethod
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
-
-    # endregion
-    # region concat
-    @overload
-    def concat[*Ts](self, selector: Callable[[T], tuple[*Ts]]) -> IAggregate[T]: ...
-
-    # endregion
-    # region max
-    @overload
-    def max[TProp](
-        self,
-        column: Callable[[T], TProp],
-        alias: bool = ...,
-        alias_name: Optional[str] = ...,
-    ) -> TProp: ...
-    # endregion
-    # region min
-    @overload
-    def min[TProp](
-        self,
-        column: Callable[[T], TProp],
-        alias: bool = ...,
-        alias_name: Optional[str] = ...,
-    ) -> TProp: ...
-    # endregion
-    # region sum
-    @overload
-    def sum[TProp](
-        self,
-        column: Callable[[T], TProp],
-        alias: bool = ...,
-        alias_name: Optional[str] = ...,
-    ) -> TProp: ...
-
-    # endregion
-    # region join
-
-    @overload
-    def join[T1](self, table: T1, relation: WhereCondition[T, T1], join_type: Optional[JoinType]) -> IStatements[T, T1]: ...
-    @overload
-    def join[T1](self, table: JoinCondition[T, T1]) -> IStatements[T, T1]: ...
-    @overload
-    def join[T1](self, table: TupleJoins1[T, T1]) -> IStatements[T, T1]: ...
-    @overload
-    def join[T1, T2](self, table: TupleJoins2[T, T1, T2]) -> IStatements[T, T1, T2]: ...
-    @overload
-    def join[T1, T2, T3](self, table: TupleJoins3[T, T1, T2, T3]) -> IStatements[T, T1, T2, T3]: ...
-    @overload
-    def join[T1, T2, T3, T4](self, table: TupleJoins4[T, T1, T2, T3, T4]) -> IStatements[T, T1, T2, T3, T4]: ...
-    @overload
-    def join[T1, T2, T3, T4, T5](self, table: TupleJoins5[T, T1, T2, T3, T4, T5]) -> IStatements[T, T1, T2, T3, T4, T5]: ...
-    @overload
-    def join[T1, T2, T3, T4, T5, T6](self, table: TupleJoins6[T, T1, T2, T3, T4, T5, T6]) -> IStatements[T, T1, T2, T3, T4, T5, T6]: ...
-
-    @abstractmethod
-    def join[*FKTables](
-        self,
-        table: Optional[T] = ...,
-        relation: Optional[WhereCondition[T, FKTables]] = ...,
-        join_type: Optional[JoinType] = ...,
-    ) -> IStatements[T, *FKTables]: ...
-
-    # endregion
-    # region select
-    @overload
-    def select(self) -> SelectRes1[T]: ...
-    @overload
-    def select[T1](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ...) -> SelectRes1[T1]: ...
-    @overload
-    def select[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ...) -> SelectRes1[T1]: ...
-    @overload
-    def select[T1, T2](self, selector: Callable[[T, *Ts], tuple[T1, T2]], *, by: Optional[Enum] = ...) -> SelectRes2[T1, T2]: ...
-    @overload
-    def select[T1, T2, T3](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3]], *, by: Optional[Enum] = ...) -> SelectRes3[T1, T2, T3]: ...
-    @overload
-    def select[T1, T2, T3, T4](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4]], *, by: Optional[Enum] = ...) -> SelectRes4[T1, T2, T3, T4]: ...
-    @overload
-    def select[T1, T2, T3, T4, T5](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5]], *, by: Optional[Enum] = ...) -> SelectRes5[T1, T2, T3, T4, T5]: ...
-    @overload
-    def select[T1, T2, T3, T4, T5, T6](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6]], *, by: Optional[Enum] = ...) -> SelectRes6[T1, T2, T3, T4, T5, T6]: ...
-    @overload
-    def select[T1, T2, T3, T4, T5, T6, T7](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7]], *, by: Optional[Enum] = ...) -> SelectRes7[T1, T2, T3, T4, T5, T6, T7]: ...
-    @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7, T8]], *, by: Optional[Enum] = ...) -> SelectRes8[T1, T2, T3, T4, T5, T6, T7, T8]: ...
-    @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]], *, by: Optional[Enum] = ...) -> SelectRes9[T1, T2, T3, T4, T5, T6, T7, T8, T9]: ...
-    @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], *, by: Optional[Enum] = ...) -> SelectRes10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: ...
-
-    @overload
-    def select[TFlavour](self, selector: Optional[Callable[[T, *Ts], tuple]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> TFlavour: ...
-    @overload
-    def select[TRes](self, selector: Optional[Callable[[T, *Ts], TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[TRes, ...]: ...
-    @overload
-    def select[TRes](self, selector: Optional[Callable[[T, *Ts], tuple[TRes]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[TRes, ...]: ...
-    @overload
-    def select[*TRes](self, selector: Optional[Callable[[T, *Ts], tuple[*TRes]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
-    @overload
-    def select[TFlavour](self, selector: Optional[Callable[[T, *Ts], tuple]] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> tuple[TFlavour]: ...
-
-    @abstractmethod
-    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour] = ..., by: JoinType = ..., **kwargs): ...
-
-    # endregion
-    # region select_one
-    @overload
-    def select_one(self) -> T: ...
-    @overload
-    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
-    @overload
-    def select_one[T1](self, selector: Callable[[T, *Ts], tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
-    @overload
-    def select_one[*TRes](self, selector: Callable[[T, *Ts], tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
-    @overload
-    def select_one[T1](self, selector: Callable[[T, *Ts], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type) -> T1: ...
-    @overload
-    def select_one[T1, TFlavour](self, selector: Callable[[T, *Ts], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> T1: ...
-    @overload
-    def select_one[*Ts](self, selector: Callable[[T, *Ts], tuple[*Ts]], *, by: Optional[Enum] = ..., flavour: Type[tuple]) -> tuple[*Ts]: ...
-    @overload
-    def select_one[TFlavour](self, selector: Callable[[T, *Ts], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
-    @abstractmethod
-    def select_one[TValue, TFlavour, *Ts](
-        self,
-        selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None,
-        *,
-        flavour: Type[TFlavour] = ...,
-        by: Optional[Enum] = ...,
-    ): ...
-
-    # endregion
-    # region group_by
-    @abstractmethod
-    def group_by[TRepo](self, column: Callable[[T, *Ts], TRepo]) -> IStatements[T, *Ts]: ...
-
-    # endregion
-
-    @abstractmethod
-    def _build(self) -> str: ...
-
-    @abstractmethod
-    def alias(self, column: Callable[[T, *Ts], Any], alias: str) -> IStatements[T, *Ts]: ...
-
-
-class IStatements_two_generic[T: Table, *Ts, TRepo](IStatements[T, *Ts]):
-    @property
-    @abstractmethod
-    def repository(self) -> IRepositoryBase[TRepo]: ...
-
-    @property
-    def query(self) -> str: ...
-
-    @property
-    def model(self) -> Type[T]: ...
-
-    @property
-    def models(self) -> tuple[*Ts]: ...

ormlambda/components/where/__init__.py

@@ -1 +0,0 @@
-from .abstract_where import AbstractWhere  # noqa: F401

ormlambda/components/where/abstract_where.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-from abc import abstractmethod
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ormlambda import Table
-
-from ormlambda.common.interfaces import IQuery
-
-
-class AbstractWhere(IQuery):
-    WHERE: str = "WHERE"
-
-    @abstractmethod
-    def get_involved_tables(self) -> tuple[tuple[Table, Table]]: ...

ormlambda/databases/my_sql/clauses/where_condition.py

@@ -1,222 +0,0 @@
-from typing import Any, Callable, Optional, override, Type
-import inspect
-
-from ormlambda.common.enums import ConditionType
-from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction
-from ormlambda.common.interfaces.IQueryCommand import IQuery
-from ormlambda.components.where.abstract_where import AbstractWhere
-from ormlambda.common.errors import UnmatchedLambdaParameterError
-from ormlambda import Table
-
-
-class WhereConditionByArg[TProp1, TProp2](IQuery):
-    def __init__(self, cond1: TProp1, cond2: TProp2, symbol: ConditionType) -> None:
-        self.cond1: TProp1 = cond1
-        self.cond2: TProp2 = cond2
-        self.symbol: ConditionType = symbol
-
-    @property
-    def query(self) -> str:
-        return f"WHERE {self.cond1} {self.symbol.value} {self.cond2}"
-
-
-class WhereCondition[T: Type[Table], *Inst](AbstractWhere):
-    """
-    The purpose of this class is to create 'WHERE' condition queries properly.
-
-    Args.
-        - instances: tuple[*Inst],
-            - passed all instance that we are going to use inside of `function` arg
-
-        - function: Callable[[*Inst], bool] = lambda: None,
-            - lambda function to create condition between instance variables
-        - **kwargs: Any,
-            - We use this clause by passing all the variables that we want to replace inside the lambda function.
-            When we try to disassemble the lambda function, we see that the variables were not replaced by their values.
-            Instead, we only got the variable names, not the values.
-            Due to this problem, we need to specify the correct dictionary to map variable names to their values.
-
-    >>> var = 100
-    >>> _lambda = lambda a: a.city_id <= var
-    >>> ... #Dissamble _lambda method
-    >>> parts_of_lambda = [
-    >>>     "city_id"
-    >>>     "<="
-    >>>     "var"                   <-------- We excepted 100
-    >>> ]
-    """
-
-    __slots__ = [
-        "_instances",
-        "_function",
-        "_tree",
-        "_kwargs",
-        "_lambda_param_map",
-    ]
-
-    def __init__(
-        self,
-        instances: tuple[*Inst],
-        function: Callable[[*Inst], bool] = lambda: None,
-        **kwargs: Any,
-    ) -> None:
-        self._instances: tuple[Table] = instances
-        self._function: Callable[[*Inst], bool] = function
-        self._kwargs: dict[str, tuple[*Inst]] = kwargs
-        self._tree: TreeInstruction = TreeInstruction(function)
-        self._lambda_param_map: dict[str, Table] = self._create_lambda_param_map()
-
-    def _create_lambda_param_map(self) -> dict[str, Table]:
-        """
-        The method is responsible for mapping the variables present in the lambda function so that they are replaced with the instance of the model Table.
-        """
-        lamda_param = inspect.signature(self._function).parameters
-        if len(lamda_param) != (expected := len(self._instances)):
-            raise UnmatchedLambdaParameterError(expected, found_param=tuple(lamda_param))
-
-        _temp_instances = list(self._instances)[::-1]  # we copied and translated tuple instance due to pop each value in order to param
-        new_dicc: dict[str, Table] = {}
-        for param in lamda_param.keys():
-            new_dicc[param] = _temp_instances.pop()
-
-        return new_dicc
-
-    @override
-    @property
-    def query(self) -> str:
-        if len(self._tree.compare_op) == 0:
-            return self._build_with_lambda_as_column_name()
-        return self._build_with_lambda_as_condition()
-
-    def _build_with_lambda_as_column_name(self) -> str:
-        conditions, compare_sign = self.create_conditions_list_and_compare_sign()
-        c1, c2 = conditions
-        return f"{self.WHERE} {c1} {compare_sign[0]} {c2}"
-
-    def _replace_values(self, ti: TupleInstruction) -> str:
-        instance: Any = self._kwargs[ti.var]
-        if isinstance(instance, Table):
-            data = getattr(instance, ti.nested_element.name)
-        else:
-            data = instance
-
-        return f"'{data}'" if isinstance(data, str) else data
-
-    def _build_with_lambda_as_condition(self) -> Callable[[], Any]:
-        n: int = len(self._tree.compare_op)
-        dicc_selector: dict[int, Callable[[], str]] = {
-            1: self.__one_sign,
-            2: self.__two_sign,
-        }
-        return dicc_selector[n]()
-
-    def __one_sign(self) -> str:
-        """lambda x: x <= 10"""
-        (c1, c2), _ = self.create_conditions_list_and_compare_sign()
-
-        return f"{self.WHERE} {c1} {self._tree.compare_op[0]} {c2}"
-
-    def _get_table_for_tuple_instruction(self, ti: TupleInstruction) -> Optional[Table]:
-        if ti.var not in self._lambda_param_map:
-            return None
-
-        involved_tables: list[Table] = [self._lambda_param_map[ti.var]]
-
-        def get_attr_tbl(tbl: Table, class_var: str) -> Optional[Table]:
-            tbl_attrs = (tbl, class_var)
-            if hasattr(*tbl_attrs):
-                attr = getattr(*tbl_attrs)
-
-                if not isinstance(attr, property) and issubclass(attr, Table):
-                    return attr
-            return None
-
-        for name in ti.nested_element.parents[1:]:
-            attr = get_attr_tbl(involved_tables[-1], name)
-            if attr is not None:
-                involved_tables.append(attr)
-
-        return involved_tables[-1].__table_name__
-
-    def __two_sign(self) -> str:
-        """lambda x: 100 <= x <= 500"""
-        self.__valid_between_comparable_sign()
-        conds, _ = self.create_conditions_list_and_compare_sign()
-        c1, c2, c3 = conds
-        cond1 = WhereConditionByArg[str, str](c1, c2, ConditionType(self._tree.compare_op[0]))
-        cond2 = WhereConditionByArg[str, str](c2, c3, ConditionType(self._tree.compare_op[1]))
-
-        return WhereCondition.join_condition(cond1, cond2, restrictive=True)
-
-    def __valid_between_comparable_sign(self) -> bool:
-        if not len(self._tree.compare_op) == 2:
-            raise Exception("Number of comparable signs distinct from 2.")
-        return True
-
-    @classmethod
-    def join_condition(cls, *args: WhereConditionByArg, restrictive=False) -> str:
-        BY: str = "AND" if restrictive else "OR"
-        query: str = f"{cls.WHERE} "
-
-        n = len(args)
-        for i in range(n):
-            condition: IQuery = args[i]
-            query += "(" + condition.query.removeprefix(f"{cls.WHERE} ") + ")"
-            if i != n - 1:
-                query += f" {BY} "
-
-        return query
-
-    @override
-    def get_involved_tables(self) -> tuple[tuple[Table, Table]]:
-        return_involved_tables: list[tuple[Table, Table]] = []
-        involved_tables: list[Table] = [self._instances[0]]
-
-        def get_attr_tbl(instance: Table, tbl_name: str) -> Optional[Table]:
-            inst_tbl_name = (instance, tbl_name)
-            if hasattr(*inst_tbl_name):
-                attr = getattr(*inst_tbl_name)
-
-                if not isinstance(attr, property) and issubclass(attr, Table):
-                    return attr
-            return None
-
-        tables: list[str] = self._tree.to_list()[0].nested_element.parents[1:]  # Avoid lambda variable
-        for tbl_name in tables:
-            tbl = involved_tables[-1]
-            attr = get_attr_tbl(tbl, tbl_name)
-            if attr is not None:
-                involved_tables.append(attr)
-                return_involved_tables.append(tuple([tbl, attr]))
-        return tuple(return_involved_tables)
-
-    def create_conditions_list_and_compare_sign(self) -> tuple[list[str], list[str]]:
-        compare_sign: list[str] = []
-        conds: list[str] = []
-        for ti in self._tree.to_list():
-            key = ti.var
-            ne = ti.nested_element
-
-            if hasattr(ConditionType, str(ne.name)):
-                cond_type: ConditionType = getattr(ConditionType, ne.name)
-                compare_sign.append(cond_type.value)
-
-            elif key in self._kwargs:
-                conds.append(self._replace_values(ti))
-            else:
-                _name_table = self._get_table_for_tuple_instruction(ti)
-                _name_table_str = f"{_name_table}." if _name_table else ""
-
-                _name = ne.name
-                if not _name_table:
-                    _name = self._wrapp_condition_id_str(ne.name)
-
-                conds.append(f"{_name_table_str}{_name}")
-        return conds, compare_sign
-
-    def _wrapp_condition_id_str(self, name: Any):
-        if not name:
-            return "NULL"
-        if not isinstance(name, str):
-            return name
-        return f"'{name}'"

ormlambda/model_base.py

@@ -1,36 +0,0 @@
-from typing import Type
-
-
-from .utils import Table
-from .common.interfaces import IRepositoryBase, IStatements_two_generic
-from .common.abstract_classes import AbstractSQLStatements
-from .databases.my_sql import MySQLStatements, MySQLRepository
-
-
-# endregion
-
-
-class BaseModel[T: Type[Table], *Ts]:
-    """
-    Class to select the correct AbstractSQLStatements class depends on the repository.
-
-    Contiene los metodos necesarios para hacer consultas a una tabla
-    """
-
-    statements_dicc: dict[Type[IRepositoryBase], Type[AbstractSQLStatements[T, *Ts, IRepositoryBase]]] = {
-        MySQLRepository: MySQLStatements,
-    }
-
-    # region Constructor
-
-    def __new__[TRepo](cls, model: tuple[T, *Ts], repository: IRepositoryBase[TRepo]) -> IStatements_two_generic[T, *Ts, TRepo]:
-        if repository is None:
-            raise ValueError("`None` cannot be passed to the `repository` attribute when calling the `BaseModel` class")
-        cls: AbstractSQLStatements[T, TRepo] = cls.statements_dicc.get(type(repository), None)
-
-        if not cls:
-            raise Exception(f"The selected repository '{repository}' does not exist.")
-
-        self = object().__new__(cls)
-        cls.__init__(self, model, repository)
-        return self