ormlambda 3.12.2__py3-none-any.whl → 3.34.0__py3-none-any.whl

ormlambda/{databases/my_sql → dialects/mysql}/clauses/ST_AsText.py

@@ -1,7 +1,12 @@
+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]):
     """
@@ -20,16 +25,12 @@ class ST_AsText[T, TProp](AggregateFunctionBase[None]):
         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,
-        )
+        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:

ormlambda/{databases/my_sql → dialects/mysql}/clauses/ST_Contains.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import typing as tp
 
 from shapely import Point
@@ -6,6 +7,9 @@ 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"
@@ -16,15 +20,16 @@ class ST_Contains(IAggregate):
         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)
-        self.attr2: ClauseInfo[Point] = ClauseInfo[Point](None, point)
+        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
 
-    @property
-    def query(self) -> str:
-        return f"{self.FUNCTION_NAME}({self.attr1.query}, {self.attr2.query})"
+    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]:

ormlambda/dialects/mysql/clauses/__init__.py

@@ -0,0 +1,13 @@
+from .delete import DeleteQuery as Delete
+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/dialects/mysql/clauses/count.py

@@ -0,0 +1,33 @@
+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/dialects/mysql/clauses/delete.py

@@ -0,0 +1,9 @@
+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/dialects/mysql/clauses/group_by.py

@@ -0,0 +1,17 @@
+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/dialects/mysql/clauses/having.py

@@ -0,0 +1,12 @@
+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/dialects/mysql/clauses/insert.py

@@ -0,0 +1,9 @@
+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/dialects/mysql/clauses/joins.py

@@ -0,0 +1,14 @@
+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/dialects/mysql/clauses/limit.py

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

ormlambda/dialects/mysql/clauses/offset.py

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

ormlambda/dialects/mysql/clauses/order.py

@@ -0,0 +1,8 @@
+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/dialects/mysql/clauses/update.py

@@ -0,0 +1,8 @@
+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/dialects/mysql/clauses/upsert.py

@@ -0,0 +1,9 @@
+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/dialects/mysql/clauses/where.py

@@ -0,0 +1,7 @@
+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/mysql/mysqlconnector.py

@@ -0,0 +1,46 @@
+# dialects/mysql/mysqlconnector.py
+# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+# mypy: ignore-errors
+
+r"""
+.. dialect:: mysql+mysqlconnector
+    :name: MySQL Connector/Python
+    :dbapi: myconnpy
+    :connectstring: mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
+    :url: https://pypi.org/project/mysql-connector-python/
+
+.. note::
+
+    The MySQL Connector/Python DBAPI has had many issues since its release,
+    some of which may remain unresolved, and the mysqlconnector dialect is
+    The recommended MySQL dialects are mysqlclient and PyMySQL.
+
+"""  # noqa
+
+from __future__ import annotations
+from types import ModuleType
+from .base import MySQLCompiler
+from .base import MySQLDialect
+
+
+class MySQLCompiler_mysqlconnector(MySQLCompiler):
+    def visit_mod_binary(self, binary, operator, **kw):
+        return self.process(binary.left, **kw) + " % " + self.process(binary.right, **kw)
+
+
+class MySQLDialect_mysqlconnector(MySQLDialect):
+    driver = "mysqlconnector"
+    statement_compiler = MySQLCompiler_mysqlconnector
+
+    @classmethod
+    def import_dbapi(cls) -> ModuleType:
+        from mysql import connector
+
+        return connector
+
+
+dialect = MySQLDialect_mysqlconnector

ormlambda/dialects/mysql/repository/__init__.py

@@ -0,0 +1 @@
+from .repository import MySQLRepository

ormlambda/dialects/mysql/repository/repository.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+import contextlib
+from pathlib import Path
+from typing import Generator, Iterable, Optional, Type, override, TYPE_CHECKING, Unpack
+import uuid
+
+# from mysql.connector.pooling import MySQLConnectionPool
+from mysql.connector import MySQLConnection  # noqa: F401
+from mysql.connector.pooling import MySQLConnectionPool  # noqa: F401
+from ormlambda.repository import BaseRepository
+
+# Custom libraries
+from ormlambda.repository.response import Response
+from ormlambda.caster import Caster
+
+if TYPE_CHECKING:
+    from ormlambda import URL as _URL
+    from ormlambda.sql.clauses import Select
+    from .pool_types import MySQLArgs
+
+
+class MySQLRepository(BaseRepository[MySQLConnectionPool]):
+    # def get_connection[**P, TReturn](func: Callable[Concatenate[MySQLRepository, MySQLConnection, P], TReturn]) -> Callable[P, TReturn]:
+    #     def wrapper(self: MySQLRepository, *args: P.args, **kwargs: P.kwargs):
+    #         with self.get_connection() as cnx:
+    #             try:
+    #                 return func(self, cnx._cnx, *args, **kwargs)
+    #             except Exception as e:
+    #                 cnx._cnx.rollback()
+    #                 raise e
+
+    #     return wrapper
+
+    #
+
+    def __init__(
+        self,
+        /,
+        url: Optional[_URL] = None,
+        *,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        host: Optional[str] = None,
+        database: Optional[str] = None,
+        **kwargs: Unpack[MySQLArgs],
+    ):
+        timeout = self.__add_connection_timeout(kwargs)
+        name = self.__add_pool_name(kwargs)
+        size = self.__add_pool_size(kwargs)
+        attr = kwargs.copy()
+        attr["connection_timeout"] = timeout
+        attr["pool_name"] = name
+        attr["pool_size"] = size
+
+        super().__init__(
+            user=user if not url else url.username,
+            password=password if not url else url.password,
+            host=host if not url else url.host,
+            database=database if not url else url.database,
+            pool=MySQLConnectionPool,
+            **attr,
+        )
+
+    @staticmethod
+    def __add_connection_timeout(kwargs: MySQLArgs) -> int:
+        if "connection_timeout" not in kwargs.keys():
+            return 60
+        return int(kwargs.pop("connection_timeout"))
+
+    @staticmethod
+    def __add_pool_name(kwargs: MySQLArgs) -> str:
+        if "pool_name" not in kwargs.keys():
+            return str(uuid.uuid4())
+
+        return kwargs.pop("pool_name")
+
+    @staticmethod
+    def __add_pool_size(kwargs: MySQLArgs) -> int:
+        if "pool_size" not in kwargs.keys():
+            return 5
+        return int(kwargs.pop("pool_size"))
+
+    @contextlib.contextmanager
+    def get_connection(self) -> Generator[MySQLConnection, None, None]:
+        with self._pool.get_connection() as cnx:
+            try:
+                yield cnx._cnx
+                cnx._cnx.commit()
+            except Exception as exc:
+                cnx._cnx.rollback()
+                raise exc
+
+    @override
+    def read_sql[TFlavour: Iterable](
+        self,
+        query: str,
+        flavour: tuple | Type[TFlavour] = tuple,
+        **kwargs,
+    ) -> tuple[TFlavour]:
+        """
+        Return tuple of tuples by default.
+
+        ATTRIBUTE
+        -
+            - query:str: string of request to the server
+            - flavour: Type[TFlavour]: Useful to return tuple of any Iterable type as dict,set,list...
+        """
+
+        select: Select = kwargs.pop("select", None)
+
+        with self.get_connection() as cnx:
+            with cnx.cursor(buffered=True) as cursor:
+                cursor.execute(query)
+                values: list[tuple] = cursor.fetchall()
+                columns: tuple[str] = cursor.column_names
+                return Response(
+                    dialect=self._dialect,
+                    response_values=values,
+                    columns=columns,
+                    flavour=flavour,
+                    select=select,
+                ).response(**kwargs)
+
+    # FIXME [ ]: this method does not comply with the implemented interface
+    def create_tables_code_first(self, path: str | Path) -> None:
+        return
+        from ormlambda.utils.module_tree.dynamic_module import ModuleTree
+
+        if not isinstance(path, Path | str):
+            raise ValueError
+
+        if isinstance(path, str):
+            path = Path(path).resolve()
+
+        if not path.exists():
+            raise FileNotFoundError
+
+        module_tree: ModuleTree = ModuleTree(path)
+
+        queries_list: list[str] = module_tree.get_queries()
+
+        for query in queries_list:
+            with self.get_connection() as cnx:
+                with cnx.cursor(buffered=True) as cursor:
+                    cursor.execute(query)
+        return None
+
+    @override
+    def executemany_with_values(self, query: str, values) -> None:
+        with self.get_connection() as cnx:
+            with cnx.cursor(buffered=True) as cursor:
+                cursor.executemany(query, values)
+        return None
+
+    @override
+    def execute_with_values(self, query: str, values) -> None:
+        with self.get_connection() as cnx:
+            with cnx.cursor(buffered=True) as cursor:
+                cursor.execute(query, values)
+        return None
+
+    @override
+    def execute(self, query: str) -> None:
+        with self.get_connection() as cnx:
+            with cnx.cursor(buffered=True) as cursor:
+                cursor.execute(query)
+        return None
+
+    @override
+    def database_exists(self, name: str) -> bool:
+        temp_config = self._pool._cnx_config
+
+        config_without_db = temp_config.copy()
+
+        if "database" in config_without_db:
+            config_without_db.pop("database")
+        self._pool.set_config(**config_without_db)
+
+        with self.get_connection() as cnx:
+            with cnx.cursor(buffered=True) as cursor:
+                cursor.execute(f"SHOW DATABASES LIKE {Caster.PLACEHOLDER};", (name,))
+                res = cursor.fetchmany(1)
+
+        self._pool.set_config(**temp_config)
+        return len(res) > 0
+
+    @override
+    def table_exists(self, name: str) -> bool:
+        with self.get_connection() as cnx:
+            if not cnx.database:
+                raise Exception("No database selected")
+            with cnx.cursor(buffered=True) as cursor:
+                cursor.execute(f"SHOW TABLES LIKE {Caster.PLACEHOLDER};", (name,))
+            res = cursor.fetchmany(1)
+        return len(res) > 0
+
+    @property
+    def database(self) -> Optional[str]:
+        return self._pool._cnx_config.get("database", None)
+
+    @database.setter
+    def database(self, value: str) -> None:
+        """Change the current database using USE statement"""
+
+        if not self.database_exists(value):
+            raise ValueError(f"You cannot set the non-existent '{value}' database.")
+
+        old_config: MySQLArgs = self._pool._cnx_config.copy()
+        old_config["database"] = value
+
+        self._pool._remove_connections()
+        self._pool = type(self)(**old_config)._pool