ormlambda 2.0.2__py3-none-any.whl → 2.6.0__py3-none-any.whl

ormlambda/databases/my_sql/clauses/select.py

@@ -1,172 +1,45 @@
-from typing import Callable, Optional, Type, override
-import inspect
+from typing import override, Type, Callable, TYPE_CHECKING
 
-from ormlambda.utils.lambda_disassembler import TreeInstruction, TupleInstruction, NestedElement
-from ormlambda.components.select import ISelect, TableColumn
-from ormlambda import Table, ForeignKey
-from ormlambda.utils.table_constructor import TableMeta
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
+from ormlambda.common.enums.join_type import JoinType
 
-from . import JoinSelector, JoinType
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
-class SelectQuery[T: Table, *Ts](ISelect):
-    SELECT = "SELECT"
+class Select[T: Type[Table]](DecompositionQueryBase[T]):
+    CLAUSE: str = "SELECT"
 
     def __init__(
         self,
-        tables: T | tuple[T, *Ts] = (),
-        select_lambda: Optional[Callable[[T, *Ts], None]] = lambda: None,
+        table: T,
+        lambda_query: Callable[[T], tuple] = lambda x: x,
         *,
+        alias: bool = False,
+        alias_name: str | None = None,
         by: JoinType = JoinType.INNER_JOIN,
     ) -> None:
-        if not isinstance(tables, tuple):
-            tables = tuple([tables])
-
-        self._first_table: T = tables[0]
-        self._tables: tuple[T, *Ts] = tables
-        self._select_lambda: Optional[Callable[[T, *Ts], None]] = select_lambda
-        self._by: JoinType = by
-
-        self._tables_heritage: list[tuple[Table, Table]] = []
-        self._lambda_var_to_table_dicc: dict[str, Table] = self._assign_lambda_variables_to_table(select_lambda)
-
-        self._select_list: list[TableColumn] = self._rename_recursive_column_list(select_lambda)
-
-    def _rename_recursive_column_list(self, _lambda: Optional[Callable[[T], None]]) -> list[TableColumn]:
-        """
-        Recursive function tu replace variable names by Select Query
-
-        lambda a: (a.pk_address, a.city.pk_city, a.city.country.pk_country)
-
-        >>> # convert lambda expression into list of values
-        >>> select_list = [
-        >>>     "a.pk_address",
-        >>>     "a.city",
-        >>>     "a.city.pk_city",
-        >>>     "a.city.country",
-        >>>     "a.city.country.pk_country",
-        >>> ]
-        >>> result = _rename_recursive_column_list(select_list)
-        >>> print(result)
-        >>> # result = [
-        >>> #   "address.pk_address"
-        >>> #   "city.*"
-        >>> #   "city.pk_city"
-        >>> #   "country.*"
-        >>> #   "country.pk_country"
-        ]
-        """
-        instruction_list: list[TupleInstruction] = TreeInstruction(_lambda).to_list()
-        column_list: list[TableColumn] = []
-
-        for ti in instruction_list:
-            obj = self._lambda_var_to_table_dicc[ti.var]
-
-            var = obj.__table_name__
-            new_nested = ti.nested_element.parents
-            new_nested[0] = var
-            ti = TupleInstruction(var, NestedElement(new_nested))
-            self._get_parents(obj, ti, column_list)
-        return column_list
-
-    def _get_parents(self, tbl_obj: Table, tuple_inst: TupleInstruction, column_list: list[TableColumn]) -> None:
-        if self._user_want_all_col(tbl_obj, tuple_inst):
-            column_list.extend(list(TableColumn.all_columns(tbl_obj)))
-            return None
-
-        # if the 'last_el' var is a property, we'll know the user will want retrieve a column of the same instance of the 'tbl_obj'. Otherwise the user will want to get a column of the other instance
-        last_el: str = tuple_inst.nested_element.name
-        if self._user_want_column_of_the_same_table(tbl_obj, tuple_inst):
-            return column_list.append(TableColumn(tbl_obj, last_el))
-
-        parents: list[str] = tuple_inst.nested_element.parents
-        first_el = parents[1]
-        new_ti = TupleInstruction(first_el, NestedElement[str](parents[1:]))  # create new TupleInstruction from the second parent to the top
-        new_attr = self.get_attribute_of(tbl_obj, first_el)  # could be Table or property
-
-        self._add_fk_relationship(tbl_obj, new_attr)
-        return self._get_parents(new_attr, new_ti, column_list)
-
-    def _add_fk_relationship(self, t1: Table, t2: Table) -> None:
-        tuple_ = tuple([t1, t2])
-        if tuple_ not in self._tables_heritage:
-            self._tables_heritage.append(tuple_)
-        return None
-
-    @staticmethod
-    def _user_want_all_col(tbl: Table, ti: TupleInstruction) -> bool:
-        """
-        if  ti.nested_element.parents length is 1 says that the element is the table itself (table.*)
-        """
-        return issubclass(tbl.__class__, Table | TableMeta) and len(ti.nested_element.parents) == 1
-
-    def _user_want_column_of_the_same_table(self, table: Table, ti: TupleInstruction) -> bool:
-        last_el: str = ti.nested_element.name
-        first_el = ti.nested_element.parents[1]
-
-        table_attr = self.get_attribute_of(table, first_el)
-
-        return last_el in table.__dict__ and isinstance(table_attr, property)
-
-    @staticmethod
-    def get_attribute_of[TProp: Table](table: TProp, _value: str) -> Optional[TProp | property]:
-        try:
-            return getattr(table.__class__, _value)
-        except Exception:
-            return getattr(table, _value, None)
-
-    def _assign_lambda_variables_to_table(self, _lambda: Callable[[T], None]) -> dict[str, Type[Table]]:
-        """
-        return a dictionary with the lambda's parameters as keys and Type[Table] as the values
-
-
-        >>> res = _assign_lambda_variables_to_table(lambda a,ci,co: ...)
-        >>> print(res)
-        >>> # {
-        >>> #   "a": Address,
-        >>> #   "ci": City,
-        >>> #   "co": Country,
-        >>> # }
-        """
-        lambda_vars = tuple(inspect.signature(_lambda).parameters)
-
-        dicc: dict[str, Table] = {}
-        for i in range(len(lambda_vars)):
-            dicc[lambda_vars[i]] = self._tables[i]
-        return dicc
-
-    def _convert_select_list(self) -> str:
-        self._select_list = self._select_list if self._select_list else tuple(TableColumn.all_columns(self._first_table))
-
-        return ", ".join(col.column for col in self._select_list)
+        super().__init__(
+            table,
+            lambda_query,
+            alias=alias,
+            alias_name=alias_name,
+            by=by,
+        )
+
+    # @classmethod
+    # def alias_children_resolver[Tclause: Type[Table]](self, clause_info: ClauseInfo[Tclause]):
+    #     return f"{clause.table.__table_name__}_{name}"
 
     @override
     @property
     def query(self) -> str:
-        select_str = self._convert_select_list()
-        query: str = f"{self.SELECT} {select_str} FROM {self._first_table.__table_name__}"
+        col: str = ", ".join([x.query for x in self.all_clauses])
+        query: str = f"{self.CLAUSE} {col} FROM {self._table.__table_name__}"
+        alias = ""
 
-        involved_tables = self.get_involved_tables()
-        if not involved_tables:
-            return query
+        query += alias
+        if self.has_foreign_keys:
+            query += " " + self.stringify_foreign_key(" ")
 
-        sub_query: str = ""
-        for l_tbl, r_tbl in involved_tables:
-            join = JoinSelector(l_tbl, r_tbl, by=self._by, where=ForeignKey.MAPPED[l_tbl.__table_name__].referenced_tables[r_tbl.__table_name__].relationship)
-            sub_query += f" {join.query}"
-
-        query += sub_query
         return query
-
-    @override
-    @property
-    def select_list(self) -> list[TableColumn]:
-        return self._select_list
-
-    @override
-    @property
-    def tables_heritage(self) -> list[tuple[Table, Table]]:
-        return self._tables_heritage
-
-    def get_involved_tables(self) -> tuple[tuple[Table, Table]]:
-        return tuple(self._tables_heritage)

ormlambda/databases/my_sql/clauses/where_condition.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, override
+from typing import Any, Callable, Optional, override, Type
 import inspect
 
 from ormlambda.common.enums import ConditionType
@@ -19,7 +19,7 @@ class WhereConditionByArg[TProp1, TProp2](IQuery):
         return f"WHERE {self.cond1} {self.symbol.value} {self.cond2}"
 
 
