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

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

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

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a17}/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.1a17
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License

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

@@ -22,6 +22,7 @@ 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/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.1a17}/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.1a17'
 __version_tuple__ = version_tuple = (0, 1)

carconnectivity_connector_skoda-0.1a17/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.1a16 → carconnectivity_connector_skoda-0.1a17}/src/carconnectivity_connectors/skoda/connector.py

@@ -31,11 +31,12 @@ 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.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
 
@@ -340,6 +341,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 +411,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:

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

@@ -0,0 +1,42 @@
+"""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'

{carconnectivity_connector_skoda-0.1a16 → carconnectivity_connector_skoda-0.1a17}/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")
 
@@ -582,8 +581,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 +599,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.1a17}/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
-}