ormlambda 2.11.2__py3-none-any.whl → 3.7.0__py3-none-any.whl

ormlambda/sql/comparer.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+import abc
+import re
+import typing as tp
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+
+
+from ormlambda.sql.types import ConditionType, ComparerTypes
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda import ConditionType as ConditionEnum
+
+if tp.TYPE_CHECKING:
+    from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+    from ormlambda.sql import Table
+
+
+class ICleaner(abc.ABC):
+    @staticmethod
+    @abc.abstractmethod
+    def clean(value: str): ...
+
+
+class IgnoreCase(ICleaner):
+    @staticmethod
+    def clean(value: str) -> str:
+        return value.lower()
+
+
+DICC_FLAGS = {
+    re.IGNORECASE: IgnoreCase,
+}
+
+
+class CleanValue:
+    def __init__(self, name: str, *flags: re.RegexFlag):
+        self._flags = flags
+        self._filename: str = name
+
+    def clean(self) -> str:
+        temp_name = self._filename
+        for flag in self._flags:
+            cleaner = DICC_FLAGS.get(flag, None)
+            if cleaner:
+                temp_name = cleaner.clean(temp_name)
+        return temp_name
+
+
+class Comparer[LTable: Table, LProp, RTable: Table, RProp](IQuery):
+    def __init__(
+        self,
+        left_condition: ConditionType[LProp],
+        right_condition: ConditionType[RProp],
+        compare: ComparerTypes,
+        context: ClauseContextType = None,
+        flags: tp.Optional[tp.Iterable[re.RegexFlag]] = None,
+    ) -> None:
+        self._context: ClauseContextType = context
+        self._compare: ComparerTypes = compare
+        self._left_condition: Comparer[LTable, LProp, RTable, RProp] | ClauseInfo[LTable] = left_condition
+        self._right_condition: Comparer[LTable, LProp, RTable, RProp] | ClauseInfo[RTable] = right_condition
+        self._flags = flags
+
+    def set_context(self, context: ClauseContextType) -> None:
+        self._context = context
+
+    def __repr__(self) -> str:
+        return f"{Comparer.__name__}: {self.query}"
+
+    def _create_clause_info[TTable](self, cond: ConditionType[LProp]) -> Comparer[LTable, LProp, RTable, RProp] | ClauseInfo[TTable]:
+        from ormlambda import Column
+
+        if isinstance(cond, Comparer):
+            return cond
+        if isinstance(cond, Column):
+            return ClauseInfo(cond.table, cond, alias_clause=None, context=self._context)
+        # it a value that's not depend of any Table
+        return ClauseInfo(None, cond, alias_clause=None, context=self._context)
+
+    @property
+    def left_condition(self) -> Comparer | ClauseInfo[LTable]:
+        return self._create_clause_info(self._left_condition)
+
+    @property
+    def right_condition(self) -> Comparer | ClauseInfo[RTable]:
+        return self._create_clause_info(self._right_condition)
+
+    @property
+    def compare(self) -> ComparerTypes:
+        return self._compare
+
+    @property
+    def query(self) -> str:
+        lcond = self.left_condition.query
+        rcond = self.right_condition.query
+
+        if self._flags:
+            rcond = CleanValue(rcond, self._flags).clean()
+
+        return f"{lcond} {self._compare} {rcond}"
+
+    def __and__(self, other: Comparer, context: ClauseContextType = None) -> Comparer:
+        # Customize the behavior of '&'
+        return Comparer(self, other, "AND", context=context)
+
+    def __or__(self, other: Comparer, context: ClauseContextType = None) -> Comparer:
+        # Customize the behavior of '|'
+        return Comparer(self, other, "OR", context=context)
+
+    @classmethod
+    def join_comparers(cls, comparers: list[Comparer], restrictive: bool = True, context: ClauseContextType = None) -> str:
+        if not isinstance(comparers, tp.Iterable):
+            raise ValueError(f"Excepted '{Comparer.__name__}' iterable not {type(comparers).__name__}")
+        if len(comparers) == 1:
+            comparer = comparers[0]
+            comparer.set_context(context)
+            return comparer.query
+
+        join_method = cls.__or__ if not restrictive else cls.__and__
+
+        ini_comparer: Comparer = None
+        for i in range(len(comparers) - 1):
+            if ini_comparer is None:
+                ini_comparer = comparers[i]
+                ini_comparer.set_context(context)
+            right_comparer = comparers[i + 1]
+            right_comparer.set_context(context)
+            new_comparer = join_method(ini_comparer, right_comparer, context=context)
+            ini_comparer = new_comparer
+        return new_comparer.query
+
+
+class Regex[LProp, RProp](Comparer[None, LProp, None, RProp]):
+    def __init__(
+        self,
+        left_condition: ConditionType[LProp],
+        right_condition: ConditionType[RProp],
+        context: ClauseContextType = None,
+        flags: tp.Optional[tp.Iterable[re.RegexFlag]] = None,
+    ):
+        super().__init__(
+            left_condition=left_condition,
+            right_condition=right_condition,
+            compare=ConditionEnum.REGEXP.value,
+            context=context,
+            flags=flags,  # Pass as a named parameter instead
+        )
+
+
+class Like[LProp, RProp](Comparer[None, LProp, None, RProp]):
+    def __init__(
+        self,
+        left_condition: ConditionType[LProp],
+        right_condition: ConditionType[RProp],
+        context: ClauseContextType = None,
+    ):
+        super().__init__(left_condition, right_condition, ConditionEnum.LIKE.value, context)

