eco-back 0.1.0__tar.gz → 0.2.0__tar.gz

{eco_back-0.1.0/src/eco_back.egg-info → eco_back-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eco-back
-Version: 0.1.0
+Version: 0.2.0
 Summary: Librería Python eco-back
 Author-email: EI UNP <ecosistema@unp.gov.co>
 License: MIT
@@ -22,6 +22,8 @@ License-File: LICENSE
 Requires-Dist: psycopg2-binary>=2.9.0
 Requires-Dist: geoalchemy2>=0.14.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: djangorestframework>=3.14.0
+Requires-Dist: django>=4.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -34,16 +36,16 @@ Requires-Dist: shapely>=2.0.0; extra == "geo"
 Requires-Dist: geojson>=3.0.0; extra == "geo"
 Dynamic: license-file
 
-# eco-back
+# eco-back
 
 Librería Python para backend con soporte para PostgreSQL/PostGIS y clientes API
 
 ## Características
 
-- ✅ **Base de datos**: Conexión y operaciones con PostgreSQL
-- ✅ **PostGIS**: Operaciones geoespaciales (puntos, polígonos, búsquedas por proximidad)
-- ✅ **Cliente API**: Cliente HTTP genérico y cliente específico UNP
-- ✅ **Patrón Repository**: Implementación de patrones de diseño para acceso a datos
+-  **Base de datos**: Conexión y operaciones con PostgreSQL
+-  **PostGIS**: Operaciones geoespaciales (puntos, polígonos, búsquedas por proximidad)
+-  **Cliente API**: Cliente HTTP genérico y cliente específico UNP
+-  **Patrón Repository**: Implementación de patrones de diseño para acceso a datos
 
 ## Descripción
 
@@ -51,6 +53,12 @@ eco-back es una librería modular que facilita el desarrollo de aplicaciones bac
 
 ## Instalación
 
+### Desde PyPI
+
+```bash
+pip install eco-back
+```
+
 ### Desde el código fuente
 
 ```bash

{eco_back-0.1.0 → eco_back-0.2.0}/README.md

@@ -1,155 +1,161 @@
-# eco-back
-
-Librería Python para backend con soporte para PostgreSQL/PostGIS y clientes API
-
-## Características
-
-- ✅ **Base de datos**: Conexión y operaciones con PostgreSQL
-- ✅ **PostGIS**: Operaciones geoespaciales (puntos, polígonos, búsquedas por proximidad)
-- ✅ **Cliente API**: Cliente HTTP genérico y cliente específico UNP
-- ✅ **Patrón Repository**: Implementación de patrones de diseño para acceso a datos
-
-## Descripción
-
-eco-back es una librería modular que facilita el desarrollo de aplicaciones backend, proporcionando abstracciones para bases de datos geoespaciales y consumo de APIs REST.
-
-## Instalación
-
-### Desde el código fuente
-
-```bash
-pip install -e .
-```
-
-### Para desarrollo
-
-```bash
-pip install -e ".[dev]"
-```
-
-## Uso
-
-### Cliente de Consecutivos (UNP)
-
-```python
-from eco_back.api import Consecutivo
-
-# Crear cliente
-client = Consecutivo(base_url="https://api.unp.example.com")
-
-# Obtener consecutivo
-consecutivo = client.obtener(origen=1)
-if consecutivo:
-    print(f"Consecutivo: {consecutivo}")
-
-client.close()
-
-# Forma recomendada: usar context manager
-with Consecutivo(base_url="https://api.unp.example.com") as client:
-    consecutivo = client.obtener(origen=1)
-    # Usar el consecutivo...
-```
-
-### Cliente API Genérico
-
-```python
-from eco_back.api import APIConfig, APIClient
-
-config = APIConfig(
-    base_url="https://api.example.com",
-    timeout=30,
-    headers={"Authorization": "Bearer token"}
-)
-
-with APIClient(config) as client:
-    # GET request
-    data = client.get("/endpoint")
-    
-    # POST request
-    result = client.post("/endpoint", json={"key": "value"})
-```
-
-### Conexión básica a PostgreSQL
-
-```python
-from eco_back.database import DatabaseConfig, DatabaseConnection
-
-config = DatabaseConfig(
-    host="localhost",
-    port=5432,
-    database="mi_base_datos",
-    user="usuario",
-    password="password"
-)
-
-with DatabaseConnection(config) as db:
-    resultados = db.execute_query("SELECT * FROM tabla")
-    for row in resultados:
-        print(row)
-```
-
-### Uso de PostGIS
-
-```python
-from eco_back.database import DatabaseConfig, DatabaseConnection, PostGISHelper
-
-config = DatabaseConfig(
-    host="localhost",
-    port=5432,
-    database="mi_db_geo",
-    user="postgres",
-    password="password"
-)
-
-with DatabaseConnection(config) as db:
-    postgis = PostGISHelper(db)
-    
-    # Habilitar PostGIS
-    postgis.enable_postgis()
-    
-    # Insertar un punto geográfico
-    punto_id = postgis.insert_point(
-        table_name="ubicaciones",
-        lat=40.4168,
-        lon=-3.7038,
-        data={"nombre": "Madrid", "tipo": "ciudad"}
-    )
-    
-    # Buscar puntos cercanos (5km)
-    cercanos = postgis.find_within_distance(
-        table_name="ubicaciones",
-        lat=40.4168,
-        lon=-3.7038,
-        distance_meters=5000
-    )
-```
-
-## Desarrollo
-
-### Ejecutar tests
-
-```bash
-pytest
-```
-
-### Formatear código
-
-```bash
-black src/ tests/
-```
-
-### Linting
-
-```bash
-flake8 src/ tests/
-```
-
-### Type checking
-
-```bash
-mypy src/
-```
-
-## Licencia
-
-MIT
+# eco-back
+
+Librería Python para backend con soporte para PostgreSQL/PostGIS y clientes API
+
+## Características
+
+-  **Base de datos**: Conexión y operaciones con PostgreSQL
+-  **PostGIS**: Operaciones geoespaciales (puntos, polígonos, búsquedas por proximidad)
+-  **Cliente API**: Cliente HTTP genérico y cliente específico UNP
+-  **Patrón Repository**: Implementación de patrones de diseño para acceso a datos
+
+## Descripción
+
+eco-back es una librería modular que facilita el desarrollo de aplicaciones backend, proporcionando abstracciones para bases de datos geoespaciales y consumo de APIs REST.
+
+## Instalación
+
+### Desde PyPI
+
+```bash
+pip install eco-back
+```
+
+### Desde el código fuente
+
+```bash
+pip install -e .
+```
+
+### Para desarrollo
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Uso
+
+### Cliente de Consecutivos (UNP)
+
+```python
+from eco_back.api import Consecutivo
+
+# Crear cliente
+client = Consecutivo(base_url="https://api.unp.example.com")
+
+# Obtener consecutivo
+consecutivo = client.obtener(origen=1)
+if consecutivo:
+    print(f"Consecutivo: {consecutivo}")
+
+client.close()
+
+# Forma recomendada: usar context manager
+with Consecutivo(base_url="https://api.unp.example.com") as client:
+    consecutivo = client.obtener(origen=1)
+    # Usar el consecutivo...
+```
+
+### Cliente API Genérico
+
+```python
+from eco_back.api import APIConfig, APIClient
+
+config = APIConfig(
+    base_url="https://api.example.com",
+    timeout=30,
+    headers={"Authorization": "Bearer token"}
+)
+
+with APIClient(config) as client:
+    # GET request
+    data = client.get("/endpoint")
+    
+    # POST request
+    result = client.post("/endpoint", json={"key": "value"})
+```
+
+### Conexión básica a PostgreSQL
+
+```python
+from eco_back.database import DatabaseConfig, DatabaseConnection
+
+config = DatabaseConfig(
+    host="localhost",
+    port=5432,
+    database="mi_base_datos",
+    user="usuario",
+    password="password"
+)
+
+with DatabaseConnection(config) as db:
+    resultados = db.execute_query("SELECT * FROM tabla")
+    for row in resultados:
+        print(row)
+```
+
+### Uso de PostGIS
+
+```python
+from eco_back.database import DatabaseConfig, DatabaseConnection, PostGISHelper
+
+config = DatabaseConfig(
+    host="localhost",
+    port=5432,
+    database="mi_db_geo",
+    user="postgres",
+    password="password"
+)
+
+with DatabaseConnection(config) as db:
+    postgis = PostGISHelper(db)
+    
+    # Habilitar PostGIS
+    postgis.enable_postgis()
+    
+    # Insertar un punto geográfico
+    punto_id = postgis.insert_point(
+        table_name="ubicaciones",
+        lat=40.4168,
+        lon=-3.7038,
+        data={"nombre": "Madrid", "tipo": "ciudad"}
+    )
+    
+    # Buscar puntos cercanos (5km)
+    cercanos = postgis.find_within_distance(
+        table_name="ubicaciones",
+        lat=40.4168,
+        lon=-3.7038,
+        distance_meters=5000
+    )
+```
+
+## Desarrollo
+
+### Ejecutar tests
+
+```bash
+pytest
+```
+
+### Formatear código
+
+```bash
+black src/ tests/
+```
+
+### Linting
+
+```bash
+flake8 src/ tests/
+```
+
+### Type checking
+
+```bash
+mypy src/
+```
+
+## Licencia
+
+MIT

{eco_back-0.1.0 → eco_back-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "eco-back"
-version = "0.1.0"
+version = "0.2.0"
 description = "Librería Python eco-back"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -27,6 +27,8 @@ dependencies = [
     "psycopg2-binary>=2.9.0",
     "geoalchemy2>=0.14.0",
     "requests>=2.31.0",
+    "djangorestframework>=3.14.0",
+    "django>=4.0.0",
 ]
 
 [project.optional-dependencies]

eco_back-0.2.0/src/eco_back/__init__.py

@@ -0,0 +1,13 @@
+"""
+eco-back - Librería Python
+"""
+
+__version__ = "0.2.0"
+
+# Módulos principales
+from . import database
+from . import api
+from . import documento
+from . import registro
+
+__all__ = ["database", "api", "documento", "registro", "__version__"]

eco_back-0.2.0/src/eco_back/documento/__init__.py

@@ -0,0 +1,6 @@
+"""
+Módulo de gestión de documentos y anexos
+"""
+from .anexos import AnexoManager, AnexoConfig
+
+__all__ = ['AnexoManager', 'AnexoConfig']

eco_back-0.2.0/src/eco_back/documento/anexos.py

@@ -0,0 +1,481 @@
+"""
+Cliente para gestión de anexos y documentos UNP
+
+Maneja el proceso de validación, escaneo y envío de documentos
+a los servicios de la API UNP.
+"""
+import logging
+import os
+import shutil
+import tempfile
+import threading
+import time
+import uuid
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any, Callable, BinaryIO, Union
+from io import BytesIO
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+# Constantes
+MAX_SIZE = 10 * 1024 * 1024  # 10MB
+MAX_RETRIES = 3
+TIMEOUT = 30
+
+# Extensiones MIME permitidas
+ALLOWED_EXTENSIONS = {
+    'pdf': 'application/pdf',
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'png': 'image/png',
+    'doc': 'application/msword',
+    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'xls': 'application/vnd.ms-excel',
+    'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+}
+
+
+@dataclass
+class AnexoConfig:
+    """
+    Configuración para el gestor de anexos
+    
+    Attributes:
+        url_base: URL base del API UNP
+        max_size: Tamaño máximo de archivo en bytes (default: 10MB)
+        max_retries: Número máximo de reintentos (default: 3)
+        timeout: Timeout para las peticiones en segundos (default: 30)
+        scan_function: Función opcional para escaneo de archivos
+        diccionario_registro: Función para mapear tipos de documento de registro
+        diccionario_persona: Función para mapear tipos de documento de persona
+        diccionario_colectivo: Función para mapear tipos de documento de colectivo
+    """
+    url_base: str
+    max_size: int = MAX_SIZE
+    max_retries: int = MAX_RETRIES
+    timeout: int = TIMEOUT
+    scan_function: Optional[Callable] = None
+    diccionario_registro: Optional[Callable] = None
+    diccionario_persona: Optional[Callable] = None
+    diccionario_colectivo: Optional[Callable] = None
+
+
+class DocumentoResult:
+    """Resultado del procesamiento de un documento"""
+    
+    def __init__(self, status: str, mensaje: str, detalles: Optional[Dict] = None):
+        self.status = status
+        self.mensaje = mensaje
+        self.detalles = detalles or {}
+        self.exitoso = status in ['success', 'processing']
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convierte el resultado a diccionario"""
+        return {
+            'status': self.status,
+            'mensaje': self.mensaje,
+            'detalles': self.detalles,
+            'exitoso': self.exitoso
+        }
+
+
+class AnexoManager:
+    """
+    Gestor de anexos y documentos para la API UNP
+    
+    Maneja el proceso completo de:
+    - Validación de archivos
+    - Escaneo antivirus (opcional)
+    - Envío asíncrono a la API UNP
+    
+    Ejemplo:
+        >>> from eco_back.documento import AnexoManager, AnexoConfig
+        >>> 
+        >>> config = AnexoConfig(url_base="https://api.unp.gov.co")
+        >>> manager = AnexoManager(config)
+        >>> 
+        >>> # Subir archivo desde ruta
+        >>> with open("documento.pdf", "rb") as f:
+        ...     resultado = manager.guardar_anexo(
+        ...         archivo=f,
+        ...         nombre_archivo="documento.pdf",
+        ...         llave="12345",
+        ...         grupo="grupo1",
+        ...         tipo_documento="cedula",
+        ...         diccionario=1
+        ...     )
+        >>> print(resultado.mensaje)
+    """
+    
+    def __init__(self, config: AnexoConfig):
+        """
+        Inicializa el gestor de anexos
+        
+        Args:
+            config: Configuración del gestor
+        """
+        self.config = config
+    
+    def obtener_extension(self, nombre_archivo: str) -> str:
+        """
+        Obtiene la extensión del archivo (incluye el punto, ej: '.pdf')
+        
+        Args:
+            nombre_archivo: Nombre del archivo
+            
+        Returns:
+            Extensión del archivo en minúsculas (con punto)
+        """
+        return os.path.splitext(nombre_archivo)[1].lower()
+    
+    def validar_extension(self, extension: str) -> bool:
+        """
+        Valida si la extensión es permitida
+        
+        Args:
+            extension: Extensión a validar (con o sin punto)
+            
+        Returns:
+            True si es válida, False en caso contrario
+        """
+        ext = extension.lstrip('.')
+        return ext in ALLOWED_EXTENSIONS
+    
+    def obtener_mime_type(self, nombre_archivo: str) -> str:
+        """
+        Obtiene el tipo MIME basado en la extensión del archivo
+        
+        Args:
+            nombre_archivo: Nombre del archivo
+            
+        Returns:
+            Tipo MIME correspondiente
+        """
+        ext = nombre_archivo.split('.')[-1].lower()
+        return ALLOWED_EXTENSIONS.get(ext, 'application/octet-stream')
+    
+    def _escanear_archivo(self, ruta_archivo: str, extension: str) -> Dict[str, Any]:
+        """
+        Escanea el archivo en busca de amenazas
+        
+        Args:
+            ruta_archivo: Ruta del archivo a escanear
+            extension: Extensión del archivo
+            
+        Returns:
+            Diccionario con status y detalles del escaneo
+        """
+        if self.config.scan_function:
+            try:
+                return self.config.scan_function(ruta_archivo, extension)
+            except Exception as e:
+                logger.error(f"Error en escaneo: {e}")
+                return {'status': 'ERROR', 'details': str(e)}
+        
+        # Sin función de escaneo, asumir limpio
+        return {'status': 'CLEAN', 'details': 'No scan configured'}
+    
+    def guardar_anexo(
+        self,
+        archivo: Union[BinaryIO, BytesIO, bytes],
+        nombre_archivo: str,
+        llave: str,
+        grupo: str,
+        tipo_documento: str,
+        diccionario: int,
+        asincrono: bool = True
+    ) -> DocumentoResult:
+        """
+        Guarda y envía un anexo a la API UNP
+        
+        Args:
+            archivo: Archivo a subir (file-like object o bytes)
+            nombre_archivo: Nombre original del archivo
+            llave: Identificador único del registro
+            grupo: Grupo del documento
+            tipo_documento: Tipo de documento a enviar
+            diccionario: Tipo de diccionario (1=registro, 2=persona, 3=colectivo)
+            asincrono: Si True, envía en hilo separado (default: True)
+            
+        Returns:
+            DocumentoResult con el resultado del procesamiento
+        """
+        temp_dir = tempfile.mkdtemp()
+        
+        try:
+            # Validar extensión
+            extension = self.obtener_extension(nombre_archivo)
+            if not self.validar_extension(extension):
+                return DocumentoResult(
+                    status='error',
+                    mensaje=f"Extensión {extension} no permitida",
+                    detalles={'extensiones_permitidas': list(ALLOWED_EXTENSIONS.keys())}
+                )
+            
+            # Leer contenido del archivo
+            if isinstance(archivo, bytes):
+                contenido = archivo
+            else:
+                contenido = archivo.read()
+            
+            # Validar tamaño
+            if len(contenido) > self.config.max_size:
+                return DocumentoResult(
+                    status='error',
+                    mensaje=f"Archivo excede tamaño máximo de {self.config.max_size / 1024 / 1024}MB",
+                    detalles={'tamaño': len(contenido), 'max_size': self.config.max_size}
+                )
+            
+            # Guardar temporalmente
+            with tempfile.NamedTemporaryFile(delete=False, dir=temp_dir, suffix=extension) as tmp:
+                tmp.write(contenido)
+                temp_path = tmp.name
+            
+            # Escaneo antivirus
+            scan_result = self._escanear_archivo(temp_path, extension)
+            if scan_result['status'] != "CLEAN":
+                os.remove(temp_path)
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                return DocumentoResult(
+                    status='blocked',
+                    mensaje=f"Archivo {nombre_archivo} bloqueado por escaneo",
+                    detalles=scan_result
+                )
+            
+            # Renombrar archivo con timestamp
+            ext = extension.lstrip('.') or 'bin'
+            timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+            nuevo_nombre = f"{llave}_anexo_{timestamp}.{ext}"
+            destino = os.path.join(temp_dir, nuevo_nombre)
+            os.replace(temp_path, destino)
+            
+            file_meta = {
+                'field': 'anexo',
+                'path': destino,
+                'original_name': nombre_archivo,
+                'tipo_documento': tipo_documento,
+            }
+            
+            # Enviar archivo
+            if asincrono:
+                threading.Thread(
+                    target=self._enviar_documento,
+                    args=(file_meta, llave, grupo, tipo_documento, temp_dir, diccionario)
+                ).start()
+                
+                return DocumentoResult(
+                    status='processing',
+                    mensaje='Documento en proceso de envío',
+                    detalles={'archivo': nuevo_nombre}
+                )
+            else:
+                # Envío síncrono
+                resultado = self._enviar_documento_sincrono(
+                    file_meta, llave, grupo, tipo_documento, temp_dir, diccionario
+                )
+                return resultado
+        
+        except Exception as e:
+            logger.error(f"Error en guardar_anexo: {e}")
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            return DocumentoResult(
+                status='error',
+                mensaje=str(e),
+                detalles={'error_type': type(e).__name__}
+            )
+    
+    def _obtener_tipo_documento(self, tipo: str, diccionario: int) -> Optional[str]:
+        """
+        Obtiene el tipo de documento usando el diccionario correspondiente
+        
+        Args:
+            tipo: Tipo de documento original
+            diccionario: Tipo de diccionario (1=registro, 2=persona, 3=colectivo)
+            
+        Returns:
+            Tipo de documento mapeado o None
+        """
+        if diccionario == 1 and self.config.diccionario_registro:
+            return self.config.diccionario_registro(tipo)
+        elif diccionario == 2 and self.config.diccionario_persona:
+            return self.config.diccionario_persona(tipo)
+        elif diccionario == 3 and self.config.diccionario_colectivo:
+            return self.config.diccionario_colectivo(tipo)
+        
+        # Si no hay diccionario, devolver el tipo original
+        return tipo
+    
+    def _obtener_endpoint(self, diccionario: int) -> str:
+        """
+        Obtiene el endpoint según el tipo de diccionario
+        
+        Args:
+            diccionario: Tipo de diccionario (1=registro, 2=persona, 3=colectivo)
+            
+        Returns:
+            Endpoint correspondiente
+        """
+        endpoints = {
+            1: 'usuario',
+            2: 'persona',
+            3: 'colectivo'
+        }
+        return endpoints.get(diccionario, 'usuario')
+    
+    def _enviar_documento(
+        self,
+        file_meta: Dict[str, str],
+        llave: str,
+        grupo: str,
+        tipo: str,
+        temp_dir: str,
+        diccionario: int
+    ) -> None:
+        """
+        Envía el documento a la API UNP (versión asíncrona)
+        
+        Args:
+            file_meta: Metadatos del archivo
+            llave: Identificador del registro
+            grupo: Grupo del documento
+            tipo: Tipo de documento
+            temp_dir: Directorio temporal
+            diccionario: Tipo de diccionario
+        """
+        try:
+            resultado = self._enviar_documento_sincrono(
+                file_meta, llave, grupo, tipo, temp_dir, diccionario
+            )
+            if resultado.exitoso:
+                logger.info(f"Documento enviado exitosamente: {file_meta['original_name']}")
+            else:
+                logger.error(f"Error enviando documento: {resultado.mensaje}")
+        except Exception as e:
+            logger.error(f"Error en envío asíncrono: {e}")
+        finally:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+    
+    def _enviar_documento_sincrono(
+        self,
+        file_meta: Dict[str, str],
+        llave: str,
+        grupo: str,
+        tipo: str,
+        temp_dir: str,
+        diccionario: int
+    ) -> DocumentoResult:
+        """
+        Envía el documento a la API UNP de forma síncrona
+        
+        Args:
+            file_meta: Metadatos del archivo
+            llave: Identificador del registro
+            grupo: Grupo del documento
+            tipo: Tipo de documento
+            temp_dir: Directorio temporal
+            diccionario: Tipo de diccionario
+            
+        Returns:
+            DocumentoResult con el resultado del envío
+        """
+        try:
+            if not os.path.exists(file_meta['path']):
+                return DocumentoResult(
+                    status='error',
+                    mensaje=f"Archivo no encontrado: {file_meta['path']}"
+                )
+            
+            # Leer contenido
+            with open(file_meta['path'], 'rb') as f:
+                content = f.read()
+                if len(content) > self.config.max_size:
+                    return DocumentoResult(
+                        status='error',
+                        mensaje=f"Archivo {file_meta['original_name']} excede tamaño permitido"
+                    )
+            
+            # Determinar MIME
+            mime_type = self.obtener_mime_type(file_meta['original_name'])
+            
+            # Preparar archivos para envío
+            files = [
+                (file_meta['field'], (file_meta['original_name'], content, mime_type))
+            ]
+            
+            # Headers
+            headers = {
+                'User-Agent': 'EcoBack-DocumentSender/1.0',
+                'X-Request-ID': str(uuid.uuid4())
+            }
+            
+            # Obtener endpoint y tipo de documento
+            endpoint = self._obtener_endpoint(diccionario)
+            tipo_docu = self._obtener_tipo_documento(tipo, diccionario)
+            
+            # URL completa
+            url = f"{self.config.url_base}/api-doc/{endpoint}/guardaranexo"
+            
+            # Datos del formulario
+            data = {
+                'llave': llave,
+                'grupo': grupo,
+                'tipo_documento': tipo_docu
+            }
+            
+            # Envío con reintentos
+            for intento in range(self.config.max_retries):
+                try:
+                    response = requests.post(
+                        url,
+                        files=files,
+                        data=data,
+                        headers=headers,
+                        timeout=self.config.timeout
+                    )
+                    
+                    if response.status_code in [200, 201]:
+                        logger.info(f"Envío exitoso en intento {intento + 1}")
+                        return DocumentoResult(
+                            status='success',
+                            mensaje='Documento enviado exitosamente',
+                            detalles={
+                                'intentos': intento + 1,
+                                'response': response.json() if response.content else {}
+                            }
+                        )
+                    elif 500 <= response.status_code < 600:
+                        # Error del servidor, reintentar
+                        logger.warning(f"Error del servidor ({response.status_code}), reintentando...")
+                        time.sleep(2 ** intento)
+                        continue
+                    else:
+                        # Error del cliente, no reintentar
+                        return DocumentoResult(
+                            status='error',
+                            mensaje=f"Error en envío: {response.status_code}",
+                            detalles={'response_text': response.text}
+                        )
+                
+                except requests.RequestException as e:
+                    logger.error(f"Error de conexión en intento {intento + 1}: {e}")
+                    if intento == self.config.max_retries - 1:
+                        return DocumentoResult(
+                            status='error',
+                            mensaje='Máximo número de reintentos alcanzado',
+                            detalles={'error': str(e)}
+                        )
+                    time.sleep(2 ** intento)
+            
+            return DocumentoResult(
+                status='error',
+                mensaje='No se pudo enviar el documento después de todos los reintentos'
+            )
+        
+        finally:
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir, ignore_errors=True)

eco_back-0.2.0/src/eco_back/registro/__init__.py

@@ -0,0 +1,7 @@
+"""
+Módulo de registro y trazabilidad
+"""
+
+from .trazabilidad import TrazabilidadRegistroPermiso
+
+__all__ = ["TrazabilidadRegistroPermiso"]

{eco_back-0.1.0 → eco_back-0.2.0/src/eco_back.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eco-back
-Version: 0.1.0
+Version: 0.2.0
 Summary: Librería Python eco-back
 Author-email: EI UNP <ecosistema@unp.gov.co>
 License: MIT
@@ -22,6 +22,8 @@ License-File: LICENSE
 Requires-Dist: psycopg2-binary>=2.9.0
 Requires-Dist: geoalchemy2>=0.14.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: djangorestframework>=3.14.0
+Requires-Dist: django>=4.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -34,16 +36,16 @@ Requires-Dist: shapely>=2.0.0; extra == "geo"
 Requires-Dist: geojson>=3.0.0; extra == "geo"
 Dynamic: license-file
 
-# eco-back
+# eco-back
 
 Librería Python para backend con soporte para PostgreSQL/PostGIS y clientes API
 
 ## Características
 
-- ✅ **Base de datos**: Conexión y operaciones con PostgreSQL
-- ✅ **PostGIS**: Operaciones geoespaciales (puntos, polígonos, búsquedas por proximidad)
-- ✅ **Cliente API**: Cliente HTTP genérico y cliente específico UNP
-- ✅ **Patrón Repository**: Implementación de patrones de diseño para acceso a datos
+-  **Base de datos**: Conexión y operaciones con PostgreSQL
+-  **PostGIS**: Operaciones geoespaciales (puntos, polígonos, búsquedas por proximidad)
+-  **Cliente API**: Cliente HTTP genérico y cliente específico UNP
+-  **Patrón Repository**: Implementación de patrones de diseño para acceso a datos
 
 ## Descripción
 
@@ -51,6 +53,12 @@ eco-back es una librería modular que facilita el desarrollo de aplicaciones bac
 
 ## Instalación
 
+### Desde PyPI
+
+```bash
+pip install eco-back
+```
+
 ### Desde el código fuente
 
 ```bash

{eco_back-0.1.0 → eco_back-0.2.0}/src/eco_back.egg-info/SOURCES.txt

@@ -18,6 +18,11 @@ src/eco_back/database/connection.py
 src/eco_back/database/models.py
 src/eco_back/database/postgis.py
 src/eco_back/database/repository.py
+src/eco_back/documento/__init__.py
+src/eco_back/documento/anexos.py
+src/eco_back/registro/__init__.py
+src/eco_back/registro/trazabilidad.py
+tests/test_anexos.py
 tests/test_api.py
 tests/test_database.py
 tests/test_example.py

{eco_back-0.1.0 → eco_back-0.2.0}/src/eco_back.egg-info/requires.txt

@@ -1,6 +1,8 @@
 psycopg2-binary>=2.9.0
 geoalchemy2>=0.14.0
 requests>=2.31.0
+djangorestframework>=3.14.0
+django>=4.0.0
 
 [dev]
 pytest>=7.0

eco_back-0.2.0/tests/test_anexos.py

@@ -0,0 +1,277 @@
+"""
+Tests para el módulo de anexos y documentos
+"""
+import pytest
+import tempfile
+import os
+from io import BytesIO
+from unittest.mock import Mock, patch, MagicMock
+
+from eco_back.documento import AnexoManager, AnexoConfig, DocumentoResult
+
+
+@pytest.fixture
+def config_basica():
+    """Configuración básica para tests"""
+    return AnexoConfig(
+        url_base="https://api.test.com",
+        max_size=1024 * 1024,  # 1MB para tests
+        max_retries=2,
+        timeout=10
+    )
+
+
+@pytest.fixture
+def manager(config_basica):
+    """Fixture del manager"""
+    return AnexoManager(config_basica)
+
+
+def test_obtener_extension(manager):
+    """Test de obtención de extensión"""
+    assert manager.obtener_extension("archivo.pdf") == ".pdf"
+    assert manager.obtener_extension("documento.PDF") == ".pdf"
+    assert manager.obtener_extension("imagen.JPG") == ".jpg"
+    assert manager.obtener_extension("sin_extension") == ""
+
+
+def test_validar_extension(manager):
+    """Test de validación de extensiones"""
+    assert manager.validar_extension(".pdf") is True
+    assert manager.validar_extension("pdf") is True
+    assert manager.validar_extension(".jpg") is True
+    assert manager.validar_extension(".exe") is False
+    assert manager.validar_extension(".bat") is False
+
+
+def test_obtener_mime_type(manager):
+    """Test de obtención de tipo MIME"""
+    assert manager.obtener_mime_type("doc.pdf") == "application/pdf"
+    assert manager.obtener_mime_type("foto.jpg") == "image/jpeg"
+    assert manager.obtener_mime_type("foto.jpeg") == "image/jpeg"
+    assert manager.obtener_mime_type("imagen.png") == "image/png"
+    assert manager.obtener_mime_type("archivo.xyz") == "application/octet-stream"
+
+
+def test_documento_result():
+    """Test de DocumentoResult"""
+    resultado = DocumentoResult(
+        status="success",
+        mensaje="Todo bien",
+        detalles={"key": "value"}
+    )
+    
+    assert resultado.status == "success"
+    assert resultado.exitoso is True
+    assert resultado.detalles["key"] == "value"
+    
+    dict_result = resultado.to_dict()
+    assert dict_result["status"] == "success"
+    assert dict_result["exitoso"] is True
+
+
+def test_documento_result_error():
+    """Test de DocumentoResult con error"""
+    resultado = DocumentoResult(
+        status="error",
+        mensaje="Falló",
+    )
+    
+    assert resultado.exitoso is False
+
+
+def test_guardar_anexo_extension_invalida(manager):
+    """Test de rechazo por extensión inválida"""
+    archivo = BytesIO(b"contenido")
+    
+    resultado = manager.guardar_anexo(
+        archivo=archivo,
+        nombre_archivo="malware.exe",
+        llave="123",
+        grupo="test",
+        tipo_documento="doc",
+        diccionario=1,
+        asincrono=False
+    )
+    
+    assert resultado.exitoso is False
+    assert "no permitida" in resultado.mensaje
+
+
+def test_guardar_anexo_tamano_excedido(manager):
+    """Test de rechazo por tamaño excedido"""
+    # Crear contenido que excede el límite
+    contenido = b"X" * (2 * 1024 * 1024)  # 2MB (límite es 1MB)
+    
+    resultado = manager.guardar_anexo(
+        archivo=contenido,
+        nombre_archivo="grande.pdf",
+        llave="123",
+        grupo="test",
+        tipo_documento="doc",
+        diccionario=1,
+        asincrono=False
+    )
+    
+    assert resultado.exitoso is False
+    assert "excede tamaño" in resultado.mensaje
+
+
+def test_escanear_archivo_sin_funcion(manager):
+    """Test de escaneo cuando no hay función configurada"""
+    with tempfile.NamedTemporaryFile(suffix=".pdf") as tmp:
+        tmp.write(b"PDF content")
+        tmp.flush()
+        
+        scan_result = manager._escanear_archivo(tmp.name, ".pdf")
+        assert scan_result['status'] == 'CLEAN'
+
+
+def test_escanear_archivo_con_funcion():
+    """Test de escaneo con función personalizada"""
+    def scan_mock(path, ext):
+        return {'status': 'CLEAN', 'details': 'OK'}
+    
+    config = AnexoConfig(
+        url_base="https://test.com",
+        scan_function=scan_mock
+    )
+    manager = AnexoManager(config)
+    
+    with tempfile.NamedTemporaryFile(suffix=".pdf") as tmp:
+        tmp.write(b"PDF content")
+        tmp.flush()
+        
+        scan_result = manager._escanear_archivo(tmp.name, ".pdf")
+        assert scan_result['status'] == 'CLEAN'
+
+
+def test_obtener_endpoint(manager):
+    """Test de obtención de endpoint según diccionario"""
+    assert manager._obtener_endpoint(1) == "usuario"
+    assert manager._obtener_endpoint(2) == "persona"
+    assert manager._obtener_endpoint(3) == "colectivo"
+    assert manager._obtener_endpoint(99) == "usuario"  # Default
+
+
+def test_obtener_tipo_documento_sin_diccionario(manager):
+    """Test de tipo de documento sin función de diccionario"""
+    tipo = manager._obtener_tipo_documento("cedula", 1)
+    assert tipo == "cedula"  # Sin mapeo, devuelve original
+
+
+def test_obtener_tipo_documento_con_diccionario():
+    """Test de tipo de documento con función de diccionario"""
+    def dict_func(tipo):
+        return {"cedula": "CC"}.get(tipo, tipo)
+    
+    config = AnexoConfig(
+        url_base="https://test.com",
+        diccionario_registro=dict_func
+    )
+    manager = AnexoManager(config)
+    
+    tipo = manager._obtener_tipo_documento("cedula", 1)
+    assert tipo == "CC"
+
+
+@patch('eco_back.documento.anexos.requests.post')
+def test_enviar_documento_sincrono_exitoso(mock_post, manager):
+    """Test de envío síncrono exitoso"""
+    # Mock de respuesta exitosa
+    mock_response = Mock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {"success": True}
+    mock_response.content = b'{"success": true}'
+    mock_post.return_value = mock_response
+    
+    # Crear archivo temporal
+    with tempfile.TemporaryDirectory() as temp_dir:
+        archivo_path = os.path.join(temp_dir, "test.pdf")
+        with open(archivo_path, 'wb') as f:
+            f.write(b"PDF content")
+        
+        file_meta = {
+            'field': 'anexo',
+            'path': archivo_path,
+            'original_name': 'test.pdf',
+            'tipo_documento': 'cedula'
+        }
+        
+        resultado = manager._enviar_documento_sincrono(
+            file_meta=file_meta,
+            llave="123",
+            grupo="test",
+            tipo="cedula",
+            temp_dir=temp_dir,
+            diccionario=1
+        )
+        
+        assert resultado.exitoso is True
+        assert resultado.status == "success"
+        assert mock_post.called
+
+
+@patch('eco_back.documento.anexos.requests.post')
+def test_enviar_documento_con_reintentos(mock_post, manager):
+    """Test de reintentos en caso de error del servidor"""
+    # Primera llamada falla con 500, segunda con 200
+    mock_response_error = Mock()
+    mock_response_error.status_code = 500
+    
+    mock_response_ok = Mock()
+    mock_response_ok.status_code = 200
+    mock_response_ok.json.return_value = {"success": True}
+    mock_response_ok.content = b'{"success": true}'
+    
+    mock_post.side_effect = [mock_response_error, mock_response_ok]
+    
+    with tempfile.TemporaryDirectory() as temp_dir:
+        archivo_path = os.path.join(temp_dir, "test.pdf")
+        with open(archivo_path, 'wb') as f:
+            f.write(b"PDF content")
+        
+        file_meta = {
+            'field': 'anexo',
+            'path': archivo_path,
+            'original_name': 'test.pdf',
+            'tipo_documento': 'cedula'
+        }
+        
+        resultado = manager._enviar_documento_sincrono(
+            file_meta=file_meta,
+            llave="123",
+            grupo="test",
+            tipo="cedula",
+            temp_dir=temp_dir,
+            diccionario=1
+        )
+        
+        assert resultado.exitoso is True
+        assert mock_post.call_count == 2
+
+
+@patch('eco_back.documento.anexos.requests.post')
+def test_guardar_anexo_asincrono(mock_post, manager):
+    """Test de guardado asíncrono"""
+    mock_response = Mock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {"success": True}
+    mock_response.content = b'{"success": true}'
+    mock_post.return_value = mock_response
+    
+    contenido = b"PDF content"
+    
+    resultado = manager.guardar_anexo(
+        archivo=contenido,
+        nombre_archivo="test.pdf",
+        llave="123",
+        grupo="test",
+        tipo_documento="cedula",
+        diccionario=1,
+        asincrono=True
+    )
+    
+    assert resultado.exitoso is True
+    assert resultado.status == "processing"
+    assert "proceso" in resultado.mensaje

eco_back-0.1.0/src/eco_back/__init__.py

@@ -1,11 +0,0 @@
-"""
-eco-back - Librería Python
-"""
-
-__version__ = "0.1.0"
-
-# Módulos principales
-from . import database
-from . import api
-
-__all__ = ["database", "api", "__version__"]