carconnectivity-connector-seatcupra 0.1a6__py3-none-any.whl → 0.1a8__py3-none-any.whl

{carconnectivity_connector_seatcupra-0.1a6.dist-info → carconnectivity_connector_seatcupra-0.1a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-seatcupra
-Version: 0.1a6
+Version: 0.1a8
 Summary: CarConnectivity connector for Seat and Cupra services
 Author: Till Steinbach
 License: MIT License
@@ -68,6 +68,7 @@ In your carconnectivity.json configuration add a section for the seatcupra conne
             {
                 "type": "seatcupra",
                 "config": {
+                    "brand": "cupra",
                     "username": "test@test.de",
                     "password": "testpassword123"
                 }
@@ -76,6 +77,8 @@ In your carconnectivity.json configuration add a section for the seatcupra conne
     }
 }
 ```
+`brand` (`seat` or `cupra`) defines what login is used. MyCupra or MySeat account. Your credentials will work with both, but you may need to consent again to the terms and conditions when you use the "wrong" brand.
+
 ### Credentials
 If you do not want to provide your username or password inside the configuration you have to create a ".netrc" file at the appropriate location (usually this is your home folder):
 ```

{carconnectivity_connector_seatcupra-0.1a6.dist-info → carconnectivity_connector_seatcupra-0.1a8.dist-info}/RECORD

@@ -1,21 +1,21 @@
 carconnectivity_connectors/seatcupra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/seatcupra/_version.py,sha256=Hqe2m1dzf7-6SjKo8Gr6gXy8XAO0Guujh7xUPL78VzY,508
+carconnectivity_connectors/seatcupra/_version.py,sha256=8cqHsmeL27BhXP-5TXDRomSBRkxC7CZnFEC8NypOGaI,508
 carconnectivity_connectors/seatcupra/capability.py,sha256=Oe9tC_u69bj6VmOuNJ21RKoETe2j3QyZCoz-VgcZPQ0,4523
 carconnectivity_connectors/seatcupra/charging.py,sha256=BJe_5GEB0JkP78tpU6kyKpwuwjDZHvm-kt3PTlpQHeU,3336
 carconnectivity_connectors/seatcupra/climatization.py,sha256=0xxWlxrheAPzkVT8WRQtbm6ExZmVdgW7lUdOXyS_qWY,1695
 carconnectivity_connectors/seatcupra/command_impl.py,sha256=mtw8ZwJLmf79fPDZ1N3ImLfB8Gt9JPbzjMuIo2y5v3M,2879
-carconnectivity_connectors/seatcupra/connector.py,sha256=S6E7YlS8j39MPhV04ghOekevs53eEsZTlLyn7beeiMM,92982
+carconnectivity_connectors/seatcupra/connector.py,sha256=MQ5zGNO051feTZUt23J-TJLQUKdOlzG3pYyeOVAGsaw,99318
 carconnectivity_connectors/seatcupra/vehicle.py,sha256=kiFVbJgq5VQOzf-vSli_2NsMgY0x4pwvJsjPWLGdr1g,3404
 carconnectivity_connectors/seatcupra/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 carconnectivity_connectors/seatcupra/auth/auth_util.py,sha256=Y81h8fGOMSMgPtE4wI_TI9WgE_s43uaPjRLBBINhj4g,4433
-carconnectivity_connectors/seatcupra/auth/my_cupra_session.py,sha256=iK5SlankZqaeneC3SNad8nHHcrP0tTmYxToI_9cqwlo,10744
+carconnectivity_connectors/seatcupra/auth/my_cupra_session.py,sha256=ybBZ2y7-kUdo5MJ9Zin8UYViC0y3H43H3yOQcDGtWUo,12767
 carconnectivity_connectors/seatcupra/auth/openid_session.py,sha256=dA0vE2YuckkMPeqJo2dEI0h8_XfohdCgdGkTyshPF7Q,16858
