alexei.dolgolyov
ef33935188
Some checks failed
Lint & Test / test (push) Failing after 34s
New standalone WeatherSource entity with pluggable provider architecture (Open-Meteo v1, free, no API key). Full CRUD, test endpoint, browser geolocation, IconSelect provider picker, CardSection with test/clone/edit. WeatherColorStripStream maps WMO weather codes to ambient color palettes with temperature hue shifting and thunderstorm flash effects. Ref-counted WeatherManager polls API and caches data per source. CSS editor integration: weather type with EntitySelect source picker, speed and temperature influence sliders. Backup/restore support. i18n for en/ru/zh.
407 lines
15 KiB
Python
407 lines
15 KiB
Python
"""FastAPI application entry point."""
|
|
|
|
import sys
|
|
from contextlib import asynccontextmanager
|
|
from pathlib import Path
|
|
|
|
from fastapi import FastAPI
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.middleware.gzip import GZipMiddleware
|
|
from fastapi.responses import FileResponse, JSONResponse
|
|
from fastapi.staticfiles import StaticFiles
|
|
from fastapi.templating import Jinja2Templates
|
|
from starlette.requests import Request
|
|
|
|
from wled_controller import __version__
|
|
from wled_controller.api import router
|
|
from wled_controller.api.dependencies import init_dependencies
|
|
from wled_controller.config import get_config
|
|
from wled_controller.core.processing.processor_manager import ProcessorDependencies, ProcessorManager
|
|
from wled_controller.storage import DeviceStore
|
|
from wled_controller.storage.template_store import TemplateStore
|
|
from wled_controller.storage.postprocessing_template_store import PostprocessingTemplateStore
|
|
from wled_controller.storage.pattern_template_store import PatternTemplateStore
|
|
from wled_controller.storage.picture_source_store import PictureSourceStore
|
|
from wled_controller.storage.output_target_store import OutputTargetStore
|
|
from wled_controller.storage.color_strip_store import ColorStripStore
|
|
from wled_controller.storage.audio_source_store import AudioSourceStore
|
|
from wled_controller.storage.audio_template_store import AudioTemplateStore
|
|
import wled_controller.core.audio # noqa: F401 — trigger engine auto-registration
|
|
from wled_controller.storage.value_source_store import ValueSourceStore
|
|
from wled_controller.storage.automation_store import AutomationStore
|
|
from wled_controller.storage.scene_preset_store import ScenePresetStore
|
|
from wled_controller.storage.sync_clock_store import SyncClockStore
|
|
from wled_controller.storage.color_strip_processing_template_store import ColorStripProcessingTemplateStore
|
|
from wled_controller.storage.gradient_store import GradientStore
|
|
from wled_controller.storage.weather_source_store import WeatherSourceStore
|
|
from wled_controller.core.processing.sync_clock_manager import SyncClockManager
|
|
from wled_controller.core.weather.weather_manager import WeatherManager
|
|
from wled_controller.core.automations.automation_engine import AutomationEngine
|
|
from wled_controller.core.mqtt.mqtt_service import MQTTService
|
|
from wled_controller.core.devices.mqtt_client import set_mqtt_service
|
|
from wled_controller.core.backup.auto_backup import AutoBackupEngine
|
|
from wled_controller.core.processing.os_notification_listener import OsNotificationListener
|
|
from wled_controller.api.routes.system import STORE_MAP
|
|
from wled_controller.utils import setup_logging, get_logger, install_broadcast_handler
|
|
|
|
# Initialize logging
|
|
setup_logging()
|
|
install_broadcast_handler()
|
|
logger = get_logger(__name__)
|
|
|
|
# Get configuration
|
|
config = get_config()
|
|
|
|
# Seed demo data before stores are loaded (first-run only)
|
|
if config.demo:
|
|
from wled_controller.core.demo_seed import seed_demo_data
|
|
seed_demo_data(config.storage)
|
|
|
|
# Initialize storage and processing
|
|
device_store = DeviceStore(config.storage.devices_file)
|
|
template_store = TemplateStore(config.storage.templates_file)
|
|
pp_template_store = PostprocessingTemplateStore(config.storage.postprocessing_templates_file)
|
|
picture_source_store = PictureSourceStore(config.storage.picture_sources_file)
|
|
output_target_store = OutputTargetStore(config.storage.output_targets_file)
|
|
pattern_template_store = PatternTemplateStore(config.storage.pattern_templates_file)
|
|
color_strip_store = ColorStripStore(config.storage.color_strip_sources_file)
|
|
audio_source_store = AudioSourceStore(config.storage.audio_sources_file)
|
|
audio_template_store = AudioTemplateStore(config.storage.audio_templates_file)
|
|
value_source_store = ValueSourceStore(config.storage.value_sources_file)
|
|
automation_store = AutomationStore(config.storage.automations_file)
|
|
scene_preset_store = ScenePresetStore(config.storage.scene_presets_file)
|
|
sync_clock_store = SyncClockStore(config.storage.sync_clocks_file)
|
|
cspt_store = ColorStripProcessingTemplateStore(config.storage.color_strip_processing_templates_file)
|
|
gradient_store = GradientStore(config.storage.gradients_file)
|
|
gradient_store.migrate_palette_references(color_strip_store)
|
|
weather_source_store = WeatherSourceStore(config.storage.weather_sources_file)
|
|
sync_clock_manager = SyncClockManager(sync_clock_store)
|
|
weather_manager = WeatherManager(weather_source_store)
|
|
|
|
processor_manager = ProcessorManager(
|
|
ProcessorDependencies(
|
|
picture_source_store=picture_source_store,
|
|
capture_template_store=template_store,
|
|
pp_template_store=pp_template_store,
|
|
pattern_template_store=pattern_template_store,
|
|
device_store=device_store,
|
|
color_strip_store=color_strip_store,
|
|
audio_source_store=audio_source_store,
|
|
value_source_store=value_source_store,
|
|
audio_template_store=audio_template_store,
|
|
sync_clock_manager=sync_clock_manager,
|
|
cspt_store=cspt_store,
|
|
gradient_store=gradient_store,
|
|
weather_manager=weather_manager,
|
|
)
|
|
)
|
|
|
|
|
|
def _save_all_stores() -> None:
|
|
"""Persist every store to disk.
|
|
|
|
Called during graceful shutdown to ensure in-memory data survives
|
|
restarts even if no CRUD happened during the session.
|
|
"""
|
|
all_stores = [
|
|
device_store, template_store, pp_template_store,
|
|
picture_source_store, output_target_store, pattern_template_store,
|
|
color_strip_store, audio_source_store, audio_template_store,
|
|
value_source_store, automation_store, scene_preset_store,
|
|
sync_clock_store, cspt_store, gradient_store, weather_source_store,
|
|
]
|
|
saved = 0
|
|
for store in all_stores:
|
|
try:
|
|
store._save(force=True)
|
|
saved += 1
|
|
except Exception as e:
|
|
logger.error(f"Failed to save {store._json_key} on shutdown: {e}")
|
|
logger.info(f"Shutdown save: persisted {saved}/{len(all_stores)} stores to disk")
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
"""Application lifespan manager.
|
|
|
|
Handles startup and shutdown events.
|
|
"""
|
|
# Startup
|
|
logger.info(f"Starting LED Grab v{__version__}")
|
|
logger.info(f"Python version: {sys.version}")
|
|
logger.info(f"Server listening on {config.server.host}:{config.server.port}")
|
|
print("\n =============================================")
|
|
print(f" LED Grab v{__version__}")
|
|
print(f" Open http://localhost:{config.server.port} in your browser")
|
|
print(" =============================================\n")
|
|
|
|
# Log authentication mode
|
|
if not config.auth.api_keys:
|
|
logger.info("Authentication disabled (no API keys configured)")
|
|
else:
|
|
logger.info(f"Authentication enabled ({len(config.auth.api_keys)} API key(s) configured)")
|
|
client_labels = ", ".join(config.auth.api_keys.keys())
|
|
logger.info(f"Authorized clients: {client_labels}")
|
|
|
|
# Create MQTT service (shared broker connection)
|
|
mqtt_service = MQTTService(config.mqtt)
|
|
set_mqtt_service(mqtt_service)
|
|
|
|
# Create automation engine (needs processor_manager + mqtt_service + stores for scene activation)
|
|
automation_engine = AutomationEngine(
|
|
automation_store, processor_manager,
|
|
mqtt_service=mqtt_service,
|
|
scene_preset_store=scene_preset_store,
|
|
target_store=output_target_store,
|
|
device_store=device_store,
|
|
)
|
|
|
|
# Create auto-backup engine — derive paths from storage config so that
|
|
# demo mode auto-backups go to data/demo/ instead of data/.
|
|
_data_dir = Path(config.storage.devices_file).parent
|
|
auto_backup_engine = AutoBackupEngine(
|
|
settings_path=_data_dir / "auto_backup_settings.json",
|
|
backup_dir=_data_dir / "backups",
|
|
store_map=STORE_MAP,
|
|
storage_config=config.storage,
|
|
)
|
|
|
|
# Verify STORE_MAP covers all StorageConfig file fields.
|
|
# Catches missed additions early (at startup) rather than silently
|
|
# excluding new stores from backups.
|
|
storage_attrs = {
|
|
attr for attr in config.storage.model_fields
|
|
if attr.endswith("_file")
|
|
}
|
|
mapped_attrs = set(STORE_MAP.values())
|
|
unmapped = storage_attrs - mapped_attrs
|
|
if unmapped:
|
|
logger.warning(
|
|
f"StorageConfig fields not in STORE_MAP (missing from backups): "
|
|
f"{sorted(unmapped)}"
|
|
)
|
|
|
|
# Initialize API dependencies
|
|
init_dependencies(
|
|
device_store, template_store, processor_manager,
|
|
pp_template_store=pp_template_store,
|
|
pattern_template_store=pattern_template_store,
|
|
picture_source_store=picture_source_store,
|
|
output_target_store=output_target_store,
|
|
color_strip_store=color_strip_store,
|
|
audio_source_store=audio_source_store,
|
|
audio_template_store=audio_template_store,
|
|
value_source_store=value_source_store,
|
|
automation_store=automation_store,
|
|
scene_preset_store=scene_preset_store,
|
|
automation_engine=automation_engine,
|
|
auto_backup_engine=auto_backup_engine,
|
|
sync_clock_store=sync_clock_store,
|
|
sync_clock_manager=sync_clock_manager,
|
|
cspt_store=cspt_store,
|
|
gradient_store=gradient_store,
|
|
weather_source_store=weather_source_store,
|
|
weather_manager=weather_manager,
|
|
)
|
|
|
|
# Register devices in processor manager for health monitoring
|
|
devices = device_store.get_all_devices()
|
|
for device in devices:
|
|
try:
|
|
processor_manager.add_device(
|
|
device_id=device.id,
|
|
device_url=device.url,
|
|
led_count=device.led_count,
|
|
device_type=device.device_type,
|
|
baud_rate=device.baud_rate,
|
|
software_brightness=device.software_brightness,
|
|
auto_shutdown=device.auto_shutdown,
|
|
)
|
|
logger.info(f"Registered device: {device.name} ({device.id})")
|
|
except Exception as e:
|
|
logger.error(f"Failed to register device {device.id}: {e}")
|
|
|
|
logger.info(f"Registered {len(devices)} devices for health monitoring")
|
|
|
|
# Register output targets in processor manager
|
|
targets = output_target_store.get_all_targets()
|
|
registered_targets = 0
|
|
for target in targets:
|
|
try:
|
|
target.register_with_manager(processor_manager)
|
|
registered_targets += 1
|
|
logger.info(f"Registered target: {target.name} ({target.id})")
|
|
except Exception as e:
|
|
logger.error(f"Failed to register target {target.id}: {e}")
|
|
|
|
logger.info(f"Registered {registered_targets} output target(s)")
|
|
|
|
# Start background health monitoring for all devices
|
|
await processor_manager.start_health_monitoring()
|
|
|
|
# Start MQTT service (broker connection for output, triggers, state)
|
|
await mqtt_service.start()
|
|
|
|
# Start automation engine (evaluates conditions and activates scenes)
|
|
await automation_engine.start()
|
|
|
|
# Start auto-backup engine (periodic configuration backups)
|
|
await auto_backup_engine.start()
|
|
|
|
# Start OS notification listener (Windows toast → notification CSS streams)
|
|
os_notif_listener = OsNotificationListener(
|
|
color_strip_store=color_strip_store,
|
|
color_strip_stream_manager=processor_manager.color_strip_stream_manager,
|
|
)
|
|
os_notif_listener.start()
|
|
|
|
yield
|
|
|
|
# Shutdown
|
|
logger.info("Shutting down LED Grab")
|
|
|
|
# Persist all stores to disk before stopping anything.
|
|
# This ensures in-memory data survives force-kills and restarts
|
|
# where no CRUD happened during the session.
|
|
_save_all_stores()
|
|
|
|
# Stop weather manager
|
|
try:
|
|
weather_manager.shutdown()
|
|
except Exception as e:
|
|
logger.error(f"Error stopping weather manager: {e}")
|
|
|
|
# Stop auto-backup engine
|
|
try:
|
|
await auto_backup_engine.stop()
|
|
except Exception as e:
|
|
logger.error(f"Error stopping auto-backup engine: {e}")
|
|
|
|
# Stop automation engine first (deactivates automation-managed scenes)
|
|
try:
|
|
await automation_engine.stop()
|
|
logger.info("Stopped automation engine")
|
|
except Exception as e:
|
|
logger.error(f"Error stopping automation engine: {e}")
|
|
|
|
# Stop OS notification listener
|
|
try:
|
|
os_notif_listener.stop()
|
|
except Exception as e:
|
|
logger.error(f"Error stopping OS notification listener: {e}")
|
|
|
|
# Stop all processing
|
|
try:
|
|
await processor_manager.stop_all()
|
|
logger.info("Stopped all processors")
|
|
except Exception as e:
|
|
logger.error(f"Error stopping processors: {e}")
|
|
|
|
# Stop MQTT service
|
|
try:
|
|
await mqtt_service.stop()
|
|
except Exception as e:
|
|
logger.error(f"Error stopping MQTT service: {e}")
|
|
|
|
# Create FastAPI application
|
|
app = FastAPI(
|
|
title="LED Grab",
|
|
description="Control WLED devices based on screen content for ambient lighting",
|
|
version=__version__,
|
|
lifespan=lifespan,
|
|
docs_url="/docs",
|
|
redoc_url="/redoc",
|
|
openapi_url="/openapi.json",
|
|
)
|
|
|
|
# Configure CORS
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=config.server.cors_origins,
|
|
allow_credentials=True,
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
app.add_middleware(GZipMiddleware, minimum_size=500)
|
|
|
|
# Include API routes
|
|
app.include_router(router)
|
|
|
|
# PWA: serve manifest and service worker from root scope
|
|
_static_root = Path(__file__).parent / "static"
|
|
|
|
|
|
@app.get("/manifest.json", include_in_schema=False)
|
|
async def pwa_manifest():
|
|
"""Serve PWA manifest from root scope."""
|
|
return FileResponse(_static_root / "manifest.json", media_type="application/manifest+json")
|
|
|
|
|
|
@app.get("/sw.js", include_in_schema=False)
|
|
async def pwa_service_worker():
|
|
"""Serve service worker from root scope (controls all pages)."""
|
|
return FileResponse(
|
|
_static_root / "sw.js",
|
|
media_type="application/javascript",
|
|
headers={"Cache-Control": "no-cache"},
|
|
)
|
|
|
|
|
|
# Middleware: no-cache for static JS/CSS (development convenience)
|
|
@app.middleware("http")
|
|
async def _no_cache_static(request: Request, call_next):
|
|
path = request.url.path
|
|
if path.startswith("/static/") and path.endswith((".js", ".css", ".json")):
|
|
response = await call_next(request)
|
|
response.headers["Cache-Control"] = "no-cache, must-revalidate"
|
|
return response
|
|
return await call_next(request)
|
|
|
|
# Mount static files
|
|
static_path = Path(__file__).parent / "static"
|
|
if static_path.exists():
|
|
app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
|
|
logger.info(f"Mounted static files from {static_path}")
|
|
else:
|
|
logger.warning(f"Static files directory not found: {static_path}")
|
|
|
|
# Jinja2 templates
|
|
templates_path = Path(__file__).parent / "templates"
|
|
templates = Jinja2Templates(directory=str(templates_path))
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def global_exception_handler(request, exc):
|
|
"""Global exception handler for unhandled errors."""
|
|
import uuid
|
|
|
|
ref_id = uuid.uuid4().hex[:8]
|
|
logger.error("Unhandled exception [ref=%s]: %s", ref_id, exc, exc_info=True)
|
|
|
|
return JSONResponse(
|
|
status_code=500,
|
|
content={
|
|
"error": "InternalServerError",
|
|
"message": "Internal server error",
|
|
"ref": ref_id,
|
|
},
|
|
)
|
|
|
|
|
|
@app.get("/")
|
|
async def root(request: Request):
|
|
"""Serve the web UI dashboard."""
|
|
return templates.TemplateResponse(request, "index.html")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import uvicorn
|
|
|
|
uvicorn.run(
|
|
"wled_controller.main:app",
|
|
host=config.server.host,
|
|
port=config.server.port,
|
|
log_level=config.server.log_level.lower(),
|
|
reload=False, # Disabled due to watchfiles infinite reload loop
|
|
)
|