carconnectivity-connector-skoda 0.1a16__tar.gz → 0.1a18__tar.gz

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a18}/PKG-INFO

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

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a18}/src/carconnectivity_connector_skoda.egg-info/PKG-INFO

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

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a18}/src/carconnectivity_connector_skoda.egg-info/SOURCES.txt

@@ -21,7 +21,9 @@ 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/climatization.py
 src/carconnectivity_connectors/skoda/connector.py
+src/carconnectivity_connectors/skoda/error.py
 src/carconnectivity_connectors/skoda/mqtt_client.py
 src/carconnectivity_connectors/skoda/vehicle.py
 src/carconnectivity_connectors/skoda/auth/__init__.py

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a18}/src/carconnectivity_connectors/skoda/_version.py

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

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

@@ -0,0 +1,137 @@
+"""
+Module for charging for skoda vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import Enum
+
+from carconnectivity.charging import Charging
+from carconnectivity.objects import GenericObject
+from carconnectivity.vehicle import ElectricVehicle
+from carconnectivity.attributes import BooleanAttribute, EnumAttribute, StringAttribute
+
+from carconnectivity_connectors.skoda.error import Error
+
+if TYPE_CHECKING:
+    from typing import Optional, 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.
+    """
+    def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Charging] = None) -> None:
+        if origin is not None:
+            super().__init__(origin=origin)
+            self.settings: Charging.Settings = SkodaCharging.Settings(origin=origin.settings)
+        else:
+            super().__init__(vehicle=vehicle)
+            self.settings: Charging.Settings = SkodaCharging.Settings(origin=self.settings)
+        self.errors: Dict[str, Error] = {}
+        self.is_in_saved_location: BooleanAttribute = BooleanAttribute("is_in_saved_location", parent=self)
+
+    class Settings(Charging.Settings):
+        """
+        This class represents the settings for a skoda car charging.
+        """
+        def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Charging.Settings] = None) -> None:
+            if origin is not None:
+                super().__init__(origin=origin)
+            else:
+                super().__init__(parent=parent)
+            self.preferred_charge_mode: EnumAttribute = EnumAttribute("preferred_charge_mode", parent=self)
+            self.available_charge_modes: StringAttribute = StringAttribute("available_charge_modes", parent=self)
+            self.charging_care_mode: EnumAttribute = EnumAttribute("charging_care_mode", parent=self)
+            self.battery_support: EnumAttribute = EnumAttribute("battery_support", parent=self)
+
+    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'
+
+    class SkodaChargeMode(Enum,):
+        """
+        Enum class representing different Skoda charge modes.
+
+        Attributes:
+            HOME_STORAGE_CHARGING (str): Charge mode for home storage charging.
+            IMMEDIATE_DISCHARGING (str): Charge mode for immediate discharging.
+            ONLY_OWN_CURRENT (str): Charge mode for using only own current.
+            PREFERRED_CHARGING_TIMES (str): Charge mode for preferred charging times.
+            TIMER_CHARGING_WITH_CLIMATISATION (str): Charge mode for timer charging with climatisation.
+            TIMER (str): Charge mode for timer-based charging.
+            MANUAL (str): Charge mode for manual charging.
+            OFF (str): Charge mode for turning off charging.
+        """
+        HOME_STORAGE_CHARGING = 'HOME_STORAGE_CHARGING'
+        IMMEDIATE_DISCHARGING = 'IMMEDIATE_DISCHARGING'
+        ONLY_OWN_CURRENT = 'ONLY_OWN_CURRENT'
+        PREFERRED_CHARGING_TIMES = 'PREFERRED_CHARGING_TIMES'
+        TIMER_CHARGING_WITH_CLIMATISATION = 'TIMER_CHARGING_WITH_CLIMATISATION'
+        TIMER = 'timer'
+        MANUAL = 'manual'
+        OFF = 'off'
+        UNKNOWN = 'unknown charge mode'
+
+    class SkodaChargingCareMode(Enum,):
+        """
+        Enum representing the charging care mode for Skoda vehicles.
+        """
+        ACTIVATED = 'ACTIVATED'
+        DEACTIVATED = 'DEACTIVATED'
+        UNKNOWN = 'UNKNOWN'
+
+    class SkodaBatterySupport(Enum,):
+        """
+        SkodaBatterySupport is an enumeration that represents the different states of battery support for Skoda vehicles.
+        """
+        ENABLED = 'ENABLED'
+        DISABLED = 'DISABLED'
+        NOT_ALLOWED = 'NOT_ALLOWED'
+        UNKNOWN = 'UNKNOWN'
+
+
+# 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.1a18/src/carconnectivity_connectors/skoda/climatization.py

