carconnectivity-connector-skoda 0.1a11__py3-none-any.whl → 0.8.2__py3-none-any.whl

carconnectivity_connectors/skoda/error.py

@@ -0,0 +1,53 @@
+"""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, tags={'connector_custom'})
+        self.description: StringAttribute = StringAttribute("description", parent=self, tags={'connector_custom'})
+
+    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.
+        """
+        UNAVAILABLE_CHARGING_INFORMATION = 'UNAVAILABLE_CHARGING_INFORMATION'
+        UNKNOWN = 'UNKNOWN'

carconnectivity_connectors/skoda/mqtt_client.py

@@ -13,22 +13,31 @@ from datetime import timedelta, timezone
 from paho.mqtt.client import Client
 from paho.mqtt.enums import MQTTProtocolVersion, CallbackAPIVersion, MQTTErrorCode
 
-from carconnectivity.errors import CarConnectivityError
+from carconnectivity.errors import CarConnectivityError, TemporaryAuthenticationError
 from carconnectivity.observable import Observable
 from carconnectivity.vehicle import GenericVehicle
 
 from carconnectivity.drive import ElectricDrive
 from carconnectivity.util import robust_time_parse, log_extra_keys
 from carconnectivity.charging import Charging
+from carconnectivity.climatization import Climatization
+from carconnectivity.units import Speed, Power, Length
+from carconnectivity.enums import ConnectionState
 
 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
 
 
@@ -61,6 +70,8 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         self.delayed_access_function_timers: Dict[str, threading.Timer] = {}
 
         self.tls_set(cert_reqs=ssl.CERT_NONE)
+        
+        self._retry_refresh_login_once = True
 
     def connect(self, *args, **kwargs) -> MQTTErrorCode:
         """
@@ -69,9 +80,10 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         Returns:
             MQTTErrorCode: The result of the connection attempt.
         """
+        self._skoda_connector.connection_state._set_value(value=ConnectionState.CONNECTING)  # pylint: disable=protected-access
         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.
 
@@ -88,12 +100,17 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         del userdata
 
         if self._skoda_connector.session.expired or self._skoda_connector.session.access_token is None:
-            self._skoda_connector.session.refresh()
+            try:
+                self._skoda_connector.session.refresh()
+            except ConnectionError as exc:
+                LOG.error('Token refresh failed due to connection error: %s', exc)
+            except TemporaryAuthenticationError as exc:
+                LOG.error('Token refresh failed due to temporary MySkoda error: %s', exc)
         if not self._skoda_connector.session.expired and self._skoda_connector.session.access_token is not None:
             # 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.
 
@@ -171,7 +188,10 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                 vin: str = vehicle.vin.value
                 # If the skoda connector is managing this vehicle
                 if self._skoda_connector in vehicle.managing_connectors:
