ormlambda 3.35.3__tar.gz → 4.0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.35.3
+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,
@@ -296,19 +281,19 @@ with this approach, we will obtain a dictionary where the key will be the concat
 
 ## max
 ```python
-res = AddressModel.max(Address.address_id, execute=True)
+res = AddressModel.max(lambda x: x.address_id)
 ```
 ## min
 ```python
-res = AddressModel.min(Address.address_id, execute=True)
+res = AddressModel.min(lambda x: x.address_id)
 ```
 ## sum
 ```python
-res = AddressModel.sum(Address.address_id, execute=True)
+res = AddressModel.sum(lambda x: x.address_id)
 ```
 ## count
 ```python
-res = AddressModel.count(Address.address_id, execute=True)
+res = AddressModel.count(lambda x: x.address_id)
 ```
 
 ## 1. Concat
@@ -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,
-                self.tmodel.concat(
-                    (
-                        "Address: ",
-                        Address.address,
-                        " - city: ",
-                        Address.City.city,
-                        " - country: ",
-                        Address.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.
@@ -364,15 +344,13 @@ class Response(BaseModel):
 engine= create_engine(DATABASE_URL)
 model = ORM(Address,engine)
 
-count_name = Column(column_name="count")
-
 res = (
     self.model
-    .groupby(Address.district)
-    .select(
+    .groupby(lambda x: x.district)
+    .select(lambda x:
         (
-            Address.district,
-            self.model.count(Address.address),
+            x.district,
+            Count(x.address),
         ),
         flavour=Response,
     )
@@ -387,12 +365,12 @@ The `having` method is used to filter results based on aggregate functions. It i
 ```python
 res = (
     model
-    .groupby(Address.district)
-    .having(count_name > 4)
-    .select(
+    .groupby(lambda x: x.district)
+    .having(lambda x: x.count > 4)
+    .select(lambda x:
         (
-            Address.district,
-            model.count(Address.address),
+            x.district,
+            Count(x.address,alias="count"),
         ),
         flavour=Response,
     )
@@ -422,9 +400,9 @@ select = (
     ORM(Address, db)
     .order(lambda x: x.City.Country.country, "DESC")
     .limit(10)
-    .where(Address.City.Country.country == "Spain")
-    .first(
-        lambda x: (
+    .where(lambda x: x.City.Country.country == "Spain")
+    .first(lambda x: 
+        (
             x.address,
             x.City.city,
             x.City.Country.country,
@@ -444,14 +422,13 @@ 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: (
-                AddressModel.min(x.address_id),
-                AddressModel.max(x.address_id),
-                AddressModel.count(x.address_id),
+result = AddressModel.select_one(lambda x: (
+                Min(x.address_id),
+                Max(x.address_id),
+                Count(x.address_id),
             ),flavour=dict
         )
 ```
@@ -468,11 +445,11 @@ Getting something like
 You also can use custom alias for each method
 
 ```python
-AddressModel.select_one(
-    lambda x: (
-        AddressModel.min(x.address_id),
-        AddressModel.max(x.address_id, alias="custom-max"),
-        AddressModel.count(x.address_id),
+AddressModel.select_one(lambda x: 
+    (
+        Min(x.address_id),
+        Max(x.address_id, alias="custom-max"),
+        Count(x.address_id),
     ),
     flavour=dict,
 )

{ormlambda-3.35.3 → 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,
@@ -283,19 +268,19 @@ with this approach, we will obtain a dictionary where the key will be the concat
 
 ## max
 ```python
-res = AddressModel.max(Address.address_id, execute=True)
+res = AddressModel.max(lambda x: x.address_id)
 ```
 ## min
 ```python
-res = AddressModel.min(Address.address_id, execute=True)
+res = AddressModel.min(lambda x: x.address_id)
 ```
 ## sum
 ```python
-res = AddressModel.sum(Address.address_id, execute=True)
+res = AddressModel.sum(lambda x: x.address_id)
 ```
 ## count
 ```python
-res = AddressModel.count(Address.address_id, execute=True)
+res = AddressModel.count(lambda x: x.address_id)
 ```
 
 ## 1. Concat
@@ -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,
-                self.tmodel.concat(
-                    (
-                        "Address: ",
-                        Address.address,
-                        " - city: ",
-                        Address.City.city,
-                        " - country: ",
-                        Address.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.
@@ -351,15 +331,13 @@ class Response(BaseModel):
 engine= create_engine(DATABASE_URL)
 model = ORM(Address,engine)
 
-count_name = Column(column_name="count")
-
 res = (
     self.model
-    .groupby(Address.district)
-    .select(
+    .groupby(lambda x: x.district)
+    .select(lambda x:
         (
-            Address.district,
-            self.model.count(Address.address),
+            x.district,
+            Count(x.address),
         ),
         flavour=Response,
     )
@@ -374,12 +352,12 @@ The `having` method is used to filter results based on aggregate functions. It i
 ```python
 res = (
     model
-    .groupby(Address.district)
-    .having(count_name > 4)
-    .select(
+    .groupby(lambda x: x.district)
+    .having(lambda x: x.count > 4)
+    .select(lambda x:
         (
-            Address.district,
-            model.count(Address.address),
+            x.district,
+            Count(x.address,alias="count"),
         ),
         flavour=Response,
     )
@@ -409,9 +387,9 @@ select = (
     ORM(Address, db)
     .order(lambda x: x.City.Country.country, "DESC")
     .limit(10)
-    .where(Address.City.Country.country == "Spain")
-    .first(
-        lambda x: (
+    .where(lambda x: x.City.Country.country == "Spain")
+    .first(lambda x: 
+        (
             x.address,
             x.City.city,
             x.City.Country.country,
@@ -431,14 +409,13 @@ 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: (
-                AddressModel.min(x.address_id),
-                AddressModel.max(x.address_id),
-                AddressModel.count(x.address_id),
+result = AddressModel.select_one(lambda x: (
+                Min(x.address_id),
+                Max(x.address_id),
+                Count(x.address_id),
             ),flavour=dict
         )
 ```
@@ -455,11 +432,11 @@ Getting something like
 You also can use custom alias for each method
 
 ```python
-AddressModel.select_one(
-    lambda x: (
-        AddressModel.min(x.address_id),
-        AddressModel.max(x.address_id, alias="custom-max"),
-        AddressModel.count(x.address_id),
+AddressModel.select_one(lambda x: 
+    (
+        Min(x.address_id),
+        Max(x.address_id, alias="custom-max"),
+        Count(x.address_id),
     ),
     flavour=dict,
 )

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

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.35.3"
+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.4/src/ormlambda/__init__.py

@@ -0,0 +1,87 @@
+# COMMENT: Necesary to load all variables inside ormalambda.env
+import ormlambda.env  # noqa: F401
+
+# region enums
+from .common.enums import JoinType as JoinType
+from .common.enums import ConditionType as ConditionType
+from .common.enums import OrderType as OrderType
+
+
+# endregion
+
+# region sql
+from .sql import Column as Column
+from .sql import ColumnProxy as ColumnProxy
+from .sql import Table as Table
+from .sql import ForeignKey as ForeignKey
+from .sql import TableProxy as TableProxy
+
+
+# endregion
+
+from .repository import BaseRepository as BaseRepository
+
+from .model.base_model import BaseModel as BaseModel
+from .model.base_model import ORM as ORM
+# COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
+
+from .engine import create_engine as create_engine
+from .engine import URL as URL
+from .engine import make_url as make_url
+
+from .sql.sqltypes import JSON as JSON
+from .sql.sqltypes import UUID as UUID
+from .sql.sqltypes import NullType as NullType
+from .sql.sqltypes import INTEGER as INTEGER
+from .sql.sqltypes import INT as INT
+from .sql.sqltypes import SMALLINTEGER as SMALLINTEGER
+from .sql.sqltypes import BIGINTEGER as BIGINTEGER
+from .sql.sqltypes import NUMERIC as NUMERIC
+from .sql.sqltypes import FLOAT as FLOAT
+from .sql.sqltypes import REAL as REAL
+from .sql.sqltypes import DOUBLE as DOUBLE
+from .sql.sqltypes import DECIMAL as DECIMAL
+from .sql.sqltypes import STRING as STRING
+from .sql.sqltypes import TEXT as TEXT
+from .sql.sqltypes import UNICODE as UNICODE
+from .sql.sqltypes import UNICODETEXT as UNICODETEXT
+from .sql.sqltypes import CHAR as CHAR
+from .sql.sqltypes import NCHAR as NCHAR
+from .sql.sqltypes import BLOB as BLOB
+from .sql.sqltypes import VARCHAR as VARCHAR
+from .sql.sqltypes import NVARCHAR as NVARCHAR
+from .sql.sqltypes import DATE as DATE
+from .sql.sqltypes import TIME as TIME
+from .sql.sqltypes import DATETIME as DATETIME
+from .sql.sqltypes import TIMESTAMP as TIMESTAMP
+from .sql.sqltypes import BOOLEAN as BOOLEAN
+from .sql.sqltypes import LARGEBINARY as LARGEBINARY
+from .sql.sqltypes import VARBINARY as VARBINARY
+from .sql.sqltypes import ENUM as ENUM
+from .sql.sqltypes import POINT as POINT
+
+
+from .sql.clauses import Alias as Alias
+from .sql.clauses import Count as Count
+from .sql.clauses import Delete as Delete
+from .sql.clauses import GroupBy as GroupBy
+from .sql.clauses import Insert as Insert
+from .sql.clauses import JoinSelector as JoinSelector
+from .sql.clauses import Limit as Limit
+from .sql.clauses import Offset as Offset
+from .sql.clauses import Order as Order
+from .sql.clauses import Select as Select
+from .sql.clauses import Where as Where
+from .sql.clauses import Having as Having
+from .sql.clauses import Update as Update
+from .sql.clauses import Upsert as Upsert
+
+from .sql.functions import Max as Max
+from .sql.functions import Min as Min
+from .sql.functions import Concat as Concat
+from .sql.functions import Sum as Sum
+
+
+from . import util as _util
+
+_util.import_prefix("ormlambda")

{ormlambda-3.35.3 → ormlambda-4.0.4}/src/ormlambda/caster/caster.py

@@ -62,4 +62,9 @@ class Caster(ICaster):
             column_type = type(value)
         else:
             column_type = type_value
-        return cls.CASTER_SELECTOR()[column_type](value, column_type)
+
+        caster_class = cls.CASTER_SELECTOR().get(column_type, None)
+        if not caster_class:
+            raise ValueError(f"'{column_type}' type has not a Caster class created.")
+
+        return caster_class(value, column_type)

ormlambda-4.0.4/src/ormlambda/common/abstract_classes/__init__.py

@@ -0,0 +1 @@
+from .non_query_base import NonQueryBase as NonQueryBase

{ormlambda-3.35.3 → ormlambda-4.0.4}/src/ormlambda/common/enums/__init__.py

@@ -1,2 +1,3 @@
 from .join_type import JoinType  # noqa: F401
 from .condition_types import ConditionType  # noqa: F401
+from .order_type  import OrderType  # noqa: F401

ormlambda-4.0.4/src/ormlambda/common/enums/order_type.py

@@ -0,0 +1,9 @@
+import enum
+
+
+class OrderType(str, enum.Enum):
+    def __str__(self):
+        return super().__str__()
+
+    ASC = "ASC"
+    DESC = "DESC"

{ormlambda-3.35.3 → ormlambda-4.0.4}/src/ormlambda/common/errors/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import inspect
 import typing as tp
 
+from ormlambda import util
 
 if tp.TYPE_CHECKING:
     from ormlambda.sql.clause_info import ClauseInfo
@@ -35,16 +36,25 @@ class AggregateFunctionError[T](Exception):
         agg_methods = self.__get_all_aggregate_method(self.clause)
         return f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'."
 
+    @util.preload_module("ormlambda.sql.clause_info")
     def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
         """
-        Get the class name of those classes that inherit from 'AggregateFunctionBase' class in order to create a better error message.
+        Get the class name of those classes that inherit from 'IAggregate' class in order to create a better error message.
         """
-        from ormlambda.sql.clause_info import AggregateFunctionBase
 
+        IAggregate = util.preloaded.sql_clause_info.IAggregate
         res: set[str] = set()
         if not isinstance(clauses, tp.Iterable):
             return clauses.__class__.__name__
         for clause in clauses:
-            if isinstance(clause, AggregateFunctionBase):
+            if isinstance(clause, IAggregate):
                 res.add(clause.__class__.__name__)
         return ", ".join(res)
+
+
+class NotCallableError(ValueError):
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def __str__(self)->str:
+        return f"You must provide a function or callable to proceed with the query creation. Passed '{self.args[0].__class__.__name__}' "