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

ormlambda/databases/my_sql/{repository.py → repository/repository.py}

@@ -1,32 +1,34 @@
 from __future__ import annotations
+import contextlib
 from pathlib import Path
-from typing import Any, Optional, Type, override, Callable, TYPE_CHECKING
-import functools
+from typing import Any, Generator, Iterable, Optional, Type, override, TYPE_CHECKING
 import shapely as shp
 
 # from mysql.connector.pooling import MySQLConnectionPool
-from mysql.connector import MySQLConnection, Error  # noqa: F401
-from mysql.connector.pooling import PooledMySQLConnection, MySQLConnectionPool  # noqa: F401
+from mysql.connector import MySQLConnection  # noqa: F401
+from mysql.connector.pooling import MySQLConnectionPool  # noqa: F401
+from ormlambda.repository import BaseRepository
 
 # Custom libraries
-from ormlambda import IRepositoryBase
-from ormlambda.utils.module_tree.dynamic_module import ModuleTree
+from ormlambda.repository import IRepositoryBase
+from ormlambda.caster import Caster
 
-from .clauses import CreateDatabase, TypeExists
-from .clauses import DropDatabase
-from .clauses import DropTable
+from ..clauses import CreateDatabase, TypeExists
+from ..clauses import DropDatabase
+from ..clauses import DropTable
 
 
 if TYPE_CHECKING:
-    from src.ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
     from ormlambda import Table
-    from src.ormlambda.databases.my_sql.clauses.select import Select
+    from ormlambda.databases.my_sql.clauses.select import Select
 
 type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
 
 
 class Response[TFlavour, *Ts]:
-    def __init__(self, response_values: list[tuple[*Ts]], columns: tuple[str], flavour: Type[TFlavour], model: Optional[Table] = None, select: Optional[Select] = None) -> None:
+    def __init__(self, repository: IRepositoryBase, response_values: list[tuple[*Ts]], columns: tuple[str], flavour: Type[TFlavour], model: Optional[Table] = None, select: Optional[Select] = None) -> None:
+        self._repository: IRepositoryBase = repository
         self._response_values: list[tuple[*Ts]] = response_values
         self._columns: tuple[str] = columns
         self._flavour: Type[TFlavour] = flavour
@@ -35,6 +37,7 @@ class Response[TFlavour, *Ts]:
 
         self._response_values_index: int = len(self._response_values)
         # self.select_values()
+        self._caster = Caster(repository)
 
     @property
     def is_one(self) -> bool:
@@ -83,7 +86,16 @@ class Response[TFlavour, *Ts]:
             return [list(x) for x in data]
 
         def _default(**kwargs) -> list[TFlavour]:
-            return self._flavour(data, **kwargs)
+            replacer_dicc: dict[str, str] = {x.alias_clause: x.column for x in self._select.all_clauses}
+
+            cleaned_column_names = [replacer_dicc[col] for col in self._columns]
+
+            result = []
+            for attr in data:
+                dicc_attr = dict(zip(cleaned_column_names, attr))
+                result.append(self._flavour(**dicc_attr, **kwargs))
+
+            return result
 
         selector: dict[Type[object], Any] = {
             dict: _dict,
@@ -92,10 +104,11 @@ class Response[TFlavour, *Ts]:
             list: _list,
         }
 
+        selector.get(dict)()
         return selector.get(self._flavour, _default)(**kwargs)
 
     def _parser_response(self) -> TFlavour:
-        new_response: list[list] = []
+        new_response: list[tuple] = []
         for row in self._response_values:
             new_row: list = []
             for i, data in enumerate(row):
@@ -105,8 +118,9 @@ class Response[TFlavour, *Ts]:
                     new_row = row
                     break
                 else:
-                    parser_data = self.parser_data(clause_info, data)
-                    new_row.append(parser_data)
+                    parse_data = self._caster.for_value(data, value_type=clause_info.dtype).from_database
+                    new_row.append(parse_data)
+            new_row = tuple(new_row)
             if not isinstance(new_row, tuple):
                 new_row = tuple(new_row)
 
@@ -127,33 +141,38 @@ class Response[TFlavour, *Ts]:
         return data
 
 
-class MySQLRepository(IRepositoryBase[MySQLConnection]):
-    def get_connection(func: Callable[..., Any]):
-        @functools.wraps(func)
-        def wrapper(self: MySQLRepository, *args, **kwargs):
-            with self._pool.get_connection() as cnx:
-                try:
-                    return func(self, cnx._cnx, *args, **kwargs)
-                except Exception as e:
-                    cnx._cnx.rollback()
-                    raise e
+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
+    #     return wrapper
 
-    def __init__(self, **kwargs: Any) -> None:
-        self._data_config: dict[str, Any] = kwargs
-        self._pool: MySQLConnectionPool = self.__create_MySQLConnectionPool()
+    #
 
