Create quantumlink.py

quantumlink.py

@@ -0,0 +1,599 @@
+"""
+Ejemplos de uso de la API QuantumLink
+Incluye cliente Python, JavaScript y curl
+"""
+
+import requests
+import json
+from typing import Dict, Any, List
+
+# ==================== CLIENTE PYTHON ====================
+
+class QuantumLinkClient:
+    """Cliente Python para la API QuantumLink"""
+    
+    def __init__(self, base_url: str = "http://localhost:5000", auth_token: str = None):
+        self.base_url = base_url.rstrip('/')
+        self.auth_token = auth_token
+        self.session = requests.Session()
+        
+        if auth_token:
+            self.session.headers.update({
+                'Authorization': f'Bearer {auth_token  }'
+
+# 3. Decodificar un mensaje
+curl -X POST http://localhost:5000/api/v1/decode \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer valid_user123" \
+  -d '{
+    "package_id": "BiMO-12345678",
+    "measurements": [
+      {"energia_medida": 5.2, "timestamp": "2025-01-01T10:00:00Z"},
+      {"energia_medida": 3.8, "timestamp": "2025-01-01T10:00:01Z"},
+      {"energia_medida": 4.1, "timestamp": "2025-01-01T10:00:02Z"}
+    ]
+  }'
+
+# 4. Obtener historial de paquetes
+curl -X GET http://localhost:5000/api/v1/packages \
+  -H "Authorization: Bearer valid_user123"
+
+# 5. Obtener detalles de un paquete específico
+curl -X GET http://localhost:5000/api/v1/packages/BiMO-12345678 \
+  -H "Authorization: Bearer valid_user123"
+
+# 6. Ejemplo de error - sin autenticación
+curl -X POST http://localhost:5000/api/v1/encode \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Test without auth"}'
+"""
+
+# ==================== TESTS AUTOMATIZADOS ====================
+
+def create_test_suite():
+    """Crear suite de tests automatizados con pytest"""
+    return '''
+# test_quantumlink_api.py
+import pytest
+import json
+from app import create_app
+
+@pytest.fixture
+def client():
+    """Cliente de prueba para Flask"""
+    app = create_app()
+    app.config['TESTING'] = True
+    with app.test_client() as client:
+        yield client
+
+@pytest.fixture
+def auth_headers():
+    """Headers con autenticación válida"""
+    return {
+        'Authorization': 'Bearer valid_test_user',
+        'Content-Type': 'application/json'
+    }
+
+class TestHealthCheck:
+    """Tests para el endpoint de health check"""
+    
+    def test_health_check(self, client):
+        """Test básico de health check"""
+        response = client.get('/')
+        assert response.status_code == 200
+        data = json.loads(response.data)
+        assert data['status'] == 'success'
+        assert 'QuantumLink API' in data['message']
+
+class TestAuthentication:
+    """Tests para autenticación"""
+    
+    def test_encode_without_auth(self, client):
+        """Test de codificación sin autenticación"""
+        response = client.post('/api/v1/encode', 
+                             json={'message': 'test'},
+                             content_type='application/json')
+        assert response.status_code == 401
+        data = json.loads(response.data)
+        assert data['code'] == 'UNAUTHORIZED'
+    
+    def test_encode_with_invalid_token(self, client):
+        """Test con token inválido"""
+        headers = {'Authorization': 'Bearer invalid_token'}
+        response = client.post('/api/v1/encode',
+                             json={'message': 'test'},
+                             headers=headers)
+        assert response.status_code == 401
+        data = json.loads(response.data)
+        assert data['code'] == 'INVALID_TOKEN'
+
+class TestEncoding:
+    """Tests para codificación de mensajes"""
+    
+    def test_encode_valid_message(self, client, auth_headers):
+        """Test de codificación exitosa"""
+        message_data = {
+            'message': 'QUANTUM TEST MESSAGE',
+            'options': {
+                'encoding_type': 'BiMO',
+                'priority': 'high'
+            }
+        }
+        response = client.post('/api/v1/encode',
+                             json=message_data,
+                             headers=auth_headers)
+        assert response.status_code == 201
+        data = json.loads(response.data)
+        assert data['status'] == 'success'
+        assert 'package_id' in data['data']
+        assert data['data']['encoding_type'] == 'BiMO'
+    
+    def test_encode_empty_message(self, client, auth_headers):
+        """Test con mensaje vacío"""
+        response = client.post('/api/v1/encode',
+                             json={'message': ''},
+                             headers=auth_headers)
+        assert response.status_code == 400
+        data = json.loads(response.data)
+        assert data['code'] == 'VALIDATION_ERROR'
+    
+    def test_encode_long_message(self, client, auth_headers):
+        """Test con mensaje muy largo"""
+        long_message = 'A' * 1001  # Excede el límite de 1000 caracteres
+        response = client.post('/api/v1/encode',
+                             json={'message': long_message},
+                             headers=auth_headers)
+        assert response.status_code == 400
+
+class TestDecoding:
+    """Tests para decodificación de mensajes"""
+    
+    def test_decode_nonexistent_package(self, client, auth_headers):
+        """Test de decodificación de paquete inexistente"""
+        decode_data = {
+            'package_id': 'BiMO-nonexistent',
+            'measurements': [{'energia_medida': 5.0}]
+        }
+        response = client.post('/api/v1/decode',
+                             json=decode_data,
+                             headers=auth_headers)
+        assert response.status_code == 404
+        data = json.loads(response.data)
+        assert data['code'] == 'PACKAGE_NOT_FOUND'
+    
+    def test_decode_missing_measurements(self, client, auth_headers):
+        """Test sin mediciones"""
+        response = client.post('/api/v1/decode',
+                             json={'package_id': 'BiMO-12345'},
+                             headers=auth_headers)
+        assert response.status_code == 400
+
+class TestPackageManagement:
+    """Tests para gestión de paquetes"""
+    
+    def test_get_packages_empty(self, client, auth_headers):
+        """Test de historial vacío"""
+        response = client.get('/api/v1/packages', headers=auth_headers)
+        assert response.status_code == 200
+        data = json.loads(response.data)
+        assert data['data']['total_count'] == 0
+    
+    def test_get_package_details_not_found(self, client, auth_headers):
+        """Test de detalles de paquete no encontrado"""
+        response = client.get('/api/v1/packages/nonexistent', 
+                            headers=auth_headers)
+        assert response.status_code == 404
+
+# Comando para ejecutar los tests:
+# pytest test_quantumlink_api.py -v --tb=short
+'''
+
+# ==================== DOCUMENTACIÓN DE LA API ====================
+
+api_documentation = """
+# Documentación de la API QuantumLink
+
+## Resumen
+La API QuantumLink permite codificar y decodificar mensajes usando simulación cuántica BiMO.
+
+## Base URL
+```
+http://localhost:5000
+```
+
+## Autenticación
+Todas las rutas protegidas requieren un token de autorización en el header:
+```
+Authorization: Bearer {token}
+```
+
+Para pruebas, usa: `valid_user123`
+
+## Endpoints
+
+### GET /
+Verificación de salud de la API.
+
+**Respuesta:**
+```json
+{
+  "status": "success",
+  "message": "QuantumLink API está funcionando",
+  "version": "1.0.0",
+  "timestamp": "2025-01-01T12:00:00Z"
+}
+```
+
+### POST /api/v1/encode
+Codifica un mensaje cuántico.
+
+**Headers requeridos:**
+- `Authorization: Bearer {token}`
+- `Content-Type: application/json`
+
+**Body:**
+```json
+{
+  "message": "MENSAJE A CODIFICAR",
+  "options": {
+    "encoding_type": "BiMO",
+    "priority": "high|medium|low"
+  }
+}
+```
+
+**Respuesta exitosa (201):**
+```json
+{
+  "status": "success",
+  "data": {
+    "package_id": "BiMO-12345678",
+    "timestamp": "2025-01-01T12:00:00Z",
+    "qubits_count": 18,
+    "encoding_type": "BiMO"
+  },
+  "message": "Mensaje codificado exitosamente"
+}
+```
+
+### POST /api/v1/decode
+Decodifica un paquete cuántico.
+
+**Body:**
+```json
+{
+  "package_id": "BiMO-12345678",
+  "measurements": [
+    {"energia_medida": 5.2, "timestamp": "2025-01-01T10:00:00Z"},
+    {"energia_medida": 3.8, "timestamp": "2025-01-01T10:00:01Z"}
+  ]
+}
+```
+
+**Respuesta exitosa (200):**
+```json
+{
+  "status": "success",
+  "data": {
+    "package_id": "BiMO-12345678",
+    "decoded_message": "MENSAJE DECODIFICADO",
+    "transmission_status": "SUCCESS",
+    "metrics": {
+      "fidelidad": 0.95,
+      "error_rate": 0.05,
+      "coherencia": 0.92
+    },
+    "decoded_at": "2025-01-01T12:05:00Z"
+  }
+}
+```
+
+### GET /api/v1/packages
+Obtiene el historial de paquetes del usuario.
+
+**Respuesta:**
+```json
+{
+  "status": "success",
+  "data": {
+    "packages": [
+      {
+        "package_id": "BiMO-12345678",
+        "timestamp": "2025-01-01T12:00:00Z",
+        "encoding_type": "BiMO",
+        "qubits_count": 18,
+        "status": "decoded",
+        "metrics": {...}
+      }
+    ],
+    "total_count": 1
+  }
+}
+```
+
+### GET /api/v1/packages/{package_id}
+Obtiene detalles de un paquete específico.
+
+## Códigos de Error
+
+- `400` - Datos de entrada inválidos (`VALIDATION_ERROR`)
+- `401` - No autorizado (`UNAUTHORIZED`, `INVALID_TOKEN`)
+- `403` - Prohibido (`FORBIDDEN`)
+- `404` - No encontrado (`PACKAGE_NOT_FOUND`, `NOT_FOUND`)
+- `405` - Método no permitido (`METHOD_NOT_ALLOWED`)
+- `500` - Error interno (`INTERNAL_ERROR`)
+
+## Límites
+
+- Mensaje máximo: 1000 caracteres
+- Qubits máximos por mensaje: 100
+- Timeout de simulación: 30 segundos
+
+## Rate Limiting
+En producción, se implementará rate limiting por usuario/IP.
+"""
+
+if __name__ == "__main__":
+    print("=== Ejecutando ejemplos de QuantumLink ===")
+    
+    # Ejecutar ejemplo completo
+    ejemplo_flujo_completo()
+    
+    # Ejecutar ejemplo de errores
+    ejemplo_manejo_errores()
+    
+    print("\n=== Información adicional ===")
+    print("- Revisa los archivos de configuración para personalizar la API")
+    print("- Ejecuta 'pytest test_quantumlink_api.py -v' para tests automatizados")
+    print("- Consulta la documentación de la API para más detalles")
+    print("- Usa los ejemplos JavaScript para integración frontend")
+    print("- Los comandos curl están listos para pruebas manuales"),
+                'Content-Type': 'application/json'
+            })
+    
+    def _make_request(self, method: str, endpoint: str, data: Dict = None) -> Dict[str, Any]:
+        """Realizar una petición HTTP"""
+        url = f"{self.base_url}{endpoint}"
+        
+        try:
+            if method.upper() == 'GET':
+                response = self.session.get(url)
+            elif method.upper() == 'POST':
+                response = self.session.post(url, json=data)
+            else:
+                raise ValueError(f"Método HTTP no soportado: {method}")
+            
+            response_data = response.json()
+            
+            if response.status_code >= 400:
+                raise Exception(f"Error API: {response_data.get('message', 'Error desconocido')}")
+            
+            return response_data
+        
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Error de conexión: {str(e)}")
+    
+    def health_check(self) -> Dict[str, Any]:
+        """Verificar el estado de la API"""
+        return self._make_request('GET', '/')
+    
+    def encode_message(self, message: str, encoding_type: str = "BiMO", priority: str = "medium") -> Dict[str, Any]:
+        """Codificar un mensaje cuántico"""
+        data = {
+            "message": message,
+            "options": {
+                "encoding_type": encoding_type,
+                "priority": priority
+            }
+        }
+        return self._make_request('POST', '/api/v1/encode', data)
+    
+    def decode_message(self, package_id: str, measurements: List[Dict]) -> Dict[str, Any]:
+        """Decodificar un paquete cuántico"""
+        data = {
+            "package_id": package_id,
+            "measurements": measurements
+        }
+        return self._make_request('POST', '/api/v1/decode', data)
+    
+    def get_packages(self) -> Dict[str, Any]:
+        """Obtener historial de paquetes"""
+        return self._make_request('GET', '/api/v1/packages')
+    
+    def get_package_details(self, package_id: str) -> Dict[str, Any]:
+        """Obtener detalles de un paquete específico"""
+        return self._make_request('GET', f'/api/v1/packages/{package_id}')
+
+# ==================== EJEMPLOS DE USO ====================
+
+def ejemplo_flujo_completo():
+    """Ejemplo completo del flujo de codificación y decodificación"""
+    print("=== Ejemplo de Flujo Completo QuantumLink ===")
+    
+    # Inicializar cliente (token válido para pruebas)
+    client = QuantumLinkClient(auth_token="valid_user123")
+    
+    try:
+        # 1. Verificar estado de la API
+        print("1. Verificando estado de la API...")
+        health = client.health_check()
+        print(f"   Estado: {health['message']}")
+        
+        # 2. Codificar un mensaje
+        print("\n2. Codificando mensaje...")
+        message = "QUANTUM COMMUNICATION IS THE FUTURE"
+        encode_result = client.encode_message(
+            message=message,
+            encoding_type="BiMO",
+            priority="high"
+        )
+        print(f"   Mensaje codificado exitosamente")
+        print(f"   Package ID: {encode_result['data']['package_id']}")
+        print(f"   Qubits utilizados: {encode_result['data']['qubits_count']}")
+        
+        package_id = encode_result['data']['package_id']
+        
+        # 3. Simular mediciones ruidosas (en un escenario real, vendrían del canal cuántico)
+        print("\n3. Simulando mediciones cuánticas...")
+        measurements = [
+            {"energia_medida": 5.2, "timestamp": "2025-01-01T10:00:00Z"},
+            {"energia_medida": 3.8, "timestamp": "2025-01-01T10:00:01Z"},
+            {"energia_medida": 4.1, "timestamp": "2025-01-01T10:00:02Z"},
+            {"energia_medida": 2.9, "timestamp": "2025-01-01T10:00:03Z"},
+        ]
+        
+        # 4. Decodificar el mensaje
+        print("4. Decodificando mensaje...")
+        decode_result = client.decode_message(package_id, measurements)
+        print(f"   Mensaje decodificado: {decode_result['data']['decoded_message']}")
+        print(f"   Estado de transmisión: {decode_result['data']['transmission_status']}")
+        print(f"   Métricas cuánticas:")
+        for key, value in decode_result['data']['metrics'].items():
+            print(f"     {key}: {value}")
+        
+        # 5. Obtener historial de paquetes
+        print("\n5. Obteniendo historial...")
+        packages = client.get_packages()
+        print(f"   Total de paquetes: {packages['data']['total_count']}")
+        
+        # 6. Obtener detalles específicos del paquete
+        print("6. Obteniendo detalles del paquete...")
+        details = client.get_package_details(package_id)
+        print(f"   Paquete encontrado: {details['data']['package']['id_mensaje']}")
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+
+def ejemplo_manejo_errores():
+    """Ejemplo de manejo de errores comunes"""
+    print("\n=== Ejemplo de Manejo de Errores ===")
+    
+    client = QuantumLinkClient(auth_token="invalid_token")
+    
+    try:
+        # Intentar codificar con token inválido
+        client.encode_message("Test message")
+    except Exception as e:
+        print(f"Error esperado con token inválido: {str(e)}")
+    
+    # Cliente sin autenticación
+    client_no_auth = QuantumLinkClient()
+    try:
+        client_no_auth.encode_message("Test message")
+    except Exception as e:
+        print(f"Error esperado sin autenticación: {str(e)}")
+
+# ==================== EJEMPLOS JAVASCRIPT ====================
+
+javascript_examples = """
+// Ejemplo de cliente JavaScript para frontend
+
+class QuantumLinkAPI {
+    constructor(baseURL = 'http://localhost:5000', authToken = null) {
+        this.baseURL = baseURL;
+        this.authToken = authToken;
+    }
+
+    async makeRequest(method, endpoint, data = null) {
+        const url = `${this.baseURL}${endpoint}`;
+        const options = {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json',
+            }
+        };
+
+        if (this.authToken) {
+            options.headers['Authorization'] = `Bearer ${this.authToken}`;
+        }
+
+        if (data) {
+            options.body = JSON.stringify(data);
+        }
+
+        try {
+            const response = await fetch(url, options);
+            const responseData = await response.json();
+
+            if (!response.ok) {
+                throw new Error(responseData.message || 'Error desconocido');
+            }
+
+            return responseData;
+        } catch (error) {
+            console.error('Error en la petición:', error);
+            throw error;
+        }
+    }
+
+    async encodeMessage(message, options = {}) {
+        const data = {
+            message: message,
+            options: {
+                encoding_type: options.encoding_type || 'BiMO',
+                priority: options.priority || 'medium'
+            }
+        };
+        return await this.makeRequest('POST', '/api/v1/encode', data);
+    }
+
+    async decodeMessage(packageId, measurements) {
+        const data = {
+            package_id: packageId,
+            measurements: measurements
+        };
+        return await this.makeRequest('POST', '/api/v1/decode', data);
+    }
+
+    async getPackages() {
+        return await this.makeRequest('GET', '/api/v1/packages');
+    }
+}
+
+// Ejemplo de uso en React/Vue/Angular
+async function ejemploFrontend() {
+    const api = new QuantumLinkAPI('http://localhost:5000', 'valid_user123');
+
+    try {
+        // Codificar mensaje
+        const encodeResult = await api.encodeMessage('HELLO QUANTUM WORLD');
+        console.log('Mensaje codificado:', encodeResult);
+
+        // Simular mediciones
+        const measurements = [
+            {energia_medida: 4.5, timestamp: new Date().toISOString()},
+            {energia_medida: 3.2, timestamp: new Date().toISOString()}
+        ];
+
+        // Decodificar
+        const decodeResult = await api.decodeMessage(
+            encodeResult.data.package_id, 
+            measurements
+        );
+        console.log('Mensaje decodificado:', decodeResult);
+
+    } catch (error) {
+        console.error('Error:', error.message);
+    }
+}
+"""
+
+# ==================== EJEMPLOS CURL ====================
+
+curl_examples = """
+# Ejemplos de comandos curl para probar la API
+
+# 1. Verificar estado de la API
+curl -X GET http://localhost:5000/
+
+# 2. Codificar un mensaje
+curl -X POST http://localhost:5000/api/v1/encode \\
+  -H "Content-Type: application/json" \\
+  -H "Authorization: Bearer valid_user123" \\
+  -d '{
+    "message": "QUANTUM TEST MESSAGE",
+    "options": {
+      "encoding_type": "BiMO",
+      "priority": "high"
+    }
+