modules/scenario_contextualization/database/scenario_models.py

"""
Scenario Data Models
"""
from dataclasses import dataclass, field
from typing import List, Optional, Dict
from datetime import datetime


@dataclass
class BoundaryCondition:
    """Boundary condition"""
    condition: str  # Condition description
    impact: str     # Impact description
    details: Optional[str] = None  # Additional details


@dataclass
class AppropriateResponse:
    """Appropriate response"""
    response: str    # Response action
    rationale: str  # Rationale
    details: Optional[str] = None  # Additional details


@dataclass
class ScenarioMetadata:
    """Scenario metadata"""
    created_at: str
    updated_at: str
    views: int = 0
    quality_score: float = 0.0
    verified: bool = False
    source_urls: List[str] = field(default_factory=list)


@dataclass
class ADASScenario:
    """Complete ADAS scenario data model"""
    # Basic information
    scenario_id: str
    title: str
    description: str
    
    # Classification information
    adas_feature: str  # Related ADAS feature
    scenario_type: str  # "boundary_condition", "historical_incident", "hypothetical_edge_case"
    source: List[str]  # Data source
    severity_level: str  # "low", "medium", "high"
    
    # Scenario content
    boundary_conditions: List[BoundaryCondition]
    appropriate_responses: List[AppropriateResponse]
    educational_principles: List[str]
    
    # Generalization information
    manufacturer_specific: bool
    generalization: str  # Generalized universal principle
    
    # Metadata (must come before fields with default values)
    metadata: ScenarioMetadata
    
    # Related information (fields with default values must come last)
    related_features: List[str] = field(default_factory=list)
    related_scenarios: List[str] = field(default_factory=list)
    tags: List[str] = field(default_factory=list)
    
    @classmethod
    def from_dict(cls, data: dict) -> 'ADASScenario':
        """Create scenario object from dictionary"""
        # Convert boundary conditions
        boundary_conditions = [
            BoundaryCondition(**bc) if isinstance(bc, dict) else bc
            for bc in data.get("boundary_conditions", [])
        ]
        
        # Convert appropriate responses
        appropriate_responses = [
            AppropriateResponse(**ar) if isinstance(ar, dict) else ar
            for ar in data.get("appropriate_responses", [])
        ]
        
        # Convert metadata
        metadata = ScenarioMetadata(**data.get("metadata", {}))
        
        return cls(
            scenario_id=data["scenario_id"],
            title=data["title"],
            description=data["description"],
            adas_feature=data["adas_feature"],
            scenario_type=data["scenario_type"],
            source=data.get("source", []),
            severity_level=data.get("severity_level", "medium"),
            boundary_conditions=boundary_conditions,
            appropriate_responses=appropriate_responses,
            educational_principles=data.get("educational_principles", []),
            manufacturer_specific=data.get("manufacturer_specific", False),
            generalization=data.get("generalization", ""),
            metadata=metadata,
            related_features=data.get("related_features", []),
            related_scenarios=data.get("related_scenarios", []),
            tags=data.get("tags", [])
        )
    
    def to_dict(self) -> dict:
        """Convert to dictionary"""
        return {
            "scenario_id": self.scenario_id,
            "title": self.title,
            "description": self.description,
            "adas_feature": self.adas_feature,
            "scenario_type": self.scenario_type,
            "source": self.source,
            "severity_level": self.severity_level,
            "boundary_conditions": [
                {
                    "condition": bc.condition,
                    "impact": bc.impact,
                    "details": bc.details
                }
                for bc in self.boundary_conditions
            ],
            "appropriate_responses": [
                {
                    "response": ar.response,
                    "rationale": ar.rationale,
                    "details": ar.details
                }
                for ar in self.appropriate_responses
            ],
            "educational_principles": self.educational_principles,
            "manufacturer_specific": self.manufacturer_specific,
            "generalization": self.generalization,
            "related_features": self.related_features,
            "related_scenarios": self.related_scenarios,
            "tags": self.tags,
            "metadata": {
                "created_at": self.metadata.created_at,
                "updated_at": self.metadata.updated_at,
                "views": self.metadata.views,
                "quality_score": self.metadata.quality_score,
                "verified": self.metadata.verified,
                "source_urls": self.metadata.source_urls
            }
        }


@dataclass
class RankedScenario:
    """Scenario with relevance score"""
    scenario: ADASScenario
    relevance_score: float
    match_reasons: List[str] = field(default_factory=list)