import cortexia
from cortexia.data.models.video import VideoFramePacket
import numpy as np

# Initialize the main SDK interface
cortexia_sdk = cortexia.Cortexia()

# Create individual components
detector = cortexia.create_feature("detection")
captioner = cortexia.create_feature("caption")
blur_gate = cortexia.create_gate("blur")

# Process a single frame
frame_data = np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8)
frame = VideoFramePacket(
    frame_data=frame_data,
    frame_number=0,
    timestamp=0.0,
    source_video_id="test_video"
)

# Apply detection
detection_result = detector.process_frame(frame)
print(f"Detected {len(detection_result.detections)} objects")

# Apply captioning
caption_result = captioner.process_frame(frame)
print(f"Caption: {caption_result.caption}")

# Apply quality gating
blur_result = blur_gate.process_frame(frame)
print(f"Blur score: {blur_result.score}, Passed: {blur_result.passed}")

import cortexia
from cortexia.data.io.batch_processor import BatchProcessor

# Create a custom processing pipeline
def custom_pipeline(video_path):
    # Initialize components
    lister = cortexia.create_feature("listing")
    detector = cortexia.create_feature("detection") 
    segmenter = cortexia.create_feature("segmentation")
    blur_gate = cortexia.create_gate("blur")
    entropy_gate = cortexia.create_gate("entropy")
    
    # Process frames with quality gates
    frames = load_video_frames(video_path)  # Your frame loading function
    
    for frame in frames:
        # Apply quality gates first
        if blur_gate.process_frame(frame).passed and entropy_gate.process_frame(frame).passed:
            # Process with features
            objects = lister.process_frame(frame)
            detections = detector.process_frame(frame)
            segments = segmenter.process_frame(frame)
            
            # Combine results
            yield {
                'frame': frame,
                'objects': objects,
                'detections': detections,
                'segments': segments
            }

import cortexia
from cortexia.data.io.batch_processor import BatchProcessor

# Process large datasets efficiently
def process_dataset(image_paths):
    detector = cortexia.create_feature("detection")
    
    def load_func(paths):
        return [load_image(path) for path in paths]
    
    def inference_func(frames):
        return detector.process_batch(frames)
    
    processor = BatchProcessor(batch_size=8)
    processor.load_indices(image_paths)
    
    results = processor.process_batch(
        load_func=load_func,
        inference_func=inference_func,
        save_func=save_results  # Your save function
    )
    
    return results

from cortexia.features.base import BaseFeature
from cortexia.data.models.result.base_result import BaseResult

class CustomFeature(BaseFeature):
    output_schema = CustomResult
    required_inputs = []
    required_fields = []
    
    def _initialize(self):
        # Initialize your models here
        pass
    
    def process_frame(self, frame, **inputs):
        # Your processing logic
        return CustomResult(custom_field="result")
    
    @property
    def name(self):
        return "custom_feature"
    
    @property 
    def description(self):
        return "A custom feature implementation"

# Register your component
@FEATURE_REGISTRY.decorator("custom_feature")
class RegisteredCustomFeature(CustomFeature):
    pass

import cortexia

# List all available features
print("Available features:", cortexia.list_features())

# List all available gates  
print("Available gates:", cortexia.list_gates())

# Get component information
detector = cortexia.get_feature("detection")
print(f"Detector: {detector.name} - {detector.description}")

from cortexia.core.config.manager import ConfigManager

# Load configuration from file
config_manager = ConfigManager(config_file_path="config/example_config.toml")
config_manager.load_config()

# Access configuration parameters
model_name = config_manager.get_param("model_settings.object_listing_model")
batch_size = config_manager.get_param("processing.batch_size", 4)

cortexia_sdk = cortexia.Cortexia()

# Component management
feature = cortexia_sdk.create_feature("detection")
gate = cortexia_sdk.create_gate("blur")

# Registry access
available_features = cortexia_sdk.list_features()
available_gates = cortexia_sdk.list_gates()

class CustomFeature(BaseFeature):
    output_schema = CustomResult
    required_inputs = []
    required_fields = []
    
    def _initialize(self):
        # Initialize models
        pass
    
    def process_frame(self, frame, **inputs):
        # Process single frame
        return CustomResult(...)
    
    def process_batch(self, frames):
        # Process multiple frames efficiently
        return [self.process_frame(frame) for frame in frames]

class CustomGate(BaseGate):
    def process_frame(self, frame):
        # Return boolean decision
        return True/False
    
    def process_with_metadata(self, frame):
        # Return detailed results with scores
        return GateResult(passed=True, score=0.8, metadata={})

frame = VideoFramePacket(
    frame_data=np.ndarray,  # HxWxC numpy array
    frame_number=int,
    timestamp=float,
    source_video_id=str
)

class DetectionResult(BaseResult):
    detections: List[Detection]  # List of detected objects
    confidence: float  # Overall confidence

from cortexia.api.exceptions import CortexiaError, ModelLoadError, ProcessingError

try:
    result = detector.process_frame(frame)
except ModelLoadError as e:
    print(f"Failed to load model: {e}")
except ProcessingError as e:
    print(f"Processing failed: {e}")

# Reduce batch size in configuration
[processing]
batch_size = 1  # Reduce from default

# Validate configuration
from cortexia.core.config.manager import ConfigManager
config = ConfigManager("config/your_config.toml")
config.load_config()  # Will raise exceptions for invalid config