ormlambda 3.35.3__py3-none-any.whl → 4.0.4__py3-none-any.whl

ormlambda/util/preloaded.py

@@ -0,0 +1,80 @@
+from typing import Callable, TYPE_CHECKING
+import importlib
+
+type FuncType[T] = Callable[..., T]
+
+
+if TYPE_CHECKING:
+    from ormlambda.sql import table as _sql_table
+    from ormlambda.sql import column as _sql_column
+    from ormlambda.sql import comparer as _sql_comparer
+    from ormlambda.sql import column_table_proxy as _sql_column_table_proxy
+    from ormlambda.sql import foreign_key as _sql_foreign_key
+    from ormlambda.sql import clause_info as _sql_clause_info
+    from ormlambda.sql import sqltypes as _sql_sqltypes
+    from ormlambda.sql import clauses as _sql_clauses
+    from ormlambda.sql import type_api as _sql_type_api
+
+    sql_column = _sql_column
+    sql_table = _sql_table
+    sql_comparer = _sql_comparer
+    sql_column_table_proxy = _sql_column_table_proxy
+    sql_foreign_key = _sql_foreign_key
+    sql_clause_info = _sql_clause_info
+    sql_types = _sql_sqltypes
+    sql_clauses = _sql_clauses
+
+    sql_type_api = _sql_type_api
+
+class ModuleRegistry:
+    """Registry of modules to load in a package init file.
+
+    To avoid potential thread safety issues for imports that are deferred
+    in a function, like https://bugs.python.org/issue38884, these modules
+    are added to the system module cache by importing them after the packages
+    has finished initialization.
+
+    A global instance is provided under the name :attr:`.preloaded`. Use
+    the function :func:`.preload_module` to register modules to load and
+    :meth:`.import_prefix` to load all the modules that start with the
+    given path.
+
+    While the modules are loaded in the global module cache, it's advisable
+    to access them using :attr:`.preloaded` to ensure that it was actually
+    registered. Each registered module is added to the instance ``__dict__``
+    in the form `<package>_<module>`, omitting ``sqlalchemy`` from the package
+    name. Example: ``sqlalchemy.sql.util`` becomes ``preloaded.sql_util``.
+    """
+
+    def __init__(self, prefix="ormlambda."):
+        self.module_registry: set[str] = set()
+        self.prefix: str = prefix
+
+    def preload_module[T, **P](self, *deps: str) -> Callable[P, T]:
+        """Adds the specified modules to the list to load.
+
+        This method can be used both as a normal function and as a decorator.
+        No change is performed to the decorated object.
+        """
+        self.module_registry.update(deps)
+        return lambda fn: fn
+
+    def import_prefix(self, path: str) -> None:
+        """Resolve all the modules in the registry that start with the
+        specified path.
+        """
+        for module in self.module_registry:
+            if self.prefix:
+                key = module.split(self.prefix)[-1].replace(".", "_")
+            else:
+                key = module
+
+            if (not path or module.startswith(path)) and key not in self.__dict__:
+                _module = importlib.import_module(module)
+                self.__dict__[key] = globals()[key] = _module
+        return None
+
+
+_reg = ModuleRegistry()
+preload_module = _reg.preload_module
+import_prefix = _reg.import_prefix

ormlambda/util/typing.py

@@ -1,6 +1,15 @@
-import typing as tp
 import typing_extensions as tpe
+from typing import Any, Literal, Type, NewType, get_origin, TypeGuard, TypeAliasType
 
-LITERAL_TYPES = frozenset([tp.Literal, tpe.Literal])
 
-type _AnnotationScanType = tp.Type[tp.Any] | str | tp.NewType
+LITERAL_TYPES = frozenset([Literal, tpe.Literal])
+
+type _AnnotationScanType = Type[Any] | str | NewType
+
+
+def is_literal(type_: Any) -> bool:
+    return get_origin(type) in LITERAL_TYPES
+
+
+def is_pep695(type_: _AnnotationScanType) -> TypeGuard[TypeAliasType]:
+    return isinstance(type_, TypeAliasType)

