ormlambda 3.35.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

ormlambda/__init__.py

@@ -1,59 +1,87 @@
-import ormlambda.env  # noqa: F401 Necesary to load all variables inside ormalambda.env
+# COMMENT: Necesary to load all variables inside ormalambda.env
+import ormlambda.env  # noqa: F401
 
 # region enums
-from .common.enums import (
-    JoinType as JoinType,
-    ConditionType as ConditionType,
-)
+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 (
-    Table as Table,
-    Column as Column,
-    ForeignKey as ForeignKey,
-)
+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 .statements import BaseStatement as BaseStatement
-from .statements.types import OrderType as OrderType
-from .model.base_model import (
-    BaseModel as BaseModel,
-    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, URL, make_url  # noqa: F401
-
-from .sql.sqltypes import (  # noqa: F401
-    JSON as JSON,
-    UUID as UUID,
-    NullType as NullType,
-    INTEGER as INTEGER,
-    INT as INT,
-    SMALLINTEGER as SMALLINTEGER,
-    BIGINTEGER as BIGINTEGER,
-    NUMERIC as NUMERIC,
-    FLOAT as FLOAT,
-    REAL as REAL,
-    DOUBLE as DOUBLE,
-    DECIMAL as DECIMAL,
-    STRING as STRING,
-    TEXT as TEXT,
-    UNICODE as UNICODE,
-    UNICODETEXT as UNICODETEXT,
-    CHAR as CHAR,
-    NCHAR as NCHAR,
-    BLOB as BLOB,
-    VARCHAR as VARCHAR,
-    NVARCHAR as NVARCHAR,
-    DATE as DATE,
-    TIME as TIME,
-    DATETIME as DATETIME,
-    TIMESTAMP as TIMESTAMP,
-    BOOLEAN as BOOLEAN,
-    LARGEBINARY as LARGEBINARY,
-    VARBINARY as VARBINARY,
-    ENUM as ENUM,
-    POINT as POINT,
-)
+
+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/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/common/abstract_classes/__init__.py

@@ -1,3 +1 @@
 from .non_query_base import NonQueryBase as NonQueryBase
-from .query_base import QueryBase as QueryBase
-from .decomposition_query import DecompositionQueryBase as DecompositionQueryBase

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/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/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/common/global_checker.py

@@ -1,28 +1,106 @@
 from __future__ import annotations
 import re
-from typing import Any, TYPE_CHECKING
+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 import Table
+    from ormlambda.sql.types import SelectCol  # FIXME [ ]: enhance the name
+    from ormlambda import TableProxy
+    from ormlambda.sql.column import ColumnProxy
 
 
-class GlobalChecker:
+# 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, obj: Any, tables: tuple[Table, ...]):
-        if not cls.is_lambda_function(obj):
-            return obj
+    def resolved_callback_object(cls, table: T, lambda_func: Callable[[T], Any]) -> tuple[SelectCol, ...]:
+        TableProxy = util.preloaded.sql_table.TableProxy
 
         try:
-            return obj(*tables)
+            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(tables), obj)
+                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/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/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/dialects/__init__.py

@@ -1,13 +1,83 @@
 from __future__ import annotations
-from typing import Callable, Optional, Type, TYPE_CHECKING
+from typing import Callable, Optional, Type, TYPE_CHECKING, ClassVar
+import abc
 from ormlambda import util
 import importlib
 
+
 if TYPE_CHECKING:
-    from .interface import Dialect
+    from ormlambda.caster.caster import Caster
+    from ormlambda.repository.interfaces.IRepositoryBase import DBAPIConnection
+    from ormlambda.sql.types import DDLCompiler, SQLCompiler, TypeCompiler
+    from ormlambda import BaseRepository
 
 
-__all__ = ("mysql", "sqlite")
+class Dialect(abc.ABC):
+    """
+    Abstract base class for all database dialects.
+    """
+
+    dbapi: Optional[DBAPIConnection]
+    """A reference to the DBAPI module object itself.
+
+    Ormlambda dialects import DBAPI modules using the classmethod
+    :meth:`.Dialect.import_dbapi`. The rationale is so that any dialect
+    module can be imported and used to generate SQL statements without the
+    need for the actual DBAPI driver to be installed.  Only when an
+    :class:`.Engine` is constructed using :func:`.create_engine` does the
+    DBAPI get imported; at that point, the creation process will assign
+    the DBAPI module to this attribute.
+
+    Dialects should therefore implement :meth:`.Dialect.import_dbapi`
+    which will import the necessary module and return it, and then refer
+    to ``self.dbapi`` in dialect code in order to refer to the DBAPI module
+    contents.
+
+    .. versionchanged:: The :attr:`.Dialect.dbapi` attribute is exclusively
+       used as the per-:class:`.Dialect`-instance reference to the DBAPI
+       module.   The previous not-fully-documented ``.Dialect.dbapi()``
+       classmethod is deprecated and replaced by :meth:`.Dialect.import_dbapi`.
+
+    """
+
+    name: ClassVar[str]
+    """The name of the dialect, e.g. 'sqlite', 'postgresql', etc."""
+    driver: ClassVar[str]
+    """The driver used by the dialect, e.g. 'sqlite3', 'psycopg2', etc."""
+
+    ddl_compiler: ClassVar[Type[DDLCompiler]]
+    """The DDL compiler class used by the dialect."""
+
+    statement_compiler: ClassVar[Type[SQLCompiler]]
+    """The statement compiler class used by the dialect."""
+
+    type_compiler_cls: ClassVar[Type[TypeCompiler]]
+    """The type compiler class used by the dialect."""
+
+    type_compiler_instance: ClassVar[TypeCompiler]
+    """The instance of the type compiler class used by the dialect."""
+
+    repository_cls: ClassVar[Type[BaseRepository]]
+    """The repository class used by the dialect."""
+
+    caster: ClassVar[Type[Caster]]
+
+    @classmethod
+    def get_dialect_cls(cls) -> Type[Dialect]:
+        return cls
+
+    @classmethod
+    @abc.abstractmethod
+    def import_dbapi(cls) -> DBAPIConnection:
+        """
+        Import the DB API module for the dialect.
+        This method should be implemented by subclasses to import the
+        appropriate DB API module for the dialect.
+        """
+        ...
+
+    def __repr__(self):
+        return f"{Dialect.__name__}: {type(self).__name__}"
 
 
 def _auto_fn(name: str) -> Optional[Callable[[], Type[Dialect]]]:
@@ -37,3 +107,5 @@ def _auto_fn(name: str) -> Optional[Callable[[], Type[Dialect]]]:
 
 
 registry = util.PluginLoader("ormlambda.dialects", auto_fn=_auto_fn)
+
+__all__ = ("mysql", "sqlite")

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/dialects/mysql/__init__.py

@@ -1,84 +1,41 @@
-from . import base
-from . import mysqlconnector
+from . import base as base
+from . import mysqlconnector as mysqlconnector
 
-from .base import BIGINT
-from .base import BINARY
-from .base import BIT
-from .base import BLOB
-from .base import BOOLEAN
-from .base import CHAR
-from .base import DATE
-from .base import DATETIME
-from .base import DECIMAL
-from .base import DOUBLE
-from .base import FLOAT
-from .base import INTEGER
-from .base import LONGBLOB
-from .base import LONGTEXT
-from .base import MEDIUMBLOB
-from .base import MEDIUMINT
-from .base import MEDIUMTEXT
-from .base import NCHAR
-from .base import NUMERIC
-from .base import NVARCHAR
-from .base import REAL
-from .base import SMALLINT
-from .base import TEXT
-from .base import TIME
-from .base import TIMESTAMP
-from .base import TINYBLOB
-from .base import TINYINT
-from .base import TINYTEXT
-from .base import VARBINARY
-from .base import VARCHAR
-from .base import YEAR
+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
 
 
-
-__all__ = (
-    "BIGINT",
-    "BINARY",
-    "BIT",
-    "BLOB",
-    "BOOLEAN",
-    "CHAR",
-    "DATE",
-    "DATETIME",
-    "DECIMAL",
-    "DOUBLE",
-    "ENUM",
-    "FLOAT",
-    "INET4",
-    "INET6",
-    "INTEGER",
-    "INTEGER",
-    "JSON",
-    "LONGBLOB",
-    "LONGTEXT",
-    "MEDIUMBLOB",
-    "MEDIUMINT",
-    "MEDIUMTEXT",
-    "NCHAR",
-    "NVARCHAR",
-    "NUMERIC",
-    "SET",
-    "SMALLINT",
-    "REAL",
-    "TEXT",
-    "TIME",
-    "TIMESTAMP",
-    "TINYBLOB",
-    "TINYINT",
-    "TINYTEXT",
-    "VARBINARY",
-    "VARCHAR",
-    "YEAR",
-    "dialect",
-    "insert",
-    "Insert",
-    "match",
-)
-
+from .repository import MySQLRepository as MySQLRepository  # noqa: F401
+from .caster import MySQLCaster as MySQLCaster  # noqa: F401
 
 # default dialect
 base.dialect = dialect = mysqlconnector.dialect