carconnectivity-connector-skoda 0.1a8__tar.gz → 0.1a10__tar.gz

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: carconnectivity-connector-skoda
-Version: 0.1a8
+Version: 0.1a10
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/setup_requirements.txt

@@ -1,3 +1,3 @@
 flake8~=7.1.1
-pylint~=3.3.2
+pylint~=3.3.3
 bandit~=1.8.0

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/src/carconnectivity_connector_skoda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: carconnectivity-connector-skoda
-Version: 0.1a8
+Version: 0.1a10
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/src/carconnectivity_connector_skoda.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ src/carconnectivity_connector_skoda.egg-info/top_level.txt
 src/carconnectivity_connectors/skoda/__init__.py
 src/carconnectivity_connectors/skoda/_version.py
 src/carconnectivity_connectors/skoda/capability.py
+src/carconnectivity_connectors/skoda/charging.py
 src/carconnectivity_connectors/skoda/connector.py
 src/carconnectivity_connectors/skoda/mqtt_client.py
 src/carconnectivity_connectors/skoda/vehicle.py

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/src/carconnectivity_connectors/skoda/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1a8'
+__version__ = version = '0.1a10'
 __version_tuple__ = version_tuple = (0, 1)

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/src/carconnectivity_connectors/skoda/auth/openid_session.py