{ormlambda-3.35.3.dist-info → ormlambda-4.0.4.dist-info}/METADATA

@@ -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-4.0.4.dist-info/RECORD

@@ -0,0 +1,139 @@
+ormlambda/__init__.py,sha256=RmBuEDu4a6i8JcShsG-CWFVFhruc-YKz4_Fo5VYrcPQ,3053
+ormlambda/caster/__init__.py,sha256=lXzW6TJwgtyFTaBhKBETyGIxEje005S3SPg7PXnYEVQ,137
+ormlambda/caster/base_caster.py,sha256=c3vCGoKDyJ39kfUiS7sNKhKdjBRYSK1Ie88lwDIXqgE,1774
+ormlambda/caster/caster.py,sha256=qOKgNkoZQqTruNfSGLU0h7V-mZA19KY0uhRzjS6EGxc,2616
+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=iXhV9U5e8HIis4IhiF_w5fyAAdJclZDUGRJBkZA_AyM,57
+ormlambda/common/abstract_classes/non_query_base.py,sha256=eLXAprXVjVk2sFF8X8EK0UKoOQpgxBlDRn8prLzjr30,1201
+ormlambda/common/enums/__init__.py,sha256=daxD_1Xmrg3txPpzkvdy_VLEbiGPgnD336hMz4nvd0E,151
+ormlambda/common/enums/condition_types.py,sha256=QZnhhlTwzLcZ9kkmG6a08fQjUUJsJ5XGAH7QCiJRL1A,330
+ormlambda/common/enums/join_type.py,sha256=EosZVnvAc72LlZHuICIgoKWwUJzhvWOIIAohcbDYPQo,354
+ormlambda/common/enums/order_type.py,sha256=MOwMIUWn8H-3_BmMpEHcxUK7KNkVlmxrTBfp6etdF44,138
+ormlambda/common/errors/__init__.py,sha256=27NGxp4I4wqhn-TIT9e97IlGb7Blx9RTCFrY8CgACRM,2316
+ormlambda/common/global_checker.py,sha256=l_kN9mejC9kz5xyTEnrJ6adXDLW47cDofJfS9ATHFTI,3634
+ormlambda/common/interfaces/IJoinSelector.py,sha256=-w-MJmwq65tpDLtigWSLgvAqeOl75DA-EyWIugNkfCs,490
+ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
+ormlambda/common/interfaces/IQueryCommand.py,sha256=PKkAI1SE6U7kcbqFgQsdTQ3asIx-gIp5RDXYlBfANJk,461
+ormlambda/common/interfaces/__init__.py,sha256=-qIJf5fBX0y0vq_O7YjImWFimbj5pqONzK8udH2CMX4,169
+ormlambda/dialects/__init__.py,sha256=-WM-PqZXgZ_-3KWWLSNrPV12FhvVbo_v8Ul3XCUjs0o,3536
+ormlambda/dialects/default/__init__.py,sha256=N1B0LKEDu7r2-mTF9mBA4ReyhYeDuJDnbQCiH4hJvFQ,33
+ormlambda/dialects/default/base.py,sha256=Xle5kD_wi94NiPnkShi5LJbe5M1k8hq_XhU_PZ-iFbs,1078
+ormlambda/dialects/mysql/__init__.py,sha256=DwoefrtyJUivg7z4QS4K2k0DrUu04ItC5LJcDQEYZWg,1398
+ormlambda/dialects/mysql/base.py,sha256=BDEoWUpGB7ss6ZpzZzu8gMUCM33N_pwYgNbh5tmQ30A,21493
+ormlambda/dialects/mysql/caster/__init__.py,sha256=Df2sdZaAJ1Mi5Ego0sILMk5pF1NbK-nlV0hbpzd0PWE,47
+ormlambda/dialects/mysql/caster/caster.py,sha256=G2CDqkrmsxFrHe_nDOmqqrTA_3O2o6gIIfukqPeHmJs,1021
+ormlambda/dialects/mysql/caster/types/__init__.py,sha256=BmtHuVvKGPIOCjVuqQZgtGBMnx15YnGBaBi4r3Hd-3U,587
+ormlambda/dialects/mysql/caster/types/boolean.py,sha256=EYOxnR7-XU30UYZbBbMH4pyynTw5CPU1G8V5xpCthg4,1100
+ormlambda/dialects/mysql/caster/types/bytes.py,sha256=Mzl5oI2q6hGL9TFrTS-Ae1olQlAVtvNoxTSLUSBb5v8,1026
+ormlambda/dialects/mysql/caster/types/date.py,sha256=8usP1Af7WUzEC8BHOBL16Zjg9j-ipMlb42p0UTFELmg,1176
+ormlambda/dialects/mysql/caster/types/datetime.py,sha256=ISzcsbwijTa2wC9ZD8zy5piRm9BdnT9GxkMNf4FQYug,1189
+ormlambda/dialects/mysql/caster/types/decimal.py,sha256=ycQnSqO-aFkrcsa8JKVPdnfjotNL_BUFeScYRcueOWM,1068
+ormlambda/dialects/mysql/caster/types/float.py,sha256=EbU6J3yoL5_naLowfibkfUC9Bk9WzDaWks7lJ2pNhyA,1026
+ormlambda/dialects/mysql/caster/types/int.py,sha256=a30xbe0LNj2BvbtLNZhUXFvT3WJ115MFsHC19Y3NLTk,1016
+ormlambda/dialects/mysql/caster/types/iterable.py,sha256=S7pEAJ_NaxZqYhJAXwaJBS_zrbSz9J2yiYPpmDHATso,1057
+ormlambda/dialects/mysql/caster/types/json.py,sha256=AR7D6CEgyK3zAEijyNO1AuWtLBgC7KTj-YNEWkyilkg,1042
+ormlambda/dialects/mysql/caster/types/none.py,sha256=Bl4jpVVyoLG7ehoCAYj9lFBZbRWbyDN8QsQeWmIb84I,948
+ormlambda/dialects/mysql/caster/types/point.py,sha256=GHAf51kE0AS7wOlCYM9YW-z2ZbmY8hXwcHs979ZCeaY,1442
+ormlambda/dialects/mysql/caster/types/string.py,sha256=WFjTC5phuJ_-ShuokndFbqGuFgGZZx9GbpozH4rlB2g,1017
+ormlambda/dialects/mysql/clauses/ST_AsText.py,sha256=CC9mAAWtU8Vw79Un1ZjQHljsFqaBIW2GHAsoZfn6RO8,726
+ormlambda/dialects/mysql/clauses/ST_Contains.py,sha256=Oexez4rYLTlmWb1sKj4ZVolUqK8BRvgdj2sX3ROVIOc,737
+ormlambda/dialects/mysql/clauses/__init__.py,sha256=n5MMwLhDypwXIJyZd-ggPt8GbTxozIAUfzu5wObbQn0,46
+ormlambda/dialects/mysql/mysqlconnector.py,sha256=DOjK7U7LOhjuVQJULzAV8xaRGX0OlBU8APUeRiTcbDY,1378
+ormlambda/dialects/mysql/repository/__init__.py,sha256=yX1XIaVD8U2JT0nliQpcDQGPutXyhmeJnpI_4ZUxapM,53
+ormlambda/dialects/mysql/repository/pool_types.py,sha256=6c7LMS1VGR8ko1LB1T8DQzn1l10Mzk8PfIeYEOb9w30,1839
+ormlambda/dialects/mysql/repository/repository.py,sha256=-LwEWRvyq6_DDmWD2sWiH9x12x0RUDmH94ZID1Xyvac,7067
+ormlambda/dialects/mysql/types.py,sha256=oQUQiriHhmubmfBdJvhRhcq5zyFqJshbqSktvmxlGR8,23671
+ormlambda/dialects/sqlite/__init__.py,sha256=2EMmxD7ORtGoD18GJ_9aC_tPutAq9ormMZJmaJ5nkYA,103
+ormlambda/dialects/sqlite/base.py,sha256=24LSB461yQDEnXa-TsQt_srJmBCAR6M6419pa40CL_4,1503
+ormlambda/dialects/sqlite/pysqlite.py,sha256=dZY0NV2IvSTk3DNEDyncstmIABKj3M2xfmhf2dc2zQs,680
+ormlambda/engine/__init__.py,sha256=JpCLfuW1zcJi4ki97ajXh0aQxMSvWBKzDlBZx9ZVF9o,132
+ormlambda/engine/base.py,sha256=f60O6CLzB7rFBtw7XNxaEw0BccruROzRR-vXBUMcYgQ,2621
+ormlambda/engine/create.py,sha256=caDYXX4BP5uODSrdJXRZvWWjbliDgH1TiSvhtHP3RNY,533
+ormlambda/engine/url.py,sha256=ZzdgZU_Cnjhonbbr5OfBvq_ThUPnDj9v-3-7O54ENm0,26137
+ormlambda/engine/utils.py,sha256=fFoiKsiFuLcjcBVYNebVoYnMrEj3aZdoxEVSNfCY-GM,522
+ormlambda/env.py,sha256=rCZKT2rpvRF3hPtkLmtiaVAIxQ0xj8tF7ZKJpFp7BkA,736
+ormlambda/errors.py,sha256=ltLR52g3fnUTjrDC_x_R9-b5LlLjC6bVACnOoc9-OZg,839
+ormlambda/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/model/base_model.py,sha256=lhtJWiGXiRWLOxsuPg0PPr53shhreMy69Ps2-7dYU7U,739
+ormlambda/repository/__init__.py,sha256=4KAhKn6vWV7bslewvGMNqbbbUnz1DLnH4yy-M5QNAQA,112
+ormlambda/repository/base_repository.py,sha256=SW7VsbNddIY8-ALIGYcLlj4tFAoPSepeQpFvDNMOWpg,1252
+ormlambda/repository/interfaces/IDatabaseConnection.py,sha256=pxczjx0b53yjjg5hvVDloMgUTFDahVC3HlJLQjo9_1w,283
+ormlambda/repository/interfaces/IRepositoryBase.py,sha256=jTlViARH5SWIcYXstmXhttvNOShJ5mmAbTEmfGLiRuA,3527
+ormlambda/repository/interfaces/__init__.py,sha256=t8Mn0aRZm8uF4MGaqjEANTTADCdOwNF0THZ_qebyzwo,126
+ormlambda/repository/response.py,sha256=ZCV3joh_IMtcAHR_JIhbOudRT5ejPyXBFrHsTJoTz9o,4729
+ormlambda/sql/__init__.py,sha256=C5tpRVPZFnk8h1GSUkAM83u0M-IiOWtxrQSzD5DFZYU,211
+ormlambda/sql/clause_info/__init__.py,sha256=tbDXMGPjIc1e4YpBycjmyh8gRFgqZLva6sH-9awsni4,98
+ormlambda/sql/clause_info/clause_info.py,sha256=OnVyjDcisJK7-exFCgk7xqyXFGMTBMxzIXEg8RF56DI,14107
+ormlambda/sql/clause_info/interface/IAggregate.py,sha256=wdaNxhRYrHqwknljvTEus5PDkt9MD0eufBmphFqsH-8,429
+ormlambda/sql/clause_info/interface/IClauseInfo.py,sha256=vPJWSi6ojSIc931Z8BTYFHkFbSYpEiD5oIdtLby3fBc,820
+ormlambda/sql/clause_info/interface/__init__.py,sha256=bTNYVMPuJebEvQpPa5LBQaAesGnfljQ8BKsj1UxN09k,100
+ormlambda/sql/clauses/__init__.py,sha256=9bkgw3jbd2HdB-WGQtpyHLr0K-SbCZcBU7KmHur7k1c,572
+ormlambda/sql/clauses/alias.py,sha256=EywUwSYTWFOptTEnJ3O6UqLw4IJyd7XXumPM4djbegU,340
+ormlambda/sql/clauses/count.py,sha256=MpbnfNRiylDlL93d25s6XEqCMfgME6lZwF9H4A5iRv0,1034
+ormlambda/sql/clauses/delete.py,sha256=tTSCcSD_F-z9rl4HwfJOeb_M_XJlg-LkyU3f6vVQNTc,2289
+ormlambda/sql/clauses/group_by.py,sha256=wCPCBnre_XR93L_8_alnxOh8PqXyxr8hbZom373EiFo,569
+ormlambda/sql/clauses/having.py,sha256=yvWKUxLPVBzbmI0D-dAkbRXkkEPa365TKQuAmov91XI,360
+ormlambda/sql/clauses/insert.py,sha256=QwY_-StS7yzwoFLvvJQAG2mTx7luxyFk6j26Kwv9HCA,3832
+ormlambda/sql/clauses/interfaces/IDelete.py,sha256=06ZEdbKBxsHSwsGMBu0E1om4WJjojZAm-L3b95eQrcc,139
+ormlambda/sql/clauses/interfaces/IInsert.py,sha256=YIfMPlKu7UGgnVpZuhpr0Mtnefe-O85hqk8-GZrVK7w,139
+ormlambda/sql/clauses/interfaces/IUpdate.py,sha256=U-3Wx8lyCglhxf9gCXWO3MVgydG6gfRpzp00_MHC5cU,168
+ormlambda/sql/clauses/interfaces/IUpsert.py,sha256=2m6Bcwa0X80IDLnf0QErqr01uYEydOnRta9_T1nxjK4,139
+ormlambda/sql/clauses/interfaces/__init__.py,sha256=amGsD84C2torwyZMMknv2GBuA2W16DB3HTuhAGIpYds,172
+ormlambda/sql/clauses/join/__init__.py,sha256=7hwAB-nKaMirTT6uNZ1JtYNkkIx5zMSa6jaqr28d8Cg,67
+ormlambda/sql/clauses/join/join_context.py,sha256=I3Z8l0EoDwVb6EnFacm7o2lkAPgzuYxP5mNhih78aSQ,3096
+ormlambda/sql/clauses/joins.py,sha256=Lt0KbKC7aOFPzkerB2TUHsUKOdIsbCkIJCMktEn_XaA,4295
+ormlambda/sql/clauses/limit.py,sha256=h3WuF4QV5_Pns3r7MzfZn_QtINdq6CEiCh30LLaeWKY,315
+ormlambda/sql/clauses/offset.py,sha256=dGUVDUvvaLQJov8vYwImhwKgHjwud5eViRYs-kcvAtA,318
+ormlambda/sql/clauses/order.py,sha256=Zpl_XxVViURrwl4LFw3ldvCh0OeGVjvGIPYurHQ8S9Q,1438
+ormlambda/sql/clauses/select.py,sha256=-tViA_6Z-7WFJaILnUdX8AUmcwEarrO2e2HkGeIzRTg,2193
+ormlambda/sql/clauses/update.py,sha256=LM6Cb9A31O93IvOxL80NLZuKPr9xFt65BpYejbqQKj8,3072
+ormlambda/sql/clauses/upsert.py,sha256=1MlHSzIVXSnCnXx_0HqX_-JT1FAxaIKHImrv-OKjnWU,2250
+ormlambda/sql/clauses/where.py,sha256=QRYuBstzVG0nlI87USE_hJyCqzSkZSwq7aSA0OAItbE,1255
+ormlambda/sql/column/__init__.py,sha256=v5zXftkrFqpZeXVu_jtHKWHdmDYALVQelmxt52Fvs5E,93
+ormlambda/sql/column/column.py,sha256=DLmfInvrdqMESy3C3zA_nY2-SSfk5iXzxtncy_lX-Pw,8352
+ormlambda/sql/column/column_proxy.py,sha256=lyNmMIo-1j-bmwOofWas03H7_LKTzcYxEZyqsbR7WCM,4006
+ormlambda/sql/column_table_proxy.py,sha256=h-cCakQjtHnrnO9NY_6oq0xOMH3fnNAvMeIDfd29ci8,450
+ormlambda/sql/comparer.py,sha256=VUaS81ikBrK_R5rk5GgVqjWg_JzYgXtWmfGip1NFMzk,3967
+ormlambda/sql/compiler.py,sha256=KaKiuAmuCluqWGQ69vYnm9laMBn1gmoIBtUULqNUuHA,22233
+ormlambda/sql/context/__init__.py,sha256=0PkoZ0nk4dxw1275cyAEhlOHHE6jgyg7BrJJ_P1hG4E,10256
+ormlambda/sql/ddl.py,sha256=LqIOLl5bfyyw07U96e6FQMbyQBbv7SjLd0uDc1gJpf8,1916
+ormlambda/sql/elements.py,sha256=ijZiwi_CxSvr4LlgUJwTcyCDy28SZOsquNAQh6XKpd4,1016
+ormlambda/sql/foreign_key.py,sha256=yaL8E7IOTm3OFChoWTsA4cQcMux6SdNiUzoGFaKy0Sk,4242
+ormlambda/sql/functions/__init__.py,sha256=IDXpolE397LcpyYBvQ_r7QOa69cE5sk7FXPykt7XQk4,121
+ormlambda/sql/functions/concat.py,sha256=78PhV9PBzlo7vRTOhZgZUoOR8-1aI_dexc_DFphHOtI,1291
+ormlambda/sql/functions/max.py,sha256=TAoFIwfdA9m_Ml5xknDhDayHpnwAw5yxxGVIlEV6v0o,570
+ormlambda/sql/functions/min.py,sha256=Q4_ZiyKOPdmE8pbBxO-EoCKTrqpc6cQk3yiWVw1pUzc,570
+ormlambda/sql/functions/sum.py,sha256=pEN_Qxs5O9ANZlrYA0nN7qOZG7lUAWMu-jvYQSYGwLM,571
+ormlambda/sql/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/sql/sqltypes.py,sha256=17ed054oGuDW9xvoA9fUggkcIj6z7XBWGRwkNI95nxo,14503
+ormlambda/sql/table/__init__.py,sha256=ArH07tGHpC6uS4A4p63FdxbWufGQ0aM6TVnWLvTK62M,100
+ormlambda/sql/table/fields.py,sha256=ovNR3bJ473aKW-2NhbKr0iJlVpgW06jurHLob2IyZU8,2116
+ormlambda/sql/table/table.py,sha256=V0l1sCfqER-f4wEqGtLQdRld_MJ6fCU9vyP_KdWYOC4,5980
+ormlambda/sql/table/table_constructor.py,sha256=c3Z-1El0onSClYBmAatoUBYUOT70tITVqtsDJMxZ9QU,1092
+ormlambda/sql/table/table_proxy.py,sha256=pYASl4GOUcJRrdhEDCo1wFRMvPWZS8Fg43qWfBV0qQo,2931
+ormlambda/sql/type_api.py,sha256=nR5NruI6kUHefcyjqmV_uxy3dM3McCWv3THg2NxXJH8,1217
+ormlambda/sql/types.py,sha256=A1HI8HrANruuAPIfl7dbbTYx3l-SvuUbPrhlzK5SZ6w,1019
+ormlambda/sql/visitors.py,sha256=AHXxCEOME8-b_-YhFEzBv-Jd15vSoX5F-jEGrPPNRLE,2052
+ormlambda/statements/__init__.py,sha256=9IzRSVl-ZXD4D4RrrPIifOhyO0iXSpRS5ZwvVJeAW_0,49
+ormlambda/statements/base_statement.py,sha256=M8h2IqMl3vQWGzjHftx0zMzp12FfOFktu1GLsj1KLpI,2741
+ormlambda/statements/interfaces/IStatements.py,sha256=wTYEj8mBR21sU60ZMlHzaQehTy-knrqp3GT6n6l6HMU,9875
+ormlambda/statements/interfaces/__init__.py,sha256=1EAWwBueWJ1lBG7pOAEae_Bqw6ww8s7Dnvq6LTUgUJM,51
+ormlambda/statements/query_builder.py,sha256=MUTBvdlHuX6ZScyEjk4-bc6KtmpCht31NcBM1ATTyzI,10730
+ormlambda/statements/statements.py,sha256=U638djJtOu8qIMNlNOhJXktkFaV-cIhTsaBqy_S19h8,12091
+ormlambda/statements/types.py,sha256=Qh91CB3tzrqsxsPixib7w6KLRr6zY26pHXAna6MaDm8,885
+ormlambda/types/__init__.py,sha256=xVFaIMcfJvbbXs8BAvmBh8FwSiLn2R6yjZs9o-h08XM,323
+ormlambda/types/metadata.py,sha256=93eJItdVDOItf7YRJUVmN_m79WLa3Ge6I414ewYnKeM,624
+ormlambda/util/__init__.py,sha256=qWD74xQtWGxa5HCuRX1VxUnRrJ8Q5WxGo3R4_xpuRM8,349
+ormlambda/util/langhelpers.py,sha256=84JqxrH6fEE3FbQxy-Vc-C1TofIc5yuIkZT8HxS94o8,3284
+ormlambda/util/module_tree/__init__.py,sha256=LNQtqkwO1ul49Th3aHAIiyt0Wt899GmXCc44Uz1eDyY,53
+ormlambda/util/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkjptDbK3IugXm8iU,1425
+ormlambda/util/module_tree/dynamic_module.py,sha256=SQ1FZW2Es5CdACD0VS8v_UZQTuFYbUWs6diAtMbKMoA,8699
+ormlambda/util/preloaded.py,sha256=1D7t25qPjhW44nRez4Sd40gLjrl6BctLhPfPsK6Dx5g,3064
+ormlambda/util/typing.py,sha256=py6FbOLvnuByR8IHgKIIReFM0efX6Bzz-Ick9fx-nuw,423
+ormlambda-4.0.4.dist-info/AUTHORS,sha256=uWpOHaCPTOLbVkk5x9McoLwbgzSeCg7yILeDRyMGWGM,606
+ormlambda-4.0.4.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-4.0.4.dist-info/METADATA,sha256=q-8Wzvr-9NpPcQKKsrh4-QBaxSIHDtpygG8bgmcZhxo,12466
+ormlambda-4.0.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-4.0.4.dist-info/RECORD,,

