dapper-sqls 0.9.7__py3-none-any.whl → 1.2.0__py3-none-any.whl

dapper_sqls/sqlite/async_local_database.py

@@ -0,0 +1,168 @@
+# coding: utf-8
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
+from sqlalchemy import text, insert, delete, select, Connection
+from .models import BaseTables, Path, System, EnvVar, NotificationData
+from .utils import get_value
+
+class BaseAsyncLocalDatabase:
+    
+     def __init__(self, app_name: str, path : str, is_new_database : bool, insistent_tables : list[str]):
+          self._app_name = app_name
+          self.is_new_database = is_new_database
+          self.insistent_tables = insistent_tables
+          self._engine: AsyncEngine = create_async_engine(f'sqlite+aiosqlite:///{path}')
+
+     @property
+     def engine(self):
+          return self._engine
+
+     @property
+     def app_name(self):
+          return self._app_name
+     
+     async def close(self):
+        await self._engine.dispose()  
+        self._engine.pool.dispose()  
+        self._engine = None
+
+     async def init_db(self):
+          async with self.engine.begin() as conn:
+               await conn.run_sync(BaseTables.meta_data.create_all)
+               await conn.execute(BaseTables.system.insert().values(App=self.app_name, Tema='light'))
+               await conn.commit()
+
+     async def select(self, table: str, where: str = None, conn : Connection = None):
+          if not conn:
+               async with self.engine.connect() as conn:
+                    query = f"SELECT * FROM {table} WHERE App = :app_name"
+                    if where:
+                         query += f" AND {where}"
+                    result = await conn.execute(text(query), {'app_name': self.app_name})
+                    return [row._mapping for row in result]
+          else:
+               query = f"SELECT * FROM {table} WHERE App = :app_name"
+               if where:
+                    query += f" AND {where}"
+               result = await conn.execute(text(query), {'app_name': self.app_name})
+               return [row._mapping for row in result]
+
+     async def get_path(self, name):
+          name = get_value(name)
+          data = await self.select('path', f"Name = '{name}'")
+          return Path(data[0]).Path if data else None
+
+     async def update_path(self, name: str, path_name: str):
+          name, path_name = get_value(name), get_value(path_name)
+          exists_path = await self.get_path(name)
+          async with self.engine.begin() as conn:
+               if exists_path:
+                    await conn.execute(
+                         BaseTables.path.update().where(
+                         (BaseTables.path.c.Name == name) & (BaseTables.path.c.App == self.app_name)
+                         ).values(Path=path_name)
+                    )
+               else:
+                    await conn.execute(BaseTables.path.insert().values(App=self.app_name, Name=name, Path=path_name))
+
+     async def delete_path(self, name: str):
+          name = get_value(name)
+          async with self.engine.begin() as conn:
+               await conn.execute(
+                    BaseTables.path.delete().where(
+                         (BaseTables.path.c.Name == name) & (BaseTables.path.c.App == self.app_name)
+                    )
+               )
+
+     async def get_var(self, name):
+          name = get_value(name)
+          data = await self.select('env_var', f"Name = '{name}'")
+          return EnvVar(data[0]).Value if data else None
+
+     async def update_var(self, name: str, value: str):
+          name, value = get_value(name), get_value(value)
+          exists_var = await self.get_var(name)
+          async with self.engine.begin() as conn:
+               if exists_var:
+                    await conn.execute(
+                         BaseTables.env_var.update().where(
+                         (BaseTables.env_var.c.Name == name) & (BaseTables.env_var.c.App == self.app_name)
+                         ).values(Value=value)
+                    )
+               else:
+                    await conn.execute(BaseTables.env_var.insert().values(App=self.app_name, Name=name, Value=value))
+
+     async def delete_var(self, name: str):
+          name = get_value(name)
+          async with self.engine.begin() as conn:
+               await conn.execute(
+                    BaseTables.env_var.delete().where(
+                         (BaseTables.env_var.c.Name == name) & (BaseTables.env_var.c.App == self.app_name)
+                    )
+               )
+
+     async def get_theme(self):
+          data = await self.select('system')
+          if data:
+               return System(data[0]).Theme
+          async with self.engine.begin() as conn:
+               await conn.execute(BaseTables.system.insert().values(App=self.app_name, Tema='light'))
+          return 'light'
+
+     async def update_theme(self, theme: str):
+          theme = get_value(theme)
+          async with self.engine.begin() as conn:
+               await conn.execute(
+                    BaseTables.system.update().where(BaseTables.system.c.App == self.app_name).values(Tema=theme)
+               )
+
+     async def insert_notification(self, data: NotificationData):
+          async with self.engine.begin() as conn:
+               ins = insert(BaseTables.notification).values(
+                    App=self.app_name,
+                    guid=data.guid,
+                    local=data.local,
+                    title=data.title,
+                    message=data.message,
+                    type=data.type,
+                    date=data.date
+               )
+               await conn.execute(ins)
+
+     async def delete_notification(self, guid: str):
+          async with self.engine.begin() as conn:
+               stmt = delete(BaseTables.notification).where(
+                    (BaseTables.notification.c.guid == guid) & (BaseTables.notification.c.App == self.app_name)
+               )
+               await conn.execute(stmt)
+
+     async def clear_notification(self):
+          async with self.engine.begin() as conn:
+               stmt = delete(BaseTables.notification).where(BaseTables.notification.c.App == self.app_name)
+               await conn.execute(stmt)
+
+     async def get_notifications(self):
+          async with self.engine.connect() as conn:
+               stmt = select(BaseTables.notification).where(BaseTables.notification.c.App == self.app_name)
+               result = await conn.execute(stmt)
+               notifications = result.fetchall()
+               return [NotificationData(**notification._mapping) for notification in notifications]
+
+     async def insert_notification(self, data : NotificationData):
+          async with self.engine.connect() as conn:
+               ins = insert(BaseTables.notification).values(App=self.app_name, guid=data.guid, local=data.local, title=data.title, message=data.message, type=data.type,date=data.date)
+               await conn.execute(ins)
+               await conn.commit()
+
+     async def delete_notification(self, guid : str):
+          async with self.engine.connect() as conn:
+               await conn.execute(delete(BaseTables.notification).where((BaseTables.notification.c.guid == guid) & (BaseTables.notification.c.App == self.app_name)))
+               await conn.commit()
+
+     async def clear_notification(self):
+          async with self.engine.connect() as conn:
+               await conn.execute(delete(BaseTables.notification).where(BaseTables.notification.c.App == self.app_name))
+               await conn.commit()
+
+     async def get_notifications(self):
+          notifications = await self.select('notification')
+          return [NotificationData(**notification) for notification in notifications]