@@ -112,6 +112,10 @@ class OpenIDSession(requests.Session):
         if new_retries_value:
             # Retry on internal server error (500)
             retries = BlacklistRetry(total=new_retries_value,
+                                     connect=new_retries_value,
+                                     read=new_retries_value,
+                                     status=new_retries_value,
+                                     other=new_retries_value,
                                      backoff_factor=0.1,
                                      status_forcelist=[500],
                                      status_blacklist=[429],

carconnectivity_connector_skoda-0.1a10/src/carconnectivity_connectors/skoda/charging.py

@@ -0,0 +1,67 @@
+"""
+Module for charging for skoda vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import Enum
+
+from carconnectivity.charging import Charging
+
+if TYPE_CHECKING:
+    from typing import Dict
+
+
+class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
+    """
+    SkodaCharging class for handling Skoda vehicle charging information.
+
+    This class extends the Charging class and includes an enumeration of various 
+    charging states specific to Skoda vehicles.
+    """
+    class SkodaChargingState(Enum,):
+        """
+        Enum representing the various charging states for a Skoda vehicle.
+
+        Attributes:
+            OFF: The vehicle is not charging.
+            READY_FOR_CHARGING: The vehicle is ready to start charging.
+            NOT_READY_FOR_CHARGING: The vehicle is not ready to start charging.
+            CONSERVATION: The vehicle is in conservation mode.
+            CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING: The vehicle has reached its charging purpose and is not in conservation charging mode.
+            CHARGE_PURPOSE_REACHED_CONSERVATION: The vehicle has reached its charging purpose and is in conservation charging mode.
+            CHARGING: The vehicle is currently charging.
+            ERROR: There is an error in the charging process.
+            UNSUPPORTED: The charging state is unsupported.
+            DISCHARGING: The vehicle is discharging.
+            UNKNOWN: The charging state is unknown.
+        """
+        OFF = 'off'
+        CONNECT_CABLE = 'connectCable'
+        READY_FOR_CHARGING = 'readyForCharging'
+        NOT_READY_FOR_CHARGING = 'notReadyForCharging'
+        CONSERVATION = 'conservation'
+        CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING = 'chargePurposeReachedAndNotConservationCharging'
+        CHARGE_PURPOSE_REACHED_CONSERVATION = 'chargePurposeReachedAndConservation'
+        CHARGING = 'charging'
+        ERROR = 'error'
+        UNSUPPORTED = 'unsupported'
+        DISCHARGING = 'discharging'
+        UNKNOWN = 'unknown charging state'
+
+
+# Mapping of Skoda charging states to generic charging states
+mapping_skoda_charging_state: Dict[SkodaCharging.SkodaChargingState, Charging.ChargingState] = {
+    SkodaCharging.SkodaChargingState.OFF: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.CONNECT_CABLE: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.READY_FOR_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SkodaCharging.SkodaChargingState.NOT_READY_FOR_CHARGING: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.CONSERVATION: Charging.ChargingState.CONSERVATION,
+    SkodaCharging.SkodaChargingState.CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SkodaCharging.SkodaChargingState.CHARGE_PURPOSE_REACHED_CONSERVATION: Charging.ChargingState.CONSERVATION,
+    SkodaCharging.SkodaChargingState.CHARGING: Charging.ChargingState.CHARGING,
+    SkodaCharging.SkodaChargingState.ERROR: Charging.ChargingState.ERROR,
+    SkodaCharging.SkodaChargingState.UNSUPPORTED: Charging.ChargingState.UNSUPPORTED,
+    SkodaCharging.SkodaChargingState.DISCHARGING: Charging.ChargingState.DISCHARGING,
+    SkodaCharging.SkodaChargingState.UNKNOWN: Charging.ChargingState.UNKNOWN
+}

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/src/carconnectivity_connectors/skoda/connector.py

@@ -6,7 +6,7 @@ import threading
 import os
 import logging
 import netrc
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 import requests
 
 from carconnectivity.garage import Garage
@@ -14,18 +14,22 @@ from carconnectivity.vehicle import GenericVehicle
 from carconnectivity.errors import AuthenticationError, TooManyRequestsError, RetrievalError, APIError, APICompatibilityError, \
     TemporaryAuthenticationError, ConfigurationError
 from carconnectivity.util import robust_time_parse, log_extra_keys, config_remove_credentials
-from carconnectivity.units import Length, Speed, Power
+from carconnectivity.units import Length, Speed, Power, Temperature
 from carconnectivity.doors import Doors
 from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
 from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
 from carconnectivity.attributes import BooleanAttribute, DurationAttribute
+from carconnectivity.charging import Charging
+from carconnectivity.position import Position
+from carconnectivity.climatization import Climatization
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
 from carconnectivity_connectors.skoda.auth.my_skoda_session import MySkodaSession
 from carconnectivity_connectors.skoda.vehicle import SkodaVehicle, SkodaElectricVehicle, SkodaCombustionVehicle, SkodaHybridVehicle
 from carconnectivity_connectors.skoda.capability import Capability
+from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
 from carconnectivity_connectors.skoda._version import __version__
 from carconnectivity_connectors.skoda.mqtt_client import SkodaMQTTClient
 
@@ -150,12 +154,17 @@ class Connector(BaseConnector):
 
     def _background_loop(self) -> None:
         self._stop_event.clear()
+        fetch: bool = True
         while not self._stop_event.is_set():
             interval = 300
             try:
                 try:
-                    self.fetch_all()
-                    self.last_update._set_value(value=datetime.now())  # pylint: disable=protected-access
+                    if fetch:
+                        self.fetch_all()
+                        fetch = False
+                    else:
+                        self.update_vehicles()
+                    self.last_update._set_value(value=datetime.now(tz=timezone.utc))  # pylint: disable=protected-access
                     if self.interval.value is not None:
                         interval: int = self.interval.value.total_seconds()
                 except Exception:
@@ -267,15 +276,41 @@ class Connector(BaseConnector):
                             vehicle.license_plate._set_value(None)  # pylint: disable=protected-access
 
                         log_extra_keys(LOG_API, 'vehicles', vehicle_dict,  {'vin', 'licensePlate'})
-                        vehicle = self.fetch_vehicle_status(vehicle)
-                        if isinstance(vehicle, SkodaElectricVehicle):
-                            vehicle = self.fetch_charging(vehicle)
+
+                        vehicle = self.fetch_vehicle_details(vehicle)
                     else:
                         raise APIError('Could not parse vehicle, vin missing')
         for vin in set(garage.list_vehicle_vins()) - seen_vehicle_vins:
             vehicle_to_remove = garage.get_vehicle(vin)
             if vehicle_to_remove is not None and vehicle_to_remove.is_managed_by_connector(self):
                 garage.remove_vehicle(vin)
+        self.update_vehicles()
+
+    def update_vehicles(self) -> None:
+        """
+        Updates the status of all vehicles in the garage managed by this connector.
+
+        This method iterates through all vehicle VINs in the garage, and for each vehicle that is
+        managed by this connector and is an instance of SkodaVehicle, it updates the vehicle's status
+        by fetching data from various APIs. If the vehicle is an instance of SkodaElectricVehicle,
+        it also fetches charging information.
+
+        Returns:
+            None
+        """
+        garage: Garage = self.car_connectivity.garage
+        for vin in set(garage.list_vehicle_vins()):
+            vehicle_to_update: Optional[GenericVehicle] = garage.get_vehicle(vin)
+            if vehicle_to_update is not None and isinstance(vehicle_to_update, SkodaVehicle) and vehicle_to_update.is_managed_by_connector(self):
+                vehicle_to_update = self.fetch_vehicle_status_second_api(vehicle_to_update)
+                vehicle_to_update = self.fetch_driving_range(vehicle_to_update)
+                if vehicle_to_update.capabilities is not None and vehicle_to_update.capabilities.enabled:
+                    if vehicle_to_update.capabilities.has_capability('PARKING_POSITION'):
+                        vehicle_to_update = self.fetch_position(vehicle_to_update)
+                    if vehicle_to_update.capabilities.has_capability('CHARGING') and isinstance(vehicle_to_update, SkodaElectricVehicle):
+                        vehicle_to_update = self.fetch_charging(vehicle_to_update)
+                    if vehicle_to_update.capabilities.has_capability('AIR_CONDITIONING'):
+                        vehicle_to_update = self.fetch_air_conditioning(vehicle_to_update)
 
     def fetch_charging(self, vehicle: SkodaElectricVehicle) -> SkodaElectricVehicle:
         """
@@ -301,6 +336,18 @@ class Connector(BaseConnector):
             else:
                 raise APIError('Could not fetch charging, carCapturedTimestamp missing')
             if 'status' in data and data['status'] is not None:
+                if 'state' in data['status'] and data['status']['state'] is not None:
+                    if data['status']['state'] in [item.name for item in SkodaCharging.SkodaChargingState]:
+                        skoda_charging_state = SkodaCharging.SkodaChargingState[data['status']['state']]
+                        charging_state: Charging.ChargingState = mapping_skoda_charging_state[skoda_charging_state]
+                    else:
+                        LOG_API.info('Unkown charging state %s not in %s', data['status']['state'], str(SkodaCharging.SkodaChargingState))
+                        charging_state = Charging.ChargingState.UNKNOWN
+
+                    # pylint: disable-next=protected-access
+                    vehicle.charging.state._set_value(value=charging_state, measured=captured_at)
+                else:
+                    vehicle.charging.state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 if 'chargingRateInKilometersPerHour' in data['status'] and data['status']['chargingRateInKilometersPerHour'] is not None:
                     # pylint: disable-next=protected-access
                     vehicle.charging.rate._set_value(value=data['status']['chargingRateInKilometersPerHour'], measured=captured_at, unit=Speed.KMH)
@@ -313,19 +360,178 @@ class Connector(BaseConnector):
                     vehicle.charging.power._set_value(None, measured=captured_at, unit=Power.KW)  # pylint: disable=protected-access
                 if 'remainingTimeToFullyChargedInMinutes' in data['status'] and data['status']['remainingTimeToFullyChargedInMinutes'] is not None:
                     remaining_duration: timedelta = timedelta(minutes=data['status']['remainingTimeToFullyChargedInMinutes'])
+                    estimated_date_reached: datetime = captured_at + remaining_duration
                     # pylint: disable-next=protected-access
-                    vehicle.charging.remaining_duration._set_value(value=remaining_duration, measured=captured_at)
+                    vehicle.charging.estimated_date_reached._set_value(value=estimated_date_reached, measured=captured_at)
                 else:
-                    vehicle.charging.remaining_duration._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                    vehicle.charging.estimated_date_reached._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 log_extra_keys(LOG_API, 'status', data['status'],  {'chargingRateInKilometersPerHour',
                                                                     'chargePowerInKw',
-                                                                    'remainingTimeToFullyChargedInMinutes'})
+                                                                    'remainingTimeToFullyChargedInMinutes',
+                                                                    'state'})
             log_extra_keys(LOG_API, 'charging data', data,  {'carCapturedTimestamp', 'status'})
         return vehicle
 
