ormlambda 4.0.0__py3-none-any.whl → 4.0.4__py3-none-any.whl

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/statements/base_statement.py

@@ -4,7 +4,6 @@ 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
@@ -13,6 +12,7 @@ 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"]
@@ -29,62 +29,57 @@ class ClusterResponse[T, TFlavour]:
         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)]
+        tables: dict[Table, list[ColumnProxy]] = defaultdict(list)
+        for clause in self._select.columns:
+            if isinstance(clause, IAggregate):
+                raise AggregateFunctionError(clause)
 
-        table_attr_dict = defaultdict(make_list_of_dicts)
+            tables[clause.table].append(clause)
 
-        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)
+        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))
 
-                table = clause.table
+        tuple_response = tuple(res)
 
-                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)
+        if not tuple_response:
+            return tuple_response
 
-    @util.preload_module("ormlambda.sql.column")
-    def response(self, **kwargs) -> TFlavour[T, ...]:
-        ColumnProxy = util.preloaded.sql_column.ColumnProxy
+        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()
 
-        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
+        return self._return_flavour(self.flavour, **kwargs)
 
-    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_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.engine.repository.read_sql(self.query, flavour=dict, select=self._select)  # store all columns of the SQL query
+        response_sql = self._return_flavour(flavour=dict)
+
         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 self.cluster(response_sql)
 
         return response_sql

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/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.dist-info → ormlambda-4.0.4.dist-info}/METADATA

@@ -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.dist-info → ormlambda-4.0.4.dist-info}/RECORD

@@ -62,7 +62,7 @@ ormlambda/repository/base_repository.py,sha256=SW7VsbNddIY8-ALIGYcLlj4tFAoPSepeQ
 ormlambda/repository/interfaces/IDatabaseConnection.py,sha256=pxczjx0b53yjjg5hvVDloMgUTFDahVC3HlJLQjo9_1w,283
 ormlambda/repository/interfaces/IRepositoryBase.py,sha256=jTlViARH5SWIcYXstmXhttvNOShJ5mmAbTEmfGLiRuA,3527
 ormlambda/repository/interfaces/__init__.py,sha256=t8Mn0aRZm8uF4MGaqjEANTTADCdOwNF0THZ_qebyzwo,126
-ormlambda/repository/response.py,sha256=z1e0DlToPZqMCxS3Y36P0lTBOWzhMMkla6k8IiCvYQo,4525
+ormlambda/repository/response.py,sha256=ZCV3joh_IMtcAHR_JIhbOudRT5ejPyXBFrHsTJoTz9o,4729
 ormlambda/sql/__init__.py,sha256=C5tpRVPZFnk8h1GSUkAM83u0M-IiOWtxrQSzD5DFZYU,211
 ormlambda/sql/clause_info/__init__.py,sha256=tbDXMGPjIc1e4YpBycjmyh8gRFgqZLva6sH-9awsni4,98
 ormlambda/sql/clause_info/clause_info.py,sha256=OnVyjDcisJK7-exFCgk7xqyXFGMTBMxzIXEg8RF56DI,14107
@@ -117,11 +117,11 @@ ormlambda/sql/type_api.py,sha256=nR5NruI6kUHefcyjqmV_uxy3dM3McCWv3THg2NxXJH8,121
 ormlambda/sql/types.py,sha256=A1HI8HrANruuAPIfl7dbbTYx3l-SvuUbPrhlzK5SZ6w,1019
 ormlambda/sql/visitors.py,sha256=AHXxCEOME8-b_-YhFEzBv-Jd15vSoX5F-jEGrPPNRLE,2052
 ormlambda/statements/__init__.py,sha256=9IzRSVl-ZXD4D4RrrPIifOhyO0iXSpRS5ZwvVJeAW_0,49
-ormlambda/statements/base_statement.py,sha256=tzDRfDJrzHCvgHWxHRhePrLi4GkOq651JBow8y-5NME,3575
-ormlambda/statements/interfaces/IStatements.py,sha256=ZAMvQA-TtGf9ghhcHVaLcKHeJtodPyTzLPsFw8dngO4,9888
+ormlambda/statements/base_statement.py,sha256=M8h2IqMl3vQWGzjHftx0zMzp12FfOFktu1GLsj1KLpI,2741
+ormlambda/statements/interfaces/IStatements.py,sha256=wTYEj8mBR21sU60ZMlHzaQehTy-knrqp3GT6n6l6HMU,9875
 ormlambda/statements/interfaces/__init__.py,sha256=1EAWwBueWJ1lBG7pOAEae_Bqw6ww8s7Dnvq6LTUgUJM,51
 ormlambda/statements/query_builder.py,sha256=MUTBvdlHuX6ZScyEjk4-bc6KtmpCht31NcBM1ATTyzI,10730
-ormlambda/statements/statements.py,sha256=YXY-1nKONugKWWW3dPVjPJzFeTUcWFt0-hJpke7Oiw4,12250
+ormlambda/statements/statements.py,sha256=U638djJtOu8qIMNlNOhJXktkFaV-cIhTsaBqy_S19h8,12091
 ormlambda/statements/types.py,sha256=Qh91CB3tzrqsxsPixib7w6KLRr6zY26pHXAna6MaDm8,885
 ormlambda/types/__init__.py,sha256=xVFaIMcfJvbbXs8BAvmBh8FwSiLn2R6yjZs9o-h08XM,323
 ormlambda/types/metadata.py,sha256=93eJItdVDOItf7YRJUVmN_m79WLa3Ge6I414ewYnKeM,624
@@ -132,8 +132,8 @@ ormlambda/util/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkj
 ormlambda/util/module_tree/dynamic_module.py,sha256=SQ1FZW2Es5CdACD0VS8v_UZQTuFYbUWs6diAtMbKMoA,8699
 ormlambda/util/preloaded.py,sha256=1D7t25qPjhW44nRez4Sd40gLjrl6BctLhPfPsK6Dx5g,3064
 ormlambda/util/typing.py,sha256=py6FbOLvnuByR8IHgKIIReFM0efX6Bzz-Ick9fx-nuw,423
-ormlambda-4.0.0.dist-info/AUTHORS,sha256=uWpOHaCPTOLbVkk5x9McoLwbgzSeCg7yILeDRyMGWGM,606
-ormlambda-4.0.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
-ormlambda-4.0.0.dist-info/METADATA,sha256=Ts-rXOPpIPNWaXEpxVAIZobEw4CnmRUuV95AIJwm50A,13140
-ormlambda-4.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ormlambda-4.0.0.dist-info/RECORD,,
+ormlambda-4.0.4.dist-info/AUTHORS,sha256=uWpOHaCPTOLbVkk5x9McoLwbgzSeCg7yILeDRyMGWGM,606
+ormlambda-4.0.4.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-4.0.4.dist-info/METADATA,sha256=q-8Wzvr-9NpPcQKKsrh4-QBaxSIHDtpygG8bgmcZhxo,12466
+ormlambda-4.0.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-4.0.4.dist-info/RECORD,,