ormlambda 2.9.0__py3-none-any.whl → 2.9.4__py3-none-any.whl

ormlambda/common/abstract_classes/abstract_model.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING
+from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING, Optional
 from collections import defaultdict
 import abc
 
@@ -16,14 +16,16 @@ if TYPE_CHECKING:
 ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
 
 
-class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
+class AbstractSQLStatements[T: Table, *Ts, TRepo](IStatements_two_generic[T, *Ts, TRepo]):
     __slots__ = ("_model", "_repository", "_query_list")
     __order__: tuple[str, ...] = ("select", "join", "where", "order", "with", "group by", "limit", "offset")
 
-    def __init__(self, model: T, repository: IRepositoryBase[TRepo]) -> None:
+    def __init__(self, model: tuple[T, *Ts], repository: IRepositoryBase[TRepo]) -> None:
         self.__valid_repository(repository)
 
-        self._model: T = model
+        self._query: Optional[str] = None
+        self._model: T = model[0] if isinstance(model, Iterable) else model
+        self._models: tuple[T, *Ts] = self._model if isinstance(model, Iterable) else (model,)
         self._repository: IRepositoryBase[TRepo] = repository
         self._query_list: dict[ORDER_QUERIES, list[IQuery]] = defaultdict(list)
 
@@ -41,12 +43,8 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
     def __repr__(self):
         return f"<Model: {self.__class__.__name__}>"
 
-    @property
-    @override
-    def repository(self) -> IRepositoryBase[TRepo]: ...
-
-    def _return_flavour[TValue](self, query, flavour: Type[TValue], select) -> tuple[TValue]:
-        return self._repository.read_sql(query, flavour=flavour, model=self._model, select=select)
+    def _return_flavour[TValue](self, query, flavour: Type[TValue], select, **kwargs) -> tuple[TValue]:
+        return self._repository.read_sql(query, flavour=flavour, model=self._model, select=select, **kwargs)
 
     def _return_model(self, select, query: str):
         response_sql = self._repository.read_sql(query, flavour=dict, model=self._model, select=select)  # store all columns of the SQL query
@@ -59,6 +57,22 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
     @abc.abstractmethod
     def _build(sef): ...
 
+    @property
+    def query(self) -> str:
+        return self._query
+
+    @property
+    def model(self) -> Type[T]:
+        return self._model
+
+    @property
+    def models(self) -> tuple[*Ts]:
+        return self._models
+
+    @property
+    @override
+    def repository(self) -> IRepositoryBase[TRepo]: ...
+
 
 class ClusterQuery[T]:
     def __init__(self, select: DecompositionQueryBase[T], response_sql: tuple[dict[str, Any]]) -> None:
@@ -82,7 +96,7 @@ class ClusterQuery[T]:
             for dicc_cols in self._response_sql:
                 valid_attr: dict[str, Any] = {}
                 for clause in clauses:
-                    if not hasattr(table, clause.column):
+                    if clause.column is None or not hasattr(table, clause.column):
                         agg_methods = self.__get_all_aggregate_method(clauses)
                         raise ValueError(f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'.")
                     valid_attr[clause.column] = dicc_cols[clause.alias]

ormlambda/common/abstract_classes/decomposition_query.py

@@ -5,13 +5,15 @@ import inspect
 import abc
 from ormlambda import Table
 
-from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction
+from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction, NestedElement
 from ormlambda.common.interfaces import IAggregate, IDecompositionQuery
 from ormlambda import JoinType, ForeignKey
 from ormlambda.databases.my_sql.clauses.joins import JoinSelector
-from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
 
-ClauseDataType = tp.TypeVar("ClauseDataType", bound=tp.Union[property, str])
+from ..errors import DifferentTablesAndVariablesError
+
+type ClauseDataType = property | str
+type AliasType[T] = tp.Type[Table] | tp.Callable[[tp.Type[Table]], T]
 
 
 class ClauseInfo[T: tp.Type[Table]]:
@@ -60,7 +62,7 @@ class ClauseInfo[T: tp.Type[Table]]:
 
         elif isinstance(data, str):
             # TODOL: refactor to base the condition in dict with '*' as key. '*' must to work as special character
-            return f"'{data}'" if data != "*" else data
+            return f"'{data}'" if data != DecompositionQueryBase.CHAR else data
 
     def __create_value_string(self, name: str) -> str:
         if isinstance(self._row_column, property):
@@ -79,38 +81,47 @@ class ClauseInfo[T: tp.Type[Table]]:
         return f"{column_name} as `{alias}`"
 
 
-class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
+class DecompositionQueryBase[T: tp.Type[Table], *Ts](IDecompositionQuery[T, *Ts]):
+    CHAR: str = "*"
+
+    @staticmethod
+    def _asterik_resolver(table: tp.Type[Table]):
+        return table
+
     @tp.overload
-    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]]) -> None: ...
+    def __init__(self, tables: T, lambda_query: tp.Callable[[T], tuple]) -> None: ...
     @tp.overload
