ormlambda 3.35.2__py3-none-any.whl → 4.0.0__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.2.dist-info → ormlambda-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.35.2
+Version: 4.0.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
@@ -296,19 +296,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
@@ -322,14 +322,14 @@ response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain"))
             (
                 Address.address,
                 Address.City.city,
-                self.tmodel.concat(
+                Concat(lambda x:
                     (
                         "Address: ",
-                        Address.address,
+                        x.address,
                         " - city: ",
-                        Address.City.city,
+                        x.City.city,
                         " - country: ",
-                        Address.City.Country.country,
+                        x.City.Country.country,
                     )
                 ),
             ),
@@ -364,15 +364,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 +385,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),
         ),
         flavour=Response,
     )
@@ -422,9 +420,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,
@@ -449,9 +447,9 @@ As shown in the previous examples, setting the `execute` attribute to `True` all
 ```python
 result = AddressModel.select_one(
             lambda x: (
-                AddressModel.min(x.address_id),
-                AddressModel.max(x.address_id),
-                AddressModel.count(x.address_id),
+                Min(x.address_id),
+                Max(x.address_id),
+                Count(x.address_id),
             ),flavour=dict
         )
 ```
@@ -468,11 +466,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.0.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=z1e0DlToPZqMCxS3Y36P0lTBOWzhMMkla6k8IiCvYQo,4525
+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=tzDRfDJrzHCvgHWxHRhePrLi4GkOq651JBow8y-5NME,3575
+ormlambda/statements/interfaces/IStatements.py,sha256=ZAMvQA-TtGf9ghhcHVaLcKHeJtodPyTzLPsFw8dngO4,9888
+ormlambda/statements/interfaces/__init__.py,sha256=1EAWwBueWJ1lBG7pOAEae_Bqw6ww8s7Dnvq6LTUgUJM,51
+ormlambda/statements/query_builder.py,sha256=MUTBvdlHuX6ZScyEjk4-bc6KtmpCht31NcBM1ATTyzI,10730
+ormlambda/statements/statements.py,sha256=YXY-1nKONugKWWW3dPVjPJzFeTUcWFt0-hJpke7Oiw4,12250
+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.0.dist-info/AUTHORS,sha256=uWpOHaCPTOLbVkk5x9McoLwbgzSeCg7yILeDRyMGWGM,606
+ormlambda-4.0.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-4.0.0.dist-info/METADATA,sha256=Ts-rXOPpIPNWaXEpxVAIZobEw4CnmRUuV95AIJwm50A,13140
+ormlambda-4.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-4.0.0.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

ormlambda/common/abstract_classes/decomposition_query.py