ormlambda/sql/foreign_key.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+from typing import Callable, TYPE_CHECKING, Optional, Any, Type, overload
+
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+
+
+if TYPE_CHECKING:
+    from ormlambda.sql.comparer import Comparer
+    from ormlambda import Table
+    from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+
+
+class ForeignKey[TLeft: Table, TRight: Table](IQuery):
+    stored_calls: set[ForeignKey] = set()
+
+    @overload
+    def __new__[LProp, RProp](self, comparer: Comparer[LProp, RProp], clause_name: str) -> None: ...
+    @overload
+    def __new__[LProp, TRight, RProp](cls, tright: Type[TRight], relationship: Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]) -> TRight: ...
+
+    def __new__[LProp, TRight, RProp](cls, tright: Optional[TRight] = None, relationship: Optional[Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]] = None, *, comparer: Optional[Comparer] = None, clause_name: Optional[str] = None) -> TRight:
+        return super().__new__(cls)
+
+    def __init__[LProp, RProp](
+        self,
+        tright: Optional[TRight] = None,
+        relationship: Optional[Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]] = None,
+        *,
+        comparer: Optional[Comparer] = None,
+        clause_name: Optional[str] = None,
+    ) -> None:
+        if comparer is not None and clause_name is not None:
+            self.__init__with_comparer(comparer, clause_name)
+        else:
+            self.__init_with_callable(tright, relationship)
+
+    def __init__with_comparer[LProp, RProp](self, comparer: Comparer[LProp, RProp], clause_name: str) -> None:
+        self._relationship = None
+        self._tleft: TLeft = comparer.left_condition.table
+        self._tright: TRight = comparer.right_condition.table
+        self._clause_name: str = clause_name
+        self._comparer: Comparer[LProp, RProp] = comparer
+
+    def __init_with_callable[LProp, RProp](self, tright: Optional[TRight], relationship: Optional[Callable[[TLeft, TRight], Comparer[LProp, RProp]]]) -> None:
+        self._relationship: Callable[[TLeft, TRight], Comparer[LProp, RProp]] = relationship
+        self._tleft: TLeft = None
+        self._tright: TRight = tright
+        self._clause_name: str = None
+        self._comparer: Optional[Comparer] = None
+
+    def __set_name__(self, owner: TLeft, name) -> None:
+        self._tleft: TLeft = owner
+        self._clause_name: str = name
+
+    def __get__(self, obj: Optional[TRight], objtype=None) -> ForeignKey[TLeft, TRight] | TRight:
+        if not obj:
+            ForeignKey.stored_calls.add(self)
+            return self
+        return self._tright
+
+    def __set__(self, obj, value):
+        raise AttributeError(f"The {ForeignKey.__name__} '{self._clause_name}' in the '{self._tleft.__table_name__}' table cannot be overwritten.")
+
+    def __getattr__(self, name: str):
+        if self._tright is None:
+            raise AttributeError("No right table assigned to ForeignKey")
+        return getattr(self._tright, name)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(" f"left={self._tleft.__name__ if self._tleft else 'None'}, " f"right={self._tright.__name__ if self._tright else 'None'}, " f"name={self._clause_name})"
+
+    @property
+    def tleft(self) -> TLeft:
+        return self._tleft
+
+    @property
+    def tright(self) -> TRight:
+        return self._tright
+
+    @property
+    def clause_name(self) -> str:
+        return self._clause_name
+
+    @property
+    def query(self) -> str:
+        compare = self.resolved_function()
+        rcon = alias if (alias := compare.right_condition.alias_table) else compare.right_condition.table.__table_name__
+        return f"FOREIGN KEY ({self._tleft.__table_name__}) REFERENCES {rcon}({compare.right_condition._column.column_name})"
+
+    @property
+    def alias(self) -> str:
+        self._comparer = self.resolved_function()
+        lcol = self._comparer.left_condition._column.column_name
+        rcol = self._comparer.right_condition._column.column_name
+        return f"{self.tleft.__table_name__}_{lcol}_{rcol}"
+
+    @classmethod
+    def create_query(cls, orig_table: Table) -> list[str]:
+        clauses: list[str] = []
+
+        for attr in vars(orig_table):
+            if isinstance(attr, ForeignKey):
+                clauses.append(attr.query)
+        return clauses
+
+    def resolved_function[LProp: Any, RProp: Any](self, context: ClauseContextType = None) -> Comparer[LProp, RProp]:
+        """ """
+        if self._comparer is not None:
+            return self._comparer
+
+        left = self._tleft
+        right = self._tright
+        comparer = self._relationship(left, right)
+        comparer.set_context(context)
+        return comparer

