aioaudiobookshelf 0.1.4__py3-none-any.whl → 0.1.11__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.4"
-
-
-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.11"
 
 
 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__)
@@ -32,16 +41,19 @@ class BaseClient:
             self.logger = self.session_config.logger
 
         self.logger.debug(
-            "Initialized client %s, token: %s",
+            "Initialized client %s",
             self.__class__.__name__,
-            self._token,
         )
 
         self._verify_user()
 
     @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:
@@ -53,26 +65,57 @@ 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,
+                timeout=self.session_config.timeout,
             )
+
+        try:
+            response = await _request()
         except ClientResponseError as exc:
-            raise ApiError(f"API POST call to {endpoint} failed.") from exc
+            if exc.code == 401:
+                if self.session_config.auto_refresh:
+                    self.logger.debug("Auto refreshing tokens.")
+                    await self.refresh()
+                    # TODO: remove redundant clause
+                    try:
+                        response = await _request()
+                    except ClientResponseError as inner_exc:
+                        raise ApiError(f"API POST call to {endpoint} failed.") from inner_exc
+                else:
+                    raise AccessTokenExpiredError from exc
+            else:
+                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,
+                timeout=self.session_config.timeout,
+            )
+
+        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()
@@ -82,29 +125,74 @@ 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,
                 ssl=self.session_config.verify_ssl,
                 headers=self.session_config.headers,
                 raise_for_status=True,
+                timeout=self.session_config.timeout,
             )
+
+        try:
+            await _request()
         except ClientResponseError as exc:
-            raise ApiError(f"API PATCH call to {endpoint} failed.") from exc
+            if exc.code == 401:
+                if self.session_config.auto_refresh:
+                    self.logger.debug("Auto refreshing tokens.")
+                    await self.refresh()
+                    try:
+                        await _request()
+                    except ClientResponseError as inner_exc:
+                        raise ApiError(f"API PATCH call to {endpoint} failed.") from inner_exc
+                else:
+                    raise AccessTokenExpiredError from exc
+            else:
+                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,
+                timeout=self.session_config.timeout,
             )
+
+        try:
+            await _request()
         except ClientResponseError as exc:
-            raise ApiError(f"API DELETE call to {endpoint} failed.") from exc
+            if exc.code == 401:
+                if self.session_config.auto_refresh:
+                    self.logger.debug("Auto refreshing tokens.")
+                    await self.refresh()
+                    try:
+                        await _request()
+                    except ClientResponseError as inner_exc:
+                        raise ApiError(f"API DELETE call to {endpoint} failed.") from inner_exc
+                else:
+                    raise AccessTokenExpiredError from exc
+            else:
+                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/authors.py

@@ -1,10 +1,19 @@
 """Calls to /api/authors."""
 
+from enum import StrEnum
+
 from aioaudiobookshelf.client._base import BaseClient
 from aioaudiobookshelf.schema.author import Author
 from aioaudiobookshelf.schema.calls_authors import AuthorWithItems, AuthorWithItemsAndSeries
 
 
+class AuthorImageFormat(StrEnum):
+    """AuthorImageFormat."""
+
+    JPEG = "jpeg"
+    WEBP = "webp"
+
+
 class AuthorsClient(BaseClient):
     """AuthorsClient."""
 
@@ -31,4 +40,18 @@ class AuthorsClient(BaseClient):
 
     # update author
     # match author
-    # get author image
+    async def get_author_image(
+        self,
+        *,
+        author_id: str,
+        width: int = 400,
+        height: int | None = None,
+        format_: AuthorImageFormat = AuthorImageFormat.JPEG,
+        raw: bool = False,
+    ) -> bytes:
+        """Get image of author. If height is None, image is scaled proportionally."""
+        endpoint = f"/api/authors/{author_id}/image"
+        params = {"width": width, "format": format_.value, "raw": int(raw)}
+        if height:
+            params["height"] = height
+        return await self._get(endpoint, params=params)

aioaudiobookshelf/client/libraries.py

