aioaudiobookshelf 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

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/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/client/_base.py

@@ -4,11 +4,12 @@ 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 import SessionConfiguration
-from aioaudiobookshelf.exceptions import ApiError
+    from aioaudiobookshelf.client.session_configuration import SessionConfiguration
+from aioaudiobookshelf.exceptions import AccessTokenExpiredError, ApiError, TokenIsMissingError
 from aioaudiobookshelf.schema.calls_login import LoginResponse
 
 
@@ -20,9 +21,17 @@ class BaseClient:
     ) -> 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
+        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__)
@@ -40,7 +49,11 @@ class BaseClient:
 
     @property
     def token(self) -> str:
-        return self._token
+        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:
@@ -52,26 +65,56 @@ class BaseClient:
         data: dict[str, Any] | None = None,
     ) -> bytes:
         """POST request to abs api."""
-        try:
-            response = await self.session_config.session.post(
+
+        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."""
-        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,
-        )
+
+        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()
@@ -81,7 +124,8 @@ class BaseClient:
 
     async def _patch(self, endpoint: str, data: dict[str, Any] | None = None) -> None:
         """PATCH request to abs api."""
-        try:
+
+        async def _request() -> None:
             await self.session_config.session.patch(
                 f"{self.session_config.url}/{endpoint}",
                 json=data,
@@ -89,21 +133,65 @@ class BaseClient:
                 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."""
-        try:
+
+        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."""
-        await self._post("logout")
+        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/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/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/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/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/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.dist-info → aioaudiobookshelf-0.1.8.dist-info}/METADATA

@@ -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.dist-info → aioaudiobookshelf-0.1.8.dist-info}/RECORD

@@ -1,8 +1,8 @@
-aioaudiobookshelf/__init__.py,sha256=92IqTPNA_kicw_jm0NS78m11LoMTLkiSNiZHP0cyXzU,4138
-aioaudiobookshelf/exceptions.py,sha256=JQNdqBaR5AhuCUBg5DH5-orkfJrx_CJpe53ignWD6vE,377
-aioaudiobookshelf/helpers.py,sha256=ImZntca2l39P285TVVrFah82MjrP4wXLnVd7LMoD5Ck,1581
-aioaudiobookshelf/client/__init__.py,sha256=YnrNm2ZmQeVqGQ8EfAKIPRI4p2cLFqCzv4uKgL6HJPM,6931
-aioaudiobookshelf/client/_base.py,sha256=cxzivvqAitDkpyjqr0o_GjtaoWn6-kQ4GXCrkhZ3ufI,3779
+aioaudiobookshelf/__init__.py,sha256=qJeq9-dgajENDo6mWUr_LJ8NRSQFFFooL1cjgHMd6wI,3507
+aioaudiobookshelf/exceptions.py,sha256=G3z99KrxHoSoj7kpSRVpa7Rp_RkL3jmW6266ak8h_p0,661
+aioaudiobookshelf/helpers.py,sha256=gvoBWsu6PSiGYyXe5BH9TP6WydzAMp_6Ye9RUivvk9Y,2700
+aioaudiobookshelf/client/__init__.py,sha256=6xwDrY0xWWC8cXHn5GK3Mc1jPpmmtfJ9HGO9aryKL8U,7993
+aioaudiobookshelf/client/_base.py,sha256=eQjybEvl79GmvLUCJKTJmuivrF9fTo6SEt_W0BHYbSw,7183
 aioaudiobookshelf/client/authors.py,sha256=8bXN0NsPvH1rvF166xUu7rVC-0P0Sp4N7oxZrO666nc,1129
 aioaudiobookshelf/client/collections_.py,sha256=Z3r7dxHhzMm_cGCMRJkVzN5-Eesftib3d0bs4iXmmzY,879
 aioaudiobookshelf/client/items.py,sha256=4yWy7Shd6sbKj4MSGYJXklXs-yZH2q95qGIm4L-PS5o,3624
@@ -12,6 +12,7 @@ aioaudiobookshelf/client/playlists.py,sha256=sTsmuBqjSlKyTo31mc9Ha-WtzX7bh0hH7n1
 aioaudiobookshelf/client/podcasts.py,sha256=f1ECD43cn4EIwWpRvwM_RosfzDr8popFDFbRYgCZQxs,684
 aioaudiobookshelf/client/series.py,sha256=bS4RO8k1Im5wpeKt0oNcBSeeZCRIGCi9otTCEOy7xMo,820
 aioaudiobookshelf/client/session.py,sha256=YWv4GkrW5fMbq1AdnMOWQHM_YzAH1U6varzsyXlP0Jc,1249
+aioaudiobookshelf/client/session_configuration.py,sha256=AbDYT2OixncuStLz0ovMF83RNuyHTKKHdzaJKqSL7X0,3881
 aioaudiobookshelf/schema/__init__.py,sha256=vEEwPVweT0j2VqlBj2V34Xk5J9OBZ7zkd6eLOUx-RdU,358
 aioaudiobookshelf/schema/audio.py,sha256=PFKkGsZgJSDYJS-7VwoTvYTcVfR8ip8qOuE8hQa9TtE,2105
 aioaudiobookshelf/schema/author.py,sha256=OZGcCUHOfXvN8N2SRUiIRnDS2Lz3UrQFWOaOZ1sKV0U,976
@@ -20,7 +21,7 @@ aioaudiobookshelf/schema/calls_authors.py,sha256=eIvdyEcrmXuOxFJuCX39cGU9HSZprl4
 aioaudiobookshelf/schema/calls_collections.py,sha256=nXurha41Y1atAuOWG9aXJbYo66qgcFUaW02QPEVdo4w,319
 aioaudiobookshelf/schema/calls_items.py,sha256=KF8s6WNbsVUIxAuN9TZBBGsysnxfw-FQWM9XRTljOpo,1547
 aioaudiobookshelf/schema/calls_library.py,sha256=IX4vf55fUW5wLADo1QnCIg3tEhtQ2UuyKsZWpx5CmtU,2543
-aioaudiobookshelf/schema/calls_login.py,sha256=squLCKxXHRxzlm4-1BOCDQ5-Zics1717JuZ89STkN5g,791
+aioaudiobookshelf/schema/calls_login.py,sha256=DpIBtAzg5uQtS0CLDfEXHkOh_RGfDI5epFVnziFsEEs,853
 aioaudiobookshelf/schema/calls_me.py,sha256=jdpvExRytoqX8FHkzq4N9RtKn50cmTc_B693e9lLCHQ,693
 aioaudiobookshelf/schema/calls_playlists.py,sha256=Ll1scstd1NNc6PXgkhmWUfqSzIR07LKzqBCEvrVHACE,305
 aioaudiobookshelf/schema/calls_series.py,sha256=aUdlTR01UE2APN0pGS1h7x0ydsREqZf53mKaHq2zeh4,597
@@ -38,9 +39,9 @@ aioaudiobookshelf/schema/series_books.py,sha256=rs8a4JmSHqJR6WPA2XKXmC6XDq8D9wmz
 aioaudiobookshelf/schema/server.py,sha256=yWBRxtwtX1USs43yGFuDIM3jfWbmduW3GRahisOUCqw,2726
 aioaudiobookshelf/schema/session.py,sha256=jqCHNUthuzE6jhgG3UwFgagl1HA_rfDwn6Te38jaqC8,2684
 aioaudiobookshelf/schema/shelf.py,sha256=npPr5iacm6b5FfJYF9_lFZaitJNJ3SVvBOScbxlF5MQ,5064
-aioaudiobookshelf/schema/user.py,sha256=Zcnl6gqfc97dmHrNOHVsX_OOqwcJq-eFMhc9zVMLIs4,2057
-aioaudiobookshelf-0.1.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-aioaudiobookshelf-0.1.7.dist-info/METADATA,sha256=wqjbGkX5bPV9GEyvy7RKp_QAjQaJxvyGeRbjCE03lHM,4405
-aioaudiobookshelf-0.1.7.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
-aioaudiobookshelf-0.1.7.dist-info/top_level.txt,sha256=2_I2_xz98xmVIT84pcF3tlq3NdZNKskfs7BqUmYZylk,18
-aioaudiobookshelf-0.1.7.dist-info/RECORD,,
+aioaudiobookshelf/schema/user.py,sha256=cm2Oev9i062mjM3Ku-yaAjm_o4-sJOkJTczdq43_qrY,2485
+aioaudiobookshelf-0.1.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+aioaudiobookshelf-0.1.8.dist-info/METADATA,sha256=lnsXI8B8rQsaaoQ2NCDEpd4hD8s9lSPX25r6COqV69o,4405
+aioaudiobookshelf-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aioaudiobookshelf-0.1.8.dist-info/top_level.txt,sha256=2_I2_xz98xmVIT84pcF3tlq3NdZNKskfs7BqUmYZylk,18
+aioaudiobookshelf-0.1.8.dist-info/RECORD,,

{aioaudiobookshelf-0.1.7.dist-info → aioaudiobookshelf-0.1.8.dist-info}/WHEEL

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