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

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

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

{carconnectivity_connector_skoda-0.1a20 → carconnectivity_connector_skoda-0.1a22}/doc/Config.md

@@ -10,11 +10,13 @@ These are the valid options for the MySkoda Connector
         "connectors": [
             {
                 "type": "skoda", // Definition for the MySkoda Connector
+                "disabled": false, // You can disable connectors without removing them from the config completely
                 "config": {
                     "log_level": "error", // set the connectos log level
                     "interval": 300, // Interval in which the server is checked in seconds
                     "username": "test@test.de", // Username of your Volkswagen Account
                     "password": "testpassword123", // Username of your Volkswagen Account
+                    "spin": 1234, //S-Pin used for some special commands like locking/unlocking
                     "netrc": "~/.netr", // netrc file if to be used for passwords
                     "api_log_level": "debug", // Show debug information regarding the API
                     "max_age": 300 //Cache requests to the server vor MAX_AGE seconds

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

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

{carconnectivity_connector_skoda-0.1a20 → carconnectivity_connector_skoda-0.1a22}/src/carconnectivity_connector_skoda.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ src/carconnectivity_connectors/skoda/_version.py
 src/carconnectivity_connectors/skoda/capability.py
 src/carconnectivity_connectors/skoda/charging.py
 src/carconnectivity_connectors/skoda/climatization.py
+src/carconnectivity_connectors/skoda/command_impl.py
 src/carconnectivity_connectors/skoda/connector.py
 src/carconnectivity_connectors/skoda/error.py
 src/carconnectivity_connectors/skoda/mqtt_client.py

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

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

carconnectivity_connector_skoda-0.1a22/src/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_connector_skoda-0.1a20 → carconnectivity_connector_skoda-0.1a22}/src/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
@@ -1009,7 +1050,10 @@ class Connector(BaseConnector):
         url = f'https://mysmob.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:
-            captured_at: datetime = robust_time_parse(vehicle_status_data['carCapturedTimestamp'])
+            if 'carCapturedTimestamp' in vehicle_status_data and vehicle_status_data['carCapturedTimestamp'] is not None:
+                captured_at: Optional[datetime] = robust_time_parse(vehicle_status_data['carCapturedTimestamp'])
+            else:
+                captured_at: Optional[datetime] = None
             if 'overall' in vehicle_status_data and vehicle_status_data['overall'] is not None:
                 if 'doorsLocked' in vehicle_status_data['overall'] and vehicle_status_data['overall']['doorsLocked'] is not None \
                         and vehicle.doors is not None:
@@ -1448,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]]) \
@@ -1475,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_connector_skoda-0.1a20 → carconnectivity_connector_skoda-0.1a22}/src/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