-    def fetch_vehicle_status(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+    def fetch_position(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the position of the given Skoda vehicle and updates its position attributes.
+
+        Args:
+            vehicle (SkodaVehicle): The Skoda vehicle object containing the VIN and position attributes.
+
+        Returns:
+            SkodaVehicle: The updated Skoda vehicle object with the fetched position data.
+
+        Raises:
+            APIError: If the VIN is missing.
+            ValueError: If the vehicle has no position object.
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
+        if vehicle.position is None:
+            raise ValueError('Vehicle has no charging object')
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/maps/positions?vin={vin}'
+        data: Dict[str, Any] | None = self._fetch_data(url, session=self.session)
+        if data is not None:
+            if 'positions' in data and data['positions'] is not None:
+                for position_dict in data['positions']:
+                    if 'type' in position_dict and position_dict['type'] == 'VEHICLE':
+                        if 'gpsCoordinates' in position_dict and position_dict['gpsCoordinates'] is not None:
+                            if 'latitude' in position_dict['gpsCoordinates'] and position_dict['gpsCoordinates']['latitude'] is not None:
+                                latitude: Optional[float] = position_dict['gpsCoordinates']['latitude']
+                            else:
+                                latitude = None
+                            if 'longitude' in position_dict['gpsCoordinates'] and position_dict['gpsCoordinates']['longitude'] is not None:
+                                longitude: Optional[float] = position_dict['gpsCoordinates']['longitude']
+                            else:
+                                longitude = None
+                            vehicle.position.latitude._set_value(latitude)  # pylint: disable=protected-access
+                            vehicle.position.longitude._set_value(longitude)  # pylint: disable=protected-access
+                            vehicle.position.position_type._set_value(Position.PositionType.PARKING)  # pylint: disable=protected-access
+                        else:
+                            vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
+                            vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
+                            vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
+                    else:
+                        vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
+                        vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
+                        vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
+                    log_extra_keys(LOG_API, 'positions', position_dict,  {'type',
+                                                                          'gpsCoordinates',
+                                                                          'address'})
+            else:
+                vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
+                vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
+                vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
+        return vehicle
+
+    def fetch_air_conditioning(self, vehicle: SkodaVehicle) -> SkodaVehicle:
         """
-        Fetches the status of a vehicle from the Skoda API.
+        Fetches the air conditioning data for a given Skoda vehicle and updates the vehicle object with the retrieved data.
+
+        Args:
+            vehicle (SkodaVehicle): The vehicle object for which to fetch air conditioning data.
+
+        Returns:
+            SkodaVehicle: The updated vehicle object with the fetched air conditioning data.
+
+        Raises:
+            APIError: If the VIN is missing or if the carCapturedTimestamp is missing in the response data.
+            ValueError: If the vehicle has no charging object.
+
+        Notes:
+            - The method fetches data from the Skoda API using the vehicle's VIN.
+            - It updates the vehicle's climatization state, estimated date to reach target temperature, target temperature, and outside temperature.
+            - Logs additional keys found in the response data for debugging purposes.
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
+        if vehicle.position is None:
+            raise ValueError('Vehicle has no charging object')
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}'
+        data: Dict[str, Any] | None = self._fetch_data(url, session=self.session)
+        if data is not None:
+            if 'carCapturedTimestamp' in data and data['carCapturedTimestamp'] is not None:
+                captured_at: datetime = robust_time_parse(data['carCapturedTimestamp'])
+            else:
+                raise APIError('Could not fetch air conditioning, carCapturedTimestamp missing')
+            if 'state' in data and data['state'] is not None:
+                if data['state'] in [item.name for item in Climatization.ClimatizationState]:
+                    climatization_state: Climatization.ClimatizationState = Climatization.ClimatizationState[data['state']]
+                else:
+                    LOG_API.info('Unknown climatization state %s not in %s', data['state'], str(Climatization.ClimatizationState))
+                    climatization_state = Climatization.ClimatizationState.UNKNOWN
+                vehicle.climatization.state._set_value(value=climatization_state, measured=captured_at)  # pylint: disable=protected-access
+            else:
+                vehicle.climatization.state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+            if 'estimatedDateTimeToReachTargetTemperature' in data and data['estimatedDateTimeToReachTargetTemperature'] is not None:
+                estimated_reach: datetime = robust_time_parse(data['estimatedDateTimeToReachTargetTemperature'])
+                if estimated_reach is not None:
+                    vehicle.climatization.estimated_date_reached._set_value(value=estimated_reach, measured=captured_at)  # pylint: disable=protected-access
+                else:
+                    vehicle.climatization.estimated_date_reached._set_value(value=None, measured=captured_at)  # pylint: disable=protected-access
+            else:
+                vehicle.climatization.estimated_date_reached._set_value(value=None, measured=captured_at)  # pylint: disable=protected-access
+            if 'targetTemperature' in data and data['targetTemperature'] is not None:
+                unit: Temperature = Temperature.UNKNOWN
+                if 'unitInCar' in data['targetTemperature'] and data['targetTemperature']['unitInCar'] is not None:
+                    if data['targetTemperature']['unitInCar'] == 'CELSIUS':
+                        unit = Temperature.C
+                    elif data['targetTemperature']['unitInCar'] == 'FAHRENHEIT':
+                        unit = Temperature.F
+                    elif data['targetTemperature']['unitInCar'] == 'KELVIN':
+                        unit = Temperature.K
+                    else:
+                        LOG_API.info('Unknown temperature unit for targetTemperature in air-conditioning %s', data['targetTemperature']['unitInCar'])
+                if 'temperatureValue' in data['targetTemperature'] and data['targetTemperature']['temperatureValue'] is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.target_temperature._set_value(value=data['targetTemperature']['temperatureValue'],
+                                                                        measured=captured_at,
+                                                                        unit=unit)
+                else:
+                    vehicle.climatization.target_temperature._set_value(value=None, measured=captured_at, unit=unit)  # pylint: disable=protected-access
+                log_extra_keys(LOG_API, 'targetTemperature', data['targetTemperature'],  {'unitInCar', 'temperatureValue'})
+            else:
+                # pylint: disable-next=protected-access
+                vehicle.climatization.target_temperature._set_value(value=None, measured=captured_at, unit=Temperature.UNKNOWN)
+            if 'outsideTemperature' in data and data['outsideTemperature'] is not None:
+                if 'carCapturedTimestamp' in data['outsideTemperature'] and data['outsideTemperature']['carCapturedTimestamp'] is not None:
+                    outside_captured_at: datetime = robust_time_parse(data['outsideTemperature']['carCapturedTimestamp'])
+                else:
+                    outside_captured_at = captured_at
+                if 'temperatureUnit' in data['outsideTemperature'] and data['outsideTemperature']['temperatureUnit'] is not None:
+                    unit: Temperature = Temperature.UNKNOWN
+                    if data['outsideTemperature']['temperatureUnit'] == 'CELSIUS':
+                        unit = Temperature.C
+                    elif data['outsideTemperature']['temperatureUnit'] == 'FAHRENHEIT':
+                        unit = Temperature.F
+                    elif data['outsideTemperature']['temperatureUnit'] == 'KELVIN':
+                        unit = Temperature.K
+                    else:
+                        LOG_API.info('Unknown temperature unit for outsideTemperature in air-conditioning %s', data['targetTemperature']['temperatureUnit'])
+                    if 'temperatureValue' in data['outsideTemperature'] and data['outsideTemperature']['temperatureValue'] is not None:
+                        # pylint: disable-next=protected-access
+                        vehicle.outside_temperature._set_value(value=data['outsideTemperature']['temperatureValue'],
+                                                               measured=outside_captured_at,
+                                                               unit=unit)
+                    else:
+                        # pylint: disable-next=protected-access
+                        vehicle.outside_temperature._set_value(value=None, measured=outside_captured_at, unit=Temperature.UNKNOWN)
+                else:
+                    # pylint: disable-next=protected-access
+                    vehicle.outside_temperature._set_value(value=None, measured=outside_captured_at, unit=Temperature.UNKNOWN)
+                log_extra_keys(LOG_API, 'targetTemperature', data['outsideTemperature'],  {'carCapturedTimestamp', 'temperatureUnit', 'temperatureValue'})
+            else:
+                vehicle.outside_temperature._set_value(value=None, measured=None, unit=Temperature.UNKNOWN)  # pylint: disable=protected-access
+            log_extra_keys(LOG_API, 'air-condition', data,  {'carCapturedTimestamp', 'state', 'estimatedDateTimeToReachTargetTemperature'
+                                                             'targetTemperature', 'outsideTemperature'})
+        return vehicle
+
+    def fetch_vehicle_details(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the details of a vehicle from the Skoda API.
 
         Args:
             vehicle (GenericVehicle): The vehicle object containing the VIN.
@@ -374,7 +580,30 @@ class Connector(BaseConnector):
             else:
                 vehicle.model._set_value(None)  # pylint: disable=protected-access
             log_extra_keys(LOG_API, 'api/v2/garage/vehicles/VIN', vehicle_data, {'softwareVersion'})
+        return vehicle
 
+    def fetch_driving_range(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the driving range data for a given Skoda vehicle and updates the vehicle object accordingly.
+
+        Args:
+            vehicle (SkodaVehicle): The Skoda vehicle object for which to fetch the driving range data.
+
+        Returns:
+            SkodaVehicle: The updated Skoda vehicle object with the fetched driving range data.
+
+        Raises:
+            APIError: If the vehicle's VIN is missing.
+
+        Notes:
+            - The method fetches data from the Skoda API using the vehicle's VIN.
+            - It updates the vehicle's type if the fetched data indicates a different type (e.g., electric, combustion, hybrid).
+            - It updates the vehicle's total range and individual drive ranges (primary and secondary) based on the fetched data.
+            - It logs warnings for unknown car types and engine types.
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}/driving-range'
         range_data: Dict[str, Any] | None = self._fetch_data(url, self.session)
         if range_data:
@@ -461,7 +690,21 @@ class Connector(BaseConnector):
                                                                                                'totalRangeInKm',
                                                                                                'primaryEngineRange',
                                                                                                'secondaryEngineRange'})
+        return vehicle
+
+    def fetch_vehicle_status_second_api(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the status of a vehicle from other Skoda API.
+
+        Args:
+            vehicle (GenericVehicle): The vehicle object containing the VIN.
 
+        Returns:
+            None
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
         url = f'https://api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}'
         vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url, self.session)
         if vehicle_status_data:

{carconnectivity_connector_skoda-0.1a8 → carconnectivity_connector_skoda-0.1a10}/src/carconnectivity_connectors/skoda/mqtt_client.py

@@ -7,15 +7,21 @@ import logging
 import uuid
 import ssl
 import json
-from datetime import timedelta
+from datetime import timedelta, timezone
 
 from paho.mqtt.client import Client
 from paho.mqtt.enums import MQTTProtocolVersion, CallbackAPIVersion, MQTTErrorCode
 
+from carconnectivity.errors import CarConnectivityError
 from carconnectivity.observable import Observable
-from carconnectivity.vehicle import GenericVehicle, ElectricVehicle
+from carconnectivity.vehicle import GenericVehicle
+
 from carconnectivity.drive import ElectricDrive
 from carconnectivity.util import robust_time_parse, log_extra_keys
+from carconnectivity.charging import Charging
+
+from carconnectivity_connectors.skoda.vehicle import SkodaVehicle, SkodaElectricVehicle
+from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
 
 
 if TYPE_CHECKING:
@@ -101,7 +107,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         if (flags & Observable.ObserverEvent.ENABLED) and isinstance(element, GenericVehicle):
             self._subscribe_vehicle(element)
         elif (flags & Observable.ObserverEvent.DISABLED) and isinstance(element, GenericVehicle):
-            self._subscribe_vehicle(element)
+            self._unsubscribe_vehicle(element)
 
     def _subscribe_vehicles(self) -> None:
         """
@@ -235,15 +241,12 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             - Warning if the vehicle's VIN is not enabled or is None.
             - Info for each topic successfully unsubscribed.
         """
-        if not vehicle.vin.enabled or vehicle.vin.value is None:
-            LOG.warning('Could not unsubscribe to vehicle without vin')
-        else:
-            vin: str = vehicle.vin.value
-            for topic in self.subscribed_topics:
-                if vin in topic:
-                    self.unsubscribe(topic)
-                    self.subscribed_topics.remove(topic)
-                    LOG.debug('Unsubscribed from topic %s', topic)
+        vin: str = vehicle.id
+        for topic in self.subscribed_topics:
+            if vin in topic:
+                self.unsubscribe(topic)
+                self.subscribed_topics.remove(topic)
+                LOG.debug('Unsubscribed from topic %s', topic)
 
     def _on_connect_callback(self, mqttc, obj, flags, reason_code, properties) -> None:
         """
@@ -434,7 +437,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             return
 
         # service_events
-        match = re.match(r'^(?P<user_id>[0-9a-fA-F-]+)/(?P<vin>[A-Z0-9]+)/service-event/(?P<service_event>\w+)$', msg.topic)
+        match = re.match(r'^(?P<user_id>[0-9a-fA-F-]+)/(?P<vin>[A-Z0-9]+)/service-event/(?P<service_event>[a-zA-Z0-9-_]+)$', msg.topic)
         if match:
             user_id: str = match.group('user_id')
             vin: str = match.group('vin')
@@ -444,30 +447,93 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                 if 'timestamp' in data and data['timestamp'] is not None:
                     measured_at: datetime = robust_time_parse(data['timestamp'])
                 else:
-                    measured_at: datetime = datetime.now()
+                    measured_at: datetime = datetime.now(tz=timezone.utc)
                 if service_event == 'charging':
                     if 'name' in data and data['name'] == 'change-charge-mode' or data['name'] == 'change-soc':
                         if 'data' in data and data['data'] is not None:
                             vehicle: Optional[GenericVehicle] = self._skoda_connector.car_connectivity.garage.get_vehicle(vin)
-                            if isinstance(vehicle, ElectricVehicle):
+                            if isinstance(vehicle, SkodaElectricVehicle):
                                 electric_drive: ElectricDrive = vehicle.get_electric_drive()
                                 if electric_drive is not None:
+                                    charging_state: Optional[Charging.ChargingState] = vehicle.charging.state.value
+                                    old_charging_state: Optional[Charging.ChargingState] = charging_state
+                                    if 'state' in data['data'] and data['data']['state'] is not None:
+                                        if data['data']['state'] in [item.value for item in SkodaCharging.SkodaChargingState]:
+                                            skoda_charging_state = SkodaCharging.SkodaChargingState(data['data']['state'])
+                                            charging_state = mapping_skoda_charging_state[skoda_charging_state]
+                                        else:
+                                            LOG_API.info('Unkown charging state %s not in %s', data['data']['state'], str(SkodaCharging.SkodaChargingState))
+                                            charging_state = Charging.ChargingState.UNKNOWN
+                                        # pylint: disable-next=protected-access
+                                        vehicle.charging.state._set_value(value=charging_state, measured=measured_at)
+                                        if charging_state == Charging.ChargingState.OFF:
+                                            # pylint: disable-next=protected-access
+                                            vehicle.charging.type._set_value(value=Charging.ChargingType.OFF, measured=measured_at)
+                                            # pylint: disable-next=protected-access
+                                            vehicle.charging.rate._set_value(value=0, measured=measured_at)
+                                            # pylint: disable-next=protected-access
+                                            vehicle.charging.power._set_value(value=0, measured=measured_at)
                                     if 'soc' in data['data'] and data['data']['soc'] is not None:
                                         electric_drive.level._set_value(measured=measured_at, value=data['data']['soc'])  # pylint: disable=protected-access
                                     if 'chargedRange' in data['data'] and data['data']['chargedRange'] is not None:
                                         # pylint: disable-next=protected-access
                                         electric_drive.range._set_value(measured=measured_at, value=data['data']['chargedRange'])
+                                    # If charging state changed, fetch charging again
+                                    if old_charging_state != charging_state:
+                                        try:
+                                            self._skoda_connector.fetch_charging(vehicle)
+                                        except CarConnectivityError as e:
+                                            LOG.error('Error while fetching charging: %s', e)
                                 if 'timeToFinish' in data['data'] and data['data']['timeToFinish'] is not None \
                                         and vehicle.charging is not None:
-                                    remaining_duration: timedelta = timedelta(minutes=int(data['data']['timeToFinish']))
+                                    try:
+                                        remaining_duration: Optional[timedelta] = timedelta(minutes=int(data['data']['timeToFinish']))
+                                        estimated_date_reached: Optional[datetime] = measured_at + remaining_duration
+                                    except ValueError:
+                                        estimated_date_reached: Optional[datetime] = None
                                     # pylint: disable-next=protected-access
-                                    vehicle.charging.remaining_duration._set_value(measured=measured_at, value=remaining_duration)
-                                log_extra_keys(LOG_API, 'data', data['data'],  {'vin', 'userId', 'soc', 'chargedRange', 'timeToFinish'})
+                                    vehicle.charging.estimated_date_reached._set_value(measured=measured_at, value=estimated_date_reached)
+                                log_extra_keys(LOG_API, 'data', data['data'],  {'vin', 'userId', 'soc', 'chargedRange', 'timeToFinish', 'state'})
                                 LOG.debug('Received %s event for vehicle %s from user %s', data['name'], vin, user_id)
                                 return
+                            else:
+                                LOG.debug('Discarded %s event for vehicle %s from user %s: vehicle is not an electric vehicle', data['name'], vin, user_id)
+                    LOG_API.info('Received event name %s service event %s for vehicle %s from user %s: %s', data['name'],
+                                 service_event, vin, user_id, msg.payload)
+                    return
+                elif service_event == 'air-conditioning':
+                    if 'name' in data and data['name'] == 'change-remaining-time':
+                        if 'data' in data and data['data'] is not None:
+                            vehicle: Optional[GenericVehicle] = self._skoda_connector.car_connectivity.garage.get_vehicle(vin)
+                            if isinstance(vehicle, SkodaVehicle):
+                                try:
+                                    self._skoda_connector.fetch_air_conditioning(vehicle)
+                                except CarConnectivityError as e:
+                                    LOG.error('Error while fetching charging: %s', e)
                     LOG_API.info('Received event name %s service event %s for vehicle %s from user %s: %s', data['name'],
                                  service_event, vin, user_id, msg.payload)
                     return
             LOG_API.info('Received unknown service event %s for vehicle %s from user %s: %s', service_event, vin, user_id, msg.payload)
             return
+        # service_events
+        match = re.match(r'^(?P<user_id>[0-9a-fA-F-]+)/(?P<vin>[A-Z0-9]+)/operation-request/(?P<operation_request>[a-zA-Z0-9-_/]+)$', msg.topic)
+        if match:
+            user_id: str = match.group('user_id')
+            vin: str = match.group('vin')
+            operation_request: str = match.group('operation_request')
+            data: Dict[str, Any] = json.loads(msg.payload)
+            if data is not None:
+                if operation_request == 'air-conditioning/start-stop-air-conditioning':
+                    vehicle: Optional[GenericVehicle] = self._skoda_connector.car_connectivity.garage.get_vehicle(vin)
+                    if isinstance(vehicle, SkodaVehicle):
+                        if 'status' in data and data['status'] is not None:
+                            if data['status'] == 'COMPLETED_SUCCESS':
+                                LOG.debug('Received %s operation request for vehicle %s from user %s', operation_request, vin, user_id)
+                                try:
+                                    self._skoda_connector.fetch_air_conditioning(vehicle)
+                                except CarConnectivityError as e:
+                                    LOG.error('Error while fetching air-conditioning: %s', e)
+                                return
+                    LOG_API.info('Received unknown operation request %s for vehicle %s from user %s: %s', operation_request, vin, user_id, msg.payload)
+                    return
         LOG_API.info('I don\'t understand message %s: %s', msg.topic, msg.payload)