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

ormlambda/databases/my_sql/clauses/ST_AsText.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-from ormlambda.sql.clause_info import AggregateFunctionBase
-from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-
-if TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class ST_AsText[T, TProp](AggregateFunctionBase[None]):
-    """
-    https://dev.mysql.com/doc/refman/8.4/en/fetching-spatial-data.html
-
-    The ST_AsText() function converts a geometry from internal format to a WKT string.
-    """
-
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "ST_AsText"
-
-    def __init__(
-        self,
-        point: ColumnType[TProp],
-        alias_table: AliasType[ColumnType[TProp]] = None,
-        alias_clause: AliasType[ColumnType[TProp]] = None,
-        context: ClauseContextType = None,
-        *,
-        dialect: Dialect,
-    ) -> None:
-        default_alias_clause = self.create_alias_from(point) if not alias_clause else alias_clause
-
-        super().__init__(table=point.table, column=point, alias_table=alias_table, alias_clause=default_alias_clause, context=context, dialect=dialect)
-
-    @staticmethod
-    def create_alias_from(element: ColumnType[TProp]) -> str:
-        return element.column_name

ormlambda/databases/my_sql/clauses/ST_Contains.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-import typing as tp
-
-from shapely import Point
-
-from ormlambda import Column
-from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info import ClauseInfo, IAggregate
-
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class ST_Contains(IAggregate):
-    FUNCTION_NAME: str = "ST_Contains"
-
-    def __init__[TProp: Column](
-        self,
-        column: ColumnType[TProp],
-        point: Point,
-        alias_table: tp.Optional[AliasType[ColumnType[TProp]]] = None,
-        alias_clause: tp.Optional[AliasType[ColumnType[TProp]]] = None,
-        *,
-        dialect: Dialect,
-    ):
-        self.attr1: ClauseInfo[Point] = ClauseInfo(column.table, column, alias_table, dialect=dialect)
-        self.attr2: ClauseInfo[Point] = ClauseInfo[Point](None, point, dialect=dialect)
-
-        self._alias_clause: AliasType[ColumnType[TProp]] = alias_clause
-
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        return f"{self.FUNCTION_NAME}({self.attr1.query(dialect,**kwargs)}, {self.attr2.query(dialect,**kwargs)})"
-
-    @property
-    def alias_clause(self) -> tp.Optional[str]:
-        return self._alias_clause

ormlambda/databases/my_sql/clauses/__init__.py

@@ -1,14 +0,0 @@
-from .delete import DeleteQuery as Delete
-from .drop_table import DropTable as DropTable
-from .insert import InsertQuery as Insert
-from .joins import JoinSelector as JoinSelector
-from .limit import Limit as Limit
-from .offset import Offset as Offset
-from .order import Order as Order
-from .update import Update as Update
-from .upsert import UpsertQuery as Upsert
-from .where import Where as Where
-from .having import Having as Having
-from .count import Count as Count
-from .group_by import GroupBy as GroupBy
-from .ST_AsText import ST_AsText as ST_AsText

ormlambda/databases/my_sql/clauses/count.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-from ormlambda.sql.clauses import Count
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-
-from ormlambda.sql.types import AliasType, ColumnType
-
-from ormlambda import Table
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ormlambda import Table
-    from ormlambda.sql.types import ColumnType, AliasType, TableType
-
-
-class Count[T: Table](Count[T]):
-    def __init__[TProp: Table](
-        self,
-        element: ColumnType[T] | TableType[TProp],
-        alias_table: AliasType[ColumnType[TProp]] = None,
-        alias_clause: AliasType[ColumnType[TProp]] = "count",
-        context: ClauseContextType = None,
-        keep_asterisk: bool = True,
-        preserve_context: bool = True,
-    ) -> None:
-        super().__init__(
-            element=element,
-            alias_table=alias_table,
-            alias_clause=alias_clause,
-            context=context,
-            keep_asterisk=keep_asterisk,
-            preserve_context=preserve_context,
-        )

