complexity_reduction_examples.py

"""
Examples of complexity reduction techniques.
"""

from dataclasses import dataclass
from typing import List, Dict, Any, Optional
from abc import ABC, abstractmethod


@dataclass
class ConsolidatedDataNode:
    """Consolidated data node with reduced complexity."""
    id: str
    type: str
    data: Dict[str, Any]
    connections: List[str] = None
    
    def __post_init__(self):
        if self.connections is None:
            self.connections = []
    
    def add_connection(self, node_id: str):
        """Add connection to another node."""
        if node_id not in self.connections:
            self.connections.append(node_id)
    
    def remove_connection(self, node_id: str):
        """Remove connection to another node."""
        if node_id in self.connections:
            self.connections.remove(node_id)


class DataProcessor(ABC):
    """Abstract base class for data processors."""
    
    @abstractmethod
    def process(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Process data."""
        pass


class ConsolidatedProcessor(DataProcessor):
    """Consolidated processor with reduced complexity."""
    
    def __init__(self):
        self._processors = {}
    
    def register_processor(self, data_type: str, processor: DataProcessor):
        """Register processor for data type."""
        self._processors[data_type] = processor
    
    def process(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Process data using appropriate processor."""
        data_type = data.get('type', 'unknown')
        processor = self._processors.get(data_type)
        
        if processor:
            return processor.process(data)
        else:
            return self._default_process(data)
    
    def _default_process(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Default processing logic."""
        return {
            'processed': True,
            'original_type': data.get('type'),
            'data': data
        }


# Usage example
def create_consolidated_system():
    """Create consolidated data processing system."""
    
    processor = ConsolidatedProcessor()
    
    # Create consolidated nodes
    nodes = [
        ConsolidatedDataNode('node1', 'input', {'value': 42}),
        ConsolidatedDataNode('node2', 'process', {'value': 84}),
        ConsolidatedDataNode('node3', 'output', {'value': 126})
    ]
    
    # Connect nodes
    nodes[0].add_connection('node2')
    nodes[1].add_connection('node3')
    
    return processor, nodes