@@ -0,0 +1,41 @@
+"""
+Module for charging for skoda vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from carconnectivity.climatization import Climatization
+from carconnectivity.objects import GenericObject
+from carconnectivity.vehicle import ElectricVehicle
+
+from carconnectivity_connectors.skoda.error import Error
+
+if TYPE_CHECKING:
+    from typing import Optional, Dict
+
+
+class SkodaClimatization(Climatization):  # pylint: disable=too-many-instance-attributes
+    """
+    SkodaClimatization class for handling Skoda vehicle climatization information.
+
+    This class extends the Climatization class and includes an enumeration of various
+    charging states specific to Skoda vehicles.
+    """
+    def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Climatization] = None) -> None:
+        if origin is not None:
+            super().__init__(origin=origin)
+            self.settings: Climatization.Settings = SkodaClimatization.Settings(origin=origin.settings)
+        else:
+            super().__init__(vehicle=vehicle)
+            self.settings: Climatization.Settings = SkodaClimatization.Settings(origin=self.settings)
+        self.errors: Dict[str, Error] = {}
+
+    class Settings(Climatization.Settings):
+        """
+        This class represents the settings for a skoda car climatiation.
+        """
+        def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Climatization.Settings] = None) -> None:
+            if origin is not None:
+                super().__init__(origin=origin)
+            else:
+                super().__init__(parent=parent)

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a18}/src/carconnectivity_connectors/skoda/connector.py

@@ -15,9 +15,9 @@ from carconnectivity.errors import AuthenticationError, TooManyRequestsError, Re
     TemporaryAuthenticationError, ConfigurationError
 from carconnectivity.util import robust_time_parse, log_extra_keys, config_remove_credentials
 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.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
@@ -31,11 +31,13 @@ from carconnectivity_connectors.skoda.auth.my_skoda_session import MySkodaSessio
 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.climatization import SkodaClimatization
+from carconnectivity_connectors.skoda.error import Error
 from carconnectivity_connectors.skoda._version import __version__
 from carconnectivity_connectors.skoda.mqtt_client import SkodaMQTTClient
 
 if TYPE_CHECKING:
-    from typing import Dict, List, Optional, Any
+    from typing import Dict, List, Optional, Any, Set
 
     from carconnectivity.carconnectivity import CarConnectivity
 
@@ -308,6 +310,7 @@ class Connector(BaseConnector):
         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(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'):
@@ -340,6 +343,12 @@ class Connector(BaseConnector):
                 captured_at: datetime = robust_time_parse(data['carCapturedTimestamp'])
             else:
                 raise APIError('Could not fetch charging, carCapturedTimestamp missing')
+            if 'isVehicleInSavedLocation' in data and data['isVehicleInSavedLocation'] is not None:
+                if vehicle.charging is not None:
+                    if not isinstance(vehicle.charging, SkodaCharging):
+                        vehicle.charging = SkodaCharging(origin=vehicle.charging)
+                    # pylint: disable-next=protected-access
+                    vehicle.charging.is_in_saved_location._set_value(data['isVehicleInSavedLocation'], measured=captured_at)
             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]:
@@ -404,7 +413,114 @@ class Connector(BaseConnector):
                                                                     'state',
                                                                     'chargeType',
                                                                     'battery'})
-            log_extra_keys(LOG_API, 'charging data', data,  {'carCapturedTimestamp', 'status'})
+            if 'settings' in data and data['settings'] is not None:
+                if 'targetStateOfChargeInPercent' in data['settings'] and data['settings']['targetStateOfChargeInPercent'] is not None \
+                        and vehicle.charging is not None and vehicle.charging.settings is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.charging.settings.target_level._set_value(value=data['settings']['targetStateOfChargeInPercent'], measured=captured_at)
+                else:
+                    vehicle.charging.settings.target_level._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                if 'maxChargeCurrentAc' in data['settings'] and data['settings']['maxChargeCurrentAc'] is not None \
+                        and vehicle.charging is not None and vehicle.charging.settings is not None:
+                    if data['settings']['maxChargeCurrentAc'] == 'MAXIMUM':
+                        vehicle.charging.settings.maximum_current._set_value(value=11, measured=captured_at)  # pylint: disable=protected-access
+                    elif data['settings']['maxChargeCurrentAc'] == 'REDUCED':
+                        vehicle.charging.settings.maximum_current._set_value(value=6, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        LOG_API.info('Unknown maxChargeCurrentAc %s not in %s', data['settings']['maxChargeCurrentAc'], ['MAXIMUM', 'REDUCED'])
+                        vehicle.charging.settings.maximum_current._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                else:
+                    vehicle.charging.settings.maximum_current._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                if 'autoUnlockPlugWhenCharged' in data['settings'] and data['settings']['autoUnlockPlugWhenCharged'] is not None:
+                    if data['settings']['autoUnlockPlugWhenCharged'] in ['ON', 'PERMANENT']:
+                        vehicle.charging.settings.auto_unlock._set_value(True, measured=captured_at)  # pylint: disable=protected-access
+                    elif data['settings']['autoUnlockPlugWhenCharged'] == 'OFF':
+                        vehicle.charging.settings.auto_unlock._set_value(False, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        LOG_API.info('Unknown autoUnlockPlugWhenCharged %s not in %s', data['settings']['autoUnlockPlugWhenCharged'],
+                                     ['ON', 'PERMANENT', 'OFF'])
+                        vehicle.charging.settings.auto_unlock._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                if 'preferredChargeMode' in data['settings'] and data['settings']['preferredChargeMode'] is not None:
+                    if not isinstance(vehicle.charging, SkodaCharging):
+                        vehicle.charging = SkodaCharging(origin=vehicle.charging)
+                    if data['settings']['preferredChargeMode'] in [item.name for item in SkodaCharging.SkodaChargeMode]:
+                        preferred_charge_mode: SkodaCharging.SkodaChargeMode = SkodaCharging.SkodaChargeMode[data['settings']['preferredChargeMode']]
+                    else:
+                        LOG_API.info('Unkown charge mode %s not in %s', data['settings']['preferredChargeMode'], str(SkodaCharging.SkodaChargeMode))
+                        preferred_charge_mode = SkodaCharging.SkodaChargeMode.UNKNOWN
+
+                    if isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        # pylint: disable-next=protected-access
+                        vehicle.charging.settings.preferred_charge_mode._set_value(value=preferred_charge_mode, measured=captured_at)
+                else:
+                    if vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        vehicle.charging.settings.preferred_charge_mode._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                if 'availableChargeModes' in data['settings'] and data['settings']['availableChargeModes'] is not None:
+                    if not isinstance(vehicle.charging, SkodaCharging):
+                        vehicle.charging = SkodaCharging(origin=vehicle.charging)
+                    available_charge_modes: list[str] = data['settings']['availableChargeModes']
+                    if vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        # pylint: disable-next=protected-access
+                        vehicle.charging.settings.available_charge_modes._set_value('.'.join(available_charge_modes), measured=captured_at)
+                else:
+                    if vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        vehicle.charging.settings.available_charge_modes._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                if 'chargingCareMode' in data['settings'] and data['settings']['chargingCareMode'] is not None:
+                    if not isinstance(vehicle.charging, SkodaCharging):
+                        vehicle.charging = SkodaCharging(origin=vehicle.charging)
+                    if data['settings']['chargingCareMode'] in [item.name for item in SkodaCharging.SkodaChargingCareMode]:
+                        charge_mode: SkodaCharging.SkodaChargingCareMode = SkodaCharging.SkodaChargingCareMode[data['settings']['chargingCareMode']]
+                    else:
+                        LOG_API.info('Unknown charging care mode %s not in %s', data['settings']['chargingCareMode'], str(SkodaCharging.SkodaChargingCareMode))
+                        charge_mode = SkodaCharging.SkodaChargingCareMode.UNKNOWN
+                    if vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        # pylint: disable-next=protected-access
+                        vehicle.charging.settings.charging_care_mode._set_value(value=charge_mode, measured=captured_at)
+                else:
+                    if vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        vehicle.charging.settings.charging_care_mode._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                if 'batterySupport' in data['settings'] and data['settings']['batterySupport'] is not None:
+                    if not isinstance(vehicle.charging, SkodaCharging):
+                        vehicle.charging = SkodaCharging(origin=vehicle.charging)
+                    if data['settings']['batterySupport'] in [item.name for item in SkodaCharging.SkodaBatterySupport]:
+                        battery_support: SkodaCharging.SkodaBatterySupport = SkodaCharging.SkodaBatterySupport[data['settings']['batterySupport']]
+                    else:
+                        LOG_API.info('Unknown battery support %s not in %s', data['settings']['batterySupport'], str(SkodaCharging.SkodaBatterySupport))
+                        battery_support = SkodaCharging.SkodaBatterySupport.UNKNOWN
+                    if vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        # pylint: disable-next=protected-access
+                        vehicle.charging.settings.battery_support._set_value(value=battery_support, measured=captured_at)
+                else:
+                    if vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                        vehicle.charging.settings.battery_support._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                log_extra_keys(LOG_API, 'settings', data['settings'],  {'targetStateOfChargeInPercent', 'maxChargeCurrentAc', 'autoUnlockPlugWhenCharged',
+                                                                        'preferredChargeMode', 'availableChargeModes', 'chargingCareMode', 'batterySupport'})
+            if 'errors' in data and data['errors'] is not None:
+                found_errors: Set[str] = set()
+                if not isinstance(vehicle.charging, SkodaCharging):
+                    vehicle.charging = SkodaCharging(origin=vehicle.charging)
+                for error_dict in data['errors']:
+                    if 'type' in error_dict and error_dict['type'] is not None:
+                        if error_dict['type'] not in vehicle.charging.errors:
+                            error: Error = Error(object_id=error_dict['type'])
+                        else:
+                            error = vehicle.charging.errors[error_dict['type']]
+                        if error_dict['type'] in [item.name for item in Error.ChargingError]:
+                            error_type: Error.ChargingError = Error.ChargingError[error_dict['type']]
+                        else:
+                            LOG_API.info('Unknown charging error type %s not in %s', error_dict['type'], str(Error.ChargingError))
+                            error_type = Error.ChargingError.UNKNOWN
+                        error.type._set_value(error_type, measured=captured_at)  # pylint: disable=protected-access
+                        if 'description' in error_dict and error_dict['description'] is not None:
+                            error.description._set_value(error_dict['description'], measured=captured_at)  # pylint: disable=protected-access
+                    log_extra_keys(LOG_API, 'errors', error_dict,  {'type', 'description'})
+                if vehicle.charging is not None and vehicle.charging.errors is not None and len(vehicle.charging.errors) > 0:
+                    for error_id in vehicle.charging.errors.keys()-found_errors:
+                        vehicle.charging.errors.pop(error_id)
+            else:
+                if isinstance(vehicle.charging, SkodaCharging):
+                    vehicle.charging.errors.clear()
+            log_extra_keys(LOG_API, 'charging data', data,  {'carCapturedTimestamp', 'status', 'isVehicleInSavedLocation', 'errors', 'settings'})
         return vehicle
 
     def fetch_position(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
@@ -522,15 +638,16 @@ class Connector(BaseConnector):
                         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)
+                    vehicle.climatization.settings.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
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.settings.target_temperature._set_value(value=None, measured=captured_at, unit=unit)
                 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)
+                vehicle.climatization.settings.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'])
@@ -545,7 +662,7 @@ class Connector(BaseConnector):
                     elif data['outsideTemperature']['temperatureUnit'] == 'KELVIN':
                         unit = Temperature.K
                     else:
-                        LOG_API.info('Unknown temperature unit for outsideTemperature in air-conditioning %s', data['targetTemperature']['temperatureUnit'])
+                        LOG_API.info('Unknown temperature unit for outsideTemperature in air-conditioning %s', data['outsideTemperature']['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'],
@@ -560,6 +677,66 @@ class Connector(BaseConnector):
                 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
+            if 'airConditioningAtUnlock' in data and data['airConditioningAtUnlock'] is not None:
+                if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    if data['airConditioningAtUnlock'] is True:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.climatization_at_unlock._set_value(True, measured=captured_at)
+                    elif data['airConditioningAtUnlock'] is False:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.climatization_at_unlock._set_value(False, measured=captured_at)
+                    else:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.climatization_at_unlock._set_value(None, measured=captured_at)
+            else:
+                if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.settings.climatization_at_unlock._set_value(None, measured=captured_at)
+            if 'steeringWheelPosition' in data and data['steeringWheelPosition'] is not None:
+                if vehicle.specification is not None:
+                    if data['steeringWheelPosition'] in [item.name for item in GenericVehicle.VehicleSpecification.SteeringPosition]:
+                        steering_wheel_position: GenericVehicle.VehicleSpecification.SteeringPosition = \
+                            GenericVehicle.VehicleSpecification.SteeringPosition[data['steeringWheelPosition']]
+                    else:
+                        LOG_API.info('Unknown steering wheel position %s not in %s', data['steeringWheelPosition'],
+                                     str(GenericVehicle.VehicleSpecification.SteeringPosition))
+                        steering_wheel_position = GenericVehicle.VehicleSpecification.SteeringPosition.UNKNOWN
+                    # pylint: disable-next=protected-access
+                    vehicle.specification.steering_wheel_position._set_value(value=steering_wheel_position, measured=captured_at)
+            else:
+                if vehicle.specification is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.specification.steering_wheel_position._set_value(None, measured=captured_at)
+            if 'windowHeatingEnabled' in data and data['windowHeatingEnabled'] is not None:
+                if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    if data['windowHeatingEnabled'] is True:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.window_heating._set_value(True, measured=captured_at)
+                    elif data['windowHeatingEnabled'] is False:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.window_heating._set_value(False, measured=captured_at)
+                    else:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.window_heating._set_value(None, measured=captured_at)
+            else:
+                if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.settings.window_heating._set_value(None, measured=captured_at)
+            if 'seatHeatingActivated' in data and data['seatHeatingActivated'] is not None:
+                if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    if data['seatHeatingActivated'] is True:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.seat_heating._set_value(True, measured=captured_at)
+                    elif data['seatHeatingActivated'] is False:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.seat_heating._set_value(False, measured=captured_at)
+                    else:
+                        # pylint: disable-next=protected-access
+                        vehicle.climatization.settings.seat_heating._set_value(None, measured=captured_at)
+            else:
+                if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.settings.seat_heating._set_value(None, measured=captured_at)
             if isinstance(vehicle, SkodaElectricVehicle):
                 if 'chargerConnectionState' in data and data['chargerConnectionState'] is not None \
                         and vehicle.charging is not None and vehicle.charging.connector is not None:
@@ -593,9 +770,35 @@ class Connector(BaseConnector):
                     vehicle.charging.connector.lock_state._set_value(value=None, measured=captured_at)
             if 'windowHeatingState' in data and data['windowHeatingState'] is not None:
                 pass
-            log_extra_keys(LOG_API, 'air-condition', data,  {'carCapturedTimestamp', 'state', 'estimatedDateTimeToReachTargetTemperature'
+            if 'errors' in data and data['errors'] is not None:
+                found_errors: Set[str] = set()
+                if not isinstance(vehicle.climatization, SkodaClimatization):
+                    vehicle.climatization = SkodaClimatization(origin=vehicle.climatization)
+                for error_dict in data['errors']:
+                    if 'type' in error_dict and error_dict['type'] is not None:
+                        if error_dict['type'] not in vehicle.climatization.errors:
+                            error: Error = Error(object_id=error_dict['type'])
+                        else:
+                            error = vehicle.climatization.errors[error_dict['type']]
+                        if error_dict['type'] in [item.name for item in Error.ClimatizationError]:
+                            error_type: Error.ClimatizationError = Error.ClimatizationError[error_dict['type']]
+                        else:
+                            LOG_API.info('Unknown climatization error type %s not in %s', error_dict['type'], str(Error.ClimatizationError))
+                            error_type = Error.ClimatizationError.UNKNOWN
+                        error.type._set_value(error_type, measured=captured_at)  # pylint: disable=protected-access
+                        if 'description' in error_dict and error_dict['description'] is not None:
+                            error.description._set_value(error_dict['description'], measured=captured_at)  # pylint: disable=protected-access
+                    log_extra_keys(LOG_API, 'errors', error_dict,  {'type', 'description'})
+                if vehicle.climatization is not None and vehicle.climatization.errors is not None and len(vehicle.climatization.errors) > 0:
+                    for error_id in vehicle.climatization.errors.keys()-found_errors:
+                        vehicle.climatization.errors.pop(error_id)
+            else:
+                if isinstance(vehicle.climatization, SkodaClimatization):
+                    vehicle.climatization.errors.clear()
+            log_extra_keys(LOG_API, 'air-condition', data,  {'carCapturedTimestamp', 'state', 'estimatedDateTimeToReachTargetTemperature',
                                                              'targetTemperature', 'outsideTemperature', 'chargerConnectionState',
-                                                             'chargerLockState'})
+                                                             'chargerLockState', 'airConditioningAtUnlock', 'steeringWheelPosition',
+                                                             'windowHeatingEnabled', 'seatHeatingActivated', 'errors'})
         return vehicle
 
     def fetch_vehicle_details(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
@@ -761,6 +964,97 @@ class Connector(BaseConnector):
                                                                                                'secondaryEngineRange'})
         return vehicle
 
+    def fetch_vehicle_status(self, vehicle: SkodaVehicle, no_cache: bool = False) -> 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://mysmob.api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}'
+        vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        if vehicle_status_data:
+            captured_at: datetime = robust_time_parse(vehicle_status_data['carCapturedTimestamp'])
+            if 'overall' in vehicle_status_data and vehicle_status_data['overall'] is not None:
+                if 'doorsLocked' in vehicle_status_data['overall'] and vehicle_status_data['overall']['doorsLocked'] is not None \
+                        and vehicle.doors is not None:
+                    if vehicle_status_data['overall']['doorsLocked'] == 'YES':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.LOCKED, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.doors.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['doorsLocked'] == 'OPENED':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.doors.open_state._set_value(Doors.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['doorsLocked'] == 'UNLOCKED':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.doors.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['doorsLocked'] == 'TRUNK_OPENED':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.doors.open_state._set_value(Doors.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['doorsLocked'] == 'UNKNOWN':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.doors.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        LOG_API.info('Unknown doorsLocked state %s', vehicle_status_data['overall']['doorsLocked'])
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.doors.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                if 'locked' in vehicle_status_data['overall'] and vehicle_status_data['overall']['locked'] is not None:
+                    if vehicle_status_data['overall']['locked'] == 'YES':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.LOCKED, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['locked'] == 'NO':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['locked'] == 'UNKNOWN':
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        LOG_API.info('Unknown locked state %s', vehicle_status_data['overall']['locked'])
+                        vehicle.doors.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                if 'doors' in vehicle_status_data['overall'] and vehicle_status_data['overall']['doors'] is not None:
+                    if vehicle_status_data['overall']['doors'] == 'CLOSED':
+                        vehicle.doors.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['doors'] == 'OPEN':
+                        vehicle.doors.open_state._set_value(Doors.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['doors'] == 'UNSUPPORTED':
+                        vehicle.doors.open_state._set_value(Doors.OpenState.UNSUPPORTED, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['doors'] == 'UNKNOWN':
+                        vehicle.doors.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        LOG_API.info('Unknown doors state %s', vehicle_status_data['overall']['doors'])
+                        vehicle.doors.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                if 'windows' in vehicle_status_data['overall'] and vehicle_status_data['overall']['windows'] is not None:
+                    if vehicle_status_data['overall']['windows'] == 'CLOSED':
+                        vehicle.windows.open_state._set_value(Windows.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['windows'] == 'OPEN':
+                        vehicle.windows.open_state._set_value(Windows.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['windows'] == 'UNKNOWN':
+                        vehicle.windows.open_state._set_value(Windows.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['windows'] == 'UNSUPPORTED':
+                        vehicle.windows.open_state._set_value(Windows.OpenState.UNSUPPORTED, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        LOG_API.info('Unknown windows state %s', vehicle_status_data['overall']['windows'])
+                        vehicle.windows.open_state._set_value(Windows.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                if 'lights' in vehicle_status_data['overall'] and vehicle_status_data['overall']['lights'] is not None:
+                    if vehicle_status_data['overall']['lights'] == 'ON':
+                        vehicle.lights.light_state._set_value(Lights.LightState.ON, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['lights'] == 'OFF':
+                        vehicle.lights.light_state._set_value(Lights.LightState.OFF, measured=captured_at)  # pylint: disable=protected-access
+                    elif vehicle_status_data['overall']['lights'] == 'UNKNOWN':
+                        vehicle.lights.light_state._set_value(Lights.LightState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        LOG_API.info('Unknown lights state %s', vehicle_status_data['overall']['lights'])
+                        vehicle.lights.light_state._set_value(Lights.LightState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
+                log_extra_keys(LOG_API, 'status overall', vehicle_status_data['overall'], {'doorsLocked',
+                                                                                           'locked',
+                                                                                           'doors',
+                                                                                           'windows',
+                                                                                           'lights'})
+            log_extra_keys(LOG_API, f'/api/v2/vehicle-status/{vin}', vehicle_status_data, {'overall', 'carCapturedTimestamp'})
+        return vehicle
+
         # def fetch_vehicle_status_second_api(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
         #     """
         #     Fetches the status of a vehicle from other Skoda API.

