dapper-sqls 0.9.2__py3-none-any.whl

dapper_sqls/__init__.py

@@ -0,0 +1,7 @@
+from .dapper import Dapper
+from .async_dapper import AsyncDapper
+from .models import TableBaseModel
+from .builders import ModelBuilder, StpBuilder, AsyncStpBuilder
+from .sqlite import LocalDatabase
+
+

dapper_sqls/_types.py

@@ -0,0 +1,15 @@
+from typing import TypeVar
+from enum import Enum
+
+
+T = TypeVar('T')
+
+class ExecType(Enum):
+    send = "send"
+    fetchone = "fetchone"
+    fetchall = "fetchall"
+
+
+
+
+

dapper_sqls/async_dapper/__init__.py

@@ -0,0 +1,5 @@
+from .async_dapper import AsyncDapper
+
+
+
+

dapper_sqls/async_dapper/async_dapper.py

@@ -0,0 +1,67 @@
+# -*- coding: latin -*-
+from .._types import  T
+from ..config import Config
+from ..models import Result
+from typing import Type, overload
+from .async_executors import AsyncQuery, AsyncStored
+
+class AsyncDapper(object):
+
+    def __init__(self,  server: str , database : str , username : str, password : str, sql_version : int = None, api_environment = False, default_attempts = 1, default_wait_timeout = 2):
+        self._config = Config(server, database, username, password, sql_version, api_environment, default_attempts, default_wait_timeout)
+        
+    async def query(self, attempts : int = None, wait_timeout : int = None):
+        attempts = attempts if attempts else self.config.default_attempts
+        wait_timeout = wait_timeout if wait_timeout else self.config.default_wait_timeout
+        return AsyncQuery(self.config.connectionStringDataQuery.get(), attempts, wait_timeout, self._config.sql_version, self._config.api_environment)
+
+    async def stored(self, attempts : int = None, wait_timeout : int = None):
+        attempts = attempts if attempts else self.config.default_attempts
+        wait_timeout = wait_timeout if wait_timeout else self.config.default_wait_timeout
+        return AsyncStored(self.config.connectionStringDataStored.get() , attempts, wait_timeout, self._config.sql_version, self._config.api_environment)
+
+    @property
+    def config(self):
+        return self._config
+    
+    @overload
+    @staticmethod
+    def load(model : Type[T], dict_data : dict) -> T:
+        pass
+
+    @overload
+    @staticmethod
+    def load(model : Type[T], list_dict_data : list[dict]) -> list[T]:
+        pass
+
+    @overload
+    @staticmethod
+    def load(model : Type[T], fetchone : Result.Fetchone) -> T:
+        pass
+
+    @overload
+    @staticmethod
+    def load(model : Type[T], fetchall : Result.Fetchall) -> list[T]:
+        pass
+
+    @staticmethod
+    def load(*args) -> object | list[object]:
+        model = args[0] 
+        data = args[1]
+        if isinstance(args[1], dict) or isinstance(args[1], Result.Fetchone):
+            if isinstance(args[1], Result.Fetchone):
+                data = data.dict
+            if all(value is None for value in data.values()):
+                return model()
+
+            return model(**data)
+
+        if isinstance(args[1], Result.Fetchall):
+                data = data.list_dict
+
+        return [model(**d) for d in data]
+
+
+
+
+

dapper_sqls/async_dapper/async_executors.py

@@ -0,0 +1,343 @@
+# -*- coding: latin -*-
+import aioodbc, asyncio
+from typing import overload
+from datetime import datetime
+from abc import ABC, abstractmethod
+from ..models import ConnectionStringData, Result, UnavailableServiceException, BaseUpdate
+from .._types import T, ExecType
+from ..config import Config
+from ..builders import QueryBuilder, StoredBuilder
+from ..utils import Utils
+
+class AsyncBaseExecutor(ABC):
+    def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int, sql_version : int | None, api_environment : bool):
+        self._connectionStringData = connectionStringData
+        self._cursor = None
+        self._connection = None
+        self._wait_timeout = wait_timeout 
+        self._attempts = attempts 
+        self._sql_version = sql_version
+        self._api_environment = api_environment
+
+    async def __aenter__(self):
+        cs_data = self._connectionStringData
+        for n in range(self._attempts):
+            odbc_version = f'ODBC Driver {self._sql_version} for SQL Server' 
+            if not self._sql_version:
+                all_driver_versions = Config.get_all_odbc_driver_versions()
+                if all_driver_versions:
+                    odbc_version = all_driver_versions[0]
+                else:
+                    raise RuntimeError("Nenhuma vers�o do driver ODBC for SQL Server foi encontrada.")
+            try:
+                connection_string = f'DRIVER={{{odbc_version}}};SERVER={cs_data.server};DATABASE={cs_data.database};UID={cs_data.username};PWD={cs_data.password}'
+                self._connection = await aioodbc.connect(dsn=connection_string)
+                self._cursor = await self._connection.cursor()
+
+            except Exception as e:
+                print(e)
+                print(f'Erro na conex�o com a base de dados, nova tentativa em {self._wait_timeout}s')
+                await asyncio.sleep(self._wait_timeout)
+
+        return self
+
+    async def __aexit__(self, *args):
+        if self._cursor:
+            await self._cursor.close()
+        if self._connection:
+            await self._connection.close()
+
+    @property
+    def connectionStringData(self):
+        return self._connectionStringData
+
+    @property
+    def api_environment(self):
+        return self._api_environment
+
+    @property
+    def sql_version(self):
+        return self._sql_version
+
+    @property
+    async def cursor(self):
+        if not self._cursor:
+            if self._connection:
+                self._cursor = await self._connection.cursor()
+        return self._cursor
+
+    @property
+    def connection(self):
+        if self._connection:
+            return self._connection
+
+    @property
+    def attempts(self):
+        return self._attempts
+
+    @attempts.setter
+    def attempts(self, value):
+        if isinstance(value, int):
+            self._attempts = value
+        else:
+            raise ValueError("O n�mero de tentativas deve ser um n�mero inteiro.")
+
+    @property
+    def wait_timeout(self):
+        return self._wait_timeout
+
+    @wait_timeout.setter
+    def wait_timeout(self, value):
+        if isinstance(value, int):
+            self._wait_timeout = value
+        else:
+            raise ValueError("O tempo de espera deve ser um n�mero inteiro.")
+
+    @abstractmethod
+    async def _exec_(self, connection, operation_sql, exec_type):
+        pass
+
+class AsyncQueryUpdate(BaseUpdate):
+    def __init__(self, executor : AsyncBaseExecutor, model : T):
+        super().__init__(executor, model)
+
+    @overload
+    async def where(self, model : T)  -> Result.Send:
+            pass
+
+    @overload
+    async def where(self, query : str)  -> Result.Send:
+        pass
+
+    async def where(self, *args) -> Result.Send:
+        query = QueryBuilder.update(self._set_data, *args)
+        return await self.executor._exec_(self.executor.connection , query, ExecType.send)
+
+
+class AsyncQuery(AsyncBaseExecutor):
+
+    def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int, sql_version : int | None, api_environment : bool):
+        super().__init__(connectionStringData, attempts, wait_timeout, sql_version, api_environment)
+
+    @overload
+    async def fetchone(self, query : str) -> Result.Fetchone:
+        pass
+
+    @overload
+    async def fetchone(self, model : T, additional_sql : str = "") -> T:
+        pass
+          
+    async def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+        args = Utils.args_query(*args, **kwargs)
+        if args.model:
+            args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
+        
+        result = await self._exec_(self._connection, args.query, ExecType.fetchone)
+        if args.model:
+            return args.model.__class__(**result.dict) if result.success else args.model.__class__()
+        return result
+
+    @overload
+    async def fetchall(self, query : str) -> Result.Fetchall:
+        pass
+
+    @overload
+    async def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+        pass
+
+    async def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+        args = Utils.args_query(*args, **kwargs)
+        if args.model:
+            args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
+
+        result = await self._exec_(self._connection, args.query, ExecType.fetchall)
+        if args.model:
+            return [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+        return result
+
+    async def execute(self, query : str) -> Result.Send:
+            return await self._exec_(self._connection, query, ExecType.send)
+
+    async def delete(self, model: T) -> Result.Send:
+        query = QueryBuilder.delete(model)
+        return await self._exec_(self._connection, query, ExecType.send)
+
+    def update(self, model: T):
+        return AsyncQueryUpdate(self, model)
+
+    async def insert(self, model: T, name_column_id = 'Id') -> Result.Insert:
+        insert_data = model.model_dump()
+        if name_column_id not in insert_data:
+            name_column_id = next(iter(insert_data.keys())) 
+
+        query = QueryBuilder.insert(model, name_column_id)
+        result : Result.Fetchone = await self._exec_(self._connection, query, ExecType.fetchone)
+        if result.success:
+            return Result.Insert(result.dict.get('Id', 0), result.status_code, result.message)
+        return Result.Insert(0, result.status_code, result.message)
+    
+    async def _exec_(self, connection, query_sql : str, exec_type : ExecType):
+ 
+        if not self._cursor:
+            if self._api_environment:
+                raise UnavailableServiceException()
+
+            if exec_type == ExecType.fetchone:
+                return Result.Fetchone(None, None, 503)
+            elif exec_type == ExecType.fetchall:
+                return Result.Fetchall(None, None, 503)
+            elif exec_type == ExecType.send:
+                return Result.Send(False, 503)
+
+        # executar
+        response = await self._cursor.execute(query_sql)
+
+        # ober resultado se nessesario
+        if exec_type == ExecType.fetchone:
+            result = Result.Fetchone(self._cursor, await response.fetchone())
+
+        elif exec_type == ExecType.fetchall:
+            result = Result.Fetchall(self._cursor, await response.fetchall())
+        elif exec_type == ExecType.send:
+            result = Result.Send(True)
+
+        # fazer o commit 
+        await connection.commit()
+
+        # retorna o resultado
+        return result
+
+
+class AsyncStoredUpdate(BaseUpdate):
+    def __init__(self, executor : AsyncBaseExecutor, model : T):
+        super().__init__(executor, model)
+
+    async def where(self, data : T)  -> Result.Send:
+        query, params = StoredBuilder.update(self._set_data, data)
+        return await self.executor._exec_(self.executor.connection, (query,  *params), ExecType.send)
+
+
+class AsyncStored(AsyncBaseExecutor):
+
+    def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int,sql_version : int | None,  api_environment : bool):
+        super().__init__(connectionStringData, attempts, wait_timeout, sql_version, api_environment)
+
+    @overload
+    async def fetchone(self, query : str, params : list | tuple) -> Result.Fetchone:
+        pass
+
+    @overload
+    async def fetchone(self, query : str, *params : int | str | datetime) -> Result.Fetchone:
+        pass
+
+    @overload
+    async def fetchone(self, model : T, additional_sql : str = "") -> T:
+        pass
+
+    async def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+        args = Utils.args_stored(*args, **kwargs)
+        if args.model:
+            args.query, args.params = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
+
+        result = await self._exec_(self._connection, (args.query, *args.params), ExecType.fetchone)
+        if args.model:
+            return args.model.__class__(**result.dict) if result.success else args.model.__class__()
+        return result
+
+    @overload
+    async def fetchall(self, query : str, params : list | tuple) -> Result.Fetchall:
+        pass
+
+    @overload
+    async def fetchall(self, query : str, *params : int | str | datetime) -> Result.Fetchall:
+        pass
+
+    @overload
+    async def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+        pass
+
+    async def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+        args = Utils.args_stored(*args, **kwargs)
+        if args.model:
+            args.query, args.params = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
+
+        result = await self._exec_(self._connection, (args.query, *args.params), ExecType.fetchall)
+        if args.model:
+            return [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+        return result
+
+    @overload
+    async def execute(self, query : str, *params : str | int) -> Result.Send:
+        pass
+
+    @overload
+    async def execute(self, query : str, params : list | tuple) -> Result.Send:
+        pass
+
+    async def execute(self, *args) -> Result.Send:
+        query = args[0]
+        params = args[1:]
+        if len(params) == 1 and isinstance(params[0], (list, tuple)):
+            params = params[0]
+        return await self._exec_(self._connection, (query, *params), ExecType.send)
+
+    async def delete(self, model: T) -> Result.Send:
+        query, params = StoredBuilder.delete(model)
+        return await self._exec_(self._connection, (query,  *params), ExecType.send)
+
+    def update(self, model: T):
+        return AsyncStoredUpdate(self, model)
+
+    async def insert(self, model: T, name_column_id = 'Id') -> Result.Insert:
+        insert_data = model.model_dump()
+        if name_column_id not in insert_data:
+            name_column_id = next(iter(insert_data.keys()))
+
+        query, params = StoredBuilder.insert(model, name_column_id)
+        result : Result.Fetchone = await self._exec_(self._connection, (query,  *params), ExecType.fetchone)
+        if result.success:
+            return Result.Insert(result.dict.get('Id', 0), result.status_code, result.message)
+        return Result.Insert(0, result.status_code, result.message)
+    
+    async def _exec_(self, connection , stored_procedure : tuple, exec_type : ExecType):
+ 
+        if not self._cursor:
+            if self._api_environment:
+                raise UnavailableServiceException()
+
+            if exec_type == ExecType.fetchone:
+                return Result.Fetchone(None, None, 503)
+            elif exec_type == ExecType.fetchall:
+                return Result.Fetchall(None, None, 503)
+            elif exec_type == ExecType.send:
+                return Result.Send(False, 503)
+
+        try:
+            # executar
+            response = await self._cursor.execute(*stored_procedure)
+
+            # ober resultado se nessesario
+            if exec_type == ExecType.fetchone:
+                result = Result.Fetchone(self._cursor, await response.fetchone())
+            elif exec_type == ExecType.fetchall:
+                result = Result.Fetchall(self._cursor, await response.fetchall())
+            elif exec_type == ExecType.send:
+                result = Result.Send(True)
+
+            # fazer o commit 
+            await connection.commit()
+            
+        except Exception as ex:
+            if exec_type == ExecType.fetchone:
+                return Result.Fetchone(None, None, 503, str(ex))
+            elif exec_type == ExecType.fetchall:
+                return Result.Fetchall(None, None, 503, str(ex))
+            elif exec_type == ExecType.send:
+                return Result.Send(False, 503, str(ex))
+
+        # retorna o resultado
+        return result
+
+
+
+

dapper_sqls/builders/__init__.py

@@ -0,0 +1,7 @@
+from .query import QueryBuilder
+from .stored import StoredBuilder
+from .model import ModelBuilder
+from .stp import StpBuilder, AsyncStpBuilder
+
+
+

dapper_sqls/builders/model/__init__.py

@@ -0,0 +1,5 @@
+from .model import ModelBuilder
+
+
+
+