-class WhereCondition[*Inst](AbstractWhere):
+class WhereCondition[T: Type[Table], *Inst](AbstractWhere):
     """
     The purpose of this class is to create 'WHERE' condition queries properly.
 

ormlambda/databases/my_sql/functions/__init__.py

@@ -0,0 +1,3 @@
+from .max import Max  # noqa: F401
+from .concat import Concat  # noqa: F401
+from .group_by import GroupBy  # noqa: F401

ormlambda/databases/my_sql/functions/concat.py

@@ -0,0 +1,41 @@
+from ormlambda.common.interfaces.IAggregate import IAggregate
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+
+
+import typing as tp
+from ormlambda.common.enums.join_type import JoinType
+
+if tp.TYPE_CHECKING:
+    from ormlambda import Table
+
+
+class Concat[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
+    CLAUSE = "CONCAT"
+
+    def __init__[*Ts](
+        self,
+        table: T,
+        lambda_query: str | tp.Callable[[T], tuple[*Ts]],
+        *,
+        alias: bool = True,
+        alias_name: str = "CONCAT",
+        by: JoinType = JoinType.INNER_JOIN,
+    ) -> None:
+        super().__init__(
+            table,
+            lambda_query,
+            alias=alias,
+            alias_name=alias_name,
+            by=by,
+        )
+
+    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
+        if isinstance(clause_info._row_column, IAggregate):
+            return clause_info._row_column.alias
+        return None
+
+    @property
+    def query(self) -> str:
+        col: str = ", ".join([x.query for x in self.all_clauses])
+
+        return f"{self.CLAUSE}({col})"

ormlambda/databases/my_sql/functions/group_by.py

@@ -0,0 +1,37 @@
+import typing as tp
+from ormlambda.common.enums.join_type import JoinType
+from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo, DecompositionQueryBase
+from ormlambda.common.interfaces.IAggregate import IAggregate
+from ormlambda import Table
+
+
+class GroupBy[T: tp.Type[Table], TProp](DecompositionQueryBase[T], IAggregate[T]):
+    CLAUSE: str = "GROUP BY"
+
+    def __init__(
+        self,
+        table: T,
+        column: tp.Callable[[T], TProp],
+        *,
+        alias: bool = True,
+        alias_name: str | None = None,
+        by: JoinType = JoinType.INNER_JOIN,
+    ) -> None:
+        super().__init__(
+            table,
+            lambda_query=column,
+            alias=alias,
+            alias_name=alias_name,
+            by=by,
+        )
+
+        self._column: TProp = column
+
+    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
+        return None
+
+    @property
+    def query(self) -> str:
+        col: str = ", ".join([x.query for x in self.all_clauses])
+
+        return f"{self.CLAUSE} {col}"

ormlambda/databases/my_sql/functions/max.py

@@ -0,0 +1,39 @@
+from ormlambda.common.interfaces import IAggregate
+import typing as tp
+
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+
+if tp.TYPE_CHECKING:
+    from ormlambda import Table
+
+
+class Max[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
+    NAME: str = "MAX"
+
+    @tp.overload
+    def __init__[T: tp.Type[Table]](self, table: T, column: tp.Callable[[T], tp.Any], *, alias: bool = True, alias_name: str = "max") -> None: ...
+
+    def __init__(
+        self,
+        table: T,
+        column: str | tp.Callable[[T], tuple],
+        *,
+        alias: bool = True,
+        alias_name: str = "max",
+    ) -> None:
+        super().__init__(
+            table,
+            lambda_query=column,
+            alias=alias,
+            alias_name=alias_name,
+        )
+
+    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
+        if isinstance(clause_info._row_column, IAggregate):
+            return clause_info._row_column.alias
+        return None
+
+    @property
+    def query(self) -> str:
+        col = ", ".join([x.query for x in self.all_clauses])
+        return f"{self.NAME}({col})"

ormlambda/databases/my_sql/repository.py

@@ -81,8 +81,10 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
             self.connect()
             try:
                 foo = func(self, *args, **kwargs)
-            finally:
+            except Exception as e:
                 self.connection.rollback()
+                raise e
+            finally:
                 self.close_connection()
             return foo
 
@@ -94,7 +96,8 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         self._connection: PooledMySQLConnection = None
 
     def __create_MySQLConnectionPool(self):
-        return MySQLConnectionPool(pool_name="mypool",pool_size=10, **self._data_config)
+        return MySQLConnectionPool(pool_name="mypool", pool_size=10, **self._data_config)
+
     @override
     def is_connected(self) -> bool:
         return self._connection._cnx is not None if self._connection else False
@@ -122,7 +125,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
             - flavour: Type[TFlavour]: Useful to return tuple of any Iterable type as dict,set,list...
         """
 
