dapper-sqls 0.9.2__py3-none-any.whl

dapper_sqls/decorators.py

@@ -0,0 +1,63 @@
+# -*- coding: latin -*-
+from functools import wraps
+import asyncio
+from time import perf_counter
+from typing import Callable
+
+def func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True):
+    """
+    Synchronous function decorator for validation, error handling, and logging execution time.
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if use_log:
+                start = perf_counter()
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                error_message = str(e)
+                if error_message == "Database unavailable":
+                    if callable_msg_error:
+                        callable_msg_error("Service temporarily unavailable. Please try again later.")
+                else:
+                    if use_raise:
+                        raise
+                    else:
+                        print(f"Unhandled exception in '{func.__name__}': {error_message}")
+            finally:
+                if use_log:
+                    stop = perf_counter()
+                    execution_time = round(stop - start, 3)
+                    print(f"The function '{func.__name__}' executed in {execution_time} seconds.")
+        return wrapper
+    return decorator
+
+def async_func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True):
+    """
+    Asynchronous function decorator for validation, error handling, and logging execution time.
+    """
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            if use_log:
+                start = perf_counter()
+            try:
+                return await asyncio.create_task(func(*args, **kwargs))
+            except Exception as e:
+                error_message = str(e)
+                if error_message == "Database unavailable":
+                    if callable_msg_error:
+                        callable_msg_error("Service temporarily unavailable. Please try again later.")
+                else:
+                    if use_raise:
+                        raise
+                    else:
+                        print(f"Unhandled exception in async function '{func.__name__}': {error_message}")
+            finally:
+                if use_log:
+                    stop = perf_counter()
+                    execution_time = round(stop - start, 3)
+                    print(f"The async function '{func.__name__}' executed in {execution_time} seconds.")
+        return wrapper
+    return decorator

dapper_sqls/models/__init__.py

@@ -0,0 +1,8 @@
+from .http import UnavailableServiceException
+from .result import Result
+from .connection import ConnectionStringData
+from .base import TableBaseModel, BaseUpdate
+
+
+
+

dapper_sqls/models/base.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel, BaseConfig
+from abc import ABC
+from abc import ABC, abstractmethod
+from .result import Result
+
+class TableBaseModel(BaseModel, ABC): 
+    class Config(BaseConfig):
+        from_attributes = True
+
+    _TABLE_NAME: str = ''
+
+    @property
+    def TABLE_NAME(cls) -> str:
+        return cls._TABLE_NAME
+
+class BaseUpdate(ABC):
+
+        def __init__(self, executor , model):
+            self._set_data = model
+            self._executor = executor
+
+        @property
+        def set_data(self):
+            return self._set_data
+
+        @property
+        def executor(self):
+            return self._executor
+
+        @abstractmethod
+        def where(self, *args)  -> Result.Send:
+            pass
+
+
+

dapper_sqls/models/connection.py

@@ -0,0 +1,60 @@
+# -*- coding: latin -*-
+
+class ConnectionStringData(object):
+    def __init__(self, server: str, database: str, username: str, password: str):
+        self._server = server
+        self._database = database
+        self._username = username
+        self._password = password
+
+    @property
+    def server(self) -> str:
+        return self._server
+
+    @server.setter
+    def server(self, value: str):
+        if not isinstance(value, str):
+            raise ValueError("O valor do servidor deve ser uma string.")
+        self._server = value
+
+    @property
+    def database(self) -> str:
+        return self._database
+
+    @database.setter
+    def database(self, value: str):
+        if not isinstance(value, str):
+            raise ValueError("O nome do banco de dados deve ser uma string.")
+        self._database = value
+
+    @property
+    def username(self) -> str:
+        return self._username
+
+    @username.setter
+    def username(self, value: str):
+        if not isinstance(value, str):
+            raise ValueError("O nome de usu�rio deve ser uma string.")
+        self._username = value
+
+    @property
+    def password(self) -> str:
+        return self._password
+
+    @password.setter
+    def password(self, value: str):
+        if not isinstance(value, str):
+            raise ValueError("A senha deve ser uma string.")
+        self._password = value
+
+    def get(self, server : str , database : str, username : str, password : str):
+        self.server = server
+        self.database = database
+        self.username = username
+        self.password = password
+
+    def get(self):
+        return ConnectionStringData(self.server, self.database, self.username, self.password)
+
+
+

dapper_sqls/models/http.py

@@ -0,0 +1,10 @@
+class UnavailableServiceException(Exception):
+    def __init__(self, message="Database unavailable", code="DatabaseUnavailable", exception_type="Database", status_code=503):
+        self.message = message
+        self.code = code
+        self.type = exception_type
+        self.status_code = status_code
+        super().__init__(self.message)
+
+
+

dapper_sqls/models/result.py

@@ -0,0 +1,123 @@
+# -*- coding: latin -*-
+
+def result_dict(cursor, result):
+        return dict(
+                zip(
+                    [column[0] for column in cursor.description],
+                    result
+                )
+                )
+
+class Result(object):
+    
+    class Fetchone(object):
+        def __init__(self, cursor, result, status_code = 200, message : str = ""):
+            self._status_code = status_code
+            self._message = message
+            if result:
+                self._success = True
+                self._list = result
+                self._dict = dict(zip([column[0] for column in cursor.description], result))
+            else:
+                self._success = False
+                self._list = []
+                self._dict = {}
+
+        @property
+        def status_code(self):
+            return self._status_code
+
+        @property
+        def list(self):
+            return self._list
+
+        @property
+        def dict(self):
+            return self._dict
+
+        @property
+        def success(self):
+            return self._success
+        
+        @property
+        def message(self):
+            return self._message
+
+
+    class Fetchall:
+
+        def __init__(self, cursor, result, status_code = 200, message : str = ""):
+            self._status_code = status_code
+            self._message = message
+            if result:
+                self._success = True
+                self._list_dict = []
+                for r in result:
+                    self._list_dict.append(dict(zip([column[0] for column in cursor.description], r)))
+            else:
+                self._success = False
+                self._list_dict = []
+
+        @property
+        def status_code(self):
+            return self._status_code
+
+        @property
+        def list_dict(self):
+            return self._list_dict
+
+        @property
+        def dict(self):
+            return self._dict
+
+        @property
+        def success(self):
+            return self._success
+        
+        @property
+        def message(self):
+            return self._message
+
+    class Insert:
+        def __init__(self, result : int | str, status_code = 200, message : str = ""):
+            self._id = result
+            self._status_code = status_code
+            self._success = bool(result)
+            self._message = message
+
+        @property
+        def id(self):
+            return self._id
+
+        @property
+        def status_code(self):
+            return self._status_code
+
+        @property
+        def success(self):
+            return self._success
+        
+        @property
+        def message(self):
+            return self._message
+
+    class Send:
+        def __init__(self, result : bool, status_code = 200, message : str = ""):
+            self._status_code = status_code
+            self._success = result
+            self._message = message
+
+        @property
+        def status_code(self):
+            return self._status_code
+
+        @property
+        def success(self):
+            return self._success
+        
+        @property
+        def message(self):
+            return self._message
+
+
+

dapper_sqls/sqlite/__init__.py

@@ -0,0 +1,4 @@
+from .local_database import LocalDatabase
+
+
+

dapper_sqls/sqlite/local_database.py

@@ -0,0 +1,268 @@
+# -*- coding: latin -*-
+
+from sqlalchemy import create_engine, inspect, text, insert,MetaData, Table, Integer, Column, String, delete, update
+from sqlalchemy.engine import Engine
+from tempfile import gettempdir
+from os import path, makedirs
+from .models import Path, System ,EnvVar
+import re
+
+#C:\Users\Samuel\AppData\Local\Temp
+
+
+def is_valid_name(name, max_length=255):
+    # Verifica se o nome n�o � vazio
+    if not name:
+        return False
+
+    # Verifica se o nome n�o excede o comprimento m�ximo permitido
+    if len(name) > max_length:
+        return False
+
+    # Verifica se o nome n�o cont�m caracteres inv�lidos
+    # Neste exemplo, permitimos apenas letras, n�meros, espa�os e underscore (_)
+    if not re.match(r'^[\w\s]+$', name):
+        return False
+
+    return True
+
+class LocalDatabase(object):
+
+    class Tables(object):
+
+        meta_data = MetaData()
+
+        system = Table(
+            'system',  # Nome da tabela
+            meta_data,
+            Column('id', Integer, primary_key=True),  
+            Column('App', String),  
+            Column('Tema', String) 
+        )
+
+        env_var = Table(
+            'env_var',
+            meta_data,
+            Column('id', Integer, primary_key=True),
+            Column('App', String), 
+            Column('Name', String),
+            Column('Value', String)
+            )
+
+        path = Table(
+            'path',
+            meta_data,
+            Column('id', Integer, primary_key=True),
+            Column('App', String), 
+            Column('Name', String),
+            Column('Path', String)
+            )
+
+
+    def __init__(self, app_name : str, *, path_local_database = gettempdir(), database_name="saftOnlineLocalDatabase", database_folder_name = "SaftOnline"):
+        app_name = self.get_value(app_name)
+        if not database_name.endswith('.db'):
+            database_name = f'{database_name}.db'
+        if not is_valid_name(app_name):
+            raise Exception("Nome de identifica��o do programa � inv�lido")
+        self._app_name = app_name
+        self._path_database = path.join(path_local_database,database_folder_name, database_name)
+        self._engine : Engine = None
+
+        if not path.isfile(self._path_database):
+            if not path.exists(path.join(path_local_database,database_folder_name)):
+                makedirs(path.join(path_local_database,database_folder_name))
+
+            # Se o banco de dados n�o existe, crie-o e crie a tabela
+            conn = self.engine.connect()
+      
+            self.Tables.meta_data.create_all(self.engine)
+
+            ins = insert(self.Tables.system).values(App=app_name, Tema='light')
+            conn.execute(ins)
+            conn.commit()
+            conn.close()
+
+        else:
+            if not self.are_tables_existing(self.engine):
+                try:
+                    self.Tables.meta_data.create_all(self.engine)
+                    ...
+                except:
+                   ...
+            else:
+                try:
+                    self.synchronize_columns(self.engine)
+                except:
+                    ...
+       
+
+    @property
+    def engine(self):
+        if not self._engine:
+            self._engine = create_engine(f'sqlite:///{self.path_database}')
+        return self._engine
+
+    @property
+    def app_name(self):
+        return self._app_name
+
+    @property
+    def path_database(self):
+        return self._path_database
+
+    def are_columns_existing(self, engine):
+        inspector = inspect(engine)
+        existing_tables = inspector.get_table_names()
+        required_tables = self.Tables.meta_data.tables.keys()
+
+        for table_name in required_tables:
+            if table_name in existing_tables:
+                # Get the columns in the existing table
+                existing_columns = inspector.get_columns(table_name)
+                existing_column_names = [column['name'] for column in existing_columns]
+            
+                # Get the columns defined in the Table class
+                required_columns = self.Tables.meta_data.tables[table_name].c.keys()
+            
+                if not all(column in existing_column_names for column in required_columns):
+                    return False
+            else:
+                return False
+        return True
+
+    def are_tables_existing(self, engine):
+        inspector = inspect(engine)
+        existing_tables = inspector.get_table_names()
+        required_tables = self.Tables.meta_data.tables.keys()
+    
+        return all(table in existing_tables for table in required_tables)
+
+    def synchronize_columns(self, engine):
+        inspector = inspect(engine)
+        existing_tables = inspector.get_table_names()
+
+        for table_name in self.Tables.meta_data.tables.keys():
+            if table_name in existing_tables:
+                # Get the columns in the existing table
+                existing_columns = inspector.get_columns(table_name)
+                existing_column_names = [column['name'] for column in existing_columns]
+
+                # Get the columns defined in the Table class
+                required_columns = self.Tables.meta_data.tables[table_name].c.keys()
+                required_column_defs = {col.name: col for col in self.Tables.meta_data.tables[table_name].columns}
+
+                # Add columns in lack
+                for column in required_columns:
+                    if column not in existing_column_names:
+                        column_type = required_column_defs[column].type
+                        add_column_sql = f'ALTER TABLE {table_name} ADD COLUMN {column} {column_type}'
+                        with engine.connect() as conn:
+                            conn.execute(text(add_column_sql))
+                     
+    def get_value(self, value):
+        try :
+            return value.value
+        except:
+            return value
+
+    def select(self, table : str, where : str = None):
+        with self.engine.connect() as conn:
+            if where:
+                query = conn.execute(text(f"select * from {table} where App = '{self.app_name}' and {where}"))
+            else:
+                query = conn.execute(text(f"select * from {table} where App = '{self.app_name}'"))
+            data = [dict(zip(tuple(query.keys()), i)) for i in query.cursor]
+            return data
+
+
+    def get_path(self, name):
+        name = self.get_value(name)
+        data = self.select('path', f"Name = '{name}'")
+        for d in data:
+            return Path(d).Path
+
+    def update_path(self, name : str, path_name : str):
+        name = self.get_value(name)
+        path_name = self.get_value(path_name)
+        existsPath = self.get_path(name)
+
+        with self.engine.connect() as conn:
+            if existsPath != None:
+                stmt = update(self.Tables.path).where(
+                    (self.Tables.path.c.Name == name) &
+                    (self.Tables.path.c.App == self.app_name)
+                ).values(Path=path_name)
+                conn.execute(stmt)
+            else:
+                ins = insert(self.Tables.path).values(App=self.app_name, Name=name, Path=path_name)
+                conn.execute(ins)
+            conn.commit()
+
+    def delete_path(self, name : str):
+        name = self.get_value(name)
+        with self.engine.connect() as conn:
+            stmt = delete(self.Tables.path).where((self.Tables.path.c.Name == name) & (self.Tables.env_var.c.App == self.app_name))
+            conn.execute(stmt)
+            conn.commit()
+
+    def get_var(self, name):
+        name = self.get_value(name)
+        data = self.select('env_var', f"name = '{name}'")
+        for d in data:
+            return EnvVar(d).Value
+
+    def update_var(self, name : str, value : str):
+        name = self.get_value(name)
+        value = self.get_value(value)
+        existsVar = self.get_var(name)
+        with self.engine.connect() as conn:
+            if existsVar != None:
+               stmt = update(self.Tables.env_var).where(
+                    (self.Tables.env_var.c.Name == name) &
+                    (self.Tables.env_var.c.App == self.app_name)
+               ).values(Value=value)
+               conn.execute(stmt)
+            else:
+               ins = insert(self.Tables.env_var).values(App=self.app_name, Name=name, Value=value)
+               conn.execute(ins)
+            conn.commit()
+
+    def delete_var(self, name : str):
+        name = self.get_value(name)
+        with self.engine.connect() as conn:
+            stmt = delete(self.Tables.env_var).where((self.Tables.env_var.c.Name == name) & (self.Tables.env_var.c.App == self.app_name))
+            conn.execute(stmt)
+            conn.commit()
+
+    def get_theme(self):
+        # Consulta o tema no banco de dados
+        data = self.select('system')
+        if data:
+            # Se houver dados, retorna o tema
+            return System(data[0]).Theme
+        else:
+            # Se n�o houver dados, insere um tema padr�o e retorna 'light'
+            with self.engine.connect() as conn:
+                ins = insert(self.Tables.system).values(App=self.app_name, Tema='light')
+                conn.execute(ins)
+                conn.commit()
+            return 'light'
+
+    def update_theme(self, theme : str):
+        theme = self.get_value(theme)
+        _theme = self.get_theme()
+        if _theme:
+            with self.engine.connect() as conn:
+                stmt = update(self.Tables.system).where(
+                    self.Tables.system.c.App == self.app_name
+                ).values(Tema=theme)
+                conn.execute(stmt)
+                conn.commit()
+           
+
+    
+
+
+
+

dapper_sqls/sqlite/models.py

@@ -0,0 +1,30 @@
+# -*- coding: latin -*-
+
+class BaseTableModel(object):
+    def __init__(self, dados : dict):
+        self.id : int = dados['id']
+        self.App : str = dados['App'] 
+
+class Path(BaseTableModel):
+    def __init__(self, dados : dict):
+       super().__init__(dados)
+       self.Name : str = dados['Name']
+       self.Path : str = dados['Path']
+
+class EnvVar(BaseTableModel):
+    
+    def __init__(self, dados : dict):
+       super().__init__(dados)
+       self.Name : str = dados['Name']
+       self.Value : str = dados['Value']
+
+class System(BaseTableModel):
+    def __init__(self, dados : dict):
+       super().__init__(dados)
+       self.Theme : str = dados['Tema']
+
+
+   
+    
+
+

dapper_sqls/utils.py

@@ -0,0 +1,89 @@
+
+
+def get_dict_args(local : dict , ignore_args = [], ignore_values_none = True):
+    if ignore_values_none:
+        return {k: v for k, v in local.items() if k != 'self' and k != 'cls' and v != None and k not in ignore_args}
+    return {k: v for k, v in local.items() if k != 'self' and k != 'cls' and k not in ignore_args}
+
+class ArgsStored:
+    def __init__(self, model : object | None, query : str | None, params : list | tuple | None, additional_sql : str, select_top : int | None):
+        self.model = model
+        self.query = query
+        self.params = params
+        self.additional_sql = additional_sql if isinstance(additional_sql, str) else ""
+        self.select_top = select_top if isinstance(select_top, int) else None
+
+class ArgsQuery:
+    def __init__(self, model : object | None, query : str | None, additional_sql : str, select_top : int | None):
+        self.model = model
+        self.query = query
+        self.additional_sql = additional_sql
+        self.select_top = select_top
+
+class ArgsSTP:
+    def __init__(self, model : object | None, attempts : str | None, wait_timeout : str | None):
+        self.model = model
+        self.attempts = attempts
+        self.wait_timeout = wait_timeout
+        
+
+class Utils(object):
+
+    @staticmethod
+    def args_stored(*args, **kwargs):
+        query = kwargs.get('query')
+        model = kwargs.get('model')
+        params = kwargs.get('params')
+        additional_sql = kwargs.get('additional_sql', '')
+        select_top = kwargs.get('select_top')
+
+        if not query and not model:
+            if isinstance(args[0], str):
+                query = args[0] 
+                params = args[1:]
+                if len(params) == 1 and isinstance(params[0], (list, tuple)):
+                    params = params[0]
+                params = tuple(params)
+
+            else:
+                model = args[0]
+                if not additional_sql.strip():
+                    if len(args) > 1:
+                        additional_sql = args[1] if len(args) > 1 else ""
+                if not select_top:
+                    select_top = args[2] if len(args) > 2  else None
+
+        return ArgsStored(model, query, params, additional_sql, select_top)
+
+
+    @staticmethod
+    def args_query(*args, **kwargs):
+        query = kwargs.get('query')
+        model = kwargs.get('model')
+        additional_sql = kwargs.get('additional_sql', '')
+        select_top = kwargs.get('select_top')
+
+        if not query and not model:
+            if  isinstance(args[0], str):
+                query = args[0]
+            else:
+                model = args[0]
+                if not additional_sql.strip():
+                    additional_sql = args[1] if len(args) > 1 else ""
+                if not select_top:
+                    select_top = args[2] if len(args) > 2 and not select_top else None
+
+        return ArgsQuery(model, query, additional_sql, select_top)
+
+    @staticmethod
+    def args_stp(*args, **kwargs):
+        model = kwargs.get('model')
+        attempts = kwargs.get('attempts')
+        wait_timeout = kwargs.get('wait_timeout')
+        if not model:
+            model = args[0] if len(args) > 0 else None
+            attempts = args[1] if len(args) > 1 else None
+            wait_timeout = args[2] if len(args) > 2 else None
+
+        return ArgsSTP(model, attempts, wait_timeout)
+