dapper_sqls/sqlite/decorators.py

@@ -0,0 +1,69 @@
+# coding: utf-8
+from functools import wraps
+from dataclasses import dataclass
+from typing import Any, Callable, TypeVar
+from enum import Enum
+
+T = TypeVar("T")
+
+# Tipos de erro padronizados
+class SqliteErrorType(Enum):
+    UNIQUE_VIOLATION = "Unique violation"
+    FOREIGN_KEY_VIOLATION = "Foreign key violation"
+    CHECK_CONSTRAINT_VIOLATION = "Check constraint violation"
+    PERMISSION_DENIED = "Permission denied"
+    SYNTAX_ERROR = "Syntax error"
+    TIMEOUT = "Timeout"
+    CONNECTION_ERROR = "Connection error"
+    UNKNOWN = "Unknown"
+
+# Classificador específico para SQLite
+def classify_sqlite_error(message: str) -> SqliteErrorType:
+    msg = message.lower()
+
+    if "unique constraint failed" in msg:
+        return SqliteErrorType.UNIQUE_VIOLATION
+    if "foreign key constraint failed" in msg:
+        return SqliteErrorType.FOREIGN_KEY_VIOLATION
+    if "check constraint failed" in msg:
+        return SqliteErrorType.CHECK_CONSTRAINT_VIOLATION
+    if "permission denied" in msg:
+        return SqliteErrorType.PERMISSION_DENIED
+    if "syntax error" in msg or ("near" in msg and "syntax error" in msg):
+        return SqliteErrorType.SYNTAX_ERROR
+    if "database is locked" in msg or "timeout" in msg:
+        return SqliteErrorType.TIMEOUT
+    if any(kw in msg for kw in [
+        "unable to open database file",
+        "disk i/o error",
+        "not a database",
+        "file is encrypted",
+        "file is not a database"
+    ]):
+        return SqliteErrorType.CONNECTION_ERROR
+
+    return SqliteErrorType.UNKNOWN
+
+# Classe Error
+class Error:
+    def __init__(self, exception: Exception = None):
+        self.message = str(exception) if isinstance(exception, Exception) else ""
+        self.type = classify_sqlite_error(self.message) if self.message.strip() else None
+
+# Classe de retorno do decorador
+@dataclass
+class OperationResult:
+    success: bool
+    error: Error | None
+    result: Any = None
+
+# Decorador
+def safe_sqlite_operation(func: Callable[..., T]) -> Callable[..., OperationResult]:
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> OperationResult:
+        try:
+            result = func(*args, **kwargs)
+            return OperationResult(success=True, error=None, result=result)
+        except Exception as e:
+            return OperationResult(success=False, error=Error(e), result=None)
+    return wrapper