ormlambda/databases/my_sql/clauses/delete.py

@@ -1,9 +0,0 @@
-from ormlambda import Table
-from ormlambda.repository import IRepositoryBase
-from ormlambda.sql.clauses import Delete
-from mysql.connector import MySQLConnection
-
-
-class DeleteQuery[T: Table](Delete[T, MySQLConnection]):
-    def __init__(self, model: T, repository: IRepositoryBase) -> None:
-        super().__init__(model, repository)

ormlambda/databases/my_sql/clauses/drop_table.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-from typing import Literal, override, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from mysql.connector import MySQLConnection
-
-from ormlambda.repository import BaseRepository
-
-
-TypeExists = Literal["fail", "replace", "append"]
-
-
-class DropTable:
-    def __init__(self, repository: BaseRepository[MySQLConnection]) -> None:
-        self._repository: BaseRepository[MySQLConnection] = repository
-
-    @override
-    def execute(self, name: str = None) -> None:
-        query = rf"{self.CLAUSE} {name}"
-        self._repository.execute(query)
-        return None
-
-    @property
-    @override
-    def CLAUSE(self) -> str:
-        return "DROP TABLE"

ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,17 +0,0 @@
-from ormlambda.sql.clause_info import ClauseInfoContext
-from ormlambda.sql.clauses import GroupBy
-from ormlambda.sql.types import ColumnType
-
-
-class GroupBy(GroupBy):
-    def __init__(
-        self,
-        column: ColumnType,
-        context: ClauseInfoContext,
-        **kwargs,
-    ):
-        super().__init__(
-            column=column,
-            context=context,
-            **kwargs,
-        )

ormlambda/databases/my_sql/clauses/having.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from ormlambda.sql.clauses import Having
-
-
-class Having(Having):
-    """
-    The purpose of this class is to create 'WHERE' condition queries properly.
-    """
-
-    def __init__(self, *comparer, restrictive=True, context=None):
-        super().__init__(*comparer, restrictive=restrictive, context=context)

ormlambda/databases/my_sql/clauses/insert.py

@@ -1,9 +0,0 @@
-from __future__ import annotations
-from ormlambda import Table
-from ormlambda.sql.clauses import Insert
-from mysql.connector import MySQLConnection
-
-
-class InsertQuery[T: Table](Insert[T, MySQLConnection]):
-    def __init__(self, model, repository):
-        super().__init__(model, repository)

ormlambda/databases/my_sql/clauses/joins.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-
-from ormlambda.sql.clauses import JoinSelector
-
-# TODOL [x]: Try to import Table module without circular import Error
-if TYPE_CHECKING:
-    from ormlambda import Table
-
-
-class JoinSelector[TLeft: Table, TRight: Table](JoinSelector[TLeft, TRight]):
-    def __init__(self, where, by, alias="{table}", context=None, **kw):
-        super().__init__(where, by, alias, context, **kw)

ormlambda/databases/my_sql/clauses/limit.py

@@ -1,6 +0,0 @@
-from ormlambda.sql.clauses import Limit
-
-
-class Limit(Limit):
-    def __init__(self, number):
-        super().__init__(number)

ormlambda/databases/my_sql/clauses/offset.py

@@ -1,6 +0,0 @@
-from ormlambda.sql.clauses import Offset
-
-
-class Offset(Offset):
-    def __init__(self, number):
-        super().__init__(number)

ormlambda/databases/my_sql/clauses/order.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-from ormlambda.sql.clauses import Order
-
-
-class Order(Order):
-    def __init__(self, column, order_type, context=None):
-        super().__init__(column, order_type, context)

ormlambda/databases/my_sql/clauses/update.py

@@ -1,8 +0,0 @@
-from mysql.connector import MySQLConnection
-
-from ormlambda.sql.clauses import Update
-
-
-class Update[T](Update[T, MySQLConnection]):
-    def __init__(self, model, repository, where):
-        super().__init__(model, repository, where)

ormlambda/databases/my_sql/clauses/upsert.py

