ormlambda 4.4.0__tar.gz → 4.4.4__tar.gz

{ormlambda-4.4.0 → ormlambda-4.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 4.4.0
+Version: 4.4.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

{ormlambda-4.4.0 → ormlambda-4.4.4}/pyproject.toml

@@ -1,9 +1,6 @@
-[tool.ruff]
-line-length = 320
-
 [tool.poetry]
 name = "ormlambda"
-version = "4.4.0"
+version = "4.4.4"
 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"
@@ -21,8 +18,27 @@ ruff = "^0.4.5"
 parameterized = "^0.9.0"
 pydantic = "^2.11.1"
 sqlserver = "^0.0.17.1"
+pytest = "^8.4.2"
+
+[tool.ruff]
+line-length = 320
 
+[tool.pytest.ini_options]
+testpaths = ["src/test"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-v",                    # verbose output
+    "--strict-markers",      # error on unknown markers
+    "--tb=short",           # shorter traceback format
+]
+
+markers = [
+    "slow: Slow test (deselect with '-m \"not slow\"')",
+]
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/__init__.py

@@ -80,4 +80,16 @@ from .sql import functions as functions
 from .sql.functions import *  # noqa: F403
 from . import util as _util
 
+
+from .sql.column.metadata import PrimaryKey as PrimaryKey
+from .sql.column.metadata import AutoGenerated as AutoGenerated
+from .sql.column.metadata import AutoIncrement as AutoIncrement
+from .sql.column.metadata import Unique as Unique
+from .sql.column.metadata import CheckTypes as CheckTypes
+from .sql.column.metadata import Default as Default
+from .sql.column.metadata import NotNull as NotNull
+
+from ormlambda.statements.interfaces import IStatements as IStatements
+from ormlambda.engine import Engine as Engine
+
 _util.import_prefix("ormlambda")

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/common/__init__.py

@@ -1 +1,2 @@
 from .global_checker import GlobalChecker as GlobalChecker
+from .constants import DOT as DOT

ormlambda-4.4.4/src/ormlambda/common/constants.py

@@ -0,0 +1 @@
+DOT = '.'

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/common/enums/union_type.py

@@ -6,4 +6,4 @@ class UnionEnum(str, enum.Enum):
     OR = "OR"
 
     def __str__(self):
-        return super().__str__()
+        return super().__str__()

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/common/errors/__init__.py

@@ -6,6 +6,7 @@ from ormlambda import util
 
 if tp.TYPE_CHECKING:
     from ormlambda.sql.clause_info import ClauseInfo
+    from ormlambda.sql import Column
 
 
 class UnmatchedLambdaParameterError(Exception):
@@ -42,7 +43,7 @@ class FunctionFunctionError[T](Exception):
         Get the class name of those classes that inherit from 'IFunction' class in order to create a better error message.
         """
 
-        IFunction = util.preloaded.sql_functions.IFunction 
+        IFunction = util.preloaded.sql_functions.IFunction
         res: set[str] = set()
         if not isinstance(clauses, tp.Iterable):
             return clauses.__class__.__name__
@@ -58,3 +59,44 @@ class NotCallableError(ValueError):
 
     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__}' "
+
+
+class CompileError(Exception):
+    """Exception raised for errors in the compilation process."""
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return f"CompileError: {self.message}"
+
+
+class NoSuchModuleError(Exception):
+    """Raised when a dynamically-loaded module (usually a database dialect)
+    of a particular name cannot be located."""
+
+    def __str__(self):
+        return f"NoSuchModuleError: {self.args[0]}"
+
+
+class DuplicatedClauseNameError(Exception):
+    def __init__(self, names: tuple[str], **kw):
+        self.names = names
+        super().__init__(**kw)
+
+    def __str__(self):
+        return f"Some clauses has the same alias. {self.names}\nTry wrapping the clause with the 'Alias' class first or setting 'avoid_duplicates' param as 'True'"
+
+
+class ColumnError(ValueError):
+    def __init__(self, column: Column, *args):
+        super().__init__(*args)
+        self.column = column
+        self.clause: str = ""
+
+    def set_clause(self, value: str) -> None:
+        self.clause = value
+
+    def __str__(self):
+        return f"The column '{self.column.column_name}' does not exist. Check the name you used inside of '{self.clause}' clause."

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/common/global_checker.py

@@ -29,7 +29,7 @@ class GlobalChecker[T: TableProxy]:
         try:
             table_proxy = TableProxy(table)
 
-            if not callable(lambda_func): 
+            if not callable(lambda_func):
                 raise NotCallableError(lambda_func)
 
             if isinstance(lambda_func, Iterable):

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/dialects/mysql/base.py

@@ -101,6 +101,9 @@ class MySQLCompiler(compiler.SQLCompiler):
     render_table_with_column_in_update_from = True
     """Overridden from base SQLCompiler value"""
 
+    def visit_table(self, table: Table):
+        return ClauseInfo(table=table, dialect=self.dialect).query(dialect=self.dialect)
+
     def visit_table_proxy(self, table: TableProxy, **kw) -> str:
         param = {
             "table": None,
@@ -167,7 +170,7 @@ class MySQLCompiler(compiler.SQLCompiler):
 
         return f"{lcond} {comparer.compare} {rcond}"
 
-    def visit_where(self, where: Where) -> str:
+    def visit_where(self, where: Where, sep: str = " ", **kw) -> str:
         assert (n := len(where.comparers)) == len(where.restrictive)
 
         if not where.comparers:
@@ -178,17 +181,17 @@ class MySQLCompiler(compiler.SQLCompiler):
         for i in range(n):
             comp = where.comparers[i]
 
-            string = comp.compile(self.dialect).string
+            string = comp.compile(self.dialect, **kw).string
 
             condition = f"({string})" if isinstance(comp, ComparerCluster) else string
 
-            union = f" {where.restrictive[i + 1]} " if i != n - 1 else ""
+            union = f" {where.restrictive[i + 1]}{sep}" if i != n - 1 else ""
 
             condition += union
             cond.append(condition)
-        return f" WHERE {"".join(cond)}"
+        return f"WHERE{sep}{''.join(cond)}"
 
-    def visit_having(self, having: Having) -> str:
+    def visit_having(self, having: Having, sep: str = " ", **kw) -> str:
         assert (n := len(having.comparers)) == len(having.restrictive)
 
         if not having.comparers:
@@ -199,15 +202,15 @@ class MySQLCompiler(compiler.SQLCompiler):
         for i in range(n):
             comp = having.comparers[i]
 
-            string = comp.compile(self.dialect).string
+            string = comp.compile(self.dialect, **kw).string
 
             condition = f"({string})" if isinstance(comp, ComparerCluster) else string
 
-            union = f" {having.restrictive[i + 1]} " if i != n - 1 else ""
+            union = f" {having.restrictive[i + 1]}{sep}" if i != n - 1 else ""
 
             condition += union
             cond.append(condition)
-        return f" HAVING {"".join(cond)}"
+        return f"HAVING{sep}{''.join(cond)}"
 
     def visit_join(self, join: JoinSelector) -> str:
         rt = join.rcon.table
@@ -226,7 +229,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         ]
         return " ".join([x for x in list_ if x is not None])
 
-    def visit_select(self, select: Select):
+    def visit_select(self, select: Select, sep: str = " ", **kw):
         params = {}
 
         # COMMENT: when passing alias into 'select' method, we gonna replace the current aliases of columns with the generic one.
@@ -236,15 +239,15 @@ class MySQLCompiler(compiler.SQLCompiler):
         elif select.alias:
             params["alias_clause"] = select.alias
 
-        columns = ClauseInfo.join_clauses(select.columns, ",", dialect=self.dialect, **params)
+        columns = ClauseInfo.join_clauses(select.columns, sep, dialect=self.dialect, **params)
+
         from_ = ClauseInfo(
             select._table,
             None,
-            alias_table=select._alias_table,
             dialect=self.dialect,
         ).query(self.dialect)
 
-        return f"SELECT {columns} FROM {from_}"
+        return f"SELECT{sep}{columns}{sep}FROM {from_}"
 
     def visit_group_by(self, groupby: GroupBy):
         column = ", ".join(x.compile(self.dialect, alias_clause=None).string for x in groupby.column)
@@ -320,11 +323,18 @@ class MySQLCompiler(compiler.SQLCompiler):
         unknown_rows = f"({', '.join(wildcards)})"  # The number of "%s" must match the dict 'dicc_0' length
 
         insert.cleaned_values = [tuple(x) for x in col_values]
-        query = f"INSERT INTO {insert.table.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
+        query = f"INSERT INTO {self.visit_table(insert.table)} {f'({join_cols})'} VALUES {unknown_rows}"
         return query
 
     def visit_delete(self, delete: Delete, **kw) -> str:
-        return f"DELETE FROM {delete.table.__table_name__}"
+        query = f"DELETE FROM {self.visit_table(delete.table)}"
+
+        if delete.where.comparers:
+            # COMMENT: We need to change the Where.restrictive due to if we use more than one where, we want to use "OR" instead "AND"
+            for x in range(len(delete.where.restrictive)):
+                delete.where.restrictive[x] = "OR"
+            query += " " + delete.where.compile(self.dialect).string
+        return query
 
     def visit_upsert(self, upsert: Upsert, **kw) -> str:
         """
@@ -436,6 +446,11 @@ class MySQLCompiler(compiler.SQLCompiler):
         set_query: str = ",".join(["=".join(col_data) for col_data in col_names])
 
         query = f"UPDATE {update.table.__table_name__} SET {set_query}"
+
+        if update.where.comparers:
+            where_string = update.where.compile(self.dialect).string
+
+            query += " " + where_string
         update.cleaned_values = tuple(update.cleaned_values)
         return query
 
@@ -568,7 +583,7 @@ class MySQLCompiler(compiler.SQLCompiler):
 
 class MySQLDDLCompiler(compiler.DDLCompiler):
     def get_column_specification(self, column: Column, **kwargs):
-        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dbtype)
+        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dtype)
         default = self.get_column_default_string(column)
         if default is not None:
             colspec += " DEFAULT " + default

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/dialects/mysql/caster/caster.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from typing import Union
 from ormlambda.caster.caster import Caster
 
 
