Types & Dataclasses

@dataclass(frozen=True, slots=True)
class VideoFrame:
    data: np.ndarray      # RGB uint8 array, shape (height, width, 3)
    width: int            # Frame width in pixels
    height: int           # Frame height in pixels
    timestamp_ms: int     # Presentation timestamp in milliseconds

import cv2
from PIL import Image

def on_frame(frame: VideoFrame) -> None:
    # OpenCV (note: OpenCV uses BGR)
    cv2.imshow("video", cv2.cvtColor(frame.data, cv2.COLOR_RGB2BGR))

    # PIL
    image = Image.fromarray(frame.data)

    # Headless processing
    processed = some_ml_model(frame.data)

@dataclass(frozen=True, slots=True)
class Recording:
    stream_id: str              # Unique stream identifier
    video_url: str | None       # Presigned URL for video file
    events_url: str | None      # Presigned URL for events JSON
    thumbnail_url: str | None   # Presigned URL for thumbnail image
    preview_url: str | None     # Presigned URL for preview video
    frame_count: int | None     # Total number of frames
    duration_seconds: float | None  # Duration in seconds

@dataclass(frozen=True, slots=True)
class StreamRecordingInfo:
    stream_id: str              # Unique stream identifier
    width: int                  # Video width in pixels
    height: int                 # Video height in pixels
    started_at: str             # ISO 8601 timestamp
    ended_at: str | None        # ISO 8601 timestamp or None if active
    duration_seconds: float | None  # Duration in seconds

@dataclass(frozen=True, slots=True)
class StreamRecordingsList:
    recordings: list[StreamRecordingInfo]  # List of recording info
    total: int                              # Total recordings available
    limit: int                              # Max per request
    offset: int                             # Recordings skipped

from typing import TypedDict, NotRequired

class StartAction(TypedDict):
    prompt: str
    image: NotRequired[str | bytes]  # Optional image for image-to-video

class InteractAction(TypedDict):
    prompt: str

class ScriptEntry(TypedDict):
    timestamp_ms: int                    # When this action occurs (milliseconds from start)
    start: NotRequired[StartAction]      # Begin a new stream
    interact: NotRequired[InteractAction] # Send an interaction
    end: NotRequired[dict]               # End the stream (empty dict)

@dataclass(frozen=True, slots=True)
class SimulationStream:
    stream_id: str                    # Unique stream identifier
    video_url: str | None             # Presigned URL for the video file
    events_url: str | None            # Presigned URL for the events JSON
    thumbnail_url: str | None         # Presigned URL for the thumbnail image
    preview_url: str | None           # Presigned URL for the preview video
    frame_count: int | None           # Total number of frames
    duration_seconds: float | None    # Duration of the video in seconds
    script_index: int                 # Index of the script in batch mode (0 for single script)

@dataclass(frozen=True, slots=True)
class SimulationJobInfo:
    job_id: str                       # Unique identifier for the job
    status: str                       # Current job status
    priority: str                     # Job priority
    created_at: str                   # ISO timestamp when job was created
    completed_at: str | None          # ISO timestamp when job completed
    error_message: str | None         # Error message if job failed

@dataclass(frozen=True, slots=True)
class SimulationJobDetail:
    job_id: str                       # Unique identifier for the job
    status: SimulationJobStatus       # Current job status
    priority: str                     # Job priority
    created_at: str                   # ISO timestamp when job was created
    dispatched_at: str | None         # ISO timestamp when job was dispatched
    started_at: str | None            # ISO timestamp when processing started
    completed_at: str | None          # ISO timestamp when job completed
    error_message: str | None         # Error message if job failed
    assigned_region: str | None       # Region where the job is being processed
    retry_count: int                  # Number of times the job has been retried
    streams: list[SimulationStream]   # Output streams from the simulation
    estimated_wait_minutes: float | None  # Estimated wait time in minutes

@dataclass(frozen=True, slots=True)
class SimulationJobsList:
    jobs: list[SimulationJobInfo]     # List of simulation job summaries
    total: int                        # Total jobs available
    limit: int                        # Limit used in request
    offset: int                       # Offset used in request

@dataclass(frozen=True, slots=True)
class StreamerCapabilities:
    image_to_video: bool = False

    def to_dict(self) -> dict[str, bool]
    @classmethod
    def from_dict(cls, data: dict) -> StreamerCapabilities

@dataclass(frozen=True, slots=True)
class ClientCredentials:
    signaling_url: str
    session_token: str
    expires_in: int
    capabilities: StreamerCapabilities | None = None
    session_id: str  # auto-derived from JWT, not user-provided

    def to_dict(self) -> dict[str, Any]
    @classmethod
    def from_dict(cls, data: dict) -> ClientCredentials

# Server-side: mint and serialize
creds = await server.create_client_credentials()
creds_dict = creds.to_dict()
# Send creds_dict as JSON to the client

# Client-side: deserialize
from odyssey import ClientCredentials
creds = ClientCredentials.from_dict(data_from_server)

@dataclass(frozen=True, slots=True)
class BroadcastInfo:
   webrtc_url: str
   spectator_token: str
   hls_url: str | None = None

@dataclass(frozen=True, slots=True)
class SpectatorConnection:
   @property
   def is_connected(self) -> bool
   @property
   def peer_connection(self) -> object | None
   async def disconnect(self) -> None

from odyssey import connect_to_stream

def handle_frame(frame):
   cv2.imshow("Broadcast", frame.data)
   cv2.waitKey(1)

connection = await connect_to_stream(
   webrtc_url="http://localhost:8889/live/stream123",
   spectator_token="spectator_abc...",
   on_video_frame=handle_frame,
)

# Later
await connection.disconnect()

class ConnectionStatus(str, Enum):
    AUTHENTICATING = "authenticating"  # Authenticating with Odyssey API
    CONNECTING = "connecting"          # Connecting to signaling server
    RECONNECTING = "reconnecting"      # Reconnecting after disconnect
    CONNECTED = "connected"            # Connected and ready
    DISCONNECTED = "disconnected"      # Disconnected (clean)
    FAILED = "failed"                  # Connection failed (fatal)

@dataclass
class ClientConfig:
    api_key: str                        # API key for authentication (required)
    api_url: str = "https://api.odyssey.ml"  # API URL
    debug: bool = False                 # Enable debug logging
    advanced: AdvancedConfig = AdvancedConfig()  # Advanced settings

@dataclass
class AdvancedConfig:
    max_retries: int = 5              # Max retry attempts
    initial_retry_delay_ms: int = 1000  # Initial retry delay
    max_retry_delay_ms: int = 2000    # Max retry delay
    retry_backoff_multiplier: float = 2.0  # Backoff multiplier
    queue_timeout_s: int = 30         # Queue timeout in seconds

class OdysseyError(Exception):
    pass

class OdysseyAuthError(OdysseyError):
    pass

class OdysseyConnectionError(OdysseyError):
    pass

class OdysseyStreamError(OdysseyError):
    pass