ormlambda 3.35.2__tar.gz → 4.0.0__tar.gz

{ormlambda-3.35.2 → ormlambda-4.0.0}/PKG-INFO

@@ -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-3.35.2 → ormlambda-4.0.0}/README.md

@@ -283,19 +283,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
@@ -309,14 +309,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,
                     )
                 ),
             ),
@@ -351,15 +351,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,
     )
@@ -374,12 +372,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,
     )
@@ -409,9 +407,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,
@@ -436,9 +434,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
         )
 ```
@@ -455,11 +453,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-3.35.2 → ormlambda-4.0.0}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.35.2"
+version = "4.0.0"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"

ormlambda-4.0.0/src/ormlambda/__init__.py

@@ -0,0 +1,87 @@
+# COMMENT: Necesary to load all variables inside ormalambda.env
+import ormlambda.env  # noqa: F401
+
+# region enums
+from .common.enums import JoinType as JoinType
+from .common.enums import ConditionType as ConditionType
+from .common.enums import OrderType as OrderType
+
+
+# endregion
+
+# region sql
+from .sql import Column as Column
+from .sql import ColumnProxy as ColumnProxy
+from .sql import Table as Table
+from .sql import ForeignKey as ForeignKey
+from .sql import TableProxy as TableProxy
+
+
+# endregion
+
+from .repository import BaseRepository as BaseRepository
+
+from .model.base_model import BaseModel as BaseModel
+from .model.base_model import ORM as ORM
+# COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
+
+from .engine import create_engine as create_engine
+from .engine import URL as URL
+from .engine import make_url as make_url
+
+from .sql.sqltypes import JSON as JSON
+from .sql.sqltypes import UUID as UUID
+from .sql.sqltypes import NullType as NullType
+from .sql.sqltypes import INTEGER as INTEGER
+from .sql.sqltypes import INT as INT
+from .sql.sqltypes import SMALLINTEGER as SMALLINTEGER
+from .sql.sqltypes import BIGINTEGER as BIGINTEGER
+from .sql.sqltypes import NUMERIC as NUMERIC
+from .sql.sqltypes import FLOAT as FLOAT
+from .sql.sqltypes import REAL as REAL
+from .sql.sqltypes import DOUBLE as DOUBLE
+from .sql.sqltypes import DECIMAL as DECIMAL
+from .sql.sqltypes import STRING as STRING
+from .sql.sqltypes import TEXT as TEXT
+from .sql.sqltypes import UNICODE as UNICODE
+from .sql.sqltypes import UNICODETEXT as UNICODETEXT
+from .sql.sqltypes import CHAR as CHAR
+from .sql.sqltypes import NCHAR as NCHAR
+from .sql.sqltypes import BLOB as BLOB
+from .sql.sqltypes import VARCHAR as VARCHAR
+from .sql.sqltypes import NVARCHAR as NVARCHAR
+from .sql.sqltypes import DATE as DATE
+from .sql.sqltypes import TIME as TIME
+from .sql.sqltypes import DATETIME as DATETIME
+from .sql.sqltypes import TIMESTAMP as TIMESTAMP
+from .sql.sqltypes import BOOLEAN as BOOLEAN
+from .sql.sqltypes import LARGEBINARY as LARGEBINARY
+from .sql.sqltypes import VARBINARY as VARBINARY
+from .sql.sqltypes import ENUM as ENUM
+from .sql.sqltypes import POINT as POINT
+
+
+from .sql.clauses import Alias as Alias
+from .sql.clauses import Count as Count
+from .sql.clauses import Delete as Delete
+from .sql.clauses import GroupBy as GroupBy
+from .sql.clauses import Insert as Insert
+from .sql.clauses import JoinSelector as JoinSelector
+from .sql.clauses import Limit as Limit
+from .sql.clauses import Offset as Offset
+from .sql.clauses import Order as Order
+from .sql.clauses import Select as Select
+from .sql.clauses import Where as Where
+from .sql.clauses import Having as Having
+from .sql.clauses import Update as Update
+from .sql.clauses import Upsert as Upsert
+
+from .sql.functions import Max as Max
+from .sql.functions import Min as Min
+from .sql.functions import Concat as Concat
+from .sql.functions import Sum as Sum
+
+
+from . import util as _util
+
+_util.import_prefix("ormlambda")

{ormlambda-3.35.2 → ormlambda-4.0.0}/src/ormlambda/caster/caster.py

@@ -62,4 +62,9 @@ class Caster(ICaster):
             column_type = type(value)
         else:
             column_type = type_value
-        return cls.CASTER_SELECTOR()[column_type](value, column_type)
+
+        caster_class = cls.CASTER_SELECTOR().get(column_type, None)
+        if not caster_class:
+            raise ValueError(f"'{column_type}' type has not a Caster class created.")
+
+        return caster_class(value, column_type)

ormlambda-4.0.0/src/ormlambda/common/abstract_classes/__init__.py

@@ -0,0 +1 @@
+from .non_query_base import NonQueryBase as NonQueryBase

{ormlambda-3.35.2 → ormlambda-4.0.0}/src/ormlambda/common/enums/__init__.py

@@ -1,2 +1,3 @@
 from .join_type import JoinType  # noqa: F401
 from .condition_types import ConditionType  # noqa: F401
+from .order_type  import OrderType  # noqa: F401

ormlambda-4.0.0/src/ormlambda/common/enums/order_type.py

@@ -0,0 +1,9 @@
+import enum
+
+
+class OrderType(str, enum.Enum):
+    def __str__(self):
+        return super().__str__()
+
+    ASC = "ASC"
+    DESC = "DESC"

{ormlambda-3.35.2 → ormlambda-4.0.0}/src/ormlambda/common/errors/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import inspect
 import typing as tp
 
+from ormlambda import util
 
 if tp.TYPE_CHECKING:
     from ormlambda.sql.clause_info import ClauseInfo
@@ -35,16 +36,25 @@ class AggregateFunctionError[T](Exception):
         agg_methods = self.__get_all_aggregate_method(self.clause)
         return f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'."
 
+    @util.preload_module("ormlambda.sql.clause_info")
     def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
         """
-        Get the class name of those classes that inherit from 'AggregateFunctionBase' class in order to create a better error message.
+        Get the class name of those classes that inherit from 'IAggregate' class in order to create a better error message.
         """
-        from ormlambda.sql.clause_info import AggregateFunctionBase
 
+        IAggregate = util.preloaded.sql_clause_info.IAggregate
         res: set[str] = set()
         if not isinstance(clauses, tp.Iterable):
             return clauses.__class__.__name__
         for clause in clauses:
-            if isinstance(clause, AggregateFunctionBase):
+            if isinstance(clause, IAggregate):
                 res.add(clause.__class__.__name__)
         return ", ".join(res)
+
+
+class NotCallableError(ValueError):
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def __str__(self)->str:
+        return f"You must provide a function or callable to proceed with the query creation. Passed '{self.args[0].__class__.__name__}' "

ormlambda-4.0.0/src/ormlambda/common/global_checker.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+import re
+from typing import Any, TYPE_CHECKING, Iterable, Callable
+
+from ormlambda.common.errors import UnmatchedLambdaParameterError
+from ormlambda.common.errors import NotCallableError
+from ormlambda import util
+
+if TYPE_CHECKING:
+    from ormlambda.sql.types import SelectCol  # FIXME [ ]: enhance the name
+    from ormlambda import TableProxy
+    from ormlambda.sql.column import ColumnProxy
+
+
+# type LambdaResponse[T] = TableProxy[T] | ColumnProxy[T] | Comparer
+class GlobalChecker[T: TableProxy]:
+    FIRST_QUOTE = "`"
+    END_QUOTE = "`"
+
+    @staticmethod
+    def is_lambda_function(obj: Any) -> bool:
+        return callable(obj) and not isinstance(obj, type)
+
+    @util.preload_module("ormlambda.sql")
+    @classmethod
+    def resolved_callback_object(cls, table: T, lambda_func: Callable[[T], Any]) -> tuple[SelectCol, ...]:
+        TableProxy = util.preloaded.sql_table.TableProxy
+
+        try:
+            table_proxy = TableProxy(table)
+
+            if not callable(lambda_func): 
+                raise NotCallableError(lambda_func)
+
+            if isinstance(lambda_func, Iterable):
+                # We hit that condition when trying to pass column or function dynamically into select clause.
+
+                # max_fn = Max(lambda x: x.Col1)
+                # min_fn = Min(lambda x: x.Col1)
+                # sum_fn = Sum(lambda x: x.Col1)
+                # result = self.model.select(
+                #     (
+                #         max_fn,
+                #         min_fn,
+                #         sum_fn,
+                #     ),
+                #     flavour=dict,
+                # )
+
+                response = []
+
+                for item in lambda_func:
+                    response.append(item)
+                return response
+
+            response = lambda_func(table_proxy)
+            result = []
+
+            if isinstance(response, str) or not isinstance(response, Iterable):
+                response = [response]
+
+            for item in response:
+                column = cls.parser_object(item, table)
+
+                result.extend(column)
+
+            return result
+
+        except TypeError as err:
+            cond1 = r"takes \d+ positional argument but \d+ were given"
+            cond2 = r"missing \d+ required positional arguments:"
+            if re.search(r"(" + f"{cond1}|{cond2}" + r")", err.args[0]):
+                raise UnmatchedLambdaParameterError(len(table), lambda_func)
+            raise err
+
+    @util.preload_module(
+        "ormlambda.sql.column",
+        "ormlambda.sql.table",
+        "ormlambda.sql.comparer",
+        "ormlambda.sql.column_table_proxy",
+    )
+    @staticmethod
+    def parser_object(item: Any, table: T) -> tuple[ColumnProxy, ...]:
+        ColumnProxy = util.preloaded.sql_column.ColumnProxy
+        Column = util.preloaded.sql_column.Column
+
+        TableProxy = util.preloaded.sql_table.TableProxy
+        Comparer = util.preloaded.sql_comparer.Comparer
+        FKChain = util.preloaded.sql_column_table_proxy.FKChain
+
+        if isinstance(item, TableProxy):
+            return item.get_columns()
+
+        if isinstance(item, str):
+            # If we got a string, probably means that it'll be an alias,
+            # so we'll want to avoid add string alias table to alias like  `address`.count
+            new_col = Column(dtype=str, column_name=item)
+            new_col.table = table
+            return [ColumnProxy(new_col, path=FKChain(table, None))]
+        if isinstance(item, Comparer):
+            return [item]
+
+        if isinstance(item, ColumnProxy):
+            return [item]
+
+        return [item]