-        with self._connection.cursor(buffered=True) as cursor:
+        with self._connection._cnx.cursor(buffered=True) as cursor:
             cursor.execute(query)
             values: list[tuple] = cursor.fetchall()
             columns: tuple[str] = cursor.column_names
@@ -145,33 +148,33 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         queries_list: list[str] = module_tree.get_queries()
 
         for query in queries_list:
-            with self._connection.cursor(buffered=True) as cursor:
+            with self._connection._cnx.cursor(buffered=True) as cursor:
                 cursor.execute(query)
-        self._connection.commit()
+        self._connection._cnx.commit()
         return None
 
     @override
     @get_connection
     def executemany_with_values(self, query: str, values) -> None:
-        with self._connection.cursor(buffered=True) as cursor:
+        with self._connection._cnx.cursor(buffered=True) as cursor:
             cursor.executemany(query, values)
-        self._connection.commit()
+        self._connection._cnx.commit()
         return None
 
     @override
     @get_connection
     def execute_with_values(self, query: str, values) -> None:
-        with self._connection.cursor(buffered=True) as cursor:
+        with self._connection._cnx.cursor(buffered=True) as cursor:
             cursor.execute(query, values)
-        self._connection.commit()
+        self._connection._cnx.commit()
         return None
 
     @override
     @get_connection
     def execute(self, query: str) -> None:
-        with self._connection.cursor(buffered=True) as cursor:
+        with self._connection._cnx.cursor(buffered=True) as cursor:
             cursor.execute(query)
-        self._connection.commit()
+        self._connection._cnx.commit()
         return None
 
     @override
@@ -182,7 +185,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     @get_connection
     def database_exists(self, name: str) -> bool:
         query = "SHOW DATABASES LIKE %s;"
-        with self._connection.cursor(buffered=True) as cursor:
+        with self._connection._cnx.cursor(buffered=True) as cursor:
             cursor.execute(query, (name,))
             res = cursor.fetchmany(1)
         return len(res) > 0
@@ -194,11 +197,11 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     @override
     @get_connection
     def table_exists(self, name: str) -> bool:
-        if not self._connection.database:
+        if not self._connection._cnx.database:
             raise Exception("No database selected")
 
         query = "SHOW TABLES LIKE %s;"
-        with self._connection.cursor(buffered=True) as cursor:
+        with self._connection._cnx.cursor(buffered=True) as cursor:
             cursor.execute(query, (name,))
             res = cursor.fetchmany(1)
         return len(res) > 0
@@ -219,4 +222,4 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     @database.setter
     def database(self, value: str) -> None:
         self._data_config["database"] = value
-        self._pool = self.__create_MySQLConnectionPool() 
+        self._pool = self.__create_MySQLConnectionPool()

ormlambda/databases/my_sql/statements.py

@@ -3,15 +3,10 @@ from typing import override, Type, TYPE_CHECKING, Any, Callable, Optional
 
 if TYPE_CHECKING:
     from ormlambda import Table
-    from ormlambda.components.select import ISelect
     from ormlambda.components.where.abstract_where import AbstractWhere
     from ormlambda.common.interfaces.IStatements import OrderType
     from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
-    from src.ormlambda.common.interfaces.IRepositoryBase import TypeExists
-
-    from ormlambda.databases.my_sql.clauses.select import SelectQuery
-    from ormlambda.databases.my_sql.clauses.count import CountQuery
-
+    from ormlambda.common.interfaces.IRepositoryBase import TypeExists
 
 from ormlambda import AbstractSQLStatements
 from .clauses import DeleteQuery
@@ -20,11 +15,13 @@ from .clauses import JoinSelector
 from .clauses import LimitQuery
 from .clauses import OffsetQuery
 from .clauses import OrderQuery
-from .clauses import SelectQuery
+from .clauses.select import Select
+
 from .clauses import UpsertQuery
 from .clauses import UpdateQuery
 from .clauses import WhereCondition
