aioaudiobookshelf 0.1.7__tar.gz → 0.1.8__tar.gz

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioaudiobookshelf
-Version: 0.1.7
+Version: 0.1.8
 Summary: Async library for Audiobookshelf
 Author-email: Fabian Munkes <105975993+fmunkes@users.noreply.github.com>
 License: Apache-2.0

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf/__init__.py

@@ -2,29 +2,13 @@
 
 from aiohttp.client_exceptions import ClientResponseError, InvalidUrlClientError
 
-from aioaudiobookshelf.client import AdminClient, SessionConfiguration, SocketClient, UserClient
+from aioaudiobookshelf.client import AdminClient, SocketClient, UserClient
+from aioaudiobookshelf.client.session_configuration import SessionConfiguration
 from aioaudiobookshelf.exceptions import LoginError, TokenIsMissingError
-from aioaudiobookshelf.schema.calls_login import AuthorizeResponse, LoginParameters, LoginResponse
+from aioaudiobookshelf.helpers import get_login_response
+from aioaudiobookshelf.schema.calls_login import AuthorizeResponse
 
-__version__ = "0.1.7"
-
-
-async def _get_login_response(
-    *, session_config: SessionConfiguration, username: str, password: str
-) -> LoginResponse:
-    """Login via username and password."""
-    login_request = LoginParameters(username=username, password=password).to_dict()
-
-    try:
-        resp = await session_config.session.post(
-            f"{session_config.url}/login",
-            json=login_request,
-            ssl=session_config.verify_ssl,
-            raise_for_status=True,
-        )
-    except (ClientResponseError, InvalidUrlClientError) as exc:
-        raise LoginError from exc
-    return LoginResponse.from_json(await resp.read())
+__version__ = "0.1.8"
 
 
 async def _get_authorize_response(*, session_config: SessionConfiguration) -> AuthorizeResponse:
@@ -70,7 +54,7 @@ async def get_user_client(
     password: str,
 ) -> UserClient:
     """Get a user client."""
