volkswagencarnet 5.0.0b2__py3-none-any.whl → 5.0.0b4__py3-none-any.whl

volkswagencarnet/vw_connection.py

@@ -1,40 +1,46 @@
 #!/usr/bin/env python3
-"""Communicate with Volkswagen Connect services."""
-
+"""Communicate with We Connect services."""
 from __future__ import annotations
 
-import asyncio
-from datetime import UTC, datetime, timedelta
 import hashlib
-from json import dumps as to_json
-import logging
-from random import randint, random
 import re
-from urllib.parse import parse_qs, urljoin, urlparse
+import secrets
+import time
+from base64 import b64encode, urlsafe_b64encode
+from datetime import timedelta, datetime, timezone
+from random import random, randint
+from sys import version_info
 
+import asyncio
+import jwt
+import logging
 from aiohttp import ClientTimeout, client_exceptions
 from aiohttp.hdrs import METH_GET, METH_POST, METH_PUT
 from bs4 import BeautifulSoup
-import jwt
+from json import dumps as to_json
+from urllib.parse import urljoin, parse_qs, urlparse
 
+from volkswagencarnet.vw_exceptions import AuthenticationException
 from .vw_const import (
-    APP_URI,
-    BASE_API,
-    BASE_AUTH,
-    BASE_SESSION,
     BRAND,
-    CLIENT,
     COUNTRY,
-    HEADERS_AUTH,
     HEADERS_SESSION,
+    HEADERS_AUTH,
+    BASE_SESSION,
+    BASE_API,
+    BASE_AUTH,
+    CLIENT,
     USER_AGENT,
+    APP_URI,
 )
 from .vw_utilities import json_loads
 from .vw_vehicle import Vehicle
 
 MAX_RETRIES_ON_RATE_LIMIT = 3
 
-_LOGGER = logging.getLogger(__name__)  # pylint: disable=unreachable
+version_info >= (3, 7) or exit("Python 3.7+ required")
+
+_LOGGER = logging.getLogger(__name__)
 
 TIMEOUT = timedelta(seconds=30)
 JWT_ALGORITHMS = ["RS256"]
@@ -47,15 +53,7 @@ class Connection:
     _login_lock = asyncio.Lock()
 
     # Init connection class
-    def __init__(
-        self,
-        session,
-        username,
-        password,
-        fulldebug=False,
-        country=COUNTRY,
-        interval=timedelta(minutes=5),
-    ) -> None:
+    def __init__(self, session, username, password, fulldebug=False, country=COUNTRY, interval=timedelta(minutes=5)):
         """Initialize."""
         self._x_client_id = None
         self._session = session
@@ -78,7 +76,7 @@ class Connection:
 
         self._vehicles = []
 
-        _LOGGER.debug("Using service %s", self._session_base)
+        _LOGGER.debug(f"Using service {self._session_base}")
 
         self._jarCookie = ""
         self._state = {}
@@ -86,7 +84,7 @@ class Connection:
         self._service_status = {}
 
     def _clear_cookies(self):
-        self._session._cookie_jar._cookies.clear()  # pylint: disable=protected-access
+        self._session._cookie_jar._cookies.clear()
 
     # API Login
     async def doLogin(self, tries: int = 1):
@@ -98,9 +96,7 @@ class Connection:
                 self._session_logged_in = await self._login("Legacy")
                 if self._session_logged_in:
                     break
-                if i > tries:
-                    _LOGGER.error("Login failed after %s tries", tries)
-                    return False
+                _LOGGER.info("Something failed")
                 await asyncio.sleep(random() * 5)
 
             if not self._session_logged_in:
@@ -115,12 +111,12 @@ class Connection:
             loaded_vehicles = await self.get(url=f"{BASE_API}/vehicle/v2/vehicles")
             # Add Vehicle class object for all VIN-numbers from account
             if loaded_vehicles.get("data") is not None:
-                _LOGGER.debug("Found vehicle(s) associated with account")
+                _LOGGER.debug("Found vehicle(s) associated with account.")
                 self._vehicles = []
                 for vehicle in loaded_vehicles.get("data"):
                     self._vehicles.append(Vehicle(self, vehicle.get("vin")))
             else:
-                _LOGGER.warning("Failed to login to Volkswagen Connect API")
+                _LOGGER.warning("Failed to login to We Connect API.")
                 self._session_logged_in = False
                 return False
 
@@ -128,246 +124,251 @@ class Connection:
             await self.update()
             return True
 
