carconnectivity-connector-skoda 0.1a21__py3-none-any.whl → 0.2a1__py3-none-any.whl

{carconnectivity_connector_skoda-0.1a21.dist-info → carconnectivity_connector_skoda-0.2a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-skoda
-Version: 0.1a21
+Version: 0.2a1
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License
@@ -37,7 +37,7 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity
+Requires-Dist: carconnectivity>=0.2a1
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
 Requires-Dist: jwt~=1.3.1

{carconnectivity_connector_skoda-0.1a21.dist-info → carconnectivity_connector_skoda-0.2a1.dist-info}/RECORD

@@ -1,12 +1,13 @@
 carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=-vcE8ACd4f4xkWjtAIGu7OmA4mHDuj0tWUvm5MRRZ38,409
-carconnectivity_connectors/skoda/capability.py,sha256=JlNEaisVYF8qWv0wNDHTaas36uIpTIQ3NVR69wesiYQ,4513
+carconnectivity_connectors/skoda/_version.py,sha256=4Y9bnt1x-p71kTX4650igUjzXxyHB_QN6k4UFEycuZQ,408
+carconnectivity_connectors/skoda/capability.py,sha256=SnK9xVsqDA5EcWtBznzfWxe6gIpkYdjgY3UzNIc3OCY,4198
 carconnectivity_connectors/skoda/charging.py,sha256=rG_GoDPetjyjWCyV6l65hgEDU6ths6MkMQ0KL25rbVU,6663
 carconnectivity_connectors/skoda/climatization.py,sha256=-Nk4tO5C5_YYNQfUIUWBL7mGgR6-J0_pOZplLK8p_ms,1627
-carconnectivity_connectors/skoda/connector.py,sha256=KWQWWz1KIf_Sx2t_wqYCb1yz2FywijI9yXhsWYouLRU,109729
+carconnectivity_connectors/skoda/command_impl.py,sha256=WdgxWPgi82-UgmyFpiSZE-KHRtRjqn7CH-YX9N3bAoI,2875
+carconnectivity_connectors/skoda/connector.py,sha256=2S8DVtk9KX-y9UDRtm9wbtqMUe6JNBe9mn46XsoeceY,105145
 carconnectivity_connectors/skoda/error.py,sha256=EnzzDxxJ1fswYT5QnMOVSebfoAcqoPmHKcG5i0Tqk3E,2405
-carconnectivity_connectors/skoda/mqtt_client.py,sha256=oLmITkh_KKtFyaf2TLxqh2M-nSsKaO0n0t5Vnwd50Sk,37576
-carconnectivity_connectors/skoda/vehicle.py,sha256=JKLqb6F4RyJ4C3D_sc6kcsdlqxZSlmdJNQfW04m7u78,3204
+carconnectivity_connectors/skoda/mqtt_client.py,sha256=lfHJfKOl-FBVd5hV6cS6ZMpZ53ktXyVc4lafvQls-Tk,37748
+carconnectivity_connectors/skoda/vehicle.py,sha256=_ALtlBy7sKVHmqpqAhWNbMd9dto915_SdNWcRi_AqYU,3088
 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
@@ -14,8 +15,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.1a21.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.1a21.dist-info/METADATA,sha256=bue0YMrsf7JVL00eAshzG1RcLlz1Xh54HZAMz9F2SbE,5327
-carconnectivity_connector_skoda-0.1a21.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-carconnectivity_connector_skoda-0.1a21.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.1a21.dist-info/RECORD,,
+carconnectivity_connector_skoda-0.2a1.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_skoda-0.2a1.dist-info/METADATA,sha256=gd-yKmVlkqZxS3VPnPOVx_ixUTdNWMJw0XpTiqRVtu4,5333
+carconnectivity_connector_skoda-0.2a1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+carconnectivity_connector_skoda-0.2a1.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.2a1.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.1a21'
-__version_tuple__ = version_tuple = (0, 1)
+__version__ = version = '0.2a1'
+__version_tuple__ = version_tuple = (0, 2)

carconnectivity_connectors/skoda/capability.py

@@ -89,12 +89,6 @@ class Capabilities(GenericObject):
         """
         return capability_id in self.__capabilities
 
-    def __str__(self) -> str:
-        return_string = 'Capabilities:\n'
-        for capability in self.__capabilities.values():
-            return_string += f'\t{capability}\n'
-        return return_string
-
 
 class Capability(GenericObject):
     """
@@ -113,10 +107,6 @@ class Capability(GenericObject):
         self.enabled = True
         self.delay_notifications = False
 
-    def __str__(self) -> str:
-        return_string = f'{self.capability_id}'
-        return return_string
-
     class Status(IntEnum):
         """
         Enum for capability status.

carconnectivity_connectors/skoda/command_impl.py

@@ -0,0 +1,72 @@
+"""This module defines the classes that represent attributes in the CarConnectivity system."""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Dict, Union
+
+from enum import Enum
+import argparse
+import logging
+
+from carconnectivity.commands import GenericCommand
+from carconnectivity.objects import GenericObject
+from carconnectivity.errors import SetterError
+from carconnectivity.util import ThrowingArgumentParser
+
+if TYPE_CHECKING:
+    from carconnectivity.objects import Optional
+
+LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.skoda")
+
+
+class SpinCommand(GenericCommand):
+    """
+    SpinCommand is a command class for verifying the spin
+
+    """
+    def __init__(self, name: str = 'spin', parent: Optional[GenericObject] = None) -> None:
+        super().__init__(name=name, parent=parent)
+
+    @property
+    def value(self) -> Optional[Union[str, Dict]]:
+        return super().value
+
+    @value.setter
+    def value(self, new_value: Optional[Union[str, Dict]]) -> None:
+        if isinstance(new_value, str):
+            parser = ThrowingArgumentParser(prog='', add_help=False, exit_on_error=False)
+            parser.add_argument('command', help='Command to execute', type=SpinCommand.Command,
+                                choices=list(SpinCommand.Command))
+            parser.add_argument('--spin', dest='spin', help='Spin to be used instead of spin from config or .netrc', type=str, required=False,
+                                default=None)
+            try:
+                args = parser.parse_args(new_value.split(sep=' '))
+            except argparse.ArgumentError as e:
+                raise SetterError(f'Invalid format for SpinCommand: {e.message} {parser.format_usage()}') from e
+
+            newvalue_dict = {}
+            newvalue_dict['command'] = args.command
+            if args.spin is not None:
+                newvalue_dict['spin'] = args.spin
+            new_value = newvalue_dict
+        elif isinstance(new_value, dict):
+            if 'command' in new_value and isinstance(new_value['command'], str):
+                if new_value['command'] in SpinCommand.Command:
+                    new_value['command'] = SpinCommand.Command(new_value['command'])
+                else:
+                    raise ValueError('Invalid value for SpinCommand. '
+                                     f'Command must be one of {SpinCommand.Command}')
+        if self._is_changeable:
+            for hook in self._on_set_hooks:
+                new_value = hook(self, new_value)
+            self._set_value(new_value)
+        else:
+            raise TypeError('You cannot set this attribute. Attribute is not mutable.')
+
+    class Command(Enum):
+        """
+        Enum class representing different commands for SPIN.
+
+        """
+        VERIFY = 'verify'
+
+        def __str__(self) -> str:
+            return self.value

carconnectivity_connectors/skoda/connector.py

@@ -15,7 +15,7 @@ import requests
 from carconnectivity.garage import Garage
 from carconnectivity.vehicle import GenericVehicle
 from carconnectivity.errors import AuthenticationError, TooManyRequestsError, RetrievalError, APIError, APICompatibilityError, \
-    TemporaryAuthenticationError, ConfigurationError, SetterError
+    TemporaryAuthenticationError, ConfigurationError, SetterError, CommandError
 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
@@ -27,7 +27,8 @@ 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.commands import Commands
+from carconnectivity.command_impl import ClimatizationStartStopCommand, ChargingStartStopCommand, HonkAndFlashCommand, LockUnlockCommand, WakeSleepCommand
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
@@ -39,6 +40,7 @@ from carconnectivity_connectors.skoda.climatization import SkodaClimatization
 from carconnectivity_connectors.skoda.error import Error
 from carconnectivity_connectors.skoda._version import __version__
 from carconnectivity_connectors.skoda.mqtt_client import SkodaMQTTClient
+from carconnectivity_connectors.skoda.command_impl import SpinCommand
 
 if TYPE_CHECKING:
     from typing import Dict, List, Optional, Any, Set, Union
@@ -69,6 +71,7 @@ class Connector(BaseConnector):
 
         self.connected: BooleanAttribute = BooleanAttribute(name="connected", parent=self)
         self.interval: DurationAttribute = DurationAttribute(name="interval", parent=self)
+        self.commands: Commands = Commands(parent=self)
 
         self.user_id: Optional[str] = None
 
@@ -91,6 +94,11 @@ class Connector(BaseConnector):
                 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))
 
+        if 'spin' in config and config['spin'] is not None:
+            self._spin: Optional[str] = config['spin']
+        else:
+            self._spin = None
+
         username: Optional[str] = None
         password: Optional[str] = None
         if 'username' in self.config and 'password' in self.config:
@@ -106,7 +114,13 @@ class Connector(BaseConnector):
                 secret: tuple[str, str, str] | None = secrets.authenticators("skoda")
                 if secret is None:
                     raise AuthenticationError(f'Authentication using {netrc_filename} failed: skoda not found in netrc')
-                username, _, password = secret
+                username, account, password = secret
+
+                if self._spin is None and account is not None:
+                    try:
+                        self._spin = account
+                    except ValueError as err:
+                        LOG.error('Could not parse spin from netrc: %s', err)
             except netrc.NetrcParseError as err:
                 LOG.error('Authentification using %s failed: %s', netrc_filename, err)
                 raise AuthenticationError(f'Authentication using {netrc_filename} failed: {err}') from err
@@ -241,6 +255,12 @@ class Connector(BaseConnector):
 
         This method calls the `fetch_vehicles` method to retrieve vehicle data.
         """
+        # Add spin command
+        if self.commands is not None and not self.commands.contains_command('spin'):
+            spin_command = SpinCommand(parent=self.commands)
+            spin_command._add_on_set_hook(self.__on_spin)  # pylint: disable=protected-access
+            spin_command.enabled = True
+            self.commands.add_command(spin_command)
         self.fetch_vehicles()
         self.car_connectivity.transaction_end()
 
@@ -348,10 +368,11 @@ 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 not vehicle.climatization.commands.contains_command('start-stop'):
+                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:
@@ -872,6 +893,32 @@ class Connector(BaseConnector):
             else:
                 vehicle.capabilities.clear_capabilities()
 
+            if vehicle.capabilities.has_capability('VEHICLE_WAKE_UP_TRIGGER'):
+                if vehicle.commands is not None and vehicle.commands.commands is not None \
+                        and not vehicle.commands.contains_command('wake-sleep'):
+                    wake_sleep_command = WakeSleepCommand(parent=vehicle.commands)
+                    wake_sleep_command._add_on_set_hook(self.__on_wake_sleep)  # pylint: disable=protected-access
+                    wake_sleep_command.enabled = True
+                    vehicle.commands.add_command(wake_sleep_command)
+
+            # Add HONK_AND_FLASH command if necessary capabilities are available
+            if vehicle.capabilities.has_capability('HONK_AND_FLASH') and vehicle.capabilities.has_capability('PARKING_POSITION'):
+                if vehicle.commands is not None and vehicle.commands.commands is not None \
+                        and not vehicle.commands.contains_command('honk-flash'):
+                    honk_flash_command = HonkAndFlashCommand(parent=vehicle.commands)
+                    honk_flash_command._add_on_set_hook(self.__on_honk_flash)  # pylint: disable=protected-access
+                    honk_flash_command.enabled = True
+                    vehicle.commands.add_command(honk_flash_command)
+
+            # Add lock and unlock command
+            if vehicle.capabilities.has_capability('ACCESS'):
+                if vehicle.doors is not None and vehicle.doors.commands is not None and vehicle.doors.commands.commands is not None \
+                        and not vehicle.doors.commands.contains_command('lock-unlock'):
+                    lock_unlock_command = LockUnlockCommand(parent=vehicle.doors.commands)
+                    lock_unlock_command._add_on_set_hook(self.__on_lock_unlock)  # pylint: disable=protected-access
+                    lock_unlock_command.enabled = True
+                    vehicle.doors.commands.add_command(lock_unlock_command)
+
             if 'specification' in vehicle_data and vehicle_data['specification'] is not None:
                 if 'model' in vehicle_data['specification'] and vehicle_data['specification']['model'] is not None:
                     vehicle.model._set_value(vehicle_data['specification']['model'])  # pylint: disable=protected-access
@@ -1087,187 +1134,6 @@ class Connector(BaseConnector):
             log_extra_keys(LOG_API, f'/api/v2/vehicle-status/{vin}', vehicle_status_data, {'overall', 'carCapturedTimestamp'})
         return vehicle
 
-        # def fetch_vehicle_status_second_api(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
-        #     """
-        #     Fetches the status of a vehicle from other Skoda API.
-        #
-        #     Args:
-        #         vehicle (GenericVehicle): The vehicle object containing the VIN.
-        #
-        #     Returns:
-        #         None
-        #     """
-        #     vin = vehicle.vin.value
-        #     if vin is None:
-        #         raise APIError('VIN is missing')
-        #     url = f'https://api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}'
-        #     vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #     if vehicle_status_data:
-        #         if 'remote' in vehicle_status_data and vehicle_status_data['remote'] is not None:
-        #             vehicle_status_data = vehicle_status_data['remote']
-        #     if vehicle_status_data:
-        #         if 'capturedAt' in vehicle_status_data and vehicle_status_data['capturedAt'] is not None:
-        #             captured_at: datetime = robust_time_parse(vehicle_status_data['capturedAt'])
-        #         else:
-        #             raise APIError('Could not fetch vehicle status, capturedAt missing')
-        #         if 'mileageInKm' in vehicle_status_data and vehicle_status_data['mileageInKm'] is not None:
-        #             # pylint: disable-next=protected-access
-        #             vehicle.odometer._set_value(value=vehicle_status_data['mileageInKm'], measured=captured_at, unit=Length.KM)
-        #         else:
-        #             vehicle.odometer._set_value(value=None, measured=captured_at, unit=Length.KM)  # pylint: disable=protected-access
-        #         if 'status' in vehicle_status_data and vehicle_status_data['status'] is not None:
-        #             if 'open' in vehicle_status_data['status'] and vehicle_status_data['status']['open'] is not None:
-        #                 if vehicle_status_data['status']['open'] == 'YES':
-        #                     vehicle.doors.open_state._set_value(Doors.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['status']['open'] == 'NO':
-        #                     vehicle.doors.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     vehicle.doors.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     LOG_API.info('Unknown door open state: %s', vehicle_status_data['status']['open'])
-        #             else:
-        #                 vehicle.doors.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             if 'locked' in vehicle_status_data['status'] and vehicle_status_data['status']['locked'] is not None:
-        #                 if vehicle_status_data['status']['locked'] == 'YES':
-        #                     vehicle.doors.lock_state._set_value(Doors.LockState.LOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['status']['locked'] == 'NO':
-        #                     vehicle.doors.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     vehicle.doors.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     LOG_API.info('Unknown door lock state: %s', vehicle_status_data['status']['locked'])
-        #             else:
-        #                 vehicle.doors.lock_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #         else:
-        #             vehicle.doors.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             vehicle.doors.lock_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #         if 'doors' in vehicle_status_data and vehicle_status_data['doors'] is not None:
-        #             seen_door_ids: set[str] = set()
-        #             for door_status in vehicle_status_data['doors']:
-        #                 if 'name' in door_status and door_status['name'] is not None:
-        #                     door_id = door_status['name']
-        #                     seen_door_ids.add(door_id)
-        #                     if door_id in vehicle.doors.doors:
-        #                         door: Doors.Door = vehicle.doors.doors[door_id]
-        #                     else:
-        #                         door = Doors.Door(door_id=door_id, doors=vehicle.doors)
-        #                         vehicle.doors.doors[door_id] = door
-        #                     if 'status' in door_status and door_status['status'] is not None:
-        #                         if door_status['status'] == 'OPEN':
-        #                             door.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif door_status['status'] == 'CLOSED':
-        #                             door.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif door_status['status'] == 'LOCKED':
-        #                             door.lock_state._set_value(Doors.LockState.LOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif door_status['status'] == 'UNSUPPORTED':
-        #                             door.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                         else:
-        #                             LOG_API.info('Unknown door status %s', door_status['status'])
-        #                             door.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     else:
-        #                         door.lock_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                         door.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     raise APIError('Could not parse door, name missing')
-        #                 log_extra_keys(LOG_API, 'doors', door_status, {'name', 'status'})
-        #             for door_to_remove in set(vehicle.doors.doors) - seen_door_ids:
-        #                 vehicle.doors.doors[door_to_remove].enabled = False
-        #                 vehicle.doors.doors.pop(door_to_remove)
-        #             log_extra_keys(LOG_API, 'status', vehicle_status_data['status'],  {'open', 'locked'})
-        #         else:
-        #             vehicle.doors.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             vehicle.doors.doors = {}
-        #         if 'windows' in vehicle_status_data and vehicle_status_data['windows'] is not None:
-        #             seen_window_ids: set[str] = set()
-        #             all_windows_closed: bool = True
-        #             for window_status in vehicle_status_data['windows']:
-        #                 if 'name' in window_status and window_status['name'] is not None:
-        #                     window_id = window_status['name']
-        #                     seen_window_ids.add(window_id)
-        #                     if window_id in vehicle.windows.windows:
-        #                         window: Windows.Window = vehicle.windows.windows[window_id]
-        #                     else:
-        #                         window = Windows.Window(window_id=window_id, windows=vehicle.windows)
-        #                         vehicle.windows.windows[window_id] = window
-        #                     if 'status' in window_status and window_status['status'] is not None:
-        #                         if window_status['status'] == 'OPEN':
-        #                             all_windows_closed = False
-        #                             window.open_state._set_value(Windows.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif window_status['status'] == 'CLOSED':
-        #                             window.open_state._set_value(Windows.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif window_status['status'] == 'UNSUPPORTED':
-        #                             window.open_state._set_value(Windows.OpenState.UNSUPPORTED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif window_status['status'] == 'INVALID':
-        #                             window.open_state._set_value(Windows.OpenState.INVALID, measured=captured_at)  # pylint: disable=protected-access
-        #                         else:
-        #                             LOG_API.info('Unknown window status %s', window_status['status'])
-        #                             window.open_state._set_value(Windows.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     else:
-        #                         window.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     raise APIError('Could not parse window, name missing')
-        #                 log_extra_keys(LOG_API, 'doors', window_status, {'name', 'status'})
-        #             for window_to_remove in set(vehicle.windows.windows) - seen_window_ids:
-        #                 vehicle.windows.windows[window_to_remove].enabled = False
-        #                 vehicle.windows.windows.pop(window_to_remove)
-        #             if all_windows_closed:
-        #                 vehicle.windows.open_state._set_value(Windows.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #             else:
-        #                 vehicle.windows.open_state._set_value(Windows.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #         else:
-        #             vehicle.windows.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             vehicle.windows.windows = {}
-        #         if 'lights' in vehicle_status_data and vehicle_status_data['lights'] is not None:
-        #             seen_light_ids: set[str] = set()
-        #             if 'overallStatus' in vehicle_status_data['lights'] and vehicle_status_data['lights']['overallStatus'] is not None:
-        #                 if vehicle_status_data['lights']['overallStatus'] == 'ON':
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.ON, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['lights']['overallStatus'] == 'OFF':
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.OFF, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['lights']['overallStatus'] == 'INVALID':
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.INVALID, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     LOG_API.info('Unknown light status %s', vehicle_status_data['lights']['overallStatus'])
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #             else:
-        #                 vehicle.lights.light_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             if 'lightsStatus' in vehicle_status_data['lights'] and vehicle_status_data['lights']['lightsStatus'] is not None:
-        #                 for light_status in vehicle_status_data['lights']['lightsStatus']:
-        #                     if 'name' in light_status and light_status['name'] is not None:
-        #                         light_id: str = light_status['name']
-        #                         seen_light_ids.add(light_id)
-        #                         if light_id in vehicle.lights.lights:
-        #                             light: Lights.Light = vehicle.lights.lights[light_id]
-        #                         else:
-        #                             light = Lights.Light(light_id=light_id, lights=vehicle.lights)
-        #                             vehicle.lights.lights[light_id] = light
-        #                         if 'status' in light_status and light_status['status'] is not None:
-        #                             if light_status['status'] == 'ON':
-        #                                 light.light_state._set_value(Lights.LightState.ON, measured=captured_at)  # pylint: disable=protected-access
-        #                             elif light_status['status'] == 'OFF':
-        #                                 light.light_state._set_value(Lights.LightState.OFF, measured=captured_at)  # pylint: disable=protected-access
-        #                             elif light_status['status'] == 'INVALID':
-        #                                 light.light_state._set_value(Lights.LightState.INVALID, measured=captured_at)  # pylint: disable=protected-access
-        #                             else:
-        #                                 LOG_API.info('Unknown light status %s', light_status['status'])
-        #                                 light.light_state._set_value(Lights.LightState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                         else:
-        #                             light.light_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                     else:
-        #                         raise APIError('Could not parse light, name missing')
-        #                     log_extra_keys(LOG_API, 'lights', light_status, {'name', 'status'})
-        #                 for light_to_remove in set(vehicle.lights.lights) - seen_light_ids:
-        #                     vehicle.lights.lights[light_to_remove].enabled = False
-        #                     vehicle.lights.lights.pop(light_to_remove)
-        #             else:
-        #                 vehicle.lights.lights = {}
-        #             log_extra_keys(LOG_API, 'lights', vehicle_status_data['lights'], {'overallStatus', 'lightsStatus'})
-        #         log_extra_keys(LOG_API, 'vehicles', vehicle_status_data,  {'capturedAt', 'mileageInKm', 'status', 'doors', 'windows', 'lights'})
-        #     return vehicle
-
     def _record_elapsed(self, elapsed: timedelta) -> None:
         """
         Records the elapsed time.
@@ -1404,15 +1270,15 @@ class Connector(BaseConnector):
             -> 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')
+            raise CommandError('Object hierarchy is not as expected')
         if not isinstance(command_arguments, dict):
-            raise SetterError('Command arguments are not a dictionary')
+            raise CommandError('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')
+            raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
-            raise SetterError('Command argument missing')
+            raise CommandError('Command argument missing')
         command_dict = {}
         if command_arguments['command'] == ClimatizationStartStopCommand.Command.START:
             command_dict['heaterSource'] = 'ELECTRIC'
@@ -1422,7 +1288,7 @@ class Connector(BaseConnector):
                 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')
+                        raise CommandError('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:
@@ -1430,7 +1296,7 @@ class Connector(BaseConnector):
                     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']}')
+                        raise CommandError(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 \
@@ -1446,46 +1312,167 @@ class Connector(BaseConnector):
                 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}')
+                    raise CommandError(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)
+            command_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)
+            command_response: requests.Response = self.session.post(url, allow_redirects=True)
         else:
-            raise SetterError(f'Unknown command {command_arguments["command"]}')
+            raise CommandError(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})')
+        if command_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not start/stop air conditioning (%s: %s)', command_response.status_code, command_response.text)
+            raise CommandError(f'Could not start/stop air conditioning ({command_response.status_code}: {command_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')
+            raise CommandError('Object hierarchy is not as expected')
         if not isinstance(command_arguments, dict):
-            raise SetterError('Command arguments are not a dictionary')
+            raise CommandError('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')
+            raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
-            raise SetterError('Command argument missing')
+            raise CommandError('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)
+            command_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)
+            command_response: requests.Response = self.session.post(url, allow_redirects=True)
         else:
-            raise SetterError(f'Unknown command {command_arguments["command"]}')
+            raise CommandError(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})')
+        if command_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not start/stop charging (%s: %s)', command_response.status_code, command_response.text)
+            raise CommandError(f'Could not start/stop charging ({command_response.status_code}: {command_response.text})')
+        return command_arguments
+
+    def __on_honk_flash(self, honk_flash_command: HonkAndFlashCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if honk_flash_command.parent is None or honk_flash_command.parent.parent is None \
+                or not isinstance(honk_flash_command.parent.parent, SkodaVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        vehicle: SkodaVehicle = honk_flash_command.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise CommandError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        if 'duration' in command_arguments:
+            LOG.warning('Duration argument is not supported by the Skoda API')
+        command_dict = {}
+        if command_arguments['command'] in [HonkAndFlashCommand.Command.FLASH, HonkAndFlashCommand.Command.HONK_AND_FLASH]:
+            command_dict['mode'] = command_arguments['command'].name
+            command_dict['vehiclePosition'] = {}
+            if vehicle.position is None or vehicle.position.latitude is None or vehicle.position.longitude is None \
+                    or vehicle.position.latitude.value is None or vehicle.position.longitude.value is None \
+                    or not vehicle.position.latitude.enabled or not vehicle.position.longitude.enabled:
+                raise CommandError('Can only execute honk and flash commands if vehicle position is known')
+            command_dict['vehiclePosition']['latitude'] = vehicle.position.latitude.value
+            command_dict['vehiclePosition']['longitude'] = vehicle.position.longitude.value
+
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-access/{vin}/honk-and-flash'
+            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+            if command_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not execute honk or flash command (%s: %s)', command_response.status_code, command_response.text)
+                raise CommandError(f'Could not execute honk or flash command ({command_response.status_code}: {command_response.text})')
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        return command_arguments
+
+    def __on_lock_unlock(self, lock_unlock_command: LockUnlockCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if lock_unlock_command.parent is None or lock_unlock_command.parent.parent is None \
+                or lock_unlock_command.parent.parent.parent is None or not isinstance(lock_unlock_command.parent.parent.parent, SkodaVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise SetterError('Command arguments are not a dictionary')
+        vehicle: SkodaVehicle = lock_unlock_command.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise CommandError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        command_dict = {}
+        if 'spin' in command_arguments:
+            command_dict['currentSpin'] = command_arguments['spin']
+        else:
+            if self._spin is None:
+                raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+            command_dict['currentSpin'] = self._spin
+        if command_arguments['command'] == LockUnlockCommand.Command.LOCK:
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-access/{vin}/lock'
+        elif command_arguments['command'] == LockUnlockCommand.Command.UNLOCK:
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-access/{vin}/unlock'
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+        if command_response.status_code != requests.codes['accepted']:
+            LOG.error('Could not execute locking command (%s: %s)', command_response.status_code, command_response.text)
+            raise CommandError(f'Could not execute locking command ({command_response.status_code}: {command_response.text})')
+        return command_arguments
+
+    def __on_wake_sleep(self, wake_sleep_command: WakeSleepCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if wake_sleep_command.parent is None or wake_sleep_command.parent.parent is None \
+                or not isinstance(wake_sleep_command.parent.parent, GenericVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        vehicle: GenericVehicle = wake_sleep_command.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise CommandError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        if command_arguments['command'] == WakeSleepCommand.Command.WAKE:
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-wakeup/{vin}?applyRequestLimiter=true'
+
+            command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
+            if command_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not execute wake command (%s: %s)', command_response.status_code, command_response.text)
+                raise CommandError(f'Could not execute wake command ({command_response.status_code}: {command_response.text})')
+        elif command_arguments['command'] == WakeSleepCommand.Command.SLEEP:
+            raise CommandError('Sleep command not supported by vehicle. Vehicle will put itself to sleep')
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        return command_arguments
+
+    def __on_spin(self, spin_command: SpinCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        del spin_command
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        command_dict = {}
+        if self._spin is None:
+            raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+        if 'spin' in command_arguments:
+            command_dict['currentSpin'] = command_arguments['spin']
+        else:
+            if self._spin is None or self._spin == '':
+                raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+            command_dict['currentSpin'] = self._spin
+        if command_arguments['command'] == SpinCommand.Command.VERIFY:
+            url = 'https://mysmob.api.connect.skoda-auto.cz/api/v1/spin/verify'
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+        if command_response.status_code != requests.codes['ok']:
+            LOG.error('Could not execute spin command (%s: %s)', command_response.status_code, command_response.text)
+            raise CommandError(f'Could not execute spin command ({command_response.status_code}: {command_response.text})')
+        else:
+            LOG.info('Spin verify command executed successfully')
         return command_arguments

carconnectivity_connectors/skoda/mqtt_client.py

@@ -494,6 +494,8 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                             # pylint: disable-next=protected-access
                                             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

carconnectivity_connectors/skoda/vehicle.py

@@ -29,10 +29,6 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
             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'
-        return return_string
-
 
 class SkodaElectricVehicle(ElectricVehicle, SkodaVehicle):
     """