ormlambda 4.0.0__tar.gz → 4.0.5__tar.gz

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

@@ -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 → ormlambda-4.0.5}/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.5}/pyproject.toml

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