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

{carconnectivity_connector_skoda-0.1a18 → carconnectivity_connector_skoda-0.1a20}/Makefile

@@ -6,7 +6,7 @@ test:
 
 lint:
 	@echo "\n${BLUE}Running Pylint against source and test files...${NC}\n"
-	@pylint ./examples ./src ./tests
+	@pylint ./src
 	@echo "\n${BLUE}Running Flake8 against source and test files...${NC}\n"
 	@flake8
 	@echo "\n${BLUE}Running Bandit against source files...${NC}\n"

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

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

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

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

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

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

{carconnectivity_connector_skoda-0.1a18 → carconnectivity_connector_skoda-0.1a20}/src/carconnectivity_connectors/skoda/charging.py

@@ -69,7 +69,7 @@ class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
         CONNECT_CABLE = 'connectCable'
         READY_FOR_CHARGING = 'readyForCharging'
         NOT_READY_FOR_CHARGING = 'notReadyForCharging'
-        CONSERVATION = 'conservation'
+        CONSERVING = 'conserving'
         CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING = 'chargePurposeReachedAndNotConservationCharging'
         CHARGE_PURPOSE_REACHED_CONSERVATION = 'chargePurposeReachedAndConservation'
         CHARGING = 'charging'
@@ -126,7 +126,7 @@ mapping_skoda_charging_state: Dict[SkodaCharging.SkodaChargingState, Charging.Ch
     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.CONSERVING: 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,

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

@@ -7,23 +7,27 @@ import os
 import logging
 import netrc
 from datetime import datetime, timedelta, timezone
+import json
+
 import requests
 
+
 from carconnectivity.garage import Garage
 from carconnectivity.vehicle import GenericVehicle
 from carconnectivity.errors import AuthenticationError, TooManyRequestsError, RetrievalError, APIError, APICompatibilityError, \
-    TemporaryAuthenticationError, ConfigurationError
+    TemporaryAuthenticationError, ConfigurationError, SetterError
 from carconnectivity.util import robust_time_parse, log_extra_keys, config_remove_credentials
 from carconnectivity.units import Length, Speed, Power, Temperature
 from carconnectivity.doors import Doors
 from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
 from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
-from carconnectivity.attributes import BooleanAttribute, DurationAttribute
+from carconnectivity.attributes import BooleanAttribute, DurationAttribute, TemperatureAttribute
 from carconnectivity.charging import Charging
 from carconnectivity.position import Position
 from carconnectivity.climatization import Climatization
 from carconnectivity.charging_connector import ChargingConnector
+from carconnectivity.command_impl import ClimatizationStartStopCommand, ChargingStartStopCommand
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
@@ -37,7 +41,7 @@ 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, Set
+    from typing import Dict, List, Optional, Any, Set, Union
 
     from carconnectivity.carconnectivity import CarConnectivity
 
@@ -71,20 +75,20 @@ class Connector(BaseConnector):
         # Configure logging
         if 'log_level' in config and config['log_level'] is not None:
             config['log_level'] = config['log_level'].upper()
-            if config['log_level'] in logging.getLevelNamesMapping():
+            if config['log_level'] in logging._nameToLevel:
                 LOG.setLevel(config['log_level'])
                 self.log_level._set_value(config['log_level'])  # pylint: disable=protected-access
                 logging.getLogger('requests').setLevel(config['log_level'])
                 logging.getLogger('urllib3').setLevel(config['log_level'])
                 logging.getLogger('oauthlib').setLevel(config['log_level'])
             else:
-                raise ConfigurationError(f'Invalid log level: "{config["log_level"]}" not in {list(logging.getLevelNamesMapping().keys())}')
+                raise ConfigurationError(f'Invalid log level: "{config["log_level"]}" not in {list(logging._nameToLevel.keys())}')
         if 'api_log_level' in config and config['api_log_level'] is not None:
             config['api_log_level'] = config['api_log_level'].upper()
-            if config['api_log_level'] in logging.getLevelNamesMapping():
+            if config['api_log_level'] in logging._nameToLevel:
                 LOG_API.setLevel(config['api_log_level'])
             else:
-                raise ConfigurationError(f'Invalid log level: "{config["log_level"]}" not in {list(logging.getLevelNamesMapping().keys())}')
+                raise ConfigurationError(f'Invalid log level: "{config["log_level"]}" not in {list(logging._nameToLevel.keys())}')
         LOG.info("Loading skoda connector with config %s", config_remove_credentials(self.config))
 
         username: Optional[str] = None
@@ -171,10 +175,10 @@ class Connector(BaseConnector):
                         self.update_vehicles()
                     self.last_update._set_value(value=datetime.now(tz=timezone.utc))  # pylint: disable=protected-access
                     if self.interval.value is not None:
-                        interval: int = self.interval.value.total_seconds()
+                        interval: float = self.interval.value.total_seconds()
                 except Exception:
                     if self.interval.value is not None:
-                        interval: int = self.interval.value.total_seconds()
+                        interval: float = self.interval.value.total_seconds()
                     raise
             except TooManyRequestsError as err:
                 LOG.error('Retrieval error during update. Too many requests from your account (%s). Will try again after 15 minutes', str(err))
@@ -283,7 +287,12 @@ class Connector(BaseConnector):
                         else:
                             vehicle.license_plate._set_value(None)  # pylint: disable=protected-access
 
-                        log_extra_keys(LOG_API, 'vehicles', vehicle_dict,  {'vin', 'licensePlate'})
+                        if 'name' in vehicle_dict and vehicle_dict['name'] is not None:
+                            vehicle.name._set_value(vehicle_dict['name'])  # pylint: disable=protected-access
+                        else:
+                            vehicle.name._set_value(None)  # pylint: disable=protected-access
+
+                        log_extra_keys(LOG_API, 'vehicles', vehicle_dict,  {'vin', 'licensePlate', 'name'})
 
                         vehicle = self.fetch_vehicle_details(vehicle)
                     else:
@@ -339,6 +348,10 @@ class Connector(BaseConnector):
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}'
         data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
         if data is not None:
+            start_stop_command: ChargingStartStopCommand = ChargingStartStopCommand(parent=vehicle.charging.commands)
+            start_stop_command._add_on_set_hook(self.__on_charging_start_stop)  # pylint: disable=protected-access
+            start_stop_command.enabled = True
+            vehicle.charging.commands.add_command(start_stop_command)
             if 'carCapturedTimestamp' in data and data['carCapturedTimestamp'] is not None:
                 captured_at: datetime = robust_time_parse(data['carCapturedTimestamp'])
             else:
@@ -604,6 +617,13 @@ class Connector(BaseConnector):
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}'
         data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
         if data is not None:
+            if vehicle.climatization is not None and vehicle.climatization.commands is not None \
+                    and not vehicle.climatization.commands.contains_command('start-stop'):
+                start_stop_command = ClimatizationStartStopCommand(parent=vehicle.climatization.commands)
+                start_stop_command._add_on_set_hook(self.__on_air_conditioning_start_stop)  # pylint: disable=protected-access
+                start_stop_command.enabled = True
+                vehicle.climatization.commands.add_command(start_stop_command)
+
             if 'carCapturedTimestamp' in data and data['carCapturedTimestamp'] is not None:
                 captured_at: datetime = robust_time_parse(data['carCapturedTimestamp'])
             else:
@@ -626,6 +646,9 @@ class Connector(BaseConnector):
             else:
                 vehicle.climatization.estimated_date_reached._set_value(value=None, measured=captured_at)  # pylint: disable=protected-access
             if 'targetTemperature' in data and data['targetTemperature'] is not None:
+                # pylint: disable-next=protected-access
+                vehicle.climatization.settings.target_temperature._add_on_set_hook(self.__on_air_conditioning_target_temperature_change)
+                vehicle.climatization.settings.target_temperature._is_changeable = True  # pylint: disable=protected-access
                 unit: Temperature = Temperature.UNKNOWN
                 if 'unitInCar' in data['targetTemperature'] and data['targetTemperature']['unitInCar'] is not None:
                     if data['targetTemperature']['unitInCar'] == 'CELSIUS':
@@ -679,6 +702,9 @@ class Connector(BaseConnector):
                 vehicle.outside_temperature._set_value(value=None, measured=None, unit=Temperature.UNKNOWN)  # pylint: disable=protected-access
             if 'airConditioningAtUnlock' in data and data['airConditioningAtUnlock'] is not None:
                 if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.settings.climatization_at_unlock._add_on_set_hook(self.__on_air_conditioning_at_unlock_change)
+                    vehicle.climatization.settings.climatization_at_unlock._is_changeable = True  # pylint: disable=protected-access
                     if data['airConditioningAtUnlock'] is True:
                         # pylint: disable-next=protected-access
                         vehicle.climatization.settings.climatization_at_unlock._set_value(True, measured=captured_at)
@@ -709,6 +735,9 @@ class Connector(BaseConnector):
                     vehicle.specification.steering_wheel_position._set_value(None, measured=captured_at)
             if 'windowHeatingEnabled' in data and data['windowHeatingEnabled'] is not None:
                 if vehicle.climatization is not None and vehicle.climatization.settings is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.settings.window_heating._add_on_set_hook(self.__on_air_conditioning_window_heating_change)
