Function handle_scenes

uncommon_route/proxy.py:3576–3641

GET /v1/scenes — list all scenes. POST /v1/scenes — add/remove/import.

(request: Request)

        return JSONResponse(payload)

    async def handle_scenes(request: Request) -> JSONResponse:
        """GET /v1/scenes — list all scenes.  POST /v1/scenes — add/remove/import."""
        if request.method == "GET":
            return JSONResponse(_scene_store.export())

        denied = _admin_auth_failure(request)
        if denied is not None:
            return denied
        body = await request.json()
        action = str(body.get("action", "")).strip().lower()
        try:
            if action == "add":
                name = str(body.get("name", "")).strip()
                primary = str(body.get("primary", "")).strip()
                if not name or not primary:
                    return JSONResponse({"error": "name and primary are required"}, status_code=400)
                fallback_raw = body.get("fallback", [])
                if isinstance(fallback_raw, str):
                    fallback = [p.strip() for p in fallback_raw.split(",") if p.strip()]
                elif isinstance(fallback_raw, list):
                    fallback = [str(f).strip() for f in fallback_raw if str(f).strip()]
                else:
                    fallback = []
                tier_floor_raw = body.get("tier_floor")
                tier_floor = Tier(str(tier_floor_raw).upper()) if tier_floor_raw else None
                tier_cap_raw = body.get("tier_cap")
                tier_cap = Tier(str(tier_cap_raw).upper()) if tier_cap_raw else None
                allowed_providers_raw = body.get("allowed_providers", [])
                allowed_providers = (
                    [str(p).strip() for p in allowed_providers_raw if str(p).strip()]
                    if isinstance(allowed_providers_raw, list) else []
                )
                max_cost_raw = body.get("max_cost_per_request")
                max_cost = float(max_cost_raw) if max_cost_raw is not None else None
                if max_cost is not None and max_cost <= 0:
                    return JSONResponse({"error": "max_cost_per_request must be positive"}, status_code=400)
                scene = SceneConfig(
                    name=name,
                    primary=primary,
                    fallback=fallback,
                    hard_pin=bool(body.get("hard_pin", False)),
                    description=str(body.get("description", "")),
                    tier_floor=tier_floor,
                    tier_cap=tier_cap,
                    allowed_providers=allowed_providers,
                    max_cost_per_request=max_cost,
                )
                stored = _scene_store.add(scene)
                return JSONResponse({"ok": True, "scene": _serialize_scene_response(stored)})
            elif action == "remove":
                name = str(body.get("name", "")).strip()
                if not name:
                    return JSONResponse({"error": "name is required"}, status_code=400)
                removed = _scene_store.remove(name)
                return JSONResponse({"ok": removed, "name": name})
            elif action == "import":
                data = body.get("data", {})
                count = _scene_store.import_scenes(data)