Pipeline

class Pipeline(BasePipeline):
    def __init__(self, processors: List[FrameProcessor]):
        super().__init__()
        self._source = PipelineSource(self.push_frame)
        self._sink = PipelineSink(self.push_frame)
        self._processors = [self._source] + processors + [self._sink]
        self._link_processors()

class PipelineSource(FrameProcessor):
    def __init__(self, upstream_push_frame: Callable[[Frame, FrameDirection], Coroutine])

class PipelineSink(FrameProcessor):
    def __init__(self, downstream_push_frame: Callable[[Frame, FrameDirection], Coroutine])

async def process_frame(self, frame: Frame, direction: FrameDirection):
    """
    Process frame in specified direction through the pipeline
    """

async def cleanup(self):
    """
    Clean up all processors in the pipeline
    """

def processors_with_metrics(self) -> List[FrameProcessor]:
    """
    Return all processors that can generate metrics
    """

# Create simple processing pipeline
pipeline = Pipeline([
    audio_processor,
    transcriber,
    llm_service,
    tts_service
])

# Pipeline with error handling
pipeline = Pipeline([
    input_processor,
    error_handler,
    main_processor,
    cleanup_processor
])

# Process frames
try:
    await pipeline.process_frame(frame, FrameDirection.DOWNSTREAM)
finally:
    await pipeline.cleanup()