-                    account_events: Set[str] = {'privacy'}
+                    account_events: Set[str] = {'privacy',
+                                                'guest-user-nomination',
+                                                'primary-user-nomination'}
+                    vehicle_status_events: Set[str] = {'vehicle-connection-status'}
                     operation_requests: Set[str] = {
                         'air-conditioning/set-air-conditioning-at-unlock',
                         'air-conditioning/set-air-conditioning-seats-heating',
@@ -208,6 +228,8 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                     # Compile all possible topics
                     for event in account_events:
                         possible_topics.add(f'{user_id}/{vin}/account-event/{event}')
+                    for event in vehicle_status_events:
+                        possible_topics.add(f'{user_id}/{vin}/vehicle-status/{event}')
                     for event in operation_requests:
                         possible_topics.add(f'{user_id}/{vin}/operation-request/{event}')
                     for event in service_events:
@@ -251,7 +273,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.
 
@@ -292,18 +314,21 @@ 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
         # reason_code 0 means success
         if reason_code == 0:
             LOG.info('Connected to Skoda MQTT server')
-            self._skoda_connector.connected._set_value(value=True)  # pylint: disable=protected-access
+            if self._skoda_connector.rest_connected:
+                self._skoda_connector.connection_state._set_value(value=ConnectionState.CONNECTED)  # pylint: disable=protected-access
+            self._skoda_connector.mqtt_connected = True
             observer_flags: Observable.ObserverEvent = Observable.ObserverEvent.ENABLED | Observable.ObserverEvent.DISABLED
             self._skoda_connector.car_connectivity.garage.add_observer(observer=self._on_carconnectivity_vehicle_enabled,
                                                                        flag=observer_flags,
                                                                        priority=Observable.ObserverPriority.USER_MID)
+            self._retry_refresh_login_once = True
             self._subscribe_vehicles()
 
         # Handle different reason codes
@@ -321,6 +346,15 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             LOG.error('Could not connect (%s): Client identifier not valid', reason_code)
         elif reason_code == 134:
             LOG.error('Could not connect (%s): Bad user name or password', reason_code)
+            if self._retry_refresh_login_once == True:
+                self._retry_refresh_login_once = False
+                LOG.info('trying a relogin once to resolve the error')
+                try:
+                    self._skoda_connector.session.login()
+                except TemporaryAuthenticationError as exc:
+                    LOG.error('Login failed due to temporary MySkoda error: %s', exc)
+                except ConnectionError as exc:
+                    LOG.error('Login failed due to connection error: %s', exc)
         elif reason_code == 135:
             LOG.error('Could not connect (%s): Not authorized', reason_code)
         elif reason_code == 136:
@@ -350,8 +384,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
@@ -372,7 +406,8 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         del properties
         del flags
 
-        self._skoda_connector.connected._set_value(value=False)  # pylint: disable=protected-access
+        self._skoda_connector.connection_state._set_value(value=ConnectionState.DISCONNECTED)  # pylint: disable=protected-access
+        self._skoda_connector.mqtt_connected = False
         self._skoda_connector.car_connectivity.garage.remove_observer(observer=self._on_carconnectivity_vehicle_enabled)
 
         self.subscribed_topics.clear()
@@ -390,9 +425,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.
 
@@ -409,15 +444,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.
 
@@ -433,7 +468,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)
@@ -456,10 +491,19 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                         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, SkodaElectricVehicle):
-                                electric_drive: ElectricDrive = vehicle.get_electric_drive()
+                                electric_drive: Optional[ElectricDrive] = vehicle.get_electric_drive()
                                 if electric_drive is not None:
                                     charging_state: Optional[Charging.ChargingState] = vehicle.charging.state.value
                                     old_charging_state: Optional[Charging.ChargingState] = charging_state
+                                    if '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 [item.value for item 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'])
@@ -473,18 +517,21 @@ 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:
+                                        if isinstance(data['data']['soc'], str):
+                                            data['data']['soc'] = int(data['data']['soc'])
                                         electric_drive.level._set_value(measured=measured_at, value=data['data']['soc'])  # pylint: disable=protected-access
                                     if 'chargedRange' in data['data'] and data['data']['chargedRange'] is not None:
                                         # pylint: disable-next=protected-access
-                                        electric_drive.range._set_value(measured=measured_at, value=data['data']['chargedRange'])
+                                        electric_drive.range._set_value(measured=measured_at, value=data['data']['chargedRange'], unit=Length.KM)
                                     # If charging state changed, fetch charging again
                                     if old_charging_state != charging_state:
                                         try:
                                             self._skoda_connector.fetch_charging(vehicle, no_cache=True)
+                                            self._skoda_connector.car_connectivity.transaction_end()
                                         except CarConnectivityError as e:
                                             LOG.error('Error while fetching charging: %s', e)
                                 if 'timeToFinish' in data['data'] and data['data']['timeToFinish'] is not None \
@@ -492,11 +539,12 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                     try:
                                         remaining_duration: Optional[timedelta] = timedelta(minutes=int(data['data']['timeToFinish']))
                                         estimated_date_reached: Optional[datetime] = measured_at + remaining_duration
+                                        estimated_date_reached = estimated_date_reached.replace(second=0, microsecond=0)
                                     except ValueError:
                                         estimated_date_reached: Optional[datetime] = None
                                     # pylint: disable-next=protected-access
                                     vehicle.charging.estimated_date_reached._set_value(measured=measured_at, value=estimated_date_reached)
-                                log_extra_keys(LOG_API, 'data', data['data'],  {'vin', 'userId', 'soc', 'chargedRange', 'timeToFinish', 'state'})
+                                log_extra_keys(LOG_API, 'data', data['data'],  {'vin', 'userId', 'soc', 'chargedRange', 'timeToFinish', 'state', 'mode'})
                                 LOG.debug('Received %s event for vehicle %s from user %s', data['name'], vin, user_id)
                                 return
                             else:
@@ -511,8 +559,17 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                             if isinstance(vehicle, SkodaVehicle):
                                 try:
                                     self._skoda_connector.fetch_air_conditioning(vehicle, no_cache=True)
