ormlambda 0.1.0__py3-none-any.whl

ormlambda-0.1.0.dist-info/METADATA

@@ -0,0 +1,268 @@
+Metadata-Version: 2.1
+Name: ormlambda
+Version: 0.1.0
+Summary: ORM designed to interact with the database using lambda 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: mysql-connector (>=2.2.9,<3.0.0)
+Requires-Dist: ruff (>=0.4.5,<0.5.0)
+Description-Content-Type: text/markdown
+
+# ormMySQL
+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
+
+## Initialize MySQLRepository
+```python
+from decouple import config
+from src.ormmysql.databases.my_sql import MySQLRepository
+
+USERNAME = config("USERNAME")
+PASSWORD = config("PASSWORD")
+HOST = config("HOST")
+
+
+database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila", host=HOST)
+```
+
+## Select all columns
+```python
+from src.test.models.address import AddressModel
+
+result = AddressModel(database).select()
+```
+The `result` var will be of type `tuple[Address, ...]` 
+
+## 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."
+
+```python
+from src.ormmysql.common.enums import ConditionType
+from src.test.models.address import AddressModel
+
+
+result = AddressModel(database).where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[aA]")).select(
+    lambda address: (
+        address,
+        address.City,
+        address.City.Country,
+    ),
+)
+```
+The `result` var will be of type `tuple[tuple[Address], tuple[City], tuple[Country]]`.
+
+If we were used `select_one` method, we retrieved `tuple[Address, City, Country]`.
+
+## Filter by `where` condition
+
+```python
+result = AddressModel(database).where(lambda x: 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()
+```
+
+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))
+```
+
+### 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()
+```
+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
+
+### Insert
+```python
+address = Address(address_id=1, address="C/ ...", phone="XXXXXXXXX", postal_code="28026")
+
+AddressModel(database).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(
+    {
+        Address.phone: "YYYYYYYYY",
+        Address.postal_code: "28030",
+    }
+)
+
+AddressModel(database).where(lambda x: x.address_id == 1).update(
+    {
+        "phone": "YYYYYYYYY",
+        "postal_code": "28030",
+    }
+)
+```
+### Delete
+
+```python
+AddressModel(database).where(lambda x: x.address_id == 1).delete()
+```
+
+
+# Table Map
+The most important aspect when creating classes to map database tables is to consider the importance of typing the variables that should behave as columns. In other words, variables that are typed will be those that are passed to the class constructor. This is why both `__table_name__` and variables that reference foreign classes, are not given a specific data tpye.
+
+For example, imagine you have three Table in your database: `Addres`, `City` and `Country`. Each of them has its own Foreing keys.
+
+`Address` has a FK relationship with `City`.
+
+`City` has a FK relationship with `Country`.
+
+The easiest way to map your tables is:
+
+```python
+from datetime import datetime
+
+from src.ormmysql import (
+    Column,
+    Table,
+    BaseModel,
+    ForeignKey,
+)
+from src.ormmysql.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)
+
+
+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)
+```
+
+Once created, you need to create a Model for each Table
+
+```python
+class CountryModel(BaseModel[Country]):
+    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
+        return super().__new__(cls, Country, repository)
+
+
+class AddressModel(BaseModel[Address]):
+    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
+        return super().__new__(cls, Address, repository)
+
+
+class CityModel(BaseModel[City]):
+    def __new__[TRepo](cls, repository: IRepositoryBase[TRepo]):
+        return super().__new__(cls, City, repository)
+```
+
+# Creating complex queries with lambda
+
+We can use various methods such as `where`, `limit`, `offset`, `order`, etc... 
+
+# Filter using `where` method
+To retrieve all `Address` object where the fk reference to the `City` table, and the fk reference to the `Country` table have a `country_id` value greater or equal than 50, ordered in `descending` order, then:
+
+```python
+result = (
+    AddressModel(database)
+    .order(lambda a: a.address_id, order_type="DESC")
+    .where(lambda x: x.City.Country.country_id >= 50)
+    .select(lambda a: (a))
+)
+
+```
+Also you can use `ConditionType` enum for `regular expressions` and get, for example, all rows from a different table where the `Country` name starts with `A`, limited to `100`:
+
+
+```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]"))
+    .limit(100)
+    .select(
+        lambda a: (
+            a,
+            a.City,
+            a.City.Country,
+        )
+    )
+)
+
+
+for a in address:
+
+    print(a.address_id)
+
+for c in city:
+    print(c.city_id)
+
+for co in country:
+    print(co.country)
+```
+
+# Transform Table objects into Iterable object
+In the example above, we see that the `result` var returns a tuple of tuples. However, we can simplify the `result` var when needed by passing `flavour` attribute in `select` method to get a tuple of the specified data type.
+
+```python
+result = (
+    a_model
+    .where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[A]"))
+    .limit(100)
+    .select(
+        lambda a: (
+            a.address_id,
+            a.City.city_id,
+            a.City.Country.country_id,
+            a.City.Country.country,
+        ),
+        flavour=dict,
+    )
+)
+```
+
+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.
+
+

