sqliteplus-enhanced 1.0.0__tar.gz

sqliteplus_enhanced-1.0.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.2
+Name: sqliteplus-enhanced
+Version: 1.0.0
+Summary: SQLite mejorado con cifrado SQLCipher y caché en Redis
+Home-page: https://github.com/Alphonsus411/sqliteplus-enhanced
+Author: Adolfo González Hernández
+Author-email: Adolfo González Hernández <adolfogonzal@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: click
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: redis
+Requires-Dist: bcrypt
+Requires-Dist: PyJWT
+Requires-Dist: pytest
+Requires-Dist: setuptools
+Dynamic: author
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-python
+
+# 📌 SQLitePlus - Base de Datos Mejorada con Cifrado y Caché 🚀
+
+## 📖 Descripción
+SQLitePlus es una implementación mejorada de SQLite con soporte para:
+- **Cifrado de base de datos con SQLCipher** 🔒
+- **Caché en Redis** para mejorar el rendimiento ⚡
+- **Manejo de concurrencia con threading** 🛠️
+- **Exportación y replicación de datos** 📂
+- **Interfaz CLI para administración desde la terminal** 🖥️
+- **Servidor API con FastAPI** para integración flexible 🌐
+
+---
+
+## 📦 Instalación
+### **1️⃣ Clonar el Repositorio**
+```bash
+git clone https://github.com/tuusuario/sqliteplus.git
+cd sqliteplus
+```
+
+### **2️⃣ Crear un Entorno Virtual**
+```bash
+python -m venv .venv
+source .venv/bin/activate  # En Linux/Mac
+.venv\Scripts\activate     # En Windows
+```
+
+### **3️⃣ Instalar Dependencias**
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## 🚀 Uso
+
+### **🔹 Inicializar la Base de Datos**
+```bash
+python -m sqliteplus.cli init-db
+```
+
+### **🔹 Ejecutar una Consulta de Escritura**
+```bash
+python -m sqliteplus.cli execute "INSERT INTO logs (action) VALUES ('Test desde CLI')"
+```
+
+### **🔹 Ejecutar una Consulta de Lectura**
+```bash
+python -m sqliteplus.cli fetch "SELECT * FROM logs"
+```
+
+### **🔹 Crear una Copia de Seguridad**
+```bash
+python -m sqliteplus.cli backup
+```
+
+### **🔹 Exportar una Tabla a CSV**
+```bash
+python -m sqliteplus.cli export-csv logs logs_export.csv
+```
+
+---
+
+## ⚙️ Configuración de Redis (Opcional pero Recomendado)
+Si deseas habilitar la caché en Redis:
+1. **Iniciar Redis en Local**
+   ```bash
+   redis-server
+   ```
+2. **Verificar que Redis está activo**
+   ```bash
+   redis-cli ping  # Debería responder con 'PONG'
+   ```
+
+---
+
+## 📡 Uso del Servidor API
+### **🔹 Iniciar el Servidor FastAPI**
+```bash
+uvicorn sqliteplus.server:app --reload --host 0.0.0.0 --port 8000
+```
+
+### **🔹 Acceder a la Documentación Interactiva**
+Abre en tu navegador: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)
+
+---
+
+## 📜 Licencia
+Este proyecto está bajo la licencia **MIT**.
+
+---
+
+## 🤝 Contribuciones
+¡Las contribuciones son bienvenidas! Si deseas mejorar SQLitePlus, haz un fork del repositorio y envía un pull request. 🚀
+
+---
+
+## 📧 Contacto
+Si tienes dudas o sugerencias, puedes contactarme en **[tuemail@example.com](mailto:tuemail@example.com)** o abrir un issue en GitHub.
+

sqliteplus_enhanced-1.0.0/README.md

@@ -0,0 +1,100 @@
+# 📌 SQLitePlus - Base de Datos Mejorada con Cifrado y Caché 🚀
+
+## 📖 Descripción
+SQLitePlus es una implementación mejorada de SQLite con soporte para:
+- **Cifrado de base de datos con SQLCipher** 🔒
+- **Caché en Redis** para mejorar el rendimiento ⚡
+- **Manejo de concurrencia con threading** 🛠️
+- **Exportación y replicación de datos** 📂
+- **Interfaz CLI para administración desde la terminal** 🖥️
+- **Servidor API con FastAPI** para integración flexible 🌐
+
+---
+
+## 📦 Instalación
+### **1️⃣ Clonar el Repositorio**
+```bash
+git clone https://github.com/tuusuario/sqliteplus.git
+cd sqliteplus
+```
+
+### **2️⃣ Crear un Entorno Virtual**
+```bash
+python -m venv .venv
+source .venv/bin/activate  # En Linux/Mac
+.venv\Scripts\activate     # En Windows
+```
+
+### **3️⃣ Instalar Dependencias**
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## 🚀 Uso
+
+### **🔹 Inicializar la Base de Datos**
+```bash
+python -m sqliteplus.cli init-db
+```
+
+### **🔹 Ejecutar una Consulta de Escritura**
+```bash
+python -m sqliteplus.cli execute "INSERT INTO logs (action) VALUES ('Test desde CLI')"
+```
+
+### **🔹 Ejecutar una Consulta de Lectura**
+```bash
+python -m sqliteplus.cli fetch "SELECT * FROM logs"
+```
+
+### **🔹 Crear una Copia de Seguridad**
+```bash
+python -m sqliteplus.cli backup
+```
+
+### **🔹 Exportar una Tabla a CSV**
+```bash
+python -m sqliteplus.cli export-csv logs logs_export.csv
+```
+
+---
+
+## ⚙️ Configuración de Redis (Opcional pero Recomendado)
+Si deseas habilitar la caché en Redis:
+1. **Iniciar Redis en Local**
+   ```bash
+   redis-server
+   ```
+2. **Verificar que Redis está activo**
+   ```bash
+   redis-cli ping  # Debería responder con 'PONG'
+   ```
+
+---
+
+## 📡 Uso del Servidor API
+### **🔹 Iniciar el Servidor FastAPI**
+```bash
+uvicorn sqliteplus.server:app --reload --host 0.0.0.0 --port 8000
+```
+
+### **🔹 Acceder a la Documentación Interactiva**
+Abre en tu navegador: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)
+
+---
+
+## 📜 Licencia
+Este proyecto está bajo la licencia **MIT**.
+
+---
+
+## 🤝 Contribuciones
+¡Las contribuciones son bienvenidas! Si deseas mejorar SQLitePlus, haz un fork del repositorio y envía un pull request. 🚀
+
+---
+
+## 📧 Contacto
+Si tienes dudas o sugerencias, puedes contactarme en **[tuemail@example.com](mailto:tuemail@example.com)** o abrir un issue en GitHub.
+

sqliteplus_enhanced-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqliteplus-enhanced"
+version = "1.0.0"
+description = "SQLite mejorado con cifrado SQLCipher y caché en Redis"
+authors = [
+    { name = "Adolfo González Hernández", email = "adolfogonzal@gmail.com" }
+]
+license = { text = "MIT" }
+dependencies = [
+    "click",
+    "fastapi",
+    "uvicorn",
+    "redis",
+    "bcrypt",
+    "PyJWT",
+    "pytest",
+    "setuptools"
+]
+readme = "README.md"
+requires-python = ">=3.7"
+dynamic = ["classifiers"]
+
+[project.scripts]
+sqliteplus = "sqliteplus.cli:cli"
+
+[tool.setuptools]
+packages = ["sqliteplus"]

sqliteplus_enhanced-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqliteplus_enhanced-1.0.0/setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="sqliteplus-enhanced",
+    version="1.0.0",
+    author="Adolfo González Hernández",
+    author_email="adolfogonzal@gmail.com",
+    description="SQLite mejorado con cifrado SQLCipher y caché en Redis",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Alphonsus411/sqliteplus-enhanced",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "click",
+        "fastapi",
+        "uvicorn",
+        "redis",
+        "bcrypt",
+        "PyJWT",
+        "pytest",
+        "setuptools"
+    ],
+    entry_points={
+        "console_scripts": [
+            "sqliteplus-enhanced=sqliteplus.cli:cli"
+        ]
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+)

sqliteplus_enhanced-1.0.0/sqliteplus/cli.py

@@ -0,0 +1,56 @@
+import click
+from sqliteplus.core import SQLitePlus
+from sqliteplus.replication import SQLiteReplication
+
+@click.group()
+def cli():
+    """Interfaz de Línea de Comandos para SQLitePlus."""
+    pass
+
+@click.command()
+def init_db():
+    """Inicializa la base de datos SQLitePlus."""
+    db = SQLitePlus()
+    db.log_action("Inicialización de la base de datos desde CLI")
+    click.echo("Base de datos inicializada correctamente.")
+
+@click.command()
+@click.argument("query")
+def execute(query):
+    """Ejecuta una consulta SQL de escritura."""
+    db = SQLitePlus()
+    result = db.execute_query(query)
+    click.echo(f"Consulta ejecutada. ID insertado: {result}")
+
+@click.command()
+@click.argument("query")
+def fetch(query):
+    """Ejecuta una consulta SQL de lectura."""
+    db = SQLitePlus()
+    result = db.fetch_query(query)
+    click.echo(result)
+
+@click.command()
+@click.argument("table_name")
+@click.argument("output_file")
+def export_csv(table_name, output_file):
+    """Exporta una tabla a CSV."""
+    replicator = SQLiteReplication()
+    replicator.export_to_csv(table_name, output_file)
+    click.echo(f"Tabla {table_name} exportada a {output_file}")
+
+@click.command()
+def backup():
+    """Crea un respaldo de la base de datos."""
+    replicator = SQLiteReplication()
+    replicator.backup_database()
+    click.echo("Copia de seguridad creada correctamente.")
+
+cli.add_command(init_db)
+cli.add_command(execute)
+cli.add_command(fetch)
+cli.add_command(export_csv)
+cli.add_command(backup)
+
+if __name__ == "__main__":
+    cli()

sqliteplus_enhanced-1.0.0/sqliteplus/core.py

@@ -0,0 +1,77 @@
+import sqlite3
+import threading
+
+
+class SQLitePlus:
+    """
+    Manejador de SQLite mejorado con soporte para concurrencia y manejo seguro de consultas.
+    """
+
+    def __init__(self, db_path="database.db"):
+        self.db_path = db_path
+        self.lock = threading.Lock()  # Para manejar concurrencia
+        self._initialize_db()
+
+    def _initialize_db(self):
+        """
+        Inicializa la base de datos creando las tablas necesarias si no existen.
+        """
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                CREATE TABLE IF NOT EXISTS logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    action TEXT,
+                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+            conn.commit()
+
+    def get_connection(self):
+        """
+        Obtiene una conexión a la base de datos.
+        """
+        return sqlite3.connect(self.db_path, check_same_thread=False)
+
+    def execute_query(self, query, params=()):
+        """
+        Ejecuta una consulta de escritura en la base de datos.
+        """
+        with self.lock:  # Bloquea la ejecución para evitar conflictos
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(query, params)
+                    conn.commit()
+                    return cursor.lastrowid
+                except sqlite3.Error as e:
+                    print(f"Error en la consulta: {e}")
+                    return None
+
+    def fetch_query(self, query, params=()):
+        """
+        Ejecuta una consulta de lectura en la base de datos y devuelve los resultados.
+        """
+        with self.lock:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(query, params)
+                    return cursor.fetchall()
+                except sqlite3.Error as e:
+                    print(f"Error en la consulta: {e}")
+                    return None
+
+    def log_action(self, action):
+        """
+        Registra una acción en la tabla de logs.
+        """
+        self.execute_query("INSERT INTO logs (action) VALUES (?)", (action,))
+
+
+if __name__ == "__main__":
+    db = SQLitePlus()
+    db.log_action("Inicialización del sistema")
+    print("SQLitePlus está listo para usar.")

sqliteplus_enhanced-1.0.0/sqliteplus/replication.py