carconnectivity_connector_skoda-0.1a18/src/carconnectivity_connectors/skoda/error.py

@@ -0,0 +1,52 @@
+"""Module for Skoda vehicle capability class."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import Enum
+
+from carconnectivity.objects import GenericObject
+from carconnectivity.attributes import EnumAttribute, StringAttribute
+
+if TYPE_CHECKING:
+    from typing import Optional
+
+
+class Error(GenericObject):
+    """
+    Represents an error object in the car connectivity context.
+    """
+
+    def __init__(self, object_id, parent: Optional[GenericObject] = None) -> None:
+        super().__init__(object_id, parent=parent)
+        self.type: EnumAttribute = EnumAttribute("type", parent=self)
+        self.description: StringAttribute = StringAttribute("description", parent=self)
+
+    class ChargingError(Enum):
+        """
+        Enum representing various charging errors for Skoda car connectivity.
+
+        Attributes:
+            STATUS_OF_CHARGING_NOT_AVAILABLE: Indicates that the status of charging is not available.
+            STATUS_OF_CONNECTION_NOT_AVAILABLE: Indicates that the status of connection is not available.
+            CARE_MODE_IS_NOT_AVAILABLE: Indicates that the care mode is not available.
+            AUTO_UNLOCK_IS_NOT_AVAILABLE: Indicates that the auto unlock feature is not available.
+            MAX_CHARGE_CURRENT_IS_NOT_AVAILABLE: Indicates that the maximum charge current setting is not available.
+            CHARGE_LIMIT_IS_NOT_AVAILABLE: Indicates that the charge limit setting is not available.
+        """
+        STATUS_OF_CHARGING_NOT_AVAILABLE = 'STATUS_OF_CHARGING_NOT_AVAILABLE'
+        STATUS_OF_CONNECTION_NOT_AVAILABLE = 'STATUS_OF_CONNECTION_NOT_AVAILABLE'
+        CARE_MODE_IS_NOT_AVAILABLE = 'CARE_MODE_IS_NOT_AVAILABLE'
+        AUTO_UNLOCK_IS_NOT_AVAILABLE = 'AUTO_UNLOCK_IS_NOT_AVAILABLE'
+        MAX_CHARGE_CURRENT_IS_NOT_AVAILABLE = 'MAX_CHARGE_CURRENT_IS_NOT_AVAILABLE'
+        CHARGE_LIMIT_IS_NOT_AVAILABLE = 'CHARGE_LIMIT_IS_NOT_AVAILABLE'
+        UNKNOWN = 'UNKNOWN'
+
+    class ClimatizationError(Enum):
+        """
+        ClimatizationError is an enumeration for representing various errors
+        related to the climatization system in a Skoda car.
+
+        This enum can be extended to include specific error codes and messages
+        that correspond to different climatization issues.
+        """
+        UNKNOWN = 'UNKNOWN'

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a18}/src/carconnectivity_connectors/skoda/mqtt_client.py

@@ -40,7 +40,6 @@ if TYPE_CHECKING:
     from carconnectivity_connectors.skoda.connector import Connector
 
 
-
 LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.skoda.mqtt")
 LOG_API: logging.Logger = logging.getLogger("carconnectivity.connectors.skoda-api-debug")
 
@@ -469,6 +468,15 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 if electric_drive is not None:
                                     charging_state: Optional[Charging.ChargingState] = vehicle.charging.state.value
                                     old_charging_state: Optional[Charging.ChargingState] = charging_state
+                                    if 'mode' in data['data'] and data['data']['mode'] is not None \
+                                            and vehicle.charging is not None and isinstance(vehicle.charging.settings, SkodaCharging.Settings):
+                                        if data['data']['mode'] in SkodaCharging.SkodaChargeMode:
+                                            skoda_charging_mode = SkodaCharging.SkodaChargeMode(data['data']['mode'])
+                                        else:
+                                            LOG_API.info('Unkown charging mode %s not in %s', data['data']['mode'], str(SkodaCharging.SkodaChargeMode))
+                                            skoda_charging_mode = Charging.ChargingState.UNKNOWN
+                                        # pylint: disable-next=protected-access
+                                        vehicle.charging.settings.preferred_charge_mode._set_value(value=skoda_charging_mode, measured=measured_at)
                                     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'])
@@ -545,6 +553,10 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                     """
                                     vin = vehicle.id
                                     self.delayed_access_function_timers.pop(vin)
