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

ormlambda/dialects/__init__.py

@@ -3,13 +3,14 @@ from typing import Callable, Optional, Type, TYPE_CHECKING, ClassVar
 import abc
 from ormlambda import util
 import importlib
+from ormlambda import BaseRepository
 
 
 if TYPE_CHECKING:
+    from ormlambda import URL
     from ormlambda.caster.caster import Caster
     from ormlambda.repository.interfaces.IRepositoryBase import DBAPIConnection
     from ormlambda.sql.types import DDLCompiler, SQLCompiler, TypeCompiler
-    from ormlambda import BaseRepository
 
 
 class Dialect(abc.ABC):
@@ -57,15 +58,21 @@ class Dialect(abc.ABC):
     type_compiler_instance: ClassVar[TypeCompiler]
     """The instance of the type compiler class used by the dialect."""
 
-    repository_cls: ClassVar[Type[BaseRepository]]
-    """The repository class used by the dialect."""
-
     caster: ClassVar[Type[Caster]]
 
     @classmethod
     def get_dialect_cls(cls) -> Type[Dialect]:
         return cls
 
+    @classmethod
+    @abc.abstractmethod
+    def get_pool_class(cls, url: URL) -> Type[BaseRepository]: ...
+
+    @abc.abstractmethod
+    def get_dialect_pool_class(self, url: str) -> None:
+        """Validates an identifier name, raising an exception if invalid"""
+        ...
+
     @classmethod
     @abc.abstractmethod
     def import_dbapi(cls) -> DBAPIConnection:

ormlambda/dialects/default/base.py

@@ -2,7 +2,6 @@ from ormlambda.dialects import Dialect
 from ormlambda.sql import compiler
 from typing import Optional, Any
 from types import ModuleType
-from ormlambda import BaseRepository
 
 
 class DefaultDialect(Dialect):
@@ -11,7 +10,6 @@ class DefaultDialect(Dialect):
     statement_compiler = compiler.SQLCompiler
     ddl_compiler = compiler.DDLCompiler
     type_compiler_cls = compiler.GenericTypeCompiler
-    repository_cls = BaseRepository
     default_paramstyle = "named"
 
     def __init__(
@@ -37,3 +35,6 @@ class DefaultDialect(Dialect):
         self.type_compiler_instance = self.type_compiler = tt_callable(self)
 
         super().__init__(**kwargs)
+
+    def get_dialect_pool_class(self, url):
+        return self.get_pool_class(url)

ormlambda/dialects/mysql/base.py

@@ -627,7 +627,6 @@ class MySQLDialect(default.DefaultDialect):
     statement_compiler = MySQLCompiler
     ddl_compiler = MySQLDDLCompiler
     type_compiler_cls = MySQLTypeCompiler
-    repository_cls = MySQLRepository
     caster = MySQLCaster
 
     def __init__(self, **kwargs):
@@ -638,3 +637,7 @@ class MySQLDialect(default.DefaultDialect):
         from mysql import connector
 
         return connector
+
+    @classmethod
+    def get_pool_class(cls, url):
+        return MySQLRepository

ormlambda/engine/base.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, BinaryIO, Literal, Optional, TextIO
 from ormlambda.engine import url
 from ormlambda.sql.ddl import CreateSchema, DropSchema, CreateBackup
+from ormlambda import BaseRepository
 
 if TYPE_CHECKING:
     from ormlambda.dialects import Dialect
@@ -11,10 +12,10 @@ type TypeExists = Literal["fail", "replace", "append"]
 
 
 class Engine:
-    def __init__(self, dialect: Dialect, url: url.URL):
+    def __init__(self, repository: BaseRepository, dialect: Dialect, url: url.URL):
+        self.repository = repository
         self.dialect = dialect
         self.url = url
-        self.repository = self.dialect.repository_cls(url, dialect=dialect)
 
     def __repr__(self):
         return f"{Engine.__name__}: {self.url}"
@@ -78,3 +79,15 @@ class Engine:
             )
             .string
         )
+
+    @property
+    def engine(self) -> Engine:
+        return self
+
+    @property
+    def driver(self) -> str:
+        return self.dialect.driver
+
+    @property
+    def name(self) -> str:
+        return self.dialect.name

ormlambda/engine/create.py

@@ -18,4 +18,9 @@ def create_engine(url: URL | str, **kwargs: Any) -> base.Engine:
     dialect_args["dbapi"] = dialect_cls.import_dbapi()
 
     dialect = dialect_cls(**dialect_args)
-    return base.Engine(dialect, u)
+
+    repositoryclass = dialect.get_dialect_pool_class(u)
+
+    repository_args = {"dialect": dialect, **kwargs}
+    repository = repositoryclass(u, **repository_args)
+    return base.Engine(repository, dialect, u)

ormlambda/repository/base_repository.py

@@ -42,3 +42,7 @@ class BaseRepository[TPool](IRepositoryBase):
 
     @abc.abstractmethod
     def get_connection[TCnx](self) -> Generator[TCnx, None, None]: ...
+
+    @property
+    def pool(self) -> TPool:
+        return self._pool

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.5.dist-info}/METADATA

@@ -1,12 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: ormlambda
-Version: 4.0.0
+Version: 4.0.5
 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
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
 Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown
@@ -90,16 +91,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 +111,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 +119,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 +230,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 +238,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 +252,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 +263,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 +304,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 +371,7 @@ res = (
     .select(lambda x:
         (
             x.district,
-            Count(x.address),
+            Count(x.address,alias="count"),
         ),
         flavour=Response,
     )
@@ -442,11 +423,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.5.dist-info}/RECORD