@@ -41,5 +42,6 @@ class MySQLCaster(Caster):
             list: IterableCaster,
             bool: BooleanCaster,
             Decimal: DecimalCaster,
-            dict:JsonCaster
+            dict: JsonCaster,
+            Union[list | dict]: JsonCaster,
         }

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/dialects/mysql/caster/types/__init__.py

@@ -9,4 +9,4 @@ from .iterable import IterableCaster as IterableCaster
 from .boolean import BooleanCaster as BooleanCaster
 from .date import DateCaster as DateCaster
 from .decimal import DecimalCaster as DecimalCaster
-from .json import JsonCaster as JsonCaster 
+from .json import JsonCaster as JsonCaster

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/dialects/mysql/caster/types/json.py

@@ -2,6 +2,7 @@ from typing import Optional
 from ormlambda.caster import BaseCaster, Caster
 import json
 
+
 class JsonCaster[TType](BaseCaster[dict, TType]):
     def __init__(self, value: dict, type_value: TType):
         super().__init__(value, type_value)

ormlambda-4.4.4/src/ormlambda/dialects/mysql/repository/__init__.py

@@ -0,0 +1 @@
+from .repository import MySQLRepository  # noqa: F401

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/repository/response.py

@@ -5,8 +5,10 @@ import shapely as shp
 
 # Custom libraries
 from ormlambda.sql.clauses import Alias
