ormlambda 3.11.0__tar.gz → 3.11.1__tar.gz

{ormlambda-3.11.0 → ormlambda-3.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.11.0
+Version: 3.11.1
 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

{ormlambda-3.11.0 → ormlambda-3.11.1}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.11.0"
+version = "3.11.1"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"

{ormlambda-3.11.0 → ormlambda-3.11.1}/src/ormlambda/databases/my_sql/functions/max.py

@@ -14,7 +14,7 @@ class Max(AggregateFunctionBase[None]):
 
     def __init__[TProp](
         self,
-        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        elements: ColumnType[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "max",
         context: ClauseContextType = None,
     ):

{ormlambda-3.11.0 → ormlambda-3.11.1}/src/ormlambda/databases/my_sql/statements.py

@@ -14,6 +14,7 @@ if TYPE_CHECKING:
     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.interfaces import IRepositoryBase
     from ormlambda.statements.interfaces import IStatements_two_generic
     from ormlambda.repository.interfaces.IRepositoryBase import TypeExists
@@ -289,25 +290,23 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         return self
 
     @override
-    def count(
+    def count[TProp](
         self,
-        selection: None | Iterable[Table] | Callable[[T], tuple] = lambda x: "*",
-        alias_clause="count",
+        selection: None | SelectCols[T,TProp] = lambda x: "*",
+        alias="count",
         execute: bool = False,
     ) -> Optional[int]:
         if execute is True:
-            return self.select_one(self.count(selection, alias_clause, False), flavour=dict)[alias_clause]
+            return self.select_one(self.count(selection, alias, False), flavour=dict)[alias]
 
-        if GlobalChecker.is_lambda_function(selection):
-            selection = selection(*self.models)
-        return Count(element=selection, alias_clause=alias_clause, context=self._query_builder._context)
+        selection = GlobalChecker.resolved_callback_object(selection, self.models)
+        return Count(element=selection, alias_clause=alias, context=self._query_builder._context)
 
     @override
     def where(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
 
-        if GlobalChecker.is_lambda_function(conditions):
-            conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
         if not isinstance(conditions, Iterable):
             conditions = (conditions,)
         self._query_builder.add_statement(Where(*conditions))
@@ -315,8 +314,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
 
     @override
     def having(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
-        if GlobalChecker.is_lambda_function(conditions):
-            conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
         if not isinstance(conditions, Iterable):
             conditions = (conditions,)
         self._query_builder.add_statement(Having(*conditions))
@@ -324,13 +322,13 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
 
     @override
     def order[TValue](self, columns: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, MySQLConnection]:
-        query = GlobalChecker.resolved_callback_object(columns, self._models) if GlobalChecker.is_lambda_function(columns) else columns
+        query = GlobalChecker.resolved_callback_object(columns, self._models)
         order = Order(query, order_type)
         self._query_builder.add_statement(order)
         return self
 
     @override
-    def concat(self, selector: str | Callable[[T], str], alias: str = "CONCAT") -> IAggregate:
+    def concat(self, selector: SelectCols[T, str], alias: str = "concat") -> IAggregate:
         return func.Concat[T](
             values=selector,
             alias_clause=alias,
@@ -340,10 +338,11 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     def max[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: str = "max",
         execute: bool = False,
-    ) -> TProp:
+    ) -> int:
+        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)
@@ -351,10 +350,11 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     def min[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: str = "min",
         execute: bool = False,
-    ) -> TProp:
+    ) -> int:
+        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)
@@ -362,10 +362,11 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     def sum[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: str = "sum",
         execute: bool = False,
-    ) -> TProp:
+    ) -> int:
+        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)
@@ -384,7 +385,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         by: JoinType = JoinType.INNER_JOIN,
         **kwargs,
     ):
-        select_clause = GlobalChecker.resolved_callback_object(selector, self._models) if GlobalChecker.is_lambda_function(selector) else selector
+        select_clause = GlobalChecker.resolved_callback_object(selector, self._models)
 
         if selector is None:
             # COMMENT: if we do not specify any lambda function we assumed the user want to retreive only elements of the Model itself avoiding other models

{ormlambda-3.11.0 → ormlambda-3.11.1}/src/ormlambda/statements/interfaces/IStatements.py

@@ -27,10 +27,9 @@ from ..types import (
     Select10,
     TypeExists,
     WhereTypes,
+    SelectCols,
 )
 
-type SelectCols[T, TProp] = Callable[[T], ColumnType[TProp]] | ColumnType[TProp]
-
 
 class IStatements[T: Table](ABC):
     @abstractmethod
@@ -132,12 +131,12 @@ class IStatements[T: Table](ABC):
     # endregion
     # region count
     @abstractmethod
-    def count(
+    def count[TProp](
         self,
-        selection: Callable[[T], tuple] = ...,
-        alias_clause="count",
+        selection: None | SelectCols[T, TProp] = ...,
+        alias: str = ...,
         execute: bool = False,
-    ) -> Optional[IStatements[T]]: ...
+    ) -> Optional[int]: ...
 
     # endregion
     # region delete
@@ -174,45 +173,41 @@ class IStatements[T: Table](ABC):
 
     # 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]: ...
+    def order[TValue](self, columns: SelectCols[T, TValue], order_type: OrderTypes) -> IStatements[T]: ...
 
     # endregion
     # region concat
     @overload
-    def concat(self, selector: Callable[[T], str], alias: str = "CONCAT") -> IAggregate: ...
+    def concat(self, selector: SelectCols[T, str], alias: str = "concat") -> IAggregate: ...
 
     # endregion
     # region max
-    @overload
+    @abstractmethod
     def max[TProp](
         self,
         column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
-        execute: bool = ...,
-    ) -> TProp: ...
+        execute: bool = False,
+    ) -> int: ...
     # endregion
     # region min
-    @overload
+    @abstractmethod
     def min[TProp](
         self,
         column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
-        execute: bool = ...,
-    ) -> TProp: ...
+        execute: bool = False,
+    ) -> int: ...
     # endregion
     # region sum
-    @overload
+    @abstractmethod
     def sum[TProp](
         self,
         column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
-        execute: bool = ...,
-    ) -> TProp: ...
+        execute: bool = False,
+    ) -> int: ...
 
     @overload
     def join[FKTable](self, joins: TupleJoinType[FKTable] | tuple[*TupleJoinType[FKTable]]) -> JoinContext[tuple[*TupleJoinType[FKTable]]]: ...

{ormlambda-3.11.0 → ormlambda-3.11.1}/src/ormlambda/statements/types.py

@@ -10,10 +10,10 @@ from typing import (
 import enum
 
 
-from ormlambda.common.enums import JoinType
-
 if TYPE_CHECKING:
+    from ormlambda.common.enums import JoinType
     from ormlambda.sql.comparer import Comparer
+    from ormlambda.sql.types import ColumnType
 
 type OrderTypes = Literal["ASC", "DESC"] | OrderType | Iterable[OrderType]
 
@@ -52,3 +52,6 @@ type WhereTypes[LTable, LProp, RTable, RProp] = Union[
     tuple[Comparer[LTable, LProp, RTable, RProp], ...],
     Callable[[LTable], WhereTypes[LTable, LProp, RTable, RProp]],
 ]
+
+
+type SelectCols[T, TProp] = Callable[[T], ColumnType[TProp]] | ColumnType[TProp]