@@ -17,11 +17,11 @@ ormlambda/common/interfaces/IJoinSelector.py,sha256=-w-MJmwq65tpDLtigWSLgvAqeOl7
 ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
 ormlambda/common/interfaces/IQueryCommand.py,sha256=PKkAI1SE6U7kcbqFgQsdTQ3asIx-gIp5RDXYlBfANJk,461
 ormlambda/common/interfaces/__init__.py,sha256=-qIJf5fBX0y0vq_O7YjImWFimbj5pqONzK8udH2CMX4,169
-ormlambda/dialects/__init__.py,sha256=-WM-PqZXgZ_-3KWWLSNrPV12FhvVbo_v8Ul3XCUjs0o,3536
+ormlambda/dialects/__init__.py,sha256=iykTU_kv3w_FaLWZuxxcVUfvUznrM1YNWyABYlZqEXg,3736
 ormlambda/dialects/default/__init__.py,sha256=N1B0LKEDu7r2-mTF9mBA4ReyhYeDuJDnbQCiH4hJvFQ,33
-ormlambda/dialects/default/base.py,sha256=Xle5kD_wi94NiPnkShi5LJbe5M1k8hq_XhU_PZ-iFbs,1078
+ormlambda/dialects/default/base.py,sha256=-cxwjUipQITbIPqWV7N0H8UlIXgxs-qeQhJlDbAHvL8,1089
 ormlambda/dialects/mysql/__init__.py,sha256=DwoefrtyJUivg7z4QS4K2k0DrUu04ItC5LJcDQEYZWg,1398
-ormlambda/dialects/mysql/base.py,sha256=BDEoWUpGB7ss6ZpzZzu8gMUCM33N_pwYgNbh5tmQ30A,21493
+ormlambda/dialects/mysql/base.py,sha256=jtt1US1wILOebN7hfYmN9JzreG-_Awv9ahmzNPK0z_k,21539
 ormlambda/dialects/mysql/caster/__init__.py,sha256=Df2sdZaAJ1Mi5Ego0sILMk5pF1NbK-nlV0hbpzd0PWE,47
 ormlambda/dialects/mysql/caster/caster.py,sha256=G2CDqkrmsxFrHe_nDOmqqrTA_3O2o6gIIfukqPeHmJs,1021
 ormlambda/dialects/mysql/caster/types/__init__.py,sha256=BmtHuVvKGPIOCjVuqQZgtGBMnx15YnGBaBi4r3Hd-3U,587
@@ -49,8 +49,8 @@ ormlambda/dialects/sqlite/__init__.py,sha256=2EMmxD7ORtGoD18GJ_9aC_tPutAq9ormMZJ
 ormlambda/dialects/sqlite/base.py,sha256=24LSB461yQDEnXa-TsQt_srJmBCAR6M6419pa40CL_4,1503
 ormlambda/dialects/sqlite/pysqlite.py,sha256=dZY0NV2IvSTk3DNEDyncstmIABKj3M2xfmhf2dc2zQs,680
 ormlambda/engine/__init__.py,sha256=JpCLfuW1zcJi4ki97ajXh0aQxMSvWBKzDlBZx9ZVF9o,132
-ormlambda/engine/base.py,sha256=f60O6CLzB7rFBtw7XNxaEw0BccruROzRR-vXBUMcYgQ,2621
-ormlambda/engine/create.py,sha256=caDYXX4BP5uODSrdJXRZvWWjbliDgH1TiSvhtHP3RNY,533
+ormlambda/engine/base.py,sha256=BUzSRGbe-_dlh71gdHNlD1z8OyiM2K3QAV-Ul5JV_XQ,2868
+ormlambda/engine/create.py,sha256=z9MDi_ldwuCa4b_Oe-orgt6Fk1EagsjKmLHZvJ0jHN8,711
 ormlambda/engine/url.py,sha256=ZzdgZU_Cnjhonbbr5OfBvq_ThUPnDj9v-3-7O54ENm0,26137
 ormlambda/engine/utils.py,sha256=fFoiKsiFuLcjcBVYNebVoYnMrEj3aZdoxEVSNfCY-GM,522
 ormlambda/env.py,sha256=rCZKT2rpvRF3hPtkLmtiaVAIxQ0xj8tF7ZKJpFp7BkA,736
@@ -58,11 +58,11 @@ ormlambda/errors.py,sha256=ltLR52g3fnUTjrDC_x_R9-b5LlLjC6bVACnOoc9-OZg,839
 ormlambda/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ormlambda/model/base_model.py,sha256=lhtJWiGXiRWLOxsuPg0PPr53shhreMy69Ps2-7dYU7U,739
 ormlambda/repository/__init__.py,sha256=4KAhKn6vWV7bslewvGMNqbbbUnz1DLnH4yy-M5QNAQA,112
-ormlambda/repository/base_repository.py,sha256=SW7VsbNddIY8-ALIGYcLlj4tFAoPSepeQpFvDNMOWpg,1252
+ormlambda/repository/base_repository.py,sha256=QGFPDg_Y12YEOEJYjkvsHErJS5-IIPxejTVwnnf_qzI,1322
 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.5.dist-info/AUTHORS,sha256=uWpOHaCPTOLbVkk5x9McoLwbgzSeCg7yILeDRyMGWGM,606
+ormlambda-4.0.5.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-4.0.5.dist-info/METADATA,sha256=9nElZo731sVCQr5dvymaDAIfypgU71R6PnJmJgcCOsg,12517
+ormlambda-4.0.5.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+ormlambda-4.0.5.dist-info/RECORD,,

{ormlambda-4.0.0.dist-info → ormlambda-4.0.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any