ormlambda/common/abstract_classes/clause_info_converter.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-import typing as tp
-from ormlambda import Table
-
-from ormlambda.sql.clause_info import ClauseInfo, AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-from ormlambda import ForeignKey
-
-from ormlambda.sql.types import AliasType, TableType, ColumnType
-
-
-class ClauseInfoConverter[T, TProp](tp.Protocol):
-    @classmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]: ...
-
-
-class ConvertFromAnyType(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
-        return [ClauseInfo[None](table=None, column=data, alias_table=alias_table, alias_clause=kwargs.get("alias", None), context=context, **kwargs)]
-
-
-class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
-    @classmethod
-    def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[RT]]:
-        return ConvertFromTable[RT].convert(data.tright, data.get_alias(kwargs["dialect"]), context, **kwargs)
-
-
-class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
-    @classmethod
-    def convert(cls, data: ColumnType[TProp], alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
-        # COMMENT: if the property belongs to the main class, the columnn name in not prefixed. This only done if the property comes from any join.
-        attributes = {
-            "table": data.table,
-            "column": data,
-            "alias_table": alias_table,
-            "alias_clause": "{table}_{column}",
-            "context": context,
-        }
-        attributes.update(**kwargs)
-        clause_info = ClauseInfo(**attributes)
-        return [clause_info]
-
-
-class ConvertFromIAggregate(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: AggregateFunctionBase, alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
-        return [data]
-
-
-class ConvertFromTable[T: Table](ClauseInfoConverter[T, None]):
-    @classmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]:
-        """
-        if the data is Table, means that we want to retrieve all columns
-        """
-        return cls._extract_all_clauses(data, alias_table, context, **kwargs)
-
-    @staticmethod
-    def _extract_all_clauses(table: TableType[T], alias_table: AliasType[ColumnType], context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[TableType[T]]]:
-        # all columns
-        column_clauses = []
-        for column in table.get_columns():
-            column_clauses.extend(ConvertFromColumn.convert(column, alias_table=alias_table, context=context, **kwargs))
-        return column_clauses