eco-back 0.1.0__py3-none-any.whl

eco_back/__init__.py

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

eco_back/api/__init__.py

@@ -0,0 +1,9 @@
+"""
+Módulo de cliente API para eco-back
+"""
+
+from .config import APIConfig
+from .client import APIClient
+from .registro import Consecutivo
+
+__all__ = ["APIConfig", "APIClient", "Consecutivo"]

eco_back/api/client.py

@@ -0,0 +1,278 @@
+"""
+Cliente HTTP para consumir APIs
+"""
+from typing import Optional, Dict, Any, Union
+import logging
+
+try:
+    import requests
+    from requests.exceptions import RequestException, Timeout, HTTPError
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+
+from .config import APIConfig
+
+logger = logging.getLogger(__name__)
+
+
+class APIClient:
+    """
+    Cliente HTTP genérico para consumir APIs REST
+    
+    Ejemplo:
+        >>> from eco_back.api import APIConfig, APIClient
+        >>> 
+        >>> config = APIConfig(base_url="https://api.ejemplo.com")
+        >>> client = APIClient(config)
+        >>> 
+        >>> # GET request
+        >>> data = client.get("/users/1")
+        >>> 
+        >>> # POST request
+        >>> response = client.post("/users", data={"name": "Juan"})
+    """
+    
+    def __init__(self, config: APIConfig):
+        """
+        Inicializa el cliente API
+        
+        Args:
+            config: Configuración del API
+            
+        Raises:
+            ImportError: Si requests no está instalado
+        """
+        if not REQUESTS_AVAILABLE:
+            raise ImportError(
+                "requests no está instalado. Instálalo con: pip install requests"
+            )
+        
+        self.config = config
+        self.session = requests.Session()
+        
+        # Configurar headers por defecto
+        if self.config.headers:
+            self.session.headers.update(self.config.headers)
+    
+    def _build_url(self, endpoint: str) -> str:
+        """
+        Construye la URL completa
+        
+        Args:
+            endpoint: Endpoint del API
+            
+        Returns:
+            URL completa
+        """
+        # Asegurar que el endpoint empiece con /
+        if not endpoint.startswith('/'):
+            endpoint = f'/{endpoint}'
+        
+        return f'{self.config.base_url}{endpoint}'
+    
+    def _handle_response(
+        self,
+        response: requests.Response,
+        raise_for_status: bool = True
+    ) -> Optional[Union[Dict[str, Any], list, str]]:
+        """
+        Procesa la respuesta HTTP
+        
+        Args:
+            response: Respuesta HTTP
+            raise_for_status: Si debe lanzar excepción en errores HTTP
+            
+        Returns:
+            Datos parseados de la respuesta o None
+        """
+        if raise_for_status:
+            try:
+                response.raise_for_status()
+            except HTTPError as e:
+                logger.error(f"Error HTTP {response.status_code}: {e}")
+                raise
+        
+        if response.status_code == 204:  # No Content
+            return None
+        
+        try:
+            return response.json()
+        except ValueError:
+            # Si no es JSON, retornar el texto
+            return response.text
+    
+    def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        raise_for_status: bool = True
+    ) -> Optional[Union[Dict[str, Any], list, str]]:
+        """
+        Realiza una petición GET
+        
+        Args:
+            endpoint: Endpoint del API
+            params: Parámetros query string
+            headers: Headers adicionales
+            timeout: Tiempo de espera (usa el default si no se especifica)
+            raise_for_status: Si debe lanzar excepción en errores HTTP
+            
+        Returns:
+            Respuesta parseada
+            
+        Raises:
+            RequestException: Si hay error en la petición
+        """
+        url = self._build_url(endpoint)
+        timeout = timeout or self.config.timeout
+        
+        try:
+            logger.debug(f"GET {url}")
+            response = self.session.get(
+                url,
+                params=params,
+                headers=headers,
+                timeout=timeout,
+                verify=self.config.verify_ssl
+            )
+            return self._handle_response(response, raise_for_status)
+        except Timeout:
+            logger.error(f"Timeout al hacer GET a {url}")
+            raise
+        except RequestException as e:
+            logger.error(f"Error en GET {url}: {e}")
+            raise
+    
+    def post(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        raise_for_status: bool = True
+    ) -> Optional[Union[Dict[str, Any], list, str]]:
+        """
+        Realiza una petición POST
+        
+        Args:
+            endpoint: Endpoint del API
+            data: Datos form-encoded
+            json: Datos JSON
+            headers: Headers adicionales
+            timeout: Tiempo de espera
+            raise_for_status: Si debe lanzar excepción en errores HTTP
+            
+        Returns:
+            Respuesta parseada
+        """
+        url = self._build_url(endpoint)
+        timeout = timeout or self.config.timeout
+        
+        try:
+            logger.debug(f"POST {url}")
+            response = self.session.post(
+                url,
+                data=data,
+                json=json,
+                headers=headers,
+                timeout=timeout,
+                verify=self.config.verify_ssl
+            )
+            return self._handle_response(response, raise_for_status)
+        except RequestException as e:
+            logger.error(f"Error en POST {url}: {e}")
+            raise
+    
+    def put(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        raise_for_status: bool = True
+    ) -> Optional[Union[Dict[str, Any], list, str]]:
+        """
+        Realiza una petición PUT
+        
+        Args:
+            endpoint: Endpoint del API
+            data: Datos form-encoded
+            json: Datos JSON
+            headers: Headers adicionales
+            timeout: Tiempo de espera
+            raise_for_status: Si debe lanzar excepción en errores HTTP
+            
+        Returns:
+            Respuesta parseada
+        """
+        url = self._build_url(endpoint)
+        timeout = timeout or self.config.timeout
+        
+        try:
+            logger.debug(f"PUT {url}")
+            response = self.session.put(
+                url,
+                data=data,
+                json=json,
+                headers=headers,
+                timeout=timeout,
+                verify=self.config.verify_ssl
+            )
+            return self._handle_response(response, raise_for_status)
+        except RequestException as e:
+            logger.error(f"Error en PUT {url}: {e}")
+            raise
+    
+    def delete(
+        self,
+        endpoint: str,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        raise_for_status: bool = True
+    ) -> Optional[Union[Dict[str, Any], list, str]]:
+        """
+        Realiza una petición DELETE
+        
+        Args:
+            endpoint: Endpoint del API
+            headers: Headers adicionales
+            timeout: Tiempo de espera
+            raise_for_status: Si debe lanzar excepción en errores HTTP
+            
+        Returns:
+            Respuesta parseada
+        """
+        url = self._build_url(endpoint)
+        timeout = timeout or self.config.timeout
+        
+        try:
+            logger.debug(f"DELETE {url}")
+            response = self.session.delete(
+                url,
+                headers=headers,
+                timeout=timeout,
+                verify=self.config.verify_ssl
+            )
+            return self._handle_response(response, raise_for_status)
+        except RequestException as e:
+            logger.error(f"Error en DELETE {url}: {e}")
+            raise
+    
+    def close(self):
+        """Cierra la sesión"""
+        if self.session:
+            self.session.close()
+    
+    def __enter__(self):
+        """Context manager entry"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close()
+        return False

eco_back/api/config.py

@@ -0,0 +1,58 @@
+"""
+Configuración para clientes API
+"""
+from dataclasses import dataclass
+from typing import Optional, Dict
+
+
+@dataclass
+class APIConfig:
+    """
+    Configuración para el cliente API
+    
+    Args:
+        base_url: URL base del API
+        timeout: Tiempo de espera para las peticiones en segundos
+        headers: Headers personalizados para las peticiones
+        verify_ssl: Verificar certificados SSL
+    """
+    base_url: str
+    timeout: int = 30
+    headers: Optional[Dict[str, str]] = None
+    verify_ssl: bool = True
+    
+    def __post_init__(self):
+        """Inicialización después de crear la instancia"""
+        if self.headers is None:
+            self.headers = {}
+        
+        # Asegurar que la URL base no termine con /
+        if self.base_url.endswith('/'):
+            self.base_url = self.base_url[:-1]
+    
+    @classmethod
+    def from_dict(cls, config: dict) -> "APIConfig":
+        """
+        Crea una instancia de APIConfig desde un diccionario
+        
+        Args:
+            config: Diccionario con la configuración
+            
+        Returns:
+            Instancia de APIConfig
+        """
+        return cls(**config)
+    
+    def to_dict(self) -> dict:
+        """
+        Convierte la configuración a diccionario
+        
+        Returns:
+            Diccionario con la configuración
+        """
+        return {
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "headers": self.headers,
+            "verify_ssl": self.verify_ssl,
+        }

eco_back/api/registro.py

@@ -0,0 +1,91 @@
+"""
+Cliente para operaciones de registro y consecutivos UNP
+"""
+from typing import Optional
+import logging
+
+from .client import APIClient
+from .config import APIConfig
+
+logger = logging.getLogger(__name__)
+
+
+class Consecutivo:
+    """
+    Cliente para obtener consecutivos de la API UNP
+    
+    Maneja operaciones relacionadas con la obtención de consecutivos.
+    
+    Ejemplo:
+        >>> from eco_back.api import Consecutivo
+        >>> 
+        >>> client = Consecutivo(base_url="https://api.unp.com")
+        >>> numero = client.obtener(origen=1)
+        >>> print(numero)
+    """
+    
+    def __init__(self, base_url: str, timeout: int = 30, verify_ssl: bool = True):
+        """
+        Inicializa el cliente de Consecutivos
+        
+        Args:
+            base_url: URL base del API UNP
+            timeout: Tiempo de espera para las peticiones
+            verify_ssl: Verificar certificados SSL
+        """
+        config = APIConfig(
+            base_url=base_url,
+            timeout=timeout,
+            verify_ssl=verify_ssl
+        )
+        self.client = APIClient(config)
+    
+    def obtener(self, origen: int = 1) -> Optional[int]:
+        """
+        Obtiene un consecutivo desde la API UNP
+        
+        Args:
+            origen: Identificador del origen (default: 1)
+            
+        Returns:
+            Número consecutivo o None si hay error
+            
+        Example:
+            >>> client = Consecutivo(base_url="https://api.unp.com")
+            >>> numero = client.obtener(origen=1)
+            >>> if numero:
+            ...     print(f"Consecutivo obtenido: {numero}")
+        """
+        try:
+            endpoint = f'api-auth/users/consecutivos/{origen}/'
+            response = self.client.get(endpoint, raise_for_status=False)
+            
+            if response and isinstance(response, dict):
+                consecutivo = response.get('consecutivo')
+                logger.info(f"Consecutivo obtenido: {consecutivo} para origen {origen}")
+                return consecutivo
+            else:
+                logger.warning(f"No se pudo obtener consecutivo para origen {origen}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error al obtener consecutivo: {e}")
+            return None
+    
+    # Alias para compatibilidad
+    def obtener_consecutivo(self, origen: int = 1) -> Optional[int]:
+        """Alias de obtener() para compatibilidad"""
+        return self.obtener(origen)
+    
+    def close(self):
+        """Cierra el cliente"""
+        self.client.close()
+    
+    def __enter__(self):
+        """Context manager entry"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close()
+        return False

eco_back/database/__init__.py

@@ -0,0 +1,9 @@
+"""
+Módulo de gestión de base de datos para eco-back
+"""
+
+from .connection import DatabaseConnection
+from .config import DatabaseConfig
+from .postgis import PostGISHelper
+
+__all__ = ["DatabaseConnection", "DatabaseConfig", "PostGISHelper"]

eco_back/database/config.py

@@ -0,0 +1,58 @@
+"""
+Configuración de base de datos
+"""
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class DatabaseConfig:
+    """
+    Configuración para la conexión a la base de datos
+    
+    Args:
+        host: Dirección del servidor de base de datos
+        port: Puerto de conexión
+        database: Nombre de la base de datos
+        user: Usuario de la base de datos
+        password: Contraseña del usuario
+        charset: Conjunto de caracteres (default: utf8mb4)
+        connect_timeout: Tiempo de espera para la conexión en segundos
+    """
+    host: str
+    port: int
+    database: str
+    user: str
+    password: str
+    charset: str = "utf8mb4"
+    connect_timeout: int = 10
+    
+    @classmethod
+    def from_dict(cls, config: dict) -> "DatabaseConfig":
+        """
+        Crea una instancia de DatabaseConfig desde un diccionario
+        
+        Args:
+            config: Diccionario con la configuración
+            
+        Returns:
+            Instancia de DatabaseConfig
+        """
+        return cls(**config)
+    
+    def to_dict(self) -> dict:
+        """
+        Convierte la configuración a diccionario
+        
+        Returns:
+            Diccionario con la configuración
+        """
+        return {
+            "host": self.host,
+            "port": self.port,
+            "database": self.database,
+            "user": self.user,
+            "password": self.password,
+            "charset": self.charset,
+            "connect_timeout": self.connect_timeout,
+        }