carconnectivity-connector-skoda 0.1__py3-none-any.whl

carconnectivity_connectors/skoda/auth/skoda_web_session.py

@@ -0,0 +1,239 @@
+"""
+Module implements a VW Web session.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+
+from urllib.parse import parse_qsl, urlparse, urlsplit, urljoin
+
+from urllib3.util.retry import Retry
+
+import requests
+from requests.adapters import HTTPAdapter
+from requests.models import CaseInsensitiveDict
+
+from carconnectivity.errors import APICompatibilityError, AuthenticationError, RetrievalError
+
+from carconnectivity_connectors.skoda.auth.auth_util import CredentialsFormParser, HTMLFormParser, TermsAndConditionsFormParser
+from carconnectivity_connectors.skoda.auth.openid_session import OpenIDSession
+
+if TYPE_CHECKING:
+    from typing import Any, Dict
+
+
+class SkodaWebSession(OpenIDSession):
+    """
+    SkodaWebSession handles the web authentication process for Skoda's web services.
+    """
+    def __init__(self, session_user, cache, accept_terms_on_login=False, **kwargs):
+        super(SkodaWebSession, self).__init__(**kwargs)
+        self.session_user = session_user
+        self.cache = cache
+        self.accept_terms_on_login: bool = accept_terms_on_login
+
+        # Set up the web session
+        retries = Retry(
+            total=self.retries,
+            backoff_factor=0.1,
+            status_forcelist=[500],
+            raise_on_status=False
+        )
+
+        self.websession: requests.Session = requests.Session()
+        self.websession.proxies.update(self.proxies)
+        self.websession.mount('https://', HTTPAdapter(max_retries=retries))
+        self.websession.headers = CaseInsensitiveDict({
+            'user-agent': 'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 '
+                          'Chrome/74.0.3729.185 Mobile Safari/537.36',
+            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,'
+                      'application/signed-exchange;v=b3',
+            'accept-language': 'en-US,en;q=0.9',
+            'accept-encoding': 'gzip, deflate',
+            'x-requested-with': 'cz.skodaauto.connect',
+            'upgrade-insecure-requests': '1',
+        })
+
+    def do_web_auth(self, url: str) -> str:
+        """
+        Perform web authentication using the provided URL.
+
+        This method handles the web authentication process by:
+        1. Retrieving the login form.
+        2. Setting the email to the provided username.
+        3. Retrieving the password form.
+        4. Setting the credentials (email and password).
+        5. Logging in and getting the redirect URL.
+        6. Checking the URL for terms and conditions and handling consent if required.
+        7. Following redirects until the final URL is reached.
+
+        Args:
+            url (str): The URL to start the authentication process.
+
+        Returns:
+            str: The final URL after successful authentication.
+
+        Raises:
+            AuthenticationError: If terms and conditions need to be accepted.
+            RetrievalError: If there is a temporary server error during login.
+            APICompatibilityError: If forwarding occurs without 'Location' in headers.
+        """
+        # Get the login form
+        email_form: HTMLFormParser = self._get_login_form(url)
+
+        # Set email to the provided username
+        email_form.data['email'] = self.session_user.username
+
+        # Get password form
+        password_form = self._get_password_form(
+            urljoin('https://identity.vwgroup.io', email_form.target),
+            email_form.data
+        )
+
+        # Set credentials
+        password_form.data['email'] = self.session_user.username
+        password_form.data['password'] = self.session_user.password
+
+        # Log in and get the redirect URL
+        url = self._handle_login(
+            f'https://identity.vwgroup.io/signin-service/v1/{self.client_id}/{password_form.target}',
+            password_form.data
+        )
+
+        if self.redirect_uri is None:
+            raise ValueError('Redirect URI is not set')
+        # Check URL for terms and conditions
+        while True:
+            if url.startswith(self.redirect_uri):
+                break
+
+            url = urljoin('https://identity.vwgroup.io', url)
+
+            if 'terms-and-conditions' in url:
+                if self.accept_terms_on_login:
+                    url = self._handle_consent_form(url)
+                else:
+                    raise AuthenticationError(f'It seems like you need to accept the terms and conditions. '
+                                              f'Try to visit the URL "{url}" or log into smartphone app.')
+
+            response = self.websession.get(url, allow_redirects=False)
+            if response.status_code == requests.codes['internal_server_error']:
+                raise RetrievalError('Temporary server error during login')
+
+            if 'Location' not in response.headers:
+                raise APICompatibilityError('Forwarding without Location in headers')
+
+            url = response.headers['Location']
+
+        return url.replace(self.redirect_uri + '#', 'https://egal?')
+
+    def _get_login_form(self, url: str) -> HTMLFormParser:
+        while True:
+            response = self.websession.get(url, allow_redirects=False)
+            if response.status_code == requests.codes['ok']:
+                break
+
+            if response.status_code in (requests.codes['found'], requests.codes['see_other']):
+                if 'Location' not in response.headers:
+                    raise APICompatibilityError('Forwarding without Location in headers')
+
+                url = response.headers['Location']
+                continue
+
+            raise APICompatibilityError(f'Retrieving login page was not successful, '
+                                        f'status code: {response.status_code}')
+
+        # Find login form on page to obtain inputs
+        email_form = HTMLFormParser(form_id='emailPasswordForm')
+        email_form.feed(response.text)
+
+        if not email_form.target or not all(x in email_form.data for x in ['_csrf', 'relayState', 'hmac', 'email']):
+            raise APICompatibilityError('Could not find all required input fields on login page')
+
+        return email_form
+
+    def _get_password_form(self, url: str, data: Dict[str, Any]) -> CredentialsFormParser:
+        response = self.websession.post(url, data=data, allow_redirects=True)
+        if response.status_code != requests.codes['ok']:
+            raise APICompatibilityError(f'Retrieving credentials page was not successful, '
+                                        f'status code: {response.status_code}')
+
+        # Find login form on page to obtain inputs
+        credentials_form = CredentialsFormParser()
+        credentials_form.feed(response.text)
+
+        if not credentials_form.target or not all(x in credentials_form.data for x in ['relayState', 'hmac', '_csrf']):
+            raise APICompatibilityError('Could not find all required input fields on credentials page')
+
+        if credentials_form.data.get('error', None) is not None:
+            if credentials_form.data['error'] == 'validator.email.invalid':
+                raise AuthenticationError('Error during login, email invalid')
+            raise AuthenticationError(f'Error during login: {credentials_form.data["error"]}')
+
+        if 'errorCode' in credentials_form.data:
+            raise AuthenticationError('Error during login, is the username correct?')
+
+        if credentials_form.data.get('registerCredentialsPath', None) == 'register':
+            raise AuthenticationError(f'Error during login, account {self.session_user.username} does not exist')
+
+        return credentials_form
+
+    def _handle_login(self, url: str, data: Dict[str, Any]) -> str:
+        response: requests.Response = self.websession.post(url, data=data, allow_redirects=False)
+
+        if response.status_code == requests.codes['internal_server_error']:
+            raise RetrievalError('Temporary server error during login')
+
+        if response.status_code not in (requests.codes['found'], requests.codes['see_other']):
+            raise APICompatibilityError(f'Forwarding expected (status code 302), '
+                                        f'but got status code {response.status_code}')
+
+        if 'Location' not in response.headers:
+            raise APICompatibilityError('Forwarding without Location in headers')
+
+        # Parse parameters from forwarding url
+        params: Dict[str, str] = dict(parse_qsl(urlsplit(response.headers['Location']).query))
+
+        # Check for login error
+        if 'error' in params and params['error']:
+            error_messages: Dict[str, str] = {
+                'login.errors.password_invalid': 'Password is invalid',
+                'login.error.throttled': 'Login throttled, probably too many wrong logins. You have to wait '
+                                         'a few minutes until a new login attempt is possible'
+            }
+
+            raise AuthenticationError(error_messages.get(params['error'], params['error']))
+
+        # Check for user ID
+        if 'userId' not in params or not params['userId']:
+            if 'updated' in params and params['updated'] == 'dataprivacy':
+                raise AuthenticationError('You have to login at myvolkswagen.de and accept the terms and conditions')
+            raise APICompatibilityError('No user ID provided')
+
+        self.user_id = params['userId']  # pylint: disable=unused-private-member
+        return response.headers['Location']
+
+    def _handle_consent_form(self, url: str) -> str:
+        response = self.websession.get(url, allow_redirects=False)
+        if response.status_code == requests.codes['internal_server_error']:
+            raise RetrievalError('Temporary server error during login')
+
+        # Find form on page to obtain inputs
+        tc_form = TermsAndConditionsFormParser()
+        tc_form.feed(response.text)
+
+        # Remove query from URL
+        url = urlparse(response.url)._replace(query='').geturl()
+
+        response = self.websession.post(url, data=tc_form.data, allow_redirects=False)
+        if response.status_code == requests.codes['internal_server_error']:
+            raise RetrievalError('Temporary server error during login')
+
+        if response.status_code not in (requests.codes['found'], requests.codes['see_other']):
+            raise APICompatibilityError('Forwarding expected (status code 302), '
+                                        f'but got status code {response.status_code}')
+
+        if 'Location' not in response.headers:
+            raise APICompatibilityError('Forwarding without Location in headers')
+
+        return response.headers['Location']

carconnectivity_connectors/skoda/capability.py

@@ -0,0 +1,135 @@
+"""Module for Skoda vehicle capability class."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import IntEnum
+
+from carconnectivity.objects import GenericObject
+from carconnectivity.attributes import StringAttribute
+
+if TYPE_CHECKING:
+    from typing import Dict, Optional
+    from carconnectivity_connectors.skoda.vehicle import SkodaVehicle
+
+
+class Capabilities(GenericObject):
+    """
+    Represents the capabilities of a Skoda vehicle.
+    """
+    def __init__(self, vehicle: SkodaVehicle) -> None:
+        super().__init__(object_id='capabilities', parent=vehicle)
+        self.__capabilities: Dict[str, Capability] = {}
+
+    @property
+    def capabilities(self) -> Dict[str, Capability]:
+        """
+        Retrieve the capabilities of the vehicle.
+
+        Returns:
+            Dict[str, Capability]: A dictionary of capabilities.
+        """
+        return self.__capabilities
+
+    def add_capability(self, capability_id: str, capability: Capability) -> None:
+        """
+        Adds a capability to the Capabilities of the vehicle.
+
+        Args:
+            capability_id (str): The unique identifier of the capability.
+            capability (Capability): The capability object to be added.
+
+        Returns:
+            None
+        """
+        self.__capabilities[capability_id] = capability
+
+    def remove_capability(self, capability_id: str) -> None:
+        """
+        Remove a capability from the Capabilities by its capability ID.
+
+        Args:
+            capability_id (str): The ID of the capability to be removed.
+
+        Returns:
+            None
+        """
+        if capability_id in self.__capabilities:
+            del self.__capabilities[capability_id]
+
+    def clear_capabilities(self) -> None:
+        """
+        Remove all capabilities from the Capabilities.
+
+        Returns:
+            None
+        """
+        self.__capabilities.clear()
+
+    def get_capability(self, capability_id: str) -> Optional[Capability]:
+        """
+        Retrieve a capability from the Capabilities by its capability ID.
+
+        Args:
+            capability_id (str): The unique identifier of the capability to retrieve.
+
+        Returns:
+            Capability: The capability object if found, otherwise None.
+        """
+        return self.__capabilities.get(capability_id)
+
+    def has_capability(self, capability_id: str) -> bool:
+        """
+        Check if the Capabilities contains a capability with the specified ID.
+
+        Args:
+            capability_id (str): The unique identifier of the capability to check.
+
+        Returns:
+            bool: True if the capability exists, otherwise False.
+        """
+        return capability_id in self.__capabilities
+
+
+class Capability(GenericObject):
+    """
+    Represents a capability of a Skoda vehicle.
+    """
+
+    def __init__(self, capability_id: str, capabilities: Capabilities) -> None:
+        if capabilities is None:
+            raise ValueError('Cannot create capability without Capabilities')
+        if id is None:
+            raise ValueError('Capability ID cannot be None')
+        super().__init__(object_id=capability_id, parent=capabilities)
+        self.delay_notifications = True
+        self.capability_id = StringAttribute("id", self, capability_id)
+        self.statuses = list[Capability.Status]
+        self.enabled = True
+        self.delay_notifications = False
+
+    class Status(IntEnum):
+        """
+        Enum for capability status.
+        """
+        UNKNOWN = 0
+        DEACTIVATED = 1001
+        INITIALLY_DISABLED = 1003
+        DISABLED_BY_USER = 1004
+        OFFLINE_MODE = 1005
+        WORKSHOP_MODE = 1006
+        MISSING_OPERATION = 1007
+        MISSING_SERVICE = 1008
+        PLAY_PROTECTION = 1009
+        POWER_BUDGET_REACHED = 1010
+        DEEP_SLEEP = 1011
+        LOCATION_DATA_DISABLED = 1013
+        LICENSE_INACTIVE = 2001
+        LICENSE_EXPIRED = 2002
+        MISSING_LICENSE = 2003
+        USER_NOT_VERIFIED = 3001
+        TERMS_AND_CONDITIONS_NOT_ACCEPTED = 3002
+        INSUFFICIENT_RIGHTS = 3003
+        CONSENT_MISSING = 3004
+        LIMITED_FEATURE = 3005
+        AUTH_APP_CERT_ERROR = 3006
+        STATUS_UNSUPPORTED = 4001

