ParaAIV3.1

config/pipeline_config.yaml

@@ -59,4 +59,4 @@ global_config:
   batch_size: 50
   enable_retry: true
   max_retries: 3
-  retry_delay: 2
+  retry_delay: 2

core/__init__.py

@@ -4,15 +4,15 @@ Core Module - Componentes principais da pipeline V13.6
 """
 
 from .orchestrator import PipelineOrchestrator
-from .base_specialist import BaseSpecialist
 from .context_builder import ContextBuilder
 from .validator import SchemaValidator
+from .specialist_wrapper import SpecialistWrapper
 
 __all__ = [
     'PipelineOrchestrator',
-    'BaseSpecialist',
     'ContextBuilder',
-    'SchemaValidator'
+    'SchemaValidator',
+    'SpecialistWrapper'
 ]
 
 __version__ = "13.6.0"

core/specialist_wrapper.py

@@ -0,0 +1,71 @@
+##PARA.AI/core/specialist_wrapper.py
+"""
+Specialist Wrapper - Adaptador de compatibilidade V13.1 → V13.6
+Permite que ProcessorBase antigo funcione com novo PipelineOrchestrator
+"""
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SpecialistWrapper:
+    """
+    Wrapper para adaptar ProcessorBase V13.1 ao novo formato V13.6
+
+    PROBLEMA:
+    - V13.1: processor.process(acordao_data)
+    - V13.6: specialist.process(input_data=..., context=...)
+
+    SOLUÇÃO:
+    - Wrapper adapta a chamada mantendo compatibilidade
+    """
+
+    def __init__(self, processor_v13_1, specialist_id: int):
+        """
+        Args:
+            processor_v13_1: Instância de ProcessorBase (V13.1)
+            specialist_id: ID do especialista (1-7)
+        """
+        self.processor = processor_v13_1
+        self.id = specialist_id
+        self.name = processor_v13_1.__class__.__name__
+
+        logger.info(f"🔄 SpecialistWrapper criado para {self.name} (ID {self.id})")
+
+    async def process(
+        self, 
+        input_data: Dict[str, Any],
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Adapta chamada V13.6 → V13.1
+
+        Args:
+            input_data: Dados do acórdão (formato V13.6)
+            context: Contexto de especialistas anteriores (IGNORADO no V13.1)
+
+        Returns:
+            Resultado do processador V13.1
+        """
+        logger.debug(f"🔄 Wrapper adaptando chamada para {self.name}")
+
+        # ADAPTAÇÃO: V13.1 espera apenas acordao_data como argumento posicional
+        try:
+            # Chamar processor.process() com assinatura V13.1
+            result = await self.processor.process(input_data)
+
+            # Processar resultado
+            if result:
+                logger.debug(f"✅ {self.name} retornou resultado")
+                return result
+            else:
+                logger.warning(f"⚠️ {self.name} retornou None")
+                return {}
+
+        except Exception as e:
+            logger.error(f"❌ Erro no wrapper de {self.name}: {e}")
+            return {}
+
+    def __repr__(self):
+        return f"SpecialistWrapper({self.name}, ID={self.id})"

processors/processor_manager.py

@@ -1,7 +1,7 @@
 ##PARA.AI/processors/processor_manager.py
 """
 Processor Manager - REFATORADO para usar PipelineOrchestrator V13.6
-MUDANÇA: Este arquivo agora é apenas um wrapper para manter compatibilidade
+MUDANÇA: Usa SpecialistWrapper para compatibilidade com ProcessorBase V13.1
 """
 import logging
 import yaml
@@ -9,8 +9,9 @@ from typing import Dict, Any, List, Optional
 
 from core.orchestrator import PipelineOrchestrator
 from core.validator import SchemaValidator
+from core.specialist_wrapper import SpecialistWrapper
 
-# Importar especialistas (mantidos do V13.1, serão refatorados na FASE 2)
+# Importar processadores V13.1 (serão refatorados na FASE 2)
 from processors.processor_metadados import ProcessorMetadados
 from processors.processor_segmentacao import ProcessorSegmentacao
 from processors.processor_relatorio import ProcessorRelatorio
@@ -25,11 +26,11 @@ logger = logging.getLogger(__name__)
 class ProcessorManager:
     """
     Gerenciador de processadores - WRAPPER para PipelineOrchestrator
-    
+
     MUDANÇA V13.6:
-    - Este arquivo agora delega para PipelineOrchestrator
-    - Mantém compatibilidade com código existente
-    - Especialistas serão migrados gradualmente para novo formato
+    - Delega para PipelineOrchestrator
+    - Usa SpecialistWrapper para adaptar ProcessorBase V13.1
+    - Mantém compatibilidade total com código existente
     """
 
     def __init__(self, llm_manager, max_workers: int = 3):
@@ -42,11 +43,17 @@ class ProcessorManager:
         self.max_workers = max_workers
 
         # Carregar configuração da pipeline
-        with open('config/pipeline_config.yaml', 'r', encoding='utf-8') as f:
-            self.pipeline_config = yaml.safe_load(f)
+        try:
+            with open('config/pipeline_config.yaml', 'r', encoding='utf-8') as f:
+                self.pipeline_config = yaml.safe_load(f)
+        except FileNotFoundError:
+            # Fallback: usar config padrão se arquivo não existir
+            logger.warning("⚠️ config/pipeline_config.yaml não encontrado, usando config padrão")
+            self.pipeline_config = self._get_default_config()
 
-        # Inicializar especialistas (mapeamento temporário V13.1 → V13.6)
-        self.specialists = {
+        # Inicializar processadores V13.1
+        logger.info("🔄 Inicializando processadores V13.1...")
+        processor_instances = {
             1: ProcessorSegmentacao(llm_manager),      # Segmentador
             2: ProcessorMetadados(llm_manager),        # Metadados
             3: ProcessorContexto(llm_manager),         # Classificador (renomear depois)
@@ -56,6 +63,11 @@ class ProcessorManager:
             7: ProcessorArquivo(llm_manager),          # Arquivista
         }
 
+        # Envolver cada processador em SpecialistWrapper
+        self.specialists = {}
+        for spec_id, processor in processor_instances.items():
+            self.specialists[spec_id] = SpecialistWrapper(processor, spec_id)
+
         # Inicializar orquestrador V13.6
         self.orchestrator = PipelineOrchestrator(
             config=self.pipeline_config,
@@ -64,9 +76,27 @@ class ProcessorManager:
         )
 
         logger.info(
-            f"✅ ProcessorManager V13.6: Orquestração refatorada com {len(self.specialists)} especialistas"
+            f"✅ ProcessorManager V13.6: {len(self.specialists)} especialistas "
+            f"com SpecialistWrapper (compatibilidade V13.1)"
         )
 
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Retorna configuração padrão caso YAML não exista"""
+        return {
+            'pipeline': {
+                'name': 'Para.AI V13.6 Pipeline',
+                'version': 'v13.6',
+                'phases': [
+                    {'id': 1, 'name': 'Segmentação', 'parallel': False, 'specialists': [1], 'depends_on': []},
+                    {'id': 2, 'name': 'Metadados', 'parallel': False, 'specialists': [2], 'depends_on': [1]},
+                    {'id': 3, 'name': 'Classificação', 'parallel': False, 'specialists': [3], 'depends_on': [2]},
+                    {'id': 4, 'name': 'Tripartite', 'parallel': True, 'specialists': [4, 5, 6], 'depends_on': [1, 2, 3]},
+                    {'id': 5, 'name': 'Arquivista', 'parallel': False, 'specialists': [7], 'depends_on': [4]},
+                    {'id': 6, 'name': 'Validação', 'parallel': False, 'specialists': [], 'depends_on': [5]},
+                ]
+            }
+        }
+
     async def process_acordao_sequential(
         self,
         acordao_data: Dict[str, Any],
@@ -74,19 +104,24 @@ class ProcessorManager:
     ) -> Dict[str, Any]:
         """
         Processa acórdão sequencialmente (compatibilidade V13.1)
-        
-        MUDANÇA: Delega para PipelineOrchestrator
+
+        Args:
+            acordao_data: Dados do acórdão
+            specialist_ids: IDs dos especialistas (None = todos)
+
+        Returns:
+            Resultado completo da pipeline
         """
-        logger.info("🔄 process_acordao_sequential() → delegando para PipelineOrchestrator")
-        
-        # Se specialist_ids fornecido, processar apenas fases específicas
+        logger.info("🔄 process_acordao_sequential() → PipelineOrchestrator")
+
+        # Determinar fases a executar
         if specialist_ids:
             fase_inicial = min(specialist_ids)
             fase_final = max(specialist_ids)
         else:
             fase_inicial = 1
             fase_final = 6
-        
+
         return await self.orchestrator.process_acordao(
             acordao_bruto=acordao_data,
             fase_inicial=fase_inicial,
@@ -100,17 +135,41 @@ class ProcessorManager:
     ) -> Dict[str, Any]:
         """
         Processa acórdão em paralelo (compatibilidade V13.1)
-        
-        MUDANÇA: Paralelo é controlado por fase no V13.6
+
+        NOTA: Paralelismo é controlado por fase no V13.6 (FASE 4)
         """
-        logger.info("🔄 process_acordao_parallel() → delegando para PipelineOrchestrator")
-        
+        logger.info("🔄 process_acordao_parallel() → PipelineOrchestrator")
+
         return await self.orchestrator.process_acordao(
             acordao_bruto=acordao_data,
             fase_inicial=1,
             fase_final=6
         )
 
+    async def process_acordao_batch(
+        self,
+        acordaos_data: List[Dict[str, Any]],
+        specialist_ids: Optional[List[int]] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Processa múltiplos acórdãos em batch (compatibilidade V13.1)
+
+        Args:
+            acordaos_data: Lista de acórdãos
+            specialist_ids: IDs dos especialistas (None = todos)
+
+        Returns:
+            Lista de resultados
+        """
+        logger.info(f"🔄 process_acordao_batch() com {len(acordaos_data)} acórdãos")
+
+        results = []
+        for acordao in acordaos_data:
+            result = await self.process_acordao_sequential(acordao, specialist_ids)
+            results.append(result)
+
+        return results
+
     def get_processor(self, specialist_id: int):
         """Retorna especialista específico (compatibilidade V13.1)"""
         return self.specialists.get(specialist_id)
@@ -121,4 +180,4 @@ class ProcessorManager:
 
     def get_processors_info(self) -> Dict[str, Any]:
         """Retorna informações sobre todos os especialistas"""
-        return self.orchestrator.get_pipeline_status()
+        return self.orchestrator.get_pipeline_status()