carconnectivity-connector-seatcupra 0.1a1__py3-none-any.whl

carconnectivity_connector_seatcupra-0.1a1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Till Steinbach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

carconnectivity_connector_seatcupra-0.1a1.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.2
+Name: carconnectivity-connector-seatcupra
+Version: 0.1a1
+Summary: CarConnectivity connector for Seat and Cupra services
+Author: Till Steinbach
+License: MIT License
+        
+        Copyright (c) 2021 Till Steinbach
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: carconnectivity>=0.3
+Requires-Dist: oauthlib~=3.2.2
+Requires-Dist: requests~=2.32.3
+Requires-Dist: jwt~=1.3.1
+
+
+
+# CarConnectivity Connector for Seat and Cupra Vehicles
+[![GitHub sourcecode](https://img.shields.io/badge/Source-GitHub-green)](https://github.com/tillsteinbach/CarConnectivity-connector-seatcupra/)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/tillsteinbach/CarConnectivity-connector-seatcupra)](https://github.com/tillsteinbach/CarConnectivity-connector-seatcupra/releases/latest)
+[![GitHub](https://img.shields.io/github/license/tillsteinbach/CarConnectivity-connector-seatcupra)](https://github.com/tillsteinbach/CarConnectivity-connector-seatcupra/blob/master/LICENSE)
+[![GitHub issues](https://img.shields.io/github/issues/tillsteinbach/CarConnectivity-connector-seatcupra)](https://github.com/tillsteinbach/CarConnectivity-connector-seatcupra/issues)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/carconnectivity-connector-seatcupra?label=PyPI%20Downloads)](https://pypi.org/project/carconnectivity-connector-seatcupra/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/carconnectivity-connector-seatcupra)](https://pypi.org/project/carconnectivity-connector-seatcupra/)
+[![Donate at PayPal](https://img.shields.io/badge/Donate-PayPal-2997d8)](https://www.paypal.com/donate?hosted_button_id=2BVFF5GJ9SXAJ)
+[![Sponsor at Github](https://img.shields.io/badge/Sponsor-GitHub-28a745)](https://github.com/sponsors/tillsteinbach)
+
+
+## Due to lack of access to a Cupra car the development of this conenctor is currently stuck. If you want to help me with access to your account, please contact me!
+
+[CarConnectivity](https://github.com/tillsteinbach/CarConnectivity) is a python API to connect to various car services. This connector enables the integration of seat and cupra vehicles through the MyCupra API. Look at [CarConnectivity](https://github.com/tillsteinbach/CarConnectivity) for other supported brands.
+
+## Configuration
+In your carconnectivity.json configuration add a section for the seatcupra connector like this:
+```
+{
+    "carConnectivity": {
+        "connectors": [
+            {
+                "type": "seatcupra",
+                "config": {
+                    "username": "test@test.de",
+                    "password": "testpassword123"
+                }
+            }
+        ]
+    }
+}
+```
+### 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):
+```
+# For MyCupra
+machine seatcupra
+login test@test.de
+password testpassword123
+```
+In this case the configuration needs to look like this:
+```
+{
+    "carConnectivity": {
+        "connectors": [
+            {
+                "type": "seatcupra",
+                "config": {
+                }
+            }
+        ]
+    }
+}
+```
+
+You can also provide the location of the netrc file in the configuration.
+```
+{
+    "carConnectivity": {
+        "connectors": [
+            {
+                "type": "seatcupra",
+                "config": {
+                    "netrc": "/some/path/on/your/filesystem"
+                }
+            }
+        ]
+    }
+}
+```
+The optional S-PIN needed for some commands can be provided in the account section of the netrc:
+```
+# For MyCupra
+machine seatcupra
+login test@test.de
+password testpassword123
+account 1234
+```

carconnectivity_connector_seatcupra-0.1a1.dist-info/RECORD

@@ -0,0 +1,17 @@
+carconnectivity_connectors/seatcupra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_connectors/seatcupra/_version.py,sha256=_BIT6nGqXqfHgeHw9NwtWXgZnV8T_7fSo6lEqHbnf88,508
+carconnectivity_connectors/seatcupra/charging.py,sha256=kcCJJddZxUXFoayYMpq3lzdnrPp5yexnGBfDB-zQrmE,3336
+carconnectivity_connectors/seatcupra/connector.py,sha256=nyfIjft7pXPfQojU93BfNdXQ-fSmU7DFh9Xqw4ujfd4,44278
+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/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/helpers/blacklist_retry.py,sha256=f3wsiY5bpHDBxp7Va1Mv9nKJ4u3qnCHZZmDu78_AhMk,1251
+carconnectivity_connectors/seatcupra/ui/connector_ui.py,sha256=SNYnlcGJpbWhuLiIHD2l6H9IfSiMz3IgmvXsdossDnE,1412
+carconnectivity_connector_seatcupra-0.1a1.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_seatcupra-0.1a1.dist-info/METADATA,sha256=eG-9qfRLgK8bseYbWLxo_brIPtu02IrgXjW5ZiimCc0,5384
+carconnectivity_connector_seatcupra-0.1a1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+carconnectivity_connector_seatcupra-0.1a1.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_seatcupra-0.1a1.dist-info/RECORD,,

carconnectivity_connector_seatcupra-0.1a1.dist-info/WHEEL

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

carconnectivity_connector_seatcupra-0.1a1.dist-info/top_level.txt

@@ -0,0 +1 @@
+carconnectivity_connectors

carconnectivity_connectors/seatcupra/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1a1'
+__version_tuple__ = version_tuple = (0, 1)

carconnectivity_connectors/seatcupra/auth/auth_util.py

@@ -0,0 +1,141 @@
+
+"""
+This module provides utility functions and classes for handling authentication and parsing HTML forms
+and scripts for the seatcupra car connectivity connector.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import json
+import re
+from html.parser import HTMLParser
+
+if TYPE_CHECKING:
+    from typing import Optional, Dict
+
+
+def add_bearer_auth_header(token, headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+    """
+    Adds a Bearer token to the Authorization header.
+
+    Args:
+        token (str): The Bearer token to be added to the headers.
+        headers (Optional[Dict[str, str]]): An optional dictionary of headers to which the Authorization header will be added.
+                                            If not provided, a new dictionary will be created.
+
+    Returns:
+        Dict[str, str]: The headers dictionary with the added Authorization header.
+    """
+    headers = headers or {}
+    headers['Authorization'] = f'Bearer {token}'
+    return headers
+
+
+class HTMLFormParser(HTMLParser):
+    """
+    A custom HTML parser to extract form data from HTML content.
+    """
+    def __init__(self, form_id) -> None:
+        super().__init__()
+        self._form_id = form_id
+        self._inside_form: bool = False
+        self.target = None
+        self.data = {}
+
+    def _get_attr(self, attrs, name):
+        for attr in attrs:
+            if attr[0] == name:
+                return attr[1]
+        return None
+
+    def handle_starttag(self, tag, attrs) -> None:
+        if self._inside_form and tag == 'input':
+            self.handle_input(attrs)
+            return
+
+        if tag == 'form' and self._get_attr(attrs, 'id') == self._form_id:
+            self._inside_form = True
+            self.target = self._get_attr(attrs, 'action')
+
+    def handle_endtag(self, tag) -> None:
+        if tag == 'form' and self._inside_form:
+            self._inside_form = False
+
+    def handle_input(self, attrs) -> None:
+        if not self._inside_form:
+            return
+
+        name = self._get_attr(attrs, 'name')
+        value = self._get_attr(attrs, 'value')
+
+        if name:
+            self.data[name] = value
+
+
+class ScriptFormParser(HTMLParser):
+    fields: list[str] = []
+    targetField: str = ''
+
+    def __init__(self):
+        super().__init__()
+        self._inside_script = False
+        self.data = {}
+        self.target = None
+
+    def handle_starttag(self, tag, attrs) -> None:
+        if not self._inside_script and tag == 'script':
+            self._inside_script = True
+
+    def handle_endtag(self, tag) -> None:
+        if self._inside_script and tag == 'script':
+            self._inside_script = False
+
+    def handle_data(self, data) -> None:
+        if not self._inside_script:
+            return
+
+        match: re.Match[str] | None = re.search(r'templateModel: (.*?),\n', data)
+        if not match:
+            return
+
+        result = json.loads(match.group(1))
+        self.target = result.get(self.targetField, None)
+        self.data = {k: v for k, v in result.items() if k in self.fields}
+
+        match2 = re.search(r'csrf_token: \'(.*?)\'', data)
+        if match2:
+            self.data['_csrf'] = match2.group(1)
+
+
+class CredentialsFormParser(ScriptFormParser):
+    fields: list[str] = ['relayState', 'hmac', 'registerCredentialsPath', 'error', 'errorCode']
+    targetField: str = 'postAction'
+
+
+class TermsAndConditionsFormParser(ScriptFormParser):
+    fields: list[str] = ['relayState', 'hmac', 'countryOfResidence', 'legalDocuments']
+    targetField: str = 'loginUrl'
+
+    def handle_data(self, data) -> None:
+        if not self._inside_script:
+            return
+
+        super().handle_data(data)
+
+        if 'countryOfResidence' in self.data:
+            self.data['countryOfResidence'] = self.data['countryOfResidence'].upper()
+
+        if 'legalDocuments' not in self.data:
+            return
+
+        for key in self.data['legalDocuments'][0]:
+            # Skip unnecessary keys
+            if key in ('skipLink', 'declineLink', 'majorVersion', 'minorVersion', 'changeSummary'):
+                continue
+
+            # Move values under a new key while converting boolean values to 'yes' or 'no'
+            v = self.data['legalDocuments'][0][key]
+            self.data[f'legalDocuments[0].{key}'] = ('yes' if v else 'no') if isinstance(v, bool) else v
+
+        # Remove the original object
+        del self.data['legalDocuments']

carconnectivity_connectors/seatcupra/auth/helpers/blacklist_retry.py

@@ -0,0 +1,29 @@
+"""Implements a custom Retry class that allows for blacklisting certain status codes that will not retry."""
+from urllib3.util.retry import Retry
+
+
+class BlacklistRetry(Retry):
+    """
+    BlacklistRetry class extends the Retry class to include a blacklist of status codes that should not be retried.
+    """
+    def __init__(self, status_blacklist=None, **kwargs) -> None:
+        self.status_blacklist = status_blacklist
+        super().__init__(**kwargs)
+
+    def is_retry(self, method, status_code, has_retry_after=False) -> bool:
+        """
+        Determines if a request should be retried based on the HTTP method, status code,
+        and the presence of a 'Retry-After' header.
+
+        Args:
+            method (str): The HTTP method of the request (e.g., 'GET', 'POST').
+            status_code (int): The HTTP status code of the response.
+            has_retry_after (bool): Indicates if the response contains a 'Retry-After' header.
+
+        Returns:
+            bool: True if the request should be retried, False otherwise.
+        """
+        if self.status_blacklist is not None and status_code in self.status_blacklist:
+            return False
+        else:
+            return super().is_retry(method, status_code, has_retry_after)

carconnectivity_connectors/seatcupra/auth/my_cupra_session.py

@@ -0,0 +1,244 @@
+"""
+Module implements the MyCupra Session handling.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import json
+import logging
+import secrets
+
+from urllib.parse import parse_qsl, urlparse
+
+import requests
+from requests.models import CaseInsensitiveDict
+
+from oauthlib.common import add_params_to_uri, generate_nonce, to_unicode
+from oauthlib.oauth2 import InsecureTransportError
+from oauthlib.oauth2 import is_secure_transport
+
+from carconnectivity.errors import AuthenticationError, RetrievalError, TemporaryAuthenticationError
+
+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
+
+
+LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.seatcupra.auth")
+
+
+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 login(self):
+        super(MyCupraSession, self).login()
+        # retrieve authorization URL
+        authorization_url_str: str = self.authorization_url(url='https://identity.vwgroup.io/oidc/v1/authorize')
+        # 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)
+
+    def refresh(self) -> None:
+        # refresh tokens from refresh endpoint
+        self.refresh_tokens(
+            'https://identity.vwgroup.io/oidc/v1/token',
+        )
+
+    def fetch_tokens(
+        self,
+        token_url,
+        authorization_response=None,
+        **_
+    ):
+        """
+        Fetches tokens using the given token URL using the tokens from authorization response.
+
+        Args:
+            token_url (str): The URL to request the tokens from.
+            authorization_response (str, optional): The authorization response containing the tokens. Defaults to None.
+            **_ : Additional keyword arguments.
+
+        Returns:
+            dict: A dictionary containing the fetched tokens if successful.
+            None: If the tokens could not be fetched.
+
+        Raises:
+            TemporaryAuthenticationError: If the token request fails due to a temporary MyCupra failure.
+        """
+        # take token from authorization response (those are stored in self.token now!)
+        self.parse_from_fragment(authorization_response)
+
+        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'
+                }
+
+            request_headers: CaseInsensitiveDict = dict(self.headers)  # pyright: ignore reportAssignmentType
+            request_headers['content-type'] = 'application/x-www-form-urlencoded; charset=utf-8'
+
+            # request tokens from token_url
+            token_response = self.post(token_url, headers=request_headers, data=body, allow_redirects=False,
+                                       access_type=AccessType.NONE)  # pyright: ignore reportCallIssue
+            if token_response.status_code != requests.codes['ok']:
+                raise TemporaryAuthenticationError(f'Token could not be fetched due to temporary MyCupra failure: {token_response.status_code}')
+            # parse token from response body
+            token = self.parse_from_body(token_response.text)
+
+            return token
+        return None
+
+    def parse_from_body(self, token_response, state=None):
+        """
+            Fix strange token naming before parsing it with OAuthlib.
+        """
+        try:
+            # Tokens are in body of response in json format
+            token = json.loads(token_response)
+        except json.decoder.JSONDecodeError as err:
+            raise TemporaryAuthenticationError('Token could not be refreshed due to temporary MyCupra failure: json could not be decoded') from err
+        # Fix token keys, we want access_token instead of accessToken
+        if 'accessToken' in token:
+            token['access_token'] = token.pop('accessToken')
+        # Fix token keys, we want id_token instead of idToken
+        if 'idToken' in token:
+            token['id_token'] = token.pop('idToken')
+        # Fix token keys, we want refresh_token instead of refreshToken
+        if 'refreshToken' in token:
+            token['refresh_token'] = token.pop('refreshToken')
+        # generate json from fixed dict
+        fixed_token_response = to_unicode(json.dumps(token)).encode("utf-8")
+        # Let OAuthlib parse the token
+        return super(MyCupraSession, self).parse_from_body(token_response=fixed_token_response, state=state)
+
+    def refresh_tokens(
+        self,
+        token_url,
+        refresh_token=None,
+        auth=None,
+        timeout=None,
+        headers=None,
+        verify=True,
+        proxies=None,
+        **_
+    ):
+        """
+        Refreshes the authentication tokens using the provided refresh token.
+        Args:
+            token_url (str): The URL to request new tokens from.
+            refresh_token (str, optional): The refresh token to use. Defaults to None.
+            auth (tuple, optional): Authentication credentials. Defaults to None.
+            timeout (float or tuple, optional): How long to wait for the server to send data before giving up. Defaults to None.
+            headers (dict, optional): Headers to include in the request. Defaults to None.
+            verify (bool, optional): Whether to verify the server's TLS certificate. Defaults to True.
+            proxies (dict, optional): Proxies to use for the request. Defaults to None.
+            **_ (dict): Additional arguments.
+        Raises:
+            ValueError: If no token endpoint is set for auto_refresh.
+            InsecureTransportError: If the token URL is not secure.
+            AuthenticationError: If the server requests new authorization.
+            TemporaryAuthenticationError: If the token could not be refreshed due to a temporary server failure.
+            RetrievalError: If the status code from the server is not recognized.
+        Returns:
+            dict: The new tokens.
+        """
+        LOG.info('Refreshing tokens')
+        if not token_url:
+            raise ValueError("No token endpoint set for auto_refresh.")
+
+        if not is_secure_transport(token_url):
+            raise InsecureTransportError()
+
+        # Store old refresh token in case no new one is given
+        refresh_token = refresh_token or self.refresh_token
+        if refresh_token is None:
+            self.login()
+            return self.token
+
+        if headers is None:
+            headers = dict(self.headers)
+
+        body: Dict[str, str] = {
+            'client_id': self.client_id,
+            'client_secret': 'eb8814e641c81a2640ad62eeccec11c98effc9bccd4269ab7af338b50a94b3a2',
+            'grant_type': 'refresh_token',
+            'refresh_token': self.refresh_token
+        }
+
+        headers['content-type'] = 'application/x-www-form-urlencoded; charset=utf-8'
+
+        # Request new tokens using the refresh token
+        token_response = self.post(
+            token_url,
+            data=body,
+            auth=auth,
+            timeout=timeout,
+            headers=headers,
+            verify=verify,
+            withhold_token=False,  # pyright: ignore reportCallIssue
+            proxies=proxies,
+            access_type=AccessType.NONE  # pyright: ignore reportCallIssue
+        )
+        if token_response.status_code == requests.codes['unauthorized']:
+            raise AuthenticationError('Refreshing tokens failed: Server requests new authorization')
+        elif token_response.status_code in (requests.codes['internal_server_error'], requests.codes['service_unavailable'], requests.codes['gateway_timeout']):
+            raise TemporaryAuthenticationError('Token could not be refreshed due to temporary MyCupra failure: {tokenResponse.status_code}')
+        elif token_response.status_code == requests.codes['ok']:
+            # parse new tokens from response
+            self.parse_from_body(token_response.text)
+            if self.token is not None and "refresh_token" not in self.token:
+                LOG.debug("No new refresh token given. Re-using old.")
+                self.token["refresh_token"] = refresh_token
+            return self.token
+        else:
+            raise RetrievalError(f'Status Code from MyCupra while refreshing tokens was: {token_response.status_code}')
+
+    def request(
+        self,
+        method,
+        url,
+        data=None,
+        headers=None,
+        withhold_token=False,
+        access_type=AccessType.ACCESS,
+        token=None,
+        timeout=None,
+        **kwargs
+    ):
+        """Intercept all requests and add userId if present."""
+        if not is_secure_transport(url):
+            raise InsecureTransportError()
+        if self.user_id is not None:
+            headers = headers or {}
+            headers['user-id'] = self.user_id
+
+        return super(MyCupraSession, self).request(method, url, headers=headers, data=data, withhold_token=withhold_token, access_type=access_type, token=token,
+                                                   timeout=timeout, **kwargs)