@@ -1,9 +0,0 @@
-from __future__ import annotations
-
-from ormlambda import Table
-from ormlambda.sql.clauses.upsert import Upsert
-
-
-class UpsertQuery[T: Table](Upsert):
-    def __init__(self, model, repository):
-        super().__init__(model, repository)

ormlambda/databases/my_sql/clauses/where.py

@@ -1,7 +0,0 @@
-from __future__ import annotations
-from ormlambda.sql.clauses import Where
-
-
-class Where(Where):
-    def __init__(self, *comparer, restrictive=True, context=None):
-        super().__init__(*comparer, restrictive=restrictive, context=context)

ormlambda/dialects/interface/__init__.py

@@ -1 +0,0 @@
-from .dialect import Dialect  # noqa: F401

ormlambda/dialects/interface/dialect.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-import abc
-from typing import ClassVar, Optional, Type, TYPE_CHECKING
-
-
-if TYPE_CHECKING:
-    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
-
-
-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__}"

ormlambda/sql/clause_info/aggregate_function_base.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-import abc
-import typing as tp
-
-from ormlambda import Table
-from ormlambda import Column
-from ormlambda.sql.types import (
-    TableType,
-    ColumnType,
-    AliasType,
-)
-from .interface import IAggregate
-from ormlambda.common.errors import NotKeysInIAggregateError
-from ormlambda.sql import ForeignKey
-from ormlambda.sql.table import TableMeta
-from .clause_info import ClauseInfo
-from .clause_info_context import ClauseContextType
-
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
-    def __init__[TProp: Column](
-        self,
-        table: TableType[T],
-        column: tp.Optional[ColumnType[TProp]] = None,
-        alias_table: tp.Optional[AliasType[ClauseInfo[T]]] = None,
-        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]] = None,
-        context: ClauseContextType = None,
-        keep_asterisk: bool = False,
-        preserve_context: bool = False,
-        dtype: TProp = None,
-        *,
-        dialect: Dialect,
-        **kw,
-    ):
-        self._alias_aggregate = alias_clause
-        super().__init__(
-            table=table,
-            column=column,
-            alias_table=alias_table,
-            context=context,
-            keep_asterisk=keep_asterisk,
-            preserve_context=preserve_context,
-            dtype=dtype,
-            dialect=dialect,
-            **kw,
-        )
-
-    @staticmethod
-    @abc.abstractmethod
-    def FUNCTION_NAME() -> str: ...
-
-    @classmethod
-    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType, dialect: Dialect) -> list[ClauseInfo]:
-        type DEFAULT = tp.Literal["default"]
-        type ClusterType = ColumnType | ForeignKey | DEFAULT
-
-        dicc_type: dict[ClusterType, tp.Callable[[ClusterType], ClauseInfo]] = {
-            Column: lambda column: ClauseInfo(column.table, column, context=context, dialect=dialect),
-            ClauseInfo: lambda column: column,
-            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context, dialect=dialect),
-            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context, dialect=dialect),
-            "default": lambda column: ClauseInfo(table=None, column=column, context=context, dialect=dialect),
-        }
-        all_clauses: list[ClauseInfo] = []
-        if isinstance(columns, str) or not isinstance(columns, tp.Iterable):
-            columns = (columns,)
-        for value in columns:
-            all_clauses.append(dicc_type.get(type(value), dicc_type["default"])(value))
-
-        return all_clauses
-
-    @tp.override
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        wrapped_ci = self.wrapped_clause_info(self)
-        if not self._alias_aggregate:
-            return wrapped_ci
-
-        return ClauseInfo(
-            table=None,
-            column=wrapped_ci,
-            alias_clause=self._alias_aggregate,
-            context=self._context,
-            keep_asterisk=self._keep_asterisk,
-            preserve_context=self._preserve_context,
-            dialect=self._dialect,
-        ).query(dialect, **kwargs)
-
-    def wrapped_clause_info(self, ci: ClauseInfo[T]) -> str:
-        # avoid use placeholder when using IAggregate because no make sense.
-        if self._alias_aggregate and (found := self._keyRegex.findall(self._alias_aggregate)):
-            raise NotKeysInIAggregateError(found)
-
-        return f"{self.FUNCTION_NAME()}({ci._create_query(self._dialect)})"