-    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ...) -> None: ...
+    def __init__(self, tables: T, lambda_query: tp.Callable[[T], tuple], *, alias: bool = ...) -> None: ...
     @tp.overload
-    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ..., alias_name: tp.Optional[str] = ...) -> None: ...
+    def __init__(self, tables: T, lambda_query: tp.Callable[[T], tuple], *, alias: bool = ..., alias_name: tp.Optional[str] = ...) -> None: ...
     @tp.overload
-    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ..., alias_name: tp.Optional[str] = ..., by: JoinType = ...) -> None: ...
+    def __init__(self, tables: T, lambda_query: tp.Callable[[T], tuple], *, alias: bool = ..., alias_name: tp.Optional[str] = ..., by: JoinType = ...) -> None: ...
     @tp.overload
-    def __init__[*Ts](self, table: T, lambda_query: tp.Callable[[T], tuple[*Ts]], *, alias: bool = ..., alias_name: tp.Optional[str] = ..., by: JoinType = ..., replace_asterisk_char: bool = ...) -> None: ...
+    def __init__(self, tables: T, lambda_query: tp.Callable[[T], tuple], *, alias: bool = ..., alias_name: tp.Optional[str] = ..., by: JoinType = ..., replace_asterisk_char: bool = ...) -> None: ...
+    @tp.overload
+    def __init__(self, tables: T, lambda_query: tp.Callable[[T], tuple], *, alias: bool = ..., alias_name: tp.Optional[str] = ..., by: JoinType = ..., replace_asterisk_char: bool = ..., joins: tp.Optional[list[JoinSelector]] = ...) -> None: ...
 