carconnectivity_connectors/skoda/charging.py

@@ -0,0 +1,137 @@
+"""
+Module for charging for skoda vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import Enum
+
+from carconnectivity.charging import Charging
+from carconnectivity.objects import GenericObject
+from carconnectivity.vehicle import ElectricVehicle
+from carconnectivity.attributes import BooleanAttribute, EnumAttribute, StringAttribute
+
+from carconnectivity_connectors.skoda.error import Error
+
+if TYPE_CHECKING:
+    from typing import Optional, Dict
+
+
+class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
+    """
+    SkodaCharging class for handling Skoda vehicle charging information.
+
+    This class extends the Charging class and includes an enumeration of various
+    charging states specific to Skoda vehicles.
+    """
+    def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Charging] = None) -> None:
+        if origin is not None:
+            super().__init__(origin=origin)
+            self.settings: Charging.Settings = SkodaCharging.Settings(origin=origin.settings)
+        else:
+            super().__init__(vehicle=vehicle)
+            self.settings: Charging.Settings = SkodaCharging.Settings(origin=self.settings)
+        self.errors: Dict[str, Error] = {}
+        self.is_in_saved_location: BooleanAttribute = BooleanAttribute("is_in_saved_location", parent=self)
+
+    class Settings(Charging.Settings):
+        """
+        This class represents the settings for a skoda car charging.
+        """
+        def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Charging.Settings] = None) -> None:
+            if origin is not None:
+                super().__init__(origin=origin)
+            else:
+                super().__init__(parent=parent)
+            self.preferred_charge_mode: EnumAttribute = EnumAttribute("preferred_charge_mode", parent=self)
+            self.available_charge_modes: StringAttribute = StringAttribute("available_charge_modes", parent=self)
+            self.charging_care_mode: EnumAttribute = EnumAttribute("charging_care_mode", parent=self)
+            self.battery_support: EnumAttribute = EnumAttribute("battery_support", parent=self)
+
+    class SkodaChargingState(Enum,):
+        """
+        Enum representing the various charging states for a Skoda vehicle.
+
+        Attributes:
+            OFF: The vehicle is not charging.
+            READY_FOR_CHARGING: The vehicle is ready to start charging.
+            NOT_READY_FOR_CHARGING: The vehicle is not ready to start charging.
+            CONSERVATION: The vehicle is in conservation mode.
+            CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING: The vehicle has reached its charging purpose and is not in conservation charging mode.
+            CHARGE_PURPOSE_REACHED_CONSERVATION: The vehicle has reached its charging purpose and is in conservation charging mode.
+            CHARGING: The vehicle is currently charging.
+            ERROR: There is an error in the charging process.
+            UNSUPPORTED: The charging state is unsupported.
+            DISCHARGING: The vehicle is discharging.
+            UNKNOWN: The charging state is unknown.
+        """
+        OFF = 'off'
+        CONNECT_CABLE = 'connectCable'
+        READY_FOR_CHARGING = 'readyForCharging'
+        NOT_READY_FOR_CHARGING = 'notReadyForCharging'
+        CONSERVING = 'conserving'
+        CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING = 'chargePurposeReachedAndNotConservationCharging'
+        CHARGE_PURPOSE_REACHED_CONSERVATION = 'chargePurposeReachedAndConservation'
+        CHARGING = 'charging'
+        ERROR = 'error'
+        UNSUPPORTED = 'unsupported'
+        DISCHARGING = 'discharging'
+        UNKNOWN = 'unknown charging state'
+
+    class SkodaChargeMode(Enum,):
+        """
+        Enum class representing different Skoda charge modes.
+
+        Attributes:
+            HOME_STORAGE_CHARGING (str): Charge mode for home storage charging.
+            IMMEDIATE_DISCHARGING (str): Charge mode for immediate discharging.
+            ONLY_OWN_CURRENT (str): Charge mode for using only own current.
+            PREFERRED_CHARGING_TIMES (str): Charge mode for preferred charging times.
+            TIMER_CHARGING_WITH_CLIMATISATION (str): Charge mode for timer charging with climatisation.
+            TIMER (str): Charge mode for timer-based charging.
+            MANUAL (str): Charge mode for manual charging.
+            OFF (str): Charge mode for turning off charging.
+        """
+        HOME_STORAGE_CHARGING = 'HOME_STORAGE_CHARGING'
+        IMMEDIATE_DISCHARGING = 'IMMEDIATE_DISCHARGING'
+        ONLY_OWN_CURRENT = 'ONLY_OWN_CURRENT'
+        PREFERRED_CHARGING_TIMES = 'PREFERRED_CHARGING_TIMES'
+        TIMER_CHARGING_WITH_CLIMATISATION = 'TIMER_CHARGING_WITH_CLIMATISATION'
+        TIMER = 'timer'
+        MANUAL = 'manual'
+        OFF = 'off'
+        UNKNOWN = 'unknown charge mode'
+
+    class SkodaChargingCareMode(Enum,):
+        """
+        Enum representing the charging care mode for Skoda vehicles.
+        """
+        ACTIVATED = 'ACTIVATED'
+        DEACTIVATED = 'DEACTIVATED'
+        UNKNOWN = 'UNKNOWN'
+
+    class SkodaBatterySupport(Enum,):
+        """
+        SkodaBatterySupport is an enumeration that represents the different states of battery support for Skoda vehicles.
+        """
+        ENABLED = 'ENABLED'
+        DISABLED = 'DISABLED'
+        NOT_ALLOWED = 'NOT_ALLOWED'
+        UNKNOWN = 'UNKNOWN'
+
+
+# Mapping of Skoda charging states to generic charging states
+mapping_skoda_charging_state: Dict[SkodaCharging.SkodaChargingState, Charging.ChargingState] = {
+    SkodaCharging.SkodaChargingState.OFF: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.CONNECT_CABLE: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.READY_FOR_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SkodaCharging.SkodaChargingState.NOT_READY_FOR_CHARGING: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.CONSERVING: Charging.ChargingState.CONSERVATION,
+    SkodaCharging.SkodaChargingState.CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SkodaCharging.SkodaChargingState.CHARGE_PURPOSE_REACHED_CONSERVATION: Charging.ChargingState.CONSERVATION,
+    SkodaCharging.SkodaChargingState.CHARGING: Charging.ChargingState.CHARGING,
+    SkodaCharging.SkodaChargingState.ERROR: Charging.ChargingState.ERROR,
+    SkodaCharging.SkodaChargingState.UNSUPPORTED: Charging.ChargingState.UNSUPPORTED,
+    SkodaCharging.SkodaChargingState.DISCHARGING: Charging.ChargingState.DISCHARGING,
+    SkodaCharging.SkodaChargingState.UNKNOWN: Charging.ChargingState.UNKNOWN
+}

carconnectivity_connectors/skoda/climatization.py

@@ -0,0 +1,41 @@
+"""
+Module for charging for skoda vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from carconnectivity.climatization import Climatization
+from carconnectivity.objects import GenericObject
+from carconnectivity.vehicle import ElectricVehicle
+
+from carconnectivity_connectors.skoda.error import Error
+
+if TYPE_CHECKING:
+    from typing import Optional, Dict
+
+
+class SkodaClimatization(Climatization):  # pylint: disable=too-many-instance-attributes
+    """
+    SkodaClimatization class for handling Skoda vehicle climatization information.
+
+    This class extends the Climatization class and includes an enumeration of various
+    charging states specific to Skoda vehicles.
+    """
+    def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Climatization] = None) -> None:
+        if origin is not None:
+            super().__init__(origin=origin)
+            self.settings: Climatization.Settings = SkodaClimatization.Settings(origin=origin.settings)
+        else:
+            super().__init__(vehicle=vehicle)
+            self.settings: Climatization.Settings = SkodaClimatization.Settings(origin=self.settings)
+        self.errors: Dict[str, Error] = {}
+
+    class Settings(Climatization.Settings):
+        """
+        This class represents the settings for a skoda car climatiation.
+        """
+        def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Climatization.Settings] = None) -> None:
+            if origin is not None:
+                super().__init__(origin=origin)
+            else:
+                super().__init__(parent=parent)

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