ormlambda/sql/table/__init__.py

@@ -0,0 +1 @@
+from .table_constructor import Table, TableMeta  # noqa: F401

ormlambda/{utils → sql/table}/fields.py

@@ -1,9 +1,9 @@
 import typing as tp
-from .column import Column
+from ormlambda.sql import Column
 
 __all__ = ["get_fields"]
 
-MISSING = lambda: Column()  # COMMENT: Very Important to avoid reusing the same variable across different classes.  # noqa: E731
+MISSING = lambda x: Column(x)  # COMMENT: Very Important to avoid reusing the same variable across different classes.  # noqa: E731
 
 
 class Field[TProp: tp.AnnotatedAny]:
@@ -34,7 +34,7 @@ class Field[TProp: tp.AnnotatedAny]:
 
     @property
     def assginment(self) -> str:
-        return f"self._{self.name} = {self.default.__to_string__(self)}"
+        return f"self.{self.name} = {self.default.column_name}"
 
 
 def get_fields[T, TProp](cls: tp.Type[T]) -> tp.Iterable[Field]:
@@ -50,11 +50,12 @@ def get_fields[T, TProp](cls: tp.Type[T]) -> tp.Iterable[Field]:
             # type_ must by Column object
             field_type: TProp = type_
 
-        default: Column = getattr(cls, name, MISSING())
+        default: Column = getattr(cls, name, MISSING(field_type))
+        Column.__set_name__(default, cls, name)
 
