2023.6.3

homeassistant/components/airzone/manifest.json

@@ -11,5 +11,5 @@
   "documentation": "https://www.home-assistant.io/integrations/airzone",
   "iot_class": "local_polling",
   "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==0.6.3"]
+  "requirements": ["aioairzone==0.6.4"]
 }

homeassistant/components/bluetooth_tracker/device_tracker.py

@@ -173,7 +173,11 @@ async def perform_bluetooth_update() -> None:
                     rssi = await hass.async_add_executor_job(client.request_rssi)
                     client.close()
 
-                tasks.append(see_device(hass, async_see, mac, friendly_name, rssi))
+                tasks.append(
+                    asyncio.create_task(
+                        see_device(hass, async_see, mac, friendly_name, rssi)
+                    )
+                )
 
             if tasks:
                 await asyncio.wait(tasks)

homeassistant/components/bmw_connected_drive/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/bmw_connected_drive",
   "iot_class": "cloud_polling",
   "loggers": ["bimmer_connected"],
-  "requirements": ["bimmer_connected==0.13.6"]
+  "requirements": ["bimmer-connected==0.13.7"]
 }

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==2.11.3"]
+  "requirements": ["bthome-ble==2.12.0"]
 }

homeassistant/components/bthome/sensor.py

@@ -47,6 +47,15 @@
 from .device import device_key_to_bluetooth_entity_key
 
 SENSOR_DESCRIPTIONS = {
+    # Acceleration (m/s²)
+    (
+        BTHomeSensorDeviceClass.ACCELERATION,
+        Units.ACCELERATION_METERS_PER_SQUARE_SECOND,
+    ): SensorEntityDescription(
+        key=f"{BTHomeSensorDeviceClass.ACCELERATION}_{Units.ACCELERATION_METERS_PER_SQUARE_SECOND}",
+        native_unit_of_measurement=Units.ACCELERATION_METERS_PER_SQUARE_SECOND,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
     # Battery (percent)
     (BTHomeSensorDeviceClass.BATTERY, Units.PERCENTAGE): SensorEntityDescription(
         key=f"{BTHomeSensorDeviceClass.BATTERY}_{Units.PERCENTAGE}",
@@ -131,6 +140,15 @@
         native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
         state_class=SensorStateClass.TOTAL,
     ),
+    # Gyroscope (°/s)
+    (
+        BTHomeSensorDeviceClass.GYROSCOPE,
+        Units.GYROSCOPE_DEGREES_PER_SECOND,
+    ): SensorEntityDescription(
+        key=f"{BTHomeSensorDeviceClass.GYROSCOPE}_{Units.GYROSCOPE_DEGREES_PER_SECOND}",
+        native_unit_of_measurement=Units.GYROSCOPE_DEGREES_PER_SECOND,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
     # Humidity in (percent)
     (BTHomeSensorDeviceClass.HUMIDITY, Units.PERCENTAGE): SensorEntityDescription(
         key=f"{BTHomeSensorDeviceClass.HUMIDITY}_{Units.PERCENTAGE}",
@@ -242,6 +260,15 @@
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    # Timestamp (datetime object)
+    (
+        BTHomeSensorDeviceClass.TIMESTAMP,
+        None,
+    ): SensorEntityDescription(
+        key=f"{BTHomeSensorDeviceClass.TIMESTAMP}",
+        device_class=SensorDeviceClass.TIMESTAMP,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
     # UV index (-)
     (
         BTHomeSensorDeviceClass.UV_INDEX,

homeassistant/components/fortios/device_tracker.py

@@ -43,7 +43,7 @@ def get_scanner(hass: HomeAssistant, config: ConfigType) -> FortiOSDeviceScanner
     fgt = FortiOSAPI()
 
     try:
-        fgt.tokenlogin(host, token, verify_ssl)
+        fgt.tokenlogin(host, token, verify_ssl, None, 12, "root")
     except ConnectionError as ex:
         _LOGGER.error("ConnectionError to FortiOS API: %s", ex)
         return None
@@ -77,16 +77,25 @@ def __init__(self, fgt) -> None:
 
     def update(self):
         """Update clients from the device."""
-        clients_json = self._fgt.monitor("user/device/query", "")
+        clients_json = self._fgt.monitor(
+            "user/device/query",
+            "",
+            parameters={"filter": "format=master_mac|hostname|is_online"},
+        )
+
         self._clients_json = clients_json
 
         self._clients = []
 
         if clients_json:
             try:
                 for client in clients_json["results"]:
-                    if client["is_online"]:
-                        self._clients.append(client["mac"].upper())
+                    if (
+                        "is_online" in client
+                        and "master_mac" in client
+                        and client["is_online"]
+                    ):
+                        self._clients.append(client["master_mac"].upper())
             except KeyError as kex:
                 _LOGGER.error("Key not found in clients: %s", kex)
 
@@ -106,17 +115,10 @@ def get_device_name(self, device):
             return None
 
         for client in data["results"]:
-            if client["mac"] == device:
-                try:
+            if "master_mac" in client and client["master_mac"] == device:
+                if "hostname" in client:
                     name = client["hostname"]
-                    _LOGGER.debug("Getting device name=%s", name)
-                    return name
-                except KeyError as kex:
-                    _LOGGER.debug(
-                        "No hostname found for %s in client data: %s",
-                        device,
-                        kex,
-                    )
-                    return device.replace(":", "_")
-
+                else:
+                    name = client["master_mac"].replace(":", "_")
+                return name
         return None

homeassistant/components/fully_kiosk/__init__.py

@@ -2,6 +2,7 @@
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
 from .coordinator import FullyKioskDataUpdateCoordinator
@@ -17,6 +18,14 @@
 ]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up Fully Kiosk Browser."""
+
+    await async_setup_services(hass)
+
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Fully Kiosk Browser from a config entry."""
 
@@ -28,8 +37,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     coordinator.async_update_listeners()
 
-    await async_setup_services(hass)
-
     return True
 
 

homeassistant/components/fully_kiosk/services.py

@@ -1,74 +1,66 @@
 """Services for the Fully Kiosk Browser integration."""
 from __future__ import annotations
 
-from collections.abc import Callable
-from typing import Any
-
-from fullykiosk import FullyKiosk
 import voluptuous as vol
 
+from homeassistant.config_entries import ConfigEntry, ConfigEntryState
 from homeassistant.const import ATTR_DEVICE_ID
 from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.exceptions import HomeAssistantError
 import homeassistant.helpers.config_validation as cv
 import homeassistant.helpers.device_registry as dr
 
 from .const import (
     ATTR_APPLICATION,
     ATTR_URL,
     DOMAIN,
-    LOGGER,
     SERVICE_LOAD_URL,
     SERVICE_START_APPLICATION,
 )
+from .coordinator import FullyKioskDataUpdateCoordinator
 
 
 async def async_setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the Fully Kiosk Browser integration."""
 
-    async def execute_service(
-        call: ServiceCall,
-        fully_method: Callable,
-        *args: list[str],
-        **kwargs: dict[str, Any],
-    ) -> None:
-        """Execute a Fully service call.
-
-        :param call: {ServiceCall} HA service call.
-        :param fully_method: {Callable} A method of the FullyKiosk class.
-        :param args: Arguments for fully_method.
-        :param kwargs: Key-word arguments for fully_method.
-        :return: None
-        """
-        LOGGER.debug(
-            "Calling Fully service %s with args: %s, %s", ServiceCall, args, kwargs
-        )
+    async def collect_coordinators(
+        device_ids: list[str],
+    ) -> list[FullyKioskDataUpdateCoordinator]:
+        config_entries = list[ConfigEntry]()
         registry = dr.async_get(hass)
-        for target in call.data[ATTR_DEVICE_ID]:
+        for target in device_ids:
             device = registry.async_get(target)
             if device:
-                for key in device.config_entries:
-                    entry = hass.config_entries.async_get_entry(key)
-                    if not entry:
-                        continue
-                    if entry.domain != DOMAIN:
-                        continue
-                    coordinator = hass.data[DOMAIN][key]
-                    # fully_method(coordinator.fully, *args, **kwargs) would make
-                    # test_services.py fail.
-                    await getattr(coordinator.fully, fully_method.__name__)(
-                        *args, **kwargs
+                device_entries = list[ConfigEntry]()
+                for entry_id in device.config_entries:
+                    entry = hass.config_entries.async_get_entry(entry_id)
+                    if entry and entry.domain == DOMAIN:
+                        device_entries.append(entry)
+                if not device_entries:
+                    raise HomeAssistantError(
+                        f"Device '{target}' is not a {DOMAIN} device"
                     )
-                    break
+                config_entries.extend(device_entries)
+            else:
+                raise HomeAssistantError(
+                    f"Device '{target}' not found in device registry"
+                )
+        coordinators = list[FullyKioskDataUpdateCoordinator]()
+        for config_entry in config_entries:
+            if config_entry.state != ConfigEntryState.LOADED:
+                raise HomeAssistantError(f"{config_entry.title} is not loaded")
+            coordinators.append(hass.data[DOMAIN][config_entry.entry_id])
+        return coordinators
 
     async def async_load_url(call: ServiceCall) -> None:
         """Load a URL on the Fully Kiosk Browser."""
-        await execute_service(call, FullyKiosk.loadUrl, call.data[ATTR_URL])
+        for coordinator in await collect_coordinators(call.data[ATTR_DEVICE_ID]):
+            await coordinator.fully.loadUrl(call.data[ATTR_URL])
 
     async def async_start_app(call: ServiceCall) -> None:
         """Start an app on the device."""
-        await execute_service(
-            call, FullyKiosk.startApplication, call.data[ATTR_APPLICATION]
-        )
+        for coordinator in await collect_coordinators(call.data[ATTR_DEVICE_ID]):
+            await coordinator.fully.startApplication(call.data[ATTR_APPLICATION])
 
     # Register all the above services
     service_mapping = [

homeassistant/components/glances/sensor.py

@@ -223,17 +223,17 @@ class GlancesSensorEntityDescription(
         icon="mdi:docker",
         state_class=SensorStateClass.MEASUREMENT,
     ),
-    ("raid", "used"): GlancesSensorEntityDescription(
-        key="used",
+    ("raid", "available"): GlancesSensorEntityDescription(
+        key="available",
         type="raid",
-        name_suffix="Raid used",
+        name_suffix="Raid available",
         icon="mdi:harddisk",
         state_class=SensorStateClass.MEASUREMENT,
     ),
-    ("raid", "available"): GlancesSensorEntityDescription(
-        key="available",
+    ("raid", "used"): GlancesSensorEntityDescription(
+        key="used",
         type="raid",
-        name_suffix="Raid available",
+        name_suffix="Raid used",
         icon="mdi:harddisk",
         state_class=SensorStateClass.MEASUREMENT,
     ),
@@ -269,36 +269,36 @@ def _migrate_old_unique_ids(
         if sensor_type in ["fs", "sensors", "raid"]:
             for sensor_label, params in sensors.items():
                 for param in params:
-                    sensor_description = SENSOR_TYPES[(sensor_type, param)]
+                    if sensor_description := SENSOR_TYPES.get((sensor_type, param)):
+                        _migrate_old_unique_ids(
+                            hass,
+                            f"{coordinator.host}-{name} {sensor_label} {sensor_description.name_suffix}",
+                            f"{sensor_label}-{sensor_description.key}",
+                        )
+                        entities.append(
+                            GlancesSensor(
+                                coordinator,
+                                name,
+                                sensor_label,
+                                sensor_description,
+                            )
+                        )
+        else:
+            for sensor in sensors:
+                if sensor_description := SENSOR_TYPES.get((sensor_type, sensor)):
                     _migrate_old_unique_ids(
                         hass,
-                        f"{coordinator.host}-{name} {sensor_label} {sensor_description.name_suffix}",
-                        f"{sensor_label}-{sensor_description.key}",
+                        f"{coordinator.host}-{name}  {sensor_description.name_suffix}",
+                        f"-{sensor_description.key}",
                     )
                     entities.append(
                         GlancesSensor(
                             coordinator,
                             name,
-                            sensor_label,
+                            "",
                             sensor_description,
                         )
                     )
-        else:
-            for sensor in sensors:
-                sensor_description = SENSOR_TYPES[(sensor_type, sensor)]
-                _migrate_old_unique_ids(
-                    hass,
-                    f"{coordinator.host}-{name}  {sensor_description.name_suffix}",
-                    f"-{sensor_description.key}",
-                )
-                entities.append(
-                    GlancesSensor(
-                        coordinator,
-                        name,
-                        "",
-                        sensor_description,
-                    )
-                )
 
     async_add_entities(entities)
 

homeassistant/components/goodwe/sensor.py

@@ -243,7 +243,7 @@ def async_reset(self, now):
         In contrast to "total" sensors, these "daily" sensors need to be reset to 0 on midnight.
         """
         if not self.coordinator.last_update_success:
-            self.coordinator.reset_sensor(self._sensor.id)
+            self.coordinator.reset_sensor(self._sensor.id_)
             self.async_write_ha_state()
             _LOGGER.debug("Goodwe reset %s to 0", self.name)
         next_midnight = dt_util.start_of_local_day(

homeassistant/components/habitica/sensor.py

@@ -24,7 +24,7 @@
 SensorType = namedtuple("SensorType", ["name", "icon", "unit", "path"])
 
 SENSORS_TYPES = {
-    "name": SensorType("Name", None, "", ["profile", "name"]),
+    "name": SensorType("Name", None, None, ["profile", "name"]),
     "hp": SensorType("HP", "mdi:heart", "HP", ["stats", "hp"]),
     "maxHealth": SensorType("max HP", "mdi:heart", "HP", ["stats", "maxHealth"]),
     "mp": SensorType("Mana", "mdi:auto-fix", "MP", ["stats", "mp"]),
@@ -35,7 +35,7 @@
         "Lvl", "mdi:arrow-up-bold-circle-outline", "Lvl", ["stats", "lvl"]
     ),
     "gp": SensorType("Gold", "mdi:circle-multiple", "Gold", ["stats", "gp"]),
-    "class": SensorType("Class", "mdi:sword", "", ["stats", "class"]),
+    "class": SensorType("Class", "mdi:sword", None, ["stats", "class"]),
 }
 
 TASKS_TYPES = {