Update api/services/processing_service.py

api/services/processing_service.py

@@ -1,74 +1,94 @@
-"""Router de testes de processadores"""
-from fastapi import APIRouter, HTTPException
-from api.models.requests import ProcessorTestRequest
-from api.models.responses import ProcessorTestResponse
-from api.utils.logger import setup_logger
-import time
+"""Serviço de processamento de acórdãos"""
+from typing import Dict, Any
+import json
+import tarfile
+import hashlib
+from pathlib import Path
+from datetime import datetime
 
-router = APIRouter()
-logger = setup_logger(__name__)
-
-@router.post("/run", response_model=ProcessorTestResponse)
-async def test_processor(request: ProcessorTestRequest):
-    """Testa um processador específico."""
-    start_time = time.time()
+class ProcessingService:
+    """Serviço para processar arquivos JSONL de acórdãos."""
     
-    try:
-        # Importar processador
-        processor_map = {
-            "1": "processor_metadados",
-            "2": "processor_relatorio",
-            "metadados": "processor_metadados",
-            "relatorio": "processor_relatorio"
-        }
+    async def process_jsonl_file(
+        self,
+        file_path: str,
+        task_id: str,
+        llm_provider: str = "groq",
+        model_type: str = "balanced",
+        enable_parallel: bool = True,
+        max_workers: int = 3
+    ) -> Dict[str, Any]:
+        """
+        Processa arquivo JSONL com acórdãos.
         
-        processor_name = processor_map.get(request.processor_name, request.processor_name)
+        Returns:
+            Dict com resultados do processamento
+        """
+        from api.config import get_settings
         
-        from processors import base_processor
-        processor = base_processor.get_processor(processor_name)
+        settings = get_settings()
+        processed = 0
+        failed = 0
+        results = []
         
-        # Processar
-        result = await processor.process(
-            ementa=request.ementa,
-            integra=request.integra,
-            tribunal=request.tribunal
-        )
+        # Ler arquivo JSONL
+        with open(file_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                
+                try:
+                    record = json.loads(line)
+                    # Aqui seria o processamento real com os 9 especialistas
+                    # Por enquanto, retornar mock
+                    results.append({
+                        "acordao_id": record.get("acordao_id"),
+                        "status": "processed",
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    processed += 1
+                except Exception as e:
+                    failed += 1
+                    results.append({
+                        "acordao_id": record.get("acordao_id", "unknown"),
+                        "status": "error",
+                        "error": str(e)
+                    })
         
-        duration_ms = (time.time() - start_time) * 1000
+        # Criar arquivo TAR.GZ com resultados
+        output_dir = Path(settings.OUTPUT_PATH) / "archives"
+        output_dir.mkdir(parents=True, exist_ok=True)
         
-        return ProcessorTestResponse(
-            processor_name=processor_name,
-            success=True,
-            result=result,
-            duration_ms=duration_ms
-        )
+        archive_path = output_dir / f"{task_id}.tar.gz"
         
-    except Exception as e:
-        duration_ms = (time.time() - start_time) * 1000
-        logger.error(f"Processor test error: {e}")
+        # Criar JSON com resultados
+        result_json = {
+            "task_id": task_id,
+            "processed": processed,
+            "failed": failed,
+            "results": results,
+            "completed_at": datetime.now().isoformat()
+        }
         
-        return ProcessorTestResponse(
-            processor_name=request.processor_name,
-            success=False,
-            duration_ms=duration_ms,
-            error=str(e)
-        )
-
-@router.get("/list")
-async def list_processors():
-    """Lista processadores disponíveis."""
-    return {
-        "processors": [
-            {"id": 1, "name": "Metadados"},
-            {"id": 2, "name": "Relatório"},
-            {"id": 3, "name": "Fundamentação"},
-            {"id": 4, "name": "Decisão"},
-            {"id": 5, "name": "Auditoria"},
-            {"id": 6, "name": "Arquivo Relacional"},
-            {"id": 7, "name": "Segmentação Sintática"},
-            {"id": 8, "name": "Análise Contextual"},
-            {"id": 9, "name": "Transcrição 3-Partite"}
-        ],
-        "total": 9
-    }
-    
+        temp_json = output_dir / f"{task_id}_results.json"
+        with open(temp_json, 'w', encoding='utf-8') as f:
+            json.dump(result_json, f, ensure_ascii=False, indent=2)
+        
+        # Criar TAR.GZ
+        with tarfile.open(archive_path, 'w:gz') as tar:
+            tar.add(temp_json, arcname=f"{task_id}_results.json")
+        
+        # Remover JSON temporário
+        temp_json.unlink()
+        
+        # Calcular hash
+        with open(archive_path, 'rb') as f:
+            file_hash = hashlib.sha256(f.read()).hexdigest()
+        
+        return {
+            "processed": processed,
+            "failed": failed,
+            "archive_path": str(archive_path),
+            "hash": file_hash,
+            "elapsed_seconds": 1.5  # mock
+        }