carconnectivity-connector-skoda 0.1a21__py3-none-any.whl → 0.1a22__py3-none-any.whl

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

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

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

@@ -1,11 +1,12 @@
 carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=-vcE8ACd4f4xkWjtAIGu7OmA4mHDuj0tWUvm5MRRZ38,409
+carconnectivity_connectors/skoda/_version.py,sha256=HEdZtBITW7HcUEt9NLSPGn_UorBnRBrHZWl8fmngNs8,409
 carconnectivity_connectors/skoda/capability.py,sha256=JlNEaisVYF8qWv0wNDHTaas36uIpTIQ3NVR69wesiYQ,4513
 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=dtJsiuhwSuR1PXz7AMrdBowHqPxw6DKSAQKk4Z63GG8,2957
+carconnectivity_connectors/skoda/connector.py,sha256=rMHAigH9t1P95vGewKxK54umBuqkI6-zFQYw5iPeols,118916
 carconnectivity_connectors/skoda/error.py,sha256=EnzzDxxJ1fswYT5QnMOVSebfoAcqoPmHKcG5i0Tqk3E,2405
-carconnectivity_connectors/skoda/mqtt_client.py,sha256=oLmITkh_KKtFyaf2TLxqh2M-nSsKaO0n0t5Vnwd50Sk,37576
+carconnectivity_connectors/skoda/mqtt_client.py,sha256=lfHJfKOl-FBVd5hV6cS6ZMpZ53ktXyVc4lafvQls-Tk,37748
 carconnectivity_connectors/skoda/vehicle.py,sha256=JKLqb6F4RyJ4C3D_sc6kcsdlqxZSlmdJNQfW04m7u78,3204
 carconnectivity_connectors/skoda/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 carconnectivity_connectors/skoda/auth/auth_util.py,sha256=dGLUbUre0HBsTg_Ii5vW34f8DLrCykYJYCyzEvUBBEE,4434
@@ -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.1a22.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_skoda-0.1a22.dist-info/METADATA,sha256=d5o6lGEA7DgbRIAn0be_LDLiLLXOIOmkGRcAdwodadw,5327
+carconnectivity_connector_skoda-0.1a22.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+carconnectivity_connector_skoda-0.1a22.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.1a22.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__ = version = '0.1a22'
 __version_tuple__ = version_tuple = (0, 1)

carconnectivity_connectors/skoda/command_impl.py

@@ -0,0 +1,74 @@
+"""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")
+
+
+class SpinCommand(GenericCommand):
+    """
+    LockUnlockCommand is a command class for locking and unlocking the vehicle.
+
+    Command (Enum): Enum class representing different commands for locking.
+
+    """
+    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

@@ -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
 
 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
@@ -348,10 +362,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 +887,32 @@ class Connector(BaseConnector):
             else:
                 vehicle.capabilities.clear_capabilities()
 
+            # 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)
+
+            # Add spin command
+            if vehicle.commands is not None and vehicle.commands.commands is not None \
+                    and not vehicle.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
+                vehicle.commands.add_command(spin_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
@@ -1451,16 +1492,16 @@ class Connector(BaseConnector):
                 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"]}')
 
-        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 SetterError(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]]) \
@@ -1478,14 +1519,112 @@ class Connector(BaseConnector):
             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)
+            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"]}')
 
-        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 SetterError(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 SetterError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise SetterError('Command arguments are not a dictionary')
+        vehicle: SkodaVehicle = honk_flash_command.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'] 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 SetterError('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 SetterError(f'Could not execute honk or flash command ({command_response.status_code}: {command_response.text})')
+        else:
+            raise SetterError(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 SetterError('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 SetterError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise SetterError('Command argument missing')
+        command_dict = {}
+        if 'spin' in command_arguments:
+            command_dict['currentSpin'] = command_arguments['spin']
+        else:
+            if self._spin is None:
+                raise SetterError('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 SetterError(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 SetterError(f'Could not execute locking command ({command_response.status_code}: {command_response.text})')
+        return command_arguments
+
+    def __on_spin(self, spin_command: SpinCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if spin_command.parent is None or spin_command.parent.parent is None or not isinstance(spin_command.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 = spin_command.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 self._spin is None:
+            raise SetterError('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:
+                raise SetterError('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/v1/spin/verify'
+        else:
+            raise SetterError(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 spin command (%s: %s)', command_response.status_code, command_response.text)
+            raise SetterError(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