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

ormlambda/databases/my_sql/clauses/update.py

@@ -1,71 +1,8 @@
-from typing import Type, override, Any
+from mysql.connector import MySQLConnection
 
-from ormlambda.components.update import UpdateQueryBase
-from ormlambda import Table, Column
-from ormlambda.repository import IRepositoryBase
-from ormlambda.caster.caster import Caster
-from .where import Where
-from ormlambda.sql.types import ColumnType
+from ormlambda.sql.clauses import Update
 
 
-class UpdateKeyError(KeyError):
-    def __init__(self, table: Type[Table], key: str | ColumnType, *args):
-        super().__init__(*args)
-        self._table: Type[Table] = table
-        self._key: str | ColumnType = key
-
-    def __str__(self):
-        if isinstance(self._key, Column):
-            return f"The column '{self._key.column_name}' does not belong to the table '{self._table.__table_name__}'; it belongs to the table '{self._key.table.__table_name__}'. Please check the columns in the query."
-        return f"The column '{self._key}' does not belong to the table '{self._table.__table_name__}'. Please check the columns in the query."
-
-
-class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: Any, where: list[Where]) -> None:
+class Update[T](Update[T, MySQLConnection]):
+    def __init__(self, model, repository, where):
         super().__init__(model, repository, where)
-
-    @override
-    @property
-    def CLAUSE(self) -> str:
-        return "UPDATE"
-
-    @override
-    def execute(self) -> None:
-        if self._where:
-            for where in self._where:
-                query_with_table = where.query
-                for x in where._comparer:
-                    # TODOH []: Refactor this part. We need to get only the columns withouth __table_name__ preffix
-                    self._query += " " + query_with_table.replace(x.left_condition.table.__table_name__ + ".", "")
-        return self._repository.execute_with_values(self._query, self._values)
-
-    @override
-    def update[TProp](self, dicc: dict[str | ColumnType[TProp], Any]) -> None:
-        if not isinstance(dicc, dict):
-            raise TypeError
-
-        col_names: list[Column] = []
-        CASTER = Caster(self._repository)
-        for col, value in dicc.items():
-            if isinstance(col, str):
-                if not hasattr(self._model, col):
-                    raise UpdateKeyError(self._model, col)
-                col = getattr(self._model, col)
-            if not isinstance(col, Column):
-                raise ValueError
-
-            if self.__is_valid__(col):
-                clean_data = CASTER.for_value(value)
-                col_names.append((col.column_name, clean_data.wildcard_to_insert()))
-                self._values.append(clean_data.to_database)
-
-        set_query: str = ",".join(["=".join(col_data) for col_data in col_names])
-
-        self._query = f"{self.CLAUSE} {self._model.__table_name__} SET {set_query}"
-        self._values = tuple(self._values)
-        return None
-
-    def __is_valid__(self, col: Column) -> bool:
-        if self._model is not col.table:
-            raise UpdateKeyError(self._model, col)
-        return not col.is_auto_generated

ormlambda/databases/my_sql/clauses/upsert.py

@@ -1,72 +1,9 @@
 from __future__ import annotations
-from typing import override, TYPE_CHECKING
 
 from ormlambda import Table
-from ormlambda.components.upsert import UpsertQueryBase
-from ormlambda.repository import IRepositoryBase, BaseRepository
+from ormlambda.sql.clauses.upsert import Upsert
 
 
-from .insert import InsertQuery
-
-if TYPE_CHECKING:
-    from mysql.connector import MySQLConnection
-
-
-class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: BaseRepository[MySQLConnection]) -> None:
+class UpsertQuery[T: Table](Upsert):
+    def __init__(self, model, repository):
         super().__init__(model, repository)
-
-    @override
-    @property
-    def CLAUSE(self) -> str:
-        return "ON DUPLICATE KEY UPDATE"
-
-    @override
-    def execute(self) -> None:
-        return self._repository.executemany_with_values(self._query, self._values)
-
-    @override
-    def upsert(self, instances: T | list[T]) -> None:
-        """
-        Esta funcion se enfoca para trabajar con listas, aunque el argumneto changes sea un unico diccionario.
-
-        Accedemos a la primera posicion de la lista 'changes[0]' porque en la query solo estamos poniendo marcadores de posicion, alias y nombres de columnas
-
-        EXAMPLE
-        ------
-
-        MySQL
-        -----
-
-        INSERT INTO NAME_TABLE(PK_COL,COL2)
-        VALUES
-        (1,'PABLO'),
-        (2,'MARINA') AS _val
-        ON DUPLICATE KEY UPDATE
-        COL2 = _val.COL2;
-
-        Python
-        -----
-
-        INSERT INTO NAME_TABLE(PK_COL,COL2)
-        VALUES (%s, %s') AS _val
-        ON DUPLICATE KEY UPDATE
-        COL2 = _val.COL2;
-
-        """
-        insert = InsertQuery[T](self._model, self._repository)
-        insert.insert(instances)
-
-        if isinstance(instances, Table):
-            instances = tuple([instances])
-        ALIAS = "VALUES"
-
-        cols = instances[0].get_columns()
-        pk_key = instances[0].get_pk().column_name
-
-        alternative = ", ".join([f"{col}={ALIAS}({col})" for col in cols if col != pk_key])
-        query = f"{insert._query} {self.CLAUSE} {alternative};"
-
-        self._query = query
-        self._values = insert.values
-        return None

