carconnectivity-connector-skoda 0.1a14__py3-none-any.whl → 0.1a17__py3-none-any.whl

{carconnectivity_connector_skoda-0.1a14.dist-info → carconnectivity_connector_skoda-0.1a17.dist-info}/METADATA

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

{carconnectivity_connector_skoda-0.1a14.dist-info → carconnectivity_connector_skoda-0.1a17.dist-info}/RECORD

@@ -1,10 +1,11 @@
 carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=ydJdzW-btPcfSrfx2Va0JEeRefzQRak0BrHC2KuWcaU,409
+carconnectivity_connectors/skoda/_version.py,sha256=waXAIf0j4Aq__xvEJNJvHzQvbn3T7HTylT_B7dyZT10,409
 carconnectivity_connectors/skoda/capability.py,sha256=JlNEaisVYF8qWv0wNDHTaas36uIpTIQ3NVR69wesiYQ,4513
-carconnectivity_connectors/skoda/charging.py,sha256=oDHxZxrfTMvtYCJxmGfKFeWVMH4ceQ5HTKRAspnsunU,3312
-carconnectivity_connectors/skoda/connector.py,sha256=Z7CZclSC8lg0Rc5Zf2Vp9ATgXxACq_aTpxJxfe2EEsw,69140
-carconnectivity_connectors/skoda/mqtt_client.py,sha256=oFyuMWchYSdu_St4VzcGsCUzsgUzYdA2_gmzbilgqL8,32105
-carconnectivity_connectors/skoda/vehicle.py,sha256=H3GRDNimMghFwFi--y9BsgoSK3pMibNf_l6SsDN6gvQ,2759
+carconnectivity_connectors/skoda/charging.py,sha256=OXy4Yr9bw5H_6BnGbvQTDyvxaIg8QN9YUog0dashdGE,6669
+carconnectivity_connectors/skoda/connector.py,sha256=7307glMfF1EbhFzxrdomC_pvbHysyvq_cd4YoiHvG2M,79859
+carconnectivity_connectors/skoda/error.py,sha256=xM8Ldgj-Biy793if3yTP5U7QIaBnOT7haEkxbXH4uYA,1962
+carconnectivity_connectors/skoda/mqtt_client.py,sha256=AKRv2nmH3MfppFR3ub4Bg0oTZEhqxC-i9YVrmyHGq3U,34824
+carconnectivity_connectors/skoda/vehicle.py,sha256=FbrhxZF-5TOUiPzUvryeFZrT-ie1XIyjRO4RbMymlJs,3115
 carconnectivity_connectors/skoda/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 carconnectivity_connectors/skoda/auth/auth_util.py,sha256=dGLUbUre0HBsTg_Ii5vW34f8DLrCykYJYCyzEvUBBEE,4434
 carconnectivity_connectors/skoda/auth/my_skoda_session.py,sha256=lSh23SFJs8opjmPwHTv-KNIKDep_WY4aItSP4Zq7bT8,10396
@@ -12,8 +13,8 @@ carconnectivity_connectors/skoda/auth/openid_session.py,sha256=LusWi2FZZIL3buodG
 carconnectivity_connectors/skoda/auth/session_manager.py,sha256=Uf1vujuDBYUCAXhYToOsZkgbTtfmY3Qe0ICTfwomBpI,2899
 carconnectivity_connectors/skoda/auth/skoda_web_session.py,sha256=cjzMkzx473Sh-4RgZAQULeRRcxB1MboddldCVM_y5LE,10640
 carconnectivity_connectors/skoda/auth/helpers/blacklist_retry.py,sha256=f3wsiY5bpHDBxp7Va1Mv9nKJ4u3qnCHZZmDu78_AhMk,1251
-carconnectivity_connector_skoda-0.1a14.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.1a14.dist-info/METADATA,sha256=65N4TiZujxrtbetLvzRlpY7Jntm3cQRqn4MNpjWkXyY,5327
-carconnectivity_connector_skoda-0.1a14.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-carconnectivity_connector_skoda-0.1a14.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.1a14.dist-info/RECORD,,
+carconnectivity_connector_skoda-0.1a17.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_skoda-0.1a17.dist-info/METADATA,sha256=mlKJheSBMcIcszI4631ex5Eve1lzOt-a38eW1xRUBBs,5327
+carconnectivity_connector_skoda-0.1a17.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+carconnectivity_connector_skoda-0.1a17.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.1a17.dist-info/RECORD,,

carconnectivity_connectors/skoda/_version.py

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

carconnectivity_connectors/skoda/charging.py