@@ -0,0 +1,72 @@
+import sqlite3
+import os
+import shutil
+from sqliteplus.core import SQLitePlus
+
+
+class SQLiteReplication:
+    """
+    Módulo para exportación y replicación de bases de datos SQLitePlus.
+    """
+
+    def __init__(self, db_path="database.db", backup_dir="backups"):
+        self.db_path = db_path
+        self.backup_dir = backup_dir
+        os.makedirs(self.backup_dir, exist_ok=True)
+
+    def export_to_csv(self, table_name: str, output_file: str):
+        """
+        Exporta los datos de una tabla a un archivo CSV.
+        """
+        conn = SQLitePlus().get_connection()
+        cursor = conn.cursor()
+
+        try:
+            cursor.execute(f"SELECT * FROM {table_name}")
+            rows = cursor.fetchall()
+            column_names = [desc[0] for desc in cursor.description]
+
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.write(",".join(column_names) + "\n")
+                for row in rows:
+                    f.write(",".join(map(str, row)) + "\n")
+
+            print(f"Datos exportados correctamente a {output_file}")
+        except sqlite3.Error as e:
+            print(f"Error al exportar datos: {e}")
+        finally:
+            conn.close()
+
+    def backup_database(self):
+        """
+        Crea una copia de seguridad de la base de datos.
+        """
+        backup_file = os.path.join(self.backup_dir, f"backup_{self._get_timestamp()}.db")
+        try:
+            shutil.copy2(self.db_path, backup_file)
+            print(f"Copia de seguridad creada en {backup_file}")
+        except Exception as e:
+            print(f"Error al realizar la copia de seguridad: {e}")
+
+    def replicate_database(self, target_db_path: str):
+        """
+        Replica la base de datos en otra ubicación.
+        """
+        try:
+            shutil.copy2(self.db_path, target_db_path)
+            print(f"Base de datos replicada en {target_db_path}")
+        except Exception as e:
+            print(f"Error en la replicación: {e}")
+
+    def _get_timestamp(self):
+        """
+        Genera un timestamp para los nombres de archivo.
+        """
+        import datetime
+        return datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+if __name__ == "__main__":
+    replicator = SQLiteReplication()
+    replicator.backup_database()
+    replicator.export_to_csv("logs", "logs_export.csv")

sqliteplus_enhanced-1.0.0/sqliteplus/security.py

@@ -0,0 +1,104 @@
+import sqlite3
+import threading
+import os
+import functools
+import redis
+
+
+class SQLitePlus:
+    """
+    Manejador de SQLite mejorado con soporte para concurrencia, caché en Redis y cifrado con SQLCipher.
+    """
+
+    def __init__(self, db_path="database.db", redis_host="localhost", redis_port=6379):
+        self.db_path = db_path
+        self.lock = threading.Lock()  # Para manejar concurrencia
+        self.db_key = os.getenv("SQLITE_DB_KEY", "clave_super_segura")  # Clave de cifrado
+        self.redis_client = redis.Redis(host=redis_host, port=redis_port, db=0)  # Configuración de caché
+        self._initialize_db()
+
+    def _initialize_db(self):
+        """
+        Inicializa la base de datos creando las tablas necesarias si no existen.
+        """
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                CREATE TABLE IF NOT EXISTS logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    action TEXT,
+                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+            conn.commit()
+
+    def get_connection(self):
+        """
+        Obtiene una conexión cifrada a la base de datos usando SQLCipher.
+        """
+        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        cursor = conn.cursor()
+        cursor.execute(f"PRAGMA key='{self.db_key}';")  # Aplica la clave de cifrado
+        return conn
+
+    def cache_result(func):
+        """
+        Decorador para almacenar en caché los resultados de las consultas SELECT.
+        """
+
+        @functools.wraps(func)
+        def wrapper(self, query, params=()):
+            cache_key = f"query:{query}:{params}"
+            cached_result = self.redis_client.get(cache_key)
+            if cached_result:
+                return eval(cached_result.decode())  # Convertir de string a lista
+            result = func(self, query, params)
+            if result:
+                self.redis_client.setex(cache_key, 300, str(result))  # Caché por 5 minutos
+            return result
+
+        return wrapper
+
+    def execute_query(self, query, params=()):
+        """
+        Ejecuta una consulta de escritura en la base de datos.
+        """
+        with self.lock:  # Bloquea la ejecución para evitar conflictos
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(query, params)
+                    conn.commit()
+                    return cursor.lastrowid
+                except sqlite3.Error as e:
+                    print(f"Error en la consulta: {e}")
+                    return None
+
+    @cache_result
+    def fetch_query(self, query, params=()):
+        """
+        Ejecuta una consulta de lectura en la base de datos y devuelve los resultados, con caché en Redis.
+        """
+        with self.lock:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(query, params)
+                    return cursor.fetchall()
+                except sqlite3.Error as e:
+                    print(f"Error en la consulta: {e}")
+                    return None
+
+    def log_action(self, action):
+        """
+        Registra una acción en la tabla de logs.
+        """
+        self.execute_query("INSERT INTO logs (action) VALUES (?)", (action,))
+
+
+if __name__ == "__main__":
+    db = SQLitePlus()
+    db.log_action("Inicialización del sistema con SQLCipher y caché en Redis")
+    print("SQLitePlus está listo para usar con cifrado SQLCipher y caché optimizada en Redis.")

