Sync changes from hacore2/dwd_global_rad_api_server

aschmere · aschmere · commit 6d3083e88190 · 2024-06-15T23:01:29.000+02:00
diff --git a/custom_components/dwd_global_rad/__init__.py b/custom_components/dwd_global_rad/__init__.py
@@ -12,7 +12,7 @@
 
 from homeassistant.components.hassio import async_get_addon_info, async_start_addon
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import Platform
+from homeassistant.const import CONF_NAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -78,7 +78,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     _LOGGER.debug("Setup with data %s", entry.data)
     # entry.async_on_unload(entry.add_update_listener(update_listener))
 
-    use_addon = True
+    use_addon = False
 
     if use_addon:
         addon_info = await get_addon_config(hass, ADDON_SLUG)
@@ -91,7 +91,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # Ensure the add-on is started
         await ensure_addon_started(hass, ADDON_SLUG)
     else:
-        hostname = "homeassistant.local"
+        hostname = "192.168.2.165"
         port_number = "5001"
 
     hass.data.setdefault(DOMAIN, {})
@@ -104,17 +104,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         hass.data[DOMAIN]["rest_api_setup"] = True
 
     api_client = hass.data[DOMAIN]["api_client"]
-    latitude = entry.data["latitude"]
-    longitude = entry.data["longitude"]
-    name = entry.data["name"]
-
     if not await wait_for_api_server(api_client):
         raise ConfigEntryNotReady("API server not available after multiple attempts")
 
-    location = await api_client.get_location_by_name(name)
-    if location is None:
-        await api_client.add_location(name=name, latitude=latitude, longitude=longitude)
-
     # Initialize ForecastUpdateCoordinator
     if "forecast_coordinator" not in hass.data[DOMAIN]:
         hass.data[DOMAIN]["forecast_coordinator"] = ForecastUpdateCoordinator(
@@ -132,26 +124,58 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         await hass.data[DOMAIN][
             "measurement_coordinator"
         ].async_config_entry_first_refresh()
+    # Ensure camera entity is created
+    if not any(
+        e.data.get("category") == "forecast_camera"
+        for e in hass.config_entries.async_entries(DOMAIN)
+    ):
+        forecast_camera_entry = {
+            CONF_NAME: "DWD Global Radiation Forecast Camera",
+            "category": "forecast_camera",
+            "unique_id": "dwd_global_radiation_forecast_camera",
+        }
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": "implicit_config_entry_create"},
+                data=forecast_camera_entry,
+            )
+        )
+    if entry.data.get("category") != "forecast_camera":
+        latitude = entry.data["latitude"]
+        longitude = entry.data["longitude"]
+        name = entry.data["name"]
+
+        location = await api_client.get_location_by_name(name)
+        if location is None:
+            await api_client.add_location(
+                name=name, latitude=latitude, longitude=longitude
+            )
 
-    # Initialize LocationDataUpdateCoordinator
-    name = entry.data["name"]
-    location_coordinator = LocationDataUpdateCoordinator(
-        hass,
-        hass.data[DOMAIN]["forecast_coordinator"],
-        hass.data[DOMAIN]["measurement_coordinator"],
-        name,
-    )
-    await location_coordinator.async_config_entry_first_refresh()
-
-    # Store only the location_coordinator in the entry's data
-    hass.data[DOMAIN][entry.entry_id] = {"location_coordinator": location_coordinator}
-
-    # Perform the first data fetch for the new location immediately
-    await hass.data[DOMAIN]["measurement_coordinator"].async_request_refresh()
-    await hass.data[DOMAIN]["forecast_coordinator"].async_request_refresh()
+        # Initialize LocationDataUpdateCoordinator
+        name = entry.data["name"]
+        location_coordinator = LocationDataUpdateCoordinator(
+            hass,
+            hass.data[DOMAIN]["forecast_coordinator"],
+            hass.data[DOMAIN]["measurement_coordinator"],
+            name,
+        )
+        await location_coordinator.async_config_entry_first_refresh()
+
+        # Store only the location_coordinator in the entry's data
+        hass.data[DOMAIN][entry.entry_id] = {
+            "location_coordinator": location_coordinator
+        }
+
+        # Perform the first data fetch for the new location immediately
+        await hass.data[DOMAIN]["measurement_coordinator"].async_request_refresh()
+
+        # Forward setup to the sensor platform
+        await hass.config_entries.async_forward_entry_setups(entry, ["sensor"])
+    else:
+        await hass.config_entries.async_forward_entry_setups(entry, ["camera"])
 
-    # Setup platforms (e.g., sensor)
-    await hass.config_entries.async_forward_entry_setups(entry, ["sensor"])
+    await hass.data[DOMAIN]["forecast_coordinator"].async_request_refresh()
 
     return True
 
@@ -181,22 +205,48 @@ async def ensure_addon_started(
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
+    if entry.data.get("category") == "forecast_camera":
+        platforms = ["camera"]
+    else:
+        platforms = ["sensor"]
+
+    # Unload the specified platforms for the config entry
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, platforms)
+
+    if unload_ok:
+        # Remove entry-specific data
+        if entry.entry_id in hass.data[DOMAIN]:
+            del hass.data[DOMAIN][entry.entry_id]
+
         # Check if there are any remaining entries
         if not hass.config_entries.async_entries(DOMAIN):
-            # Perform additional cleanup if this was the last entry
-            if "coordinator" in hass.data[DOMAIN]:
-                # Perform any cleanup for the coordinator if necessary
-                coordinator = hass.data[DOMAIN]["coordinator"]
-                await coordinator.async_shutdown()
-                hass.data[DOMAIN].pop("coordinator")
+            # Clean up the forecast coordinator
+            forecast_coordinator = hass.data[DOMAIN].get("forecast_coordinator")
+            if forecast_coordinator:
+                await forecast_coordinator.async_shutdown()
+                hass.data[DOMAIN].pop("forecast_coordinator", None)
+
+            # Clean up the measurement coordinator
+            measurement_coordinator = hass.data[DOMAIN].get("measurement_coordinator")
+            if measurement_coordinator:
+                await measurement_coordinator.async_shutdown()
+                hass.data[DOMAIN].pop("measurement_coordinator", None)
 
             # Clean up the API client if no locations are left
-            if "api_client" in hass.data[DOMAIN]:
-                api_client = hass.data[DOMAIN]["api_client"]
-                if not api_client.locations:
-                    hass.data[DOMAIN].pop("api_client")
+            api_client = hass.data[DOMAIN].get("api_client")
+            if api_client:
+                locations = (
+                    await api_client.locations()
+                )  # Ensure async method is awaited
+                if not locations:
+                    await (
+                        api_client.async_shutdown()
+                    )  # Ensure proper API client shutdown
+                    hass.data[DOMAIN].pop("api_client", None)
+
+            # Clean up the REST API setup
+            if "rest_api_setup" in hass.data[DOMAIN]:
+                hass.data[DOMAIN].pop("rest_api_setup", None)
 
     return unload_ok
 
@@ -207,14 +257,15 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
     name = entry.data["name"]
 
     # Remove the location from the api_client
-    api_client.remove_location(name)
+    await api_client.remove_location(name)
 
     # Clean up the entry data
     if entry.entry_id in hass.data[DOMAIN]:
         hass.data[DOMAIN].pop(entry.entry_id)
 
     # Optionally, clean up the api_client if no locations are left
-    if not api_client.locations:
+    locations = await api_client.locations
+    if not locations:
         hass.data[DOMAIN].pop("api_client")
         # Check and remove forecast and measurement coordinators if they exist
         forecast_coordinator = hass.data[DOMAIN].get("forecast_coordinator")
@@ -239,7 +290,7 @@ async def wait_for_api_server(api_client, retries=5, delay=10):
                 api_client.get_status()
             )  # Assuming get_status is a method to check the API server status
             return True
-        except Exception as e:
+        except Exception:
             _LOGGER.warning(
                 f"API server not available, retrying in {delay} seconds... (Attempt {attempt+1}/{retries})"
             )
diff --git a/custom_components/dwd_global_rad/api_client.py b/custom_components/dwd_global_rad/api_client.py
@@ -70,6 +70,15 @@ async def remove_location(self, name: str):
         async with self.session.delete(url) as response:
             return await response.json()
 
+    async def get_forecast_animated_gif(self):
+        self._log_debug_info("Fetching forecast animated GIF")
+        url = f"{self.base_url}/process"
+        async with self.session.post(url) as response:
+            if response.status == 200:
+                return await response.read()
+            else:
+                return None
+
     async def get_status(self):
         self._log_debug_info("Checking API server status")
         url = f"{self.base_url}/status"