-    async def get_openid_config(self):
-        """Get OpenID config."""
-        if self._session_fulldebug:
-            _LOGGER.debug("Requesting openid config")
-        req = await self._session.get(
-            url=f"{BASE_API}/login/v1/idk/openid-configuration"
-        )
-        if req.status != 200:
-            _LOGGER.error("Failed to get OpenID configuration, status: %s", req.status)
-            raise Exception("OpenID configuration error")  # pylint: disable=broad-exception-raised
-        return await req.json()
-
-    async def get_authorization_page(self, authorization_endpoint, client):
-        """Get authorization page (login page)."""
-        # https://identity.vwgroup.io/oidc/v1/authorize?nonce={NONCE}&state={STATE}&response_type={TOKEN_TYPES}&scope={SCOPE}&redirect_uri={APP_URI}&client_id={CLIENT_ID}
-        # https://identity.vwgroup.io/oidc/v1/authorize?client_id={CLIENT_ID}&scope={SCOPE}&response_type={TOKEN_TYPES}&redirect_uri={APP_URI}
-        if self._session_fulldebug:
-            _LOGGER.debug(
-                'Requesting authorization page from "%s"', authorization_endpoint
-            )
-            self._session_auth_headers.pop("Referer", None)
-            self._session_auth_headers.pop("Origin", None)
-            _LOGGER.debug('Request headers: "%s"', self._session_auth_headers)
-
-        try:
-            req = await self._session.get(
-                url=authorization_endpoint,
-                headers=self._session_auth_headers,
-                allow_redirects=False,
-                params={
-                    "redirect_uri": APP_URI,
-                    "response_type": CLIENT[client].get("TOKEN_TYPES"),
-                    "client_id": CLIENT[client].get("CLIENT_ID"),
-                    "scope": CLIENT[client].get("SCOPE"),
-                },
-            )
-
-            # Check if the response contains a redirect location
-            location = req.headers.get("Location")
-            if not location:
-                # pylint: disable=broad-exception-raised
-                raise Exception(
-                    f"Missing 'Location' header, payload returned: {await req.content.read()}"
-                )
-
-            ref = urljoin(authorization_endpoint, location)
-            if "error" in ref:
-                parsed_query = parse_qs(urlparse(ref).query)
-                error_msg = parsed_query.get("error", ["Unknown error"])[0]
-                error_description = parsed_query.get(
-                    "error_description", ["No description"]
-                )[0]
-                _LOGGER.info("Authorization error: %s", error_description)
-                raise Exception(error_msg)  # pylint: disable=broad-exception-raised
-
-            # If redirected, fetch the new location
-            req = await self._session.get(
-                url=ref, headers=self._session_auth_headers, allow_redirects=False
-            )
-
-            if req.status != 200:
-                raise Exception("Failed to fetch authorization endpoint")  # pylint: disable=broad-exception-raised
-
-            return await req.text()
-
-        except Exception as e:
-            _LOGGER.warning("Error during fetching authorization page: %s", str(e))
-            raise
-
-    def extract_form_data(self, page_content, form_id):
-        """Extract form data from a page."""
-        soup = BeautifulSoup(page_content, "html.parser")
-        form = soup.find("form", id=form_id)
-        if form is None:
-            raise Exception(f"Form with ID '{form_id}' not found.")  # pylint: disable=broad-exception-raised
-        return {
-            input_field["name"]: input_field["value"]
-            for input_field in form.find_all("input", type="hidden")
-        }
-
-    def extract_password_form_data(self, soup):
-        """Extract password form data from a page."""
-        pw_form = {}
-        for script in soup.find_all("script"):
-            if "src" in script.attrs or not script.string:
-                continue
-            script_text = script.string
-
-            if "window._IDK" not in script_text:
-                continue  # Skip scripts that don't contain relevant data
-            if re.match('"errorCode":"', script_text):
-                raise Exception("Error code found in script data.")  # pylint: disable=broad-exception-raised
-
-            pw_form["relayState"] = re.search(
-                '"relayState":"([a-f0-9]*)"', script_text
-            )[1]
-            pw_form["hmac"] = re.search('"hmac":"([a-f0-9]*)"', script_text)[1]
-            pw_form["email"] = re.search('"email":"([^"]*)"', script_text)[1]
-            pw_form["_csrf"] = re.search("csrf_token:\\s*'([^\"']*)'", script_text)[1]
-
-            post_action = re.search('"postAction":\\s*"([^"\']*)"', script_text)[1]
-            client_id = re.search('"clientId":\\s*"([^"\']*)"', script_text)[1]
-            return pw_form, post_action, client_id
-
-        raise Exception("Password form data not found in script.")  # pylint: disable=broad-exception-raised
-
-    async def post_form(self, session, url, headers, form_data, redirect=True):
-        """Post a form and check for success."""
-        req = await session.post(
-            url, headers=headers, data=form_data, allow_redirects=redirect
-        )
-        if not redirect and req.status == 302:
-            return req.headers["Location"]
-        if req.status != 200:
-            raise Exception("Form POST request failed.")  # pylint: disable=broad-exception-raised
-        return await req.text()
-
-    async def handle_login_with_password(self, session, url, auth_headers, form_data):
-        """Handle login with email and password."""
-        return await self.post_form(session, url, auth_headers, form_data, False)
-
-    async def follow_redirects(self, session, pw_url, redirect_location):
-        """Handle redirects."""
-        ref = urljoin(pw_url, redirect_location)
-        max_depth = 10
-        while not ref.startswith(APP_URI):
-            if max_depth == 0:
-                raise Exception("Too many redirects")  # pylint: disable=broad-exception-raised
-            response = await session.get(
-                url=ref, headers=self._session_auth_headers, allow_redirects=False
-            )
-            if "Location" not in response.headers:
-                _LOGGER.warning("Failed to find next redirect location")
-                raise Exception("Redirect error")  # pylint: disable=broad-exception-raised
-            ref = urljoin(ref, response.headers["Location"])
-            max_depth -= 1
-        return ref
-
     async def _login(self, client="Legacy"):
         """Login function."""
 
+        # Helper functions
+        def getNonce():
+            """
+            Get a random nonce.
+
+            :return:
+            """
+            ts = "%d" % (time.time())
+            sha256 = hashlib.sha256()
+            sha256.update(ts.encode())
+            sha256.update(secrets.token_bytes(16))
+            return b64encode(sha256.digest()).decode("utf-8")[:-1]
+
+        def base64URLEncode(s):
+            """
+            Encode string as Base 64 in a URL safe way, stripping trailing '='.
+
+            :param s:
+            :return:
+            """
+            return urlsafe_b64encode(s).rstrip(b"=")
+
+        # Login starts here
         try:
-            # Clear cookies and reset headers
+            # Get OpenID config:
             self._clear_cookies()
             self._session_headers = HEADERS_SESSION.copy()
             self._session_auth_headers = HEADERS_AUTH.copy()