-from .clauses import CountQuery
+from .clauses import Count
+from .clauses import GroupBy
 
 from mysql.connector import MySQLConnection, errors, errorcode
 
@@ -129,10 +126,10 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return self
 
     @override
-    def count(self) -> int:
-        count_select: IQuery = CountQuery(self._model)
+    def count(self, selection: Callable[[T], tuple] = lambda x: "*") -> int:
+        count_select: IQuery = Select[T](self._model, lambda x: Count[T](self._model, selection))
         self._query_list["select"].append(count_select)
-        query = self.build()
+        query = self._build()
         return self.repository.read_sql(query)[0][0]
 
     @override
@@ -165,10 +162,10 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
             if flavour:
                 return result
             return () if not result else result[0]
-        select: ISelect = SelectQuery(self._model, select_lambda=selector, by=by)
+        select = Select[T](self._model, lambda_query=selector, by=by, alias=False)
         self._query_list["select"].append(select)
 
-        query: str = self.build()
+        query: str = self._build()
         if flavour:
             result = self._return_flavour(query, flavour)
             if issubclass(flavour, tuple) and isinstance(selector(self._model), property):
@@ -194,12 +191,17 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return tuple([res[0] for res in response])
 
     @override
-    def build(self) -> str:
+    def group_by[TRepo, *Ts](self, column: Callable[[T], TRepo], select_query: Callable[[T], tuple[*Ts]]) -> tuple[tuple[*Ts]]:
+        return GroupBy[T, TRepo, tuple[*Ts]](self._model, column, select_query)
+
+    @override
+    def _build(self) -> str:
         query: str = ""
 
-        self.__create_necessary_inner_join()
+        # self.__create_necessary_inner_join()
         for x in self.__order__:
-            if sub_query := self._query_list.get(x, None):
+            sub_query: Optional[list[IQuery]] = self._query_list.get(x, None)
+            if sub_query is not None:
                 if isinstance(sub_query[0], WhereCondition):
                     query_ = self.__build_where_clause(sub_query)
 
@@ -225,19 +227,3 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
             and_, clause = q.split(" ", maxsplit=1)
             query += f" {and_} ({clause})"
         return query
-
-    def __create_necessary_inner_join(self) -> None:
-        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
-        if "where" not in self._query_list:
-            return None
-
-        where: AbstractWhere = self._query_list["where"][0]
-        involved_tables = where.get_involved_tables()
-
-        select: ISelect = self._query_list["select"][0]
-        if not involved_tables or (set(involved_tables) == set(select.tables_heritage)):
-            return None
-
-        for l_tbl, r_tbl in involved_tables:
-            # FIXME [ ]: Checked what function was called by the self.join method before the change
-            self.join(l_tbl, r_tbl, by="INNER JOIN")

ormlambda/model_base.py

@@ -24,6 +24,8 @@ class BaseModel[T: Type[Table]]:
     # region Constructor
 
     def __new__[TRepo](cls, model: T, repository: IRepositoryBase[TRepo]) -> IStatements_two_generic[T, 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:

ormlambda/utils/table_constructor.py

@@ -1,7 +1,7 @@
 import base64
 import datetime
 from decimal import Decimal
-from typing import Any, Iterable, Optional, Type, dataclass_transform
+from typing import Any, Iterable, Optional, Type, dataclass_transform, get_type_hints
 import json
 
 from .dtypes import get_query_clausule
@@ -14,9 +14,9 @@ MISSING = Column()
 
 
 class Field:
-    def __init__(self, name: str, type_: type, default: object) -> None:
+    def __init__(self, name: str, type_: Type, default: object) -> None:
         self.name: str = name
-        self.type_: type = type_
+        self.type_: Type = type_
         self.default: Column = default
 
     def __repr__(self) -> str:
@@ -54,7 +54,8 @@ def delete_special_variables(dicc: dict[str, object]) -> None:
 
 
 def get_fields[T](cls: Type[T]) -> Iterable[Field]:
-    annotations = getattr(cls, "__annotations__", {})
+    # COMMENT: Used the 'get_type_hints' method to resolve typing when 'from __future__ import annotations' is in use
+    annotations = {key: val for key, val in get_type_hints(cls).items() if not key.startswith("_")}
 
     # delete_special_variables(annotations)
     fields = []

{ormlambda-2.0.2.dist-info → ormlambda-2.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.0.2
+Version: 2.6.0
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com