Use new mytoyota api endpoints

custom_components/toyota/__init__.py

@@ -5,42 +5,33 @@
 import asyncio.exceptions as asyncioexceptions
 import logging
 from datetime import timedelta
-from typing import Any, Optional, TypedDict
+from typing import Optional, TypedDict
 
 import httpcore
 import httpx
+from arrow import Arrow
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_EMAIL,
-    CONF_PASSWORD,
-    CONF_UNIT_SYSTEM_IMPERIAL,
-    CONF_UNIT_SYSTEM_METRIC,
-)
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from mytoyota import MyT
 from mytoyota.exceptions import ToyotaApiError, ToyotaInternalError, ToyotaLoginError
+from mytoyota.models.summary import Summary, SummaryType
 from mytoyota.models.vehicle import Vehicle
 
-from .const import (
-    CONF_UNIT_SYSTEM_IMPERIAL_LITERS,
-    CONF_USE_LITERS_PER_100_MILES,
-    DOMAIN,
-    PLATFORMS,
-    STARTUP_MESSAGE,
-)
+from .const import CONF_METRIC_VALUES, DOMAIN, PLATFORMS, STARTUP_MESSAGE
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class StatisticsData(TypedDict):
     """Representing Statistics data."""
 
-    day: list[dict[str, Any]]
-    week: list[dict[str, Any]]
-    month: list[dict[str, Any]]
-    year: list[dict[str, Any]]
+    day: Optional[Summary]
+    week: Optional[Summary]
+    month: Optional[Summary]
+    year: Optional[Summary]
 
 
 class VehicleData(TypedDict):