-
-            # Get OpenID configuration
-            openid_config = await self.get_openid_config()
-            authorization_endpoint = openid_config["authorization_endpoint"]
-            token_endpoint = openid_config["token_endpoint"]
-            auth_issuer = openid_config["issuer"]
-
-            # Get authorization page
-            authorization_page = await self.get_authorization_page(
-                authorization_endpoint, client
-            )
-
-            # Extract form data
-            mailform = self.extract_form_data(authorization_page, "emailPasswordForm")
-            mailform["email"] = self._session_auth_username
-            pe_url = auth_issuer + BeautifulSoup(
-                authorization_page, "html.parser"
-            ).find("form", id="emailPasswordForm").get("action")
+            if self._session_fulldebug:
+                _LOGGER.debug("Requesting openid config")
+            req = await self._session.get(url=f"{BASE_API}/login/v1/idk/openid-configuration")
+            if req.status != 200:
+                _LOGGER.debug("OpenId config error")
+                return False
+            response_data = await req.json()
+            authorization_endpoint = response_data["authorization_endpoint"]
+            token_endpoint = response_data["token_endpoint"]
+            auth_issuer = response_data["issuer"]
+
+            # Get authorization page (login page)
+            # https://identity.vwgroup.io/oidc/v1/authorize?nonce={NONCE}&state={STATE}&response_type={TOKEN_TYPES}&scope={SCOPE}&redirect_uri={APP_URI}&client_id={CLIENT_ID}
+            # https://identity.vwgroup.io/oidc/v1/authorize?client_id={CLIENT_ID}&scope={SCOPE}&response_type={TOKEN_TYPES}&redirect_uri={APP_URI}
+            if self._session_fulldebug:
+                _LOGGER.debug(f'Get authorization page from "{authorization_endpoint}"')
+                self._session_auth_headers.pop("Referer", None)
+                self._session_auth_headers.pop("Origin", None)
+                _LOGGER.debug(f'Request headers: "{self._session_auth_headers}"')
+            try:
+                code_verifier = base64URLEncode(secrets.token_bytes(32))
+                if len(code_verifier) < 43:
+                    raise ValueError("Verifier too short. n_bytes must be > 30.")
+                elif len(code_verifier) > 128:
+                    raise ValueError("Verifier too long. n_bytes must be < 97.")
+
+                req = await self._session.get(
+                    url=authorization_endpoint,
+                    headers=self._session_auth_headers,
+                    allow_redirects=False,
+                    params={
+                        "redirect_uri": APP_URI,
+                        "response_type": CLIENT[client].get("TOKEN_TYPES"),
+                        "client_id": CLIENT[client].get("CLIENT_ID"),
+                        "scope": CLIENT[client].get("SCOPE"),
+                    },
+                )
+                if req.headers.get("Location", False):
+                    ref = urljoin(authorization_endpoint, req.headers.get("Location", ""))
+                    if "error" in ref:
+                        error = parse_qs(urlparse(ref).query).get("error", "")[0]
+                        if "error_description" in ref:
+                            error_description = parse_qs(urlparse(ref).query).get("error_description", "")[0]
+                            _LOGGER.info(f"Unable to login, {error_description}")
+                        else:
+                            _LOGGER.info("Unable to login.")
+                        raise Exception(error)
+                    else:
+                        if self._session_fulldebug:
+                            _LOGGER.debug(f'Got redirect to "{ref}"')
+                        req = await self._session.get(
+                            url=ref, headers=self._session_auth_headers, allow_redirects=False
+                        )
+                else:
+                    _LOGGER.warning("Unable to fetch authorization endpoint.")
+                    raise Exception(f'Missing "location" header, payload returned: {await req.content.read()}')
+            except Exception as error:
+                _LOGGER.warning("Failed to get authorization endpoint")
+                raise error
+            if req.status != 200:
+                raise Exception("Fetching authorization endpoint failed")
+            else:
+                _LOGGER.debug("Got authorization endpoint")
+            try:
+                response_data = await req.text()
+                response_soup = BeautifulSoup(response_data, "html.parser")
+                mailform = {
+                    t["name"]: t["value"]
+                    for t in response_soup.find("form", id="emailPasswordForm").find_all("input", type="hidden")
+                }
+                mailform["email"] = self._session_auth_username
+                pe_url = auth_issuer + response_soup.find("form", id="emailPasswordForm").get("action")
+            except Exception as e:
+                _LOGGER.error("Failed to extract user login form.")
+                raise e
 
             # POST email
             # https://identity.vwgroup.io/signin-service/v1/{CLIENT_ID}/login/identifier
             self._session_auth_headers["Referer"] = authorization_endpoint
             self._session_auth_headers["Origin"] = auth_issuer
-            response_text = await self.post_form(
-                self._session, pe_url, self._session_auth_headers, mailform
-            )
-
-            # Extract password form data
-            response_soup = BeautifulSoup(response_text, "html.parser")
-            pw_form, post_action, client_id = self.extract_password_form_data(
-                response_soup
-            )
-
-            # Add password to form data
-            pw_form["password"] = self._session_auth_password
-            pw_url = f"{auth_issuer}/signin-service/v1/{client_id}/{post_action}"
+            req = await self._session.post(url=pe_url, headers=self._session_auth_headers, data=mailform)
+            if req.status != 200:
+                raise Exception("POST password request failed")
+            try:
+                response_data = await req.text()
+                response_soup = BeautifulSoup(response_data, "html.parser")
+                pw_form: dict[str, str] = {}
+                post_action = None
+                client_id = None
+                for d in response_soup.find_all("script"):
+                    if "src" in d.attrs:
+                        continue
+                    if "window._IDK" in d.string:
+                        if re.match('"errorCode":"', d.string) is not None:
+                            raise Exception("Error code in response")
+                        pw_form["relayState"] = re.search('"relayState":"([a-f0-9]*)"', d.string)[1]
+                        pw_form["hmac"] = re.search('"hmac":"([a-f0-9]*)"', d.string)[1]
+                        pw_form["email"] = re.search('"email":"([^"]*)"', d.string)[1]
+                        pw_form["_csrf"] = re.search("csrf_token:\\s*'([^\"']*)'", d.string)[1]
+                        post_action = re.search('"postAction":\\s*"([^"\']*)"', d.string)[1]
+                        client_id = re.search('"clientId":\\s*"([^"\']*)"', d.string)[1]
+                        break
+                if pw_form["hmac"] is None or post_action is None:
+                    raise Exception("Failed to find authentication data in response")
+                pw_form["password"] = self._session_auth_password
+                pw_url = "{host}/signin-service/v1/{clientId}/{postAction}".format(
+                    host=auth_issuer, clientId=client_id, postAction=post_action
+                )
+            except Exception as e:
+                _LOGGER.error("Failed to extract password login form.")
+                raise e
 
             # POST password
+            # https://identity.vwgroup.io/signin-service/v1/{CLIENT_ID}/login/authenticate
             self._session_auth_headers["Referer"] = pe_url