ormlambda/sql/clause_info/clause_info_context.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-import abc
-from typing import Literal, Optional, TYPE_CHECKING, overload
-
-from ormlambda import Table
-from ormlambda.sql.types import (
-    TableType,
-)
-
-from ormlambda import Column
-
-if TYPE_CHECKING:
-    from .clause_info import ClauseInfo
-
-
-class IClauseInfo(abc.ABC): ...
-
-
-AliasChoiceType = Literal["TABLE", "CLAUSE"]
-
-type ClauseAliasKey[T: Table, TProp] = tuple[TableType[T], Column[TProp]]
-type TableAliasKey[T: Table] = T
-
-type AliasKey[T: Table, TProp] = ClauseAliasKey[T, TProp] | TableAliasKey[T]
-
-type ClauseContextType = Optional[ClauseInfoContext]
-
-
-class ClauseInfoContext(IClauseInfo):
-    @overload
-    def __init__(self) -> None: ...
-    @overload
-    def __init__[T: Table, TProp](self, clause_context: dict[ClauseAliasKey[T, TProp], str]) -> None: ...
-    @overload
-    def __init__[T: Table](self, table_context: dict[TableAliasKey[T], str]) -> None: ...
-
-    def __init__[T: Table, TProp](
-        self,
-        clause_context: Optional[dict[ClauseAliasKey[T, TProp], str]] = None,
-        table_context: Optional[dict[TableAliasKey[T], str]] = None,
-    ) -> None:
-        self._clause_context: dict[AliasKey[T, TProp], str] = clause_context if clause_context else {}
-        self._table_context: dict[AliasKey[T, TProp], str] = table_context if table_context else {}
-
-    def add_clause_to_context[T: Table](self, clause: ClauseInfo[T]) -> None:
-        if not clause:
-            return None
-
-        if t := clause.table:
-            self._add_table_alias(t, clause._alias_table)
-        if c := clause.column:
-            self._add_clause_alias((t, c, type(clause)), clause._alias_clause)
-
-        return None
-
-    def _add_clause_alias[T: Table, TProp](self, key: AliasKey[T, TProp], alias: str) -> None:
-        if not all([key, alias]):
-            return None
-
-        self._clause_context[key] = alias
-
-        return None
-
-    def _add_table_alias[T: Table, TProp](self, key: AliasKey[T, TProp], alias: str) -> None:
-        if not all([key, alias]):
-            return None
-
-        self._table_context[key] = alias
-
-        return None
-
-    def get_clause_alias[T: Table, TProp](self, clause: ClauseInfo[T]) -> Optional[str]:
-        table_col: ClauseAliasKey[T, TProp] = (clause.table, clause.column, type(clause))
-        return self._clause_context.get(table_col, None)
-
-    def get_table_alias[T: Table](self, table: T) -> Optional[str]:
-        return self._table_context.get(table, None)
-
-    def update(self, context: ClauseInfoContext) -> None:
-        if not context:
-            return None
-        if not isinstance(context, ClauseInfoContext):
-            raise ValueError(f"A '{ClauseInfoContext.__name__}' type was expected")
-
-        self._table_context.update(context._table_context)
-        self._clause_context.update(context._clause_context)
-        return None

ormlambda/sql/clauses/interfaces/ISelect.py

@@ -1,17 +0,0 @@
-from __future__ import annotations
-import abc
-from ormlambda.common.interfaces import IQuery
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ormlambda.sql.clause_info import ClauseInfo
-
-
-class ISelect(IQuery):
-    @property
-    @abc.abstractmethod
-    def FROM(self) -> ClauseInfo: ...
-
-    @property
-    @abc.abstractmethod
-    def COLUMNS(self) -> str: ...