-    def __init__[*Ts](
+    def __init__(
         self,
-        table: T,
+        tables: tuple[T, *Ts],
         lambda_query: tp.Callable[[T], tuple[*Ts]],
         *,
         alias: bool = True,
         alias_name: tp.Optional[str] = None,
         by: JoinType = JoinType.INNER_JOIN,
         replace_asterisk_char: bool = True,
+        joins: tp.Optional[list[JoinType]] = None,
     ) -> None:
-        self._table: T = table
-        self._lambda_query: tp.Callable[[T], tuple[Ts]] = lambda_query
+        self._tables: tuple[T, *Ts] = tables if isinstance(tables, tp.Iterable) else (tables,)
+        self._lambda_query: tp.Callable[[T], tuple] = lambda_query
         self._alias: bool = alias
         self._alias_name: tp.Optional[str] = alias_name
         self._by: JoinType = by
+        self._joins: set[JoinSelector] = set(joins) if joins is not None else set()
 
-        self._fk_relationship: set[tuple[tp.Type[Table], tp.Type[Table]]] = set()
         self._clauses_group_by_tables: dict[tp.Type[Table], list[ClauseInfo[T]]] = defaultdict(list)
         self._all_clauses: list[ClauseInfo] = []
-        self.alias_cache: dict[str, tp.Any] = {"*": lambda x: x}
+        self.alias_cache: dict[str, AliasType] = {self.CHAR: self._asterik_resolver}
         self._replace_asterisk_char: bool = replace_asterisk_char
         self.__assign_lambda_variables_to_table(lambda_query)
 
@@ -143,77 +154,92 @@ class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
         """
         lambda_vars = tuple(inspect.signature(_lambda).parameters)
 
-        for param in lambda_vars:
-            self.alias_cache[param] = lambda x: self._table
+        # COMMENT: We don't pass a lambda method because lambda reads the las value of 'i'
+        for i, param in enumerate(lambda_vars):
+            self.alias_cache[param] = self._tables[i]
         return None
 
     def __clauses_list_generetor(self, function: tp.Callable[[T], tp.Any]) -> None:
         if not callable(function):
             return None
+        try:
+            resolved_function = function(*self._tables)
+        except TypeError:
+            raise DifferentTablesAndVariablesError
 
-        resolved_function = function(self._table)
-
+        tree_list = TreeInstruction(function).to_list()
         # Python treats string objects as iterable, so we need to prevent this behavior
         if isinstance(resolved_function, str) or not isinstance(resolved_function, tp.Iterable):
             resolved_function = (resolved_function,)
 
-        for index, value in enumerate(resolved_function):
-            values: ClauseInfo | list[ClauseInfo] = self._identify_value_type(index, value, function)
+        for col_index, last_data in enumerate(resolved_function):
+            ti = tree_list[col_index] if tree_list else TupleInstruction(self.CHAR, NestedElement(self.CHAR))
+
+            values: ClauseInfo | list[ClauseInfo] = self.__identify_value_type(last_data, ti)
 
             if isinstance(values, tp.Iterable):
-                [self.add_clause(x) for x in values]
+                [self.__add_clause(x) for x in values]
             else:
-                self.add_clause(values)
+                self.__add_clause(values)
 
         return None
 
-    def _identify_value_type[TProp](self, index: int, value: TProp, function) -> ClauseInfo[T]:
+    def __identify_value_type[TProp](self, last_data: TProp, tuple_instruction: TupleInstruction) -> ClauseInfo[T]:
         """
         A method that behaves based on the variable's type
         """
-        if isinstance(value, property):
-            if value in self._table.__properties_mapped__:
-                return ClauseInfo[T](self._table, value, self.alias_children_resolver)
 
-            return self._search_correct_table_for_prop(index, function, value)
-
-        elif isinstance(value, IAggregate):
-            return ClauseInfo[T](self._table, value, self.alias_children_resolver)
-
-        # if value is a Table instance (when you need to retrieve all columns) we'll ensure that all INNER JOINs are added
-        elif isinstance(value, type) and issubclass(value, Table):
-            if self._table != value:
-                self._add_necessary_fk(index, function, value)
+        if isinstance(last_data, property):
+            if tuple_instruction.var == self.CHAR:
+                table_left = self.table
+            else:
+                table_left = self.alias_cache[tuple_instruction.var]
+
+            if last_data in table_left.__properties_mapped__:
+                # if self.table != table_left:
+                #     self._add_fk_relationship(self.table, table_left)
+                return ClauseInfo[T](table_left, last_data, self.alias_children_resolver)
+
+            for table in self.tables:
+                try:
+                    return self._search_correct_table_for_prop(table, tuple_instruction, last_data)
+                except ValueError:
+                    continue
+
+        elif isinstance(last_data, IAggregate):
+            return ClauseInfo[T](self.table, last_data, self.alias_children_resolver)
+
+        # if value is a Table instance (when you need to retrieve all columns) we'll ensure that all JOINs are added
+        elif isinstance(last_data, type) and issubclass(last_data, Table):
+            if last_data not in self._tables:
+                self.__add_necessary_fk(tuple_instruction, last_data)
             # all columns
             clauses: list[ClauseInfo] = []
-            for prop in value.__properties_mapped__:
+            for prop in last_data.__properties_mapped__:
                 if isinstance(prop, property):
-                    clauses.append(self._identify_value_type(index, prop, function))
+                    clauses.append(self.__identify_value_type(prop, tuple_instruction))
             return clauses
 
-        elif isinstance(value, str):
-            # TODOM: alias_cache to replace '*' by all columns
-            if self._replace_asterisk_char and (replace_value := self.alias_cache.get(value, None)) is not None:
-                return self._identify_value_type(index, replace_value(self._table), function)
-            return ClauseInfo[T](self._table, value, alias_children_resolver=self.alias_children_resolver)
+        elif isinstance(last_data, str):
+            # COMMENT: use self.table instead self._tables because if we hit this conditional, means that
+            # COMMENT: alias_cache to replace '*' by all columns
+            if self._replace_asterisk_char and (replace_value := self.alias_cache.get(last_data, None)) is not None:
+                return self.__identify_value_type(replace_value(self.table), tuple_instruction)
+            return ClauseInfo[T](self.table, last_data, alias_children_resolver=self.alias_children_resolver)
 
-        elif isinstance(value, bool):
-            ...
+        raise NotImplementedError(f"type of value '{last_data}' is not implemented.")
 
-        raise NotImplementedError(f"type of value '{value}' is not implemented.")
+    def _search_correct_table_for_prop[TTable](self, table: tp.Type[Table], tuple_instruction: TupleInstruction, prop: property) -> ClauseInfo[TTable]:
+        temp_table: tp.Type[Table] = table
 
-    def _search_correct_table_for_prop[TTable](self, index: int, function: tp.Callable[[T], tp.Any], prop: property) -> ClauseInfo[TTable]:
-        tree_list = TreeInstruction(function).to_list()
-        temp_table: tp.Type[Table] = self._table
-
-        table_list: list[Table] = tree_list[index].nested_element.parents[1:]
+        _, *table_list = tuple_instruction.nested_element.parents
         counter: int = 0
         while prop not in temp_table.__properties_mapped__:
             new_table: TTable = getattr(temp_table(), table_list[counter])
 
             if not isinstance(new_table, type) or not issubclass(new_table, Table):
                 raise ValueError(f"new_table var must be '{Table.__class__}' type and is '{type(new_table)}'")
-            self.__add_fk_relationship(temp_table, new_table)
+            self._add_fk_relationship(temp_table, new_table)
 
             temp_table = new_table
             counter += 1
@@ -221,41 +247,41 @@ class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
             if prop in new_table.__properties_mapped__:
                 return ClauseInfo[TTable](new_table, prop, self.alias_children_resolver)
 
-        raise ValueError(f"property '{prop}' does not exist in any inherit table.")
+        raise ValueError(f"property '{prop}' does not exist in any inherit tables.")
 
-    def add_clause[Tc: tp.Type[Table]](self, clause: ClauseInfo[Tc]) -> None:
+    def __add_clause[Tc: tp.Type[Table]](self, clause: ClauseInfo[Tc]) -> None:
         self._all_clauses.append(clause)
         self._clauses_group_by_tables[clause._table].append(clause)
-
         return None
 
-    def _add_necessary_fk(self, index: int, function: tp.Callable[[T], tp.Any], table: tp.Type[Table]) -> None:
-        tree_list = TreeInstruction(function).to_list()
-        old_table: tp.Type[Table] = self._table
+    def __add_necessary_fk(self, tuple_instruction: TupleInstruction, tables: tp.Type[Table]) -> None:
+        old_table = self.table
 
-        table_list: list[Table] = tree_list[index].nested_element.parents[1:]
+        table_inherit_list: list[Table] = tuple_instruction.nested_element.parents[1:]
         counter: int = 0
-        while table not in old_table.__dict__.values():
-            new_table: tp.Type[Table] = getattr(old_table(), table_list[counter])
+        while tables not in old_table.__dict__.values():
+            new_table: tp.Type[Table] = getattr(old_table(), table_inherit_list[counter])
 
             if not issubclass(new_table, Table):
                 raise ValueError(f"new_table var must be '{Table.__class__}' type and is '{type(new_table)}'")
 
-            self.__add_fk_relationship(old_table, new_table)
+            self._add_fk_relationship(old_table, new_table)
 
-            if table in new_table.__dict__.values():
-                self.__add_fk_relationship(new_table, table)
-                return None
+            if tables in new_table.__dict__.values():
+                return self._add_fk_relationship(new_table, tables)
 
             old_table = new_table
             counter += 1
 
-        self.__add_fk_relationship(old_table, table)
-        return None
+        return self._add_fk_relationship(old_table, tables)
 
     @property
     def table(self) -> T:
-        return self._table
+        return self.tables[0] if isinstance(self.tables, tp.Iterable) else self.tables
+
+    @property
+    def tables(self) -> T:
+        return self._tables
 
     @property
     def lambda_query[*Ts](self) -> tp.Callable[[T], tuple[*Ts]]:
@@ -271,11 +297,11 @@ class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
 
     @property
     def has_foreign_keys(self) -> bool:
-        return len(self._fk_relationship) > 0
+        return len(self._joins) > 0
 
     @property
     def fk_relationship(self) -> set[tuple[tp.Type[Table], tp.Type[Table]]]:
-        return self._fk_relationship
+        return self._joins
 
     @property
     @abc.abstractmethod
@@ -299,25 +325,14 @@ class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
         self._alias_name = value
 
     def stringify_foreign_key(self, sep: str = "\n") -> str:
-        graph: dict[tp.Type[Table], list[tp.Type[Table]]] = defaultdict(list)
-        for left, right in self.fk_relationship:
-            graph[left].append(right)
-
-        dfs = DFSTraversal.sort(graph)[::-1]
-        query: list = []
-        for l_tbl in dfs:
-            list_r_tbl = graph[l_tbl]
-            if not list_r_tbl:
-                continue
-
-            for r_tbl in list_r_tbl:
-                lambda_relationship = ForeignKey.MAPPED[l_tbl.__table_name__].referenced_tables[r_tbl.__table_name__].relationship
+        sorted_joins = JoinSelector.sort_join_selectors(self._joins)
+        return f"{sep}".join([join.query for join in sorted_joins])
 
-                join = JoinSelector(l_tbl, r_tbl, by=self._by, where=lambda_relationship)
-                query.append(join.query)
+    def _add_fk_relationship[T1: tp.Type[Table], T2: tp.Type[Table]](self, t1: T1, t2: T2) -> None:
+        lambda_relationship = ForeignKey.MAPPED[t1.__table_name__].referenced_tables[t2.__table_name__].relationship
 
-        return f"{sep}".join(query)
-
-    def __add_fk_relationship(self, t1: Table, t2: Table) -> None:
-        self._fk_relationship.add((t1, t2))
-        return None
+        tables = list(self._tables)
+        if t2 not in tables:
+            tables.append(t2)
+        self._tables = tuple(tables)
+        return self._joins.add(JoinSelector[T1, T2](t1, t2, self._by, where=lambda_relationship))

ormlambda/common/errors/__init__.py

@@ -0,0 +1,3 @@
+class DifferentTablesAndVariablesError(Exception):
+    def __str__(self) -> str:
+        return "The number of tables and the variables used in the lambda select are not 'consistent'"

ormlambda/common/interfaces/ICustomAlias.py

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

ormlambda/common/interfaces/IDecompositionQuery.py

@@ -12,11 +12,15 @@ if tp.TYPE_CHECKING:
 from .IQueryCommand import IQuery
 
 
-class IDecompositionQuery[T: tp.Type[Table]](IQuery):
+class IDecompositionQuery[T: tp.Type[Table], *Ts](IQuery):
     @property
     @abc.abstractmethod
     def table(self) -> T: ...
 
+    @property
+    @abc.abstractmethod
+    def tables(self) -> tuple[*Ts]: ...
+
     @property
     @abc.abstractmethod
     def lambda_query[*Ts](self) -> tp.Callable[[T], tuple[*Ts]]: ...

ormlambda/common/interfaces/IRepositoryBase.py

@@ -9,7 +9,7 @@ class IRepositoryBase[T](ABC):
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"
 
     @abstractmethod
-    def read_sql[TFlavour](self, query: str, flavour: Optional[Type[TFlavour]], **kwargs) -> tuple[TFlavour]: ...
+    def read_sql[TFlavour](self, cnx: T, query: str, flavour: Optional[Type[TFlavour]], **kwargs) -> tuple[TFlavour]: ...
 
     @abstractmethod
     def executemany_with_values(self, query: str, values) -> None: ...