@@ -3,6 +3,7 @@
 from collections.abc import AsyncGenerator
 from typing import TypeVar
 
+from mashumaro.codecs.json import json_decode
 from mashumaro.mixins.json import DataClassJSONMixin
 
 from aioaudiobookshelf.client._base import BaseClient
@@ -18,6 +19,14 @@ from aioaudiobookshelf.schema.calls_library import (
     LibraryWithFilterDataResponse,
 )
 from aioaudiobookshelf.schema.library import Library, LibraryFilterData
+from aioaudiobookshelf.schema.shelf import (
+    Shelf,
+    ShelfAuthors,
+    ShelfBook,
+    ShelfEpisode,
+    ShelfPodcast,
+    ShelfSeries,
+)
 
 ResponseMinified = TypeVar("ResponseMinified", bound=DataClassJSONMixin)
 ResponseNormal = TypeVar("ResponseNormal", bound=DataClassJSONMixin)
@@ -147,7 +156,17 @@ class LibrariesClient(BaseClient):
         ):
             yield result
 
-    # get library's personalized view
+    async def get_library_personalized_view(
+        self, *, library_id: str, limit: int = 10
+    ) -> list[ShelfBook | ShelfPodcast | ShelfAuthors | ShelfEpisode | ShelfSeries]:
+        """Get personalized view of library.
+
+        TODO: Add rssfeed
+        """
+        response = await self._get(
+            endpoint=f"/api/libraries/{library_id}/personalized", params={"limit": limit}
+        )
+        return json_decode(response, list[Shelf])
 
     async def get_library_filterdata(self, *, library_id: str) -> LibraryFilterData:
         """Get filterdata of library."""

aioaudiobookshelf/client/session.py

@@ -1,7 +1,10 @@
 """Calls to /api/session."""
 
 from aioaudiobookshelf.client._base import BaseClient
-from aioaudiobookshelf.schema.calls_session import CloseOpenSessionsParameters
+from aioaudiobookshelf.schema.calls_session import (
+    CloseOpenSessionsParameters,
+    SyncOpenSessionParameters,
+)
 from aioaudiobookshelf.schema.session import PlaybackSessionExpanded
 
 
@@ -24,7 +27,11 @@ class SessionClient(BaseClient):
         )
         return psession
 
