Upload processing_service.py

api/services/processing_service.py

@@ -1,94 +1,67 @@
-"""Serviço de processamento de acórdãos"""
-from typing import Dict, Any
-import json
-import tarfile
-import hashlib
-from pathlib import Path
+"""
+ProcessingService REAL - Integra LLM
+"""
+import logging
+from typing import Dict, Any, List, Optional
 from datetime import datetime
+from api.llm.factory import LLMFactory
+from api.processors.processor_metadados_llm import ProcessorMetadadosLLM
+
+logger = logging.getLogger(__name__)
+
 
 class ProcessingService:
-    """Serviço para processar arquivos JSONL de acórdãos."""
-    
-    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.
-        
-        Returns:
-            Dict com resultados do processamento
-        """
-        from api.config import get_settings
-        
-        settings = get_settings()
-        processed = 0
-        failed = 0
-        results = []
-        
-        # 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)
-                    })
-        
-        # Criar arquivo TAR.GZ com resultados
-        output_dir = Path(settings.OUTPUT_PATH) / "archives"
-        output_dir.mkdir(parents=True, exist_ok=True)
-        
-        archive_path = output_dir / f"{task_id}.tar.gz"
-        
-        # Criar JSON com resultados
-        result_json = {
-            "task_id": task_id,
-            "processed": processed,
-            "failed": failed,
+    """Serviço de processamento com LLM REAL."""
+
+    def __init__(self, llm_provider: str = "groq", api_key: Optional[str] = None):
+        """Initialize."""
+        self.llm_provider = llm_provider
+        self.api_key = api_key
+        self.llm_client = self._create_llm_client()
+        self.processors = {1: ProcessorMetadadosLLM(llm_client=self.llm_client)}
+        logger.info(f"ProcessingService init (provider={llm_provider})")
+
+    def _create_llm_client(self):
+        """Cria LLM client."""
+        try:
+            if not self.api_key:
+                logger.warning("API key não fornecida")
+                return None
+            factory = LLMFactory(provider=self.llm_provider, api_key=self.api_key)
+            return factory.create_client(model_tier="balanced")
+        except Exception as e:
+            logger.error(f"Erro ao criar LLM client: {e}")
+            return None
+
+    def process_acordao(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Processa 1 acórdão."""
+        start_time = datetime.now()
+        results = {}
+
+        for proc_id, processor in self.processors.items():
+            try:
+                logger.info(f"Executando {processor.specialist_name}...")
+                result = processor.process(acordao_data)
+                results[proc_id] = processor.postprocess(result)
+            except Exception as e:
+                logger.error(f"Erro processor {proc_id}: {e}")
+
+        return {
+            "acordao_id": acordao_data.get("acordao_id", "unknown"),
+            "status": "completed",
+            "execution_time": (datetime.now() - start_time).total_seconds(),
             "results": results,
-            "completed_at": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat()
         }
-        
-        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()
-        
+
+    def process_batch(self, acordaos: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Processa batch."""
+        results = []
+        for idx, acordao in enumerate(acordaos, 1):
+            logger.info(f"Processando {idx}/{len(acordaos)}...")
+            results.append(self.process_acordao(acordao))
         return {
-            "processed": processed,
-            "failed": failed,
-            "archive_path": str(archive_path),
-            "hash": file_hash,
-            "elapsed_seconds": 1.5  # mock
+            "batch_size": len(acordaos),
+            "processed": len(results),
+            "results": results
         }