+                                    self._skoda_connector.car_connectivity.transaction_end()
                                 except CarConnectivityError as e:
-                                    LOG.error('Error while fetching charging: %s', e)
+                                    LOG.error('Error while fetching air conditioning: %s', e)
+                    elif 'name' in data and data['name'] == 'climatisation-completed':
+                        if 'data' in data and data['data'] is not None:
+                            vehicle: Optional[GenericVehicle] = self._skoda_connector.car_connectivity.garage.get_vehicle(vin)
+                            if vehicle is not None and vehicle.climatization is not None:
+                                # pylint: disable-next=protected-access
+                                vehicle.climatization.state._set_value(value=Climatization.ClimatizationState.OFF, measured=measured_at)
+                                # pylint: disable-next=protected-access
+                                vehicle.climatization.estimated_date_reached._set_value(value=measured_at, measured=measured_at)
                     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
@@ -527,6 +584,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:
@@ -545,26 +606,33 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                             self._skoda_connector.fetch_air_conditioning(vehicle, no_cache=True)
                                         except CarConnectivityError as e:
                                             LOG.error('Error while fetching air conditioning: %s', e)
-                                    try:
-                                        self._skoda_connector.fetch_vehicle_status_second_api(vehicle, no_cache=True)
-                                    except CarConnectivityError as e:
-                                        LOG.error('Error while fetching status second API: %s', e)
-                                    try:
-                                        self._skoda_connector.fetch_driving_range(vehicle, no_cache=True)
-                                    except CarConnectivityError as e:
-                                        LOG.error('Error while fetching driving range: %s', e)
+                                    self._skoda_connector.car_connectivity.transaction_end()
 
                                 if vin in self.delayed_access_function_timers:
                                     self.delayed_access_function_timers[vin].cancel()
                                 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)
+                                    self._skoda_connector.car_connectivity.transaction_end()
+                                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
             LOG_API.info('Received unknown service event %s for vehicle %s from user %s: %s', service_event, vin, user_id, msg.payload)
             return
-        # service_events
+        # operation-requests
         match = re.match(r'^(?P<user_id>[0-9a-fA-F-]+)/(?P<vin>[A-Z0-9]+)/operation-request/(?P<operation_request>[a-zA-Z0-9-_/]+)$', msg.topic)
         if match:
             user_id: str = match.group('user_id')
@@ -572,17 +640,49 @@ 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':
                                 LOG.debug('Received %s operation request for vehicle %s from user %s', operation_request, vin, user_id)
                                 try:
                                     self._skoda_connector.fetch_air_conditioning(vehicle, no_cache=True)
+                                    self._skoda_connector.car_connectivity.transaction_end()
                                 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
+                            elif data['status'] == 'IN_PROGRESS':
+                                LOG.debug('Received %s operation request for vehicle %s from user %s', operation_request, vin, user_id)
+                                return
+                elif 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)
+                                    self._skoda_connector.car_connectivity.transaction_end()
+                                except CarConnectivityError as e:
+                                    LOG.error('Error while fetching charging: %s', e)
+                                return
+                            elif data['status'] == 'IN_PROGRESS':
+                                LOG.debug('Received %s operation request for vehicle %s from user %s', operation_request, vin, user_id)
+                                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/ui/connector_ui.py

@@ -0,0 +1,39 @@
+""" User interface for the Skoda connector in the Car Connectivity application. """
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import os
+
+import flask
+
+from carconnectivity_connectors.base.ui.connector_ui import BaseConnectorUI
+
+if TYPE_CHECKING:
+    from typing import Optional, List, Dict, Union, Literal
+
+    from carconnectivity_connectors.base.connector import BaseConnector
+
+
+class ConnectorUI(BaseConnectorUI):
+    """
+    A user interface class for the Skoda connector in the Car Connectivity application.
+    """
+    def __init__(self, connector: BaseConnector):
+        blueprint: Optional[flask.Blueprint] = flask.Blueprint(name=connector.id, import_name='carconnectivity-connector-skoda', url_prefix=f'/{connector.id}',
+                                                               template_folder=os.path.dirname(__file__) + '/templates')
+        super().__init__(connector, blueprint=blueprint)
+
+    def get_nav_items(self) -> List[Dict[Literal['text', 'url', 'sublinks', 'divider'], Union[str, List]]]:
+        """
+        Generates a list of navigation items for the Skoda connector UI.
+        """
+        return super().get_nav_items()
+
+    def get_title(self) -> str:
+        """
+        Returns the title of the connector.
+
+        Returns:
+            str: The title of the connector, which is "Skoda".
+        """
+        return "Skoda"