+                                    try:
+                                        self._skoda_connector.fetch_vehicle_status(vehicle, no_cache=True)
+                                    except CarConnectivityError as e:
+                                        LOG.error('Error while fetching vehicle status: %s', e)
                                     if vehicle.capabilities is not None and vehicle.capabilities.enabled \
                                             and vehicle.capabilities.has_capability('CHARGING') and isinstance(vehicle, SkodaElectricVehicle):
                                         try:
@@ -569,6 +581,19 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 self.delayed_access_function_timers[vin] = threading.Timer(2.0, delayed_access_function, kwargs={'vehicle': vehicle})
                                 self.delayed_access_function_timers[vin].start()
 
+                    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 == 'vehicle-status/lights':
+                    if 'name' in data and data['name'] == 'change-lights':
+                        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_vehicle_status(vehicle, no_cache=True)
+                                except CarConnectivityError as e:
+                                    LOG.error('Error while fetching vehicle status: %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
@@ -582,8 +607,15 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             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)
+                vehicle: Optional[GenericVehicle] = self._skoda_connector.car_connectivity.garage.get_vehicle(vin)
+                if operation_request == 'air-conditioning/set-air-conditioning-at-unlock' \
+                        or operation_request == 'air-conditioning/set-air-conditioning-seats-heating' \
+                        or operation_request == 'air-conditioning/set-air-conditioning-timers' \
+                        or operation_request == 'air-conditioning/set-air-conditioning-without-external-power' \
+                        or operation_request == 'air-conditioning/set-target-temperature' \
+                        or operation_request == 'air-conditioning/start-stop-air-conditioning' \
+                        or operation_request == 'air-conditioning/start-stop-window-heating' \
+                        or operation_request == 'air-conditioning/windows-heating':
                     if isinstance(vehicle, SkodaVehicle):
                         if 'status' in data and data['status'] is not None:
                             if data['status'] == 'COMPLETED_SUCCESS':
