lifx-emulator 1.0.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

lifx_emulator/{api.py → api/templates/dashboard.html}

@@ -1,944 +1,3 @@
-"""FastAPI-based management API for LIFX emulator."""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import HTMLResponse
-from pydantic import BaseModel, Field, field_validator
-
-if TYPE_CHECKING:
-    from lifx_emulator.server import EmulatedLifxServer
-
-logger = logging.getLogger(__name__)
-
-
-class DeviceCreateRequest(BaseModel):
-    """Request to create a new device."""
-
-    product_id: int = Field(..., description="Product ID from LIFX registry")
-    serial: str | None = Field(
-        None, description="Optional serial (auto-generated if not provided)"
-    )
-    zone_count: int | None = Field(
-        None, description="Number of zones for multizone devices"
-    )
-    tile_count: int | None = Field(
-        None, description="Number of tiles for matrix devices"
-    )
-    tile_width: int | None = Field(None, description="Width of each tile in pixels")
-    tile_height: int | None = Field(None, description="Height of each tile in pixels")
-    firmware_major: int | None = Field(None, description="Firmware major version")
-    firmware_minor: int | None = Field(None, description="Firmware minor version")
-
-
-class ColorHsbk(BaseModel):
-    """HSBK color representation."""
-
-    hue: int
-    saturation: int
-    brightness: int
-    kelvin: int
-
-
-class DeviceInfo(BaseModel):
-    """Device information response."""
-
-    serial: str
-    label: str
-    product: int
-    vendor: int
-    power_level: int
-    has_color: bool
-    has_infrared: bool
-    has_multizone: bool
-    has_extended_multizone: bool
-    has_matrix: bool
-    has_hev: bool
-    zone_count: int
-    tile_count: int
-    color: ColorHsbk | None = None
-    zone_colors: list[ColorHsbk] = Field(default_factory=list)
-    tile_devices: list[dict] = Field(default_factory=list)
-    # Metadata fields
-    version_major: int = 0
-    version_minor: int = 0
-    build_timestamp: int = 0
-    group_label: str = ""
-    location_label: str = ""
-    uptime_ns: int = 0
-    wifi_signal: float = 0.0
-
-
-class ServerStats(BaseModel):
-    """Server statistics response."""
-
-    uptime_seconds: float
-    start_time: float
-    device_count: int
-    packets_received: int
-    packets_sent: int
-    packets_received_by_type: dict[int, int]
-    packets_sent_by_type: dict[int, int]
-    error_count: int
-    activity_enabled: bool
-
-
-class ActivityEvent(BaseModel):
-    """Recent activity event."""
-
-    timestamp: float
-    direction: str
-    packet_type: int
-    packet_name: str
-    device: str | None = None
-    target: str | None = None
-    addr: str
-
-
-# Scenario Management Models
-
-
-class ScenarioConfigModel(BaseModel):
-    """Scenario configuration model for API."""
-
-    drop_packets: dict[int, float] = Field(
-        default_factory=dict,
-        description="Map of packet types to drop rates (0.1-1.0). "
-        "1.0 = always drop, 0.5 = drop 50%, 0.1 = drop 10%. "
-        "Example: {101: 1.0, 102: 0.6}",
-    )
-    response_delays: dict[int, float] = Field(
-        default_factory=dict,
-        description="Map of packet types to delay in seconds before responding",
-    )
-    malformed_packets: list[int] = Field(
-        default_factory=list,
-        description="List of packet types to send with truncated/corrupted payloads",
-    )
-    invalid_field_values: list[int] = Field(
-        default_factory=list,
-        description="List of packet types to send with all 0xFF bytes in fields",
-    )
-    firmware_version: tuple[int, int] | None = Field(
-        None, description="Override firmware version (major, minor). Example: [3, 70]"
-    )
-    partial_responses: list[int] = Field(
-        default_factory=list,
-        description="List of packet types to send with incomplete data",
-    )
-    send_unhandled: bool = Field(
-        False, description="Send unhandled message responses for unknown packet types"
-    )
-
-    @field_validator("drop_packets", mode="before")
-    @classmethod
-    def convert_drop_packets_keys(cls, v):
-        """Convert string keys to integers for drop_packets."""
-        if isinstance(v, dict):
-            return {int(k): float(val) for k, val in v.items()}
-        return v
-
-    @field_validator("response_delays", mode="before")
-    @classmethod
-    def convert_response_delays_keys(cls, v):
-        """Convert string keys to integers for response_delays."""
-        if isinstance(v, dict):
-            return {int(k): float(val) for k, val in v.items()}
-        return v
-
-
-class ScenarioResponse(BaseModel):
-    """Response model for scenario operations."""
-
-    scope: str = Field(
-        ..., description="Scope of the scenario (global, device, type, location, group)"
-    )
-    identifier: str | None = Field(
-        None, description="Identifier for the scope (serial, type name, etc.)"
-    )
-    scenario: ScenarioConfigModel = Field(..., description="The scenario configuration")
-
-
-def create_api_app(server: EmulatedLifxServer) -> FastAPI:
-    """Create FastAPI application for emulator management.
-
-    Args:
-        server: The LIFX emulator server instance
-
-    Returns:
-        FastAPI application
-    """
-    app = FastAPI(
-        title="LIFX Emulator API",
-        description="""
-Runtime management and monitoring API for LIFX device emulator.
-
-This API provides read-only monitoring of the emulator state and device management
-capabilities (add/remove devices). Device state changes must be performed via the
-LIFX LAN protocol.
-
-## Features
-- Real-time server statistics and packet monitoring
-- Device inspection and management
-- Recent activity tracking
-- OpenAPI 3.1.0 compliant schema
-        """,
-        version="1.0.0",
-        contact={
-            "name": "LIFX Emulator",
-            "url": "https://github.com/Djelibeybi/lifx-emulator",
-        },
-        license_info={
-            "name": "UPL-1.0",
-            "url": "https://opensource.org/licenses/UPL",
-        },
-        openapi_tags=[
-            {
-                "name": "monitoring",
-                "description": "Server statistics and activity monitoring",
-            },
-            {
-                "name": "devices",
-                "description": "Device management and inspection",
-            },
-            {
-                "name": "scenarios",
-                "description": (
-                    "Test scenario management for simulating device behaviors"
-                ),
-            },
-        ],
-    )
-
-    @app.get("/", response_class=HTMLResponse, include_in_schema=False)
-    async def root():
-        """Serve web UI."""
-        return HTML_UI
-
-    @app.get(
-        "/api/stats",
-        response_model=ServerStats,
-        tags=["monitoring"],
-        summary="Get server statistics",
-        description=(
-            "Returns server uptime, packet counts, error counts, and device count."
-        ),
-    )
-    async def get_stats():
-        """Get server statistics."""
-        return server.get_stats()
-
-    @app.get(
-        "/api/devices",
-        response_model=list[DeviceInfo],
-        tags=["devices"],
-        summary="List all devices",
-        description=(
-            "Returns a list of all emulated devices with their current configuration."
-        ),
-    )
-    async def list_devices():
-        """List all emulated devices."""
-        devices = server.get_all_devices()
-        result = []
-        for dev in devices:
-            device_info = DeviceInfo(
-                serial=dev.state.serial,
-                label=dev.state.label,
-                product=dev.state.product,
-                vendor=dev.state.vendor,
-                power_level=dev.state.power_level,
-                has_color=dev.state.has_color,
-                has_infrared=dev.state.has_infrared,
-                has_multizone=dev.state.has_multizone,
-                has_extended_multizone=dev.state.has_extended_multizone,
-                has_matrix=dev.state.has_matrix,
-                has_hev=dev.state.has_hev,
-                zone_count=dev.state.multizone.zone_count
-                if dev.state.multizone is not None
-                else 0,
-                tile_count=dev.state.matrix.tile_count
-                if dev.state.matrix is not None
-                else 0,
-                color=ColorHsbk(
-                    hue=dev.state.color.hue,
-                    saturation=dev.state.color.saturation,
-                    brightness=dev.state.color.brightness,
-                    kelvin=dev.state.color.kelvin,
-                )
-                if dev.state.has_color
-                else None,
-                zone_colors=[
-                    ColorHsbk(
-                        hue=c.hue,
-                        saturation=c.saturation,
-                        brightness=c.brightness,
-                        kelvin=c.kelvin,
-                    )
-                    for c in dev.state.multizone.zone_colors
-                ]
-                if dev.state.multizone is not None
-                else [],
-                tile_devices=dev.state.matrix.tile_devices
-                if dev.state.matrix is not None
-                else [],
-                version_major=dev.state.version_major,
-                version_minor=dev.state.version_minor,
-                build_timestamp=dev.state.build_timestamp,
-                group_label=dev.state.group.group_label,
-                location_label=dev.state.location.location_label,
-                uptime_ns=dev.state.uptime_ns,
-                wifi_signal=dev.state.wifi_signal,
-            )
-            result.append(device_info)
-        return result
-
-    @app.get(
-        "/api/devices/{serial}",
-        response_model=DeviceInfo,
-        tags=["devices"],
-        summary="Get device information",
-        description=(
-            "Returns detailed information about a specific device by its serial number."
-        ),
-        responses={
-            404: {"description": "Device not found"},
-        },
-    )
-    async def get_device(serial: str):
-        """Get specific device information."""
-        device = server.get_device(serial)
-        if not device:
-            raise HTTPException(status_code=404, detail=f"Device {serial} not found")
-
-        return DeviceInfo(
-            serial=device.state.serial,
-            label=device.state.label,
-            product=device.state.product,
-            vendor=device.state.vendor,
-            power_level=device.state.power_level,
-            has_color=device.state.has_color,
-            has_infrared=device.state.has_infrared,
-            has_multizone=device.state.has_multizone,
-            has_extended_multizone=device.state.has_extended_multizone,
-            has_matrix=device.state.has_matrix,
-            has_hev=device.state.has_hev,
-            zone_count=device.state.multizone.zone_count
-            if device.state.multizone is not None
-            else 0,
-            tile_count=device.state.matrix.tile_count
-            if device.state.matrix is not None
-            else 0,
-            color=ColorHsbk(
-                hue=device.state.color.hue,
-                saturation=device.state.color.saturation,
-                brightness=device.state.color.brightness,
-                kelvin=device.state.color.kelvin,
-            )
-            if device.state.has_color
-            else None,
-            zone_colors=[
-                ColorHsbk(
-                    hue=c.hue,
-                    saturation=c.saturation,
-                    brightness=c.brightness,
-                    kelvin=c.kelvin,
-                )
-                for c in device.state.multizone.zone_colors
-            ]
-            if device.state.multizone is not None
-            else [],
-            tile_devices=device.state.matrix.tile_devices
-            if device.state.matrix is not None
-            else [],
-            version_major=device.state.version_major,
-            version_minor=device.state.version_minor,
-            build_timestamp=device.state.build_timestamp,
-            group_label=device.state.group.group_label,
-            location_label=device.state.location.location_label,
-            uptime_ns=device.state.uptime_ns,
-            wifi_signal=device.state.wifi_signal,
-        )
-
-    @app.post(
-        "/api/devices",
-        response_model=DeviceInfo,
-        status_code=201,
-        tags=["devices"],
-        summary="Create a new device",
-        description=(
-            "Creates a new emulated device by product ID. "
-            "The device will be added to the emulator immediately."
-        ),
-        responses={
-            201: {"description": "Device created successfully"},
-            400: {"description": "Invalid product ID or parameters"},
-            409: {"description": "Device with this serial already exists"},
-        },
-    )
-    async def create_device(request: DeviceCreateRequest):
-        """Create a new device."""
-        from lifx_emulator.factories import create_device
-
-        # Build firmware_version tuple if both major and minor are provided
-        firmware_version = None
-        if request.firmware_major is not None and request.firmware_minor is not None:
-            firmware_version = (request.firmware_major, request.firmware_minor)
-
-        try:
-            device = create_device(
-                product_id=request.product_id,
-                serial=request.serial,
-                zone_count=request.zone_count,
-                tile_count=request.tile_count,
-                tile_width=request.tile_width,
-                tile_height=request.tile_height,
-                firmware_version=firmware_version,
-                storage=server.storage,
-            )
-        except Exception as e:
-            raise HTTPException(status_code=400, detail=f"Failed to create device: {e}")
-
-        if not server.add_device(device):
-            raise HTTPException(
-                status_code=409,
-                detail=f"Device with serial {device.state.serial} already exists",
-            )
-
-        return DeviceInfo(
-            serial=device.state.serial,
-            label=device.state.label,
-            product=device.state.product,
-            vendor=device.state.vendor,
-            power_level=device.state.power_level,
-            has_color=device.state.has_color,
-            has_infrared=device.state.has_infrared,
-            has_multizone=device.state.has_multizone,
-            has_extended_multizone=device.state.has_extended_multizone,
-            has_matrix=device.state.has_matrix,
-            has_hev=device.state.has_hev,
-            zone_count=device.state.multizone.zone_count
-            if device.state.multizone is not None
-            else 0,
-            tile_count=device.state.matrix.tile_count
-            if device.state.matrix is not None
-            else 0,
-            color=ColorHsbk(
-                hue=device.state.color.hue,
-                saturation=device.state.color.saturation,
-                brightness=device.state.color.brightness,
-                kelvin=device.state.color.kelvin,
-            )
-            if device.state.has_color
-            else None,
-            zone_colors=[
-                ColorHsbk(
-                    hue=c.hue,
-                    saturation=c.saturation,
-                    brightness=c.brightness,
-                    kelvin=c.kelvin,
-                )
-                for c in device.state.multizone.zone_colors
-            ]
-            if device.state.multizone is not None
-            else [],
-            tile_devices=device.state.matrix.tile_devices
-            if device.state.matrix is not None
-            else [],
-            version_major=device.state.version_major,
-            version_minor=device.state.version_minor,
-            build_timestamp=device.state.build_timestamp,
-            group_label=device.state.group.group_label,
-            location_label=device.state.location.location_label,
-            uptime_ns=device.state.uptime_ns,
-            wifi_signal=device.state.wifi_signal,
-        )
-
-    @app.delete(
-        "/api/devices/{serial}",
-        status_code=204,
-        tags=["devices"],
-        summary="Delete a device",
-        description=(
-            "Removes an emulated device from the server. "
-            "The device will stop responding to LIFX protocol packets."
-        ),
-        responses={
-            204: {"description": "Device deleted successfully"},
-            404: {"description": "Device not found"},
-        },
-    )
-    async def delete_device(serial: str):
-        """Delete a device."""
-        if not server.remove_device(serial):
-            raise HTTPException(status_code=404, detail=f"Device {serial} not found")
-
-    @app.delete(
-        "/api/devices",
-        status_code=200,
-        tags=["devices"],
-        summary="Delete all devices",
-        description=(
-            "Removes all emulated devices from the server. "
-            "All devices will stop responding to LIFX protocol packets."
-        ),
-        responses={
-            200: {"description": "All devices deleted successfully"},
-        },
-    )
-    async def delete_all_devices():
-        """Delete all devices from the running server."""
-        count = server.remove_all_devices(delete_storage=False)
-        return {"deleted": count, "message": f"Removed {count} device(s) from server"}
-
-    @app.delete(
-        "/api/storage",
-        status_code=200,
-        tags=["devices"],
-        summary="Clear persistent storage",
-        description=(
-            "Deletes all persistent device state files from disk. "
-            "This does not affect currently running devices, only saved state files."
-        ),
-        responses={
-            200: {"description": "Storage cleared successfully"},
-            503: {"description": "Persistent storage not enabled"},
-        },
-    )
-    async def clear_storage():
-        """Clear all persistent device state from storage."""
-        if not server.storage:
-            raise HTTPException(
-                status_code=503, detail="Persistent storage is not enabled"
-            )
-
-        deleted = server.storage.delete_all_device_states()
-        return {
-            "deleted": deleted,
-            "message": f"Deleted {deleted} device state(s) from persistent storage",
-        }
-
-    @app.get(
-        "/api/activity",
-        response_model=list[ActivityEvent],
-        tags=["monitoring"],
-        summary="Get recent activity",
-        description=(
-            "Returns the last 100 packet events (TX/RX) "
-            "with timestamps and packet details."
-        ),
-    )
-    async def get_activity():
-        """Get recent activity events."""
-        return [ActivityEvent(**event) for event in server.get_recent_activity()]
-
-    # Scenario Management Endpoints
-
-    def _scenario_config_to_model(config) -> ScenarioConfigModel:
-        """Convert ScenarioConfig to Pydantic model."""
-        from lifx_emulator.scenario_manager import ScenarioConfig
-
-        if isinstance(config, ScenarioConfig):
-            return ScenarioConfigModel(
-                drop_packets=config.drop_packets,
-                response_delays=config.response_delays,
-                malformed_packets=config.malformed_packets,
-                invalid_field_values=config.invalid_field_values,
-                firmware_version=config.firmware_version,
-                partial_responses=config.partial_responses,
-                send_unhandled=config.send_unhandled,
-            )
-        return ScenarioConfigModel(**config)
-
-    def _model_to_scenario_config(model: ScenarioConfigModel):
-        """Convert Pydantic model to ScenarioConfig."""
-        from lifx_emulator.scenario_manager import ScenarioConfig
-
-        return ScenarioConfig(
-            drop_packets=model.drop_packets,
-            response_delays=model.response_delays,
-            malformed_packets=model.malformed_packets,
-            invalid_field_values=model.invalid_field_values,
-            firmware_version=model.firmware_version,
-            partial_responses=model.partial_responses,
-            send_unhandled=model.send_unhandled,
-        )
-
-    @app.get(
-        "/api/scenarios/global",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Get global scenario",
-        description=(
-            "Returns the global scenario that applies to all devices as a baseline."
-        ),
-    )
-    async def get_global_scenario():
-        """Get global scenario configuration."""
-        config = server.scenario_manager.get_global_scenario()
-        return ScenarioResponse(
-            scope="global", identifier=None, scenario=_scenario_config_to_model(config)
-        )
-
-    @app.put(
-        "/api/scenarios/global",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Set global scenario",
-        description=(
-            "Sets the global scenario that applies to all devices as a baseline."
-        ),
-    )
-    async def set_global_scenario(scenario: ScenarioConfigModel):
-        """Set global scenario configuration."""
-        config = _model_to_scenario_config(scenario)
-        server.scenario_manager.set_global_scenario(config)
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-        return ScenarioResponse(scope="global", identifier=None, scenario=scenario)
-
-    @app.delete(
-        "/api/scenarios/global",
-        status_code=204,
-        tags=["scenarios"],
-        summary="Clear global scenario",
-        description="Clears the global scenario, resetting it to defaults.",
-    )
-    async def clear_global_scenario():
-        """Clear global scenario configuration."""
-        server.scenario_manager.clear_global_scenario()
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-    @app.get(
-        "/api/scenarios/devices/{serial}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Get device-specific scenario",
-        description=(
-            "Returns the scenario configuration for a specific device by serial number."
-        ),
-        responses={404: {"description": "Device scenario not found"}},
-    )
-    async def get_device_scenario(serial: str):
-        """Get device-specific scenario."""
-        config = server.scenario_manager.get_device_scenario(serial)
-        if config is None:
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for device {serial}"
-            )
-        return ScenarioResponse(
-            scope="device",
-            identifier=serial,
-            scenario=_scenario_config_to_model(config),
-        )
-
-    @app.put(
-        "/api/scenarios/devices/{serial}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Set device-specific scenario",
-        description="Sets a scenario that applies only to the specified device.",
-    )
-    async def set_device_scenario(serial: str, scenario: ScenarioConfigModel):
-        """Set device-specific scenario."""
-        # Verify device exists
-        device = server.get_device(serial)
-        if not device:
-            raise HTTPException(status_code=404, detail=f"Device {serial} not found")
-
-        config = _model_to_scenario_config(scenario)
-        server.scenario_manager.set_device_scenario(serial, config)
-
-        # Invalidate cache for this device
-        device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-        return ScenarioResponse(scope="device", identifier=serial, scenario=scenario)
-
-    @app.delete(
-        "/api/scenarios/devices/{serial}",
-        status_code=204,
-        tags=["scenarios"],
-        summary="Clear device-specific scenario",
-        description="Clears the scenario for the specified device.",
-        responses={404: {"description": "Device scenario not found"}},
-    )
-    async def clear_device_scenario(serial: str):
-        """Clear device-specific scenario."""
-        if not server.scenario_manager.delete_device_scenario(serial):
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for device {serial}"
-            )
-
-        # Invalidate cache if device exists
-        device = server.get_device(serial)
-        if device:
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-    @app.get(
-        "/api/scenarios/types/{device_type}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Get type-specific scenario",
-        description=(
-            "Returns the scenario for a device type (matrix, multizone, color, etc.)."
-        ),
-        responses={404: {"description": "Type scenario not found"}},
-    )
-    async def get_type_scenario(device_type: str):
-        """Get type-specific scenario."""
-        config = server.scenario_manager.get_type_scenario(device_type)
-        if config is None:
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for type {device_type}"
-            )
-        return ScenarioResponse(
-            scope="type",
-            identifier=device_type,
-            scenario=_scenario_config_to_model(config),
-        )
-
-    @app.put(
-        "/api/scenarios/types/{device_type}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Set type-specific scenario",
-        description=(
-            "Sets a scenario that applies to all devices "
-            "of a specific type. "
-            "Valid types: matrix, multizone, color, infrared, hev"
-        ),
-    )
-    async def set_type_scenario(device_type: str, scenario: ScenarioConfigModel):
-        """Set type-specific scenario."""
-        config = _model_to_scenario_config(scenario)
-        server.scenario_manager.set_type_scenario(device_type, config)
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-        return ScenarioResponse(scope="type", identifier=device_type, scenario=scenario)
-
-    @app.delete(
-        "/api/scenarios/types/{device_type}",
-        status_code=204,
-        tags=["scenarios"],
-        summary="Clear type-specific scenario",
-        description="Clears the scenario for the specified device type.",
-        responses={404: {"description": "Type scenario not found"}},
-    )
-    async def clear_type_scenario(device_type: str):
-        """Clear type-specific scenario."""
-        if not server.scenario_manager.delete_type_scenario(device_type):
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for type {device_type}"
-            )
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-    @app.get(
-        "/api/scenarios/locations/{location}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Get location-specific scenario",
-        description="Returns the scenario for a specific location.",
-        responses={404: {"description": "Location scenario not found"}},
-    )
-    async def get_location_scenario(location: str):
-        """Get location-specific scenario."""
-        config = server.scenario_manager.get_location_scenario(location)
-        if config is None:
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for location {location}"
-            )
-        return ScenarioResponse(
-            scope="location",
-            identifier=location,
-            scenario=_scenario_config_to_model(config),
-        )
-
-    @app.put(
-        "/api/scenarios/locations/{location}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Set location-specific scenario",
-        description=(
-            "Sets a scenario that applies to all devices in a specific location."
-        ),
-    )
-    async def set_location_scenario(location: str, scenario: ScenarioConfigModel):
-        """Set location-specific scenario."""
-        config = _model_to_scenario_config(scenario)
-        server.scenario_manager.set_location_scenario(location, config)
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-        return ScenarioResponse(
-            scope="location", identifier=location, scenario=scenario
-        )
-
-    @app.delete(
-        "/api/scenarios/locations/{location}",
-        status_code=204,
-        tags=["scenarios"],
-        summary="Clear location-specific scenario",
-        description="Clears the scenario for the specified location.",
-        responses={404: {"description": "Location scenario not found"}},
-    )
-    async def clear_location_scenario(location: str):
-        """Clear location-specific scenario."""
-        if not server.scenario_manager.delete_location_scenario(location):
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for location {location}"
-            )
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-    @app.get(
-        "/api/scenarios/groups/{group}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Get group-specific scenario",
-        description="Returns the scenario for a specific group.",
-        responses={404: {"description": "Group scenario not found"}},
-    )
-    async def get_group_scenario(group: str):
-        """Get group-specific scenario."""
-        config = server.scenario_manager.get_group_scenario(group)
-        if config is None:
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for group {group}"
-            )
-        return ScenarioResponse(
-            scope="group", identifier=group, scenario=_scenario_config_to_model(config)
-        )
-
-    @app.put(
-        "/api/scenarios/groups/{group}",
-        response_model=ScenarioResponse,
-        tags=["scenarios"],
-        summary="Set group-specific scenario",
-        description=(
-            "Sets a scenario that applies to all devices in a specific group."
-        ),
-    )
-    async def set_group_scenario(group: str, scenario: ScenarioConfigModel):
-        """Set group-specific scenario."""
-        config = _model_to_scenario_config(scenario)
-        server.scenario_manager.set_group_scenario(group, config)
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-        return ScenarioResponse(scope="group", identifier=group, scenario=scenario)
-
-    @app.delete(
-        "/api/scenarios/groups/{group}",
-        status_code=204,
-        tags=["scenarios"],
-        summary="Clear group-specific scenario",
-        description="Clears the scenario for the specified group.",
-        responses={404: {"description": "Group scenario not found"}},
-    )
-    async def clear_group_scenario(group: str):
-        """Clear group-specific scenario."""
-        if not server.scenario_manager.delete_group_scenario(group):
-            raise HTTPException(
-                status_code=404, detail=f"No scenario found for group {group}"
-            )
-
-        # Invalidate cache for all devices
-        for device in server.get_all_devices():
-            device.invalidate_scenario_cache()
-
-        # Save to disk if persistence is enabled
-        if server.scenario_persistence:
-            server.scenario_persistence.save(server.scenario_manager)
-
-    return app
-
-
-async def run_api_server(
-    server: EmulatedLifxServer, host: str = "127.0.0.1", port: int = 8080
-):
-    """Run the FastAPI server.
-
-    Args:
-        server: The LIFX emulator server instance
-        host: Host to bind to
-        port: Port to bind to
-    """
-    import uvicorn
-
-    app = create_api_app(server)
-
-    config = uvicorn.Config(
-        app,
-        host=host,
-        port=port,
-        log_level="info",
-        access_log=True,
-    )
-    api_server = uvicorn.Server(config)
-
-    logger.info("Starting API server on http://%s:%s", host, port)
-    await api_server.serve()
-
-
-# Embedded web UI
-HTML_UI = """
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -1838,4 +897,3 @@ HTML_UI = """
     </script>
 </body>
 </html>
-"""