-    def __create_MySQLConnectionPool(self):
-        return MySQLConnectionPool(pool_name="mypool", pool_size=10, **self._data_config)
+    def __init__(self, **kwargs):
+        super().__init__(MySQLConnectionPool, **kwargs)
+
+    @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
-    @get_connection
-    def read_sql[TFlavour](
+    def read_sql[TFlavour: Iterable](
         self,
-        cnx: MySQLConnection,
         query: str,
-        flavour: Type[TFlavour] = tuple,
+        flavour: tuple | Type[TFlavour] = tuple,
         **kwargs,
     ) -> tuple[TFlavour]:
         """
@@ -169,15 +188,25 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         select: Select = kwargs.pop("select", None)
         cast_to_tuple: bool = kwargs.pop("cast_to_tuple", True)
 
-        with cnx.cursor(buffered=True) as cursor:
-            cursor.execute(query)
-            values: list[tuple] = cursor.fetchall()
-            columns: tuple[str] = cursor.column_names
-            return Response[TFlavour](model=model, response_values=values, columns=columns, flavour=flavour, select=select).response(_tuple=cast_to_tuple, **kwargs)
+        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[TFlavour](
+                    repository=self,
+                    model=model,
+                    response_values=values,
+                    columns=columns,
+                    flavour=flavour,
+                    select=select,
+                ).response(_tuple=cast_to_tuple, **kwargs)
 
     # FIXME [ ]: this method does not comply with the implemented interface
-    @get_connection
-    def create_tables_code_first(self, cnx: MySQLConnection, path: str | Path) -> None:
+    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
 
@@ -192,33 +221,30 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         queries_list: list[str] = module_tree.get_queries()
 
         for query in queries_list:
-            with cnx.cursor(buffered=True) as cursor:
-                cursor.execute(query)
-        cnx.commit()
+            with self.get_connection() as cnx:
+                with cnx.cursor(buffered=True) as cursor:
+                    cursor.execute(query)
         return None
 
     @override
-    @get_connection
-    def executemany_with_values(self, cnx: MySQLConnection, query: str, values) -> None:
-        with cnx.cursor(buffered=True) as cursor:
-            cursor.executemany(query, values)
-        cnx.commit()
+    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
-    @get_connection
-    def execute_with_values(self, cnx: MySQLConnection, query: str, values) -> None:
-        with cnx.cursor(buffered=True) as cursor:
-            cursor.execute(query, values)
-        cnx.commit()
+    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
-    @get_connection
-    def execute(self, cnx: MySQLConnection, query: str) -> None:
-        with cnx.cursor(buffered=True) as cursor:
-            cursor.execute(query)
-        cnx.commit()
+    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
@@ -226,12 +252,21 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return DropTable(self).execute(name)
 
     @override
-    @get_connection
-    def database_exists(self, cnx: MySQLConnection, name: str) -> bool:
+    def database_exists(self, name: str) -> bool:
         query = "SHOW DATABASES LIKE %s;"
-        with cnx.cursor(buffered=True) as cursor:
-            cursor.execute(query, (name,))
+        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(query, (name,))
             res = cursor.fetchmany(1)
+
+        self._pool.set_config(**temp_config)
         return len(res) > 0
 
     @override
@@ -239,20 +274,25 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return DropDatabase(self).execute(name)
 
     @override
-    @get_connection
-    def table_exists(self, cnx: MySQLConnection, name: str) -> bool:
-        if not cnx.database:
-            raise Exception("No database selected")
-
+    def table_exists(self, name: str) -> bool:
         query = "SHOW TABLES LIKE %s;"
-        with cnx.cursor(buffered=True) as cursor:
-            cursor.execute(query, (name,))
+        with self.get_connection() as cnx:
+            if not cnx.database:
+                raise Exception("No database selected")
+            with cnx.cursor(buffered=True) as cursor:
+                cursor.execute(query, (name,))
             res = cursor.fetchmany(1)
         return len(res) > 0
 
     @override
     def create_database(self, name: str, if_exists: TypeExists = "fail") -> None:
-        return CreateDatabase(self).execute(name, if_exists)
+        temp_config = self._pool._cnx_config
+
+        config_without_db = temp_config.copy()
+
+        if "database" in config_without_db:
+            config_without_db.pop("database")
+        return CreateDatabase(type(self)(**config_without_db)).execute(name, if_exists)
 
     @property
     def database(self) -> Optional[str]:
@@ -261,4 +301,4 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     @database.setter
     def database(self, value: str) -> None:
         self._data_config["database"] = value
-        self._pool = self.__create_MySQLConnectionPool()
+        self._pool.set_config(**self._data_config)