deezer-python-gql 0.6.0__tar.gz → 0.8.0__tar.gz

{deezer_python_gql-0.6.0/deezer_python_gql.egg-info → deezer_python_gql-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deezer-python-gql
-Version: 0.6.0
+Version: 0.8.0
 Summary: Async typed Python client for Deezer's Pipe GraphQL API.
 Author-email: Julian Daberkow <jdaberkow@users.noreply.github.com>
 License: Apache-2.0
@@ -184,6 +184,12 @@ asyncio.run(main())
 | `music_together_update_group_settings(...)`       | Update group settings (name, family mode)   |
 | `music_together_generate_group_name()`            | Generate a random group name                |
 
+### Utilities
+
+| Method                           | Description                                                      |
+| -------------------------------- | ---------------------------------------------------------------- |
+| `check_audiobook_ids(album_ids)` | Batch-check which album IDs are audiobooks (single GraphQL call) |
+
 All methods return fully-typed Pydantic models generated from the GraphQL schema.
 
 ## Development

{deezer_python_gql-0.6.0 → deezer_python_gql-0.8.0}/README.md

@@ -156,6 +156,12 @@ asyncio.run(main())
 | `music_together_update_group_settings(...)`       | Update group settings (name, family mode)   |
 | `music_together_generate_group_name()`            | Generate a random group name                |
 
+### Utilities
+
+| Method                           | Description                                                      |
+| -------------------------------- | ---------------------------------------------------------------- |
+| `check_audiobook_ids(album_ids)` | Batch-check which album IDs are audiobooks (single GraphQL call) |
+
 All methods return fully-typed Pydantic models generated from the GraphQL schema.
 
 ## Development

{deezer_python_gql-0.6.0 → deezer_python_gql-0.8.0}/deezer_python_gql/base_client.py

@@ -6,7 +6,7 @@ import json
 import logging
 import time
 from base64 import urlsafe_b64decode
-from typing import Any, ClassVar, cast
+from typing import Any, ClassVar, Self, cast
 
 import httpx
 
@@ -76,9 +76,13 @@ class DeezerBaseClient:
     Handles the ARL cookie → JWT token exchange and automatic refresh.
     This class is used as the base client for ariadne-codegen's generated client.
 
+    Manages its own httpx connection pool by default. Pass an external
+    ``http_client`` only if you need to share a pool across multiple clients.
+
     :param arl: Deezer ARL cookie value for authentication.
     :param url: GraphQL endpoint URL (defaults to Pipe API).
     :param http_client: Optional pre-configured httpx.AsyncClient.
+        If provided, the caller is responsible for closing it.
     """
 
     PIPE_URL = "https://pipe.deezer.com/api"
@@ -94,9 +98,35 @@ class DeezerBaseClient:
         self.url = url
         self._arl = arl
         self._http_client = http_client
+        self._owns_http_client = http_client is None
         self._jwt: str | None = None
         self._jwt_expires_at: float = 0
 
+    def _get_http_client(self) -> httpx.AsyncClient:
+        """Return the HTTP client, creating an internal one if needed."""
+        if self._http_client is None:
+            self._http_client = httpx.AsyncClient()
+            self._owns_http_client = True
+        return self._http_client
+
+    async def close(self) -> None:
+        """Close the internal HTTP client if we own it.
+
+        Safe to call multiple times. Does nothing if an external
+        ``http_client`` was provided at construction time.
+        """
+        if self._owns_http_client and self._http_client is not None:
+            await self._http_client.aclose()
+            self._http_client = None
+
+    async def __aenter__(self) -> Self:
+        """Enter the async context manager."""
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        """Exit the async context manager, closing internal resources."""
+        await self.close()
+
     async def execute(
         self,
         query: str,
@@ -132,24 +162,20 @@ class DeezerBaseClient:
                 k: v for k, v in variables.items() if not isinstance(v, UnsetType)
             }
 
-        client = self._http_client or httpx.AsyncClient()
-        try:
-            resp = await client.post(
-                self.url,
-                json=payload,
-                headers=headers,
-                **kwargs,
-            )
-            logger.debug(
-                "GQL response: %s status=%s length=%s",
-                operation_name or "<unnamed>",
-                resp.status_code,
-                len(resp.content),
-            )
-            return resp
-        finally:
-            if not self._http_client:
-                await client.aclose()
+        client = self._get_http_client()
+        resp = await client.post(
+            self.url,
+            json=payload,
+            headers=headers,
+            **kwargs,
+        )
+        logger.debug(
+            "GQL response: %s status=%s length=%s",
+            operation_name or "<unnamed>",
+            resp.status_code,
+            len(resp.content),
+        )
+        return resp
 
     def get_data(self, response: httpx.Response) -> dict[str, Any]:
         """Parse a GraphQL response and return the data dict.
@@ -236,13 +262,13 @@ class DeezerBaseClient:
         logger.debug("JWT expired or missing, refreshing from ARL")
         params = {"jo": "p", "rto": "c", "i": "c"}
 
-        async with httpx.AsyncClient() as http:
-            resp = await http.post(
-                self.AUTH_URL,
-                params=params,
-                cookies={"arl": self._arl},
-            )
-            resp.raise_for_status()
+        client = self._get_http_client()
+        resp = await client.post(
+            self.AUTH_URL,
+            params=params,
+            cookies={"arl": self._arl},
+        )
+        resp.raise_for_status()
 
         # Response body is text/plain containing JSON
         data = json.loads(resp.text)
@@ -257,3 +283,35 @@ class DeezerBaseClient:
         logger.debug("JWT acquired, expires at %s", self._jwt_expires_at)
 
         return self._jwt
+
+    async def check_audiobook_ids(self, album_ids: list[str]) -> set[str]:
+        """Check which album IDs are also valid audiobooks on Deezer.
+
+        Uses GraphQL aliases to batch-check many IDs in a single request.
+        Returns the subset of IDs that are audiobooks (i.e., the audiobook
+        query returns non-null for them).
+
+        :param album_ids: List of Deezer album/audiobook IDs to check.
+        """
+        if not album_ids:
+            return set()
+
+        # Query displayTitle alongside id — querying only { id } echoes back the
+        # input without validating that the ID is actually an audiobook.
+        parts = [
+            f'a{i}: audiobook(audiobookId: "{aid}") {{ id displayTitle }}'
+            for i, aid in enumerate(album_ids)
+        ]
+        query = "{ " + " ".join(parts) + " }"
+
+        resp = await self.execute(query)
+        data = self.get_data(resp)
+
+        audiobook_ids: set[str] = set()
+        for i, aid in enumerate(album_ids):
+            node = data.get(f"a{i}")
+            # The API echoes back {id} for any valid album, so we must check
+            # a real audiobook field like displayTitle to distinguish.
+            if node is not None and node.get("displayTitle") is not None:
+                audiobook_ids.add(aid)
+        return audiobook_ids

{deezer_python_gql-0.6.0 → deezer_python_gql-0.8.0/deezer_python_gql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deezer-python-gql
-Version: 0.6.0
+Version: 0.8.0
 Summary: Async typed Python client for Deezer's Pipe GraphQL API.
 Author-email: Julian Daberkow <jdaberkow@users.noreply.github.com>
 License: Apache-2.0
@@ -184,6 +184,12 @@ asyncio.run(main())
 | `music_together_update_group_settings(...)`       | Update group settings (name, family mode)   |
 | `music_together_generate_group_name()`            | Generate a random group name                |
 
+### Utilities
+
+| Method                           | Description                                                      |
+| -------------------------------- | ---------------------------------------------------------------- |
+| `check_audiobook_ids(album_ids)` | Batch-check which album IDs are audiobooks (single GraphQL call) |
+
 All methods return fully-typed Pydantic models generated from the GraphQL schema.
 
 ## Development

{deezer_python_gql-0.6.0 → deezer_python_gql-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deezer-python-gql"
-version = "0.6.0"
+version = "0.8.0"
 description = "Async typed Python client for Deezer's Pipe GraphQL API."
 readme = "README.md"
 requires-python = ">=3.12"

{deezer_python_gql-0.6.0 → deezer_python_gql-0.8.0}/tests/test_client.py

@@ -67,6 +67,9 @@ from deezer_python_gql.generated.get_podcast_episode import GetPodcastEpisode
 from deezer_python_gql.generated.get_podcast_episode_bookmarks import (
     GetPodcastEpisodeBookmarks,
 )
+from deezer_python_gql.generated.get_podcast_episodes_by_ids import (
+    GetPodcastEpisodesByIds,
+)
 from deezer_python_gql.generated.get_recently_played import GetRecentlyPlayed
 from deezer_python_gql.generated.get_recommendations import GetRecommendations
 from deezer_python_gql.generated.get_similar_tracks import GetSimilarTracks
@@ -209,6 +212,7 @@ def test_client_has_generated_methods() -> None:
         "remove_tracks_from_playlist",
         "get_podcast",
         "get_podcast_episode",
+        "get_podcast_episodes_by_ids",
         "get_favorite_podcasts",
         "get_podcast_episode_bookmarks",
         "add_podcast_to_favorite",
@@ -241,7 +245,55 @@ def test_client_has_generated_methods() -> None:
 
 
 # ---------------------------------------------------------------------------
-# 2. Auth flow (mocked HTTP)
+# 2. Lifecycle (connection pool management)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_close_shuts_down_internal_client() -> None:
+    """Verify close() calls aclose() on the internally-created httpx client."""
+    client = DeezerBaseClient(arl="test")
+
+    with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_cls:
+        mock_instance = AsyncMock()
+        mock_cls.return_value = mock_instance
+
+        # Trigger lazy creation
+        client._get_http_client()  # noqa: SLF001
+        assert client._http_client is mock_instance  # noqa: SLF001
+
+        await client.close()
+
+    mock_instance.aclose.assert_awaited_once()
+    assert client._http_client is None  # noqa: SLF001
+
+
+@pytest.mark.asyncio
+async def test_close_skips_external_client() -> None:
+    """Verify close() does NOT close an externally-provided httpx client."""
+    external = AsyncMock(spec=httpx.AsyncClient)
+    client = DeezerBaseClient(arl="test", http_client=external)
+
+    await client.close()
+
+    external.aclose.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_context_manager_calls_close() -> None:
+    """Verify the async context manager closes the client on exit."""
+    with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_cls:
+        mock_instance = AsyncMock()
+        mock_cls.return_value = mock_instance
+
+        async with DeezerBaseClient(arl="test") as client:
+            client._get_http_client()  # noqa: SLF001
+
+    mock_instance.aclose.assert_awaited_once()
+
+
+# ---------------------------------------------------------------------------
+# 3. Auth flow (mocked HTTP)
 # ---------------------------------------------------------------------------
 
 
@@ -251,27 +303,19 @@ async def test_auth_acquires_jwt_on_first_request() -> None:
     jwt = _make_jwt()
     client = DeezerBaseClient(arl="test_arl")
 
-    mock_auth = AsyncMock(return_value=_mock_auth_response(jwt))
-    mock_gql = AsyncMock(
-        return_value=httpx.Response(
-            200,
-            json={"data": {"me": {"id": "1"}}},
-            request=httpx.Request("POST", DeezerBaseClient.PIPE_URL),
-        ),
+    gql_response = httpx.Response(
+        200,
+        json={"data": {"me": {"id": "1"}}},
+        request=httpx.Request("POST", DeezerBaseClient.PIPE_URL),
     )
 
     with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_client_cls:
         mock_instance = AsyncMock()
-        mock_instance.post = mock_auth
-        mock_instance.__aenter__ = AsyncMock(return_value=mock_instance)
-        mock_instance.__aexit__ = AsyncMock(return_value=False)
-        mock_client_cls.return_value = mock_instance
-
-        # First call: should trigger auth, then make GQL request
-        # Override post to return auth first, then GQL response
         mock_instance.post = AsyncMock(
-            side_effect=[_mock_auth_response(jwt), mock_gql.return_value],
+            side_effect=[_mock_auth_response(jwt), gql_response],
         )
+        mock_client_cls.return_value = mock_instance
+
         resp = await client.execute(query="{ me { id } }")
 
     assert resp.status_code == 200
@@ -295,8 +339,6 @@ async def test_auth_reuses_valid_jwt() -> None:
     with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_client_cls:
         mock_instance = AsyncMock()
         mock_instance.post = AsyncMock(return_value=gql_response)
-        mock_instance.__aenter__ = AsyncMock(return_value=mock_instance)
-        mock_instance.__aexit__ = AsyncMock(return_value=False)
         mock_client_cls.return_value = mock_instance
 
         await client.execute(query="{ me { id } }")
@@ -317,9 +359,6 @@ async def test_auth_refreshes_expiring_jwt() -> None:
 
     with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_client_cls:
         mock_instance = AsyncMock()
-        mock_instance.__aenter__ = AsyncMock(return_value=mock_instance)
-        mock_instance.__aexit__ = AsyncMock(return_value=False)
-        # Auth response, then GQL response
         mock_instance.post = AsyncMock(
             side_effect=[
                 _mock_auth_response(new_jwt),
@@ -344,8 +383,6 @@ async def test_auth_sends_arl_cookie_to_correct_domain() -> None:
 
     with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_client_cls:
         mock_instance = AsyncMock()
-        mock_instance.__aenter__ = AsyncMock(return_value=mock_instance)
-        mock_instance.__aexit__ = AsyncMock(return_value=False)
         mock_instance.post = AsyncMock(
             side_effect=[
                 _mock_auth_response(),
@@ -375,8 +412,6 @@ async def test_auth_parses_text_plain_response() -> None:
     # Verify _ensure_jwt correctly parses the text/plain body
     with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_client_cls:
         mock_instance = AsyncMock()
-        mock_instance.__aenter__ = AsyncMock(return_value=mock_instance)
-        mock_instance.__aexit__ = AsyncMock(return_value=False)
         mock_instance.post = AsyncMock(return_value=_mock_auth_response(jwt))
         mock_client_cls.return_value = mock_instance
 
@@ -387,7 +422,7 @@ async def test_auth_parses_text_plain_response() -> None:
 
 
 # ---------------------------------------------------------------------------
-# 3. Error handling (mocked HTTP)
+# 4. Error handling (mocked HTTP)
 # ---------------------------------------------------------------------------
 
 
@@ -467,7 +502,49 @@ def test_get_data_returns_data_on_success() -> None:
 
 
 # ---------------------------------------------------------------------------
-# 4. Model smoke tests (one per query — fixture-based)
+# 5. check_audiobook_ids tests
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_check_audiobook_ids_returns_matching() -> None:
+    """Verify check_audiobook_ids returns IDs that are valid audiobooks."""
+    client = DeezerBaseClient(arl="test_arl")
+    client._jwt = _make_jwt(exp=time.time() + 600)  # noqa: SLF001
+    client._jwt_expires_at = time.time() + 600  # noqa: SLF001
+
+    # a0 is an audiobook (has displayTitle), a1 is not (displayTitle is null)
+    gql_response = httpx.Response(
+        200,
+        json={
+            "data": {
+                "a0": {"id": "111", "displayTitle": "Test Book"},
+                "a1": {"id": "222", "displayTitle": None},
+            }
+        },
+        request=httpx.Request("POST", DeezerBaseClient.PIPE_URL),
+    )
+
+    with patch("deezer_python_gql.base_client.httpx.AsyncClient") as mock_client_cls:
+        mock_instance = AsyncMock()
+        mock_instance.post = AsyncMock(return_value=gql_response)
+        mock_client_cls.return_value = mock_instance
+
+        result = await client.check_audiobook_ids(["111", "222"])
+
+    assert result == {"111"}
+
+
+@pytest.mark.asyncio
+async def test_check_audiobook_ids_empty_input() -> None:
+    """Verify check_audiobook_ids returns empty set for empty input."""
+    client = DeezerBaseClient(arl="test_arl")
+    result = await client.check_audiobook_ids([])
+    assert result == set()
+
+
+# ---------------------------------------------------------------------------
+# 6. Model smoke tests (one per query — fixture-based)
 # ---------------------------------------------------------------------------
 
 
@@ -548,7 +625,7 @@ def test_smoke_search() -> None:
 
 
 # ---------------------------------------------------------------------------
-# 5. Browse-related model smoke tests (new queries)
+# 6. Browse-related model smoke tests (new queries)
 # ---------------------------------------------------------------------------
 
 
@@ -995,6 +1072,20 @@ def test_smoke_get_podcast_episode() -> None:
     assert ep.podcast.display_title == "Tech Weekly"
 
 
+def test_smoke_get_podcast_episodes_by_ids() -> None:
+    """Verify GetPodcastEpisodesByIds fixture parses with nullable entries."""
+    data = _load_fixture("get_podcast_episodes_by_ids.json")
+    episodes = GetPodcastEpisodesByIds.model_validate(data).podcast_episodes_by_ids
+    assert len(episodes) == 3
+    assert episodes[0] is not None
+    assert episodes[0].id == "ep_100"
+    assert episodes[0].title == "Episode 100: AI Revolution"
+    assert episodes[0].duration == 2400
+    assert episodes[1] is not None
+    assert episodes[1].id == "ep_099"
+    assert episodes[2] is None
+
+
 def test_smoke_get_favorite_podcasts() -> None:
     """Verify GetFavoritePodcasts fixture parses with pagination."""
     data = _load_fixture("get_favorite_podcasts.json")