ma-http-client 0.1.2__tar.gz → 0.2.0__tar.gz

{ma_http_client-0.1.2 → ma_http_client-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ma-http-client
-Version: 0.1.2
+Version: 0.2.0
 Summary: A simple HTTP client for the Music Assistant API
 Author-email: Mike Gray/Oscillate Labs <mike@oscillatelabs.net>
 License: Apache-2.0
@@ -50,12 +50,38 @@ players = client.get_players()
 # Search for media
 results = client.search_media("Radiohead", limit=5)
 
-# Play media on a player
+# Resolve one item by name; the server matches across types, or narrow it
+album = client.get_item_by_name("Abbey Road", artist="The Beatles")
+track = client.get_track_by_name("Come Together", artist_name="The Beatles")
+
+# Play media on a player (a uri or a list of uris; shuffle is optional)
 client.play_media(queue_id=players[0].player_id, media="library://artist/204")
+client.play_media(queue_id=players[0].player_id, media=album["uri"], shuffle=True)
 
-# Queue controls
+# Queue controls and modes
 client.queue_command_pause(players[0].player_id)
 client.queue_command_next(players[0].player_id)
+client.queue_set_shuffle(players[0].player_id, True)
+client.queue_set_repeat(players[0].player_id, RepeatMode.ALL)  # from music_assistant_models.enums
+
+# Favorites
+client.add_favorite(track["uri"])
+
+# Library listings and genres ("play some jazz", "play some music")
+from ma_http_client import SORT_RANDOM
+jazz = client.search_genres("jazz")[0]
+tracks = client.genre_tracks(jazz["item_id"], limit=30, sort_field=SORT_RANDOM)
+random_tracks = client.library_items(MediaType.TRACK, limit=20, sort_field=SORT_RANDOM)
+client.play_media(players[0].player_id, [t["uri"] for t in tracks], shuffle=True)
+
+# Playlists
+workout = client.library_playlists(search="workout") or [client.create_playlist("Workout")]
+client.add_playlist_tracks(workout[0]["item_id"], [track["uri"]])
+client.save_queue_as_playlist(players[0].player_id, "Tonight")
+
+# Browse provider folders, e.g. radio stations by country, language, or tag
+stations = client.browse("radiobrowser://category/tag/jazz", limit=10)
+client.play_media(players[0].player_id, [s["uri"] for s in stations])
 
 # Volume
 client.player_command_volume_set(players[0].player_id, 50)

{ma_http_client-0.1.2 → ma_http_client-0.2.0}/README.md

@@ -26,12 +26,38 @@ players = client.get_players()
 # Search for media
 results = client.search_media("Radiohead", limit=5)
 
-# Play media on a player
+# Resolve one item by name; the server matches across types, or narrow it
+album = client.get_item_by_name("Abbey Road", artist="The Beatles")
+track = client.get_track_by_name("Come Together", artist_name="The Beatles")
+
+# Play media on a player (a uri or a list of uris; shuffle is optional)
 client.play_media(queue_id=players[0].player_id, media="library://artist/204")
+client.play_media(queue_id=players[0].player_id, media=album["uri"], shuffle=True)
 
-# Queue controls
+# Queue controls and modes
 client.queue_command_pause(players[0].player_id)
 client.queue_command_next(players[0].player_id)
+client.queue_set_shuffle(players[0].player_id, True)
+client.queue_set_repeat(players[0].player_id, RepeatMode.ALL)  # from music_assistant_models.enums
+
+# Favorites
+client.add_favorite(track["uri"])
+
+# Library listings and genres ("play some jazz", "play some music")
+from ma_http_client import SORT_RANDOM
+jazz = client.search_genres("jazz")[0]
+tracks = client.genre_tracks(jazz["item_id"], limit=30, sort_field=SORT_RANDOM)
+random_tracks = client.library_items(MediaType.TRACK, limit=20, sort_field=SORT_RANDOM)
+client.play_media(players[0].player_id, [t["uri"] for t in tracks], shuffle=True)
+
+# Playlists
+workout = client.library_playlists(search="workout") or [client.create_playlist("Workout")]
+client.add_playlist_tracks(workout[0]["item_id"], [track["uri"]])
+client.save_queue_as_playlist(players[0].player_id, "Tonight")
+
+# Browse provider folders, e.g. radio stations by country, language, or tag
+stations = client.browse("radiobrowser://category/tag/jazz", limit=10)
+client.play_media(players[0].player_id, [s["uri"] for s in stations])
 
 # Volume
 client.player_command_volume_set(players[0].player_id, 50)

{ma_http_client-0.1.2 → ma_http_client-0.2.0}/ma_http_client/__init__.py

@@ -1,10 +1,19 @@
-from ma_http_client.client import SimpleHTTPMusicAssistantClient, debug_method
+from ma_http_client.client import (
+    SORT_NAME,
+    SORT_RANDOM,
+    SORT_RANDOM_PLAY_COUNT,
+    SimpleHTTPMusicAssistantClient,
+    debug_method,
+)
 from ma_http_client.debug import DebugMusicAssistantClient
 from ma_http_client.version import __version__
 
 
 __all__ = [
     "__version__",
+    "SORT_NAME",
+    "SORT_RANDOM",
+    "SORT_RANDOM_PLAY_COUNT",
     "SimpleHTTPMusicAssistantClient",
     "DebugMusicAssistantClient",
     "debug_method",

{ma_http_client-0.1.2 → ma_http_client-0.2.0}/ma_http_client/client.py

@@ -5,11 +5,17 @@ import uuid
 from typing import Any, Dict, List, Optional
 
 import requests
-from music_assistant_models.enums import MediaType, QueueOption
+from music_assistant_models.enums import MediaType, QueueOption, RepeatMode
 from music_assistant_models.errors import MusicAssistantError
 from music_assistant_models.player import Player
 
 
+# Server SortField values accepted by library listings (music_assistant_models.enums.SortField)
+SORT_RANDOM = "random"
+SORT_RANDOM_PLAY_COUNT = "random_play_count"
+SORT_NAME = "sort_name"
+
+
 def debug_method(func):
     """Decorator to log method inputs and outputs for debugging purposes."""
 
@@ -116,25 +122,178 @@ class SimpleHTTPMusicAssistantClient:
         """Search for media."""
         return self.send_command("music/recently_played_items")
 
+    def get_item_by_name(
+        self,
+        name: str,
+        artist: Optional[str] = None,
+        album: Optional[str] = None,
+        media_type: Optional[MediaType] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Resolve one media item by name, letting the server do the matching.
+
+        Without ``media_type`` the server tries every type, which suits a bare
+        "play X" request. Returns the item dict or ``None`` when nothing matched.
+        """
+        args: Dict[str, Any] = {"name": name}
+        if artist:
+            args["artist"] = artist
+        if album:
+            args["album"] = album
+        if media_type:
+            args["media_type"] = media_type.value
+        return self.send_command("music/item_by_name", **args)
+
+    def get_track_by_name(
+        self,
+        track_name: str,
+        artist_name: Optional[str] = None,
+        album_name: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Resolve a track by title, with optional artist and album filters.
+
+        The server matches title and version, then artist and album when given,
+        and falls back to a looser album match before giving up. Returns the
+        track dict or ``None``.
+        """
+        args: Dict[str, Any] = {"track_name": track_name}
+        if artist_name:
+            args["artist_name"] = artist_name
+        if album_name:
+            args["album_name"] = album_name
+        return self.send_command("music/track_by_name", **args)
+
+    def library_items(
+        self,
+        media_type: MediaType,
+        search: Optional[str] = None,
+        limit: int = 25,
+        favorite: Optional[bool] = None,
+        sort_field: Optional[str] = None,
+        genre_ids: Optional[List[int]] = None,
+    ) -> List[Dict[str, Any]]:
+        """List library items of one type, with optional search, favorite, sort and genre filters.
+
+        ``sort_field`` takes the server's SortField values; ``SORT_RANDOM`` gives a
+        random sample, which is how "play some music" picks tracks.
+        """
+        args: Dict[str, Any] = {"limit": limit}
+        if search:
+            args["search"] = search
+        if favorite is not None:
+            args["favorite"] = favorite
+        if sort_field:
+            args["sort_field"] = sort_field
+        if genre_ids:
+            args["genre"] = genre_ids
+        return self.send_command(f"music/{media_type.value}s/library_items", **args)
+
+    def search_genres(self, name: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """Find library genres whose name or alias matches ``name`` (server-side, alias aware)."""
+        return self.send_command("music/genres/library_items", search=name, limit=limit)
+
+    def genre_tracks(self, genre_id: str | int, limit: int = 50, sort_field: Optional[str] = None):
+        """List tracks mapped to a library genre."""
+        args: Dict[str, Any] = {"item_id": genre_id, "limit": limit}
+        if sort_field:
+            args["sort_field"] = sort_field
+        return self.send_command("music/genres/tracks", **args)
+
+    def genre_albums(self, genre_id: str | int, limit: int = 50, sort_field: Optional[str] = None):
+        """List albums mapped to a library genre."""
+        args: Dict[str, Any] = {"item_id": genre_id, "limit": limit}
+        if sort_field:
+            args["sort_field"] = sort_field
+        return self.send_command("music/genres/albums", **args)
+
+    # Playlists
+    def library_playlists(self, search: Optional[str] = None, limit: int = 25) -> List[Dict[str, Any]]:
+        """List library playlists, optionally filtered by a name search."""
+        return self.library_items(MediaType.PLAYLIST, search=search, limit=limit)
+
+    def create_playlist(self, name: str, provider: Optional[str] = None) -> Dict[str, Any]:
+        """Create a playlist and return it. ``provider`` defaults to the server's builtin provider."""
+        args: Dict[str, Any] = {"name": name}
+        if provider:
+            args["provider_instance_or_domain"] = provider
+        return self.send_command("music/playlists/create_playlist", **args)
+
+    def playlist_tracks(
+        self, playlist_id: str | int, provider: str = "library", limit: int = 500
+    ) -> List[Dict[str, Any]]:
+        """List the tracks of a playlist in order; positions are the list indexes."""
+        return self.send_command(
+            "music/playlists/playlist_tracks",
+            item_id=str(playlist_id),
+            provider_instance_id_or_domain=provider,
+            limit=limit,
+        )
+
+    def add_playlist_tracks(self, playlist_id: str | int, uris: List[str]):
+        """Append tracks (by uri) to a library playlist."""
+        return self.send_command("music/playlists/add_playlist_tracks", db_playlist_id=playlist_id, uris=uris)
+
+    def remove_playlist_tracks(self, playlist_id: str | int, positions: List[int]):
+        """Remove tracks from a library playlist by their positions (see playlist_tracks)."""
+        return self.send_command(
+            "music/playlists/remove_playlist_tracks", db_playlist_id=playlist_id, positions_to_remove=positions
+        )
+
+    def save_queue_as_playlist(self, queue_id: str, name: str):
+        """Save the current queue of a player as a new library playlist."""
+        return self.send_command("player_queues/save_as_playlist", queue_id=queue_id, name=name)
+
+    # Browse (provider folders, e.g. radio-browser categories)
+    def browse(self, path: Optional[str] = None, limit: int = 100, offset: int = 0) -> List[Dict[str, Any]]:
+        """Browse a provider path; ``None`` lists the top-level provider folders.
+
+        Radio by country, language, or genre tag uses the radio-browser provider's
+        folders, for example ``radiobrowser://category/country/ES``,
+        ``radiobrowser://category/language/spanish``, ``radiobrowser://category/tag/jazz``
+        and ``radiobrowser://popularity/popular``. Folder listings return items with
+        ``media_type`` ``folder``; station listings return ``radio`` items.
+        """
+        args: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if path:
+            args["path"] = path
+        return self.send_command("music/browse", **args)
+
+    def add_favorite(self, uri: str):
+        """Mark the item at ``uri`` as a favorite (adds it to the library if needed)."""
+        return self.send_command("music/favorites/add_item", item=uri)
+
+    def remove_favorite(self, media_type: MediaType, library_item_id: str | int):
+        """Remove a library item from favorites."""
+        return self.send_command(
+            "music/favorites/remove_item", media_type=media_type.value, library_item_id=library_item_id
+        )
+
     def play_media(
         self,
         queue_id: str,
-        media: str,
+        media: str | List[str],
         option: QueueOption = QueueOption.PLAY,  # type: ignore
         radio_mode: bool = False,
+        shuffle: Optional[bool] = None,
     ):
-        """Play media on a player queue."""
+        """Play media on a player queue.
+
+        ``media`` is a uri or a list of uris. ``shuffle`` is only sent when set,
+        so older servers that lack the argument keep working; it applies to the
+        PLAY and REPLACE options.
+        """
         self.log.info(
             f"Sending play_media: queue_id={queue_id}, media={media}, option={option.value}, "
-            f"radio_mode={radio_mode}"
-        )
-        return self.send_command(
-            command="player_queues/play_media",
-            queue_id=queue_id,
-            media=media,
-            option=option.value,
-            radio_mode=radio_mode,
+            f"radio_mode={radio_mode}, shuffle={shuffle}"
         )
+        args: Dict[str, Any] = {
+            "queue_id": queue_id,
+            "media": media,
+            "option": option.value,
+            "radio_mode": radio_mode,
+        }
+        if shuffle is not None:
+            args["shuffle"] = shuffle
+        return self.send_command("player_queues/play_media", **args)
 
     def queue_command_play(self, queue_id: str):
         """Send PLAY command to given queue."""
@@ -152,6 +311,14 @@ class SimpleHTTPMusicAssistantClient:
         """Go to previous track."""
         return self.send_command("player_queues/previous", queue_id=queue_id)
 
+    def queue_set_shuffle(self, queue_id: str, enabled: bool):
+        """Turn shuffle on or off for a queue."""
+        return self.send_command("player_queues/shuffle", queue_id=queue_id, shuffle_enabled=enabled)
+
+    def queue_set_repeat(self, queue_id: str, mode: RepeatMode):
+        """Set the repeat mode (off, one, all) for a queue."""
+        return self.send_command("player_queues/repeat", queue_id=queue_id, repeat_mode=mode.value)
+
     def player_command_power_on(self, player_id: str):
         """Power on a player."""
         return self.send_command("players/player_command_power_on", player_id=player_id)

ma_http_client-0.2.0/ma_http_client/version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{ma_http_client-0.1.2 → ma_http_client-0.2.0}/ma_http_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ma-http-client
-Version: 0.1.2
+Version: 0.2.0
 Summary: A simple HTTP client for the Music Assistant API
 Author-email: Mike Gray/Oscillate Labs <mike@oscillatelabs.net>
 License: Apache-2.0
@@ -50,12 +50,38 @@ players = client.get_players()
 # Search for media
 results = client.search_media("Radiohead", limit=5)
 
-# Play media on a player
+# Resolve one item by name; the server matches across types, or narrow it
+album = client.get_item_by_name("Abbey Road", artist="The Beatles")
+track = client.get_track_by_name("Come Together", artist_name="The Beatles")
+
+# Play media on a player (a uri or a list of uris; shuffle is optional)
 client.play_media(queue_id=players[0].player_id, media="library://artist/204")
+client.play_media(queue_id=players[0].player_id, media=album["uri"], shuffle=True)
 
-# Queue controls
+# Queue controls and modes
 client.queue_command_pause(players[0].player_id)
 client.queue_command_next(players[0].player_id)
+client.queue_set_shuffle(players[0].player_id, True)
+client.queue_set_repeat(players[0].player_id, RepeatMode.ALL)  # from music_assistant_models.enums
+
+# Favorites
+client.add_favorite(track["uri"])
+
+# Library listings and genres ("play some jazz", "play some music")
+from ma_http_client import SORT_RANDOM
+jazz = client.search_genres("jazz")[0]
+tracks = client.genre_tracks(jazz["item_id"], limit=30, sort_field=SORT_RANDOM)
+random_tracks = client.library_items(MediaType.TRACK, limit=20, sort_field=SORT_RANDOM)
+client.play_media(players[0].player_id, [t["uri"] for t in tracks], shuffle=True)
+
+# Playlists
+workout = client.library_playlists(search="workout") or [client.create_playlist("Workout")]
+client.add_playlist_tracks(workout[0]["item_id"], [track["uri"]])
+client.save_queue_as_playlist(players[0].player_id, "Tonight")
+
+# Browse provider folders, e.g. radio stations by country, language, or tag
+stations = client.browse("radiobrowser://category/tag/jazz", limit=10)
+client.play_media(players[0].player_id, [s["uri"] for s in stations])
 
 # Volume
 client.player_command_volume_set(players[0].player_id, 50)

{ma_http_client-0.1.2 → ma_http_client-0.2.0}/ma_http_client.egg-info/SOURCES.txt

@@ -18,4 +18,8 @@ ma_http_client/skills/music-assistant/SKILL.md
 test/test_claude_tools.py
 test/test_cli.py
 test/test_client.py
+test/test_client_browse.py
+test/test_client_catalog.py
+test/test_client_genres.py
+test/test_client_playlists.py
 test/test_debug_client.py

ma_http_client-0.2.0/test/test_client_browse.py

@@ -0,0 +1,52 @@
+"""Tests for the browse method."""
+
+from unittest.mock import Mock
+
+import pytest
+import requests
+
+from ma_http_client import SimpleHTTPMusicAssistantClient
+
+
+@pytest.fixture
+def mock_session():
+    return Mock(spec=requests.Session)
+
+
+@pytest.fixture
+def client(mock_session):
+    return SimpleHTTPMusicAssistantClient(server_url="http://test-server:8095", session=mock_session)
+
+
+def _respond(mock_session, payload):
+    response = Mock()
+    response.status_code = 200
+    response.json.return_value = payload
+    mock_session.post.return_value = response
+
+
+def _sent(mock_session):
+    return mock_session.post.call_args[1]["json"]
+
+
+def test_browse_root_omits_path(client, mock_session):
+    _respond(mock_session, [{"media_type": "folder", "path": "radiobrowser://"}])
+
+    result = client.browse()
+
+    sent = _sent(mock_session)
+    assert sent["command"] == "music/browse"
+    assert sent["args"] == {"limit": 100, "offset": 0}
+    assert result[0]["media_type"] == "folder"
+
+
+def test_browse_radio_country(client, mock_session):
+    _respond(mock_session, [])
+
+    client.browse("radiobrowser://category/country/ES", limit=20, offset=40)
+
+    assert _sent(mock_session)["args"] == {
+        "limit": 20,
+        "offset": 40,
+        "path": "radiobrowser://category/country/ES",
+    }

ma_http_client-0.2.0/test/test_client_catalog.py

@@ -0,0 +1,124 @@
+"""Tests for the by-name lookup, favorites, and queue mode methods."""
+
+from unittest.mock import Mock
+
+import pytest
+import requests
+from music_assistant_models.enums import MediaType, QueueOption, RepeatMode
+
+from ma_http_client import SimpleHTTPMusicAssistantClient
+
+
+@pytest.fixture
+def mock_session():
+    return Mock(spec=requests.Session)
+
+
+@pytest.fixture
+def client(mock_session):
+    return SimpleHTTPMusicAssistantClient(server_url="http://test-server:8095", session=mock_session)
+
+
+def _respond(mock_session, payload):
+    response = Mock()
+    response.status_code = 200
+    response.json.return_value = payload
+    mock_session.post.return_value = response
+
+
+def _sent(mock_session):
+    return mock_session.post.call_args[1]["json"]
+
+
+class TestItemByName:
+    def test_bare_name_sends_only_name(self, client, mock_session):
+        _respond(mock_session, {"name": "Abbey Road", "media_type": "album"})
+
+        result = client.get_item_by_name("Abbey Road")
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/item_by_name"
+        assert sent["args"] == {"name": "Abbey Road"}
+        assert result["name"] == "Abbey Road"
+
+    def test_filters_are_sent_when_given(self, client, mock_session):
+        _respond(mock_session, None)
+
+        result = client.get_item_by_name(
+            "Come Together", artist="The Beatles", album="Abbey Road", media_type=MediaType.TRACK
+        )
+
+        assert _sent(mock_session)["args"] == {
+            "name": "Come Together",
+            "artist": "The Beatles",
+            "album": "Abbey Road",
+            "media_type": "track",
+        }
+        assert result is None
+
+    def test_track_by_name(self, client, mock_session):
+        _respond(mock_session, {"name": "Come Together"})
+
+        client.get_track_by_name("Come Together", artist_name="The Beatles")
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/track_by_name"
+        assert sent["args"] == {"track_name": "Come Together", "artist_name": "The Beatles"}
+
+
+class TestFavorites:
+    def test_add_favorite_sends_uri(self, client, mock_session):
+        _respond(mock_session, None)
+
+        client.add_favorite("library://track/42")
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/favorites/add_item"
+        assert sent["args"] == {"item": "library://track/42"}
+
+    def test_remove_favorite_sends_type_and_id(self, client, mock_session):
+        _respond(mock_session, None)
+
+        client.remove_favorite(MediaType.TRACK, 42)
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/favorites/remove_item"
+        assert sent["args"] == {"media_type": "track", "library_item_id": 42}
+
+
+class TestQueueModes:
+    def test_set_shuffle(self, client, mock_session):
+        _respond(mock_session, None)
+
+        client.queue_set_shuffle("queue-1", True)
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "player_queues/shuffle"
+        assert sent["args"] == {"queue_id": "queue-1", "shuffle_enabled": True}
+
+    def test_set_repeat(self, client, mock_session):
+        _respond(mock_session, None)
+
+        client.queue_set_repeat("queue-1", RepeatMode.ALL)
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "player_queues/repeat"
+        assert sent["args"] == {"queue_id": "queue-1", "repeat_mode": "all"}
+
+    def test_play_media_omits_shuffle_by_default(self, client, mock_session):
+        _respond(mock_session, None)
+
+        client.play_media("queue-1", "library://artist/1")
+
+        args = _sent(mock_session)["args"]
+        assert "shuffle" not in args
+        assert args["option"] == QueueOption.PLAY.value
+
+    def test_play_media_sends_shuffle_and_uri_list(self, client, mock_session):
+        _respond(mock_session, None)
+
+        client.play_media("queue-1", ["library://track/1", "library://track/2"], shuffle=True)
+
+        args = _sent(mock_session)["args"]
+        assert args["media"] == ["library://track/1", "library://track/2"]
+        assert args["shuffle"] is True

ma_http_client-0.2.0/test/test_client_genres.py

@@ -0,0 +1,87 @@
+"""Tests for library listing and genre methods."""
+
+from unittest.mock import Mock
+
+import pytest
+import requests
+from music_assistant_models.enums import MediaType
+
+from ma_http_client import SORT_RANDOM, SimpleHTTPMusicAssistantClient
+
+
+@pytest.fixture
+def mock_session():
+    return Mock(spec=requests.Session)
+
+
+@pytest.fixture
+def client(mock_session):
+    return SimpleHTTPMusicAssistantClient(server_url="http://test-server:8095", session=mock_session)
+
+
+def _respond(mock_session, payload):
+    response = Mock()
+    response.status_code = 200
+    response.json.return_value = payload
+    mock_session.post.return_value = response
+
+
+def _sent(mock_session):
+    return mock_session.post.call_args[1]["json"]
+
+
+class TestLibraryItems:
+    def test_random_tracks(self, client, mock_session):
+        _respond(mock_session, [])
+
+        client.library_items(MediaType.TRACK, limit=20, sort_field=SORT_RANDOM)
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/tracks/library_items"
+        assert sent["args"] == {"limit": 20, "sort_field": "random"}
+
+    def test_favorite_albums_with_search(self, client, mock_session):
+        _respond(mock_session, [])
+
+        client.library_items(MediaType.ALBUM, search="abbey", favorite=True, genre_ids=[3, 4])
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/albums/library_items"
+        assert sent["args"] == {"limit": 25, "search": "abbey", "favorite": True, "genre": [3, 4]}
+
+    def test_favorite_false_is_sent(self, client, mock_session):
+        _respond(mock_session, [])
+
+        client.library_items(MediaType.TRACK, favorite=False)
+
+        assert _sent(mock_session)["args"]["favorite"] is False
+
+
+class TestGenres:
+    def test_search_genres(self, client, mock_session):
+        _respond(mock_session, [{"name": "Jazz", "item_id": "7"}])
+
+        result = client.search_genres("jazz")
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/genres/library_items"
+        assert sent["args"] == {"search": "jazz", "limit": 5}
+        assert result[0]["name"] == "Jazz"
+
+    def test_genre_tracks_random(self, client, mock_session):
+        _respond(mock_session, [])
+
+        client.genre_tracks("7", limit=30, sort_field=SORT_RANDOM)
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/genres/tracks"
+        assert sent["args"] == {"item_id": "7", "limit": 30, "sort_field": "random"}
+
+    def test_genre_albums_default(self, client, mock_session):
+        _respond(mock_session, [])
+
+        client.genre_albums(7)
+
+        sent = _sent(mock_session)
+        assert sent["command"] == "music/genres/albums"
+        assert sent["args"] == {"item_id": 7, "limit": 50}

ma_http_client-0.2.0/test/test_client_playlists.py

@@ -0,0 +1,93 @@
+"""Tests for the playlist methods."""
+
+from unittest.mock import Mock
+
+import pytest
+import requests
+
+from ma_http_client import SimpleHTTPMusicAssistantClient
+
+
+@pytest.fixture
+def mock_session():
+    return Mock(spec=requests.Session)
+
+
+@pytest.fixture
+def client(mock_session):
+    return SimpleHTTPMusicAssistantClient(server_url="http://test-server:8095", session=mock_session)
+
+
+def _respond(mock_session, payload):
+    response = Mock()
+    response.status_code = 200
+    response.json.return_value = payload
+    mock_session.post.return_value = response
+
+
+def _sent(mock_session):
+    return mock_session.post.call_args[1]["json"]
+
+
+def test_library_playlists_search(client, mock_session):
+    _respond(mock_session, [{"name": "Workout"}])
+
+    result = client.library_playlists(search="workout")
+
+    sent = _sent(mock_session)
+    assert sent["command"] == "music/playlists/library_items"
+    assert sent["args"] == {"limit": 25, "search": "workout"}
+    assert result[0]["name"] == "Workout"
+
+
+def test_create_playlist_default_provider(client, mock_session):
+    _respond(mock_session, {"item_id": "12", "name": "Workout"})
+
+    result = client.create_playlist("Workout")
+
+    sent = _sent(mock_session)
+    assert sent["command"] == "music/playlists/create_playlist"
+    assert sent["args"] == {"name": "Workout"}
+    assert result["item_id"] == "12"
+
+
+def test_create_playlist_with_provider(client, mock_session):
+    _respond(mock_session, {})
+
+    client.create_playlist("Workout", provider="spotify")
+
+    assert _sent(mock_session)["args"]["provider_instance_or_domain"] == "spotify"
+
+
+def test_playlist_tracks(client, mock_session):
+    _respond(mock_session, [])
+
+    client.playlist_tracks(12, limit=10)
+
+    sent = _sent(mock_session)
+    assert sent["command"] == "music/playlists/playlist_tracks"
+    assert sent["args"] == {"item_id": "12", "provider_instance_id_or_domain": "library", "limit": 10}
+
+
+def test_add_and_remove_playlist_tracks(client, mock_session):
+    _respond(mock_session, None)
+
+    client.add_playlist_tracks(12, ["library://track/1"])
+    sent = _sent(mock_session)
+    assert sent["command"] == "music/playlists/add_playlist_tracks"
+    assert sent["args"] == {"db_playlist_id": 12, "uris": ["library://track/1"]}
+
+    client.remove_playlist_tracks(12, [0, 3])
+    sent = _sent(mock_session)
+    assert sent["command"] == "music/playlists/remove_playlist_tracks"
+    assert sent["args"] == {"db_playlist_id": 12, "positions_to_remove": [0, 3]}
+
+
+def test_save_queue_as_playlist(client, mock_session):
+    _respond(mock_session, None)
+
+    client.save_queue_as_playlist("queue-1", "Tonight")
+
+    sent = _sent(mock_session)
+    assert sent["command"] == "player_queues/save_as_playlist"
+    assert sent["args"] == {"queue_id": "queue-1", "name": "Tonight"}

ma_http_client-0.1.2/ma_http_client/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.2"