Revert "ParaAIV3.1"

This reverts commit ed5f314ca908762149bdd74b25b09c94f5f0183f.

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',
-    'SpecialistWrapper'
+    'SchemaValidator'
 ]
 
 __version__ = "13.6.0"

core/specialist_wrapper.py

@@ -1,71 +0,0 @@
-##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: Usa SpecialistWrapper para compatibilidade com ProcessorBase V13.1
+MUDANÇA: Este arquivo agora é apenas um wrapper para manter compatibilidade
 """
 import logging
 import yaml
@@ -9,9 +9,8 @@ from typing import Dict, Any, List, Optional
 
 from core.orchestrator import PipelineOrchestrator
 from core.validator import SchemaValidator
-from core.specialist_wrapper import SpecialistWrapper
 
-# Importar processadores V13.1 (serão refatorados na FASE 2)
+# Importar especialistas (mantidos do 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
@@ -26,11 +25,11 @@ logger = logging.getLogger(__name__)
 class ProcessorManager:
     """
     Gerenciador de processadores - WRAPPER para PipelineOrchestrator
-
+    
     MUDANÇA V13.6:
-    - Delega para PipelineOrchestrator
-    - Usa SpecialistWrapper para adaptar ProcessorBase V13.1
-    - Mantém compatibilidade total com código existente
+    - Este arquivo agora delega para PipelineOrchestrator
+    - Mantém compatibilidade com código existente
+    - Especialistas serão migrados gradualmente para novo formato
     """
 
     def __init__(self, llm_manager, max_workers: int = 3):
@@ -43,17 +42,11 @@ class ProcessorManager:
         self.max_workers = max_workers
 
         # Carregar configuração da pipeline
-        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()
+        with open('config/pipeline_config.yaml', 'r', encoding='utf-8') as f:
+            self.pipeline_config = yaml.safe_load(f)
 
-        # Inicializar processadores V13.1
-        logger.info("🔄 Inicializando processadores V13.1...")
-        processor_instances = {
+        # Inicializar especialistas (mapeamento temporário V13.1 → V13.6)
+        self.specialists = {
             1: ProcessorSegmentacao(llm_manager),      # Segmentador
             2: ProcessorMetadados(llm_manager),        # Metadados
             3: ProcessorContexto(llm_manager),         # Classificador (renomear depois)
@@ -63,11 +56,6 @@ 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,
@@ -76,27 +64,9 @@ class ProcessorManager:
         )
 
         logger.info(
-            f"✅ ProcessorManager V13.6: {len(self.specialists)} especialistas "
-            f"com SpecialistWrapper (compatibilidade V13.1)"
+            f"✅ ProcessorManager V13.6: Orquestração refatorada com {len(self.specialists)} especialistas"
         )
 
-    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],
@@ -104,24 +74,19 @@ class ProcessorManager:
     ) -> Dict[str, Any]:
         """
         Processa acórdão sequencialmente (compatibilidade V13.1)
-
-        Args:
-            acordao_data: Dados do acórdão
-            specialist_ids: IDs dos especialistas (None = todos)
-
-        Returns:
-            Resultado completo da pipeline
+        
+        MUDANÇA: Delega para PipelineOrchestrator
         """
-        logger.info("🔄 process_acordao_sequential() → PipelineOrchestrator")
-
-        # Determinar fases a executar
+        logger.info("🔄 process_acordao_sequential() → delegando para PipelineOrchestrator")
+        
+        # Se specialist_ids fornecido, processar apenas fases específicas
         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,
@@ -135,41 +100,17 @@ class ProcessorManager:
     ) -> Dict[str, Any]:
         """
         Processa acórdão em paralelo (compatibilidade V13.1)
-
-        NOTA: Paralelismo é controlado por fase no V13.6 (FASE 4)
+        
+        MUDANÇA: Paralelo é controlado por fase no V13.6
         """
-        logger.info("🔄 process_acordao_parallel() → PipelineOrchestrator")
-
+        logger.info("🔄 process_acordao_parallel() → delegando para 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)
@@ -180,4 +121,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()