-carconnectivity_connectors/seatcupra/auth/session_manager.py,sha256=NizIuY-pvkVBSwqYwFHKtjTU_02Nj4vMgjD_FjqCY6c,5377
-carconnectivity_connectors/seatcupra/auth/vw_web_session.py,sha256=hgsCdXugVnSgvLta4hBNtoNgMhAA83paAYO2fUOOFyM,10657
+carconnectivity_connectors/seatcupra/auth/session_manager.py,sha256=ZIDvC848T3fy6PgGqCl8A2SzaNhu2YG19Xam5kgp7SA,5635
+carconnectivity_connectors/seatcupra/auth/vw_web_session.py,sha256=CcI6m68IyRs6WsMDu-IsW3Dj85vyGiMmxvFqNETMHO0,10929
 carconnectivity_connectors/seatcupra/auth/helpers/blacklist_retry.py,sha256=f3wsiY5bpHDBxp7Va1Mv9nKJ4u3qnCHZZmDu78_AhMk,1251
 carconnectivity_connectors/seatcupra/ui/connector_ui.py,sha256=SNYnlcGJpbWhuLiIHD2l6H9IfSiMz3IgmvXsdossDnE,1412
-carconnectivity_connector_seatcupra-0.1a6.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_seatcupra-0.1a6.dist-info/METADATA,sha256=gIbtmwE_VYMO2tDtu9jTTvXeNYAuBpyV3PUAdAt85W4,5386
-carconnectivity_connector_seatcupra-0.1a6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-carconnectivity_connector_seatcupra-0.1a6.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_seatcupra-0.1a6.dist-info/RECORD,,
+carconnectivity_connector_seatcupra-0.1a8.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_seatcupra-0.1a8.dist-info/METADATA,sha256=OcY0IeJGVQIRGNGjdTUJ32jwKBA77KB_BNed0XxmTEg,5640
+carconnectivity_connector_seatcupra-0.1a8.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+carconnectivity_connector_seatcupra-0.1a8.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_seatcupra-0.1a8.dist-info/RECORD,,