-    login_response = await _get_login_response(
+    login_response = await get_login_response(
         session_config=session_config, username=username, password=password
     )
 
@@ -84,13 +68,11 @@ async def get_user_and_socket_client(
     password: str,
 ) -> tuple[UserClient, SocketClient]:
     """Get user and socket client."""
-    login_response = await _get_login_response(
+    login_response = await get_login_response(
         session_config=session_config, username=username, password=password
     )
 
     user_client = UserClient(session_config=session_config, login_response=login_response)
-    if not session_config.token:
-        session_config.token = user_client.token
     socket_client = SocketClient(session_config=session_config)
     return user_client, socket_client
 
@@ -102,7 +84,7 @@ async def get_admin_client(
     password: str,
 ) -> UserClient:
     """Get a admin client."""
-    login_response = await _get_login_response(
+    login_response = await get_login_response(
         session_config=session_config, username=username, password=password
     )
 

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf/client/__init__.py

@@ -2,14 +2,18 @@
 
 import logging
 from collections.abc import Callable
-from dataclasses import dataclass
 from typing import Any
 
 import socketio
 import socketio.exceptions
-from aiohttp import ClientSession
 
-from aioaudiobookshelf.exceptions import BadUserError, TokenIsMissingError
+from aioaudiobookshelf.client.session_configuration import SessionConfiguration
+from aioaudiobookshelf.exceptions import (
+    BadUserError,
+    RefreshTokenExpiredError,
+    ServiceUnavailableError,
+    TokenIsMissingError,
+)
 from aioaudiobookshelf.schema.events_socket import (
     LibraryItemRemoved,
     PodcastEpisodeDownload,
@@ -30,29 +34,6 @@ from .series import SeriesClient
 from .session import SessionClient
 
 
-@dataclass(kw_only=True)
-class SessionConfiguration:
-    """Session configuration for abs client."""
-
-    session: ClientSession
-    url: str
-    verify_ssl: bool = True
-    token: str | None = None
-    pagination_items_per_page: int = 10
-    logger: logging.Logger | None = None
-
-    @property
-    def headers(self) -> dict[str, str]:
-        """Session headers."""
-        if self.token is None:
-            raise TokenIsMissingError("Token not set.")
-        return {"Authorization": f"Bearer {self.token}"}
-
-    def __post_init__(self) -> None:
-        """Post init."""
-        self.url = self.url.rstrip("/")
-
-
 class UserClient(
     LibrariesClient,
     ItemsClient,
@@ -82,7 +63,10 @@ class AdminClient(UserClient):
 class SocketClient:
     """Client for connecting to abs' socket."""
 
-    def __init__(self, session_config: SessionConfiguration) -> None:
+    def __init__(
+        self,
+        session_config: SessionConfiguration,
+    ) -> None:
         """Init SocketClient."""
         self.session_config = session_config
 
@@ -93,9 +77,17 @@ class SocketClient:
             ssl_verify=self.session_config.verify_ssl,
         )
 
+        if self.session_config.logger is None:
+            self.logger = logging.getLogger(__name__)
+            logging.basicConfig()
+            self.logger.setLevel(logging.DEBUG)
+        else:
+            self.logger = self.session_config.logger
+
         self.set_item_callbacks()
         self.set_user_callbacks()
         self.set_podcast_episode_download_callbacks()
+        self.set_refresh_token_expired_callback()
 
     def set_item_callbacks(
         self,
@@ -129,9 +121,16 @@ class SocketClient:
         """Set podcast episode download callbacks."""
         self.on_episode_download_finished = on_episode_download_finished
 
+    def set_refresh_token_expired_callback(
+        self, *, on_refresh_token_expired: Callable[[], Any] | None = None
+    ) -> None:
+        """Set refresh token expired callback."""
+        self.on_refresh_token_expired = on_refresh_token_expired
+
     async def init_client(self) -> None:
         """Initialize the client."""
         self.client.on("connect", handler=self._on_connect)
+        self.client.on("connect_error", handler=self._on_connect_error)
 
         self.client.on("user_updated", handler=self._on_user_updated)
         self.client.on("user_item_progress_updated", handler=self._on_user_item_progress_updated)
@@ -153,7 +152,30 @@ class SocketClient:
     logout = shutdown
 
     async def _on_connect(self) -> None:
-        await self.client.emit(event="auth", data=self.session_config.token)
+        """V2.26 and above: access token or api token."""
+        if self.session_config.access_token is not None:
+            token = self.session_config.access_token
+        else:
+            if self.session_config.token is None:
+                raise TokenIsMissingError
+            token = self.session_config.token
+        await self.client.emit(event="auth", data=token)
+        self.logger.debug("Socket connected.")
+
+    async def _on_connect_error(self, *_: Any) -> None:
+        if not self.session_config.auto_refresh or self.session_config.access_token is None:
+            return
+        # try to refresh token
+        self.logger.debug("Auto refreshing token")
+        try:
+            await self.session_config.refresh()
+        except RefreshTokenExpiredError:
+            if self.on_refresh_token_expired is not None:
+                await self.on_refresh_token_expired()
+            return
+        except ServiceUnavailableError:
+            # socketio will continue trying to reconnect.
+            return
 
     async def _on_user_updated(self, data: dict[str, Any]) -> None:
         if self.on_user_updated is not None:

aioaudiobookshelf-0.1.8/aioaudiobookshelf/client/_base.py

@@ -0,0 +1,197 @@
+"""BaseClient."""
+
+import logging
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from aiohttp.client import ClientResponse
+from aiohttp.client_exceptions import ClientResponseError
+
+if TYPE_CHECKING:
+    from aioaudiobookshelf.client.session_configuration import SessionConfiguration
+from aioaudiobookshelf.exceptions import AccessTokenExpiredError, ApiError, TokenIsMissingError
+from aioaudiobookshelf.schema.calls_login import LoginResponse
+
+
+class BaseClient:
+    """Base for clients."""
+
+    def __init__(
+        self, session_config: "SessionConfiguration", login_response: LoginResponse
+    ) -> None:
+        self.session_config = session_config
+        self.user = login_response.user
+        self.server_settings = login_response.server_settings
+
+        if not self.session_config.token and not self.session_config.refresh_token:
+            if login_response.user.refresh_token is not None:
+                assert login_response.user.access_token is not None
+                assert login_response.user.refresh_token is not None
+                self.session_config.refresh_token = login_response.user.refresh_token
+                self.session_config.access_token = login_response.user.access_token
+            elif login_response.user.token is not None:
+                assert login_response.user.token is not None
+                self.session_config.token = login_response.user.token
+
+        if self.session_config.logger is None:
+            self.logger = logging.getLogger(__name__)
+            logging.basicConfig()
+            self.logger.setLevel(logging.DEBUG)
+        else:
+            self.logger = self.session_config.logger
+
+        self.logger.debug(
+            "Initialized client %s",
+            self.__class__.__name__,
+        )
+
+        self._verify_user()
+
+    @property
+    def token(self) -> str:
+        if self.session_config.access_token is not None:
+            return self.session_config.access_token
+        if self.session_config.token is None:
+            raise TokenIsMissingError
+        return self.session_config.token
+
+    @abstractmethod
+    def _verify_user(self) -> None:
+        """Verify if user has enough permissions for endpoints in use."""
+
+    async def _post(
+        self,
+        endpoint: str,
+        data: dict[str, Any] | None = None,
+    ) -> bytes:
+        """POST request to abs api."""
+
+        async def _request() -> ClientResponse:
+            return await self.session_config.session.post(
+                f"{self.session_config.url}/{endpoint}",
+                json=data,
+                ssl=self.session_config.verify_ssl,
+                headers=self.session_config.headers,
+                raise_for_status=True,
+            )
+
+        try:
+            response = await _request()
+        except ClientResponseError as exc:
+            if exc.code == 401:
+                if self.session_config.auto_refresh:
+                    self.logger.debug("Auto refreshing tokens.")
+                    await self.refresh()
+                else:
+                    raise AccessTokenExpiredError from exc
+            else:
+                raise ApiError(f"API POST call to {endpoint} failed.") from exc
+
+        # TODO: remove redundant clause
+        try:
+            response = await _request()
+        except ClientResponseError as exc:
+            raise ApiError(f"API POST call to {endpoint} failed.") from exc
+
+        return await response.read()
+
+    async def _get(self, endpoint: str, params: dict[str, str | int] | None = None) -> bytes:
+        """GET request to abs api."""
+
+        async def _request() -> ClientResponse:
+            return await self.session_config.session.get(
+                f"{self.session_config.url}/{endpoint}",
+                params=params,
+                ssl=self.session_config.verify_ssl,
+                headers=self.session_config.headers,
+            )
+
+        response = await _request()
+        if response.status == 401:
+            if self.session_config.auto_refresh:
+                self.logger.debug("Auto refreshing tokens.")
+                await self.refresh()
+                response = await _request()
+            else:
+                raise AccessTokenExpiredError
+
+        status = response.status
+        if response.content_type == "application/json" and status == 200:
+            return await response.read()
+        if status == 404:
+            return b""
+        raise ApiError(f"API GET call to {endpoint} failed.")
+
+    async def _patch(self, endpoint: str, data: dict[str, Any] | None = None) -> None:
+        """PATCH request to abs api."""
+
+        async def _request() -> None:
+            await self.session_config.session.patch(
+                f"{self.session_config.url}/{endpoint}",
+                json=data,
+                ssl=self.session_config.verify_ssl,
+                headers=self.session_config.headers,
+                raise_for_status=True,
+            )
+
+        try:
+            await _request()
+        except ClientResponseError as exc:
+            if exc.code == 401:
+                if self.session_config.auto_refresh:
+                    self.logger.debug("Auto refreshing tokens.")
+                    await self.refresh()
+                else:
+                    raise AccessTokenExpiredError from exc
+            else:
+                raise ApiError(f"API PATCH call to {endpoint} failed.") from exc
+
+        try:
+            await _request()
+        except ClientResponseError as exc:
+            raise ApiError(f"API PATCH call to {endpoint} failed.") from exc
+
+    async def _delete(self, endpoint: str) -> None:
+        """DELETE request to abs api."""
+
+        async def _request() -> None:
+            await self.session_config.session.delete(
+                f"{self.session_config.url}/{endpoint}",
+                ssl=self.session_config.verify_ssl,
+                headers=self.session_config.headers,
+                raise_for_status=True,
+            )
+
+        try:
+            await _request()
+        except ClientResponseError as exc:
+            if exc.code == 401:
+                if self.session_config.auto_refresh:
+                    self.logger.debug("Auto refreshing tokens.")
+                    await self.refresh()
+                else:
+                    raise AccessTokenExpiredError from exc
+            else:
+                raise ApiError(f"API DELETE call to {endpoint} failed.") from exc
+
+        try:
+            await _request()
+        except ClientResponseError as exc:
+            raise ApiError(f"API DELETE call to {endpoint} failed.") from exc
+
+    async def refresh(self) -> None:
+        """Refresh tokens."""
+        await self.session_config.refresh()
+
+    async def logout(self) -> None:
+        """Logout client."""
+        if self.session_config.refresh_token is not None:
+            # v2.26 and above
+            await self.session_config.session.post(
+                f"{self.session_config.url}/logout",
+                ssl=self.session_config.verify_ssl,
+                headers=self.session_config.headers_refresh_logout,
+                raise_for_status=True,
+            )
+        else:
+            await self._post("logout")

aioaudiobookshelf-0.1.8/aioaudiobookshelf/client/session_configuration.py

@@ -0,0 +1,105 @@
+"""Session Configuration."""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+
+from aiohttp.client import ClientSession
+from aiohttp.client_exceptions import ClientResponseError
+
+from aioaudiobookshelf.exceptions import (
+    RefreshTokenExpiredError,
+    ServiceUnavailableError,
+    TokenIsMissingError,
+)
+from aioaudiobookshelf.helpers import get_login_response
+from aioaudiobookshelf.schema.calls_login import RefreshResponse
+
+
+@dataclass(kw_only=True)
+class SessionConfiguration:
+    """Session configuration for abs client.
+
+    Relevant token information for v2.26 and above:
+        https://github.com/advplyr/audiobookshelf/discussions/4460
+    """
+
+    session: ClientSession
+    url: str
+    verify_ssl: bool = True
+    token: str | None = None  # pre v2.26 token or api token if > v2.26
+    access_token: str | None = None  # > v2.26
+    refresh_token: str | None = None  # > v2.26
+    auto_refresh: bool = True  # automatically refresh access token, should it be expired.
+    pagination_items_per_page: int = 10
+    logger: logging.Logger | None = None
+
+    @property
+    def headers(self) -> dict[str, str]:
+        """Session headers.
+
+        These are normal request headers.
+        """
+        if self.token is not None:
+            return {"Authorization": f"Bearer {self.token}"}
+        if self.access_token is not None:
+            return {"Authorization": f"Bearer {self.access_token}"}
+        raise TokenIsMissingError("Token not set.")
+
+    @property
+    def headers_refresh_logout(self) -> dict[str, str]:
+        """Session headers for /auth/refresh and /logout.
+
+        Only v2.26 and above.
+        """
+        if self.refresh_token is None:
+            raise TokenIsMissingError("Refresh token not set.")
+        return {"x-refresh-token": self.refresh_token}
+
+    def __post_init__(self) -> None:
+        """Post init."""
+        self.url = self.url.rstrip("/")
+        self.__refresh_lock = asyncio.Lock()
+
+    async def refresh(self) -> None:
+        """Refresh access_token with refresh token.
+
+        v2.26 and above
+        """
+        if self.__refresh_lock.locked():
+            return
+        async with self.__refresh_lock:
+            try:
+                endpoint = "auth/refresh"
+                response = await self.session.post(
+                    f"{self.url}/{endpoint}",
+                    ssl=self.verify_ssl,
+                    headers=self.headers_refresh_logout,
+                    raise_for_status=True,
+                )
+            except ClientResponseError as err:
+                if err.code == 503:
+                    raise ServiceUnavailableError from err
+                raise RefreshTokenExpiredError from err
+            data = await response.read()
+            refresh_response = RefreshResponse.from_json(data)
+            assert refresh_response.user.access_token is not None
+            assert refresh_response.user.refresh_token is not None
+            self.access_token = refresh_response.user.access_token
+            self.refresh_token = refresh_response.user.refresh_token
+
+    async def authenticate(self, *, username: str, password: str) -> None:
+        """Relogin and update tokens if refresh token expired."""
+        async with self.__refresh_lock:
+            login_response = await get_login_response(
+                session_config=self, username=username, password=password
+            )
+            if login_response.user.access_token is None:
+                # pre v2.26
+                assert login_response.user.token is not None
+                self.token = login_response.user.token
+                return
+            assert login_response.user.access_token is not None
+            assert login_response.user.refresh_token is not None
+            self.access_token = login_response.user.access_token
+            self.refresh_token = login_response.user.refresh_token

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf/exceptions.py

@@ -15,3 +15,15 @@ class ApiError(Exception):
 
 class TokenIsMissingError(Exception):
     """Exception raised if token is missing."""
+
+
+class AccessTokenExpiredError(Exception):
+    """Exception raised if access token expired."""
+
+
+class RefreshTokenExpiredError(Exception):
+    """Exception raised if refresh token expired."""
+
+
+class ServiceUnavailableError(Exception):
+    """Raised if service is not available."""

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf/helpers.py

@@ -3,6 +3,15 @@
 import base64
 import urllib.parse
 from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from aiohttp.client_exceptions import ClientResponseError, InvalidUrlClientError
+
+from aioaudiobookshelf.exceptions import LoginError
+from aioaudiobookshelf.schema.calls_login import LoginParameters, LoginResponse
+
+if TYPE_CHECKING:
+    from aioaudiobookshelf.client.session_configuration import SessionConfiguration
 
 
 class FilterGroup(StrEnum):
@@ -54,3 +63,23 @@ def get_library_filter_string(
         return f"{filter_group.value}.{_encoded}"
 
     raise NotImplementedError(f"The {filter_group=} is not yet implemented.")
+
+
+async def get_login_response(
+    *, session_config: "SessionConfiguration", username: str, password: str
+) -> LoginResponse:
+    """Login via username and password."""
+    login_request = LoginParameters(username=username, password=password).to_dict()
+
+    try:
+        resp = await session_config.session.post(
+            f"{session_config.url}/login",
+            json=login_request,
+            ssl=session_config.verify_ssl,
+            raise_for_status=True,
+            # adapt > v2.26.0 https://github.com/advplyr/audiobookshelf/discussions/4460
+            headers={"x-return-tokens": "true"},
+        )
+    except (ClientResponseError, InvalidUrlClientError) as exc:
+        raise LoginError from exc
+    return LoginResponse.from_json(await resp.read())

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf/schema/calls_login.py

@@ -30,3 +30,6 @@ class LoginResponse(DataClassJSONMixin):
 
 # api/authorize, if token is used for authorization
 AuthorizeResponse = LoginResponse
+
+# auth/refresh, new in v2.26
+RefreshResponse = LoginResponse

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf/schema/user.py

@@ -52,7 +52,13 @@ class _UserBase(_BaseModel):
 class User(_UserBase):
     """User."""
 
-    token: str
+    # see https://github.com/advplyr/audiobookshelf/discussions/4460
+    # new in v2.26.0 old token system will be removed in the future
+    # we make them optional to have some backwards compatibility
+    token: str | None = None
+    # will only be returned if x-return-tokens is set to true in header
+    refresh_token: Annotated[str | None, Alias("refreshToken")] = None
+    access_token: Annotated[str | None, Alias("accessToken")] = None
 
     media_progress: Annotated[list[MediaProgress], Alias("mediaProgress")]
     series_hide_from_continue_listening: Annotated[

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioaudiobookshelf
-Version: 0.1.7
+Version: 0.1.8
 Summary: Async library for Audiobookshelf
 Author-email: Fabian Munkes <105975993+fmunkes@users.noreply.github.com>
 License: Apache-2.0

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/aioaudiobookshelf.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ aioaudiobookshelf/client/playlists.py
 aioaudiobookshelf/client/podcasts.py
 aioaudiobookshelf/client/series.py
 aioaudiobookshelf/client/session.py
+aioaudiobookshelf/client/session_configuration.py
 aioaudiobookshelf/schema/__init__.py
 aioaudiobookshelf/schema/audio.py
 aioaudiobookshelf/schema/author.py

{aioaudiobookshelf-0.1.7 → aioaudiobookshelf-0.1.8}/pyproject.toml

@@ -18,7 +18,7 @@ description = "Async library for Audiobookshelf"
 license = {text = "Apache-2.0"}
 readme = "README.md"
 requires-python = ">=3.12"
-version = "0.1.7"
+version = "0.1.8"
 
 [project.optional-dependencies]
 test = [
@@ -133,7 +133,7 @@ known-first-party = ["music_assistant"]
 max-complexity = 25
 
 [tool.bumpver]
-current_version = "0.1.7"
+current_version = "0.1.8"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"

aioaudiobookshelf-0.1.7/aioaudiobookshelf/client/_base.py

@@ -1,109 +0,0 @@
-"""BaseClient."""
-
-import logging
-from abc import abstractmethod
-from typing import TYPE_CHECKING, Any
-
-from aiohttp.client_exceptions import ClientResponseError
-
-if TYPE_CHECKING:
-    from aioaudiobookshelf.client import SessionConfiguration
-from aioaudiobookshelf.exceptions import ApiError
-from aioaudiobookshelf.schema.calls_login import LoginResponse
-
-
-class BaseClient:
-    """Base for clients."""
-
-    def __init__(
-        self, session_config: "SessionConfiguration", login_response: LoginResponse
-    ) -> None:
-        self.session_config = session_config
-        self.user = login_response.user
-        if not self.session_config.token:
-            self.session_config.token = login_response.user.token
-        self._token = self.session_config.token
-
-        if self.session_config.logger is None:
-            self.logger = logging.getLogger(__name__)
-            logging.basicConfig()
-            self.logger.setLevel(logging.DEBUG)
-        else:
-            self.logger = self.session_config.logger
-
-        self.logger.debug(
-            "Initialized client %s",
-            self.__class__.__name__,
-        )
-
-        self._verify_user()
-
-    @property
-    def token(self) -> str:
-        return self._token
-
-    @abstractmethod
-    def _verify_user(self) -> None:
-        """Verify if user has enough permissions for endpoints in use."""
-
-    async def _post(
-        self,
-        endpoint: str,
-        data: dict[str, Any] | None = None,
-    ) -> bytes:
-        """POST request to abs api."""
-        try:
-            response = await self.session_config.session.post(
-                f"{self.session_config.url}/{endpoint}",
-                json=data,
-                ssl=self.session_config.verify_ssl,
-                headers=self.session_config.headers,
-                raise_for_status=True,
-            )
-        except ClientResponseError as exc:
-            raise ApiError(f"API POST call to {endpoint} failed.") from exc
-        return await response.read()
-
-    async def _get(self, endpoint: str, params: dict[str, str | int] | None = None) -> bytes:
-        """GET request to abs api."""
-        response = await self.session_config.session.get(
-            f"{self.session_config.url}/{endpoint}",
-            params=params,
-            ssl=self.session_config.verify_ssl,
-            headers=self.session_config.headers,
-        )
-        status = response.status
-        if response.content_type == "application/json" and status == 200:
-            return await response.read()
-        if status == 404:
-            return b""
-        raise ApiError(f"API GET call to {endpoint} failed.")
-
-    async def _patch(self, endpoint: str, data: dict[str, Any] | None = None) -> None:
-        """PATCH request to abs api."""
-        try:
-            await self.session_config.session.patch(
-                f"{self.session_config.url}/{endpoint}",
-                json=data,
-                ssl=self.session_config.verify_ssl,
-                headers=self.session_config.headers,
-                raise_for_status=True,
-            )
-        except ClientResponseError as exc:
-            raise ApiError(f"API PATCH call to {endpoint} failed.") from exc
-
-    async def _delete(self, endpoint: str) -> None:
-        """DELETE request to abs api."""
-        try:
-            await self.session_config.session.delete(
-                f"{self.session_config.url}/{endpoint}",
-                ssl=self.session_config.verify_ssl,
-                headers=self.session_config.headers,
-                raise_for_status=True,
-            )
-        except ClientResponseError as exc:
-            raise ApiError(f"API DELETE call to {endpoint} failed.") from exc
-
-    async def logout(self) -> None:
-        """Logout client."""
-        await self._post("logout")