@@ -60,12 +51,11 @@ async def async_setup_entry(  # pylint: disable=too-many-statements
 
     email = entry.data[CONF_EMAIL]
     password = entry.data[CONF_PASSWORD]
-    use_liters = entry.options.get(CONF_USE_LITERS_PER_100_MILES, False)
+    use_metric_values = entry.options.get(CONF_METRIC_VALUES, True)
 
     client = MyT(
         username=email,
         password=password,
-        disable_locale_check=True,
     )
 
     try:
@@ -75,49 +65,52 @@ async def async_setup_entry(  # pylint: disable=too-many-statements
     except (httpx.ConnectTimeout, httpcore.ConnectTimeout) as ex:
         raise ConfigEntryNotReady("Unable to connect to Toyota Connected Services") from ex
 
-    async def async_get_vehicle_data() -> list[VehicleData]:
+    async def async_get_vehicle_data() -> Optional[list[VehicleData]]:
         """Fetch vehicle data from Toyota API."""
         try:
-            vehicles = await asyncio.wait_for(client.get_vehicles(), 15)
+            vehicles = await asyncio.wait_for(client.get_vehicles(metric=use_metric_values), 15)
             vehicle_informations: list[VehicleData] = []
-            for vehicle in vehicles:
-                vehicle_status = await client.get_vehicle_status(vehicle)
-                _LOGGER.debug(vars(vehicle_status))
-
-                vehicle_data = VehicleData(data=vehicle_status, statistics=None)
-
-                unit_system_map = {
-                    False: CONF_UNIT_SYSTEM_IMPERIAL,
-                    True: CONF_UNIT_SYSTEM_IMPERIAL_LITERS,
-                }
-                unit = CONF_UNIT_SYSTEM_METRIC if vehicle_status.dashboard.is_metric else unit_system_map[use_liters]
-
-                _LOGGER.debug(f"The car is reporting data in {unit}")
-                if use_liters and not vehicle_status.dashboard.is_metric:
-                    _LOGGER.debug("Getting statistics in imperial and L/100 miles")
-                elif not vehicle_status.dashboard.is_metric:
-                    _LOGGER.debug("Getting statistics in imperial and MPG")
-
-                if vehicle_status.is_connected_services_enabled and vehicle_status.vin is not None:
-                    # Use parallel request to get car statistics.
-                    driving_statistics = await asyncio.gather(
-                        client.get_driving_statistics(vehicle_status.vin, interval="day", unit=unit),
-                        client.get_driving_statistics(vehicle_status.vin, interval="isoweek", unit=unit),
-                        client.get_driving_statistics(vehicle_status.vin, unit=unit),
-                        client.get_driving_statistics(vehicle_status.vin, interval="year", unit=unit),
-                    )
-
-                    vehicle_data["statistics"] = StatisticsData(
-                        day=driving_statistics[0],
-                        week=driving_statistics[1],
-                        month=driving_statistics[2],
-                        year=driving_statistics[3],
-                    )
-
-                vehicle_informations.append(vehicle_data)
-
-            _LOGGER.debug(vehicle_informations)
-            return vehicle_informations
+            if vehicles is not None:
+                for vehicle in vehicles:
+                    await vehicle.update()
+                    vehicle_data = VehicleData(data=vehicle, statistics=None)
+
+                    if vehicle.vin is not None:
+                        # Use parallel request to get car statistics.
+                        driving_statistics = await asyncio.gather(
+                            vehicle.get_summary(
+                                Arrow.now().date(),
+                                Arrow.now().date(),
+                                summary_type=SummaryType.DAILY,
+                            ),
+                            vehicle.get_summary(
+                                Arrow.now().floor("week").date(),
+                                Arrow.now().date(),
+                                summary_type=SummaryType.WEEKLY,
+                            ),
+                            vehicle.get_summary(
+                                Arrow.now().floor("month").date(),
+                                Arrow.now().date(),
+                                summary_type=SummaryType.MONTHLY,
+                            ),
+                            vehicle.get_summary(
+                                Arrow.now().floor("year").date(),
+                                Arrow.now().date(),
+                                summary_type=SummaryType.YEARLY,
+                            ),
+                        )
+
+                        vehicle_data["statistics"] = StatisticsData(
+                            day=next(iter(driving_statistics[0] or []), None),
+                            week=next(iter(driving_statistics[1] or []), None),
+                            month=next(iter(driving_statistics[2] or []), None),
+                            year=next(iter(driving_statistics[3] or []), None),
+                        )
+
+                    vehicle_informations.append(vehicle_data)
+
+                _LOGGER.debug(vehicle_informations)
+                return vehicle_informations
 
         except ToyotaLoginError as ex:
             _LOGGER.error(ex)
@@ -132,9 +125,7 @@ async def async_get_vehicle_data() -> list[VehicleData]:
             asyncioexceptions.TimeoutError,
             httpx.ReadTimeout,
         ) as ex:
-            raise UpdateFailed(
-                "Update canceled! Toyota's API was too slow to respond." " Will try again later..."
-            ) from ex
+            raise UpdateFailed("Update canceled! Toyota's API was too slow to respond. Will try again later...") from ex
 
     coordinator = DataUpdateCoordinator(
         hass,

custom_components/toyota/config_flow.py

@@ -10,10 +10,7 @@
 from mytoyota.exceptions import ToyotaInvalidUsername, ToyotaLoginError
 
 # https://github.com/PyCQA/pylint/issues/3202
-from .const import (  # pylint: disable=unused-import
-    CONF_USE_LITERS_PER_100_MILES,
-    DOMAIN,
-)
+from .const import CONF_METRIC_VALUES, DOMAIN  # pylint: disable=unused-import
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,7 +38,6 @@ async def async_step_user(self, user_input=None) -> FlowResult:
                 client = MyT(
                     username=user_input[CONF_EMAIL],
                     password=user_input[CONF_PASSWORD],
-                    disable_locale_check=True,
                 )
 
                 await client.login()
@@ -86,8 +82,8 @@ async def async_step_init(self, user_input=None) -> FlowResult:
             data_schema=vol.Schema(
                 {
                     vol.Optional(
-                        CONF_USE_LITERS_PER_100_MILES,
-                        default=self.config_entry.options.get(CONF_USE_LITERS_PER_100_MILES, False),
+                        CONF_METRIC_VALUES,
+                        default=self.config_entry.options.get(CONF_METRIC_VALUES, True),
                     ): bool,
                 }
             ),

custom_components/toyota/const.py

@@ -15,7 +15,7 @@
     "europe",
 ]
 CONF_UNIT_SYSTEM_IMPERIAL_LITERS = "imperial_liters"
-CONF_USE_LITERS_PER_100_MILES = "use_liters"
+CONF_METRIC_VALUES = "use_metric_values"
 
 # DEFAULTS
 DEFAULT_LOCALE = "en-gb"
@@ -40,7 +40,6 @@
 HIGHWAY_DISTANCE = "highwayDistanceInKm"
 HIGHWAY_DISTANCE_PERCENTAGE = "highwayDistancePercentage"
 HYBRID = "hybrid"
-IMAGE = "imageUrl"
 LAST_UPDATED = "last_updated"
 LICENSE_PLATE = "licensePlate"
 MAX_SPEED = "maxSpeedInKmph"

custom_components/toyota/device_tracker.py

@@ -11,7 +11,7 @@
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from . import VehicleData
-from .const import DOMAIN, ICON_PARKING, IMAGE
+from .const import DOMAIN, ICON_PARKING
 from .entity import ToyotaBaseEntity
 
 PARKING_TRACKER_DESCRIPTION: EntityDescription = EntityDescription(
@@ -37,7 +37,7 @@ async def async_setup_entry(
             description=PARKING_TRACKER_DESCRIPTION,
         )
         for index, vehicle in enumerate(coordinator.data)
-        if vehicle["data"].is_connected_services_enabled and vehicle["data"].parkinglocation
+        if vehicle["data"].location
     )
 
 
@@ -49,14 +49,14 @@ class ToyotaParkingTracker(ToyotaBaseEntity, TrackerEntity):
     @property
     def latitude(self) -> Optional[float]:
         """Return latitude value of the device."""
-        parking = self.coordinator.data[self.index]["data"].parkinglocation
-        return parking.latitude if parking else None
+        location = self.vehicle.location
+        return location.latitude if location else None
 
     @property
     def longitude(self) -> Optional[float]:
         """Return longitude value of the device."""
-        parking = self.coordinator.data[self.index]["data"].parkinglocation
-        return parking.longitude if parking else None
+        location = self.vehicle.location
+        return location.longitude if location else None
 
     @property
     def source_type(self) -> str:
@@ -66,4 +66,4 @@ def source_type(self) -> str:
     @property
     def entity_picture(self) -> Optional[str]:
         """Return entity picture."""
-        return self.vehicle.details.get(IMAGE)
+        return self.vehicle._vehicle_info.image

custom_components/toyota/entity.py

@@ -1,6 +1,8 @@
 """Custom coordinator entity base classes for Toyota Connected Services integration."""
 from __future__ import annotations
 
+from typing import Optional
+
 from homeassistant.core import callback
 from homeassistant.helpers.entity import DeviceInfo, EntityDescription
 from homeassistant.helpers.update_coordinator import (
@@ -9,7 +11,7 @@
 )
 from mytoyota.models.vehicle import Vehicle
 
-from . import VehicleData
+from . import StatisticsData, VehicleData
 from .const import DOMAIN
 
 
@@ -29,22 +31,23 @@ def __init__(
         super().__init__(coordinator)
 
         self.index = vehicle_index
+        self.entity_description = description
         self.vehicle: Vehicle = coordinator.data[self.index]["data"]
+        self.statistics: Optional[StatisticsData] = coordinator.data[self.index]["statistics"]
 
-        self._attr_unique_id = f"{entry_id}_{self.vehicle.vin}/{description.key}"
-
+        self._attr_unique_id = f"{entry_id}_{self.vehicle.vin}/{self.entity_description.key}"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, self.vehicle.vin)},
             name=self.vehicle.alias,