dapper_sqls/sqlite/installer.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+from sqlalchemy import create_engine, inspect, text, insert
+from sqlalchemy.engine import Engine
+from tempfile import gettempdir
+from os import path, makedirs
+from .models import BaseTables
+from .utils import is_valid_name, get_value
+from typing import TypeVar
+T = TypeVar('T')
+
+class DataBaseInstall(object):
+    
+     def __init__(self, app_name : str, *, tables : BaseTables = None, path_local_database = gettempdir(), database_name="MyLocalDatabase", database_folder_name = "MyApp"):
+          app_name = get_value(app_name)
+          if not database_name.endswith('.db'):
+               database_name = f'{database_name}.db'
+          if not is_valid_name(app_name):
+               app_name = "my_app"
+          self._app_name = app_name
+          self._path_database = path.join(path_local_database,database_folder_name, database_name)
+          self.tables = tables if tables else BaseTables
+          self._engine : Engine = None
+          self.new_database = not path.isfile(self._path_database)
+          self.insistent_tables = []
+          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))
+
+               with self.engine.connect() as conn:
+                    conn.execute(text("PRAGMA encoding = 'UTF-8'"))
+                    conn.commit()
+
+               
+               with self.engine.connect() as conn:
+                    self.tables.meta_data.create_all(self.engine)
+                    if hasattr(self.tables, 'system'):
+                         ins = insert(self.tables.system).values(App=app_name, Tema='light')
+                         conn.execute(ins)
+                    conn.commit()
+          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:
+                         ...
+
+     def instance(self, obj : T) -> T:
+          return obj(self._app_name, self._path_database, self.new_database, self.insistent_tables)
+
+     @property
+     def engine(self):
+          if not self._engine:
+               self._engine = create_engine(f'sqlite:///{self._path_database}')
+          return self._engine
+
+     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:
+                    existing_columns = inspector.get_columns(table_name)
+                    existing_column_names = [column['name'] for column in existing_columns]
+                    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()
+          self.insistent_tables = [table for table in required_tables if table not in existing_tables]
+          return not bool(self.insistent_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:
+                    existing_columns = inspector.get_columns(table_name)
+                    existing_column_names = [column['name'] for column in existing_columns]
+                    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}
+                    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))

dapper_sqls/sqlite/local_database.py

@@ -1,173 +1,39 @@
-# -*- coding: latin -*-
+# coding: utf-8
+from sqlalchemy import create_engine, text, insert, delete, update, Connection
+from .models import BaseTables, Path, System, EnvVar, NotificationData
+from .utils import get_value
 
-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
+class BaseLocalDatabase(object):
 
-#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")
+    def __init__(self, app_name : str, path : str, is_new_database : bool, insistent_tables : list[str]):
         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:
-                    ...
-       
-
+        self.is_new_database = is_new_database
+        self.insistent_tables = insistent_tables
+        self._engine = create_engine(f'sqlite:///{path}')
+        
     @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:
+    def close(self):
+        self._engine.dispose()  
+        self._engine.pool.dispose()  
+        self._engine = None
+ 
+    def select(self, table : str, where : str = None, conn : Connection = None):
+        if not conn:
+            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
+        else:
             if where:
                 query = conn.execute(text(f"select * from {table} where App = '{self.app_name}' and {where}"))
             else:
@@ -175,90 +41,106 @@ class LocalDatabase(object):
             data = [dict(zip(tuple(query.keys()), i)) for i in query.cursor]
             return data
 
-
     def get_path(self, name):
-        name = self.get_value(name)
+        name = 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)
+        name = get_value(name)
+        path_name = 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)
+                stmt = update(BaseTables.path).where(
+                    (BaseTables.path.c.Name == name) &
+                    (BaseTables.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)
+                ins = insert(BaseTables.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)
+        name = 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))
+            stmt = delete(BaseTables.path).where((BaseTables.path.c.Name == name) & (BaseTables.env_var.c.App == self.app_name))
             conn.execute(stmt)
             conn.commit()
 
     def get_var(self, name):
-        name = self.get_value(name)
+        name = 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)
+        name = get_value(name)
+        value = 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)
+               stmt = update(BaseTables.env_var).where(
+                    (BaseTables.env_var.c.Name == name) &
+                    (BaseTables.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)
+               ins = insert(BaseTables.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)
+        name = 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))
+            stmt = delete(BaseTables.env_var).where((BaseTables.env_var.c.Name == name) & (BaseTables.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')
+                ins = insert(BaseTables.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 = 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
+                stmt = update(BaseTables.system).where(
+                    BaseTables.system.c.App == self.app_name
                 ).values(Tema=theme)
                 conn.execute(stmt)
                 conn.commit()
+
+    def insert_notification(self, data : NotificationData):
+        with self.engine.connect() as conn:
+            ins = insert(BaseTables.notification).values(App=self.app_name, guid=data.guid, local=data.local, title=data.title, message=data.message, type=data.type,date=data.date)
+            conn.execute(ins)
+            conn.commit()
+
+    def delete_notification(self, guid : str):
+        with self.engine.connect() as conn:
+            conn.execute(delete(BaseTables.notification).where((BaseTables.notification.c.guid == guid) & (BaseTables.notification.c.App == self.app_name)))
+            conn.commit()
+
+    def clear_notification(self):
+        with self.engine.connect() as conn:
+            conn.execute(delete(BaseTables.notification).where(BaseTables.notification.c.App == self.app_name))
+            conn.commit()
+
+    def get_notifications(self):
+        notifications = self.select('notification')
+        return [NotificationData(**notification) for notification in notifications]