ormlambda 2.11.1__tar.gz → 3.7.0__tar.gz

{ormlambda-2.11.1 → ormlambda-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.11.1
+Version: 3.7.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
@@ -9,6 +9,7 @@ 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
 
@@ -36,9 +37,17 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 
 ## Select all columns
 ```python
-from models.address import AddressModel
+from ormlambda import ORM
+from ormlambda.databases.my_sql import MySQLRepository
+
+from models.address import Address
+from config import config_dict
+
+db = MySQLRepository(**config_dict)
+
+AddressModel = ORM(Address,db)
 
-result = AddressModel(database).select()
+result = AddressModel.select()
 ```
 The `result` var will be of type `tuple[Address, ...]` 
 
@@ -46,11 +55,13 @@ The `result` var will be of type `tuple[Address, ...]`
 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."
 
 ```python
-from ormlambda import ConditionType
-from models.address import AddressModel
+from models.address import Address
 
+db = MySQLRepository(**config_dict)
 
-result = AddressModel(database).where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[aA]")).select(
+AddressModel = ORM(Address,db)
+
+result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
         address,
         address.City,
@@ -64,31 +75,51 @@ 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(database).where(lambda x: 10 <= x.address_id <= 30).select()
+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.
+
+```python
+result = AddressModel.where(
+    lambda x: [
+        x.address_id >= 10,
+        x.address_id <= 30,
+    ]
+).select()
 
+```
 Additionally, we can filter by others tables. For example, we can return all addresses for each city where `country_id` = 87 (Spain)
 
 ```python
-result = AddressModel(database).where(lambda x: x.City.Country.country_id  == 87).select()
+result = AddressModel.where(Address.City.Country.country_id  == 87).select()
 ```
 
 We can also return `Address`, `City` or `Country` if needed.
 
 ```python
-result = AddressModel(database).where(lambda x: x.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
+result = AddressModel.where(Address.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
 ```
 
 ### Pass variables to the `where` method
-Since we generally work with lambda methods, I often have to work with `bytecode` to retrieve the name of the string variables. For this reason, it's imperative that we map these variables to replace them with the actual values.
-
 ```python
 LOWER = 10
 UPPER = 30
-AddressModel(database).where(lambda x: LOWER <= x.address_id <= UPPER, LOWER=LOWER, UPPER=UPPER).select()
+
+AddressModel.where(
+    [
+        Address.address_id >= LOWER,
+        Address.address_id <= UPPER,
+    ]
+).select()
 ```
-That solution is somewhat `awkward` and not very clean, but it's necessary for automating queries.
+
 
 ## Writable methods INSERT, UPDATE, DELETE
 The easiest way to add or delete data in your database is by using its appropiate methods. You just need to instantiate an object with the data and pass it to the method
@@ -97,22 +128,21 @@ The easiest way to add or delete data in your database is by using its appropiat
 ```python
 address = Address(address_id=1, address="C/ ...", phone="XXXXXXXXX", postal_code="28026")
 
-AddressModel(database).insert(address)
+AddressModel.insert(address)
 ```
 
 ### Update
-
 You can use either the properties of the same object or `str` values.
 ```python
 
-AddressModel(database).where(lambda x: x.address_id == 1).update(
+AddressModel.where(lambda x: x.address_id == 1).update(
     {
         Address.phone: "YYYYYYYYY",
         Address.postal_code: "28030",
     }
 )
 
-AddressModel(database).where(lambda x: x.address_id == 1).update(
+AddressModel.where(lambda x: x.address_id == 1).update(
     {
         "phone": "YYYYYYYYY",
         "postal_code": "28030",
@@ -122,7 +152,7 @@ AddressModel(database).where(lambda x: x.address_id == 1).update(
 ### Delete
 
 ```python
-AddressModel(database).where(lambda x: x.address_id == 1).delete()
+AddressModel.where(lambda x: x.address_id == 1).delete()
 ```
 
 
@@ -139,67 +169,46 @@ The easiest way to map your tables is:
 
 ```python
 from datetime import datetime
-
 from ormlambda import (
-    Column,
     Table,
-    BaseModel,
+    Column,
     ForeignKey,
 )
-from ormlambda.common.interfaces import IStatements_two_generic, IRepositoryBase
-
 
 class Country(Table):
     __table_name__ = "country"
 
-    country_id: int = Column[int](is_primary_key=True)
-    country: str
-    last_update: datetime
-
-
-class Address(Table):
-    __table_name__ = "address"
-
-    address_id: int = Column[int](is_primary_key=True)
-    address: str
-    address2: str
-    district: str
-    city_id: int
-    postal_code: str
-    phone: str
-    location: str
-    last_update: datetime = Column[datetime](is_auto_generated=True)
-
-    City = ForeignKey["Address", City](__table_name__, City, lambda a, c: a.city_id == c.city_id)
+    country_id: Column[int] = Column(int, is_primary_key=True)
+    country: Column[str]
+    last_update: Column[datetime]
 
 
 class City(Table):
     __table_name__ = "city"
 
-    city_id: int = Column[int](is_primary_key=True)
-    city: str
-    country_id: int
-    last_update: datetime
-
-    Country = ForeignKey["City", Country](__table_name__, Country, lambda ci, co: ci.country_id == co.country_id)
-```
+    city_id: Column[int] = Column(int, is_primary_key=True)
+    city: Column[str]
+    country_id: Column[int]
+    last_update: Column[datetime]
 
-Once created, you need to create a Model for each Table
+    Country = ForeignKey["City", Country](Country, lambda ci, co: ci.country_id == co.country_id)
 
-```python
-class CountryModel(BaseModel[Country]):
-    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
-        return super().__new__(cls, Country, repository)
 
+class Address(Table):
+    __table_name__ = "address"
 
-class AddressModel(BaseModel[Address]):
-    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
-        return super().__new__(cls, Address, repository)
+    address_id: Column[int] = Column(int, is_primary_key=True)
+    address: Column[str]
+    address2: Column[str]
+    district: Column[str]
+    city_id: Column[int]
+    postal_code: Column[str]
+    phone: Column[str]
+    location: Column[str]
+    last_update: Column[datetime] = Column(datetime, is_auto_generated=True)
 
+    City = ForeignKey["Address", City](City, lambda a, c: a.city_id == c.city_id)
 
-class CityModel(BaseModel[City]):
-    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
-        return super().__new__(cls, City, repository)
 ```
 
 # Creating complex queries with lambda
@@ -211,10 +220,10 @@ To retrieve all `Address` object where the fk reference to the `City` table, and
 
 ```python
 result = (
-    AddressModel(database)
+    AddressModel
     .order(lambda a: a.address_id, order_type="DESC")
     .where(lambda x: x.City.Country.country_id >= 50)
-    .select(lambda a: (a))
+    .select(Address)
 )
 
 ```
@@ -223,9 +232,9 @@ Also you can use `ConditionType` enum for `regular expressions` and get, for exa
 
 ```python
 address, city, country = (
-    AddressModel(database)
-    .order(lambda a: a.address_id, order_type="DESC")
-    .where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[A]"))
+    AddressModel
+    .order(Address.address_id, order_type="DESC")
+    .where(Address.City.Country.country.regex(r"^[A]"))
     .limit(100)
     .select(
         lambda a: (
@@ -238,7 +247,6 @@ address, city, country = (
 
 
 for a in address:
-
     print(a.address_id)
 
 for c in city:
@@ -253,8 +261,7 @@ In the example above, we see that the `result` var returns a tuple of tuples. Ho
 
 ```python
 result = (
-    a_model
-    .where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[A]"))
+    AddressModel.where(Address.City.Country.country.regex(r"^[A]"))
     .limit(100)
     .select(
         lambda a: (
@@ -270,4 +277,61 @@ result = (
 
 with this approach, we will obtain a dictionary where the key will be the concatenation between the selected table name and the column name specified in the lambda function, to avoid overwritting data from tables that sharing column names.
 
+# Other methods
 
+## max
+```python
+res = AddressModel.max(Address.address_id, execute=True)
+```
+## min
+```python
+res = AddressModel.min(Address.address_id, execute=True)
+```
+## sum
+```python
+res = AddressModel.sum(Address.address_id, execute=True)
+```
+## count
+```python
+res = AddressModel.count(Address.address_id, execute=True)
+```
+
+## 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
+result = AddressModel.select_one(
+            lambda x: (
+                AddressModel.min(x.address_id),
+                AddressModel.max(x.address_id),
+                AddressModel.count(x.address_id),
+            ),flavour=dict
+        )
+```
+Getting something like
+
+```python
+# {
+#     "min": 1,
+#     "max": 605,
+#     "count": 603,
+# }
+```
+
+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),
+    ),
+    flavour=dict,
+)
+
+# {
+#     "min": 1,
+#     "custom-max": 605,
+#     "count": 603,
+# }
+```

{ormlambda-2.11.1 → ormlambda-3.7.0}/README.md

@@ -22,9 +22,17 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 
 ## Select all columns
 ```python
-from models.address import AddressModel
+from ormlambda import ORM
+from ormlambda.databases.my_sql import MySQLRepository
+
+from models.address import Address
+from config import config_dict
+
+db = MySQLRepository(**config_dict)
+
+AddressModel = ORM(Address,db)
 
-result = AddressModel(database).select()
+result = AddressModel.select()
 ```
 The `result` var will be of type `tuple[Address, ...]` 
 
@@ -32,11 +40,13 @@ The `result` var will be of type `tuple[Address, ...]`
 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."
 
 ```python
-from ormlambda import ConditionType
-from models.address import AddressModel
+from models.address import Address
 
+db = MySQLRepository(**config_dict)
 
-result = AddressModel(database).where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[aA]")).select(
+AddressModel = ORM(Address,db)
+
+result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
         address,
         address.City,
@@ -50,31 +60,51 @@ 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(database).where(lambda x: 10 <= x.address_id <= 30).select()
+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.
+
+```python
+result = AddressModel.where(
+    lambda x: [
+        x.address_id >= 10,
+        x.address_id <= 30,
+    ]
+).select()
 
+```
 Additionally, we can filter by others tables. For example, we can return all addresses for each city where `country_id` = 87 (Spain)
 
 ```python
-result = AddressModel(database).where(lambda x: x.City.Country.country_id  == 87).select()
+result = AddressModel.where(Address.City.Country.country_id  == 87).select()
 ```
 
 We can also return `Address`, `City` or `Country` if needed.
 
 ```python
-result = AddressModel(database).where(lambda x: x.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
+result = AddressModel.where(Address.City.Country.country_id == 87).select(lambda x: (x, x.City, x.City.Country))
 ```
 
 ### Pass variables to the `where` method
-Since we generally work with lambda methods, I often have to work with `bytecode` to retrieve the name of the string variables. For this reason, it's imperative that we map these variables to replace them with the actual values.
-
 ```python
 LOWER = 10
 UPPER = 30
-AddressModel(database).where(lambda x: LOWER <= x.address_id <= UPPER, LOWER=LOWER, UPPER=UPPER).select()
+
+AddressModel.where(
+    [
+        Address.address_id >= LOWER,
+        Address.address_id <= UPPER,
+    ]
+).select()
 ```
-That solution is somewhat `awkward` and not very clean, but it's necessary for automating queries.
+
 
 ## Writable methods INSERT, UPDATE, DELETE
 The easiest way to add or delete data in your database is by using its appropiate methods. You just need to instantiate an object with the data and pass it to the method
@@ -83,22 +113,21 @@ The easiest way to add or delete data in your database is by using its appropiat
 ```python
 address = Address(address_id=1, address="C/ ...", phone="XXXXXXXXX", postal_code="28026")
 
-AddressModel(database).insert(address)
+AddressModel.insert(address)
 ```
 
 ### Update
-
 You can use either the properties of the same object or `str` values.
 ```python
 
-AddressModel(database).where(lambda x: x.address_id == 1).update(
+AddressModel.where(lambda x: x.address_id == 1).update(
     {
         Address.phone: "YYYYYYYYY",
         Address.postal_code: "28030",
     }
 )
 
-AddressModel(database).where(lambda x: x.address_id == 1).update(
+AddressModel.where(lambda x: x.address_id == 1).update(
     {
         "phone": "YYYYYYYYY",
         "postal_code": "28030",
@@ -108,7 +137,7 @@ AddressModel(database).where(lambda x: x.address_id == 1).update(
 ### Delete
 
 ```python
-AddressModel(database).where(lambda x: x.address_id == 1).delete()
+AddressModel.where(lambda x: x.address_id == 1).delete()
 ```
 
 
@@ -125,67 +154,46 @@ The easiest way to map your tables is:
 
 ```python
 from datetime import datetime
-
 from ormlambda import (
-    Column,
     Table,
-    BaseModel,
+    Column,
     ForeignKey,
 )
-from ormlambda.common.interfaces import IStatements_two_generic, IRepositoryBase
-
 
 class Country(Table):
     __table_name__ = "country"
 
-    country_id: int = Column[int](is_primary_key=True)
-    country: str
-    last_update: datetime
-
-
-class Address(Table):
-    __table_name__ = "address"
-
-    address_id: int = Column[int](is_primary_key=True)
-    address: str
-    address2: str
-    district: str
-    city_id: int
-    postal_code: str
-    phone: str
-    location: str
-    last_update: datetime = Column[datetime](is_auto_generated=True)
-
-    City = ForeignKey["Address", City](__table_name__, City, lambda a, c: a.city_id == c.city_id)
+    country_id: Column[int] = Column(int, is_primary_key=True)
+    country: Column[str]
+    last_update: Column[datetime]
 
 
 class City(Table):
     __table_name__ = "city"
 
-    city_id: int = Column[int](is_primary_key=True)
-    city: str
-    country_id: int
-    last_update: datetime
-
-    Country = ForeignKey["City", Country](__table_name__, Country, lambda ci, co: ci.country_id == co.country_id)
-```
+    city_id: Column[int] = Column(int, is_primary_key=True)
+    city: Column[str]
+    country_id: Column[int]
+    last_update: Column[datetime]
 
-Once created, you need to create a Model for each Table
+    Country = ForeignKey["City", Country](Country, lambda ci, co: ci.country_id == co.country_id)
 
-```python
-class CountryModel(BaseModel[Country]):
-    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
-        return super().__new__(cls, Country, repository)
 
+class Address(Table):
+    __table_name__ = "address"
 
-class AddressModel(BaseModel[Address]):
-    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
-        return super().__new__(cls, Address, repository)
+    address_id: Column[int] = Column(int, is_primary_key=True)
+    address: Column[str]
+    address2: Column[str]
+    district: Column[str]
+    city_id: Column[int]
+    postal_code: Column[str]
+    phone: Column[str]
+    location: Column[str]
+    last_update: Column[datetime] = Column(datetime, is_auto_generated=True)
 
+    City = ForeignKey["Address", City](City, lambda a, c: a.city_id == c.city_id)
 
-class CityModel(BaseModel[City]):
-    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
-        return super().__new__(cls, City, repository)
 ```
 
 # Creating complex queries with lambda
@@ -197,10 +205,10 @@ To retrieve all `Address` object where the fk reference to the `City` table, and
 
 ```python
 result = (
-    AddressModel(database)
+    AddressModel
     .order(lambda a: a.address_id, order_type="DESC")
     .where(lambda x: x.City.Country.country_id >= 50)
-    .select(lambda a: (a))
+    .select(Address)
 )
 
 ```
@@ -209,9 +217,9 @@ Also you can use `ConditionType` enum for `regular expressions` and get, for exa
 
 ```python
 address, city, country = (
-    AddressModel(database)
-    .order(lambda a: a.address_id, order_type="DESC")
-    .where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[A]"))
+    AddressModel
+    .order(Address.address_id, order_type="DESC")
+    .where(Address.City.Country.country.regex(r"^[A]"))
     .limit(100)
     .select(
         lambda a: (
@@ -224,7 +232,6 @@ address, city, country = (
 
 
 for a in address:
-
     print(a.address_id)
 
 for c in city:
@@ -239,8 +246,7 @@ In the example above, we see that the `result` var returns a tuple of tuples. Ho
 
 ```python
 result = (
-    a_model
-    .where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[A]"))
+    AddressModel.where(Address.City.Country.country.regex(r"^[A]"))
     .limit(100)
     .select(
         lambda a: (
@@ -256,3 +262,61 @@ result = (
 
 with this approach, we will obtain a dictionary where the key will be the concatenation between the selected table name and the column name specified in the lambda function, to avoid overwritting data from tables that sharing column names.
 
+# Other methods
+
+## max
+```python
+res = AddressModel.max(Address.address_id, execute=True)
+```
+## min
+```python
+res = AddressModel.min(Address.address_id, execute=True)
+```
+## sum
+```python
+res = AddressModel.sum(Address.address_id, execute=True)
+```
+## count
+```python
+res = AddressModel.count(Address.address_id, execute=True)
+```
+
+## 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
+result = AddressModel.select_one(
+            lambda x: (
+                AddressModel.min(x.address_id),
+                AddressModel.max(x.address_id),
+                AddressModel.count(x.address_id),
+            ),flavour=dict
+        )
+```
+Getting something like
+
+```python
+# {
+#     "min": 1,
+#     "max": 605,
+#     "count": 603,
+# }
+```
+
+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),
+    ),
+    flavour=dict,
+)
+
+# {
+#     "min": 1,
+#     "custom-max": 605,
+#     "count": 603,
+# }
+```

{ormlambda-2.11.1 → ormlambda-3.7.0}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "2.11.1"
+version = "3.7.0"
 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"
@@ -13,11 +13,11 @@ python = "^3.12"
 mysql-connector-python= "^9.0.0"
 fluent-validation = "4.3.1"
 shapely = "^2.0.6"
+python-dotenv = "^1.0.1"
 
 [tool.poetry.group.test.dependencies]
 pandas = "^2.2.2"
 ruff = "^0.4.5"
-python-decouple = "^3.8"
 parameterized = "^0.9.0"