@@ -593,6 +625,23 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 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
+                if operation_request == 'charging/start-stop-charging' \
+                        or operation_request == 'charging/update-battery-support' \
+                        or operation_request == 'charging/update-auto-unlock-plug' \
+                        or operation_request == 'charging/update-care-mode' \
+                        or operation_request == 'charging/update-charge-limit' \
+                        or operation_request == 'charging/update-charge-mode' \
+                        or operation_request == 'charging/update-charging-profiles' \
+                        or operation_request == 'charging/update-charging-current':
+                    if isinstance(vehicle, SkodaElectricVehicle):
+                        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_charging(vehicle, no_cache=True)
+                                except CarConnectivityError as e:
+                                    LOG.error('Error while fetching charging: %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)

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a18}/src/carconnectivity_connectors/skoda/vehicle.py

@@ -3,8 +3,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from carconnectivity.vehicle import GenericVehicle, ElectricVehicle, CombustionVehicle, HybridVehicle
+from carconnectivity.charging import Charging
 
 from carconnectivity_connectors.skoda.capability import Capabilities
+from carconnectivity_connectors.skoda.charging import SkodaCharging
 
 if TYPE_CHECKING:
     from typing import Optional
@@ -39,8 +41,12 @@ class SkodaElectricVehicle(ElectricVehicle, SkodaVehicle):
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
             super().__init__(origin=origin)
+            if isinstance(origin, ElectricVehicle):
+                self.charging: Charging = SkodaCharging(origin=origin.charging)
+                self.charging.parent = self
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
+            self.charging: Charging = SkodaCharging(vehicle=self)
 
 
 class SkodaCombustionVehicle(CombustionVehicle, SkodaVehicle):

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

@@ -1,67 +0,0 @@
-"""
-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
-}