ormlambda 4.0.0__tar.gz → 4.0.4__tar.gz

{ormlambda-4.0.0 → ormlambda-4.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 4.0.0
+Version: 4.0.4
 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
@@ -90,16 +90,7 @@ If we were used `select_one` method, we retrieved `tuple[Address, City, Country]
 
 ## Filter by `where` condition
 
-we can use only the Original Table to pass the variables like
-```python
-result = AddressModel.where(
-    [
-        Address.address_id >= 10,
-        Address.address_id <= 30,
-    ]
-).select()
-```
-Or by using a lambda function that returns an iterable for tables where the name is unusually long.
+We can use lambda function that returns an iterable to pass the iterable like.
 
 ```python
 result = AddressModel.where(
@@ -119,7 +110,7 @@ result = AddressModel.where(Address.City.Country.country_id  == 87).select()
 We can also return `Address`, `City` or `Country` if needed.
 
 ```python
-result = AddressModel.where(Address.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
+result = AddressModel.where(lambda x: x.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
 ```
 
 ### Pass variables to the `where` method
@@ -127,10 +118,10 @@ result = AddressModel.where(Address.City.Country.country_id == 87).select(lambda
 LOWER = 10
 UPPER = 30
 
-AddressModel.where(
+AddressModel.where(lambda x:
     [
-        Address.address_id >= LOWER,
-        Address.address_id <= UPPER,
+        x.address_id >= LOWER,
+        x.address_id <= UPPER,
     ]
 ).select()
 ```
@@ -238,7 +229,7 @@ result = (
     AddressModel
     .order(lambda a: a.address_id, order_type="DESC")
     .where(lambda x: x.City.Country.country_id >= 50)
-    .select(Address)
+    .select()
 )
 
 ```
@@ -246,13 +237,12 @@ Also you can use `ConditionType` enum for `regular expressions` and get, for exa
 
 
 ```python
-address, city, country = (
+response = (
     AddressModel
-    .order(Address.address_id, order_type="DESC")
-    .where(Address.City.Country.country.regex(r"^[A]"))
+    .order(lambda x: x.address_id, order_type="DESC")
+    .where(lambda x: x.City.Country.country.regex(r"^[A]"))
     .limit(100)
-    .select(
-        lambda a: (
+    .select(lambda a: (
             a,
             a.City,
             a.City.Country,
@@ -261,13 +251,9 @@ address, city, country = (
 )
 
 
-for a in address:
+for a,c,co in response:
     print(a.address_id)
-
-for c in city:
     print(c.city_id)
-
-for co in country:
     print(co.country)
 ```
 
@@ -276,10 +262,9 @@ In the example above, we see that the `result` var returns a tuple of tuples. Ho
 
 ```python
 result = (
-    AddressModel.where(Address.City.Country.country.regex(r"^[A]"))
+    AddressModel.where(lambda x: x.City.Country.country.regex(r"^[A]"))
     .limit(100)
-    .select(
-        lambda a: (
+    .select(lambda a: (
             a.address_id,
             a.City.city_id,
             a.City.Country.country_id,
@@ -318,28 +303,23 @@ The `concat` method allows you to concatenate multiple columns or values into a
 ### Usage
 
 ```python
-response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
-            (
-                Address.address,
-                Address.City.city,
-                Concat(lambda x:
-                    (
-                        "Address: ",
-                        x.address,
-                        " - city: ",
-                        x.City.city,
-                        " - country: ",
-                        x.City.Country.country,
-                    )
-                ),
-            ),
-            flavour=dict,
-        )
+response = (
+    ORM(Address, db)
+    .where(lambda x: x.City.Country.country.regex(r"^Spain"))
+    .first(
+        lambda x: (
+            x.address,
+            x.City.city,
+            Concat(("Address: ", x.address, " - city: ", x.City.city, " - country: ", x.City.Country.country)),
+        ),
+        flavour=dict,
+    )
+)
 
 {
-    "address_address": "939 Probolinggo Loop",
-    "city_city": "A Coruña (La Coruña)",
-    "CONCAT": "Address: 939 Probolinggo Loop - city: A Coruña (La Coruña) - country: Spain",
+    "address": "939 Probolinggo Loop",
+    "city": "A Coruña (La Coruña)",
+    "concat": "Address: 939 Probolinggo Loop - city: A Coruña (La Coruña) - country: Spain",
 }
 ```
 As you can see in the response, the result is a dictionary where the keys are a combination of the table name and the column name. This is done to avoid collisions with columns from other tables that might have the same name.
@@ -390,7 +370,7 @@ res = (
     .select(lambda x:
         (
             x.district,
-            Count(x.address),
+            Count(x.address,alias="count"),
         ),
         flavour=Response,
     )
@@ -442,11 +422,10 @@ print(select.city)
 print(select.country)
 ```
 
-## Combine aggregation method
-As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
+## Aggregation method
+You can also use `aggregation methods` to create more informative queries.
 ```python
-result = AddressModel.select_one(
-            lambda x: (
+result = AddressModel.select_one(lambda x: (
                 Min(x.address_id),
                 Max(x.address_id),
                 Count(x.address_id),

{ormlambda-4.0.0 → ormlambda-4.0.4}/README.md

@@ -77,16 +77,7 @@ If we were used `select_one` method, we retrieved `tuple[Address, City, Country]
 
 ## Filter by `where` condition
 
-we can use only the Original Table to pass the variables like
-```python
-result = AddressModel.where(
-    [
-        Address.address_id >= 10,
-        Address.address_id <= 30,
-    ]
-).select()
-```
-Or by using a lambda function that returns an iterable for tables where the name is unusually long.
+We can use lambda function that returns an iterable to pass the iterable like.
 
 ```python
 result = AddressModel.where(
@@ -106,7 +97,7 @@ result = AddressModel.where(Address.City.Country.country_id  == 87).select()
 We can also return `Address`, `City` or `Country` if needed.
 
 ```python
-result = AddressModel.where(Address.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
+result = AddressModel.where(lambda x: x.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
 ```
 
 ### Pass variables to the `where` method
@@ -114,10 +105,10 @@ result = AddressModel.where(Address.City.Country.country_id == 87).select(lambda
 LOWER = 10
 UPPER = 30
 
-AddressModel.where(
+AddressModel.where(lambda x:
     [
-        Address.address_id >= LOWER,
-        Address.address_id <= UPPER,
+        x.address_id >= LOWER,
+        x.address_id <= UPPER,
     ]
 ).select()
 ```
@@ -225,7 +216,7 @@ result = (
     AddressModel
     .order(lambda a: a.address_id, order_type="DESC")
     .where(lambda x: x.City.Country.country_id >= 50)
-    .select(Address)
+    .select()
 )
 
 ```
@@ -233,13 +224,12 @@ Also you can use `ConditionType` enum for `regular expressions` and get, for exa
 
 
 ```python
-address, city, country = (
+response = (
     AddressModel
-    .order(Address.address_id, order_type="DESC")
-    .where(Address.City.Country.country.regex(r"^[A]"))
+    .order(lambda x: x.address_id, order_type="DESC")
+    .where(lambda x: x.City.Country.country.regex(r"^[A]"))
     .limit(100)
-    .select(
-        lambda a: (
+    .select(lambda a: (
             a,
             a.City,
             a.City.Country,
@@ -248,13 +238,9 @@ address, city, country = (
 )
 
 
-for a in address:
+for a,c,co in response:
     print(a.address_id)
-
-for c in city:
     print(c.city_id)
-
-for co in country:
     print(co.country)
 ```
 
@@ -263,10 +249,9 @@ In the example above, we see that the `result` var returns a tuple of tuples. Ho
 
 ```python
 result = (
-    AddressModel.where(Address.City.Country.country.regex(r"^[A]"))
+    AddressModel.where(lambda x: x.City.Country.country.regex(r"^[A]"))
     .limit(100)
-    .select(
-        lambda a: (
+    .select(lambda a: (
             a.address_id,
             a.City.city_id,
             a.City.Country.country_id,
@@ -305,28 +290,23 @@ The `concat` method allows you to concatenate multiple columns or values into a
 ### Usage
 
 ```python
-response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
-            (
-                Address.address,
-                Address.City.city,
-                Concat(lambda x:
-                    (
-                        "Address: ",
-                        x.address,
-                        " - city: ",
-                        x.City.city,
-                        " - country: ",
-                        x.City.Country.country,
-                    )
-                ),
-            ),
-            flavour=dict,
-        )
+response = (
+    ORM(Address, db)
+    .where(lambda x: x.City.Country.country.regex(r"^Spain"))
+    .first(
+        lambda x: (
+            x.address,
+            x.City.city,
+            Concat(("Address: ", x.address, " - city: ", x.City.city, " - country: ", x.City.Country.country)),
+        ),
+        flavour=dict,
+    )
+)
 
 {
-    "address_address": "939 Probolinggo Loop",
-    "city_city": "A Coruña (La Coruña)",
-    "CONCAT": "Address: 939 Probolinggo Loop - city: A Coruña (La Coruña) - country: Spain",
+    "address": "939 Probolinggo Loop",
+    "city": "A Coruña (La Coruña)",
+    "concat": "Address: 939 Probolinggo Loop - city: A Coruña (La Coruña) - country: Spain",
 }
 ```
 As you can see in the response, the result is a dictionary where the keys are a combination of the table name and the column name. This is done to avoid collisions with columns from other tables that might have the same name.
@@ -377,7 +357,7 @@ res = (
     .select(lambda x:
         (
             x.district,
-            Count(x.address),
+            Count(x.address,alias="count"),
         ),
         flavour=Response,
     )
@@ -429,11 +409,10 @@ print(select.city)
 print(select.country)
 ```
 
-## Combine aggregation method
-As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
+## Aggregation method
+You can also use `aggregation methods` to create more informative queries.
 ```python
-result = AddressModel.select_one(
-            lambda x: (
+result = AddressModel.select_one(lambda x: (
                 Min(x.address_id),
                 Max(x.address_id),
                 Count(x.address_id),

{ormlambda-4.0.0 → ormlambda-4.0.4}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "4.0.0"
+version = "4.0.4"
 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-4.0.0 → ormlambda-4.0.4}/src/ormlambda/repository/response.py

@@ -67,7 +67,15 @@ class Response[TFlavour, *Ts]:
 
         def _tuple(**kwargs) -> list[tuple[*Ts]]:
             nonlocal data
-            return data
+            result = []
+            for value in data:
+                if len(value) ==1:
+                    result.append(value[0])
+                    continue
+                result.append(value)
+
+
+            return result
 
         def _set(**kwargs) -> list[set]:
             nonlocal data

ormlambda-4.0.4/src/ormlambda/statements/base_statement.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+from typing import Any, Type, Iterable, Literal, TYPE_CHECKING
+from collections import defaultdict
+
+
+from ormlambda import Table
+
+from ormlambda.common.errors import AggregateFunctionError
+from ormlambda.sql.clause_info import IAggregate
+
+
+if TYPE_CHECKING:
+    from ormlambda.engine.base import Engine
+    from ormlambda.sql.clauses import Select
+    from ormlambda import ColumnProxy
+
+
+ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
+
+
+type ResponseType = Iterable[dict[str, Any]]
+
+
+class ClusterResponse[T, TFlavour]:
+    def __init__(self, select: Select[T], engine: Engine, flavour: TFlavour, query: str) -> None:
+        self._select: Select[T] = select
+        self.engine = engine
+        self.flavour = flavour
+        self.query = query
+
+    def cluster(self, response_sql: ResponseType) -> tuple[dict[Type[Table], tuple[Table, ...]]]:
+        # We'll create a default list of dicts *once* we know how many rows are in _response_sql
+
+        tables: dict[Table, list[ColumnProxy]] = defaultdict(list)
+        for clause in self._select.columns:
+            if isinstance(clause, IAggregate):
+                raise AggregateFunctionError(clause)
+
+            tables[clause.table].append(clause)
+
+        res = []
+        for dicc_cols in response_sql:
+            converted_row = []
+            for table, columns in tables.items():
+                dicc = {}
+                for col in columns:
+                    if not hasattr(col, "column_name"):
+                        pass
+                    dicc[col.column_name] = dicc_cols[col.alias]
+                converted_row.append(table(**dicc))
+            res.append(tuple(converted_row))
+
+        tuple_response = tuple(res)
+
+        if not tuple_response:
+            return tuple_response
+
+        if len(tuple_response) == 1:
+            return tuple_response[0]
+
+        if len(tuple_response[0]) == 1:
+            return tuple([x[0] for x in tuple_response])
+        return tuple_response
+
+    def cluster_data(self, **kwargs) -> TFlavour[T, ...]:
+        if not self.flavour:
+            return self._return_model()
+
+        return self._return_flavour(self.flavour, **kwargs)
+
+    def _return_flavour[TValue](self, flavour: Type[TValue], **kwargs) -> tuple[TValue]:
+        return self.engine.repository.read_sql(
+            query=self.query,
+            flavour=flavour,
+            select=self._select,
+            **kwargs,
+        )
+
+    def _return_model(self) -> tuple[tuple[T]]:
+        response_sql = self._return_flavour(flavour=dict)
+
+        if response_sql and isinstance(response_sql, Iterable):
+            return self.cluster(response_sql)
+
+        return response_sql

{ormlambda-4.0.0 → ormlambda-4.0.4}/src/ormlambda/statements/interfaces/IStatements.py

@@ -214,9 +214,9 @@ class IStatements[T: Table](Element):
 
     # region deal with flavours
     @overload
-    def select[TFlavour](self, selector: Callable[[T], tuple[tuple]] = ..., *, flavour: Type[TFlavour], **kwargs) -> tuple[TFlavour, ...]: ...
-    @overload
     def select[*TRes](self, selector: Callable[[T], tuple[*TRes]] = ..., *, flavour: Type[tuple], **kwargs) -> tuple[tuple[*TRes]]: ...
+    @overload
+    def select[TFlavour](self, selector: Callable[[T], tuple] = ..., *, flavour: Type[TFlavour], **kwargs) -> tuple[TFlavour, ...]: ...
 
     # endregion
 
@@ -244,7 +244,7 @@ class IStatements[T: Table](Element):
     @overload
     def select_one[*TRes](self, selector: Callable[[T], tuple[*TRes]], *, flavour: Type[list], by: JoinType = ..., alias: Optional[AliasType[ColumnType]] = ..., avoid_duplicates: bool = ...) -> tuple[*TRes]: ...
     @overload
-    def select_one[TFlavour, *TRes](self, selector: Callable[[T], tuple[T, *TRes]], *, flavour: Type[TFlavour], by: JoinType = ..., alias: Optional[AliasType[ColumnType]] = ..., avoid_duplicates: bool = ...) -> TFlavour[*TRes]: ...
+    def select_one[TFlavour, *TRes](self, selector: Callable[[T], tuple[*TRes]], *, flavour: Type[TFlavour], by: JoinType = ..., alias: Optional[AliasType[ColumnType]] = ..., avoid_duplicates: bool = ...) -> TFlavour[*TRes]: ...
 
     @abstractmethod
     def select_one(
@@ -271,7 +271,7 @@ class IStatements[T: Table](Element):
     @overload
     def first[*TRes](self, selector: Callable[[T], tuple[*TRes]], *, flavour: Type[list], by: JoinType = ..., alias: Optional[AliasType[ColumnType]] = ..., avoid_duplicates: bool = ...) -> tuple[*TRes]: ...
     @overload
-    def first[TFlavour, *TRes](self, selector: Callable[[T], tuple[T, *TRes]], *, flavour: Type[TFlavour], by: JoinType = ..., alias: Optional[AliasType[ColumnType]] = ..., avoid_duplicates: bool = ...) -> TFlavour[*TRes]: ...
+    def first[TFlavour, *TRes](self, selector: Callable[[T], tuple[*TRes]], *, flavour: Type[TFlavour], by: JoinType = ..., alias: Optional[AliasType[ColumnType]] = ..., avoid_duplicates: bool = ...) -> TFlavour[*TRes]: ...
 
     @abstractmethod
     def first(

{ormlambda-4.0.0 → ormlambda-4.0.4}/src/ormlambda/statements/statements.py

@@ -277,7 +277,7 @@ class Statements[T: Table](IStatements[T]):
         self._query_builder.by = by
         self._query: str = self._query_builder.query(self._dialect)
 
-        return ClusterResponse(select, self._engine, flavour, self._query).response()
+        return ClusterResponse(select, self._engine, flavour, self._query).cluster_data()
 
     @override
     def select_one[TValue, TFlavour, *Ts](
@@ -301,11 +301,8 @@ class Statements[T: Table](IStatements[T]):
         # select columns from different tables using a join query
         # FIXME [x]: before it was if len(response) == 1 and len(response[0]) == 1: return response[0][0]
         if len(response) == 1:
-            if isinstance(response[0], Iterable) and len(response[0]) == 1:
-                return response[0][0]
-            else:
-                return response[0]
-        return tuple([res[0] for res in response])
+            return response[0]
+        return response
 
     @override
     def first[TValue, TFlavour, *Ts](

ormlambda-4.0.0/src/ormlambda/statements/base_statement.py

@@ -1,90 +0,0 @@
-from __future__ import annotations
-from typing import Any, Type, Iterable, Literal, TYPE_CHECKING
-from collections import defaultdict
-
-
-from ormlambda import Table
-from ormlambda import util
-
-from ormlambda.common.errors import AggregateFunctionError
-from ormlambda.sql.clause_info import IAggregate
-
-
-if TYPE_CHECKING:
-    from ormlambda.engine.base import Engine
-    from ormlambda.sql.clauses import Select
-
-
-ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
-
-
-type ResponseType = Iterable[dict[str, Any]]
-
-
-class ClusterResponse[T, TFlavour]:
-    def __init__(self, select: Select[T], engine: Engine, flavour: TFlavour, query: str) -> None:
-        self._select: Select[T] = select
-        self.engine = engine
-        self.flavour = flavour
-        self.query = query
-
-    def cluster(self, response_sql: ResponseType) -> tuple[dict[Type[Table], tuple[Table, ...]]]:
-        tbl_dicc: dict[Type[Table], list[dict[str, Any]]] = self._create_cluster(response_sql)
-
-        first_table = list(tbl_dicc)[0]
-        tuple_response = []
-        # it not depend of flavour attr
-        n_attrs = len(tbl_dicc[first_table])
-        for i in range(n_attrs):
-            new_instance = []
-            for table in tbl_dicc:
-                attrs = tbl_dicc[table][i]
-                new_instance.append(table(**attrs))
-            tuple_response.append(tuple(new_instance))
-        return tuple(tuple_response)
-
-    def _create_cluster(self, response_sql: ResponseType) -> 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(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(response_sql):
-            for clause in self._select.columns:
-                # if col is None or not hasattr(table, col):
-                if isinstance(clause, IAggregate):
-                    raise AggregateFunctionError(clause)
-
-                table = clause.table
-
-                table_attr_dict[table][i][clause.column_name] = dicc_cols[clause.alias]
-        # Convert back to a normal dict if you like (defaultdict is a dict subclass).
-        return dict(table_attr_dict)
-
-    @util.preload_module("ormlambda.sql.column")
-    def response(self, **kwargs) -> TFlavour[T, ...]:
-        ColumnProxy = util.preloaded.sql_column.ColumnProxy
-
-        if not self.flavour:
-            return self._return_model()
-
-        result = self._return_flavour(self.flavour, self._select, **kwargs)
-        if issubclass(self.flavour, tuple) and len(self._select.used_columns()) == 1 and isinstance(self._select.used_columns()[0], ColumnProxy):
-            return tuple([x[0] for x in result])
-        return result
-
-    def _return_flavour[TValue](self, flavour: Type[TValue], select, **kwargs) -> tuple[TValue]:
-        return self.engine.repository.read_sql(self.query, flavour=flavour, select=select, **kwargs)
-
-    def _return_model(self) -> tuple[tuple[T]]:
-        response_sql = self.engine.repository.read_sql(self.query, flavour=dict, select=self._select)  # store all columns of the SQL query
-        if response_sql and isinstance(response_sql, Iterable):
-            response = self.cluster(response_sql)
-            if response and len(response[0]) == 1:
-                return tuple([x[0] for x in response])
-            return response
-
-        return response_sql