@@ -7,18 +7,47 @@ 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 Dict
+    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 
+    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.
@@ -49,6 +78,47 @@ class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
         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] = {

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_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_connectors/skoda/mqtt_client.py

@@ -21,15 +21,22 @@ from carconnectivity.drive import ElectricDrive
 from carconnectivity.util import robust_time_parse, log_extra_keys
 from carconnectivity.charging import Charging
 from carconnectivity.climatization import Climatization
+from carconnectivity.units import Speed, Power
 
 from carconnectivity_connectors.skoda.vehicle import SkodaVehicle, SkodaElectricVehicle
 from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
 
 
 if TYPE_CHECKING:
-    from typing import Set, Dict, Any, Optional
+    from typing import Set, Dict, Any, Optional, List
     from datetime import datetime
 
+    from paho.mqtt.client import MQTTMessage, DisconnectFlags, ConnectFlags
+    from paho.mqtt.reasoncodes import ReasonCode
+    from paho.mqtt.properties import Properties
+
+    from carconnectivity.attributes import GenericAttribute
+
     from carconnectivity_connectors.skoda.connector import Connector
 
 
@@ -72,7 +79,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         """
         return super().connect(*args, host='mqtt.messagehub.de', port=8883, keepalive=60, **kwargs)
 
-    def _on_pre_connect_callback(self, client, userdata) -> None:
+    def _on_pre_connect_callback(self, client: Client, userdata: Any) -> None:
         """
         Callback function that is called before the MQTT client connects to the broker.
 
@@ -94,7 +101,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             # pylint: disable-next=attribute-defined-outside-init # this is a false positive, password has a setter in super class
             self._password = self._skoda_connector.session.access_token  # This is a bit hacky but if password attribute is used here there is an Exception
 
-    def _on_carconnectivity_vehicle_enabled(self, element, flags):
+    def _on_carconnectivity_vehicle_enabled(self, element: GenericAttribute, flags: Observable.ObserverEvent) -> None:
         """
         Handles the event when a vehicle is enabled or disabled in the car connectivity system.
 
@@ -252,7 +259,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                 self.subscribed_topics.remove(topic)
                 LOG.debug('Unsubscribed from topic %s', topic)
 
-    def _on_connect_callback(self, mqttc, obj, flags, reason_code, properties) -> None:
+    def _on_connect_callback(self, client: Client, obj: Any, flags: ConnectFlags, reason_code: ReasonCode, properties: Optional[Properties]) -> None:
         """
         Callback function that is called when the MQTT client connects to the broker.
 
@@ -293,7 +300,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             - 159: Connection rate exceeded.
             - Other: Generic connection error.
         """
-        del mqttc  # unused
+        del client  # unused
         del obj  # unused
         del flags  # unused
         del properties
@@ -351,8 +358,8 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         else:
             LOG.error('Could not connect (%s)', reason_code)
 
-    def _on_disconnect_callback(self, client, userdata, flags, reason_code, properties) -> None:
-        """
+    def _on_disconnect_callback(self, client: Client, userdata, flags: DisconnectFlags, reason_code: ReasonCode, properties: Optional[Properties]) -> None:
+        """["Client", Any, DisconnectFlags, ReasonCode, Union[Properties, None]
         Callback function that is called when the MQTT client disconnects.
 
         This function handles the disconnection of the MQTT client and logs the appropriate
@@ -391,9 +398,9 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         elif reason_code == 160:
             LOG.error('Client disconnected: Maximum connect time')
         else:
-            LOG.error('Client unexpectedly disconnected (%d: %s), trying to reconnect', reason_code, reason_code)
+            LOG.error('Client unexpectedly disconnected (%d: %s), trying to reconnect', reason_code.value, reason_code.getName())
 
-    def _on_subscribe_callback(self, mqttc, obj, mid, reason_codes, properties) -> None:
+    def _on_subscribe_callback(self, client: Client, obj: Any, mid: int, reason_codes: List[ReasonCode], properties: Optional[Properties]) -> None:
         """
         Callback function for MQTT subscription.
 
@@ -410,15 +417,15 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         Returns:
             None
         """
-        del mqttc  # unused
+        del client  # unused
         del obj  # unused
         del properties  # unused
         if any(x in [0, 1, 2] for x in reason_codes):
             LOG.debug('sucessfully subscribed to topic of mid %d', mid)
         else:
-            LOG.error('Subscribe was not successfull (%s)', ', '.join(reason_codes))
+            LOG.error('Subscribe was not successfull (%s)', ', '.join([reason_code.getName() for reason_code in reason_codes]))
 
-    def _on_message_callback(self, mqttc, obj, msg) -> None:  # noqa: C901
+    def _on_message_callback(self, client: Client, obj: Any, msg: MQTTMessage) -> None:  # noqa: C901
         """
         Callback function for handling incoming MQTT messages.
 
@@ -434,7 +441,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         Returns:
             None
         """
-        del mqttc  # unused
+        del client  # unused
         del obj  # unused
         if len(msg.payload) == 0:
             LOG_API.debug('MQTT topic %s: ignoring empty message', msg.topic)
@@ -474,9 +481,9 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                             # pylint: disable-next=protected-access
                                             vehicle.charging.type._set_value(value=Charging.ChargingType.OFF, measured=measured_at)
                                             # pylint: disable-next=protected-access
-                                            vehicle.charging.rate._set_value(value=0, measured=measured_at)
+                                            vehicle.charging.rate._set_value(value=0, measured=measured_at, unit=Speed.KMH)
                                             # pylint: disable-next=protected-access
-                                            vehicle.charging.power._set_value(value=0, measured=measured_at)
+                                            vehicle.charging.power._set_value(value=0, measured=measured_at, unit=Power.KW)
                                     if 'soc' in data['data'] and data['data']['soc'] is not None:
                                         electric_drive.level._set_value(measured=measured_at, value=data['data']['soc'])  # pylint: disable=protected-access
                                     if 'chargedRange' in data['data'] and data['data']['chargedRange'] is not None:
@@ -574,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':
@@ -585,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_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):