carconnectivity_connectors/skoda/vehicle.py

@@ -3,11 +3,22 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from carconnectivity.vehicle import GenericVehicle, ElectricVehicle, CombustionVehicle, HybridVehicle
+from carconnectivity.charging import Charging
+from carconnectivity.attributes import BooleanAttribute
 
 from carconnectivity_connectors.skoda.capability import Capabilities
+from carconnectivity_connectors.skoda.charging import SkodaCharging
+from carconnectivity_connectors.skoda.climatization import SkodaClimatization
+
+SUPPORT_IMAGES = False
+try:
+    from PIL import Image
+    SUPPORT_IMAGES = True
+except ImportError:
+    pass
 
 if TYPE_CHECKING:
-    from typing import Optional
+    from typing import Optional, Dict
     from carconnectivity.garage import Garage
     from carconnectivity_connectors.base.connector import BaseConnector
 
@@ -19,16 +30,22 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
             self.capabilities: Capabilities = origin.capabilities
             self.capabilities.parent = self
+            self.in_motion: BooleanAttribute = origin.in_motion
+            self.in_motion.parent = self
+            if SUPPORT_IMAGES:
+                self._car_images = origin._car_images
+
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
+            self.climatization = SkodaClimatization(vehicle=self, origin=self.climatization)
             self.capabilities = Capabilities(vehicle=self)
-
-    def __str__(self) -> str:
-        return_string: str = f'\t{self.capabilities}\n'
-        return return_string
+            self.in_motion = BooleanAttribute(name='in_motion', parent=self, tags={'connector_custom'})
+            if SUPPORT_IMAGES:
+                self._car_images: Dict[str, Image.Image] = {}
+        self.manufacturer._set_value(value='Škoda')  # pylint: disable=protected-access
 
 
 class SkodaElectricVehicle(ElectricVehicle, SkodaVehicle):
@@ -38,9 +55,14 @@ class SkodaElectricVehicle(ElectricVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
+            if isinstance(origin, ElectricVehicle):
+                self.charging: Charging = SkodaCharging(vehicle=self, origin=origin.charging)
+            else:
+                self.charging: Charging = SkodaCharging(vehicle=self, origin=self.charging)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
+            self.charging: Charging = SkodaCharging(vehicle=self, origin=self.charging)
 
 
 class SkodaCombustionVehicle(CombustionVehicle, SkodaVehicle):
@@ -50,7 +72,7 @@ class SkodaCombustionVehicle(CombustionVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
 
@@ -62,6 +84,6 @@ class SkodaHybridVehicle(HybridVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)

carconnectivity_connector_skoda-0.1a11.dist-info/RECORD

@@ -1,19 +0,0 @@
-carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=lXj09wNlQE2ygonVVc_Fk2FN_1_4nx6sHnElAwbvzHM,409
-carconnectivity_connectors/skoda/capability.py,sha256=JlNEaisVYF8qWv0wNDHTaas36uIpTIQ3NVR69wesiYQ,4513
-carconnectivity_connectors/skoda/charging.py,sha256=oDHxZxrfTMvtYCJxmGfKFeWVMH4ceQ5HTKRAspnsunU,3312
-carconnectivity_connectors/skoda/connector.py,sha256=xiPPT6XTVWsLvu0iqZvSPpgtHm3DrR1TKUL4d4NRz2Y,62158
-carconnectivity_connectors/skoda/mqtt_client.py,sha256=ZB56Za1k5vbxQPl5qCvukE46Tq1O0-Cn19kBz_bDJZM,31782
-carconnectivity_connectors/skoda/vehicle.py,sha256=H3GRDNimMghFwFi--y9BsgoSK3pMibNf_l6SsDN6gvQ,2759
-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
-carconnectivity_connectors/skoda/auth/openid_session.py,sha256=LusWi2FZZIL3buodGXZKUR0naLhhqeYv0uRW4V3wI2w,16842
-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.1a11.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.1a11.dist-info/METADATA,sha256=tS2ccqTBaAHPxFbNRA7wlbJQPiqLDU8J9h62FQcXvb8,5327
-carconnectivity_connector_skoda-0.1a11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-carconnectivity_connector_skoda-0.1a11.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.1a11.dist-info/RECORD,,