+from ormlambda import ColumnProxy
 
 if TYPE_CHECKING:
+    from ormlambda.sql.types import SelectCol
     from ormlambda.sql.clause_info import ClauseInfo
     from ormlambda import Table
     from ormlambda.sql.clauses import Select
@@ -69,12 +71,11 @@ class Response[TFlavour, *Ts]:
             nonlocal data
             result = []
             for value in data:
-                if len(value) ==1:
+                if len(value) == 1:
                     result.append(value[0])
                     continue
                 result.append(value)
 
-
             return result
 
         def _set(**kwargs) -> list[set]:
@@ -130,7 +131,7 @@ class Response[TFlavour, *Ts]:
             for i, data in enumerate(row):
                 alias = self._columns[i]
                 clause = self._select[alias]
-                dtype = clause.dtype if hasattr(clause, "dtype") else None
+                dtype = self.get_python_type(clause)
                 parse_data = self._caster.for_value(data, value_type=dtype).from_database
                 new_row.append(parse_data)
             new_row = tuple(new_row)
@@ -146,3 +147,12 @@ class Response[TFlavour, *Ts]:
             return False
 
         return clause_info.dtype is shp.Point
+
+    @staticmethod
+    def get_python_type[T](value: SelectCol) -> Type[T]:
+        if isinstance(value, ColumnProxy):
+            return value.dtype.python_type
+
+        if hasattr(value, "dtype"):
+            return value.dtype
+        return None

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/sql/clause_info/clause_info.py