-        default.dtype = field_type  # COMMENT: Useful for setting the dtype variable after instantiation.
         fields.append(Field[TProp](name, field_type, default))
 
         # Update __annotations__ to create Columns
         cls.__annotations__[name] = default
+        setattr(cls, name, default)
     return fields

ormlambda/{utils → sql/table}/table_constructor.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from decimal import Decimal
-from typing import Any, Optional, Type, dataclass_transform, overload, TYPE_CHECKING
+from typing import Any, Optional, Type, dataclass_transform
 import base64
 import datetime
 import json
@@ -8,21 +8,15 @@ import json
 import shapely as sph
 
 
-from .column import Column
-from .dtypes import get_query_clausule
+from ormlambda.sql import Column
+from ormlambda.sql import ForeignKey
+from ormlambda.sql.dtypes import get_query_clausule
 from .fields import get_fields
-from .foreign_key import ForeignKey, TableInfo
-from .module_tree.dfs_traversal import DFSTraversal
-
-if TYPE_CHECKING:
-    from .fields import Field
+from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
 
 
 @dataclass_transform()
 def __init_constructor__[T](cls: Type[T]) -> Type[T]:
-    # create '__properties_mapped__' dictionary for each Table to avoid shared information
-    # TODOL: I don't know if it's better to create a global dictionary like in commit '7de69443d7a8e7264b8d5d604c95da0e5d7e9cc0'
-    setattr(cls, "__properties_mapped__", {})
     fields = get_fields(cls)
 
     locals_: dict[str, Any] = {}
@@ -34,21 +28,20 @@ def __init_constructor__[T](cls: Type[T]) -> Type[T]:
             continue
 
         locals_[field.type_name] = field.type_
-        locals_[field.default_name] = field.default.column_value
+        locals_[field.default_name] = None
 
         init_args.append(field.init_arg)
         assignments.append(field.assginment)
-        __create_properties(cls, field)
 
     string_locals_ = ", ".join(locals_)
     string_init_args = ", ".join(init_args)
-    string_assignments = "\n\t\t".join(assignments)
+    string_assignments = "".join([f"\n\t\t{x}" for x in assignments])
 
     wrapper_fn = "\n".join(
         [
             f"def wrapper({string_locals_}):",
             f"\n\tdef __init__({string_init_args}):",
-            f"\n\t\t{string_assignments}",
+            string_assignments,
             "\treturn __init__",
         ]
     )
@@ -62,21 +55,6 @@ def __init_constructor__[T](cls: Type[T]) -> Type[T]:
     return cls
 
 