@@ -1,141 +0,0 @@
-from __future__ import annotations
-import typing as tp
-from ormlambda import Table, Column
-
-from ormlambda.common.interfaces import IDecompositionQuery, ICustomAlias
-from ormlambda.sql.clause_info import IAggregate
-from ormlambda.sql.clause_info import ClauseInfo, AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-from ormlambda import ForeignKey
-from ormlambda.common.global_checker import GlobalChecker
-
-from ormlambda.sql.types import TableType, ColumnType
-from .clause_info_converter import (
-    ClauseInfoConverter,
-    ConvertFromAnyType,
-    ConvertFromForeignKey,
-    ConvertFromColumn,
-    ConvertFromIAggregate,
-    ConvertFromTable,
-)
-
-type TableTupleType[T, *Ts] = tuple[T:TableType, *Ts]
-type ValueType = tp.Union[
-    tp.Type[IAggregate],
-    tp.Type[Table],
-    tp.Type[str],
-    tp.Type[ICustomAlias],
-]
-
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
-    @tp.overload
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType]) -> None: ...
-    @tp.overload
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], context: ClauseContextType = ...) -> None: ...
-    @tp.overload
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str, context: ClauseContextType = ...) -> None: ...
-
-    def __init__(
-        self,
-        tables: tuple[TableType[T]],
-        columns: tuple[ColumnType],
-        alias_table: str = "{table}",
-        *,
-        context: ClauseContextType = ClauseInfoContext(),
-        dialect: Dialect,
-        **kwargs,
-    ) -> None:
-        self.kwargs = kwargs
-        self._tables: tuple[TableType[T]] = tables if isinstance(tables, tp.Iterable) else (tables,)
-
-        self._dialect = dialect
-        self._columns: tp.Callable[[T], tuple] = columns
-        self._all_clauses: list[ClauseInfo | AggregateFunctionBase] = []
-        self._context: ClauseContextType = context if context else ClauseInfoContext()
-        self._alias_table: str = alias_table
-        self.__clauses_list_generetor()
-
-    def __getitem__(self, key: str) -> ClauseInfo | AggregateFunctionBase:
-        for clause in self._all_clauses:
-            is_agg_function = isinstance(clause, AggregateFunctionBase)
-            is_clause_info = isinstance(clause, ClauseInfo)
-            if (is_agg_function and clause._alias_aggregate == key) or (is_clause_info and clause.alias_clause == key):
-                return clause
-
-    def __clauses_list_generetor(self) -> None:
-        # Clean self._all_clauses if we update the context
-        self._all_clauses.clear() if self._all_clauses else None
-
-        resolved_function = GlobalChecker.resolved_callback_object(self._columns, self.tables)
-
-        # Python treats string objects as iterable, so we need to prevent this behavior
-        if isinstance(resolved_function, str) or not isinstance(resolved_function, tp.Iterable):
-            resolved_function = (self.table,) if ClauseInfo.is_asterisk(resolved_function) else (resolved_function,)
-
-        for data in resolved_function:
-            if not isinstance(data, ClauseInfo):
-                values = self.__convert_into_ClauseInfo(data)
-            else:
-                values = [data]
-            self.__add_clause(values)
-
-        return None
-
-    def __convert_into_ClauseInfo[TProp](self, data: TProp) -> list[ClauseInfo[T]]:
-        """
-        A method that behaves based on the variable's type
-        """
-
-        def validation(data: TProp, type_: ValueType) -> bool:
-            is_valid_type: bool = isinstance(data, type) and issubclass(data, type_)
-            return isinstance(data, type_) or is_valid_type
-
-        VALUE_TYPE_MAPPED: dict[tp.Type[ValueType], ClauseInfoConverter[T, TProp]] = {
-            ForeignKey: ConvertFromForeignKey[T, Table],
-            Column: ConvertFromColumn[TProp],
-            IAggregate: ConvertFromIAggregate,
-            Table: ConvertFromTable[T],
-        }
-        classConverter = next((converter for obj, converter in VALUE_TYPE_MAPPED.items() if validation(data, obj)), ConvertFromAnyType)
-        self.kwargs.setdefault("dialect", self._dialect)
-        if "dialect" not in self.kwargs:
-            raise ValueError("You must specified 'dialect' variable")
-        return classConverter.convert(data, alias_table=self._alias_table, context=self._context, **self.kwargs)
-
-    def __add_clause[TTable: TableType](self, clauses: list[ClauseInfo[TTable]] | ClauseInfo[TTable]) -> None:
-        if not isinstance(clauses, tp.Iterable):
-            raise ValueError(f"Iterable expected. '{type(clauses)}' got instead.")
-
-        for clause in clauses:
-            self._all_clauses.append(clause)
-        return None
-
-    @property
-    def table(self) -> T:
-        return self.tables[0] if isinstance(self.tables, tp.Iterable) else self.tables
-
-    @property
-    def tables(self) -> T:
-        return self._tables
-
-    @property
-    def columns[*Ts](self) -> tp.Callable[[T], tuple[*Ts]]:
-        return self._columns
-
-    @property
-    def all_clauses(self) -> list[ClauseInfo[T]]:
-        return self._all_clauses
-
-    @property
-    def context(self) -> tp.Optional[ClauseInfoContext]:
-        return self._context
-
-    @context.setter
-    def context(self, value: ClauseInfoContext) -> None:
-        self._context = value
-        self.__clauses_list_generetor()
-        return None

ormlambda/common/abstract_classes/query_base.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-from abc import abstractmethod
-from typing import TYPE_CHECKING
-
-from ormlambda.common.interfaces import IQuery
-
-if TYPE_CHECKING:
-    from ormlambda import Table
-    from ormlambda.dialects import Dialect
-
-
-class QueryBase[T: Table](IQuery):
-    @property
-    @abstractmethod
-    def query(self, dialect: Dialect, **kwargs) -> str: ...

ormlambda/common/interfaces/ICustomAlias.py

@@ -1,7 +0,0 @@
-# from ormlambda.common.interfaces import IDecompositionQuery
-
-
-class ICustomAlias[T, *Ts]: ...
-
-
-# class ICustomAlias[T, *Ts](IDecompositionQuery[T, *Ts]): ...

ormlambda/common/interfaces/IDecompositionQuery.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-import abc
-import typing as tp
-
-
-if tp.TYPE_CHECKING:
-    # TODOH: Changed to avoid mysql dependency
-    from ormlambda.sql.clause_info import ClauseInfo, TableType
-    from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
-
-
-class IDecompositionQuery_one_arg[T: TableType]:
-    @property
-    @abc.abstractmethod
-    def table(self) -> T: ...
-
-    @property
-    @abc.abstractmethod
-    def context(self) -> tp.Optional[ClauseInfoContext]: ...
-
-    @context.setter
-    @abc.abstractmethod
-    def context(self) -> tp.Optional[ClauseInfoContext]: ...
-
-
-class IDecompositionQuery[T: TableType, *Ts](IDecompositionQuery_one_arg[T]):
-    @property
-    @abc.abstractmethod
-    def tables(self) -> tuple[*Ts]: ...
-
-    @property
-    @abc.abstractmethod
-    def all_clauses(self) -> list[ClauseInfo]: ...

ormlambda/databases/__init__.py

@@ -1,4 +0,0 @@
-from .my_sql import (
-    MySQLCaster as MySQLCaster,
-    MySQLRepository as MySQLRepository,
-)

ormlambda/databases/my_sql/__init__.py

@@ -1,3 +0,0 @@
-from mysql.connector import MySQLConnection  # noqa: F401
-from .repository import MySQLRepository  # noqa: F401
-from .caster import MySQLCaster  # noqa: F401