-            redirect_location = await self.handle_login_with_password(
-                self._session, pw_url, self._session_auth_headers, pw_form
-            )
-
-            # Handle redirects and extract tokens
-            redirect_response = await self.follow_redirects(
-                self._session, pw_url, redirect_location
+            self._session_auth_headers["Origin"] = auth_issuer
+            _LOGGER.debug("Authenticating with email and password.")
+            if self._session_fulldebug:
+                _LOGGER.debug(f'Using login action url: "{pw_url}"')
+            req = await self._session.post(
+                url=pw_url, headers=self._session_auth_headers, data=pw_form, allow_redirects=False
             )
-            jwt_auth_code = parse_qs(urlparse(redirect_response).query)["code"][0]
-
-            # Exchange authorization code for tokens
+            _LOGGER.debug("Parsing login response.")
+            # Follow all redirects until we get redirected back to "our app"
+            try:
+                max_depth = 10
+                ref = urljoin(pw_url, req.headers["Location"])
+                while not ref.startswith(APP_URI):
+                    if self._session_fulldebug:
+                        _LOGGER.debug(f'Following redirect to "{ref}"')
+                    response = await self._session.get(
+                        url=ref, headers=self._session_auth_headers, allow_redirects=False
+                    )
+                    if not response.headers.get("Location", False):
+                        _LOGGER.info("Login failed, does this account have any vehicle with connect services enabled?")
+                        raise Exception("User appears unauthorized")
+                    ref = urljoin(ref, response.headers["Location"])
+                    # Set a max limit on requests to prevent forever loop
+                    max_depth -= 1
+                    if max_depth == 0:
+                        _LOGGER.warning("Should have gotten a token by now.")
+                        raise Exception("Too many redirects")
+            except Exception as e:
+                # If we get excepted it should be because we can't redirect to the APP_URI URL
+                if "error" in ref:
+                    error_msg = parse_qs(urlparse(ref).query).get("error", "")[0]
+                    if error_msg == "login.error.throttled":
+                        timeout = parse_qs(urlparse(ref).query).get("enableNextButtonAfterSeconds", "")[0]
+                        _LOGGER.warning(f"Login failed, login is disabled for another {timeout} seconds")
+                    elif error_msg == "login.errors.password_invalid":
+                        _LOGGER.warning("Login failed, invalid password")
+                    else:
+                        _LOGGER.warning(f"Login failed: {error_msg}")
+                    raise AuthenticationException(error_msg)
+                if "code" in ref:
+                    _LOGGER.debug("Got code: %s" % ref)
+                else:
+                    _LOGGER.debug("Exception occurred while logging in.")
+                    raise e
+            _LOGGER.debug("Login successful, received authorization code.")
+
+            # Extract code and tokens
+            parsed_qs = parse_qs(urlparse(ref).query)
+            jwt_auth_code = parsed_qs["code"][0]
+            # jwt_id_token = parsed_qs["id_token"][0]
+            # Exchange Auth code and id_token for new tokens with refresh_token (so we can easier fetch new ones later)
             token_body = {
                 "client_id": CLIENT[client].get("CLIENT_ID"),
                 "grant_type": "authorization_code",
                 "code": jwt_auth_code,
                 "redirect_uri": APP_URI,
+                # "brand": BRAND,
             }
-
-            # Token endpoint
-            token_response = await self.post_form(
-                self._session, token_endpoint, self._session_auth_headers, token_body
+            _LOGGER.debug("Trying to fetch user identity tokens.")
+            token_url = token_endpoint
+            req = await self._session.post(
+                url=token_url, headers=self._session_auth_headers, data=token_body, allow_redirects=False
             )
-
-            # Store session tokens
-            self._session_tokens[client] = json_loads(token_response)
-
-            # Verify tokens
-            if not await self.verify_tokens(
-                self._session_tokens[client].get("id_token", ""), "identity"
-            ):
+            if req.status != 200:
+                raise Exception(f"Token exchange failed. Received message: {await req.content.read()}")
+            self._session_tokens[client] = await req.json()
+            if "error" in self._session_tokens[client]:
+                error_msg = self._session_tokens[client].get("error", "")
+                if "error_description" in self._session_tokens[client]:
+                    error_description = self._session_tokens[client].get("error_description", "")
+                    raise Exception(f"{error_msg} - {error_description}")
+                else:
+                    raise Exception(error_msg)
+            if self._session_fulldebug:
+                for token in self._session_tokens.get(client, {}):
+                    _LOGGER.debug(f"Got token {token}")
+            if not await self.verify_tokens(self._session_tokens[client].get("id_token", ""), "identity"):
                 _LOGGER.warning("User identity token could not be verified!")
             else:
-                _LOGGER.debug("User identity token verified successfully")
-
-            # Mark session as logged in
-            self._session_logged_in = True
-
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.error("Login failed: %s", error)
+                _LOGGER.debug("User identity token verified OK.")
+                self._session_logged_in = True
+        except Exception as error:
+            _LOGGER.error(f"Login failed for {BRAND} account, {error}")
+            _LOGGER.exception(error)
             self._session_logged_in = False
             return False
-        self._session_headers["Authorization"] = (
-            "Bearer " + self._session_tokens[client]["access_token"]
-        )
+        self._session_headers["Authorization"] = "Bearer " + self._session_tokens[client]["access_token"]
         return True
 
     async def _handle_action_result(self, response_raw):
         response = await response_raw.json(loads=json_loads)
         if not response:
-            raise Exception("Invalid or no response")  # pylint: disable=broad-exception-raised
-        if response == 429:
-            return {"id": None, "state": "Throttled"}
-        request_id = response.get("data", {}).get("requestID", 0)
-        _LOGGER.debug("Request returned with request id: %s", request_id)
-        return {"id": str(request_id)}
+            raise Exception("Invalid or no response")
+        elif response == 429:
+            return dict({"id": None, "state": "Throttled"})
+        else:
+            request_id = response.get("data", {}).get("requestID", 0)
+            _LOGGER.debug(f"Request returned with request id: {request_id}")
+            return dict({"id": str(request_id)})
 
     async def terminate(self):
         """Log out from connect services."""
@@ -376,25 +377,28 @@ class Connection:
 
     async def logout(self):
         """Logout, revoke tokens."""
+        # TODO: not tested yet
         self._session_headers.pop("Authorization", None)
 
         if self._session_logged_in:
             if self._session_headers.get("identity", {}).get("identity_token"):
-                _LOGGER.info("Revoking Identity Access Token")
-
+                _LOGGER.info("Revoking Identity Access Token...")
+                # params = {
+                #    "token": self._session_tokens['identity']['access_token'],
+                #    "brand": BRAND
+                # }
+                # revoke_at = await self.post('https://emea.bff.cariad.digital/login/v1/idk/revoke', data = params)
             if self._session_headers.get("identity", {}).get("refresh_token"):
-                _LOGGER.info("Revoking Identity Refresh Token")
+                _LOGGER.info("Revoking Identity Refresh Token...")
                 params = {"token": self._session_tokens["identity"]["refresh_token"]}
-                await self.post(
-                    "https://emea.bff.cariad.digital/login/v1/idk/revoke", data=params
-                )
+                await self.post("https://emea.bff.cariad.digital/login/v1/idk/revoke", data=params)
 
     # HTTP methods to API
     async def _request(self, method, url, return_raw=False, **kwargs):
         """Perform a query to the VW-Group API."""
-        _LOGGER.debug('HTTP %s "%s"', method, url)
+        _LOGGER.debug(f'HTTP {method} "{url}"')
         if kwargs.get("json", None):
-            _LOGGER.debug("Request payload: %s", kwargs.get("json", None))
+            _LOGGER.debug(f'Request payload: {kwargs.get("json", None)}')
         try:
             async with self._session.request(
                 method,
@@ -426,36 +430,21 @@ class Connection:
                         res = await response.json(loads=json_loads)
                     else:
                         res = {}
-                        _LOGGER.debug(
-                            "Not success status code [%s] response: %s",
-                            response.status,
-                            response.text,
-                        )
-                except Exception:  # pylint: disable=broad-exception-caught
+                        _LOGGER.debug(f"Not success status code [{response.status}] response: {response.text}")
+                except Exception:
                     res = {}
-                    _LOGGER.debug(
-                        "Something went wrong [%s] response: %s",
-                        response.status,
-                        response.text,
-                    )
+                    _LOGGER.debug(f"Something went wrong [{response.status}] response: {response.text}")
                     if return_raw:
                         return response
-                    return res
+                    else:
+                        return res
 
                 if self._session_fulldebug:
                     _LOGGER.debug(
-                        'Request for "%s" returned with status code [%s], headers: %s, response: %s',
-                        url,
-                        response.status,
-                        response.headers,
-                        res,
+                        f'Request for "{url}" returned with status code [{response.status}], headers: {response.headers}, response: {res}'
                     )
                 else:
-                    _LOGGER.debug(
-                        'Request for "%s" returned with status code [%s]',
-                        url,
-                        response.status,
-                    )
+                    _LOGGER.debug(f'Request for "{url}" returned with status code [{response.status}]')
 
                 if return_raw:
                     res = response
@@ -472,7 +461,8 @@ class Connection:
     async def get(self, url, vin="", tries=0):
         """Perform a get query."""
         try:
-            return await self._request(METH_GET, url)
+            response = await self._request(METH_GET, url)
+            return response
         except client_exceptions.ClientResponseError as error:
             if error.status == 400:
                 _LOGGER.error(
@@ -480,92 +470,78 @@ class Connection:
                     " correctly for this vehicle"
                 )
             elif error.status == 401:
-                _LOGGER.warning(
-                    'Received "unauthorized" error while fetching data: %s', error
-                )
+                _LOGGER.warning(f'Received "unauthorized" error while fetching data: {error}')
                 self._session_logged_in = False
             elif error.status == 429 and tries < MAX_RETRIES_ON_RATE_LIMIT:
                 delay = randint(1, 3 + tries * 2)
-                _LOGGER.debug(
-                    "Server side throttled. Waiting %s, try %s", delay, tries + 1
-                )
+                _LOGGER.debug(f"Server side throttled. Waiting {delay}, try {tries + 1}")
                 await asyncio.sleep(delay)
                 return await self.get(url, vin, tries + 1)
             elif error.status == 500:
-                _LOGGER.info(
-                    "Got HTTP 500 from server, service might be temporarily unavailable"
-                )
+                _LOGGER.info("Got HTTP 500 from server, service might be temporarily unavailable")
             elif error.status == 502:
-                _LOGGER.info(
-                    "Got HTTP 502 from server, this request might not be supported for this vehicle"
-                )
+                _LOGGER.info("Got HTTP 502 from server, this request might not be supported for this vehicle")
             else:
-                _LOGGER.error("Got unhandled error from server: %s", error.status)
+                _LOGGER.error(f"Got unhandled error from server: {error.status}")
             return {"status_code": error.status}
 
     async def post(self, url, vin="", tries=0, return_raw=False, **data):
         """Perform a post query."""
         try:
             if data:
-                return await self._request(
-                    METH_POST, url, return_raw=return_raw, **data
-                )
-            return await self._request(METH_POST, url, return_raw=return_raw)
+                return await self._request(METH_POST, url, return_raw=return_raw, **data)
+            else:
+                return await self._request(METH_POST, url, return_raw=return_raw)
         except client_exceptions.ClientResponseError as error:
             if error.status == 429 and tries < MAX_RETRIES_ON_RATE_LIMIT:
                 delay = randint(1, 3 + tries * 2)
-                _LOGGER.debug(
-                    "Server side throttled. Waiting %s, try %s", delay, tries + 1
-                )
+                _LOGGER.debug(f"Server side throttled. Waiting {delay}, try {tries + 1}")
                 await asyncio.sleep(delay)
-                return await self.post(
-                    url, vin, tries + 1, return_raw=return_raw, **data
-                )
-            raise
+                return await self.post(url, vin, tries + 1, return_raw=return_raw, **data)
+            else:
+                raise
 
     async def put(self, url, vin="", tries=0, return_raw=False, **data):
         """Perform a put query."""
         try:
             if data:
                 return await self._request(METH_PUT, url, return_raw=return_raw, **data)
-            return await self._request(METH_PUT, url, return_raw=return_raw)
+            else:
+                return await self._request(METH_PUT, url, return_raw=return_raw)
         except client_exceptions.ClientResponseError as error:
             if error.status == 429 and tries < MAX_RETRIES_ON_RATE_LIMIT:
                 delay = randint(1, 3 + tries * 2)
-                _LOGGER.debug(
-                    "Server side throttled. Waiting %s, try %s", delay, tries + 1
-                )
+                _LOGGER.debug(f"Server side throttled. Waiting {delay}, try {tries + 1}")
                 await asyncio.sleep(delay)
-                return await self.put(
-                    url, vin, tries + 1, return_raw=return_raw, **data
-                )
-            raise
+                return await self.put(url, vin, tries + 1, return_raw=return_raw, **data)
+            else:
+                raise
 
     # Update data for all Vehicles
     async def update(self):
         """Update status."""
         if not self.logged_in:
             if not await self._login():
-                _LOGGER.warning("Login for %s account failed!", BRAND)
+                _LOGGER.warning(f"Login for {BRAND} account failed!")
                 return False
         try:
             if not await self.validate_tokens:
-                _LOGGER.info(
-                    "Session expired. Initiating new login for %s account", BRAND
-                )
+                _LOGGER.info(f"Session expired. Initiating new login for {BRAND} account.")
                 if not await self.doLogin():
-                    _LOGGER.warning("Login for %s account failed!", BRAND)
-                    raise Exception(f"Login for {BRAND} account failed")  # pylint: disable=broad-exception-raised
-            else:
-                _LOGGER.debug("Going to call vehicle updates")
-                # Get all Vehicle objects and update in parallell
-                updatelist = [vehicle.update() for vehicle in self.vehicles]
-                # Wait for all data updates to complete
-                await asyncio.gather(*updatelist)
-
-                return True
-        except (OSError, LookupError, Exception) as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not update information: %s", error)
+                    _LOGGER.warning(f"Login for {BRAND} account failed!")
+                    raise Exception(f"Login for {BRAND} account failed")
+
+            _LOGGER.debug("Going to call vehicle updates")
+            # Get all Vehicle objects and update in parallell
+            updatelist = []
+            for vehicle in self.vehicles:
+                updatelist.append(vehicle.update())
+            # Wait for all data updates to complete
+            await asyncio.gather(*updatelist)
+
+            return True
+        except (OSError, LookupError, Exception) as error:
+            _LOGGER.warning(f"Could not update information: {error}")
         return False
 
     async def getPendingRequests(self, vin):
@@ -573,18 +549,15 @@ class Connection:
         if not await self.validate_tokens:
             return False
         try:
-            response = await self.get(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/pendingrequests"
-            )
+            response = await self.get(f"{BASE_API}/vehicle/v1/vehicles/{vin}/pendingrequests")
 
             if response:
-                response["refreshTimestamp"] = datetime.now(UTC)
-                return response
+                response.update({"refreshTimestamp": datetime.now(timezone.utc)})
 
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning(
-                "Could not fetch information for pending requests, error: %s", error
-            )
+            return response
+
+        except Exception as error:
+            _LOGGER.warning(f"Could not fetch information for pending requests, error: {error}")
         return False
 
     async def getOperationList(self, vin):
@@ -592,22 +565,17 @@ class Connection:
         if not await self.validate_tokens:
             return False
         try:
-            response = await self.get(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/capabilities", ""
-            )
+            response = await self.get(f"{BASE_API}/vehicle/v1/vehicles/{vin}/capabilities", "")
             if response.get("capabilities", False):
                 data = response
             elif response.get("status_code", {}):
-                _LOGGER.warning(
-                    "Could not fetch operation list, HTTP status code: %s",
-                    response.get("status_code"),
-                )
+                _LOGGER.warning(f'Could not fetch operation list, HTTP status code: {response.get("status_code")}')
                 data = response
             else:
-                _LOGGER.info("Could not fetch operation list: %s", response)
+                _LOGGER.info(f"Could not fetch operation list: {response}")
                 data = {"error": "unknown"}
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not fetch operation list, error: %s", error)
+        except Exception as error:
+            _LOGGER.warning(f"Could not fetch operation list, error: {error}")
             data = {"error": "unknown"}
         return data
 
@@ -617,23 +585,22 @@ class Connection:
             return False
         try:
             response = await self.get(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/selectivestatus?jobs={','.join(services)}",
-                "",
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/selectivestatus?jobs={','.join(services)}", ""
             )
 
             for service in services:
                 if not response.get(service):
                     _LOGGER.debug(
-                        "Did not receive return data for requested service %s. (This is expected for several service/car combinations)",
-                        service,
+                        f"Did not receive return data for requested service {service}. (This is expected for several service/car combinations)"
                     )
 
             if response:
-                response.update({"refreshTimestamp": datetime.now(UTC)})
-                return response
+                response.update({"refreshTimestamp": datetime.now(timezone.utc)})
+
+            return response
 
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not fetch selectivestatus, error: %s", error)
+        except Exception as error:
+            _LOGGER.warning(f"Could not fetch selectivestatus, error: {error}")
         return False
 
     async def getVehicleData(self, vin):
@@ -645,12 +612,13 @@ class Connection:
 
             for vehicle in response.get("data"):
                 if vehicle.get("vin") == vin:
-                    return {"vehicle": vehicle}
+                    data = {"vehicle": vehicle}
+                    return data
 
-            _LOGGER.warning("Could not fetch vehicle data for vin %s", vin)
+            _LOGGER.warning(f"Could not fetch vehicle data for vin {vin}")
 
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not fetch vehicle data, error: %s", error)
+        except Exception as error:
+            _LOGGER.warning(f"Could not fetch vehicle data, error: {error}")
         return False
 
     async def getParkingPosition(self, vin):
@@ -658,29 +626,21 @@ class Connection:
         if not await self.validate_tokens:
             return False
         try:
-            response = await self.get(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/parkingposition", ""
-            )
+            response = await self.get(f"{BASE_API}/vehicle/v1/vehicles/{vin}/parkingposition", "")
 
             if "data" in response:
                 return {"isMoving": False, "parkingposition": response["data"]}
-            if response.get("status_code", {}):
+            elif response.get("status_code", {}):
                 if response.get("status_code", 0) == 204:
-                    _LOGGER.debug(
-                        "Seems car is moving, HTTP 204 received from parkingposition"
-                    )
-                    return {"isMoving": True, "parkingposition": {}}
-
-                _LOGGER.warning(
-                    "Could not fetch parkingposition, HTTP status code: %s",
-                    response.get("status_code"),
-                )
+                    _LOGGER.debug("Seems car is moving, HTTP 204 received from parkingposition")
+                    data = {"isMoving": True, "parkingposition": {}}
+                    return data
+                else:
+                    _LOGGER.warning(f'Could not fetch parkingposition, HTTP status code: {response.get("status_code")}')
             else:
-                _LOGGER.info(
-                    "Unhandled error while trying to fetch parkingposition data"
-                )
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not fetch parkingposition, error: %s", error)
+                _LOGGER.info("Unhandled error while trying to fetch parkingposition data")
+        except Exception as error:
+            _LOGGER.warning(f"Could not fetch parkingposition, error: {error}")
         return False
 
     async def getTripLast(self, vin):
@@ -688,18 +648,14 @@ class Connection:
         if not await self.validate_tokens:
             return False
         try:
-            response = await self.get(
-                f"{BASE_API}/vehicle/v1/trips/{vin}/shortterm/last", ""
-            )
+            response = await self.get(f"{BASE_API}/vehicle/v1/trips/{vin}/shortterm/last", "")
             if "data" in response:
                 return {"trip_last": response["data"]}
+            else:
+                _LOGGER.warning(f"Could not fetch last trip data, server response: {response}")
 
-            _LOGGER.warning(
-                "Could not fetch last trip data, server response: %s", response
-            )
-
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not fetch last trip data, error: %s", error)
+        except Exception as error:
+            _LOGGER.warning(f"Could not fetch last trip data, error: {error}")
         return False
 
     async def wakeUpVehicle(self, vin):
@@ -707,30 +663,27 @@ class Connection:
         if not await self.validate_tokens:
             return False
         try:
-            return await self.post(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/vehiclewakeuptrigger",
-                json={},
-                return_raw=True,
+            response = await self.post(
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/vehiclewakeuptrigger", json={}, return_raw=True
             )
+            return response
 
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not refresh the data, error: %s", error)
+        except Exception as error:
+            _LOGGER.warning(f"Could not refresh the data, error: {error}")
         return False
 
     async def get_request_status(self, vin, requestId, actionId=""):
         """Return status of a request ID for a given section ID."""
         if self.logged_in is False:
             if not await self.doLogin():
-                _LOGGER.warning("Login for %s account failed!", BRAND)
-                raise Exception(f"Login for {BRAND} account failed")  # pylint: disable=broad-exception-raised
+                _LOGGER.warning(f"Login for {BRAND} account failed!")
+                raise Exception(f"Login for {BRAND} account failed")
         try:
             if not await self.validate_tokens:
-                _LOGGER.info(
-                    "Session expired. Initiating new login for %s account", BRAND
-                )
+                _LOGGER.info(f"Session expired. Initiating new login for {BRAND} account.")
                 if not await self.doLogin():
-                    _LOGGER.warning("Login for %s account failed!", BRAND)
-                    raise Exception(f"Login for {BRAND} account failed")  # pylint: disable=broad-exception-raised
+                    _LOGGER.warning(f"Login for {BRAND} account failed!")
+                    raise Exception(f"Login for {BRAND} account failed")
 
             response = await self.getPendingRequests(vin)
 
@@ -741,37 +694,35 @@ class Connection:
                     result = request.get("status")
 
             # Translate status messages to meaningful info
-            if result in ("in_progress", "queued", "fetched"):
+            if result == "in_progress" or result == "queued" or result == "fetched":
                 status = "In Progress"
-            elif result in ("request_fail", "failed"):
+            elif result == "request_fail" or result == "failed":
                 status = "Failed"
             elif result == "unfetched":
                 status = "No response"
-            elif result in ("request_successful", "successful"):
+            elif result == "request_successful" or result == "successful":
                 status = "Success"
             elif result == "fail_ignition_on":
                 status = "Failed because ignition is on"
             else:
                 status = result
-        except Exception as error:
-            _LOGGER.warning("Failure during get request status: %s", error)
-            raise Exception(f"Failure during get request status: {error}") from error  # pylint: disable=broad-exception-raised
-        else:
             return status
+        except Exception as error:
+            _LOGGER.warning(f"Failure during get request status: {error}")
+            raise Exception(f"Failure during get request status: {error}")
 
     async def check_spin_state(self):
         """Determine SPIN state to prevent lockout due to wrong SPIN."""
         result = await self.get(f"{BASE_API}/vehicle/v1/spin/state")
         remainingTries = result.get("remainingTries", None)
         if remainingTries is None:
-            raise Exception("Couldn't determine S-PIN state.")  # pylint: disable=broad-exception-raised
+            raise Exception("Couldn't determine S-PIN state.")
 
         if remainingTries < 3:
-            # pylint: disable=broad-exception-raised
             raise Exception(
                 "Remaining tries for S-PIN is < 3. Bailing out for security reasons. "
-                "To resume operation, please make sure the correct S-PIN has been set in the integration "
-                "and then use the correct S-PIN once via the Volkswagen app."
+                + "To resume operation, please make sure the correct S-PIN has been set in the integration "
+                + "and then use the correct S-PIN once via the Volkswagen app."
             )
 
         return True
@@ -781,148 +732,124 @@ class Connection:
         action = "start" if action else "stop"
         try:
             response_raw = await self.post(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/climatisation/{action}",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/climatisation/{action}", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setClimater") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setClimater") from e
 
     async def setClimaterSettings(self, vin, data):
         """Execute climatisation settings."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/climatisation/settings",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/climatisation/settings", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setClimaterSettings") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setClimaterSettings") from e
 
     async def setAuxiliary(self, vin, data, action):
         """Execute auxiliary climatisation actions."""
         action = "start" if action else "stop"
         try:
             response_raw = await self.post(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/auxiliaryheating/{action}",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/auxiliaryheating/{action}", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setAuxiliary") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setAuxiliary") from e
 
     async def setWindowHeater(self, vin, action):
         """Execute window heating actions."""
         action = "start" if action else "stop"
         try:
             response_raw = await self.post(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/windowheating/{action}",
-                json={},
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/windowheating/{action}", json={}, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setWindowHeater") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setWindowHeater") from e
 
     async def setCharging(self, vin, action):
         """Execute charging actions."""
         action = "start" if action else "stop"
         try:
             response_raw = await self.post(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/charging/{action}",
-                json={},
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/charging/{action}", json={}, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setCharging") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setCharging") from e
 
     async def setChargingSettings(self, vin, data):
         """Execute charging actions."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/charging/settings",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/charging/settings", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setChargingSettings") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setChargingSettings") from e
 
     async def setChargingCareModeSettings(self, vin, data):
         """Execute battery care mode actions."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/charging/care/settings",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/charging/care/settings", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setChargingCareModeSettings") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setChargingCareModeSettings") from e
 
     async def setReadinessBatterySupport(self, vin, data):
         """Execute readiness battery support actions."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/readiness/batterysupport",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/readiness/batterysupport", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setReadinessBatterySupport") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setReadinessBatterySupport") from e
 
     async def setDepartureProfiles(self, vin, data):
         """Execute departure timers actions."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/departure/profiles",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/departure/profiles", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setDepartureProfiles") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setDepartureProfiles") from e
 
     async def setClimatisationTimers(self, vin, data):
         """Execute climatisation timers actions."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/climatisation/timers",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/climatisation/timers", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setClimatisationTimers") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setClimatisationTimers") from e
 
     async def setAuxiliaryHeatingTimers(self, vin, data):
         """Execute auxiliary heating timers actions."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/auxiliaryheating/timers",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/auxiliaryheating/timers", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setAuxiliaryHeatingTimers") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setAuxiliaryHeatingTimers") from e
 
     async def setDepartureTimers(self, vin, data):
         """Execute departure timers actions."""
         try:
             response_raw = await self.put(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/departure/timers",
-                json=data,
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/departure/timers", json=data, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setDepartureTimers") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setDepartureTimers") from e
 
     async def setLock(self, vin, lock, spin):
         """Remote lock and unlock actions."""
@@ -930,13 +857,11 @@ class Connection:
         action = "lock" if lock else "unlock"
         try:
             response_raw = await self.post(
-                f"{BASE_API}/vehicle/v1/vehicles/{vin}/access/{action}",
-                json={"spin": spin},
-                return_raw=True,
+                f"{BASE_API}/vehicle/v1/vehicles/{vin}/access/{action}", json={"spin": spin}, return_raw=True
             )
             return await self._handle_action_result(response_raw)
         except Exception as e:
-            raise Exception("Unknown error during setLock") from e  # pylint: disable=broad-exception-raised
+            raise Exception("Unknown error during setLock") from e
 
     # Token handling #
     @property
@@ -945,14 +870,10 @@ class Connection:
         idtoken = self._session_tokens["identity"]["id_token"]
         atoken = self._session_tokens["identity"]["access_token"]
         id_exp = jwt.decode(
-            idtoken,
-            options={"verify_signature": False, "verify_aud": False},
-            algorithms=JWT_ALGORITHMS,
+            idtoken, options={"verify_signature": False, "verify_aud": False}, algorithms=JWT_ALGORITHMS
         ).get("exp", None)
         at_exp = jwt.decode(
-            atoken,
-            options={"verify_signature": False, "verify_aud": False},
-            algorithms=JWT_ALGORITHMS,
+            atoken, options={"verify_signature": False, "verify_aud": False}, algorithms=JWT_ALGORITHMS
         ).get("exp", None)
         id_dt = datetime.fromtimestamp(int(id_exp))
         at_dt = datetime.fromtimestamp(int(at_exp))
@@ -961,14 +882,14 @@ class Connection:
 
         # Check if tokens have expired, or expires now
         if now >= id_dt or now >= at_dt:
-            _LOGGER.debug("Tokens have expired. Try to fetch new tokens")
+            _LOGGER.debug("Tokens have expired. Try to fetch new tokens.")
             if await self.refresh_tokens():
                 _LOGGER.debug("Successfully refreshed tokens")
             else:
                 return False
         # Check if tokens expires before next update
         elif later >= id_dt or later >= at_dt:
-            _LOGGER.debug("Tokens about to expire. Try to fetch new tokens")
+            _LOGGER.debug("Tokens about to expire. Try to fetch new tokens.")
             if await self.refresh_tokens():
                 _LOGGER.debug("Successfully refreshed tokens")
             else:
@@ -1000,10 +921,10 @@ class Connection:
 
             pubkey = pubkeys[token_kid]
             jwt.decode(token, key=pubkey, algorithms=JWT_ALGORITHMS, audience=audience)
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.debug("Failed to verify token, error: %s", error)
+            return True
+        except Exception as error:
+            _LOGGER.debug(f"Failed to verify token, error: {error}")
             return False
-        return True
 
     async def refresh_tokens(self):
         """Refresh tokens."""
@@ -1021,9 +942,7 @@ class Connection:
                 "client_id": CLIENT["Legacy"]["CLIENT_ID"],
             }
             response = await self._session.post(
-                url="https://emea.bff.cariad.digital/login/v1/idk/token",
-                headers=tHeaders,
-                data=body,
+                url="https://emea.bff.cariad.digital/login/v1/idk/token", headers=tHeaders, data=body
             )
             await self.update_service_status("token", response.status)
             if response.status == 200:
@@ -1033,19 +952,15 @@ class Connection:
                     _LOGGER.warning("Token could not be verified!")
                 for token in tokens:
                     self._session_tokens["identity"][token] = tokens[token]
-                self._session_headers["Authorization"] = (
-                    "Bearer " + self._session_tokens["identity"]["access_token"]
-                )
+                self._session_headers["Authorization"] = "Bearer " + self._session_tokens["identity"]["access_token"]
             else:
-                _LOGGER.warning(
-                    "Something went wrong when refreshing %s account tokens", BRAND
-                )
+                _LOGGER.warning(f"Something went wrong when refreshing {BRAND} account tokens.")
                 return False
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Could not refresh tokens: %s", error)
-            return False
-        else:
+
             return True
+        except Exception as error:
+            _LOGGER.warning(f"Could not refresh tokens: {error}")
+            return False
 
     async def update_service_status(self, url, response_code):
         """Update service status."""
@@ -1075,7 +990,7 @@ class Connection:
         elif "token" in url:
             self._service_status["token"] = status
         else:
-            _LOGGER.debug('Unhandled API URL: "%s"', url)
+            _LOGGER.debug(f'Unhandled API URL: "{url}"')
 
     async def get_service_status(self):
         """Return list of service statuses."""
@@ -1090,7 +1005,8 @@ class Connection:
 
     @property
     def logged_in(self):
-        """Return cached logged in state.
+        """
+        Return cached logged in state.
 
         Not actually checking anything.
         """
@@ -1098,14 +1014,7 @@ class Connection:
 
     def vehicle(self, vin):
         """Return vehicle object for given vin."""
-        return next(
-            (
-                vehicle
-                for vehicle in self.vehicles
-                if vehicle.unique_id.lower() == vin.lower()
-            ),
-            None,
-        )
+        return next((vehicle for vehicle in self.vehicles if vehicle.unique_id.lower() == vin.lower()), None)
 
     def hash_spin(self, challenge, spin):
         """Convert SPIN and challenge to hash."""
@@ -1120,8 +1029,8 @@ class Connection:
         try:
             if not await self.validate_tokens:
                 return False
+
+            return True
         except OSError as error:
             _LOGGER.warning("Could not validate login: %s", error)
             return False
-        else:
-            return True