-def __create_properties(cls: Type["Table"], field: Field) -> property:
-    _name: str = f"_{field.name}"
-
-    # we need to get Table attributes (Column class) and then called __getattribute__ or __setattr__ to make changes inside of Column
-    prop = property(
-        fget=lambda self: getattr(self, _name).__getattribute__("column_value"),
-        fset=lambda self, value: getattr(self, _name).__setattr__("column_value", value),
-    )
-
-    # set property in public name
-    setattr(cls, field.name, prop)
-    cls.__properties_mapped__[prop] = field.name
-    return None
-
-
 class TableMeta(type):
     def __new__[T](cls: "Table", name: str, bases: tuple, dct: dict[str, Any]) -> Type[T]:
         """
@@ -95,27 +73,12 @@ class TableMeta(type):
         if not isinstance(cls_object.__table_name__, str):
             raise Exception(f"class variable '__table_name__' of '{cls_object.__name__}' class must be 'str'")
 
-        TableMeta.__add_to_ForeignKey(cls_object)
         self = __init_constructor__(cls_object)
         return self
 
     def __repr__(cls: "Table") -> str:
         return f"{TableMeta.__name__}: {cls.__table_name__}"
 
-    @staticmethod
-    def __add_to_ForeignKey(cls: "Table") -> None:
-        """
-        When creating a Table class, we cannot pass the class itself as a parameter in a function that initializes a class variable.
-        To fix this, we first add the table name as key and then, we add the class itself in the TableInfo class.
-        """
-        if table_info := ForeignKey.MAPPED.get(cls.__table_name__, None):
-            table_info.table_object = cls
-        else:
-            ForeignKey.MAPPED[cls.__table_name__] = TableInfo()
-            ForeignKey.MAPPED[cls.__table_name__].table_object = cls
-
-        return None
-
 
 @dataclass_transform(eq_default=False)
 class Table(metaclass=TableMeta):
@@ -130,7 +93,7 @@ class Table(metaclass=TableMeta):
     >>> class Address(Table):
     >>>     __table_name__ = "address"
 
-    >>>     address_id: int = Column[int](is_primary_key=True)
+    >>>     address_id: int = Column(int, is_primary_key=True)
     >>>     address: str
     >>>     address2: str
     >>>     district: str
@@ -138,20 +101,19 @@ class Table(metaclass=TableMeta):
     >>>     postal_code: datetime
     >>>     phone: str
     >>>     location: datetime
-    >>>     last_update: datetime = Column[datetime](is_auto_generated=True)
+    >>>     last_update: datetime = Column(datetime, is_auto_generated=True)
 
-    >>>     city = ForeignKey["Address", City](__table_name__, City, lambda a, c: a.city_id == c.city_id)
+    >>>     city = ForeignKey["Address", City](City, lambda a, c: a.city_id == c.city_id)
     """
 
     __table_name__: str = ...
-    __properties_mapped__: dict[property, str] = ...
 
     def __str__(self) -> str:
         params = self.to_dict()
         return json.dumps(params, ensure_ascii=False, indent=2)
 
-    def __getattr__[T](self, __name: str) -> Column[T]:
-        return self.__dict__.get(__name, None)
+    def __getattr__[T](self, _name: str) -> Column[T]:
+        return self.__dict__.get(_name, None)
 
     def __repr__(self: "Table") -> str:
         def __cast_long_variables(value: Any):
@@ -165,6 +127,12 @@ class Table(metaclass=TableMeta):
         equal_loop = ["=".join((x, __cast_long_variables(y))) for x, y in dicc.items()]
         return f'{self.__class__.__name__}({", ".join(equal_loop)})'
 
+    def __getitem__[TProp](self, value: str | Column[TProp]) -> Optional[TProp]:
+        name = value if isinstance(value, str) else value.column_name
+        if hasattr(self, name):
+            return getattr(self, name)
+        return None
+
     def to_dict(self) -> dict[str, str | int]:
         dicc: dict[str, Any] = {}
         for x in self.__annotations__:
@@ -190,17 +158,22 @@ class Table(metaclass=TableMeta):
             return transform_map[dtype](_value)
         return _value
 
-    def get_pk(self) -> Optional[Column]:
-        for col_name in self.__annotations__.keys():
-            private_col = f"_{col_name}"
-            col_obj = getattr(self, private_col)
-            if isinstance(col_obj, Column) and col_obj.is_primary_key:
-                return col_obj
+    @classmethod
+    def get_pk(cls) -> Optional[Column]:
+        for obj in cls.__dict__.values():
+            if isinstance(obj, Column) and obj.is_primary_key:
+                return obj
         return None
 
     @classmethod
     def get_columns(cls) -> tuple[str, ...]:
-        return tuple(cls.__annotations__.keys())
+        return tuple([x for x in cls.__annotations__.values() if isinstance(x, Column)])
+
+    @classmethod
+    def get_column[TProp](cls,name:str) -> Column[TProp]:
+        for key,value in cls.__annotations__.items():
+            if name == key:
+                return value
 
     @classmethod
     def create_table_query(cls) -> str:
@@ -218,16 +191,17 @@ class Table(metaclass=TableMeta):
         It's imperative to instantiate cls() to initialize the 'Table' object and create private variables that will be Column objects.
         Otherwise, we only can access to property method
         """
-        table_init_ = cls()
-        annotations: dict[str, Column] = table_init_.__annotations__
+        annotations: dict[str, Column] = cls.__annotations__
         all_columns: list = []
-        for col_name in annotations.keys():
-            col_object: Column = getattr(table_init_, f"_{col_name}")
-            all_columns.append(get_query_clausule(col_object))
+        for col_obj in annotations.values():
+            all_columns.append(get_query_clausule(col_obj))
         return all_columns
 
     @classmethod
     def find_dependent_tables(cls) -> tuple["Table", ...]:
+        """Work in progress"""
+        return
+
         # TODOL: Dive into new way to return dependent tables
         def get_involved_tables(graph: dict[Table, list[Table]], table_name: str) -> None:
             """
@@ -266,33 +240,11 @@ class Table(metaclass=TableMeta):
         return False
 
     @classmethod
-    def get_property_name(cls, _property: property) -> str:
-        name: str = cls.__properties_mapped__.get(_property, None)
-        if not name:
-            raise KeyError(f"Class '{cls.__name__}' has not propery '{_property}' mapped.")
-        return name
+    def table_alias(cls, column: Optional[str] = None) -> str:
+        if column:
+            return f"`{cls.__table_name__}_{column}`"
+        return cls.__table_name__
 
-    @overload
     @classmethod
-    def get_column(cls, column: str) -> Column: ...
-    @overload
-    @classmethod
-    def get_column(cls, column: property) -> Column: ...
-    @overload
-    @classmethod
-    def get_column[TProp](cls, column: property, value: TProp) -> Column[TProp]: ...
-    @overload
-    @classmethod
-    def get_column[TProp](cls, column: str, value: TProp) -> Column[TProp]: ...
-    @classmethod
-    def get_column[TProp](cls, column: str | property, value: Optional[TProp] = None) -> Column[TProp]:
-        if isinstance(column, property):
-            _column = cls.get_property_name(column)
-        elif isinstance(column, str) and column in cls.get_columns():
-            _column = column
-        else:
-            raise ValueError(f"'Column' param with value'{column}' is not expected.")
-
-        instance_table: Table = cls(**{_column: value})
-
-        return getattr(instance_table, f"_{_column}")
+    def foreign_keys(cls) -> dict[str, ForeignKey]:
+        return {key: value for key, value in cls.__dict__.items() if isinstance(value, ForeignKey)}

ormlambda/sql/types.py

@@ -0,0 +1,25 @@
+import typing as tp
+
+
+if tp.TYPE_CHECKING:
+    from ormlambda import Table, Column, ForeignKey
+    from ormlambda.sql.comparer import Comparer
+    from ormlambda import ConditionType as ConditionEnum
+    from ormlambda.common.enums.join_type import JoinType
+
+
+type AsteriskType = str
+type TableType[T: Table] = tp.Type[T] | ForeignKey[T]
+type ColumnType[TProp] = TProp | Column[TProp] | AsteriskType | tuple[Column]
+type AliasType[T] = tp.Optional[str | tp.Callable[[T], str]]
+
+# region Comparer Types
+type ComparerType = tp.Literal["=", "!=", "<", "<=", ">", ">=", "in"]
+type ConditionType[TProp] = Comparer | ColumnType[TProp]
+type UnionType = tp.Literal["AND", "OR", ""]
+type ComparerTypes = ComparerType | UnionType | ConditionEnum
+# endregion
+
+type TupleJoinType[T] = tuple[Comparer[T], JoinType]
+
+ASTERISK: AsteriskType = "*"

ormlambda/statements/__init__.py

@@ -0,0 +1,2 @@
+from .base_statement import BaseStatement  # noqa: F401
+from .types import OrderType  # noqa: F401