diff --git a/custom_components/dwd_global_rad/camera.py b/custom_components/dwd_global_rad/camera.py
@@ -0,0 +1,97 @@
+import logging
+import time
+
+from homeassistant.components.camera import Camera
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import DOMAIN, MANUFACTURER
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up the camera platform from a config entry."""
+    async_add_entities([DWDGlobalRadCamera(hass, config_entry)])
+
+
+class DWDGlobalRadCamera(Camera):
+    """Representation of a DWD Global Radiation Forecast Camera."""
+
+    def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry):
+        """Initialize the camera."""
+        super().__init__()
+        self._name = config_entry.data.get(
+            "name", "DWD Global Radiation Forecast Camera"
+        )
+        self._unique_id = config_entry.data.get("unique_id")
+        self.api_client = hass.data[DOMAIN]["api_client"]
+        self.forecast_coordinator = hass.data[DOMAIN]["forecast_coordinator"]
+        self._last_image = None
+        self._attr_is_streaming = False
+        self._config_entry = config_entry
+        self._last_update_time = 0
+
+        # Subscribe to forecast coordinator updates
+        self.forecast_coordinator.async_add_listener(self._schedule_update)
+
+    @property
+    def name(self):
+        """Return the name of the camera."""
+        return self._name
+
+    @property
+    def unique_id(self):
+        """Return the unique ID of the camera."""
+        return self._unique_id
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return device information about this camera."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._config_entry.entry_id)},
+            name=self._name,
+            manufacturer=MANUFACTURER,
+            entry_type=DeviceEntryType.SERVICE,
+        )
+
+    async def async_camera_image(self, width=None, height=None):
+        """Return bytes of camera image."""
+        _LOGGER.debug(
+            "Returning camera image with width=%s and height=%s", width, height
+        )
+        return self._last_image
+
+    @callback
+    def _schedule_update(self):
+        """Schedule an update for the camera image."""
+        _LOGGER.debug("Scheduling update for forecast animation GIF.")
+        self.hass.async_create_task(self.async_update())
+
+    async def async_update(self):
+        """Fetch new state data for the camera."""
+        current_time = time.time()
+        # Only update if the last update was more than 30 minutes ago
+        if current_time - self._last_update_time < 1800:  # 30 minutes = 1800 seconds
+            _LOGGER.debug("Skipping update, last update was less than 30 minutes ago.")
+            return
+        self._last_update_time = current_time
+        _LOGGER.debug("Fetching new forecast animation GIF")
+        image = await self.api_client.get_forecast_animated_gif()
+        if image:
+            self._last_image = image
+            self._attr_is_streaming = True
+        else:
+            self._attr_is_streaming = False
+        self.async_write_ha_state()
+
+    @property
+    def should_poll(self) -> bool:
+        """Return True if entity has to be polled for state."""
+        return False
diff --git a/custom_components/dwd_global_rad/config_flow.py b/custom_components/dwd_global_rad/config_flow.py
@@ -54,6 +54,7 @@ async def async_step_user(
     ) -> ConfigFlowResult:
         """Handle the initial step."""
         errors: dict[str, str] = {}
+
         if user_input is not None:
             name = user_input[CONF_NAME]
 
@@ -65,18 +66,28 @@ async def async_step_user(
             else:
                 await self.async_set_unique_id(name)
                 self._abort_if_unique_id_configured()
+
+                # Add location entry
+                user_input["category"] = "location"
                 return self.async_create_entry(title=name, data=user_input)
 
         user_input = user_input or {
             CONF_NAME: self.hass.config.location_name,
             CONF_LATITUDE: self.hass.config.latitude,
             CONF_LONGITUDE: self.hass.config.longitude,
         }
-        # Display the form with default values
+
+        # Display the form with default values and validation schema
         return self.async_show_form(
             step_id="user", data_schema=get_user_data_schema(self.hass), errors=errors
         )
 
+    async def async_step_implicit_config_entry_create(
+        self, data: dict[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle the implicit creation of a config entry."""
+        return self.async_create_entry(title=data["name"], data=data)
+
 
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""
diff --git a/custom_components/dwd_global_rad/manifest.json b/custom_components/dwd_global_rad/manifest.json
@@ -9,6 +9,6 @@
   "iot_class": "cloud_polling",
   "requirements": [],
   "ssdp": [],
-  "version": "0.2.9-beta",
+  "version": "0.3.0-beta",
   "zeroconf": []
-}
+}
