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

dapper_sqls/__init__.py

@@ -2,6 +2,6 @@ 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/async_dapper/async_dapper.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from .._types import  T
 from ..config import Config
 from ..models import Result

dapper_sqls/async_dapper/async_executors.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 import aioodbc, asyncio
 from typing import overload
 from datetime import datetime

dapper_sqls/builders/model/model.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 
 from itertools import groupby
 import os
@@ -152,7 +152,7 @@ class ModelBuilder(object):
                 if table_options.ignore_table:
                     continue
 
-            content_model = '''# -*- coding: latin -*-
+            content_model = '''# coding: utf-8
 
 from dapper_sqls import TableBaseModel
 from datetime import datetime
@@ -268,7 +268,7 @@ class {class_name}(TableBaseModel):
                 schema_data_tables[table.table_schema].append(table)
 
             schema_data_routine : dict[str, list[RoutineBuilderData]] = {}
-            content_file_routine = '''# -*- coding: latin -*-
+            content_file_routine = '''# coding: utf-8
 from dapper_sqls import StpBuilder
 from dapper_sqls import Dapper
 from datetime import datetime
@@ -284,7 +284,7 @@ class stp(object):
         return self._dapper
             '''
 
-            content_file_async_rounine = '''# -*- coding: latin -*-
+            content_file_async_rounine = '''# coding: utf-8
 from dapper_sqls import AsyncStpBuilder
 from dapper_sqls import AsyncDapper
 from datetime import datetime

dapper_sqls/builders/model/utils.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 import re
 from pydantic import Field, BaseModel
 
@@ -118,7 +118,7 @@ def create_params_routine(data : InformationSchemaRoutines, defaults_values : di
 
 def create_content_orm(class_name : str, fields_args_str : str):
 
-    return f'''# -*- coding: latin -*-
+    return f'''# coding: utf-8
 
 from datetime import datetime
 from typing import overload, Union
@@ -268,7 +268,7 @@ class {class_name}ORM(object):
 
 def create_content_async_orm(class_name : str, fields_args_str : str):
 
-    return f'''# -*- coding: latin -*-
+    return f'''# coding: utf-8
 
 from datetime import datetime
 from typing import overload, Union

dapper_sqls/builders/query.py

@@ -1,11 +1,11 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from typing import Type, Union
 from pydantic import BaseModel
 from datetime import datetime, date
 import json
 
 class Value:
-    def __init__(self, value : Union[str, int, bytes, float, datetime, date], prefix : str, suffix : str):
+    def __init__(self, value : Union[str, int, bytes, float, datetime, date, bool], prefix : str, suffix : str):
         self.value = value
         self.prefix = prefix
         self.suffix = suffix
@@ -37,9 +37,9 @@ class QueryBuilder(object):
 
     @classmethod
     def update(cls, model: Type[BaseModel], where : Union[str , Type[BaseModel]]):
-        update_data = model.model_dump(exclude_none=True)
+        update_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
         if not isinstance(where, str):
-            where_data = where.model_dump(exclude_none=True)
+            where_data = {k: int(v) if isinstance(v, bool) else v for k, v in where.model_dump(exclude_none=True).items()} 
             where = cls._build_where_clause(**where_data)
 
         set_clause = ", ".join([f"{key} = '{value}'" if isinstance(value, str) else f"{key} = {value}" for key, value in update_data.items()])
@@ -47,7 +47,7 @@ class QueryBuilder(object):
         return sql_query
 
     def insert(model: Type[BaseModel], name_column_id = 'Id'):
-        insert_data = model.model_dump(exclude_none=True)
+        insert_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
         columns = ", ".join(insert_data.keys())
         values = ", ".join([f"'{value}'" if isinstance(value, str) else str(value) for value in insert_data.values()])
         sql_query = f"""
@@ -60,7 +60,7 @@ class QueryBuilder(object):
     @classmethod
     def select(cls, model: Type[BaseModel], additional_sql : str = "" ,select_top : int= None):
         top_clause = f"TOP ({select_top}) * " if select_top else "*"
-        select_data = model.model_dump(exclude_none=True)
+        select_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
         where_clause = cls._build_where_clause(**select_data)
 
         sql_query = f"SELECT {top_clause} FROM {model.TABLE_NAME}"
@@ -71,7 +71,7 @@ class QueryBuilder(object):
 
     @classmethod
     def delete(cls, model: Type[BaseModel]):
-        delete_data = model.model_dump(exclude_none=True)
+        delete_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
         where_clause = cls._build_where_clause(**delete_data)
         if not where_clause:
             raise ValueError("DELETE operation requires at least one condition.")

dapper_sqls/builders/stored.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from typing import Type
 from pydantic import BaseModel
 
@@ -9,18 +9,14 @@ class StoredBuilder:
         parameters = []
         for field, value in kwargs.items():
             if value is not None:
-                if isinstance(value, str):
-                    conditions.append(f"{field} = ?")
-                    parameters.append(value)
-                else:
                     conditions.append(f"{field} = ?")
                     parameters.append(value)
         return " AND ".join(conditions), tuple(parameters)
 
     @classmethod
     def update(cls, model: Type[BaseModel], where: Type[BaseModel]):
-        update_data = model.model_dump(exclude_none=True)
-        where_data = where.model_dump(exclude_none=True)
+        update_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
+        where_data = {k: int(v) if isinstance(v, bool) else v for k, v in where.model_dump(exclude_none=True).items()}
         where_clause, where_params = cls._build_where_clause(**where_data)
 
         set_clause = ", ".join([f"{key} = ?" for key in update_data.keys()])
@@ -30,7 +26,7 @@ class StoredBuilder:
 
     @classmethod
     def insert(cls, model : Type[BaseModel], name_column_id = 'Id'):
-        insert_data = model.model_dump(exclude_none=True)
+        insert_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
         columns = ", ".join(insert_data.keys())
         values = ", ".join(["?" for _ in insert_data.values()])
         sql_query = f"""
@@ -43,7 +39,7 @@ class StoredBuilder:
     @classmethod
     def select(cls, model : Type[BaseModel], additional_sql : str = "" ,select_top : int= None):
         top_clause = f"TOP ({select_top}) * " if select_top else "*"
-        select_data = model.model_dump(exclude_none=True)
+        select_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
         where_clause, parameters = cls._build_where_clause(**select_data)
 
         sql_query = f"SELECT {top_clause} FROM {model.TABLE_NAME}" 
@@ -54,7 +50,7 @@ class StoredBuilder:
 
     @classmethod
     def delete(cls, model : Type[BaseModel]):
-        delete_data = model.model_dump(exclude_none=True)
+        delete_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
         where_clause, parameters = cls._build_where_clause(**delete_data)
         if not where_clause:
             raise ValueError("DELETE operation requires at least one condition.")

dapper_sqls/config.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from .models import ConnectionStringData
 import sys
 

dapper_sqls/dapper/dapper.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from .._types import  T
 from ..config import Config
 from ..models import Result

dapper_sqls/dapper/executors.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 import pyodbc
 from time import sleep
 from datetime import datetime

dapper_sqls/decorators.py

@@ -1,10 +1,10 @@
-# -*- coding: latin -*-
+# coding: utf-8
 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):
+def func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True, default_value = None):
     """
     Synchronous function decorator for validation, error handling, and logging execution time.
     """
@@ -25,6 +25,7 @@ def func_validation(callable_msg_error: Callable = None, use_raise: bool = False
                         raise
                     else:
                         print(f"Unhandled exception in '{func.__name__}': {error_message}")
+                return default_value
             finally:
                 if use_log:
                     stop = perf_counter()
@@ -33,7 +34,7 @@ def func_validation(callable_msg_error: Callable = None, use_raise: bool = False
         return wrapper
     return decorator
 
-def async_func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True):
+def async_func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True, default_value = None):
     """
     Asynchronous function decorator for validation, error handling, and logging execution time.
     """
@@ -54,6 +55,7 @@ def async_func_validation(callable_msg_error: Callable = None, use_raise: bool =
                         raise
                     else:
                         print(f"Unhandled exception in async function '{func.__name__}': {error_message}")
+                return default_value
             finally:
                 if use_log:
                     stop = perf_counter()

dapper_sqls/models/connection.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 
 class ConnectionStringData(object):
     def __init__(self, server: str, database: str, username: str, password: str):
@@ -34,7 +34,7 @@ class ConnectionStringData(object):
     @username.setter
     def username(self, value: str):
         if not isinstance(value, str):
-            raise ValueError("O nome de usu�rio deve ser uma string.")
+            raise ValueError("O nome de usu�rio deve ser uma string.")
         self._username = value
 
     @property

dapper_sqls/models/result.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 
 def result_dict(cursor, result):
         return dict(

dapper_sqls/sqlite/__init__.py

@@ -1,4 +1,7 @@
-from .local_database import LocalDatabase
+from .local_database import BaseLocalDatabase
+from .async_local_database import BaseAsyncLocalDatabase
+from .installer import DataBaseInstall
+from .models import BaseTables
 
 
 

dapper_sqls/sqlite/async_local_database.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
+from sqlalchemy import text
+from .models import BaseTables, Path, System, EnvVar
+from .utils import get_value
+
+class BaseAsyncLocalDatabase:
+    
+     def __init__(self, app_name: str, path : str, is_new_database : bool):
+          self._app_name = app_name
+          self.is_new_database = is_new_database
+          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 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):
+          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]
+
+     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)
+               )
+

dapper_sqls/sqlite/installer.py

@@ -0,0 +1,93 @@
+# 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)
+          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)
+                    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)
+
+     @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()
+          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:
+                    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,171 +1,23 @@
-# -*- coding: latin -*-
+# coding: utf-8
+from sqlalchemy import create_engine, text, insert, delete, update
+from .models import BaseTables, Path, System, EnvVar
+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):
         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._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:
             if where:
@@ -175,87 +27,83 @@ 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()

dapper_sqls/sqlite/models.py

@@ -1,4 +1,28 @@
-# -*- coding: latin -*-
+# coding: utf-8
+from sqlalchemy import MetaData, Table, Column, Integer, String
+
+class BaseTables:
+    meta_data = MetaData()
+    system = Table(
+        'system', 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)
+    )
 
 class BaseTableModel(object):
     def __init__(self, dados : dict):
@@ -24,6 +48,8 @@ class System(BaseTableModel):
        self.Theme : str = dados['Tema']
 
 
+
+
    
     
 

dapper_sqls/sqlite/utils.py

@@ -0,0 +1,8 @@
+# coding: utf-8
+import re
+
+def is_valid_name(name, max_length=255):
+    return bool(name and len(name) <= max_length and re.match(r'^[\w\s]+$', name))
+
+def get_value(value):
+        return getattr(value, 'value', value)

dapper_sqls/utils.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 
 def get_dict_args(local : dict , ignore_args = [], ignore_values_none = True):
     if ignore_values_none:

dapper_sqls-1.1.3.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: dapper_sqls
+Version: 1.1.3
+Author: Samuel Semedo
+Requires-Dist: aioodbc==0.5.0
+Requires-Dist: annotated-types==0.7.0
+Requires-Dist: greenlet==3.1.1
+Requires-Dist: pyodbc==5.2.0
+Requires-Dist: SQLAlchemy==2.0.36
+Requires-Dist: typing_extensions==4.12.2

dapper_sqls-1.1.3.dist-info/RECORD

@@ -0,0 +1,33 @@
+dapper_sqls/__init__.py,sha256=-m_igeGpFiWm-B1WEpyNg9nIC3WApaLEdlbRg6v61cg,174
+dapper_sqls/_types.py,sha256=GM_qDsjKGRSFC0NsU5hkqLKH-ydVKJ-1TgEkxQzi4Hw,181
+dapper_sqls/config.py,sha256=CN5x_E8PlV734Ra57ensLbdFCxe7ASXp7M1wdubcT5s,4625
+dapper_sqls/decorators.py,sha256=I2Uo3Uj1-K4XVTNTvcejaUfd_tuUmM6kOWXrMyX1Dts,2767
+dapper_sqls/utils.py,sha256=0vXX-mhbwSL3Kx7_ErHaxaASgJzrs-g9kwW38kEJZDw,3452
+dapper_sqls/async_dapper/__init__.py,sha256=lBXRyXMCaiwgcK5TCw5rg-niwFS4GcZVW5Q2enKcS-0,47
+dapper_sqls/async_dapper/async_dapper.py,sha256=n9oDmgvRvB3TkuW3e-rcvy35VZfYespB9qn9qtCVa7s,2454
+dapper_sqls/async_dapper/async_executors.py,sha256=uaI5xemBC3Cgs69utC6qqmaaMPdXegarkxyeWVkiTog,13156
+dapper_sqls/builders/__init__.py,sha256=o_dGrHF09NOj3KFLpkpfaRzJMgYcddpQy-QTOJJTLPA,153
+dapper_sqls/builders/query.py,sha256=9-wh2zALVNc4dbBcmkvZvKCxKxEoR4G8Sovcrp1go6Q,3895
+dapper_sqls/builders/stored.py,sha256=dAaKeDfW_9mKqkEgpKrTHwZmzRpsb_iYuJW9v2RXAkA,2778
+dapper_sqls/builders/stp.py,sha256=wYhhO-tlfH2izUyXhMn9sipy_8_IbKwcqkm0SvkdJfo,4739
+dapper_sqls/builders/model/__init__.py,sha256=9cAgoo-zu82YhtsmePseZhfeX94UMwfYuP9j-3d597Q,41
+dapper_sqls/builders/model/model.py,sha256=bawug0tc5PuRVgYU_3JdI7l9s4RyTQT3tDBF5TaGuQo,17026
+dapper_sqls/builders/model/utils.py,sha256=nhTODL6WTGNI5vtKZ_cRyGcBtv8G574a52-HUT1axao,17240
+dapper_sqls/dapper/__init__.py,sha256=AlQJ-QYMqKeerSQBM8Dc9_VQwUKCN4bl4ThKHsTlYms,38
+dapper_sqls/dapper/dapper.py,sha256=3sFRtgw_M3zZI8dyDJacVFwzAuH7jbyQehfCiYMymZs,2584
+dapper_sqls/dapper/executors.py,sha256=-Q9gFkNXyP1QSezta2AtywOIRx_8PsTyMOvl0q4SwH4,12760
+dapper_sqls/models/__init__.py,sha256=z1kR1XLmwxQTMctvsbVR8lcXNafQXxkEP0mdbKzB31s,175
+dapper_sqls/models/base.py,sha256=ddBgBPTVA2_cPNZ4QrYNXqcpsQ8m4Ipy7TWGoHxYF4c,766
+dapper_sqls/models/connection.py,sha256=xSSB12_Odrdplfn7_724slEAE02rDt2yrdNFsD3ENuU,1746
+dapper_sqls/models/http.py,sha256=rCmf4Mj1bA_oc0k0vDxi2v1Cqd4oXDDU83P_6kNwTuA,356
+dapper_sqls/models/result.py,sha256=7IDY3omTGHV8IVpHdej1FaxGXmK1v6h_0iH9zov4Z94,3241
+dapper_sqls/sqlite/__init__.py,sha256=A94N9nQArs7JIzGHn7gjFIBMVxFW9rnwk-y29fL7_6k,183
+dapper_sqls/sqlite/async_local_database.py,sha256=cGdGeUjvtWHktkbTCQGbgCNzRdPV6EtDRnwp5x1OtyI,4450
+dapper_sqls/sqlite/installer.py,sha256=XlXyvNEa59Qr1Kb4bw-7JXXKZBPOuHe7HSVr1KPDYg4,4560
+dapper_sqls/sqlite/local_database.py,sha256=pNccTu8s34aPVVRQd8NRdDsY4yAszmF51kh9bSUY7f8,4190
+dapper_sqls/sqlite/models.py,sha256=rZ2R4I3EhrgAxrQwj0vUZkLsjhjHcpCLCmPMBZM19hw,1403
+dapper_sqls/sqlite/utils.py,sha256=ITuUrp8chmHoVWlP1Ro_EGrWagswuYjspSwmSfWBSrw,226
+dapper_sqls-1.1.3.dist-info/METADATA,sha256=J8Fafn2-NCfnwxtTAitVOKOMfYxv79TMHZs0AeRAgEE,290
+dapper_sqls-1.1.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+dapper_sqls-1.1.3.dist-info/top_level.txt,sha256=Pe1YqCPngnYbSVdhJyDrdFWHFCOqBvFW8WK7kTaIax4,12
+dapper_sqls-1.1.3.dist-info/RECORD,,

{dapper_sqls-0.9.7.dist-info → dapper_sqls-1.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dapper_sqls-0.9.7.dist-info/METADATA

@@ -1,19 +0,0 @@
-Metadata-Version: 2.1
-Name: dapper-sqls
-Version: 0.9.7
-Summary: UNKNOWN
-Home-page: UNKNOWN
-Author: Samuel Semedo
-License: UNKNOWN
-Platform: UNKNOWN
-Requires-Dist: aioodbc ==0.5.0
-Requires-Dist: annotated-types ==0.7.0
-Requires-Dist: greenlet ==3.1.1
-Requires-Dist: pydantic ==2.10.3
-Requires-Dist: pydantic-core ==2.27.1
-Requires-Dist: pyodbc ==5.2.0
-Requires-Dist: SQLAlchemy ==2.0.36
-Requires-Dist: typing-extensions ==4.12.2
-
-UNKNOWN
-

dapper_sqls-0.9.7.dist-info/RECORD

@@ -1,30 +0,0 @@
-dapper_sqls/__init__.py,sha256=KzUmxAhkQiQIu7Oa1yRtvRhCbsxg29aNa-MszPL6PrY,207
-dapper_sqls/_types.py,sha256=GM_qDsjKGRSFC0NsU5hkqLKH-ydVKJ-1TgEkxQzi4Hw,181
-dapper_sqls/config.py,sha256=z370PREmTu8dpZV4Fm6ZyWrQBDJeb0xMr28I-ZCGRIo,4633
-dapper_sqls/decorators.py,sha256=5mrabdIv4yZpwmN1XDjAhDXIU8ruoxww6b9X7fmRtE8,2655
-dapper_sqls/utils.py,sha256=4XCK-5Ikf4bJ18EewhK2UCDR_xi3TMYpFScJJfYjulI,3460
-dapper_sqls/async_dapper/__init__.py,sha256=lBXRyXMCaiwgcK5TCw5rg-niwFS4GcZVW5Q2enKcS-0,47
-dapper_sqls/async_dapper/async_dapper.py,sha256=fcJbscwJHCS4_cZJKwfzTJPkEaVBnSc7p8MpPEqD3-0,2462
-dapper_sqls/async_dapper/async_executors.py,sha256=djBDfpz3Dg2sx7Ct29khmbeRtwrEgQb_v-HOTUFGPh4,13164
-dapper_sqls/builders/__init__.py,sha256=o_dGrHF09NOj3KFLpkpfaRzJMgYcddpQy-QTOJJTLPA,153
-dapper_sqls/builders/query.py,sha256=Z6ShajmCDjIcvVv34LuLd2_yXShDRERH84HatiacBtc,3586
-dapper_sqls/builders/stored.py,sha256=C5TvscEwfXRIeOt-ysry9rn8DS0GoH-eTdnhIGpprP8,2644
-dapper_sqls/builders/stp.py,sha256=wYhhO-tlfH2izUyXhMn9sipy_8_IbKwcqkm0SvkdJfo,4739
-dapper_sqls/builders/model/__init__.py,sha256=9cAgoo-zu82YhtsmePseZhfeX94UMwfYuP9j-3d597Q,41
-dapper_sqls/builders/model/model.py,sha256=2fCpEH_2DJt90NGQBM_tgOy0Xkj99AMmNFpUdCwqb2A,17058
-dapper_sqls/builders/model/utils.py,sha256=oVSRCUWggC6Arhy_jYzds20apk1TfyQKJnmdZdalYcA,17264
-dapper_sqls/dapper/__init__.py,sha256=AlQJ-QYMqKeerSQBM8Dc9_VQwUKCN4bl4ThKHsTlYms,38
-dapper_sqls/dapper/dapper.py,sha256=iw2UitEDcQcnw4-EuRhEe5ZpQxgLKkWHliQGlGv_qFI,2592
-dapper_sqls/dapper/executors.py,sha256=nkR8h051nKheWjWwfe8O9yIK4sg9Q9IBX-l2lYQzLlQ,12768
-dapper_sqls/models/__init__.py,sha256=z1kR1XLmwxQTMctvsbVR8lcXNafQXxkEP0mdbKzB31s,175
-dapper_sqls/models/base.py,sha256=ddBgBPTVA2_cPNZ4QrYNXqcpsQ8m4Ipy7TWGoHxYF4c,766
-dapper_sqls/models/connection.py,sha256=9z3GZW7vhk4w7m7jhey3hblTCh3wrKS90VffHkouu6Y,1752
-dapper_sqls/models/http.py,sha256=rCmf4Mj1bA_oc0k0vDxi2v1Cqd4oXDDU83P_6kNwTuA,356
-dapper_sqls/models/result.py,sha256=4yCJmQEy87gPOi6sUdrXD3xtSWAbXeAX_uR2Ou6EYpg,3249
-dapper_sqls/sqlite/__init__.py,sha256=VifBg1-pubsrYs5jm3ZsgtIqM5JzeNDS2tdInAKvjwM,49
-dapper_sqls/sqlite/local_database.py,sha256=PpIokP09sfIT8JbwRVi0OxegrubDwOVXvajO4lU1U4g,9873
-dapper_sqls/sqlite/models.py,sha256=QwV771SexBq5j92Ls9bgcuR1ucDx9ARazj9JkhMTSB0,712
-dapper_sqls-0.9.7.dist-info/METADATA,sha256=PymlIOFGFLSNlguXpV3KnKup6EZmtPQcpfpyNCjhCJQ,457
-dapper_sqls-0.9.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-dapper_sqls-0.9.7.dist-info/top_level.txt,sha256=Pe1YqCPngnYbSVdhJyDrdFWHFCOqBvFW8WK7kTaIax4,12
-dapper_sqls-0.9.7.dist-info/RECORD,,