@@ -4,9 +4,9 @@ import typing as tp
 import re
 
 from ormlambda.sql.types import ASTERISK
-from ormlambda.errors import DuplicatedClauseNameError
+from ormlambda.common.errors import DuplicatedClauseNameError
 from .interface import IClauseInfo
-from ormlambda.common import GlobalChecker
+from ormlambda.common import GlobalChecker, DOT
 from ormlambda import util
 
 
@@ -46,6 +46,8 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def __init__(self, table: TableType[T], preserve_context: tp.Optional[bool] = ...): ...
     @tp.overload
     def __init__[TProp](self, table: TableType[T], dtype: tp.Optional[TProp] = ...): ...
+    @tp.overload
+    def __init__(self, table: TableType[T], literal: bool = ...): ...
 
     @tp.overload
     def __init__(self, dialect: Dialect, *args, **kwargs): ...
@@ -122,8 +124,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     @property
     def alias_table(self) -> tp.Optional[str]:
         alias = self._alias_table
+
         return self._alias_resolver(alias)
 
+
     # TODOL [ ]: if we using this setter, we don't update the _context with the new value. Study if it's necessary
     @alias_table.setter
     def alias_table(self, value: str) -> str:
@@ -146,7 +150,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._dtype
 
         if self.is_column(self._column):
-            return self._column.dtype
+            return self._column.dtype.python_type
 
         if isinstance(self._column, type):
             return self._column
@@ -185,7 +189,8 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         # When passing the Table itself without 'column'
         if self.table and not self._column:
             if not self._alias_table:
-                return self.table.__table_name__
+                return self.join_db_and_table(self.table)
+
             alias_table = self.alias_table
             return self.concat_alias_and_column(self.table.__table_name__, alias_table)
 
@@ -193,6 +198,20 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._get_all_columns(dialect)
         return self._join_table_and_column(self._column, dialect)
 
+    @classmethod
+    def join_db_and_table(cls, table: str| Table, table_name: tp.Optional[str] = None) -> str:
+        table_name = table.__table_name__ if (not table_name and hasattr(table,"__table_name__")) else table_name
+
+        db = table.__db_name__ if hasattr(table,"__db_name__") else None
+
+        wrapped_table = cls.wrapped_with_quotes(table_name)
+
+        if db:
+            wrapped_db = cls.wrapped_with_quotes(db)
+            return f"{wrapped_db}{DOT}{wrapped_table}"
+
+        return wrapped_table
+
     @util.preload_module("ormlambda.sql")
     def _join_table_and_column[TProp](self, column: ColumnType[TProp], dialect: Dialect) -> str:
         ColumnProxy = util.preloaded.sql_column.ColumnProxy
@@ -200,15 +219,17 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         caster = dialect.caster()
 
         if self.alias_table:
-            table = self.wrapped_with_quotes(self.alias_table)
+            col = column.table if hasattr(column, "table") else column
+            table = self.join_db_and_table(col, self.alias_table)
         elif isinstance(column, ColumnProxy):
-            table = self.wrapped_with_quotes(column.get_table_chain())
+            table_name: str = column.get_table_chain()
+            table = self.join_db_and_table(column.table, table_name)
         else:
             table = self.table.__table_name__
 
         column: str = self._column_resolver(column)
 
-        table_column = f"{table}.{column}"
+        table_column = f"{table}{DOT}{column}"
 
         dtype = str if self.is_table(self.dtype) else self.dtype
         wrapped_column = caster.for_value(table_column, dtype).wildcard_to_select(table_column)
