Spaces:
Sleeping
Sleeping
File size: 5,383 Bytes
6a11527 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
"""
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)
|