{ormlambda-3.35.2 → ormlambda-4.0.0}/src/ormlambda/common/interfaces/IQueryCommand.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from abc import abstractmethod, ABC
+from abc import ABC
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 class IQuery(ABC):
     """Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
 
-    @abstractmethod
+    # @abstractmethod
     def query(self, dialect: Dialect, **kwargs) -> str: ...
 
     def __repr__(self) -> str:

{ormlambda-3.35.2 → ormlambda-4.0.0}/src/ormlambda/common/interfaces/__init__.py

@@ -1,5 +1,3 @@
-from .ICustomAlias import ICustomAlias as ICustomAlias
-from .IDecompositionQuery import IDecompositionQuery as IDecompositionQuery
 from .IJoinSelector import IJoinSelector as IJoinSelector
 from .INonQueryCommand import INonQueryCommand as INonQueryCommand
 from .IQueryCommand import IQuery as IQuery

ormlambda-3.35.2/src/ormlambda/dialects/interface/dialect.py → ormlambda-4.0.0/src/ormlambda/dialects/__init__.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
+from typing import Callable, Optional, Type, TYPE_CHECKING, ClassVar
 import abc
-from typing import ClassVar, Optional, Type, TYPE_CHECKING
+from ormlambda import util
+import importlib
 
 
 if TYPE_CHECKING:
@@ -76,3 +78,34 @@ class Dialect(abc.ABC):
 
     def __repr__(self):
         return f"{Dialect.__name__}: {type(self).__name__}"
+
+
+def _auto_fn(name: str) -> Optional[Callable[[], Type[Dialect]]]:
+    """default dialect importer.
+
+    plugs into the :class:`.PluginLoader`
+    as a first-hit system.
+
+    """
+    if "." in name:
+        dialect, driver = name.split(".")
+    else:
+        dialect = name
+        driver = "base"
+
+    try:
+        module = importlib.import_module(f"ormlambda.dialects.{dialect}")
+
+    except ImportError:
+        return None
+
+    if hasattr(module, driver):
+        module = getattr(module, driver)
+        return lambda: module.dialect
+    else:
+        return None
+
+
+registry = util.PluginLoader("ormlambda.dialects", auto_fn=_auto_fn)
+
+__all__ = ("mysql", "sqlite")

{ormlambda-3.35.2 → ormlambda-4.0.0}/src/ormlambda/dialects/default/base.py

@@ -1,4 +1,4 @@
-from ormlambda.dialects.interface import Dialect
+from ormlambda.dialects import Dialect
 from ormlambda.sql import compiler
 from typing import Optional, Any
 from types import ModuleType

ormlambda-4.0.0/src/ormlambda/dialects/mysql/__init__.py

@@ -0,0 +1,41 @@
+from . import base as base
+from . import mysqlconnector as mysqlconnector
+
+from .base import BIGINT as BIGINT
+from .base import BIT as BIT
+from .base import BLOB as BLOB
+from .base import BOOLEAN as BOOLEAN
+from .base import CHAR as CHAR
+from .base import DATE as DATE
+from .base import DATETIME as DATETIME
+from .base import DECIMAL as DECIMAL
+from .base import DOUBLE as DOUBLE
+from .base import FLOAT as FLOAT
+from .base import INTEGER as INTEGER
+from .base import LONGBLOB as LONGBLOB
+from .base import LONGTEXT as LONGTEXT
+from .base import MEDIUMBLOB as MEDIUMBLOB
+from .base import MEDIUMINT as MEDIUMINT
+from .base import MEDIUMTEXT as MEDIUMTEXT
+from .base import NCHAR as NCHAR
+from .base import NUMERIC as NUMERIC
+from .base import NVARCHAR as NVARCHAR
+from .base import REAL as REAL
+from .base import SMALLINT as SMALLINT
+from .base import TEXT as TEXT
+from .base import TIME as TIME
+from .base import TIMESTAMP as TIMESTAMP
+from .base import TINYBLOB as TINYBLOB
+from .base import TINYINT as TINYINT
+from .base import TINYTEXT as TINYTEXT
+from .base import VARBINARY as VARBINARY
+from .base import VARCHAR as VARCHAR
+from .base import YEAR as YEAR
+from .types import POINT as POINT
+
+
+from .repository import MySQLRepository as MySQLRepository  # noqa: F401
+from .caster import MySQLCaster as MySQLCaster  # noqa: F401
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect