dapper-sqls 0.9.2__py3-none-any.whl

dapper_sqls/builders/stp.py

@@ -0,0 +1,133 @@
+from ..utils import get_dict_args, Utils
+from .._types import T
+from ..models import Result
+from typing import overload, Union
+from abc import ABC
+
+class StpBaseBuilder(ABC):
+
+    @staticmethod
+    def build_data(stp_name : str, **kwargs : dict[str, Union[int, str, any]]):
+        query = f"EXEC {stp_name} "
+        i = 0
+        for chave, valor in kwargs.items():
+            i += 1
+            query += f"@{chave} = ?"
+            if i < len(kwargs):
+                query += ", "
+
+        return query, tuple(kwargs.values())
+
+
+    def __init__(self, stp_name : str, _locals : Union[object ,dict[str, Union[int, str, any]]]):
+        _locals = _locals if isinstance(_locals, dict) else _locals()
+        query , params = self.build_data(stp_name, **get_dict_args(_locals, ignore_values_none=False))
+        self._query = query
+        self._params = params
+
+    @property
+    def query(self):
+        return self._query
+
+    @property
+    def params(self):
+        return self._params
+
+class StpBuilder(StpBaseBuilder):
+
+    def __init__(self, dapper, stp_name : str, _locals : Union[object ,dict[str, Union[int, str, any]]]):
+        self._dapper = dapper
+        super().__init__(stp_name, _locals)
+
+    @property
+    def dapper(self):
+        return self._dapper
+
+    def execute(self, attempts : int = None, wait_timeout : int = None) -> Result.Send:
+        with self.dapper.stored(attempts, wait_timeout) as db:
+            return db.execute(self.query, self.params)
+
+    @overload
+    def fetchone(self, attempts : int = None, wait_timeout : int = None) -> Result.Fetchone:
+            pass
+
+    @overload
+    def fetchone(self, model : T , attempts : int = None, wait_timeout : int = None) -> T:
+            pass
+
+    def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+        args = Utils.args_stp(*args, **kwargs)
+
+        with self.dapper.stored(args.attempts, args.wait_timeout) as db:
+            result = db.fetchone(self.query, self.params)
+            if args.model:
+                return self.dapper.load(args.model, result)
+            return result
+
+    @overload
+    def fetchall(self, attempts : int = None, wait_timeout : int = None) -> Result.Fetchall:
+            pass
+
+    @overload
+    def fetchall(self, model : T, attempts : int = None, wait_timeout : int = None) -> list[T]:
+            pass
+
+    def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+        args = Utils.args_stp(*args, **kwargs)
+            
+        with self.dapper.stored(args.attempts, args.wait_timeout) as db:
+            result = db.fetchall(self.query, self.params)
+            if args.model:
+                    return self.dapper.load(args.model, result)
+            return result
+
+
+class AsyncStpBuilder(StpBaseBuilder):
+
+    def __init__(self, async_dapper, stp_name : str, _locals : Union[object ,dict[str, Union[int, str, any]]]):
+        self._async_dapper = async_dapper
+        super().__init__(stp_name, _locals)
+
+    @property
+    def async_dapper(self):
+        return self._async_dapper
+
+    async def execute(self, attempts : int = None, wait_timeout : int = None) -> Result.Send:
+        async with await self.async_dapper.stored(attempts, wait_timeout) as db:
+            return await db.execute(self.query, self.params)
+
+    @overload
+    async def fetchone(self, attempts : int = None, wait_timeout : int = None) -> Result.Fetchone:
+            pass
+
+    @overload
+    async def fetchone(self, model : T , attempts : int = None, wait_timeout : int = None) -> T:
+            pass
+
+    async def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+        args = Utils.args_stp(*args, **kwargs)
+
+        async with await self.async_dapper.stored(args.attempts, args.wait_timeout) as db:
+            result = await db.fetchone(self.query, self.params)
+            if args.model:
+                return self.async_dapper.load(args.model, result)
+            return result
+
+    @overload
+    async def fetchall(self, attempts : int = None, wait_timeout : int = None) -> Result.Fetchall:
+            pass
+
+    @overload
+    async def fetchall(self, model : T , attempts : int = None, wait_timeout : int = None) -> list[T]:
+            pass
+
+    async def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+        args = Utils.args_stp(*args, **kwargs)
+            
+        async with await self.async_dapper.stored(args.attempts, args.wait_timeout) as db:
+            result = await db.fetchall(self.query, self.params)
+            if args.model:
+                    return self.async_dapper.load(args.model, result)
+            return result
+
+

dapper_sqls/config.py

@@ -0,0 +1,109 @@
+# -*- coding: latin -*-
+from .models import ConnectionStringData
+import winreg
+
+class Config(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._api_environment = api_environment
+        self._default_attempts = default_attempts
+        self._default_wait_timeout = default_wait_timeout
+        self._connectionStringDataQuery = ConnectionStringData(server, database, username, password)
+        self._connectionStringDataStored = ConnectionStringData(server, database, username, password)
+        self._sql_version = sql_version
+
+    @property
+    def api_environment(self):
+        return self._api_environment
+
+    @api_environment.setter
+    def api_environment(self, value):
+        if not isinstance(value, bool):
+            raise ValueError("O valor atribu�do a api_environment deve ser do tipo booleano")
+        self._api_environment = value
+
+    @property
+    def default_attempts(self):
+        return self._default_attempts
+
+    @default_attempts.setter
+    def default_attempts(self, value):
+        if not isinstance(value, int):
+            raise ValueError("O valor atribu�do a default_attempts deve ser do tipo inteiro")
+        self._default_attempts = value
+
+    @property
+    def default_wait_timeout(self):
+        return self._default_wait_timeout
+
+    @default_wait_timeout.setter
+    def default_wait_timeout(self, value):
+        if not isinstance(value, int):
+            raise ValueError("O valor atribu�do a default_wait_timeout deve ser do tipo inteiro")
+        self._default_wait_timeout = value
+
+    @property
+    def connectionStringDataQuery(self):
+        return self._connectionStringDataQuery
+
+    @connectionStringDataQuery.setter
+    def connectionStringDataQuery(self, value):
+        if not isinstance(value, ConnectionStringData):
+            raise ValueError("O valor atribu�do a connectionStringDataQuery deve ser do tipo ConnectionStringData")
+        self._connectionStringDataQuery = value
+
+    @property
+    def connectionStringDataStored(self):
+        return self._connectionStringDataStored
+
+    @connectionStringDataStored.setter
+    def connectionStringDataStored(self, value):
+        if not isinstance(value, ConnectionStringData):
+            raise ValueError("O valor atribu�do a connectionStringDataStored deve ser do tipo ConnectionStringData")
+        self._connectionStringDataStored = value
+
+    @property
+    def sql_version(self):
+        return self._sql_version
+
+    @sql_version.setter
+    def sql_version(self, value):
+        if not isinstance(value, int) and value is not None:
+            raise ValueError("O valor atribu�do a sql_version deve ser do tipo inteiro ou None")
+        self._sql_version = value
+
+    @staticmethod
+    def get_all_odbc_driver_versions():
+        driver_versions = []
+        try:
+            # Abrir a chave onde as informa��es sobre os drivers ODBC est�o armazenadas
+            key_path = r"SOFTWARE\ODBC\ODBCINST.INI"
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path)
+
+            # Iterar sobre as subchaves para encontrar os drivers espec�ficos
+            i = 0
+            while True:
+                try:
+                    subkey_name = winreg.EnumKey(key, i)
+                    subkey = winreg.OpenKey(key, subkey_name)
+
+                    # Verificar se a subchave cont�m o valor 'Driver'
+                    try:
+                        driver_name, _ = winreg.QueryValueEx(subkey, "Driver")
+                        if subkey_name.startswith('ODBC Driver'):
+                            driver_versions.append(subkey_name)
+                    
+                    except FileNotFoundError:
+                        pass  # A subchave n�o possui a entrada 'Driver'
+
+                    i += 1
+                except OSError:
+                    break
+
+        except Exception as e:
+            print(f"Erro ao acessar o registro: {e}")
+
+        return sorted(driver_versions, key=lambda x: int(x.split()[-4]), reverse=True)
+
+
+
+

dapper_sqls/dapper/__init__.py

@@ -0,0 +1,6 @@
+from .dapper import Dapper
+
+
+
+
+

dapper_sqls/dapper/dapper.py

@@ -0,0 +1,66 @@
+# -*- coding: latin -*-
+from .._types import  T
+from ..config import Config
+from ..models import Result
+from typing import Type, overload
+from .executors import Query, Stored
+
+class Dapper(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)
+            
+        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 Query(self.config.connectionStringDataQuery.get(), attempts, wait_timeout, self._config.sql_version, self._config.api_environment)
+
+        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 Stored(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/dapper/executors.py

@@ -0,0 +1,342 @@
+# -*- coding: latin -*-
+import pyodbc
+from time import sleep
+from datetime import datetime
+from typing import overload
+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 BaseExecutor(ABC, object):
+    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
+
+    def __enter__(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 = pyodbc.connect(connection_string)
+                self._cursor = 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')
+                sleep(self._wait_timeout)
+
+        return self
+
+    def __exit__(self, *args):
+        if self._cursor:
+            self._cursor.close()
+        if self._connection:
+            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
+    def cursor(self):
+        if not self._cursor:
+            if self._connection:
+                self._cursor = 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
+    def _exec_(self, connection, operation_sql, exec_type):
+        pass
+
+class QueryUpdate(BaseUpdate):
+    def __init__(self, executor : BaseExecutor, model : T):
+        super().__init__(executor, model)
+
+    @overload
+    def where(self, model : T)  -> Result.Send:
+            pass
+
+    @overload
+    def where(self, query : str)  -> Result.Send:
+        pass
+
+    def where(self, *args) -> Result.Send:
+        query = QueryBuilder.update(self._set_data, *args)
+        return self.executor._exec_(self.executor.connection , query, ExecType.send)
+
+
+class Query(BaseExecutor):
+
+    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
+    def fetchone(self, query : str) -> Result.Fetchone:
+        pass
+
+    @overload
+    def fetchone(self, model : T, additional_sql : str = "") -> T:
+        pass
+          
+    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 = 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
+    def fetchall(self, query : str) -> Result.Fetchall:
+        pass
+
+    @overload
+    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+        pass
+
+    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 = 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 
+
+    def execute(self, query : str) -> Result.Send:
+        return self._exec_(self._connection, query, ExecType.send)
+
+    def delete(self, model: T) -> Result.Send:
+        query = QueryBuilder.delete(model)
+        return self._exec_(self._connection, query, ExecType.send)
+
+    def update(self, model: T):
+        return QueryUpdate(self, model)
+
+    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 = 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)
+        
+    def _exec_(self, connection, query_sql : str, exec_type : ExecType) -> Result.Send:
+
+        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 = self._cursor.execute(query_sql)
+
+            # ober resultado se nessesario
+            if exec_type == ExecType.fetchone:
+                result = Result.Fetchone(self._cursor, response.fetchone())
+            elif exec_type == ExecType.fetchall:
+                result = Result.Fetchall(self._cursor, response.fetchall())
+            elif exec_type == ExecType.send:
+                result = Result.Send(True)
+
+            # fazer o commit 
+            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
+
+class StoredUpdate(BaseUpdate):
+    def __init__(self, executor : BaseExecutor, model : T):
+        super().__init__(executor, model)
+
+    def where(self, data : T)  -> Result.Send:
+        query, params = StoredBuilder.update(self._set_data, data)
+        return self.executor._exec_(self.executor.connection, (query,  *params), ExecType.send)
+
+class Stored(BaseExecutor):
+
+    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
+    def fetchone(self, query : str, params : list | tuple) -> Result.Fetchone:
+        pass
+
+    @overload
+    def fetchone(self, query : str, *params : int | str | datetime) -> Result.Fetchone:
+        pass
+
+    @overload
+    def fetchone(self, model : T, additional_sql : str = "") -> T:
+        pass
+          
+    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 = 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
+    def fetchall(self, query : str, params : list | tuple) -> Result.Fetchall:
+        pass
+
+    @overload
+    def fetchall(self, query : str, *params : int | str | datetime) -> Result.Fetchall:
+        pass
+
+    @overload
+    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+        pass
+
+    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 = 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
+    def execute(self, query : str, *params : str | int) -> Result.Send:
+        pass
+
+    @overload
+    def execute(self, query : str, params : list | tuple) -> Result.Send:
+        pass
+
+    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 self._exec_(self._connection, (query, *params), ExecType.send)
+
+    def delete(self, model: T) -> Result.Send:
+        query, params = StoredBuilder.delete(model)
+        return self._exec_(self._connection, (query,  *params), ExecType.send)
+
+    def update(self, model: T):
+        return StoredUpdate(self, model)
+
+    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 = 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)
+
+    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)
+
+        # executar
+        response = self._cursor.execute(*stored_procedure)
+      
+        # ober resultado se nessesario
+        if exec_type == ExecType.fetchone:
+            result = Result.Fetchone(self._cursor, response.fetchone())
+        elif exec_type == ExecType.fetchall:
+            result = Result.Fetchall(self._cursor, response.fetchall())
+        elif exec_type == ExecType.send:
+            result = Result.Send(True)
+
+        # fazer o commit 
+        connection.commit()
+
+        # retorna o resultado
+        return result
+
+
+
+
+