sqliteplus_enhanced-1.0.0/sqliteplus/server.py

@@ -0,0 +1,42 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from sqliteplus.core import SQLitePlus
+
+# Inicializar FastAPI y la base de datos
+app = FastAPI()
+db = SQLitePlus()
+
+# Modelo de datos para recibir consultas SQL
+class QueryModel(BaseModel):
+    query: str
+    params: list = []
+
+@app.get("/")
+def home():
+    return {"message": "API SQLitePlus en funcionamiento"}
+
+@app.post("/execute/")
+def execute_query(query_data: QueryModel):
+    """
+    Ejecuta una consulta SQL de escritura (INSERT, UPDATE, DELETE).
+    """
+    result = db.execute_query(query_data.query, tuple(query_data.params))
+    if result is None:
+        raise HTTPException(status_code=400, detail="Error al ejecutar la consulta")
+    return {"message": "Consulta ejecutada con éxito", "last_inserted_id": result}
+
+@app.post("/fetch/")
+def fetch_query(query_data: QueryModel):
+    """
+    Ejecuta una consulta SQL de lectura (SELECT) y devuelve los resultados.
+    """
+    result = db.fetch_query(query_data.query, tuple(query_data.params))
+    if result is None:
+        raise HTTPException(status_code=400, detail="Error al ejecutar la consulta")
+    return {"data": result}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+

sqliteplus_enhanced-1.0.0/sqliteplus_enhanced.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.2
+Name: sqliteplus-enhanced
+Version: 1.0.0
+Summary: SQLite mejorado con cifrado SQLCipher y caché en Redis
+Home-page: https://github.com/Alphonsus411/sqliteplus-enhanced
+Author: Adolfo González Hernández
+Author-email: Adolfo González Hernández <adolfogonzal@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: click
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: redis
+Requires-Dist: bcrypt
+Requires-Dist: PyJWT
+Requires-Dist: pytest
+Requires-Dist: setuptools
+Dynamic: author
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-python
+
+# 📌 SQLitePlus - Base de Datos Mejorada con Cifrado y Caché 🚀
+
+## 📖 Descripción
+SQLitePlus es una implementación mejorada de SQLite con soporte para:
+- **Cifrado de base de datos con SQLCipher** 🔒
+- **Caché en Redis** para mejorar el rendimiento ⚡
+- **Manejo de concurrencia con threading** 🛠️
+- **Exportación y replicación de datos** 📂
+- **Interfaz CLI para administración desde la terminal** 🖥️
+- **Servidor API con FastAPI** para integración flexible 🌐
+
+---
+
+## 📦 Instalación
+### **1️⃣ Clonar el Repositorio**
+```bash
+git clone https://github.com/tuusuario/sqliteplus.git
+cd sqliteplus
+```
+
+### **2️⃣ Crear un Entorno Virtual**
+```bash
+python -m venv .venv
+source .venv/bin/activate  # En Linux/Mac
+.venv\Scripts\activate     # En Windows
+```
+
+### **3️⃣ Instalar Dependencias**
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## 🚀 Uso
+
+### **🔹 Inicializar la Base de Datos**
+```bash
+python -m sqliteplus.cli init-db
+```
+
+### **🔹 Ejecutar una Consulta de Escritura**
+```bash
+python -m sqliteplus.cli execute "INSERT INTO logs (action) VALUES ('Test desde CLI')"
+```
+
+### **🔹 Ejecutar una Consulta de Lectura**
+```bash
+python -m sqliteplus.cli fetch "SELECT * FROM logs"
+```
+
+### **🔹 Crear una Copia de Seguridad**
+```bash
+python -m sqliteplus.cli backup
+```
+
+### **🔹 Exportar una Tabla a CSV**
+```bash
+python -m sqliteplus.cli export-csv logs logs_export.csv
+```
+
+---
+
+## ⚙️ Configuración de Redis (Opcional pero Recomendado)
+Si deseas habilitar la caché en Redis:
+1. **Iniciar Redis en Local**
+   ```bash
+   redis-server
+   ```
+2. **Verificar que Redis está activo**
+   ```bash
+   redis-cli ping  # Debería responder con 'PONG'
+   ```
+
+---
+
+## 📡 Uso del Servidor API
+### **🔹 Iniciar el Servidor FastAPI**
+```bash
+uvicorn sqliteplus.server:app --reload --host 0.0.0.0 --port 8000
+```
+
+### **🔹 Acceder a la Documentación Interactiva**
+Abre en tu navegador: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)
+
+---
+
+## 📜 Licencia
+Este proyecto está bajo la licencia **MIT**.
+
+---
+
+## 🤝 Contribuciones
+¡Las contribuciones son bienvenidas! Si deseas mejorar SQLitePlus, haz un fork del repositorio y envía un pull request. 🚀
+
+---
+
+## 📧 Contacto
+Si tienes dudas o sugerencias, puedes contactarme en **[tuemail@example.com](mailto:tuemail@example.com)** o abrir un issue en GitHub.
+

sqliteplus_enhanced-1.0.0/sqliteplus_enhanced.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+setup.py
+sqliteplus/__init__.py
+sqliteplus/cli.py
+sqliteplus/core.py
+sqliteplus/replication.py
+sqliteplus/security.py
+sqliteplus/server.py
+sqliteplus_enhanced.egg-info/PKG-INFO
+sqliteplus_enhanced.egg-info/SOURCES.txt
+sqliteplus_enhanced.egg-info/dependency_links.txt
+sqliteplus_enhanced.egg-info/entry_points.txt
+sqliteplus_enhanced.egg-info/requires.txt
+sqliteplus_enhanced.egg-info/top_level.txt
+tests/test2.py
+tests/test3.py
+tests/test_jwt_decode.py

sqliteplus_enhanced-1.0.0/sqliteplus_enhanced.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqliteplus_enhanced-1.0.0/sqliteplus_enhanced.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sqliteplus = sqliteplus.cli:cli

sqliteplus_enhanced-1.0.0/sqliteplus_enhanced.egg-info/requires.txt

@@ -0,0 +1,8 @@
+click
+fastapi
+uvicorn
+redis
+bcrypt
+PyJWT
+pytest
+setuptools

sqliteplus_enhanced-1.0.0/sqliteplus_enhanced.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqliteplus

sqliteplus_enhanced-1.0.0/tests/test3.py

@@ -0,0 +1,79 @@
+import sqlite3
+import bcrypt
+import jwt
+import datetime
+import os
+
+SECRET_KEY = "supersecreto"  # Clave secreta para firmar los JWT
+DB_KEY = os.getenv("SQLITE_DB_KEY", "clave_super_segura")  # Clave de cifrado para SQLCipher
+
+def hash_password(password: str) -> str:
+    """
+    Genera un hash seguro de la contraseña.
+    """
+    salt = bcrypt.gensalt()
+    return bcrypt.hashpw(password.encode(), salt).decode()
+
+def verify_password(password: str, hashed_password: str) -> bool:
+    """
+    Verifica si la contraseña coincide con el hash almacenado.
+    """
+    return bcrypt.checkpw(password.encode(), hashed_password.encode())
+
+def generate_jwt(user_id: int, role: str) -> str:
+    """
+    Genera un token JWT válido.
+    """
+    try:
+        payload = {
+            "sub": user_id,
+            "role": role,
+            "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=2)
+        }
+        return jwt.encode(payload, SECRET_KEY, algorithm="HS256")
+    except Exception as e:
+        print(f"Error generando JWT: {e}")
+        return None
+
+def decode_jwt(token: str):
+    """
+    Decodifica y verifica un JWT.
+    """
+    try:
+        return jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
+    except jwt.ExpiredSignatureError:
+        return None
+    except jwt.InvalidTokenError:
+        return None
+
+def get_encrypted_connection(db_path="database.db"):
+    """
+    Obtiene una conexión cifrada con SQLCipher.
+    """
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    cursor.execute(f"PRAGMA key='{DB_KEY}';")  # Establece la clave de cifrado
+    return conn
+
+def create_users_table(db_path="database.db"):
+    """
+    Crea la tabla de usuarios si no existe, usando una base de datos cifrada.
+    """
+    conn = get_encrypted_connection(db_path)
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE,
+            password TEXT,
+            role TEXT
+        )
+        """
+    )
+    conn.commit()
+    conn.close()
+
+if __name__ == "__main__":
+    create_users_table()
+    print("Módulo de seguridad inicializado con cifrado SQLCipher y corrección en JWT.")