ormlambda 3.7.1__py3-none-any.whl → 3.11.0__py3-none-any.whl

ormlambda/engine/utils.py

@@ -0,0 +1,17 @@
+from typing import Optional, Any, TypeGuard, Iterable
+import collections.abc as collections_abc
+
+
+def is_non_string_iterable(obj: Any) -> TypeGuard[Iterable[Any]]:
+    return isinstance(obj, collections_abc.Iterable) and not isinstance(obj, (str, bytes))
+
+
+def to_list(x: Any, default: Optional[list[Any]] = None) -> list[Any]:
+    if x is None:
+        return default  # type: ignore
+    if not is_non_string_iterable(x):
+        return [x]
+    elif isinstance(x, list):
+        return x
+    else:
+        return list(x)

ormlambda/repository/base_repository.py

@@ -1,12 +1,11 @@
 import contextlib
-from typing import Generator, Type
+from typing import Generator, Type, Unpack
 from ormlambda.repository import IRepositoryBase
 import abc
 
 
 class BaseRepository[TPool](IRepositoryBase):
-    def __init__(self, pool: Type[TPool], **kwargs: str) -> None:
-        self._data_config: dict[str, str] = kwargs
+    def __init__[TArgs](self, pool: Type[TPool], **kwargs: Unpack[TArgs]) -> None:
         self._pool: TPool = pool(**kwargs)
 
     @contextlib.contextmanager

ormlambda/repository/interfaces/IRepositoryBase.py

@@ -5,6 +5,7 @@ from typing import Optional, Type, Iterable, TYPE_CHECKING
 if TYPE_CHECKING:
     from ormlambda.statements.types import TypeExists
 
+
 class IRepositoryBase(ABC):
     def __repr__(self) -> str:
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"

ormlambda/sql/column.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Iterable, Type, Optional, TYPE_CHECKING
+from typing import Iterable, Type, Optional, TYPE_CHECKING, overload
 import abc
 from ormlambda.sql.types import TableType, ComparerType, ColumnType
 from ormlambda import ConditionType
@@ -25,18 +25,41 @@ class Column[TProp]:
         "_check",
     )
 
+    @overload
+    def __init__(self, *, column_name: str): ...
+
+    @overload
     def __init__[T: Table](
         self,
         dtype: Type[TProp],
+        *,
         is_primary_key: bool = False,
         is_auto_generated: bool = False,
         is_auto_increment: bool = False,
         is_unique: bool = False,
         check_types: bool = True,
+    ) -> None: ...
+
+    def __init__[T: Table](
+        self,
+        dtype: Optional[Type[TProp]] = None,
+        *,
+        is_primary_key: bool = False,
+        is_auto_generated: bool = False,
+        is_auto_increment: bool = False,
+        is_unique: bool = False,
+        check_types: bool = True,
+        column_name: Optional[str] = None,
     ) -> None:
+        if dtype is None and column_name is None:
+            raise AttributeError("You must specify either the 'dtype' or 'column_name' attribute.")
+
+        if column_name is not None:
+            dtype = type(column_name)
+
         self.dtype: Type[TProp] = dtype
         self.table: Optional[TableType[T]] = None
-        self.column_name: Optional[str] = None
+        self.column_name: Optional[str] = column_name
         self.__private_name: Optional[str] = None
         self._check = check_types
 
@@ -70,7 +93,9 @@ class Column[TProp]:
     def __hash__(self) -> int:
         return hash(
             (
+                self.dtype,
                 self.column_name,
+                self.table,
                 self.is_primary_key,
                 self.is_auto_generated,
                 self.is_auto_increment,

ormlambda/sql/foreign_key.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Callable, TYPE_CHECKING, Optional, Any, Type, overload
+from typing import Callable, TYPE_CHECKING, Optional, Any, Type, cast, overload
 
 from ormlambda.common.interfaces.IQueryCommand import IQuery
 
@@ -10,15 +10,45 @@ if TYPE_CHECKING:
     from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
 
 
+class ForeignKeyContext(set["ForeignKey"]):
+    def clear(self):
+        to_remove = {x for x in self if not cast(ForeignKey, x)._keep_alive}
+        for el in to_remove:
+            self.remove(el)
+
+    def remove(self, element):
+        return super().remove(element)
+
+    def pop(self, item):
+        for el in self:
+            if el != item:
+                continue
+
+            if not cast(ForeignKey, el)._keep_alive:
+                super().remove(el)
+            return el
+
+    def add(self, element):
+        return super().add(element)
+
+
 class ForeignKey[TLeft: Table, TRight: Table](IQuery):
-    stored_calls: set[ForeignKey] = set()
+    stored_calls: ForeignKeyContext = ForeignKeyContext()
 
     @overload
     def __new__[LProp, RProp](self, comparer: Comparer[LProp, RProp], clause_name: str) -> None: ...
     @overload
-    def __new__[LProp, TRight, RProp](cls, tright: Type[TRight], relationship: Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]) -> TRight: ...
+    def __new__[LProp, TRight, RProp](cls, tright: Type[TRight], relationship: Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]], keep_alive: bool = ...) -> TRight: ...
 
-    def __new__[LProp, TRight, RProp](cls, tright: Optional[TRight] = None, relationship: Optional[Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]] = None, *, comparer: Optional[Comparer] = None, clause_name: Optional[str] = None) -> TRight:
+    def __new__[LProp, TRight, RProp](
+        cls,
+        tright: Optional[TRight] = None,
+        relationship: Optional[Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]] = None,
+        *,
+        comparer: Optional[Comparer] = None,
+        clause_name: Optional[str] = None,
+        keep_alive: bool = False,
+    ) -> TRight:
         return super().__new__(cls)
 
     def __init__[LProp, RProp](
@@ -28,7 +58,9 @@ class ForeignKey[TLeft: Table, TRight: Table](IQuery):
         *,
         comparer: Optional[Comparer] = None,
         clause_name: Optional[str] = None,
+        keep_alive: bool = False,
     ) -> None:
+        self._keep_alive = keep_alive
         if comparer is not None and clause_name is not None:
             self.__init__with_comparer(comparer, clause_name)
         else:

ormlambda/sql/table/table_constructor.py

@@ -170,8 +170,8 @@ class Table(metaclass=TableMeta):
         return tuple([x for x in cls.__annotations__.values() if isinstance(x, Column)])
 
     @classmethod
-    def get_column[TProp](cls,name:str) -> Column[TProp]:
-        for key,value in cls.__annotations__.items():
+    def get_column[TProp](cls, name: str) -> Column[TProp]:
+        for key, value in cls.__annotations__.items():
             if name == key:
                 return value
 

ormlambda/statements/interfaces/IStatements.py

@@ -29,6 +29,8 @@ from ..types import (
     WhereTypes,
 )
 
+type SelectCols[T, TProp] = Callable[[T], ColumnType[TProp]] | ColumnType[TProp]
+
 
 class IStatements[T: Table](ABC):
     @abstractmethod
@@ -132,7 +134,7 @@ class IStatements[T: Table](ABC):
     @abstractmethod
     def count(
         self,
-        selection: Callable[[T], tuple] = lambda x: "*",
+        selection: Callable[[T], tuple] = ...,
         alias_clause="count",
         execute: bool = False,
     ) -> Optional[IStatements[T]]: ...
@@ -160,6 +162,16 @@ class IStatements[T: Table](ABC):
     @abstractmethod
     def where[LProp, RTable, RProp](self, conditions: WhereTypes[T, LProp, RTable, RProp] = None) -> IStatements[T]: ...
 
+    # endregion
+
+    # region having
+
+    @overload
+    def having[LProp, RTable, RProp](self, conditions: Callable[[T], WhereTypes[T, LProp, RTable, RProp]]) -> IStatements[T]: ...
+
+    @abstractmethod
+    def having[LProp, RTable, RProp](self, conditions: WhereTypes[T, LProp, RTable, RProp] = None) -> IStatements[T]: ...
+
     # endregion
     # region order
     @overload
@@ -172,14 +184,14 @@ class IStatements[T: Table](ABC):
     # endregion
     # region concat
     @overload
-    def concat[P](self, selector: Callable[[T], tuple[P]]) -> IAggregate: ...
+    def concat(self, selector: Callable[[T], str], alias: str = "CONCAT") -> IAggregate: ...
 
     # endregion
     # region max
     @overload
     def max[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
         execute: bool = ...,
     ) -> TProp: ...
@@ -188,7 +200,7 @@ class IStatements[T: Table](ABC):
     @overload
     def min[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
         execute: bool = ...,
     ) -> TProp: ...
@@ -197,7 +209,7 @@ class IStatements[T: Table](ABC):
     @overload
     def sum[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
         execute: bool = ...,
     ) -> TProp: ...
@@ -208,6 +220,8 @@ class IStatements[T: Table](ABC):
     # endregion
     # region select
     type SelectorType[TOri, *T] = Callable[[TOri], tuple[*T]] | tuple[*T]
+    type SelectorFlavourType[T, TResponse] = Optional[Callable[[T], TResponse]] | TResponse
+    type SelectorOneType[T, TResponse] = Callable[[T, TResponse]] | TResponse
 
     @overload
     def select[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](self, selector: SelectorType[T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], *, by: Optional[Enum] = ...) -> Select10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: ...
@@ -234,8 +248,6 @@ class IStatements[T: Table](ABC):
     @overload
     def select(self) -> Tuple[T]: ...
 
-    type SelectorFlavourType[T, TResponse] = Optional[Callable[[T], TResponse]]
-
     # @overload
     # def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> TFlavour: ...
     @overload
@@ -243,7 +255,7 @@ class IStatements[T: Table](ABC):
     @overload
     def select[*TRes](self, selector: SelectorFlavourType[T, tuple[*TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
     @overload
-    def select[TFlavour](self, selector: SelectorFlavourType[T, tuple] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> tuple[TFlavour]: ...
+    def select[TFlavour](self, selector: SelectorFlavourType[T, tuple] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> tuple[TFlavour, ...]: ...
 
     @abstractmethod
     def select[TValue, TFlavour, P](self, selector: SelectorFlavourType[T, tuple[TValue, P]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour] = ..., by: JoinType = ..., **kwargs): ...
@@ -255,21 +267,21 @@ class IStatements[T: Table](ABC):
     @overload
     def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @overload
-    def select_one[T1](self, selector: Callable[[T], T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
+    def select_one[T1](self, selector: SelectorOneType[T, T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
     @overload
-    def select_one[*TRes](self, selector: Callable[[T], tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
+    def select_one[*TRes](self, selector: SelectorOneType[T, tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
+    def select_one[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
     @overload
-    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @overload
-    def select_one[*TRest](self, selector: Callable[[T], tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
+    def select_one[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
     @overload
-    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @abstractmethod
     def select_one[TValue, TFlavour, *TRest](
         self,
-        selector: Optional[Callable[[T], tuple[TValue, *TRest]]] = lambda: None,
+        selector: Optional[SelectorOneType[T, tuple[TValue, *TRest]]] = lambda: None,
         *,
         flavour: Type[TFlavour] = ...,
         by: Optional[Enum] = ...,
@@ -281,23 +293,23 @@ class IStatements[T: Table](ABC):
     @overload
     def first(self) -> T: ...
     @overload
-    def first[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[T1](self, selector: SelectorOneType[T, T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
     @overload
-    def first[T1](self, selector: Callable[[T], T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
+    def first[*TRes](self, selector: SelectorOneType[T, tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def first[*TRes](self, selector: Callable[[T], tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
+    def first[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @overload
-    def first[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
+    def first[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
     @overload
-    def first[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @overload
-    def first[*TRest](self, selector: Callable[[T], tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
+    def first[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
     @overload
-    def first[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @abstractmethod
     def first[TValue, TFlavour, *TRest](
         self,
-        selector: Optional[Callable[[T], tuple[TValue, *TRest]]] = lambda: None,
+        selector: Optional[SelectorOneType[T, tuple[TValue, *TRest]]] = lambda: None,
         *,
         flavour: Type[TFlavour] = ...,
         by: Optional[Enum] = ...,
@@ -305,9 +317,9 @@ class IStatements[T: Table](ABC):
 
     # endregion
 
-    # region group_by
+    # region groupby
     @abstractmethod
-    def group_by[TRepo](self, column: Callable[[T], TRepo]) -> IStatements[T]: ...
+    def groupby[TRepo](self, column: Callable[[T], TRepo]) -> IStatements[T]: ...
 
     # endregion
 

ormlambda/statements/types.py

@@ -18,7 +18,10 @@ if TYPE_CHECKING:
 type OrderTypes = Literal["ASC", "DESC"] | OrderType | Iterable[OrderType]
 
 
-class OrderType(enum.Enum):
+class OrderType(str, enum.Enum):
+    def __str__(self):
+        return super().__str__()
+
     ASC = "ASC"
     DESC = "DESC"
 

{ormlambda-3.7.1.dist-info → ormlambda-3.11.0.dist-info}/METADATA

@@ -1,15 +1,13 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.7.1
+Version: 3.11.0
 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
-Requires-Dist: fluent-validation (==4.3.1)
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
-Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown
 
@@ -17,7 +15,7 @@ Description-Content-Type: text/markdown
 ![downloads](https://img.shields.io/pypi/dm/ormlambda?label=downloads)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)
 
-# ormMySQL
+# ormlambda Documentation
 This ORM is designed to connect with a MySQL server, facilitating the management of various database queries. Built with flexibility and efficiency in mind, this ORM empowers developers to interact with the database using lambda functions, allowing for concise and expressive query construction. 
 
 # Creating your first lambda query
@@ -38,19 +36,34 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 ## Select all columns
 ```python
 from ormlambda import ORM
-from ormlambda.databases.my_sql import MySQLRepository
+from ormlambda import create_engine
 
 from models.address import Address
-from config import config_dict
+from test.config import config_dict
 
-db = MySQLRepository(**config_dict)
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
-AddressModel = ORM(Address,db)
+AddressModel = ORM(Address, db)
 
 result = AddressModel.select()
 ```
 The `result` var will be of type `tuple[Address, ...]` 
 
+## Improving Typing
+For those cases where you need to pass the database configuration from a `dict`, you can use `MySQLArgs` TypedDict object to improve type annotations.
+
+```python
+from ormlambda.databases.my_sql.types import MySQLArgs
+
+config_dict: MySQLArgs = {
+    "user": DB_USERNAME,
+    "password": DB_PASSWORD,
+    "host": DB_HOST,
+    "database": DB_DATABASE,
+}
+db = MySQLRepository(**config_dict)
+```
+
 ## Select multiples tables
 Once the `AddressModel` class is created, we will not only be able to access all the information in that table, but also all the information in all the tables that have foreign keys related to it."
 
@@ -296,6 +309,92 @@ res = AddressModel.sum(Address.address_id, execute=True)
 res = AddressModel.count(Address.address_id, execute=True)
 ```
 
+## 1. Concat
+
+The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
+
+#### Usage
+
+```python
+response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
+            (
+                Address.address,
+                Address.City.city,
+                self.tmodel.concat(
+                    (
+                        "Address: ",
+                        Address.address,
+                        " - city: ",
+                        Address.City.city,
+                        " - country: ",
+                        Address.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",
+}
+```
+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.
+
+Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
+
+## Using BaseModel for Custom Responses (Pydantic)
+
+You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
+
+### Example: Creating a Custom Response Model
+
+You can create a custom response model by subclassing `BaseModel`. In this model, you define the fields that you expect in your response, along with their types.
+
+```python
+class AddressCombine(BaseModel):
+    address: str
+    city: str
+    country: str
+
+    model_config: ConfigDict = {"extra": "forbid"}
+
+ddbb = MySQLRepository(**config_dict)
+model = ORM(Address, ddbb)
+select = (
+    model.order(lambda x: x.City.Country.country, "DESC")
+    .limit(10)
+    .where(Address.City.Country.country == "Spain")
+    .first(
+        lambda x: (
+            x.address,
+            x.City.city,
+            x.City.Country.country,
+        ),
+        flavour=AddressCombine,
+    )
+)
+```
+
+Once you execute the query, the result will be an instance of your custom model. You can access the fields directly, ensuring that the data adheres to the structure you defined.
+
+```python
+
+
+print(select.address)
+print(select.city)
+print(select.country)
+```
+
+
+<!-- ### 2. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+#### Usage -->
+
+
 ## 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.
 ```python