@@ -309,7 +330,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
     @util.preload_module("ormlambda.sql.clauses")
     @staticmethod
-    def join_clauses(clauses: list[ColumnProxy], chr: str = ",", *, dialect: Dialect, **kw) -> str:
+    def join_clauses(clauses: list[ColumnProxy], chr: str = " ", *, dialect: Dialect, **kw) -> str:
         IComparer = util.preloaded.sql_comparer.IComparer
 
         raise_alias_duplicated = False
@@ -345,7 +366,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
         if raise_alias_duplicated:
             raise DuplicatedClauseNameError(tuple(alias for alias, number in all_aliases.items() if number > 1))
-        return f"{chr} ".join(queries)
+        return f",{chr}".join(queries)
 
     @staticmethod
     def wrapped_with_quotes(
@@ -375,7 +396,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def is_table(data: ColumnType | Table | ForeignKey) -> bool:
         Table = util.preloaded.sql_table.Table
         TableProxy = util.preloaded.sql_table.TableProxy
-        
+
         return isinstance(data, type) and issubclass(data, Table | TableProxy)
 
     @util.preload_module("ormlambda.sql")

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/sql/clauses/alias.py

@@ -46,7 +46,7 @@ class ComparerAlias(IComparer):
         return self.comparer.join
 
     def compile(self, dialect=None, **kw):
-        return cast(ClauseElement,self.comparer).compile(dialect, **kw)
+        return cast(ClauseElement, self.comparer).compile(dialect, **kw)
 
 
 __all__ = ["Alias"]

ormlambda-4.4.4/src/ormlambda/sql/clauses/delete.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from typing import Iterable, overload, TYPE_CHECKING
+from ormlambda.sql.elements import ClauseElement
+from ormlambda import Table
+
+if TYPE_CHECKING:
+    from ormlambda.sql.clauses import Where
+
+
+class Delete[T: Table](ClauseElement):
+    __visit_name__ = "delete"
+
+    @overload
+    def __init__(self, table: T, where: Where, values: T) -> None: ...
+    @overload
+    def __init__(self, table: T, where: Where, values: Iterable[T]) -> None: ...
+
+    def __init__(self, table: T, where: Where, values) -> None:
+        self.values: Table | Iterable[Table] = values
+        self.table = table
+        self.cleaned_values = []
+        self.where = where
+
+
+__all__ = ["Delete"]

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/sql/clauses/insert.py

@@ -16,7 +16,7 @@ class Insert[T: Table](ClauseElement):
     def __init__(self, values: T) -> None: ...
 
     def __init__(self, values: T | list[T]) -> None:
-        self.values:Iterable[T] = values if isinstance(values, Iterable) else (values,)
+        self.values: Iterable[T] = values if isinstance(values, Iterable) else (values,)
         self.table = type(self.values[0])
 
         self.cleaned_values = []

ormlambda-4.4.4/src/ormlambda/sql/clauses/update.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from typing import Iterable, Type, overload, Any, TYPE_CHECKING
+
+from ormlambda import Table
+from ormlambda.sql.elements import ClauseElement
+
+if TYPE_CHECKING:
+    from ormlambda.sql.clauses import Where
+
+
+class Update[T: Type[Table]](ClauseElement):
+    __visit_name__ = "update"
+
+    @overload
+    def __init__(self, model: T, where: Where, values: dict[str, Any]) -> None: ...
+    @overload
+    def __init__(self, model: T, where: Where, values: Iterable[dict[str, Any]]) -> None: ...
+
+    def __init__(self, model: T, where: Where, values) -> None:
+        self.values: Iterable[dict[str, Any]] = values if isinstance(values, Iterable) else (values,)
+        self.table: Table = model
+        self.cleaned_values = []
+        self.where: Where = where
+
+
+__all__ = ["Update"]

{ormlambda-4.4.0 → ormlambda-4.4.4}/src/ormlambda/sql/clauses/where.py

@@ -38,5 +38,4 @@ class Where(ClauseElement):
         return None
 
 
-
 __all__ = ["Where"]