-    # sync open session
+    async def sync_open_session(
+        self, *, session_id: str, parameters: SyncOpenSessionParameters
+    ) -> None:
+        """Sync an open session."""
+        await self._post(f"/api/session/{session_id}/sync", data=parameters.to_dict())
 
     async def close_open_session(
         self, *, session_id: str, parameters: CloseOpenSessionsParameters | None = None

aioaudiobookshelf/client/session_configuration.py

@@ -0,0 +1,106 @@
+"""Session Configuration."""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+
+from aiohttp.client import DEFAULT_TIMEOUT, ClientSession, ClientTimeout
+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
+    timeout: ClientTimeout = DEFAULT_TIMEOUT
+    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/audio.py

@@ -56,7 +56,7 @@ class AudioFile(_BaseModel):
     exclude: bool
     error: str | None = None
     format: str
-    duration: float
+    duration: float | None
     bit_rate: Annotated[int, Alias("bitRate")]
     language: str | None = None
     codec: str

aioaudiobookshelf/schema/book.py

@@ -18,7 +18,7 @@ class EBookFile(_BaseModel):
 
     ino: str
     metadata: FileMetadata
-    ebook_format: Annotated[str, Alias("ebookFormat")]
+    ebook_format: Annotated[str | None, Alias("ebookFormat")] = None
     added_at: Annotated[int, Alias("addedAt")]  # time in ms since unix epoch
     updated_at: Annotated[int, Alias("updatedAt")]  # time in ms since unix epoch
 

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/calls_session.py

@@ -15,3 +15,6 @@ class CloseOpenSessionsParameters(_BaseModel):
     current_time: Annotated[float, Alias("currentTime")]
     time_listened: Annotated[float, Alias("timeListened")]
     duration: float
+
+
+SyncOpenSessionParameters = CloseOpenSessionsParameters

aioaudiobookshelf/schema/file.py

@@ -17,6 +17,7 @@ class FileMetadata(_BaseModel):
     path: str
     relative_path: Annotated[str, Alias("relPath")]
     size: int  # in bytes
-    modified_time_ms: Annotated[int, Alias("mtimeMs")]
+    # might not be present, see https://github.com/music-assistant/support/issues/3914
+    modified_time_ms: Annotated[int | None, Alias("mtimeMs")] = None
     changed_time_ms: Annotated[int, Alias("ctimeMs")]
     created_time_ms: Annotated[int, Alias("birthtimeMs")] = 0  # 0 if unknown

aioaudiobookshelf/schema/shelf.py

@@ -0,0 +1,188 @@
+"""Schema for shelf, the response object to library's personalized view."""
+# Discriminators don't work together with aliases.
+# https://github.com/Fatal1ty/mashumaro/issues/254
+# ruff: noqa: N815
+
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Annotated
+
+from mashumaro.types import Alias, Discriminator
+
+from aioaudiobookshelf.schema.author import AuthorExpanded
+from aioaudiobookshelf.schema.book import BookMinified
+
+from . import _BaseModel
+from .library import LibraryMediaType, _LibraryItemBase
+from .podcast import PodcastEpisode, PodcastMinified
+from .series import Series
+
+
+class ShelfId(StrEnum):
+    """ShelfId."""
+
+    LISTEN_AGAIN = "listen-again"
+    CONTINUE_LISTENING = "continue-listening"
+    CONTINUE_SERIES = "continue-series"
+    RECOMMENDED = "recommended"
+    RECENTLY_ADDED = "recently-added"
+    EPISODES_RECENTLY_ADDED = "episodes-recently-added"
+    RECENT_SERIES = "recent-series"
+    NEWEST_AUTHORS = "newest-authors"
+    NEWEST_EPISODES = "newest-episodes"
+    DISCOVER = "discover"
+
+
+@dataclass(kw_only=True)
+class ShelfLibraryItemMinified(_LibraryItemBase):
+    """ShelfLibraryItemMinified.
+
+    Beside using type, there is another distinction on which attributes
+    are available based on the id. We allow ourselves the easy route
+    here, and just make all of them optional.
+    """
+
+    # episode (type) and
+    # id: continue-listening, listen-again, episodes-recently-added
+    recent_episode: Annotated[PodcastEpisode | None, Alias("recentEpisode")] = None
+
+    # id: continue-listening
+    progress_last_update_ms: Annotated[int | None, Alias("progressLastUpdate")] = None
+
+    # id: continue-series
+    previous_book_in_progress_last_update_ms: Annotated[
+        int | None, Alias("prevBookInProgressLastUpdate")
+    ] = None
+    # TODO: minified item has seriesSequence, which we currently ignore
+
+    # id: recommended
+    weight: float | None = None
+
+    # id: listen-again
+    finished_at_ms: Annotated[int | None, Alias("finishedAt")] = None
+
+    # This and the two subclasses are copied over from libraries, as we otherwise
+    # face issues with the discriminator
+    class Config(_LibraryItemBase.Config):
+        """Config."""
+
+        discriminator = Discriminator(
+            field="mediaType",
+            include_subtypes=True,
+        )
+
+    num_files: Annotated[int, Alias("numFiles")]
+    size: int
+
+
+@dataclass(kw_only=True)
+class LibraryItemMinifiedBook(ShelfLibraryItemMinified):
+    """LibraryItemMinifiedBook."""
+
+    media: BookMinified
+    mediaType: LibraryMediaType = LibraryMediaType.BOOK
+
+
+@dataclass(kw_only=True)
+class LibraryItemMinifiedPodcast(ShelfLibraryItemMinified):
+    """LibraryItemMinifiedPodcast."""
+
+    media: PodcastMinified
+    mediaType: LibraryMediaType = LibraryMediaType.PODCAST
+
+
+@dataclass(kw_only=True)
+class LibraryItemMinifiedBookSeriesShelf(ShelfLibraryItemMinified):
+    """LibraryItemMinifiedBookSeriesShelf."""
+
+    # this appears not to be around?
+    series_sequence: Annotated[str | int | None, Alias("seriesSequence")] = None
+
+
+@dataclass(kw_only=True)
+class SeriesShelf(Series):
+    """SeriesShelf."""
+
+    books: list[LibraryItemMinifiedBookSeriesShelf]
+    in_progress: Annotated[bool | None, Alias("inProgress")] = None
+    has_active_book: Annotated[bool | None, Alias("hasActiveBook")] = None
+    hide_from_continue_listening: Annotated[bool | None, Alias("hideFromContinueListening")] = None
+    book_in_progress_last_update_ms: Annotated[int | None, Alias("bookInProgressLastUpdate")] = None
+    first_book_unread: Annotated[
+        LibraryItemMinifiedBookSeriesShelf | None, Alias("firstBookUnread")
+    ] = None
+
+
+class ShelfType(StrEnum):
+    """ShelfType."""
+
+    BOOK = "book"
+    SERIES = "series"
+    AUTHORS = "authors"
+    EPISODE = "episode"
+    PODCAST = "podcast"
+
+
+@dataclass(kw_only=True)
+class _ShelfBase(_BaseModel):
+    """Shelf."""
+
+    id_: Annotated[ShelfId | str, Alias("id")]
+    label: str
+    label_string_key: Annotated[str, Alias("labelStringKey")]
+    type_: Annotated[ShelfType, Alias("type")]
+    category: str | None = None
+
+
+@dataclass(kw_only=True)
+class Shelf(_ShelfBase):
+    """Shelf."""
+
+    class Config(_ShelfBase.Config):
+        """Config."""
+
+        discriminator = Discriminator(
+            field="type",
+            include_subtypes=True,
+        )
+
+
+@dataclass(kw_only=True)
+class ShelfBook(Shelf):
+    """ShelfBook."""
+
+    type = ShelfType.BOOK
+    entities: list[ShelfLibraryItemMinified]
+
+
+@dataclass(kw_only=True)
+class ShelfPodcast(Shelf):
+    """ShelfBook."""
+
+    type = ShelfType.PODCAST
+    entities: list[ShelfLibraryItemMinified]
+
+
+@dataclass(kw_only=True)
+class ShelfEpisode(Shelf):
+    """ShelfBook."""
+
+    type = ShelfType.EPISODE
+    entities: list[ShelfLibraryItemMinified]
+
+
+@dataclass(kw_only=True)
+class ShelfAuthors(Shelf):
+    """ShelfAuthor."""
+
+    type = ShelfType.AUTHORS
+
+    entities: list[AuthorExpanded]
+
+
+@dataclass(kw_only=True)
+class ShelfSeries(Shelf):
+    """ShelfSeries."""
+
+    type = ShelfType.SERIES
+    entities: list[SeriesShelf]

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.4.dist-info → aioaudiobookshelf-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: aioaudiobookshelf
-Version: 0.1.4
+Version: 0.1.11
 Summary: Async library for Audiobookshelf
 Author-email: Fabian Munkes <105975993+fmunkes@users.noreply.github.com>
 License: Apache-2.0
@@ -27,6 +27,7 @@ Requires-Dist: syrupy==4.8.1; extra == "test"
 Requires-Dist: tomli==2.2.1; extra == "test"
 Requires-Dist: ruff==0.9.2; extra == "test"
 Requires-Dist: bumpver; extra == "test"
+Dynamic: license-file
 
 # aioaudiobookshelf
 Async python library to interact with
@@ -109,7 +110,7 @@ async def abs_basics():
 
         # get a single podcast
         podcast_id = "dda96167-eaad-4012-83e1-149c6700d3e8"
-        podcast_expanded = client.get_library_item_podcast(podcast_id=podcast_id, expanded=True)
+        podcast_expanded = await client.get_library_item_podcast(podcast_id=podcast_id, expanded=True)
 
 
 asyncio.run(abs_basics())

{aioaudiobookshelf-0.1.4.dist-info → aioaudiobookshelf-0.1.11.dist-info}/RECORD

@@ -1,33 +1,34 @@
-aioaudiobookshelf/__init__.py,sha256=zihAWwXc_wjsyXfWPt8TJ4r3Ichm5so7484NsDXThP0,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=1S0ACN-fiXKy0uVVLb422LGFB4bOvVFnSvyEDM47-v0,3815
-aioaudiobookshelf/client/authors.py,sha256=8bXN0NsPvH1rvF166xUu7rVC-0P0Sp4N7oxZrO666nc,1129
+aioaudiobookshelf/__init__.py,sha256=xebDvWxDTQNfKKQi9I9V7yKxke3WZoBks6e2nYDPle8,3508
+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=J_RjItJFaq17Po66aEzwrpq6PiCns3xYXWAtewy48K0,7584
+aioaudiobookshelf/client/authors.py,sha256=9F8_tiTqh-5Srn_5I0wdEa1qs_495UctzSF6OlxFOJw,1808
 aioaudiobookshelf/client/collections_.py,sha256=Z3r7dxHhzMm_cGCMRJkVzN5-Eesftib3d0bs4iXmmzY,879
 aioaudiobookshelf/client/items.py,sha256=4yWy7Shd6sbKj4MSGYJXklXs-yZH2q95qGIm4L-PS5o,3624
-aioaudiobookshelf/client/libraries.py,sha256=ejzxUCFgCfWtJQMCjAlo7LHWLk82Kl2BdkjpRVKtBck,6250
+aioaudiobookshelf/client/libraries.py,sha256=VK1VqX9V6_8PAhPVx-eIPOgsS8t_U1a6iFML2nOyi14,6852
 aioaudiobookshelf/client/me.py,sha256=cYmXNoFJHZgEI6Ds19Pf6gNQMBVOqrtcKmiyXHFFIL0,3586
 aioaudiobookshelf/client/playlists.py,sha256=sTsmuBqjSlKyTo31mc9Ha-WtzX7bh0hH7n1BcnlO7YY,875
 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.py,sha256=1eMI_caj6dSTtyC3aqKgLCDqWLEOodFtBkEGoqTOmnw,1508
+aioaudiobookshelf/client/session_configuration.py,sha256=_Y-uDA9iW87siiN9xe-pCOxMS0V41Fl6MGWY4EuZ1tA,3958
 aioaudiobookshelf/schema/__init__.py,sha256=vEEwPVweT0j2VqlBj2V34Xk5J9OBZ7zkd6eLOUx-RdU,358
-aioaudiobookshelf/schema/audio.py,sha256=ByDu3pvldxsXkXP3WqVlxW-7m8NOH9TY-AQ6HfE5wxc,2098
+aioaudiobookshelf/schema/audio.py,sha256=PFKkGsZgJSDYJS-7VwoTvYTcVfR8ip8qOuE8hQa9TtE,2105
 aioaudiobookshelf/schema/author.py,sha256=OZGcCUHOfXvN8N2SRUiIRnDS2Lz3UrQFWOaOZ1sKV0U,976
-aioaudiobookshelf/schema/book.py,sha256=Ckfc_eC6jXtQnQQzl0QaB0edp91G8gIiUJTE7IfctuM,3372
+aioaudiobookshelf/schema/book.py,sha256=mf_PZqClvbfoxUQtm88Cqz14xT-594NZPi6nkQe1_Hk,3386
 aioaudiobookshelf/schema/calls_authors.py,sha256=eIvdyEcrmXuOxFJuCX39cGU9HSZprl40yKn8s2VjfAM,703
 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
-aioaudiobookshelf/schema/calls_session.py,sha256=j2NLUwS4820SwzqPXksteTACXtUXvNtio_wBfvwHHM0,416
+aioaudiobookshelf/schema/calls_session.py,sha256=E90uPxkZrV1FUTSYS9owbzTm8HaRjH4CRmb88XrGqOA,474
 aioaudiobookshelf/schema/collection.py,sha256=fB1VFQXE0hzM_NyWEHj9A11VztD_8rYo4t9OWkDj-Lc,883
 aioaudiobookshelf/schema/events_socket.py,sha256=r24ssixH0dWfyOhv0K5P6GgzGrbYC9Yh8Y2w76-bkeM,1420
-aioaudiobookshelf/schema/file.py,sha256=y_X-m_mk41OUcLpWQ5U_xndyIlG0BoNLS5iJL1RzWqQ,538
+aioaudiobookshelf/schema/file.py,sha256=frymCwsiqOh6fnZPBnkUz1pfyUuKkH4ssRd2WHpsajk,639
 aioaudiobookshelf/schema/folder.py,sha256=3S6aA306JHhOGtCnawUwMJv13_AXsHmhmNX5RzbjnqY,414
 aioaudiobookshelf/schema/library.py,sha256=6Gf9DVjKPJhbmKBaXXSbeUddN-VeUx7mIHZrx7HrfMQ,6174
 aioaudiobookshelf/schema/media_progress.py,sha256=nIISrNvkFV0zmxkGTePuGaw9xW21lTo7ceDdLfG2ffQ,1390
@@ -37,9 +38,10 @@ aioaudiobookshelf/schema/series.py,sha256=XmwDvMchb-W2y-Tm-eKiE-3rPjs4kXC3Ib2dZO
 aioaudiobookshelf/schema/series_books.py,sha256=rs8a4JmSHqJR6WPA2XKXmC6XDq8D9wmzxftLlPhvub8,868
 aioaudiobookshelf/schema/server.py,sha256=yWBRxtwtX1USs43yGFuDIM3jfWbmduW3GRahisOUCqw,2726
 aioaudiobookshelf/schema/session.py,sha256=jqCHNUthuzE6jhgG3UwFgagl1HA_rfDwn6Te38jaqC8,2684
-aioaudiobookshelf/schema/user.py,sha256=Zcnl6gqfc97dmHrNOHVsX_OOqwcJq-eFMhc9zVMLIs4,2057
-aioaudiobookshelf-0.1.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-aioaudiobookshelf-0.1.4.dist-info/METADATA,sha256=OmHbBKE2vAJ8-wU1v1NKsrnTEfwjz5-MTqRnQNKJt6o,4377
-aioaudiobookshelf-0.1.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-aioaudiobookshelf-0.1.4.dist-info/top_level.txt,sha256=2_I2_xz98xmVIT84pcF3tlq3NdZNKskfs7BqUmYZylk,18
-aioaudiobookshelf-0.1.4.dist-info/RECORD,,
+aioaudiobookshelf/schema/shelf.py,sha256=npPr5iacm6b5FfJYF9_lFZaitJNJ3SVvBOScbxlF5MQ,5064
+aioaudiobookshelf/schema/user.py,sha256=cm2Oev9i062mjM3Ku-yaAjm_o4-sJOkJTczdq43_qrY,2485
+aioaudiobookshelf-0.1.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+aioaudiobookshelf-0.1.11.dist-info/METADATA,sha256=uMPo-whmeNF-pi58S6OOA-7vejepwzgNS4lcTfodzvM,4406
+aioaudiobookshelf-0.1.11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aioaudiobookshelf-0.1.11.dist-info/top_level.txt,sha256=2_I2_xz98xmVIT84pcF3tlq3NdZNKskfs7BqUmYZylk,18
+aioaudiobookshelf-0.1.11.dist-info/RECORD,,

{aioaudiobookshelf-0.1.4.dist-info → aioaudiobookshelf-0.1.11.dist-info}/WHEEL

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