ormlambda/databases/my_sql/clauses/where.py

@@ -1,45 +1,7 @@
 from __future__ import annotations
-import typing as tp
-from ormlambda.sql.comparer import Comparer
-from ormlambda.sql.clause_info import AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.clauses import Where
 
 
-class Where(AggregateFunctionBase):
-    """
-    The purpose of this class is to create 'WHERE' condition queries properly.
-    """
-
-    def __init__(self, *comparer: Comparer, restrictive: bool = True, context: ClauseContextType = None) -> None:
-        self._comparer: tuple[Comparer] = comparer
-        self._restrictive: bool = restrictive
-        self._context: ClauseContextType = context if context else ClauseInfoContext()
-
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "WHERE"
-
-    @property
-    def query(self) -> str:
-        if isinstance(self._comparer, tp.Iterable):
-            context = ClauseInfoContext(table_context=self._context._table_context)
-            comparer = Comparer.join_comparers(self._comparer, restrictive=self._restrictive, context=context)
-        else:
-            comparer = self._comparer
-        return f"{self.FUNCTION_NAME()} {comparer}"
-
-    @property
-    def alias_clause(self) -> None:
-        return None
-
-    @classmethod
-    def join_condition(cls, wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext) -> str:
-        if not isinstance(wheres, tp.Iterable):
-            wheres = (wheres,)
-
-        comparers: list[Comparer] = []
-        for where in wheres:
-            for c in where._comparer:
-                c.set_context(context)
-                comparers.append(c)
-        return cls(*comparers, restrictive=restrictive, context=context).query
+class Where(Where):
+    def __init__(self, *comparer, restrictive=True, context=None):
+        super().__init__(*comparer, restrictive=restrictive, context=context)

ormlambda/databases/my_sql/repository.py

@@ -0,0 +1,217 @@
+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 .clauses import DropTable
+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 drop_table(self, name: str) -> None:
+        return DropTable(self).execute(name)
+
+    @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

ormlambda/dialects/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from typing import Callable, Optional, Type, TYPE_CHECKING
+from ormlambda import util
+import importlib
+
+if TYPE_CHECKING:
+    from .interface import Dialect
+
+
+__all__ = ("mysql", "sqlite")
+
+
+def _auto_fn(name: str) -> Optional[Callable[[], Type[Dialect]]]:
+    """default dialect importer.
+
+    plugs into the :class:`.PluginLoader`
+    as a first-hit system.
+
+    """
+    if "." in name:
+        dialect, driver = name.split(".")
+    else:
+        dialect = name
+        driver = "base"
+
+    try:
+        module = importlib.import_module(f"ormlambda.dialects.{dialect}")
+
+    except ImportError:
+        return None
+
+    if hasattr(module, driver):
+        module = getattr(module, driver)
+        return lambda: module.dialect
+    else:
+        return None
+
+
+registry = util.PluginLoader("ormlambda.dialects", auto_fn=_auto_fn)

ormlambda/dialects/default/__init__.py

@@ -0,0 +1 @@
+from .base import DefaultDialect

ormlambda/dialects/default/base.py

@@ -0,0 +1,39 @@
+from ormlambda.dialects.interface import Dialect
+from ormlambda.sql import compiler
+from typing import Optional, Any
+from types import ModuleType
+from ormlambda import BaseRepository
+
+
+class DefaultDialect(Dialect):
+    """Default implementation of Dialect"""
+
+    statement_compiler = compiler.SQLCompiler
+    ddl_compiler = compiler.DDLCompiler
+    type_compiler_cls = compiler.GenericTypeCompiler
+    repository_cls = BaseRepository
+    default_paramstyle = "named"
+
+    def __init__(
+        self,
+        dbapi: Optional[ModuleType] = None,  # type: ignore
+        **kwargs: Any,
+    ):
+        self.dbapi = dbapi
+
+        if self.dbapi is not None:
+            self.paramstyle = self.dbapi.paramstyle
+        else:
+            self.paramstyle = self.default_paramstyle
+        self.positional = self.paramstyle in (
+            "qmark",
+            "format",
+            "numeric",
+            "numeric_dollar",
+        )
+
+        tt_callable = self.type_compiler_cls
+
+        self.type_compiler_instance = self.type_compiler = tt_callable(self)
+
+        super().__init__(**kwargs)

ormlambda/dialects/interface/__init__.py

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

ormlambda/dialects/interface/dialect.py

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

@@ -0,0 +1,8 @@
+from . import base
+from . import mysqlconnector
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect
+
+
+from .types import *  # noqa: F403