deezer-python-gql 0.1.0__tar.gz → 0.2.0__tar.gz

{deezer_python_gql-0.1.0/deezer_python_gql.egg-info → deezer_python_gql-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deezer-python-gql
-Version: 0.1.0
+Version: 0.2.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
@@ -14,14 +14,14 @@ License-File: LICENSE
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.0.0
 Provides-Extra: test
-Requires-Dist: codespell==2.4.1; extra == "test"
+Requires-Dist: codespell==2.4.2; extra == "test"
 Requires-Dist: mypy==1.19.1; extra == "test"
 Requires-Dist: pre-commit==4.5.1; extra == "test"
 Requires-Dist: pre-commit-hooks==6.0.0; extra == "test"
 Requires-Dist: pytest==9.0.2; extra == "test"
 Requires-Dist: pytest-asyncio==1.3.0; extra == "test"
-Requires-Dist: pytest-cov==7.0.0; extra == "test"
-Requires-Dist: ruff==0.15.1; extra == "test"
+Requires-Dist: pytest-cov==7.1.0; extra == "test"
+Requires-Dist: ruff==0.15.7; extra == "test"
 Provides-Extra: dev
 Requires-Dist: ariadne-codegen[subscriptions]; extra == "dev"
 Dynamic: license-file
@@ -79,14 +79,26 @@ asyncio.run(main())
 
 ## Available Queries
 
-| Method                      | Description                                                   |
-| --------------------------- | ------------------------------------------------------------- |
-| `get_me()`                  | Current authenticated user                                    |
-| `get_track(track_id)`       | Full track details — ISRC, media tokens, lyrics, contributors |
-| `get_album(album_id)`       | Album with cover, label, paginated tracks, fallback           |
-| `get_artist(artist_id)`     | Artist with bio, top tracks, albums (ordered by release date) |
-| `get_playlist(playlist_id)` | Playlist with owner, picture, paginated tracks                |
-| `search(query, ...)`        | Unified search across tracks, albums, artists, playlists      |
+| Method                                           | Description                                                   |
+| ------------------------------------------------ | ------------------------------------------------------------- |
+| `get_me()`                                       | Current authenticated user                                    |
+| `get_track(track_id)`                            | Full track details — ISRC, media tokens, lyrics, contributors |
+| `get_album(album_id)`                            | Album with cover, label, paginated tracks, fallback           |
+| `get_artist(artist_id)`                          | Artist with bio, top tracks, albums (ordered by release date) |
+| `get_playlist(playlist_id)`                      | Playlist with owner, picture, paginated tracks                |
+| `search(query, ...)`                             | Unified search across tracks, albums, artists, playlists      |
+| `get_flow()`                                     | User's default Flow with tracks                               |
+| `get_flow_configs(moods_first, genres_first)`    | Mood & genre flow config lists for discovery                  |
+| `get_flow_config_tracks(flow_config_id)`         | Tracks for a specific mood/genre flow config                  |
+| `get_made_for_me(first)`                         | "Made For You" SmartTracklist & Flow items                    |
+| `get_smart_tracklist(smart_tracklist_id, first)` | Smart tracklist with paginated tracks                         |
+| `get_charts(country_code, ...)`                  | Country charts — tracks, albums, artists, playlists           |
+| `get_recommendations(playlists_first, ...)`      | Personalized recommendations across categories                |
+| `get_recently_played(first)`                     | Recently played mixed content (albums, playlists, artists...) |
+| `get_favorite_artists(first, after)`             | Paginated favorite artists                                    |
+| `get_favorite_albums(first, after)`              | Paginated favorite albums                                     |
+| `get_favorite_tracks(first, after)`              | Paginated favorite tracks                                     |
+| `get_favorite_playlists(first, after)`           | Paginated favorite playlists                                  |
 
 All methods return fully-typed Pydantic models generated from the GraphQL schema.
 

{deezer_python_gql-0.1.0 → deezer_python_gql-0.2.0}/README.md

@@ -51,14 +51,26 @@ asyncio.run(main())
 
 ## Available Queries
 
-| Method                      | Description                                                   |
-| --------------------------- | ------------------------------------------------------------- |
-| `get_me()`                  | Current authenticated user                                    |
-| `get_track(track_id)`       | Full track details — ISRC, media tokens, lyrics, contributors |
-| `get_album(album_id)`       | Album with cover, label, paginated tracks, fallback           |
-| `get_artist(artist_id)`     | Artist with bio, top tracks, albums (ordered by release date) |
-| `get_playlist(playlist_id)` | Playlist with owner, picture, paginated tracks                |
-| `search(query, ...)`        | Unified search across tracks, albums, artists, playlists      |
+| Method                                           | Description                                                   |
+| ------------------------------------------------ | ------------------------------------------------------------- |
+| `get_me()`                                       | Current authenticated user                                    |
+| `get_track(track_id)`                            | Full track details — ISRC, media tokens, lyrics, contributors |
+| `get_album(album_id)`                            | Album with cover, label, paginated tracks, fallback           |
+| `get_artist(artist_id)`                          | Artist with bio, top tracks, albums (ordered by release date) |
+| `get_playlist(playlist_id)`                      | Playlist with owner, picture, paginated tracks                |
+| `search(query, ...)`                             | Unified search across tracks, albums, artists, playlists      |
+| `get_flow()`                                     | User's default Flow with tracks                               |
+| `get_flow_configs(moods_first, genres_first)`    | Mood & genre flow config lists for discovery                  |
+| `get_flow_config_tracks(flow_config_id)`         | Tracks for a specific mood/genre flow config                  |
+| `get_made_for_me(first)`                         | "Made For You" SmartTracklist & Flow items                    |
+| `get_smart_tracklist(smart_tracklist_id, first)` | Smart tracklist with paginated tracks                         |
+| `get_charts(country_code, ...)`                  | Country charts — tracks, albums, artists, playlists           |
+| `get_recommendations(playlists_first, ...)`      | Personalized recommendations across categories                |
+| `get_recently_played(first)`                     | Recently played mixed content (albums, playlists, artists...) |
+| `get_favorite_artists(first, after)`             | Paginated favorite artists                                    |
+| `get_favorite_albums(first, after)`              | Paginated favorite albums                                     |
+| `get_favorite_tracks(first, after)`              | Paginated favorite tracks                                     |
+| `get_favorite_playlists(first, after)`           | Paginated favorite playlists                                  |
 
 All methods return fully-typed Pydantic models generated from the GraphQL schema.
 

{deezer_python_gql-0.1.0 → deezer_python_gql-0.2.0}/deezer_python_gql/base_client.py

@@ -3,12 +3,15 @@
 from __future__ import annotations
 
 import json
+import logging
 import time
 from base64 import urlsafe_b64decode
-from typing import Any, cast
+from typing import Any, ClassVar, cast
 
 import httpx
 
+logger = logging.getLogger(__name__)
+
 
 class GraphQLClientError(Exception):
     """Base exception for GraphQL client errors."""
@@ -110,6 +113,7 @@ class DeezerBaseClient:
         :param variables: Optional query variables.
         :param kwargs: Additional keyword arguments passed to httpx.
         """
+        logger.debug("GQL execute: %s (variables=%s)", operation_name or "<unnamed>", variables)
         jwt = await self._ensure_jwt()
 
         headers: dict[str, str] = kwargs.pop("headers", None) or {}
@@ -120,16 +124,29 @@ class DeezerBaseClient:
         if operation_name:
             payload["operationName"] = operation_name
         if variables:
-            payload["variables"] = variables
+            # Filter out UNSET sentinel values that are not JSON-serializable.
+            # Inline import avoids depending on generated code at module level.
+            from deezer_python_gql.generated.base_model import UnsetType  # noqa: PLC0415
+
+            payload["variables"] = {
+                k: v for k, v in variables.items() if not isinstance(v, UnsetType)
+            }
 
         client = self._http_client or httpx.AsyncClient()
         try:
-            return await client.post(
+            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()
@@ -159,10 +176,52 @@ class DeezerBaseClient:
         errors = response_json.get("errors")
 
         if errors:
-            raise GraphQLClientGraphQLMultiError.from_errors_dicts(errors_dicts=errors, data=data)
+            if data:
+                # Partial success — some items failed (e.g. deleted albums in favorites).
+                # Log the errors but return the valid data.
+                logger.warning(
+                    "GraphQL response contained %d error(s): %s",
+                    len(errors),
+                    [e.get("message", "Unknown error") for e in errors],
+                )
+            else:
+                raise GraphQLClientGraphQLMultiError.from_errors_dicts(
+                    errors_dicts=errors, data=data
+                )
+
+        # The Deezer API omits __typename for single-member union types
+        # (e.g. Contributor = Artist). Pydantic discriminated unions require it,
+        # so we inject the missing field before model validation.
+        self._inject_missing_typenames(data)
 
         return cast("dict[str, Any]", data)
 
+    # Map of parent key → child key → __typename value for single-member unions
+    # where the Deezer API omits the discriminator.
+    _TYPENAME_PATCHES: ClassVar[dict[str, dict[str, str]]] = {
+        "contributors": {"node": "Artist"},
+    }
+
+    @classmethod
+    def _inject_missing_typenames(cls, obj: Any) -> None:
+        """Recursively inject __typename into nodes where the API omits it."""
+        if isinstance(obj, dict):
+            for parent_key, patches in cls._TYPENAME_PATCHES.items():
+                if parent_key in obj:
+                    container = obj[parent_key]
+                    if isinstance(container, dict) and "edges" in container:
+                        for edge in container["edges"]:
+                            if isinstance(edge, dict):
+                                for child_key, typename in patches.items():
+                                    node = edge.get(child_key)
+                                    if isinstance(node, dict) and "__typename" not in node:
+                                        node["__typename"] = typename
+            for value in obj.values():
+                cls._inject_missing_typenames(value)
+        elif isinstance(obj, list):
+            for item in obj:
+                cls._inject_missing_typenames(item)
+
     async def _ensure_jwt(self) -> str:
         """Acquire or refresh the JWT token from ARL cookie.
 
@@ -174,6 +233,7 @@ class DeezerBaseClient:
         if self._jwt and now < (self._jwt_expires_at - self.JWT_REFRESH_MARGIN_SECONDS):
             return self._jwt
 
+        logger.debug("JWT expired or missing, refreshing from ARL")
         params = {"jo": "p", "rto": "c", "i": "c"}
 
         async with httpx.AsyncClient() as http:
@@ -194,5 +254,6 @@ class DeezerBaseClient:
         padded = payload_segment + "=" * (-len(payload_segment) % 4)
         payload = json.loads(urlsafe_b64decode(padded))
         self._jwt_expires_at = float(payload["exp"])
+        logger.debug("JWT acquired, expires at %s", self._jwt_expires_at)
 
         return self._jwt

{deezer_python_gql-0.1.0 → deezer_python_gql-0.2.0/deezer_python_gql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deezer-python-gql
-Version: 0.1.0
+Version: 0.2.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
@@ -14,14 +14,14 @@ License-File: LICENSE
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.0.0
 Provides-Extra: test
-Requires-Dist: codespell==2.4.1; extra == "test"
+Requires-Dist: codespell==2.4.2; extra == "test"
 Requires-Dist: mypy==1.19.1; extra == "test"
 Requires-Dist: pre-commit==4.5.1; extra == "test"
 Requires-Dist: pre-commit-hooks==6.0.0; extra == "test"
 Requires-Dist: pytest==9.0.2; extra == "test"
 Requires-Dist: pytest-asyncio==1.3.0; extra == "test"
-Requires-Dist: pytest-cov==7.0.0; extra == "test"
-Requires-Dist: ruff==0.15.1; extra == "test"
+Requires-Dist: pytest-cov==7.1.0; extra == "test"
+Requires-Dist: ruff==0.15.7; extra == "test"
 Provides-Extra: dev
 Requires-Dist: ariadne-codegen[subscriptions]; extra == "dev"
 Dynamic: license-file
@@ -79,14 +79,26 @@ asyncio.run(main())
 
 ## Available Queries
 
-| Method                      | Description                                                   |
-| --------------------------- | ------------------------------------------------------------- |
-| `get_me()`                  | Current authenticated user                                    |
-| `get_track(track_id)`       | Full track details — ISRC, media tokens, lyrics, contributors |
-| `get_album(album_id)`       | Album with cover, label, paginated tracks, fallback           |
-| `get_artist(artist_id)`     | Artist with bio, top tracks, albums (ordered by release date) |
-| `get_playlist(playlist_id)` | Playlist with owner, picture, paginated tracks                |
-| `search(query, ...)`        | Unified search across tracks, albums, artists, playlists      |
+| Method                                           | Description                                                   |
+| ------------------------------------------------ | ------------------------------------------------------------- |
+| `get_me()`                                       | Current authenticated user                                    |
+| `get_track(track_id)`                            | Full track details — ISRC, media tokens, lyrics, contributors |
+| `get_album(album_id)`                            | Album with cover, label, paginated tracks, fallback           |
+| `get_artist(artist_id)`                          | Artist with bio, top tracks, albums (ordered by release date) |
+| `get_playlist(playlist_id)`                      | Playlist with owner, picture, paginated tracks                |
+| `search(query, ...)`                             | Unified search across tracks, albums, artists, playlists      |
+| `get_flow()`                                     | User's default Flow with tracks                               |
+| `get_flow_configs(moods_first, genres_first)`    | Mood & genre flow config lists for discovery                  |
+| `get_flow_config_tracks(flow_config_id)`         | Tracks for a specific mood/genre flow config                  |
+| `get_made_for_me(first)`                         | "Made For You" SmartTracklist & Flow items                    |
+| `get_smart_tracklist(smart_tracklist_id, first)` | Smart tracklist with paginated tracks                         |
+| `get_charts(country_code, ...)`                  | Country charts — tracks, albums, artists, playlists           |
+| `get_recommendations(playlists_first, ...)`      | Personalized recommendations across categories                |
+| `get_recently_played(first)`                     | Recently played mixed content (albums, playlists, artists...) |
+| `get_favorite_artists(first, after)`             | Paginated favorite artists                                    |
+| `get_favorite_albums(first, after)`              | Paginated favorite albums                                     |
+| `get_favorite_tracks(first, after)`              | Paginated favorite tracks                                     |
+| `get_favorite_playlists(first, after)`           | Paginated favorite playlists                                  |
 
 All methods return fully-typed Pydantic models generated from the GraphQL schema.
 

{deezer_python_gql-0.1.0 → deezer_python_gql-0.2.0}/deezer_python_gql.egg-info/requires.txt

@@ -5,11 +5,11 @@ pydantic>=2.0.0
 ariadne-codegen[subscriptions]
 
 [test]
-codespell==2.4.1
+codespell==2.4.2
 mypy==1.19.1
 pre-commit==4.5.1
 pre-commit-hooks==6.0.0
 pytest==9.0.2
 pytest-asyncio==1.3.0
-pytest-cov==7.0.0
-ruff==0.15.1
+pytest-cov==7.1.0
+ruff==0.15.7

{deezer_python_gql-0.1.0 → deezer_python_gql-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deezer-python-gql"
-version = "0.1.0"
+version = "0.2.0"
 description = "Async typed Python client for Deezer's Pipe GraphQL API."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -22,14 +22,14 @@ text = "Apache-2.0"
 
 [project.optional-dependencies]
 test = [
-    "codespell==2.4.1",
+    "codespell==2.4.2",
     "mypy==1.19.1",
     "pre-commit==4.5.1",
     "pre-commit-hooks==6.0.0",
     "pytest==9.0.2",
     "pytest-asyncio==1.3.0",
-    "pytest-cov==7.0.0",
-    "ruff==0.15.1",
+    "pytest-cov==7.1.0",
+    "ruff==0.15.7",
 ]
 dev = [
     "ariadne-codegen[subscriptions]",

{deezer_python_gql-0.1.0 → deezer_python_gql-0.2.0}/tests/test_client.py

@@ -28,10 +28,24 @@ from deezer_python_gql.base_client import (
 )
 from deezer_python_gql.generated.get_album import GetAlbum
 from deezer_python_gql.generated.get_artist import GetArtist
+from deezer_python_gql.generated.get_charts import GetCharts
+from deezer_python_gql.generated.get_favorite_albums import GetFavoriteAlbums
+from deezer_python_gql.generated.get_favorite_artists import GetFavoriteArtists
+from deezer_python_gql.generated.get_favorite_playlists import GetFavoritePlaylists
+from deezer_python_gql.generated.get_favorite_tracks import GetFavoriteTracks
+from deezer_python_gql.generated.get_flow import GetFlow
+from deezer_python_gql.generated.get_flow_config_tracks import GetFlowConfigTracks
+from deezer_python_gql.generated.get_flow_configs import GetFlowConfigs
+from deezer_python_gql.generated.get_made_for_me import GetMadeForMe
 from deezer_python_gql.generated.get_me import GetMe
 from deezer_python_gql.generated.get_playlist import GetPlaylist
+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_smart_tracklist import GetSmartTracklist
 from deezer_python_gql.generated.get_track import GetTrack
+from deezer_python_gql.generated.get_user_charts import GetUserCharts
 from deezer_python_gql.generated.search import Search
+from deezer_python_gql.generated.search_flows import SearchFlows
 
 FIXTURES = Path(__file__).parent / "fixtures"
 
@@ -96,7 +110,28 @@ def test_client_instantiation() -> None:
 def test_client_has_generated_methods() -> None:
     """Verify that codegen produced all expected query methods."""
     client = DeezerGQLClient(arl="test")
-    expected_methods = ["get_me", "get_track", "get_album", "get_artist", "get_playlist", "search"]
+    expected_methods = [
+        "get_me",
+        "get_track",
+        "get_album",
+        "get_artist",
+        "get_playlist",
+        "search",
+        "get_flow",
+        "get_flow_configs",
+        "get_flow_config_tracks",
+        "get_made_for_me",
+        "get_smart_tracklist",
+        "get_charts",
+        "get_recommendations",
+        "get_recently_played",
+        "get_favorite_artists",
+        "get_favorite_albums",
+        "get_favorite_tracks",
+        "get_favorite_playlists",
+        "search_flows",
+        "get_user_charts",
+    ]
     for method in expected_methods:
         assert hasattr(client, method), f"Missing method: {method}"
         assert callable(getattr(client, method))
@@ -404,3 +439,231 @@ def test_smoke_search() -> None:
     assert len(results.artists.edges) > 0
     assert len(results.playlists.edges) > 0
     assert isinstance(results.tracks.page_info.has_next_page, bool)
+
+
+# ---------------------------------------------------------------------------
+# 5. Browse-related model smoke tests (new queries)
+# ---------------------------------------------------------------------------
+
+
+def test_smoke_get_flow() -> None:
+    """Verify GetFlow fixture parses with flow tracks."""
+    data = _load_fixture("get_flow.json")
+    me = GetFlow.model_validate(data).me
+    assert me is not None
+    assert me.flow is not None
+    assert me.flow.id == "flow:default"
+    assert me.flow.title == "Flow"
+    assert len(me.flow.tracks) == 2
+    assert me.flow.tracks[0].track is not None
+    assert me.flow.tracks[0].track.title == "Harder, Better, Faster, Stronger"
+
+
+def test_smoke_get_flow_configs() -> None:
+    """Verify GetFlowConfigs fixture parses mood and genre flow configs."""
+    data = _load_fixture("get_flow_configs.json")
+    me = GetFlowConfigs.model_validate(data).me
+    assert me is not None
+    configs = me.flow_configs
+    assert len(configs.moods.edges) == 3
+    assert len(configs.genres.edges) == 3
+    mood_node = configs.moods.edges[0].node
+    assert mood_node is not None
+    assert mood_node.title == "Chill"
+    genre_node = configs.genres.edges[0].node
+    assert genre_node is not None
+    assert genre_node.title == "Rock"
+    assert configs.moods.page_info.has_next_page is True
+
+
+def test_smoke_get_flow_config_tracks() -> None:
+    """Verify GetFlowConfigTracks fixture parses tracks for a flow config."""
+    data = _load_fixture("get_flow_config_tracks.json")
+    flow_config = GetFlowConfigTracks.model_validate(data).flow_config
+    assert flow_config is not None
+    assert flow_config.id == "flow_config:chill"
+    assert flow_config.title == "Chill"
+    assert len(flow_config.tracks) == 1
+    assert flow_config.tracks[0].track is not None
+    assert flow_config.tracks[0].track.title == "Around the World"
+
+
+def test_smoke_get_made_for_me() -> None:
+    """Verify GetMadeForMe fixture parses SmartTracklist and Flow items."""
+    data = _load_fixture("get_made_for_me.json")
+    me = GetMadeForMe.model_validate(data).me
+    assert me is not None
+    edges = me.made_for_me.edges
+    assert len(edges) == 3
+    # First two are SmartTracklists, third is a Flow
+    node_0 = edges[0].node
+    assert node_0 is not None
+    assert node_0.typename__ == "SmartTracklist"
+    node_2 = edges[2].node
+    assert node_2 is not None
+    assert node_2.typename__ == "Flow"
+
+
+def test_smoke_get_smart_tracklist() -> None:
+    """Verify GetSmartTracklist fixture parses with paginated tracks."""
+    data = _load_fixture("get_smart_tracklist.json")
+    st = GetSmartTracklist.model_validate(data).smart_tracklist
+    assert st is not None
+    assert st.id == "smart:daily_mix_1"
+    assert st.title == "Your Daily Mix 1"
+    assert len(st.tracks.edges) == 2
+    track_node = st.tracks.edges[0].node
+    assert track_node is not None
+    assert track_node.title == "Harder, Better, Faster, Stronger"
+    assert st.tracks.page_info.has_next_page is True
+
+
+def test_smoke_get_charts() -> None:
+    """Verify GetCharts fixture parses all chart categories."""
+    data = _load_fixture("get_charts.json")
+    charts = GetCharts.model_validate(data).charts
+    assert charts is not None
+    country = charts.country
+    assert country is not None
+    assert country.tracks is not None
+    assert country.albums is not None
+    assert country.artists is not None
+    assert country.playlists is not None
+    assert len(country.tracks.edges) > 0
+    assert len(country.albums.edges) > 0
+    assert len(country.artists.edges) > 0
+    assert len(country.playlists.edges) > 0
+    first_track = country.tracks.edges[0].node
+    assert first_track is not None
+    assert first_track.title == "Greedy"
+
+
+def test_smoke_get_recommendations() -> None:
+    """Verify GetRecommendations fixture parses all recommendation categories."""
+    data = _load_fixture("get_recommendations.json")
+    me = GetRecommendations.model_validate(data).me
+    assert me is not None
+    reco = me.recommendations
+    assert len(reco.playlists.edges) > 0
+    assert len(reco.artist_playlists.edges) == 2
+    assert reco.artist_playlists.edges[0].node is not None
+    assert reco.artist_playlists.edges[0].node.title == "This Is Daft Punk"
+    assert len(reco.new_releases.edges) > 0
+    assert len(reco.artists.edges) > 0
+    assert reco.hot_tracks is not None
+    assert len(reco.hot_tracks) > 0
+    assert reco.hot_tracks[0].title == "Harder, Better, Faster, Stronger"
+
+
+def test_smoke_get_recently_played() -> None:
+    """Verify GetRecentlyPlayed fixture parses mixed content types."""
+    data = _load_fixture("get_recently_played.json")
+    me = GetRecentlyPlayed.model_validate(data).me
+    assert me is not None
+    edges = me.recently_played.edges
+    assert len(edges) == 4
+    # Check discriminated union types
+    node_0 = edges[0].node
+    assert node_0 is not None
+    assert node_0.typename__ == "Album"
+    node_1 = edges[1].node
+    assert node_1 is not None
+    assert node_1.typename__ == "Playlist"
+    node_2 = edges[2].node
+    assert node_2 is not None
+    assert node_2.typename__ == "Artist"
+    node_3 = edges[3].node
+    assert node_3 is not None
+    assert node_3.typename__ == "Flow"
+
+
+def test_smoke_get_favorite_artists() -> None:
+    """Verify GetFavoriteArtists fixture parses with pagination."""
+    data = _load_fixture("get_favorite_artists.json")
+    me = GetFavoriteArtists.model_validate(data).me
+    assert me is not None
+    artists = me.user_favorites.artists
+    assert artists is not None
+    assert len(artists.edges) == 2
+    artist_node = artists.edges[0].node
+    assert artist_node is not None
+    assert artist_node.name == "Daft Punk"
+    assert artists.page_info.has_next_page is True
+
+
+def test_smoke_get_favorite_albums() -> None:
+    """Verify GetFavoriteAlbums fixture parses with pagination."""
+    data = _load_fixture("get_favorite_albums.json")
+    me = GetFavoriteAlbums.model_validate(data).me
+    assert me is not None
+    albums = me.user_favorites.albums
+    assert albums is not None
+    assert len(albums.edges) == 1
+    album_node = albums.edges[0].node
+    assert album_node is not None
+    assert album_node.display_title == "Discovery"
+    assert albums.page_info.has_next_page is True
+
+
+def test_smoke_get_favorite_tracks() -> None:
+    """Verify GetFavoriteTracks fixture parses with pagination."""
+    data = _load_fixture("get_favorite_tracks.json")
+    me = GetFavoriteTracks.model_validate(data).me
+    assert me is not None
+    tracks = me.user_favorites.tracks
+    assert tracks is not None
+    assert len(tracks.edges) == 1
+    track_node = tracks.edges[0].node
+    assert track_node is not None
+    assert track_node.title == "Harder, Better, Faster, Stronger"
+    assert tracks.page_info.has_next_page is True
+
+
+def test_smoke_get_favorite_playlists() -> None:
+    """Verify GetFavoritePlaylists fixture parses with pagination."""
+    data = _load_fixture("get_favorite_playlists.json")
+    me = GetFavoritePlaylists.model_validate(data).me
+    assert me is not None
+    playlists = me.user_favorites.playlists
+    assert playlists is not None
+    assert len(playlists.edges) == 1
+    playlist_node = playlists.edges[0].node
+    assert playlist_node is not None
+    assert playlist_node.title == "Electronic Hits"
+    assert playlists.page_info.has_next_page is True
+
+
+def test_smoke_search_flows() -> None:
+    """Verify SearchFlows fixture parses with flow config nodes."""
+    data = _load_fixture("search_flows.json")
+    search = SearchFlows.model_validate(data).search
+    assert search is not None
+    flow_configs = search.results.flow_configs
+    assert len(flow_configs.edges) == 5
+    first_node = flow_configs.edges[0].node
+    assert first_node is not None
+    assert first_node.id == "flow_config:chill"
+    assert first_node.title == "Chill"
+    assert first_node.visuals.hardware_square_icon is not None
+    assert len(first_node.visuals.hardware_square_icon.urls) == 1
+    assert flow_configs.page_info.has_next_page is True
+
+
+def test_smoke_get_user_charts() -> None:
+    """Verify GetUserCharts fixture parses personal top tracks/artists/albums."""
+    data = _load_fixture("get_user_charts.json")
+    me = GetUserCharts.model_validate(data).me
+    assert me is not None
+    charts = me.charts
+    assert charts.tracks is not None
+    assert len(charts.tracks.edges) == 2
+    assert charts.tracks.edges[0].node is not None
+    assert charts.tracks.edges[0].node.title == "Harder, Better, Faster, Stronger"
+    assert charts.artists is not None
+    assert len(charts.artists.edges) == 2
+    assert charts.artists.edges[0].node is not None
+    assert charts.artists.edges[0].node.name == "Daft Punk"
+    assert charts.albums is not None
+    assert len(charts.albums.edges) == 1
+    assert charts.albums.edges[0].node is not None
+    assert charts.albums.edges[0].node.display_title == "Discovery"