ormlambda-0.1.0.dist-info/RECORD

@@ -0,0 +1,70 @@
+ormlambda/__init__.py,sha256=nRG76yZWhrJVqckoYaej3wI2iN2uU--MvqI8Zx_SzWQ,242
+ormlambda/common/__init__.py,sha256=daEdpEyAJIa8b2VkCqSKcw8PaExcB6Qro80XNes_sHA,2
+ormlambda/common/abstract_classes/__init__.py,sha256=LZUlffEFZ98DO9MNlw2PloI4xR8Qf9WitIjafBmE9WQ,166
+ormlambda/common/abstract_classes/abstract_model.py,sha256=-n7Uu9lLQbRJPU7JQIG90HLFaKci3czeqH9ov90HVFY,12835
+ormlambda/common/abstract_classes/non_query_base.py,sha256=HCzvbiCiyIVIOwiFqDNf5HYatIG6XCWQs3_p6CaTrpw,879
+ormlambda/common/abstract_classes/query_base.py,sha256=kCGaYpdl4laekmRgtMnkJknsgC4D2BsXYKDj3aP2DvQ,194
+ormlambda/common/enums/__init__.py,sha256=cKLaRnQqrnywNnDZSvMab67pV3Bw2iqwEI-gyL7yrFE,102
+ormlambda/common/enums/condition_types.py,sha256=mDPMrtzZu4IYv3-q5Zw4NNgwUoNAx4lih5SIDFRn1Qo,309
+ormlambda/common/enums/join_type.py,sha256=iRtmY-Zw61jl8zI1Jax65CCqk2qPRjs_6UmiLOpY5F4,290
+ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
+ormlambda/common/interfaces/IQueryCommand.py,sha256=Ins6SufOqL2kAHe-l8f9Kv5NIg0TpqtwLt7Ci0zzpf0,331
+ormlambda/common/interfaces/IRepositoryBase.py,sha256=I05nCEFMoSRklnQt4fn8ase6YqNeS-qSxRPH_wqrB58,1859
+ormlambda/common/interfaces/IStatements.py,sha256=VBrVqqsqmaUinSgE11knMfRxZjSeBCwldjCsiBb5jm4,9124
+ormlambda/common/interfaces/__init__.py,sha256=Ane8WwjRFadOhoSRCbnphV4_SnE0jAE77DLj8ZZJaRg,243
+ormlambda/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=rLOWzKY1Mu-YMgOOU0DSV2XNIklkZCs5RlceZMxWB34,468
+ormlambda/components/insert/IInsert.py,sha256=MDiMFmePra9coEMWmEg5EUhxAIXLxZ9yX5uG-qP7Nl4,137
+ormlambda/components/insert/__init__.py,sha256=TGShCJZwejK3zZCRistBAKoDy2NNDRR_w1LXIbN66Dk,102
+ormlambda/components/insert/abstract_insert.py,sha256=9tKMmMgbQe8NwOisNnTHtiFN-4cwnLVO61v-EHwFiXc,602
+ormlambda/components/select/ISelect.py,sha256=MufLURuFjILvuidLQEI5Dx032cnHE2OaC0u2pQSlJRs,312
+ormlambda/components/select/__init__.py,sha256=BygaFGphVgGT0Zke4WhzdBQMUxevC34Qseok9qutaJE,95
+ormlambda/components/select/table_column.py,sha256=yseg5M1MEhzq3EER0Es8qvTWHik2OT3o7Hn1Nxs5QRA,1219
+ormlambda/components/update/IUpdate.py,sha256=PIt9ohoH0V02Wlsbg6mkwhS0vIrnRfWbuKg0EWK14RE,166
+ormlambda/components/update/__init__.py,sha256=QNl3V8Ygy6WlU2rGtwQD9TiT1vVVSceYNhx2BwsJglo,101
+ormlambda/components/update/abstract_update.py,sha256=AFIThy_qqLKqCEuC4NJ2sP9JuWHjvxXmZHCluMTPVEs,794
+ormlambda/components/upsert/IUpsert.py,sha256=2m6Bcwa0X80IDLnf0QErqr01uYEydOnRta9_T1nxjK4,139
+ormlambda/components/upsert/__init__.py,sha256=vfyfXrQILiExYo5lQ7dDNuOMhJ0mE9CVV0w3j1LaagE,101
+ormlambda/components/upsert/abstract_upsert.py,sha256=ISHdN_MTpmM24F-x6wZkKflE0WpadX9p82gr1abGeeA,592
+ormlambda/components/where/__init__.py,sha256=mI-ylB6cTTVf3rtCX54apgZrMP6y9tTD7-X3Ct0RFxw,56
+ormlambda/components/where/abstract_where.py,sha256=s4FDBJIXYzb9KfEg4ZpbnNkoGHLbK_JVJF0pIP87rQg,245
+ormlambda/databases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/databases/my_sql/__init__.py,sha256=3PbOp4WqxJzFOSRwBozqyNtQi25cLLdiJFPDzEnSI70,115
+ormlambda/databases/my_sql/clauses/__init__.py,sha256=1gAcmaajMmtIqTOXF6ibcPjKTuWkVKk9TM5OtrInmaE,650
+ormlambda/databases/my_sql/clauses/create_database.py,sha256=sZtr8PXuH2RVmpJZQAYm8giJKAhCGUj0nX1pND3IXD0,988
+ormlambda/databases/my_sql/clauses/delete.py,sha256=tjmMmGW7X2-4ai-15acT2VwygNExRAd0axzoHe6ksoA,1871
+ormlambda/databases/my_sql/clauses/drop_database.py,sha256=H4_CAl8lPXvW7UuYosg4MwZkGdi8AX_hQRD8PlQQE0E,517
+ormlambda/databases/my_sql/clauses/drop_table.py,sha256=0xZBUWuxhQpyKZ2c0JVys4gGbEdDu7YpFA-_SXsYmPw,604
+ormlambda/databases/my_sql/clauses/insert.py,sha256=2ZDN1lqR28t9Lu2l3IArxefYpn92Q9Bak6l5zxvGy1M,2790
+ormlambda/databases/my_sql/clauses/joins.py,sha256=M6Oj0T6at-zvG2UXO5pJ4bndtvgrBj0CucFppskh1sE,3037
+ormlambda/databases/my_sql/clauses/limit.py,sha256=sudJY2YLq33OA46iGGUuuappzz-kJUAwx8oVk7SCmxI,385
+ormlambda/databases/my_sql/clauses/offset.py,sha256=lRPfE198-j4X8gJUVzzrdUxKyOj9cY2vDY15qkFGUUY,389
+ormlambda/databases/my_sql/clauses/order.py,sha256=I80nCYk4Mf5O-kXWBa-gSdIOjn76j0nWTJx0PSqWtJo,1012
+ormlambda/databases/my_sql/clauses/select.py,sha256=hZKNMdUHL1JZJJB1KMzzU9KmwxkAqngzuWi1cz9giZI,6541
+ormlambda/databases/my_sql/clauses/update.py,sha256=1U9JrUOc0_aUkhcjYRWpS1b8BuDUHpootUAsh5to8jA,1873
+ormlambda/databases/my_sql/clauses/upsert.py,sha256=ecj3cqmBPczFca6QaZmSNDtk05UKPjn6Z4d0R3MZago,1957
+ormlambda/databases/my_sql/clauses/where_condition.py,sha256=SXdEDjYoeoNubb7Y07UV_UQQ_EeywPyqHsvBoH_yhrY,8290
+ormlambda/databases/my_sql/repository.py,sha256=rpBnciyYe6nTxZgjviTYGUK_YkDvJuTCw6j-LbF1Fn0,6479
+ormlambda/databases/my_sql/statements.py,sha256=IFnPRzYme8YyNiM3rumGP_1CzWiocZb8xF1QNq2DP5s,2086
+ormlambda/model_base.py,sha256=gEvGi7VH7aawmBU6a-V3pIWaWOs1grQ_gTBsrsC8DiQ,1071
+ormlambda/utils/__init__.py,sha256=ywMdWqmA2jHj19-W-S04yfaYF5hv4IZ1lZDq0B8Jnjs,142
+ormlambda/utils/column.py,sha256=ATyOUZ6cWYlvYQwlusVNYjV6A9aQn0T9CaKVUw52jDo,1941
+ormlambda/utils/dtypes.py,sha256=YTh9a3E3eZLECCXD_en1ufXV0gLVmLMS50haIdGt8Zw,7739
+ormlambda/utils/foreign_key.py,sha256=Y5mwzKXL_AjCbsV7rJ-O2rZ4SaIUjsrLl8XPjXksT7Y,1329
+ormlambda/utils/lambda_disassembler/__init__.py,sha256=_718I4R_ipYLYQ1I9nhrAcN0PzROrKluazH_Gu4S98c,228
+ormlambda/utils/lambda_disassembler/dis_types.py,sha256=D7kBFbHQJpQ5bpY30RSpNkLmITfpmblkHpnVBmt4yLo,4805
+ormlambda/utils/lambda_disassembler/disassembler.py,sha256=Zc_hFeEheCiBtFIo39F573uU3jkkB-VyA-wJGICqs44,2019
+ormlambda/utils/lambda_disassembler/dtypes.py,sha256=QtftGMCcb4arAQnXkwGQ1VeV-6x0mZdRTfZmxLkAtFo,6449
+ormlambda/utils/lambda_disassembler/name_of.py,sha256=Cjic_GzqgArxx7kDUMOGYmmNRHj7HcxG-kcDfAhA5yk,1142
+ormlambda/utils/lambda_disassembler/nested_element.py,sha256=nXwytOwBbPYSTMxksQTRMhSeqRIMpIcVWg70loVtQ_k,1234
+ormlambda/utils/lambda_disassembler/tree_instruction.py,sha256=ftt8QPSoGUZ3gYAK59y8SpiaumrvLExmp-lgwCeO9vk,5115
+ormlambda/utils/module_tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/utils/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkjptDbK3IugXm8iU,1425
+ormlambda/utils/module_tree/dynamic_module.py,sha256=PHUGfO7ENBRlUR1uP6R7g76YApLpvFzMKdWlJJ9vQLw,8468
+ormlambda/utils/table_constructor.py,sha256=hKiDDsSpVakFqL_QhIfmlvwXI91nb_KoPpPFway7NQ4,10881
+ormlambda-0.1.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-0.1.0.dist-info/METADATA,sha256=oWIgEhlInUj4bLF46UxkLfsGuPIKsqsUWhYxiAZsNcw,8205
+ormlambda-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-0.1.0.dist-info/RECORD,,

ormlambda-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any