ormlambda/sql/clauses/new_join.py

@@ -1,119 +0,0 @@
-from __future__ import annotations
-from collections import defaultdict
-from typing import override, Optional, TYPE_CHECKING, Type
-
-
-from ormlambda.util.module_tree.dfs_traversal import DFSTraversal
-from ormlambda.common.interfaces.IQueryCommand import IQuery
-from ormlambda import JoinType
-from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.sql.comparer import Comparer
-from ormlambda.sql.elements import ClauseElement
-
-
-# TODOL [x]: Try to import Table module without circular import Error
-if TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class Join(ClauseElement):
-    __visit_name__ = "join"
-    __slots__: tuple = (
-        "comparer",
-        "alias",
-        "from_clause",
-        "left_clause",
-        "right_clause",
-        "by",
-        "_dialect",
-    )
-
-    DEFAULT_TABLE: str = "{table}"
-
-    @override
-    def __repr__(self) -> str:
-        return f"{IQuery.__name__}: {self.query(self._dialect)}"
-
-    def __init__(
-        self,
-        comparer: Comparer,
-        right_alias: Optional[str] = DEFAULT_TABLE,
-        left_alias: Optional[str] = DEFAULT_TABLE,
-        by: JoinType = JoinType.LEFT_EXCLUSIVE,
-        *,
-        dialect: Dialect,
-        **kw,
-    ) -> None:
-        self.comparer = comparer
-        self._dialect = dialect
-        self.by = by
-
-        # COMMENT: When multiple columns reference the same table, we need to create an alias to maintain clear references.
-        self.alias: Optional[str] = right_alias
-        self.left_clause: ClauseInfo = comparer.left_condition(dialect)
-        self.left_clause.alias_table = left_alias if left_alias is not None else self.DEFAULT_TABLE
-
-        self.right_clause: ClauseInfo = comparer.right_condition(dialect)
-        self.right_clause.alias_table = right_alias if right_alias is not None else self.DEFAULT_TABLE
-        self.from_clause = ClauseInfo(self.right_clause.table, None, alias_table=self.alias, dialect=dialect)
-
-    def __eq__(self, __value: Join) -> bool:
-        return isinstance(__value, Join) and self.__hash__() == __value.__hash__()
-
-    def __hash__(self) -> int:
-        return hash(
-            (
-                self.by,
-                self.left_clause.query(self._dialect),
-                self.right_clause.query(self._dialect),
-                self.from_clause.query(self._dialect),
-            )
-        )
-
-    @classmethod
-    def join_selectors(cls, dialect: Dialect, *args: Join) -> str:
-        return "\n".join([x.query(dialect) for x in args])
-
-    def query(self, dialect: Dialect) -> str:
-        list_ = [
-            self.by.value,  # inner join
-            self.from_clause.query(dialect),
-            "ON",
-            self.left_clause.query(dialect),
-            "=",
-            self.right_clause.query(dialect),
-        ]
-        return " ".join([x for x in list_ if x is not None])
-
-    @classmethod
-    def sort_join_selectors(cls, joins: set[Join]) -> tuple[Join]:
-        # FIXME [x]: How to sort when needed because it's not necessary at this point. It is for testing purpouse
-        if len(joins) == 1:
-            return tuple(joins)
-
-        # create graph and sort it using 'Depth First Search' algorithm
-        graph: dict[str, list[str]] = defaultdict(list)
-        for join in joins:
-            graph[join.left_clause.alias_table].append(join.right_clause.alias_table)
-
-        sorted_graph = DFSTraversal.sort(graph)[::-1]
-
-        if not sorted_graph:
-            return tuple(joins)
-
-        # Mapped Join class using his unique alias
-        join_object_map: dict[str, Join] = {}
-        for obj in joins:
-            join_object_map[obj.alias] = obj
-
-        res = []
-        for table in sorted_graph:
-            tables = join_object_map.get(table, None)
-
-            if not tables:
-                continue
-            res.append(tables)
-        return res
-
-
-__all__ = ["Join"]