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

ormlambda/statements/base_statement.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING, Optional
+from collections import defaultdict
+
+
+from ormlambda.repository import BaseRepository
+from ormlambda.statements.interfaces import IStatements_two_generic
+from ormlambda import Table
+
+from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.caster.caster import Caster
+
+
+if TYPE_CHECKING:
+    from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
+    from ormlambda.sql.clause_info import ClauseInfo
+
+
+ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
+
+
+class BaseStatement[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
+    def __init__(self, model: tuple[T], repository: BaseRepository) -> None:
+        self.__valid_repository(repository)
+
+        self._query: Optional[str] = None
+        self._model: T = model[0] if isinstance(model, Iterable) else model
+        self._models: tuple[T] = self._model if isinstance(model, Iterable) else (model,)
+        self._repository: BaseRepository = repository
+
+        if not issubclass(self._model, Table):
+            # Deben heredar de Table ya que es la forma que tenemos para identificar si estamos pasando una instancia del tipo que corresponde o no cuando llamamos a insert o upsert.
+            # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
+            raise Exception(f"'{model}' class does not inherit from Table class")
+
+    @staticmethod
+    def __valid_repository(repository: Any) -> bool:
+        if not isinstance(repository, BaseRepository):
+            raise ValueError(f"'repository' attribute does not instance of '{BaseRepository.__name__}'")
+        return True
+
+    def __repr__(self):
+        return f"<Model: {self.__class__.__name__}>"
+
+    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) -> tuple[tuple[T]]:
+        response_sql = self._repository.read_sql(query, flavour=dict, model=self._model, select=select)  # store all columns of the SQL query
+
+        if response_sql and isinstance(response_sql, Iterable):
+            return ClusterQuery(self.repository, select, response_sql).clean_response()
+
+        return response_sql
+
+    @property
+    def query(self) -> str:
+        return self._query
+
+    @property
+    def model(self) -> Type[T]:
+        return self._model
+
+    # TODOL: add *Ts when wil be possible
+    @property
+    def models(self) -> tuple:
+        return self._models
+
+    @property
+    @override
+    def repository(self) -> BaseRepository: ...
+
+
+class ClusterQuery[T]:
+    def __init__(self, repository: BaseRepository, select: DecompositionQueryBase[T], response_sql: tuple[dict[str, Any]]) -> None:
+        self._repository: BaseRepository = repository
+        self._select: DecompositionQueryBase[T] = select
+        self._response_sql: tuple[dict[str, Any]] = response_sql
+        self._caster = Caster(repository)
+
+    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table, ...]]]:
+        tbl_dicc: dict[Type[Table], list[dict[str, Any]]] = self.__loop_foo()
+
+        response = {}
+        tuple_response = []
+        # it not depend of flavour attr
+        for table, attribute_list in tbl_dicc.items():
+            new_instance = []
+            for attrs in attribute_list:
+                casted_attr = {key: self._caster.for_value(value, table.get_column(key).dtype).from_database for key, value in attrs.items()}
+                new_instance.append(table(**casted_attr))
+            response[table] = tuple(new_instance)
+            tuple_response.append(tuple(new_instance))
+        return tuple(tuple_response)
+
+    def __loop_foo(self) -> dict[Type[Table], list[dict[str, Any]]]:
+        # We'll create a default list of dicts *once* we know how many rows are in _response_sql
+        row_count = len(self._response_sql)
+
+        def make_list_of_dicts() -> list[dict[str, Any]]:
+            return [{} for _ in range(row_count)]
+
+        table_attr_dict = defaultdict(make_list_of_dicts)
+
+        for i, dicc_cols in enumerate(self._response_sql):
+            for clause in self._select.all_clauses:
+                table = clause.table
+                col = clause.column
+
+                if col is None or not hasattr(table, col):
+                    agg_methods = self.__get_all_aggregate_method(clause)
+                    raise ValueError(f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'.")
+
+                table_attr_dict[table][i][col] = dicc_cols[clause.alias_clause]
+
+        # Convert back to a normal dict if you like (defaultdict is a dict subclass).
+        return dict(table_attr_dict)
+
+    def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
+        """
+        Get the class name of those classes that inherit from 'AggregateFunctionBase' class in order to create a better error message.
+        """
+        res: set[str] = set()
+        if not isinstance(clauses, Iterable):
+            return clauses.__class__.__name__
+        for clause in clauses:
+            if isinstance(clause, AggregateFunctionBase):
+                res.add(clause.__class__.__name__)
+        return ", ".join(res)

ormlambda/statements/interfaces/IStatements.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+from typing import Any, Callable, Optional, Type, overload, TYPE_CHECKING
+from enum import Enum
+from abc import abstractmethod, ABC
+
+
+from ormlambda.common.enums import JoinType
+
+if TYPE_CHECKING:
+    from ormlambda.repository import BaseRepository
+    from ormlambda import Table
+    from ormlambda.sql.clause_info import IAggregate
+    from ormlambda.sql.types import TupleJoinType, ColumnType
+    from ormlambda.databases.my_sql.join_context import JoinContext
+
+from ..types import (
+    OrderTypes,
+    Tuple,
+    Select2,
+    Select3,
+    Select4,
+    Select5,
+    Select6,
+    Select7,
+    Select8,
+    Select9,
+    Select10,
+    TypeExists,
+    WhereTypes,
+)
+
+
+class IStatements[T: Table](ABC):
+    @abstractmethod
+    def create_table(self, if_exists: TypeExists = "fail") -> 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
+        """
+        ...
+
+    @overload
+    def update(self, dicc: list[dict[ColumnType, Any]]) -> None:
+        """
+        An Iterable of ColumnType
+
+        type ColumnType[TProp]:
+            - TProp
+            - Column[TProp]
+            - AsteriskType
+            - tuple[Column]
+        """
+        ...
+
+    @overload
+    def update(self, dicc: dict[ColumnType, Any]) -> None:
+        """
+        type ColumnType[TProp]:
+            - TProp
+            - Column[TProp]
+            - AsteriskType
+            - tuple[Column]
+        """
+        ...
+
+    @abstractmethod
+    def update(self, dicc) -> 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], tuple] = lambda x: "*",
+        alias_clause="count",
+        execute: bool = False,
+    ) -> Optional[IStatements[T]]: ...
+
+    # 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[LProp, RTable, RProp](self, conditions: Callable[[T], WhereTypes[T, LProp, RTable, RProp]]) -> IStatements[T]: ...
+
+    @abstractmethod
+    def where[LProp, RTable, RProp](self, conditions: WhereTypes[T, LProp, RTable, RProp] = None) -> IStatements[T]: ...
+
+    # 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[P](self, selector: Callable[[T], tuple[P]]) -> IAggregate: ...
+
+    # endregion
+    # region max
+    @overload
+    def max[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: Optional[str] = ...,
+        execute: bool = ...,
+    ) -> TProp: ...
+    # endregion
+    # region min
+    @overload
+    def min[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: Optional[str] = ...,
+        execute: bool = ...,
+    ) -> TProp: ...
+    # endregion
+    # region sum
+    @overload
+    def sum[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: Optional[str] = ...,
+        execute: bool = ...,
+    ) -> TProp: ...
+
+    @overload
+    def join[FKTable](self, joins: TupleJoinType[FKTable] | tuple[*TupleJoinType[FKTable]]) -> JoinContext[tuple[*TupleJoinType[FKTable]]]: ...
+
+    # endregion
+    # region select
+    type SelectorType[TOri, *T] = Callable[[TOri], tuple[*T]] | tuple[*T]
+
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](self, selector: SelectorType[T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], *, by: Optional[Enum] = ...) -> Select10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9](self, selector: SelectorType[T, T1, T2, T3, T4, T5, T6, T7, T8, T9], *, by: Optional[Enum] = ...) -> Select9[T1, T2, T3, T4, T5, T6, T7, T8, T9]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7, T8](self, selector: SelectorType[T, T1, T2, T3, T4, T5, T6, T7, T8], *, by: Optional[Enum] = ...) -> Select8[T1, T2, T3, T4, T5, T6, T7, T8]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7](self, selector: SelectorType[T, T1, T2, T3, T4, T5, T6, T7], *, by: Optional[Enum] = ...) -> Select7[T1, T2, T3, T4, T5, T6, T7]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6](self, selector: SelectorType[T, T1, T2, T3, T4, T5, T6], *, by: Optional[Enum] = ...) -> Select6[T1, T2, T3, T4, T5, T6]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5](self, selector: SelectorType[T, T1, T2, T3, T4, T5], *, by: Optional[Enum] = ...) -> Select5[T1, T2, T3, T4, T5]: ...
+    @overload
+    def select[T1, T2, T3, T4](self, selector: SelectorType[T, T1, T2, T3, T4], *, by: Optional[Enum] = ...) -> Select4[T1, T2, T3, T4]: ...
+    @overload
+    def select[T1, T2, T3](self, selector: SelectorType[T, T1, T2, T3], *, by: Optional[Enum] = ...) -> Select3[T1, T2, T3]: ...
+    @overload
+    def select[T1, T2](self, selector: SelectorType[T, T1, T2], *, by: Optional[Enum] = ...) -> Select2[T1, T2]: ...
+    @overload
+    def select[T1](self, selector: SelectorType[T, T1], *, by: Optional[Enum] = ...) -> Tuple[T1]: ...
+    @overload
+    def select[T1](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ...) -> Tuple[T1]: ...
+    @overload
+    def select(self) -> Tuple[T]: ...
+
+    type SelectorFlavourType[T, TResponse] = Optional[Callable[[T], TResponse]]
+
+    # @overload
+    # def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> TFlavour: ...
+    @overload
+    def select[TRes](self, selector: SelectorFlavourType[T, TRes] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[TRes, ...]: ...
+    @overload
+    def select[*TRes](self, selector: SelectorFlavourType[T, tuple[*TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
+    @overload
+    def select[TFlavour](self, selector: SelectorFlavourType[T, tuple] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> tuple[TFlavour]: ...
+
+    @abstractmethod
+    def select[TValue, TFlavour, P](self, selector: SelectorFlavourType[T, tuple[TValue, P]] = ..., *, 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], T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
+    @overload
+    def select_one[*TRes](self, selector: Callable[[T], tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
+    @overload
+    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type) -> T1: ...
+    @overload
+    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> T1: ...
+    @overload
+    def select_one[*TRest](self, selector: Callable[[T], tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple]) -> tuple[*TRest]: ...
+    @overload
+    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
+    @abstractmethod
+    def select_one[TValue, TFlavour, *TRest](
+        self,
+        selector: Optional[Callable[[T], tuple[TValue, *TRest]]] = lambda: None,
+        *,
+        flavour: Type[TFlavour] = ...,
+        by: Optional[Enum] = ...,
+    ): ...
+
+    # endregion
+
+    # region first
+    @overload
+    def first(self) -> T: ...
+
+    # endregion
+
+    # region group_by
+    @abstractmethod
+    def group_by[TRepo](self, column: Callable[[T], TRepo]) -> IStatements[T]: ...
+
+    # endregion
+
+    @abstractmethod
+    def alias(self, column: Callable[[T], Any], alias: str) -> IStatements[T]: ...
+
+
+class IStatements_two_generic[T, TPool](IStatements[T]):
+    @property
+    @abstractmethod
+    def repository(self) -> BaseRepository[TPool]: ...
+
+    @property
+    def query(self) -> str: ...
+
+    @property
+    def model(self) -> Type[T]: ...
+
+    # TODOL: add P when wil be possible
+    @property
+    def models(self) -> tuple: ...

ormlambda/statements/interfaces/__init__.py

@@ -0,0 +1 @@
+from .IStatements import IStatements, IStatements_two_generic  # noqa: F401

ormlambda/statements/types.py

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

ormlambda/utils/__init__.py

@@ -1,3 +1 @@
-from .column import Column  # noqa: F401
-from .foreign_key import ForeignKey  # noqa: F401
-from .table_constructor import Table  # noqa: F401
+from .module_tree import ModuleTree  # noqa: F401

ormlambda/utils/module_tree/__init__.py

@@ -0,0 +1 @@
+from .dynamic_module import ModuleTree  # noqa: F401

ormlambda/utils/module_tree/dynamic_module.py

@@ -1,14 +1,17 @@
+from __future__ import annotations
 import sys
 from pathlib import Path
-from typing import Optional, Type
+from typing import Optional, Type, TYPE_CHECKING
 from collections import defaultdict
 import importlib.util
 import inspect
 import re
 
-from ormlambda import ForeignKey
+if TYPE_CHECKING:
+    from ormlambda import Table
 
-from ormlambda import Table
+
+# from ormlambda import ForeignKey
 from .dfs_traversal import DFSTraversal
 
 
@@ -176,19 +179,20 @@ class ModuleTree:
         return None
 
     def order_modules_from_file(self) -> tuple[str]:
-        """
-        Method whose main used is sorting all .py inside of folder to avoid import errors and overall for the creation of tables in SQL, comply with foreign key referenced table
-        This method's main purpose is to sort all .py inside a folder to avoid import errors and to ensure that tables referenced by foreign key in other tables are created first
-        """
-        tables: list[tuple[str, Table]] = self.get_member_table(self.load_module("", self.module_path))
+        return
+        # """
+        # Method whose main used is sorting all .py inside of folder to avoid import errors and overall for the creation of tables in SQL, comply with foreign key referenced table
+        # This method's main purpose is to sort all .py inside a folder to avoid import errors and to ensure that tables referenced by foreign key in other tables are created first
+        # """
+        # tables: list[tuple[str, Table]] = self.get_member_table(self.load_module("", self.module_path))
 
-        graph: dict[str, list[str]] = defaultdict(list)
-        for _, tbl in tables:
-            graph[tbl.__table_name__] = [x.__table_name__ for x in tbl.find_dependent_tables()]
+        # graph: dict[str, list[str]] = defaultdict(list)
+        # for _, tbl in tables:
+        #     graph[tbl.__table_name__] = [x.__table_name__ for x in tbl.find_dependent_tables()]
 
-        sorted_tables = DFSTraversal.sort(graph)
-        res = [ForeignKey.MAPPED[x].table_object.create_table_query() for x in sorted_tables]
-        return res
+        # sorted_tables = DFSTraversal.sort(graph)
+        # res = [ForeignKey.MAPPED[x].table_object.create_table_query() for x in sorted_tables]
+        # return res
 
     @staticmethod
     def find_module(module_name: str, nodes: list["Node"]) -> Optional["Node"]:
@@ -236,4 +240,6 @@ class ModuleTree:
 
     @staticmethod
     def get_member_table(module) -> list[tuple[str, Type[Table]]]:
+        from ormlambda import Table
+
         return inspect.getmembers(module, lambda x: inspect.isclass(x) and issubclass(x, Table) and x is not Table)