ormlambda 2.11.2__py3-none-any.whl → 3.7.0__py3-none-any.whl

{ormlambda-2.11.2.dist-info → ormlambda-3.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.11.2
+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-3.7.0.dist-info/RECORD

@@ -0,0 +1,117 @@
+ormlambda/__init__.py,sha256=KGnAPj90RWKP1GnuSQD1rAaREXfE2pwzg7vCTYB36ZI,619
+ormlambda/caster/__init__.py,sha256=JWJ6qdPTk_uyJHGfFpvFCZeOXdP6DzL4-MtMFZVDPRY,150
+ormlambda/caster/base_caster.py,sha256=ogihKXZIyeDsJ2N0EDKujf6BIfVSJAZ9G1jIbBXJV2o,1786
+ormlambda/caster/caster.py,sha256=ecDvGgMI3yFtJxqKD9XcSVtBcqQtYitfMTooWPlLnEY,1885
+ormlambda/caster/interfaces/ICaster.py,sha256=MCBBVBho9KH67vCcUk8nclY0a7QoqxgdyVJJR0-QDT0,759
+ormlambda/caster/interfaces/__init__.py,sha256=TRoIxxgxuhUhCJq2ldLS3UEa1THrMXEIyTH5K46vyGw,43
+ormlambda/common/__init__.py,sha256=g4yGxH4WEgvQ7Rix4lpp3FQ-3SeRhptNd5sabgZLQNk,59
+ormlambda/common/abstract_classes/__init__.py,sha256=l39_WaBH38wrDV2KXb83c73ct7oxSIIVj2Ep4UcvxrU,186
+ormlambda/common/abstract_classes/decomposition_query.py,sha256=CH4rRIH_wQCkpDA2qWOdzf-c5BCX6F_2bkpMPjNB044,7592
+ormlambda/common/abstract_classes/non_query_base.py,sha256=1BQa9n14k7A2txmnj76nBZckJXARFcJIRooT7VR6y3Q,991
+ormlambda/common/abstract_classes/query_base.py,sha256=6qUFPwsVx45kUW3b66pHiSyjhcH4mzbdkddlGeUnG7c,266
+ormlambda/common/enums/__init__.py,sha256=4lVKCHi1JalwgNzjsAXqX-C54NJEH83y2v5baMO8fN4,103
+ormlambda/common/enums/condition_types.py,sha256=QZnhhlTwzLcZ9kkmG6a08fQjUUJsJ5XGAH7QCiJRL1A,330
+ormlambda/common/enums/join_type.py,sha256=EosZVnvAc72LlZHuICIgoKWwUJzhvWOIIAohcbDYPQo,354
+ormlambda/common/errors/__init__.py,sha256=nc6SJs6v7MbXwcEgcSW7SSG_iBECfz_10YzWwqU1D-E,888
+ormlambda/common/global_checker.py,sha256=R_m3_byStbnOj8qeVggHWBBR9VlkA_Lz5fm8M4OCzvY,890
+ormlambda/common/interfaces/ICustomAlias.py,sha256=gEzjLFXT_JhkzGuBfWz36cqPrZ_B9999C3S61IicLoQ,159
+ormlambda/common/interfaces/IDecompositionQuery.py,sha256=2fwcXONBnYpxL1YHPHaLxqQJ4NANGuTky69QNa74xd4,853
+ormlambda/common/interfaces/IJoinSelector.py,sha256=-w-MJmwq65tpDLtigWSLgvAqeOl75DA-EyWIugNkfCs,490
+ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
+ormlambda/common/interfaces/IQueryCommand.py,sha256=hfzCosK4-n8RJIb2PYs8b0qU3TNmfYluZXBf47KxxKs,331
+ormlambda/common/interfaces/__init__.py,sha256=np5wuAnBVAHDyD01-X3M9qPmzbjOzP6KNAj9BFazGd4,300
+ormlambda/components/__init__.py,sha256=DfPVPLGLbQpbfBmXGKYcJRTELxzzdeNbZbuiMgZrPiA,168
+ormlambda/components/delete/IDelete.py,sha256=06ZEdbKBxsHSwsGMBu0E1om4WJjojZAm-L3b95eQrcc,139
+ormlambda/components/delete/__init__.py,sha256=X_at2L4QkxDVK1olXhFHqNemkB8Dxbb7BYqv0EJyu7M,102
+ormlambda/components/delete/abstract_delete.py,sha256=ca-AO3nM9MMhy0hofNLjnCod92meiWzRT2vitj8N-l4,535
+ormlambda/components/insert/IInsert.py,sha256=YIfMPlKu7UGgnVpZuhpr0Mtnefe-O85hqk8-GZrVK7w,139
+ormlambda/components/insert/__init__.py,sha256=TGShCJZwejK3zZCRistBAKoDy2NNDRR_w1LXIbN66Dk,102
+ormlambda/components/insert/abstract_insert.py,sha256=OmsfVMx8ifD2_ajRSXX8-EeKRTS7FTwbgSjdwASz_eg,695
+ormlambda/components/select/ISelect.py,sha256=PcHvp8G1Zp_Gvn-_iZp-8SRBab7WVTxrtMr2FgQ_0sU,372
+ormlambda/components/select/__init__.py,sha256=MAnVr3gsyXozsB9Q8jOl5KKCnOfQwxARuWpPS-h5Ooc,42
+ormlambda/components/update/IUpdate.py,sha256=U-3Wx8lyCglhxf9gCXWO3MVgydG6gfRpzp00_MHC5cU,168
+ormlambda/components/update/__init__.py,sha256=o1VjlfXgjftZgp64O10rzCGaDZCbdTZRRtjIlojTUWA,102
+ormlambda/components/update/abstract_update.py,sha256=BXskuatPtWzYtB2xKN30SFTe4iVu_XApTNLjR0ZY5Ig,893
+ormlambda/components/upsert/IUpsert.py,sha256=2m6Bcwa0X80IDLnf0QErqr01uYEydOnRta9_T1nxjK4,139
+ormlambda/components/upsert/__init__.py,sha256=2hv7-McdU8Jv1ZJ4J3v94brN2H_fXvVDS8ZEA9CsfPA,102
+ormlambda/components/upsert/abstract_upsert.py,sha256=a5_dJxTKI6GtxNTesxKtGFyy-AR6dXA6V2CAYiILn9o,695
+ormlambda/databases/__init__.py,sha256=-m7uIigkbFNU5JHeOE8DeTA2bRVYEppw2XPASTSvW_o,136
+ormlambda/databases/my_sql/__init__.py,sha256=2Ue97WtcpfB6-8SgUIHLOzk_iT44YUzG6baXCHmV9uA,212
+ormlambda/databases/my_sql/caster/__init__.py,sha256=Df2sdZaAJ1Mi5Ego0sILMk5pF1NbK-nlV0hbpzd0PWE,47
+ormlambda/databases/my_sql/caster/caster.py,sha256=D8hDwyZXOw5GRTQwONZyLaYe0sAimbDGb7DnDxUv_Ng,1181
+ormlambda/databases/my_sql/caster/read.py,sha256=PBseYoNJtMgmr4sL5aD6uef0f-mm6LakAz-v-IcBs7w,1096
+ormlambda/databases/my_sql/caster/types/__init__.py,sha256=lZ9YFqDjY6d6-Vy0tBMZfLI5EhyKXrb12Ys4eYiWjAg,396
+ormlambda/databases/my_sql/caster/types/bytes.py,sha256=8rf2JEDFtwY5vsWZJ3r5Y8ruH76KwvRpLjjQOFdg5aA,896
+ormlambda/databases/my_sql/caster/types/datetime.py,sha256=TXgHLJZ1v7LYqQnygK51K0WMHR96GVOOdtqd5HqXOx4,1053
+ormlambda/databases/my_sql/caster/types/float.py,sha256=KCU6n6vH7c9NtRYbad91T-EEjKCDmr9iR_14Q6oswF4,890
+ormlambda/databases/my_sql/caster/types/int.py,sha256=oqtZnqxVLysP2tTt5KXxWbpsYmv45gocU1MEBMaewBw,880
+ormlambda/databases/my_sql/caster/types/iterable.py,sha256=kcaZcz7Mjip6CEG2oBlEQ7h9gAlo9PV5IosMm0WYOu4,893
+ormlambda/databases/my_sql/caster/types/none.py,sha256=pdqcmcpHld-tM1-YjMJTrV7Aa_h2_sAprnRkaS-XIzc,784
+ormlambda/databases/my_sql/caster/types/point.py,sha256=g5G691CsyQQtK6BGoKVpDzUtMRJNIKz_98xeHxqTGLE,1426
+ormlambda/databases/my_sql/caster/types/string.py,sha256=NY03rRqLHAi_mxYWXDDIsPHtPiiw6pHAdSbn01yZuU4,887
+ormlambda/databases/my_sql/caster/write.py,sha256=mfbtlAFamsnMbe1L4ARSAw2ch5qhz15jh5cSyAljcss,1322
+ormlambda/databases/my_sql/clauses/ST_AsText.py,sha256=Fx-CgQ01aSkcuSlcdmLIWb7f3kd7r6kWs_BGu1HOVx8,1165
+ormlambda/databases/my_sql/clauses/ST_Contains.py,sha256=K9cZwQaQQCgZTQdnAokln5lVSyV99CkeRnmOd2RIots,968
+ormlambda/databases/my_sql/clauses/__init__.py,sha256=ZtIPgEoHXw5Dyv1U9aHnuKRhGQOPNhbtW1pNMUSfVvA,826
+ormlambda/databases/my_sql/clauses/alias.py,sha256=NLISh_c8L7ZwN_13mhmVUxvop6kU-j2N09GmuDjLRXs,1147
+ormlambda/databases/my_sql/clauses/count.py,sha256=rh7KNzpxkKEZpqmFV0oc8xHVgOHVGTGHrPGmCF-eLB4,1384
+ormlambda/databases/my_sql/clauses/create_database.py,sha256=zpd8uosxKJsf9BULvAHSd1-fU5de8OI7WRqVa8oyiA4,1209
+ormlambda/databases/my_sql/clauses/delete.py,sha256=Vm9lRKuX9x_m8faTlOs_A3v9zzoGGCnQ7CH_-QM6uK4,1900
+ormlambda/databases/my_sql/clauses/drop_database.py,sha256=2GYhtWzHSWM7Yy3v_l2hiY4fFumG8DSCGGLgP0t3Rhk,437
+ormlambda/databases/my_sql/clauses/drop_table.py,sha256=ltaJJFcNXChBF7fYGNCZK9QQ4iWfG72HFacL57f2k6A,569
+ormlambda/databases/my_sql/clauses/group_by.py,sha256=u5cYkWslAGr1-NTLn-OdKZQAjfZdwwi7WH2TX2qhTec,900
+ormlambda/databases/my_sql/clauses/insert.py,sha256=xR9IRiJeTIw-65MhnbK_uemMdvIEAaqFPg4IFBtC9Yk,3691
+ormlambda/databases/my_sql/clauses/joins.py,sha256=PEq7_qxgjJK5R_m8WkqJWppEc-bQFIbAb88qn81uGOg,5170
+ormlambda/databases/my_sql/clauses/limit.py,sha256=32Fii_WHjrX7K5B7H5uWlzYM6KBMFsE-Uz-70CEvTok,386
+ormlambda/databases/my_sql/clauses/offset.py,sha256=PKieZvCYLSSza-Nhcam5DJEYv--jBU8RHwju3P_f9Kk,390
+ormlambda/databases/my_sql/clauses/order.py,sha256=8sUKxWvkkOc5nn-r6GGL5MbFkCAD_St1CWMQkStSrLE,2147
+ormlambda/databases/my_sql/clauses/select.py,sha256=O1dZWKG3_93-s_X_EjOF_alp_U82EzfDUKBMBcajxKY,1830
+ormlambda/databases/my_sql/clauses/update.py,sha256=-3S_SwmSg_-qu_iDwhr1BY5ZtGGq0Og7eyO2YzdRFrU,2939
+ormlambda/databases/my_sql/clauses/upsert.py,sha256=VJAwfvpIT3xXwm3AnifVqiswnYNleDTnbY0CgnQqC0s,1945
+ormlambda/databases/my_sql/clauses/where.py,sha256=IR4BR4Rl13GiupCC3ilkUgqYu-LmISux7XZ6JIQGziw,1692
+ormlambda/databases/my_sql/functions/__init__.py,sha256=hA8t3mUpV2p-pO4TVp5rjC5Yp7aIkWPsS8NpLi3DUh0,171
+ormlambda/databases/my_sql/functions/concat.py,sha256=ih5An-1vxEVw0On0VLTuszVMku1c3eZmyUEdL4mO83o,1296
+ormlambda/databases/my_sql/functions/max.py,sha256=01kkgougyP5m9_wdZB9_QvHKV86GnfZdotwsTSwAQfA,1493
+ormlambda/databases/my_sql/functions/min.py,sha256=9g8twv0wUfpxrRK2socnfkJtmd_78pU6HDk_4AiV03c,1487
+ormlambda/databases/my_sql/functions/sum.py,sha256=PUItqZ4ZbBcOfPzGbYDVvhVKV1RxLMuI63xNbSD8KrA,1487
+ormlambda/databases/my_sql/join_context.py,sha256=CEKz0BPqkLBRoY9ciYAcLSon1jRNPq2-4HDw4ID8nkw,3192
+ormlambda/databases/my_sql/repository/__init__.py,sha256=_T7m-UpgJlx7eYdjBw8jdSVFGnjFYAcbp45g4EM7YEk,54
+ormlambda/databases/my_sql/repository/repository.py,sha256=AfTYGX96Sg9sNZNik69_e0r6YlP6fnuw92XPmk6wS-4,10246
+ormlambda/databases/my_sql/statements.py,sha256=zAJ3432zMVp4GPjCOvaEn88eYxBqB71wHekTtdc-uak,15995
+ormlambda/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/engine/template.py,sha256=colmdl-IBSGc1eIqIYShsVkseQwF5_gwwc6Pt8ndN24,1350
+ormlambda/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/model/base_model.py,sha256=S_PYs5ZO-LTgiJSyAmGUtXwFKLb9VnM2Rqlq4pdhppY,1021
+ormlambda/repository/__init__.py,sha256=4KAhKn6vWV7bslewvGMNqbbbUnz1DLnH4yy-M5QNAQA,112
+ormlambda/repository/base_repository.py,sha256=jyHkj33nP6kGEDAdqqXcADK9GH2MVY7MQVIZljZr2L0,448
+ormlambda/repository/interfaces/IDatabaseConnection.py,sha256=pxczjx0b53yjjg5hvVDloMgUTFDahVC3HlJLQjo9_1w,283
+ormlambda/repository/interfaces/IRepositoryBase.py,sha256=dxgMzALU_HtAiXwzUdNu4KeYR2PN_dqbepX4f_nA9NQ,1205
+ormlambda/repository/interfaces/__init__.py,sha256=t8Mn0aRZm8uF4MGaqjEANTTADCdOwNF0THZ_qebyzwo,126
+ormlambda/sql/__init__.py,sha256=0CWQzfxhTRWXozoRsg460o_ZwjW9w4uyL5jQUcD4eHg,121
+ormlambda/sql/clause_info/__init__.py,sha256=ft8qh3pxXx3eAJfeBfSNwjzTjEAJob59XYLOnQQCJYI,205
+ormlambda/sql/clause_info/clause_info.py,sha256=V4IQ6fuqf0Y-AS0qykQNcpOA2joib3FLuowNrMSBHNI,15644
+ormlambda/sql/clause_info/clause_info_context.py,sha256=Y32p3x4mqcdNHbAowrKaN_ldnGn7zvaP1UdAkWWryhM,2852
+ormlambda/sql/clause_info/interface/IAggregate.py,sha256=P-QPaTMAMHVR5M9-ClmL8wsj0uNGG5xpxjuAwWnzKxA,216
+ormlambda/sql/clause_info/interface/__init__.py,sha256=7eEyHO7P_1DB63bP0ej5EjKkvb7IHwaGlSG58Hrv2X0,49
+ormlambda/sql/column.py,sha256=pRrsFkUZlilvnHWDbKPvUhwyV-1bhYxlcYB-Fa8D7_4,5242
+ormlambda/sql/comparer.py,sha256=XTi4QT2ICtssCPsF8yrMwLDswnu7lF3MO217hAAY0t8,5334
+ormlambda/sql/dtypes.py,sha256=Ji4QOyKD0n9bKe7yXIIduy9uEX5BaXolQSIsx0NXYJY,7843
+ormlambda/sql/foreign_key.py,sha256=lO_OiVTmMsFQpfp-102XZgPSsYBoVCO74i6YVdQ89yk,4773
+ormlambda/sql/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/sql/table/__init__.py,sha256=nAHXi63eDJeGGCf4f0A7W6x4Rh3FJ2dpfzxPEN6r3bc,62
+ormlambda/sql/table/fields.py,sha256=ovNR3bJ473aKW-2NhbKr0iJlVpgW06jurHLob2IyZU8,2116
+ormlambda/sql/table/table_constructor.py,sha256=UQLxg2xZrNBH76MVQf-lp8de-TikZUNDIhWCNA9m7A4,8639
+ormlambda/sql/types.py,sha256=z5FME0m9j7zSKlxS21cZxHRg0pyTfiJbq7VWZ6IT0kM,832
+ormlambda/statements/__init__.py,sha256=mFER-VoLf5L2BjdQhWMw6rVQi8kpr-qZzi1ZSWRPIIU,99
+ormlambda/statements/base_statement.py,sha256=WLjQrWw72NhBdNkP8uO1UP8hzfv-leyFjmMa4ofa-fk,5660
+ormlambda/statements/interfaces/IStatements.py,sha256=nmpGRlsLqhx_uO9BYsUFiW48Qp8WhU2G-ePw4VtQiCA,10135
+ormlambda/statements/interfaces/__init__.py,sha256=a3RyTNVA7DwWMqvVi7gFYP4MArdU-RUYixJcxfc79HY,76
+ormlambda/statements/types.py,sha256=5HiOXjIm4aQzafB5Mq9b8OyBV2AyEH_P-kjQ8aQ8bIY,1743
+ormlambda/utils/__init__.py,sha256=SEgDWkwbSrYRv0If92Ewq53DKnxxv5HqEAQbETd1C6Q,50
+ormlambda/utils/module_tree/__init__.py,sha256=LNQtqkwO1ul49Th3aHAIiyt0Wt899GmXCc44Uz1eDyY,53
+ormlambda/utils/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkjptDbK3IugXm8iU,1425
+ormlambda/utils/module_tree/dynamic_module.py,sha256=SJWpOC5oqASGjCXYHW0JwzEpcZ_DkxKLyK4SpIsMbaA,8700
+ormlambda-3.7.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-3.7.0.dist-info/METADATA,sha256=mHVqTwLEX25rq7hhIuQaFkRJ50nUxN11749d8-BDSqc,9305
+ormlambda-3.7.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-3.7.0.dist-info/RECORD,,

ormlambda/common/abstract_classes/abstract_model.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING, Optional
-from collections import defaultdict
-import abc
-
-
-from ormlambda.utils import Table
-from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
-from ormlambda.common.interfaces.IAggregate import IAggregate
-
-if TYPE_CHECKING:
-    from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
-    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
-
-
-ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
-
-
-class AbstractSQLStatements[T: Table, *Ts, TRepo](IStatements_two_generic[T, *Ts, TRepo]):
-    __slots__ = ("_model", "_repository", "_query_list")
-    __order__: tuple[str, ...] = ("select", "join", "where", "order", "with", "group by", "limit", "offset")
-
-    def __init__(self, model: tuple[T, *Ts], repository: IRepositoryBase[TRepo]) -> None:
-        self.__valid_repository(repository)
-
-        self._query: Optional[str] = None
-        self._model: T = model[0] if isinstance(model, Iterable) else model
-        self._models: tuple[T, *Ts] = self._model if isinstance(model, Iterable) else (model,)
-        self._repository: IRepositoryBase[TRepo] = repository
-        self._query_list: dict[ORDER_QUERIES, list[IQuery]] = defaultdict(list)
-
-        if not issubclass(self._model, Table):
-            # Deben heredar de Table ya que es la forma que tenemos para identificar si estamos pasando una instancia del tipo que corresponde o no cuando llamamos a insert o upsert.
-            # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
-            raise Exception(f"'{model}' class does not inherit from Table class")
-
-    @staticmethod
-    def __valid_repository(repository: Any) -> bool:
-        if not isinstance(repository, IRepositoryBase):
-            raise ValueError(f"'repository' attribute does not instance of '{IRepositoryBase.__name__}'")
-        return True
-
-    def __repr__(self):
-        return f"<Model: {self.__class__.__name__}>"
-
-    def _return_flavour[TValue](self, query, flavour: Type[TValue], select, **kwargs) -> tuple[TValue]:
-        return self._repository.read_sql(query, flavour=flavour, model=self._model, select=select, **kwargs)
-
-    def _return_model(self, select, query: str):
-        response_sql = self._repository.read_sql(query, flavour=dict, model=self._model, select=select)  # store all columns of the SQL query
-
-        if isinstance(response_sql, Iterable):
-            return ClusterQuery[T](select, response_sql).clean_response()
-
-        return response_sql
-
-    @abc.abstractmethod
-    def _build(sef): ...
-
-    @property
-    def query(self) -> str:
-        return self._query
-
-    @property
-    def model(self) -> Type[T]:
-        return self._model
-
-    @property
-    def models(self) -> tuple[*Ts]:
-        return self._models
-
-    @property
-    @override
-    def repository(self) -> IRepositoryBase[TRepo]: ...
-
-
-class ClusterQuery[T]:
-    def __init__(self, select: DecompositionQueryBase[T], response_sql: tuple[dict[str, Any]]) -> None:
-        self._select: DecompositionQueryBase[T] = select
-        self._response_sql: tuple[dict[str, Any]] = response_sql
-
-    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table]]]:
-        tbl_dicc: dict[Type[Table], list[Table]] = self.__loop_foo()
-
-        # it not depend of flavour attr
-        for key, val in tbl_dicc.items():
-            tbl_dicc[key] = tuple(val)
-
-        return tuple(tbl_dicc.values())
-
-    def __loop_foo(self) -> dict[Type[Table], list[Table]]:
-        #  We must ensure to get the valid attributes for each instance
-        table_initialize = defaultdict(list)
-
-        for table, clauses in self._select._clauses_group_by_tables.items():
-            for dicc_cols in self._response_sql:
-                valid_attr: dict[str, Any] = {}
-                for clause in clauses:
-                    if clause.column is None or not hasattr(table, clause.column):
-                        agg_methods = self.__get_all_aggregate_method(clauses)
-                        raise ValueError(f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'.")
-                    valid_attr[clause.column] = dicc_cols[clause.alias]
-
-                # COMMENT: At this point we are going to instantiate Table class with specific attributes getting directly from database
-                table_initialize[table].append(table(**valid_attr))
-        return table_initialize
-
-    def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
-        res: set[str] = set()
-
-        for clause in clauses:
-            row = clause._row_column
-            if isinstance(row, IAggregate):
-                res.add(row.__class__.__name__)
-        return ", ".join(res)

ormlambda/common/interfaces/IAggregate.py

@@ -1,10 +0,0 @@
-from __future__ import annotations
-import typing as tp
-
-if tp.TYPE_CHECKING:
-    from ormlambda import Table
-from .IQueryCommand import IQuery
-from .IDecompositionQuery import IDecompositionQuery
-
-
-class IAggregate[T: tp.Type[Table]](IDecompositionQuery[T], IQuery): ...