Update api/services/processing_service.py

api/services/processing_service.py

@@ -1,81 +1,81 @@
 """
-ProcessingService REAL - Usa LLMManager
-Substituição correta usando a API real do projeto.
+ProcessingService - Usa ProcessorManager REAL
+Integração correta com os 9 especialistas existentes
 """
+import os
 import logging
 from typing import Dict, Any, List, Optional
 from datetime import datetime
 
-from llm.llm_manager import LLMManager, LLMProvider, ModelType, LLMRequest
-from api.processors.processor_metadados_llm import ProcessorMetadadosLLM
+from llm.llm_manager import LLMManager, LLMProvider
+from processors.processor_menager import ProcessorManager
 
 logger = logging.getLogger(__name__)
 
 
 class ProcessingService:
     """
-    Serviço de processamento que usa LLMManager REAL.
-
-    Coordena:
-    - LLMManager para criar clients LLM
-    - Processors com LLM integrado
-    - Logging detalhado
+    Serviço que coordena processamento via ProcessorManager REAL.
+    
+    NÃO cria processors novos - usa os 9 especialistas existentes!
     """
-
+    
     def __init__(
         self,
         llm_provider: str = "groq",
-        api_key: Optional[str] = None
+        api_key: Optional[str] = None,
+        max_workers: int = 3
     ):
         """
         Args:
             llm_provider: Provider LLM (groq, openai, anthropic)
-            api_key: API key para o provider (opcional, usa env vars)
+            api_key: API key (opcional, usa env var se não fornecido)
+            max_workers: Workers paralelos
         """
         self.llm_provider = llm_provider
         self.api_key = api_key
-
-        # Criar LLMManager
+        self.max_workers = max_workers
+        
+        # Configurar API key no ambiente se fornecida
+        if self.api_key:
+            env_key = f"{llm_provider.upper()}_API_KEY"
+            os.environ[env_key] = self.api_key
+            logger.info(f"✅ API key configurada para {env_key}")
+        
+        # Criar LLMManager (inicializa clients via env vars)
         self.llm_manager = self._create_llm_manager()
-
+        
         # Obter client específico do provider
         self.llm_client = self._get_provider_client()
-
-        # Inicializar processors (por enquanto só Metadados)
-        self.processors = {
-            1: ProcessorMetadadosLLM(llm_client=self.llm_client)
-        }
-
+        
+        # Criar ProcessorManager com LLM client
+        # ProcessorManager já inicializa os 9 especialistas!
+        self.processor_manager = ProcessorManager(
+            llm_model=self.llm_client,
+            max_workers=max_workers
+        )
+        
         logger.info(
-            f"ProcessingService inicializado "
-            f"(provider={llm_provider}, processors={len(self.processors)})"
+            f"✅ ProcessingService inicializado "
+            f"(provider={llm_provider}, 9 especialistas prontos)"
         )
-
+    
     def _create_llm_manager(self) -> Optional[LLMManager]:
-        """Cria LLMManager e inicializa clients."""
+        """Cria LLMManager."""
         try:
-            # Se API key fornecida, setar no ambiente
-            if self.api_key:
-                import os
-                env_key = f"{self.llm_provider.upper()}_API_KEY"
-                os.environ[env_key] = self.api_key
-                logger.info(f"API key configurada para {env_key}")
-
-            # Criar LLMManager (inicializa todos os clients disponíveis)
             manager = LLMManager()
-            logger.info("LLMManager criado e inicializado")
+            logger.info("✅ LLMManager inicializado")
             return manager
-
         except Exception as e:
-            logger.error(f"Erro ao criar LLMManager: {e}", exc_info=True)
+            logger.error(f"❌ Erro ao criar LLMManager: {e}", exc_info=True)
             return None
-
+    
     def _get_provider_client(self):
-        """Obtém client específico do provider."""
+        """Obtém client do provider selecionado."""
         if not self.llm_manager:
-            logger.warning("LLMManager não disponível")
+            logger.warning("⚠️ LLMManager não disponível")
             return None
-
+        
         try:
             # Mapear string para enum
             provider_map = {
@@ -83,126 +83,116 @@ class ProcessingService:
                 "openai": LLMProvider.OPENAI,
                 "anthropic": LLMProvider.ANTHROPIC
             }
-
+            
             provider_enum = provider_map.get(self.llm_provider.lower())
-            if not provider_enum:
-                logger.error(f"Provider desconhecido: {self.llm_provider}")
-                return None
-
-            # Obter client do provider
-            if provider_enum in self.llm_manager.clients:
+            
+            if provider_enum and provider_enum in self.llm_manager.clients:
                 client = self.llm_manager.clients[provider_enum]
-                logger.info(f"Client obtido: {type(client).__name__}")
+                logger.info(f"✅ Client obtido: {type(client).__name__}")
                 return client
             else:
                 logger.warning(
-                    f"Client para {self.llm_provider} não inicializado. "
-                    "Verifique se a API key está configurada."
+                    f"⚠️ Client {self.llm_provider} não disponível. "
+                    "Verifique API key no ambiente."
                 )
                 return None
-
+                
         except Exception as e:
-            logger.error(f"Erro ao obter client: {e}", exc_info=True)
+            logger.error(f"❌ Erro ao obter client: {e}", exc_info=True)
             return None
-
-    def process_acordao(
+    
+    async def process_acordao(
         self,
         acordao_data: Dict[str, Any],
-        processor_ids: Optional[List[int]] = None
+        specialist_ids: Optional[List[int]] = None,
+        enable_parallel: bool = False
     ) -> Dict[str, Any]:
         """
-        Processa um acórdão com processors especificados.
-
+        Processa 1 acórdão usando ProcessorManager.
+        
         Args:
-            acordao_data: Dados do acórdão (ementa, integra, etc)
-            processor_ids: IDs dos processors a executar (default: [1])
-
+            acordao_data: Dados do acórdão
+            specialist_ids: IDs dos especialistas (default: todos)
+            enable_parallel: Executar em paralelo
+        
         Returns:
-            Resultado consolidado
+            Resultado consolidado dos 9 especialistas
         """
-        if processor_ids is None:
-            processor_ids = [1]  # Apenas Metadados por enquanto
-
-        start_time = datetime.now()
-        results = {}
-        errors = {}
-
-        logger.info(
-            f"Processando acórdão {acordao_data.get('acordao_id', 'unknown')} "
-            f"com processors {processor_ids}"
-        )
-
-        for proc_id in processor_ids:
-            if proc_id not in self.processors:
-                error_msg = f"Processor {proc_id} não existe"
-                errors[proc_id] = error_msg
-                logger.error(error_msg)
-                continue
-
-            try:
-                processor = self.processors[proc_id]
-                logger.info(f"Executando {processor.specialist_name}...")
-
-                # Processar
-                result = processor.process(acordao_data)
-
-                # Validar
-                if processor.validate(result):
-                    results[proc_id] = processor.postprocess(result)
-                    logger.info(
-                        f"{processor.specialist_name} completado "
-                        f"(confidence={processor.confidence_score}%, "
-                        f"time={processor.execution_time:.2f}s)"
-                    )
-                else:
-                    error_msg = f"Validação falhou para {processor.specialist_name}"
-                    errors[proc_id] = error_msg
-                    logger.error(error_msg)
-
-            except Exception as e:
-                error_msg = f"Erro ao executar processor {proc_id}: {e}"
-                errors[proc_id] = error_msg
-                logger.error(error_msg, exc_info=True)
-
-        elapsed = (datetime.now() - start_time).total_seconds()
-
-        return {
-            "acordao_id": acordao_data.get("acordao_id", "unknown"),
-            "status": "completed" if not errors else "completed_with_errors",
-            "total_processors": len(processor_ids),
-            "successful": len(results),
-            "failed": len(errors),
-            "execution_time": elapsed,
-            "results": results,
-            "errors": errors,
-            "timestamp": datetime.now().isoformat()
-        }
-
-    def process_batch(
+        try:
+            logger.info(
+                f"🚀 Processando acórdão {acordao_data.get('acordao_id', 'unknown')} "
+                f"com ProcessorManager"
+            )
+            
+            # Usar ProcessorManager REAL para processar
+            if enable_parallel:
+                result = await self.processor_manager.process_acordao_parallel(
+                    acordao_data=acordao_data,
+                    specialist_ids=specialist_ids
+                )
+            else:
+                result = await self.processor_manager.process_acordao_sequential(
+                    acordao_data=acordao_data,
+                    specialist_ids=specialist_ids
+                )
+            
+            logger.info(
+                f"✅ Acórdão processado em {result.get('execution_time', 0):.2f}s"
+            )
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"❌ Erro ao processar acórdão: {e}", exc_info=True)
+            return {
+                "acordao_id": acordao_data.get("acordao_id", "unknown"),
+                "status": "error",
+                "error": str(e),
+                "timestamp": datetime.now().isoformat()
+            }
+    
+    async def process_batch(
         self,
         acordaos: List[Dict[str, Any]],
-        processor_ids: Optional[List[int]] = None
+        specialist_ids: Optional[List[int]] = None,
+        enable_parallel: bool = False
     ) -> Dict[str, Any]:
         """
         Processa lote de acórdãos.
-
+        
         Args:
             acordaos: Lista de acórdãos
-            processor_ids: IDs dos processors
-
+            specialist_ids: IDs dos especialistas
+            enable_parallel: Processar cada acórdão em paralelo
+        
         Returns:
             Resultados consolidados
         """
         results = []
-
+        start_time = datetime.now()
+        
         for idx, acordao in enumerate(acordaos, 1):
-            logger.info(f"Processando acórdão {idx}/{len(acordaos)}...")
-            result = self.process_acordao(acordao, processor_ids)
+            logger.info(f"📄 Processando acórdão {idx}/{len(acordaos)}...")
+            
+            result = await self.process_acordao(
+                acordao_data=acordao,
+                specialist_ids=specialist_ids,
+                enable_parallel=enable_parallel
+            )
             results.append(result)
-
+        
+        elapsed = (datetime.now() - start_time).total_seconds()
+        
+        successful = len([r for r in results if r.get("status") != "error"])
+        failed = len(results) - successful
+        
         return {
             "batch_size": len(acordaos),
             "processed": len(results),
+            "successful": successful,
+            "failed": failed,
+            "total_execution_time": elapsed,
+            "avg_time_per_acordao": elapsed / len(acordaos) if acordaos else 0,
             "results": results,
             "timestamp": datetime.now().isoformat()
-        }
+        }