-            model=self.vehicle.details.get("modelName"),
-            manufacturer=DOMAIN.capitalize(),
+            model=self.vehicle._vehicle_info.car_model_name,
+            manufacturer=self.vehicle._vehicle_info.brand,
         )
-        self.entity_description = description
 
     @callback
     def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
         self.vehicle = self.coordinator.data[self.index]["data"]
+        self.statistics = self.coordinator.data[self.index]["statistics"]
         super()._handle_coordinator_update()
 
     async def async_added_to_hass(self) -> None:

custom_components/toyota/manifest.json

@@ -1,12 +1,20 @@
 {
   "domain": "toyota",
   "name": "Toyota Connected Services",
-  "after_dependencies": ["cloud", "http"],
-  "codeowners": ["@DurgNomis-drol"],
+  "after_dependencies": [
+    "cloud",
+    "http"
+  ],
+  "codeowners": [
+    "@DurgNomis-drol"
+  ],
   "config_flow": true,
   "documentation": "https://github.com/DurgNomis-drol/ha_toyota",
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/DurgNomis-drol/ha_toyota/issues",
-  "requirements": ["mytoyota==0.9.3", "arrow"],
-  "version": "v1.3.0"
+  "requirements": [
+    "mytoyota>=1.1",
+    "arrow"
+  ],
+  "version": "v2.0.0"
 }