+                    vehicle.climatization.settings.window_heating._is_changeable = True  # pylint: disable=protected-access
                     if data['windowHeatingEnabled'] is True:
                         # pylint: disable-next=protected-access
                         vehicle.climatization.settings.window_heating._set_value(True, measured=captured_at)
@@ -1295,3 +1324,165 @@ class Connector(BaseConnector):
 
     def get_version(self) -> str:
         return __version__
+
+    def __on_air_conditioning_target_temperature_change(self, temperature_attribute: TemperatureAttribute, target_temperature: float) -> float:
+        """
+        Callback for the climatization target temperature change.
+
+        Args:
+            temperature_attribute (TemperatureAttribute): The temperature attribute that changed.
+            target_temperature (float): The new target temperature.
+        """
+        if temperature_attribute.parent is None or temperature_attribute.parent.parent is None \
+                or temperature_attribute.parent.parent.parent is None or not isinstance(temperature_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = temperature_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        setting_dict = {}
+        # Round target temperature to nearest 0.5
+        setting_dict['temperatureValue'] = round(target_temperature * 2) / 2
+        if temperature_attribute.unit == Temperature.C:
+            setting_dict['unitInCar'] = 'CELSIUS'
+        elif temperature_attribute.unit == Temperature.F:
+            setting_dict['unitInCar'] = 'FAHRENHEIT'
+        elif temperature_attribute.unit == Temperature.K:
+            setting_dict['unitInCar'] = 'KELVIN'
+        else:
+            raise SetterError(f'Unknown temperature unit {temperature_attribute.unit}')
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/settings/target-temperature'
+        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+        if settings_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not set target temperature (%s)', settings_response.status_code)
+            raise SetterError(f'Could not set value ({settings_response.status_code})')
+        return target_temperature
+
+    def __on_air_conditioning_at_unlock_change(self, at_unlock_attribute: BooleanAttribute, at_unlock_value: bool) -> bool:
+        if at_unlock_attribute.parent is None or at_unlock_attribute.parent.parent is None \
+                or at_unlock_attribute.parent.parent.parent is None or not isinstance(at_unlock_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = at_unlock_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        setting_dict = {}
+        # Round target temperature to nearest 0.5
+        setting_dict['airConditioningAtUnlockEnabled'] = at_unlock_value
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/settings/ac-at-unlock'
+        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+        if settings_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not set air conditioning at unlock (%s)', settings_response.status_code)
+            raise SetterError(f'Could not set value ({settings_response.status_code})')
+        return at_unlock_value
+
+    def __on_air_conditioning_window_heating_change(self, window_heating_attribute: BooleanAttribute, window_heating_value: bool) -> bool:
+        if window_heating_attribute.parent is None or window_heating_attribute.parent.parent is None \
+                or window_heating_attribute.parent.parent.parent is None or not isinstance(window_heating_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = window_heating_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        setting_dict = {}
+        # Round target temperature to nearest 0.5
+        setting_dict['windowHeatingEnabled'] = window_heating_value
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/settings/ac-at-unlock'
+        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+        if settings_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not set air conditioning window heating (%s)', settings_response.status_code)
+            raise SetterError(f'Could not set value ({settings_response.status_code})')
+        return window_heating_value
+
+    def __on_air_conditioning_start_stop(self, start_stop_command: ClimatizationStartStopCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if start_stop_command.parent is None or start_stop_command.parent.parent is None \
+                or start_stop_command.parent.parent.parent is None or not isinstance(start_stop_command.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise SetterError('Command arguments are not a dictionary')
+        vehicle: SkodaVehicle = start_stop_command.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise SetterError('Command argument missing')
+        command_dict = {}
+        if command_arguments['command'] == ClimatizationStartStopCommand.Command.START:
+            command_dict['heaterSource'] = 'ELECTRIC'
+            command_dict['targetTemperature'] = {}
+            if 'target_temperature' in command_arguments:
+                # Round target temperature to nearest 0.5
+                command_dict['targetTemperature']['temperatureValue'] = round(command_arguments['target_temperature'] * 2) / 2
+                if 'target_temperature_unit' in command_arguments:
+                    if not isinstance(command_arguments['target_temperature_unit'], Temperature):
+                        raise SetterError('Temperature unit is not of type Temperature')
+                    if command_arguments['target_temperature_unit'] == Temperature.C:
+                        command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
+                    elif command_arguments['target_temperature_unit'] == Temperature.F:
+                        command_dict['targetTemperature']['unitInCar'] = 'FAHRENHEIT'
+                    elif command_arguments['target_temperature_unit'] == Temperature.K:
+                        command_dict['targetTemperature']['unitInCar'] = 'KELVIN'
+                    else:
+                        raise SetterError(f'Unknown temperature unit {command_arguments['target_temperature_unit']}')
+                else:
+                    command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
+            elif start_stop_command.parent is not None and (climatization := start_stop_command.parent.parent) is not None \
+                    and isinstance(climatization, Climatization) and climatization.settings is not None \
+                    and climatization.settings.target_temperature is not None and climatization.settings.target_temperature.enabled \
+                    and climatization.settings.target_temperature.value is not None:  # pylint: disable=too-many-boolean-expressions
+                # Round target temperature to nearest 0.5
+                command_dict['targetTemperature']['temperatureValue'] = round(climatization.settings.target_temperature.value * 2) / 2
+                if climatization.settings.target_temperature.unit == Temperature.C:
+                    command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
+                elif climatization.settings.target_temperature.unit == Temperature.F:
+                    command_dict['targetTemperature']['unitInCar'] = 'FAHRENHEIT'
+                elif climatization.settings.target_temperature.unit == Temperature.K:
+                    command_dict['targetTemperature']['unitInCar'] = 'KELVIN'
+                else:
+                    raise SetterError(f'Unknown temperature unit {climatization.settings.target_temperature.unit}')
+            else:
+                command_dict['targetTemperature']['temperatureValue'] = 25.0
+                command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/start'
+            settings_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+        elif command_arguments['command'] == ClimatizationStartStopCommand.Command.STOP:
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/stop'
+            settings_response: requests.Response = self.session.post(url, allow_redirects=True)
+        else:
+            raise SetterError(f'Unknown command {command_arguments["command"]}')
+
+        if settings_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not start/stop air conditioning (%s: %s)', settings_response.status_code, settings_response.text)
+            raise SetterError(f'Could not start/stop air conditioning ({settings_response.status_code}: {settings_response.text})')
+        return command_arguments
+
+    def __on_charging_start_stop(self, start_stop_command: ChargingStartStopCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if start_stop_command.parent is None or start_stop_command.parent.parent is None \
+                or start_stop_command.parent.parent.parent is None or not isinstance(start_stop_command.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise SetterError('Command arguments are not a dictionary')
+        vehicle: SkodaVehicle = start_stop_command.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise SetterError('Command argument missing')
+        if command_arguments['command'] == ChargingStartStopCommand.Command.START:
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/start'
+            settings_response: requests.Response = self.session.post(url, allow_redirects=True)
+        elif command_arguments['command'] == ChargingStartStopCommand.Command.STOP:
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/stop'
+            settings_response: requests.Response = self.session.post(url, allow_redirects=True)
+        else:
+            raise SetterError(f'Unknown command {command_arguments["command"]}')
+
+        if settings_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not start/stop charging (%s: %s)', settings_response.status_code, settings_response.text)
+            raise SetterError(f'Could not start/stop charging ({settings_response.status_code}: {settings_response.text})')
+        return command_arguments

{carconnectivity_connector_skoda-0.1a18 → carconnectivity_connector_skoda-0.1a20}/src/carconnectivity_connectors/skoda/error.py

@@ -49,4 +49,5 @@ class Error(GenericObject):
         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_connector_skoda-0.1a18 → carconnectivity_connector_skoda-0.1a20}/src/carconnectivity_connectors/skoda/mqtt_client.py

@@ -21,7 +21,7 @@ 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.units import Speed, Power, Length
 
 from carconnectivity_connectors.skoda.vehicle import SkodaVehicle, SkodaElectricVehicle
 from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
@@ -497,7 +497,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                         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:
@@ -514,7 +514,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                         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:
@@ -530,7 +530,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 try:
                                     self._skoda_connector.fetch_air_conditioning(vehicle, no_cache=True)
                                 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)
@@ -599,7 +599,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                     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')
@@ -625,7 +625,10 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 except CarConnectivityError as e:
                                     LOG.error('Error while fetching air-conditioning: %s', e)
                                 return
-                if operation_request == 'charging/start-stop-charging' \
+                            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' \
@@ -642,6 +645,9 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 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_connector_skoda-0.1a18 → carconnectivity_connector_skoda-0.1a20}/src/carconnectivity_connectors/skoda/vehicle.py

@@ -27,6 +27,7 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
             self.capabilities = Capabilities(vehicle=self)
+        self.manufacturer._set_value(value='Škoda')  # pylint: disable=protected-access
 
     def __str__(self) -> str:
         return_string: str = f'\t{self.capabilities}\n'