{carconnectivity_connector_seatcupra-0.1a6.dist-info → carconnectivity_connector_seatcupra-0.1a8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

carconnectivity_connectors/seatcupra/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1a6'
+__version__ = version = '0.1a8'
 __version_tuple__ = version_tuple = (0, 1)

carconnectivity_connectors/seatcupra/auth/my_cupra_session.py

@@ -23,7 +23,7 @@ from carconnectivity_connectors.seatcupra.auth.openid_session import AccessType
 from carconnectivity_connectors.seatcupra.auth.vw_web_session import VWWebSession
 
 if TYPE_CHECKING:
-    from typing import Tuple, Dict
+    from typing import Tuple, Dict, Any
 
 
 LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.seatcupra.auth")
@@ -33,22 +33,40 @@ class MyCupraSession(VWWebSession):
     """
     MyCupraSession class handles the authentication and session management for Cupras's MyCupra service.
     """
-    def __init__(self, session_user, **kwargs) -> None:
-        super(MyCupraSession, self).__init__(client_id='3c756d46-f1ba-4d78-9f9a-cff0d5292d51@apps_vw-dilab_com',
-                                             refresh_url='https://identity.vwgroup.io/oidc/v1/token',
-                                             scope='openid profile nickname birthdate phone',
-                                             redirect_uri='cupra://oauth-callback',
-                                             state=None,
-                                             session_user=session_user,
-                                             **kwargs)
-
-        self.headers = CaseInsensitiveDict({
-            'accept': '*/*',
-            'content-type': 'application/json',
-            'user-agent': 'CUPRAApp%20-%20Store/20220503 CFNetwork/1333.0.4 Darwin/21.5.0',
-            'accept-language': 'de-de',
-            'accept-encoding': 'gzip, deflate, br'
-        })
+    def __init__(self, session_user, is_seat: bool, **kwargs) -> None:
+        self.is_seat: bool = is_seat
+        if self.is_seat:
+            super(MyCupraSession, self).__init__(client_id='99a5b77d-bd88-4d53-b4e5-a539c60694a3@apps_vw-dilab_com',
+                                                refresh_url='https://identity.vwgroup.io/oidc/v1/token',
+                                                scope='openid profile nickname birthdate phone',
+                                                redirect_uri='seat://oauth-callback',
+                                                state=None,
+                                                session_user=session_user,
+                                                **kwargs)
+
+            self.headers = CaseInsensitiveDict({
+                'accept': '*/*',
+                'content-type': 'application/json',
+                'user-agent': 'SEATApp/2.5.0 (com.seat.myseat.ola; build:202410171614; iOS 15.8.3) Alamofire/5.7.0 Mobile',
+                'accept-language': 'de-de',
+                'accept-encoding': 'gzip, deflate, br'
+            })
+        else:
+            super(MyCupraSession, self).__init__(client_id='3c756d46-f1ba-4d78-9f9a-cff0d5292d51@apps_vw-dilab_com',
+                                                refresh_url='https://identity.vwgroup.io/oidc/v1/token',
+                                                scope='openid profile nickname birthdate phone',
+                                                redirect_uri='cupra://oauth-callback',
+                                                state=None,
+                                                session_user=session_user,
+                                                **kwargs)
+
+            self.headers = CaseInsensitiveDict({
+                'accept': '*/*',
+                'content-type': 'application/json',
+                'user-agent': 'CUPRAApp%20-%20Store/20220503 CFNetwork/1333.0.4 Darwin/21.5.0',
+                'accept-language': 'de-de',
+                'accept-encoding': 'gzip, deflate, br'
+            })
 
     def login(self):
         super(MyCupraSession, self).login()
@@ -57,8 +75,12 @@ class MyCupraSession(VWWebSession):
         # perform web authentication
         response = self.do_web_auth(authorization_url_str)
         # fetch tokens from web authentication response
-        self.fetch_tokens('https://identity.vwgroup.io/oidc/v1/token',
-                          authorization_response=response)
+        if self.is_seat:
+            return self.fetch_tokens('https://ola.prod.code.seat.cloud.vwgroup.com/authorization/api/v1/token',
+                                     authorization_response=response)
+        else:
+            self.fetch_tokens('https://identity.vwgroup.io/oidc/v1/token',
+                              authorization_response=response)
 
     def refresh(self) -> None:
         # refresh tokens from refresh endpoint
@@ -92,15 +114,23 @@ class MyCupraSession(VWWebSession):
 
         if self.token is not None and all(key in self.token for key in ('state', 'id_token', 'access_token', 'code')):
             # Generate json body for token request
-            body: Dict[str, str] = {
-                'state': self.token['state'],
-                'id_token': self.token['id_token'],
-                'redirect_uri': self.redirect_uri,
-                'client_id': self.client_id,
-                'client_secret': 'eb8814e641c81a2640ad62eeccec11c98effc9bccd4269ab7af338b50a94b3a2',
-                'code': self.token['code'],
-                'grant_type': 'authorization_code'
-                }
+            if self.is_seat:
+                body: Dict[str, Any] = {'state': self.token['state'],
+                                        'id_token': self.token['id_token'],
+                                        'redirect_uri': self.redirect_uri,
+                                        'client_id': self.client_id,
+                                        'code': self.token['code'],
+                                        'grant_type': 'authorization_code'
+                                        }
+            else:
+                body: Dict[str, Any] = {'state': self.token['state'],
+                                        'id_token': self.token['id_token'],
+                                        'redirect_uri': self.redirect_uri,
+                                        'client_id': self.client_id,
+                                        'client_secret': 'eb8814e641c81a2640ad62eeccec11c98effc9bccd4269ab7af338b50a94b3a2',
+                                        'code': self.token['code'],
+                                        'grant_type': 'authorization_code'
+                                        }
 
             request_headers: CaseInsensitiveDict = dict(self.headers)  # pyright: ignore reportAssignmentType
             request_headers['content-type'] = 'application/x-www-form-urlencoded; charset=utf-8'

carconnectivity_connectors/seatcupra/auth/session_manager.py

@@ -47,11 +47,13 @@ class Service(Enum):
 
     Attributes:
         MY_CUPRA (str): Represents the 'MyCupra' service.
+        MY_SEAT (str): Represents the 'MySeat' service.
 
     Methods:
         __str__() -> str: Returns the string representation of the service.
     """
     MY_CUPRA = 'MyCupra'
+    MY_SEAT = 'MySeat'
 
     def __str__(self) -> str:
         return self.value
@@ -127,7 +129,9 @@ class SessionManager():
             cache = self.cache[identifier]
 
         if service == Service.MY_CUPRA:
-            session = MyCupraSession(session_user=session_user, token=token, metadata=metadata, cache=cache)
+            session = MyCupraSession(session_user=session_user, is_seat=False, token=token, metadata=metadata, cache=cache)
+        elif service == Service.MY_SEAT:
+            session = MyCupraSession(session_user=session_user, is_seat=True, token=token, metadata=metadata, cache=cache)
         else:
             raise ValueError(f"Unsupported service: {service}")
 

carconnectivity_connectors/seatcupra/auth/vw_web_session.py

@@ -121,6 +121,9 @@ class VWWebSession(OpenIDSession):
                 raise RetrievalError('Temporary server error during login')
 
             if 'Location' not in response.headers:
+                if 'consent' in url:
+                    raise AuthenticationError('Could not find Location in headers, probably due to missing consent. '
+                                              'Check that you configured the correct brand or try visiting: ' + url)
                 raise APICompatibilityError('Forwarding without Location in headers')
 
             url = response.headers['Location']

carconnectivity_connectors/seatcupra/connector.py

@@ -129,17 +129,30 @@ class Connector(BaseConnector):
             self.active_config['max_age'] = config['max_age']
         self.interval._set_value(timedelta(seconds=self.active_config['interval']))  # pylint: disable=protected-access
 
+        if 'brand' in config:
+            if config['brand'] not in ['seat', 'cupra']:
+                raise ValueError('Brand must be either "seat" or "cupra"')
+            self.active_config['brand'] = config['brand']
+        else:
+            self.active_config['brand'] = 'cupra'
+
         if self.active_config['username'] is None or self.active_config['password'] is None:
             raise AuthenticationError('Username or password not provided')
 
+        if self.active_config['brand'] == 'cupra':
+            service = Service.MY_CUPRA
+        elif self.active_config['brand'] == 'seat':
+            service = Service.MY_SEAT
+        else:
+            raise ValueError('Brand must be either "seat" or "cupra"')
         self._manager: SessionManager = SessionManager(tokenstore=car_connectivity.get_tokenstore(), cache=car_connectivity.get_cache())
-        session: requests.Session = self._manager.get_session(Service.MY_CUPRA, SessionUser(username=self.active_config['username'],
-                                                                                            password=self.active_config['password']))
+        session: requests.Session = self._manager.get_session(service, SessionUser(username=self.active_config['username'],
+                                                                                   password=self.active_config['password']))
         if not isinstance(session, MyCupraSession):
             raise AuthenticationError('Could not create session')
         self.session: MyCupraSession = session
         self.session.retries = 3
-        self.session.timeout = 180
+        self.session.timeout = 30
         self.session.refresh()
 
         self._elapsed: List[timedelta] = []
@@ -1089,27 +1102,37 @@ class Connector(BaseConnector):
         if 'command' not in command_arguments:
             raise CommandError('Command argument missing')
         command_dict: Dict = {}
-        if command_arguments['command'] == ChargingStartStopCommand.Command.START:
-            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/start'
-            if isinstance(vehicle, SeatCupraElectricVehicle) and vehicle.charging is not None and vehicle.charging.settings is not None \
-                    and vehicle.charging.settings.maximum_current is not None and vehicle.charging.settings.maximum_current.enabled \
-                    and vehicle.charging.settings.maximum_current.value is not None:
-                if vehicle.charging.settings.maximum_current.value <= 6:
-                    command_dict['maxChargeCurrentAC'] = 'reduced'
+        try:
+            if command_arguments['command'] == ChargingStartStopCommand.Command.START:
+                url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/start'
+                if isinstance(vehicle, SeatCupraElectricVehicle) and vehicle.charging is not None and vehicle.charging.settings is not None \
+                        and vehicle.charging.settings.maximum_current is not None and vehicle.charging.settings.maximum_current.enabled \
+                        and vehicle.charging.settings.maximum_current.value is not None:
+                    if vehicle.charging.settings.maximum_current.value <= 6:
+                        command_dict['maxChargeCurrentAC'] = 'reduced'
+                    else:
+                        command_dict['maxChargeCurrentAC'] = 'maximum'
                 else:
                     command_dict['maxChargeCurrentAC'] = 'maximum'
+                command_response: requests.Response = self.session.post(url, json=command_dict, allow_redirects=True)
+            elif command_arguments['command'] == ChargingStartStopCommand.Command.STOP:
+                url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/stop'
+                command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
             else:
-                command_dict['maxChargeCurrentAC'] = 'maximum'
-            command_response: requests.Response = self.session.post(url, json=command_dict, allow_redirects=True)
-        elif command_arguments['command'] == ChargingStartStopCommand.Command.STOP:
-            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/stop'
-            command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
-        else:
-            raise CommandError(f'Unknown command {command_arguments["command"]}')
-
-        if command_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
-            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})')
+                raise CommandError(f'Unknown command {command_arguments["command"]}')
+
+            if command_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+                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})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise CommandError(f'Connection error: {connection_error}.'
+                               ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise CommandError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise CommandError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         return command_arguments
 
     def __on_air_conditioning_start_stop(self, start_stop_command: ClimatizationStartStopCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1155,10 +1178,20 @@ class Connector(BaseConnector):
             url: str = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/climatisation/requests/stop'
         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 not in [requests.codes['ok'], requests.codes['created']]:
-            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})')
+        try:
+            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+            if command_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+                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})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise CommandError(f'Connection error: {connection_error}.'
+                               ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise CommandError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise CommandError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         return command_arguments
 
     def __on_spin(self, spin_command: SpinCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1181,12 +1214,22 @@ class Connector(BaseConnector):
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/users/{self.session.user_id}/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')
+        try:
+            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')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise CommandError(f'Connection error: {connection_error}.'
+                               ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise CommandError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise CommandError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         return command_arguments
 
     def __on_wake_sleep(self, wake_sleep_command: WakeSleepCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1205,10 +1248,20 @@ class Connector(BaseConnector):
         if command_arguments['command'] == WakeSleepCommand.Command.WAKE:
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/vehicle-wakeup/request'
 
-            command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
-            if command_response.status_code not in (requests.codes['ok'], requests.codes['no_content']):
-                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})')
+            try:
+                command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
+                if command_response.status_code not in (requests.codes['ok'], requests.codes['no_content']):
+                    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})')
+            except requests.exceptions.ConnectionError as connection_error:
+                raise CommandError(f'Connection error: {connection_error}.'
+                                   ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+            except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+                raise CommandError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+            except requests.exceptions.ReadTimeout as timeout_error:
+                raise CommandError(f'Timeout during read: {timeout_error}') from timeout_error
+            except requests.exceptions.RetryError as retry_error:
+                raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         elif command_arguments['command'] == WakeSleepCommand.Command.SLEEP:
             raise CommandError('Sleep command not supported by vehicle. Vehicle will put itself to sleep')
         else:
@@ -1244,12 +1297,22 @@ class Connector(BaseConnector):
             command_dict['userPosition']['longitude'] = vehicle.position.longitude.value
 
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{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 not in (requests.codes['ok'], requests.codes['no_content']):
-                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"]}')
+            try:
+                command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+                if command_response.status_code not in (requests.codes['ok'], requests.codes['no_content']):
+                    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})')
+            except requests.exceptions.ConnectionError as connection_error:
+                raise CommandError(f'Connection error: {connection_error}.'
+                                   ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+            except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+                raise CommandError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+            except requests.exceptions.ReadTimeout as timeout_error:
+                raise CommandError(f'Timeout during read: {timeout_error}') from timeout_error
+            except requests.exceptions.RetryError as retry_error:
+                raise CommandError(f'Retrying failed: {retry_error}') from retry_error
+            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]]) \
@@ -1278,10 +1341,20 @@ class Connector(BaseConnector):
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/access/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['ok']:
-            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})')
+        try:
+            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 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})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise CommandError(f'Connection error: {connection_error}.'
+                                ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise CommandError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise CommandError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         return command_arguments
 
     def __on_air_conditioning_settings_change(self, attribute: GenericAttribute, value: Any) -> Any:
@@ -1317,10 +1390,20 @@ class Connector(BaseConnector):
             setting_dict['climatisationWithoutExternalPower'] = settings.climatization_without_external_power.value
 
         url: str = f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/vehicles/{vin}/climatisation/settings'
-        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
-        if settings_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
-            LOG.error('Could not set climatization settings (%s) %s', settings_response.status_code, settings_response.text)
-            raise SetterError(f'Could not set value ({settings_response.status_code}): {settings_response.text}')
+        try:
+            settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+                LOG.error('Could not set climatization settings (%s) %s', settings_response.status_code, settings_response.text)
+                raise SetterError(f'Could not set value ({settings_response.status_code}): {settings_response.text}')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise SetterError(f'Connection error: {connection_error}.'
+                              ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise SetterError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise SetterError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise SetterError(f'Retrying failed: {retry_error}') from retry_error
         return value
 
     def get_version(self) -> str: