Add YoutubeMusic MusicProvider

.vscode/settings.json

@@ -6,4 +6,9 @@
     "python.linting.flake8Enabled": true,
     "python.linting.flake8Args": ["--config=${workspaceFolder}/setup.cfg"],
     "python.linting.mypyEnabled": false,
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
 }

examples/ytmusic.py

@@ -0,0 +1,159 @@
+"""Example file to play music from YTM. Might omit later"""
+import argparse
+import asyncio
+import logging
+import os
+from os.path import abspath, dirname
+from sys import path
+
+path.insert(1, dirname(dirname(abspath(__file__))))
+
+# pylint: disable=wrong-import-position
+from music_assistant.mass import MusicAssistant
+from music_assistant.models.config import MassConfig, MusicProviderConfig
+from music_assistant.models.enums import ProviderType
+from music_assistant.models.player import Player, PlayerState
+
+parser = argparse.ArgumentParser(description="MusicAssistant")
+parser.add_argument(
+    "--youtubemusic_username",
+    required=False,
+    help="YoutubeMusic username",
+)
+parser.add_argument(
+    "--youtubemusic_cookie",
+    required=False,
+    help="YoutubeMusic cookie",
+)
+args = parser.parse_args()
+
+# setup logger
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)-15s %(levelname)-5s %(name)s -- %(message)s",
+)
+# silence some loggers
+logging.getLogger("aiorun").setLevel(logging.WARNING)
+logging.getLogger("asyncio").setLevel(logging.INFO)
+logging.getLogger("aiosqlite").setLevel(logging.WARNING)
+logging.getLogger("databases").setLevel(logging.WARNING)
+
+
+# default database based on sqlite
+data_dir = os.getenv("APPDATA") if os.name == "nt" else os.path.expanduser("~")
+data_dir = os.path.join(data_dir, ".musicassistant")
+if not os.path.isdir(data_dir):
+    os.makedirs(data_dir)
+db_file = os.path.join(data_dir, "music_assistant.db")
+
+
+mass_conf = MassConfig(
+    database_url=f"sqlite:///{db_file}",
+)
+
+if args.youtubemusic_username and args.youtubemusic_cookie:
+    mass_conf.providers.append(
+        MusicProviderConfig(
+            ProviderType.YTMUSIC,
+            username=args.youtubemusic_username,
+            password=args.youtubemusic_cookie,
+        )
+    )
+
+
+class TestPlayer(Player):
+    """Demonstatration player implementation."""
+
+    def __init__(self, player_id: str):
+        """Init."""
+        self.player_id = player_id
+        self._attr_name = player_id
+        self._attr_powered = True
+        self._attr_elapsed_time = 0
+        self._attr_current_url = ""
+        self._attr_state = PlayerState.IDLE
+        self._attr_available = True
+        self._attr_volume_level = 100
+
+    async def play_url(self, url: str) -> None:
+        """Play the specified url on the player."""
+        print(f"stream url: {url}")
+        self._attr_current_url = url
+        self.update_state()
+
+    async def stop(self) -> None:
+        """Send STOP command to player."""
+        print("stop called")
+        self._attr_state = PlayerState.IDLE
+        self._attr_current_url = None
+        self._attr_elapsed_time = 0
+        self.update_state()
+
+    async def play(self) -> None:
+        """Send PLAY/UNPAUSE command to player."""
+        print("play called")
+        self._attr_state = PlayerState.PLAYING
+        self._attr_elapsed_time = 1
+        self.update_state()
+
+    async def pause(self) -> None:
+        """Send PAUSE command to player."""
+        print("pause called")
+        self._attr_state = PlayerState.PAUSED
+        self.update_state()
+
+    async def power(self, powered: bool) -> None:
+        """Send POWER command to player."""
+        print(f"POWER CALLED - new power: {powered}")
+        self._attr_powered = powered
+        self._attr_current_url = None
+        self.update_state()
+
+    async def volume_set(self, volume_level: int) -> None:
+        """Send volume level (0..100) command to player."""
+        print(f"volume_set called - {volume_level}")
+        self._attr_volume_level = volume_level
+        self.update_state()
+
+
+async def main():
+    """Handle main execution."""
+
+    asyncio.get_event_loop().set_debug(True)
+
+    async with MusicAssistant(mass_conf) as mass:
+        # get some data
+        # ytm = mass.music.get_provider(ProviderType.YTMUSIC)
+        # track = await ytm.get_track("pE3ju1qS848")
+        # album = await ytm.get_album("MPREb_AYetWMZunqA")
+        # await ytm.get_artist_albums("UCFpQsnvFBNlXi7rwQo6IW7g")
+        # albums = await ytm.get_artist_albums("UCFpQsnvFBNlXi7rwQo6IW7g")*")
+        # start sync
+        await mass.music.start_sync(schedule=3)
+        artists = await mass.music.artists.count()
+        print(f"Got {artists} artists in library")
+        albums = await mass.music.albums.count()
+        print(f"Got {albums} albums in library")
+        tracks = await mass.music.tracks.count()
+        print(f"Got {tracks} tracks in library")
+        playlists = await mass.music.playlists.library()
+        print(f"Got {len(playlists)} playlists in library")
+        # artists = await mass.music.artists.count()
+        # print(f"Got {artists} artists in library")
+        # albums = await mass.music.albums.count()
+        # print(f"Got {albums} albums in library")
+        # sd = await yt.get_stream_details(track.item_id)
+        # print(sd.data)
+
+        # test_player1 = TestPlayer("test1")
+        # await mass.players.register_player(test_player1)
+        # await test_player1.active_queue.play_media(track.uri)
+
+        await asyncio.sleep(3600)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass

music_assistant/controllers/music/__init__.py

@@ -35,6 +35,7 @@
 from music_assistant.music_providers.qobuz import QobuzProvider
 from music_assistant.music_providers.spotify import SpotifyProvider
 from music_assistant.music_providers.tunein import TuneInProvider
+from music_assistant.music_providers.ytmusic import YTMusic
 from music_assistant.music_providers.url import PROVIDER_CONFIG as URL_CONFIG
 from music_assistant.music_providers.url import URLProvider
 
@@ -46,6 +47,7 @@
     ProviderType.SPOTIFY: SpotifyProvider,
     ProviderType.QOBUZ: QobuzProvider,
     ProviderType.TUNEIN: TuneInProvider,
+    ProviderType.YTMUSIC: YTMusic,
 }
 
 

music_assistant/controllers/music/artists.py

@@ -176,29 +176,32 @@ async def add_db_item(
         self, item: Artist, overwrite_existing: bool = False
     ) -> Artist:
         """Add a new item record to the database."""
-        assert item.provider_ids, "Album is missing provider id(s)"
-        # always try to grab existing item by musicbrainz_id
-        cur_item = None
-        if item.musicbrainz_id:
-            match = {"musicbrainz_id": item.musicbrainz_id}
-            cur_item = await self.mass.database.get_row(self.db_table, match)
-        if not cur_item:
-            # fallback to exact name match
-            # NOTE: we match an artist by name which could theoretically lead to collisions
-            # but the chance is so small it is not worth the additional overhead of grabbing
-            # the musicbrainz id upfront
-            match = {"sort_name": item.sort_name}
-            for row in await self.mass.database.get_rows(self.db_table, match):
-                row_artist = Artist.from_db_row(row)
-                if row_artist.sort_name == item.sort_name:
-                    # just to be sure ?!
-                    cur_item = row_artist
-                    break
-        if cur_item:
-            # update existing
-            return await self.update_db_item(
-                cur_item.item_id, item, overwrite=overwrite_existing
-            )
+        assert item.provider_ids, "Artist is missing provider id(s)"
+        async with self.mass.database.get_db(db) as db:
+            # always try to grab existing item by musicbrainz_id
+            cur_item = None
+            if item.musicbrainz_id:
+                match = {"musicbrainz_id": item.musicbrainz_id}
+                cur_item = await self.mass.database.get_row(self.db_table, match, db=db)
+            if not cur_item:
+                # fallback to matching
+                # NOTE: we match an artist by name which could theoretically lead to collisions
+                # but the chance is so small it is not worth the additional overhead of grabbing
+                # the musicbrainz id upfront
+                match = {"sort_name": item.sort_name}
+                for row in await self.mass.database.get_rows(
+                    self.db_table, match, db=db
+                ):
+                    row_artist = Artist.from_db_row(row)
+                    if row_artist.sort_name == item.sort_name:
+                        # just to be sure ?!
+                        cur_item = row_artist
+                        break
+            if cur_item:
+                # update existing
+                return await self.update_db_item(
+                    cur_item.item_id, item, overwrite=overwrite_existing, db=db
+                )
 
         # insert item
         if item.in_library and not item.timestamp:

music_assistant/models/enums.py

@@ -68,6 +68,7 @@ class AlbumType(Enum):
     ALBUM = "album"
     SINGLE = "single"
     COMPILATION = "compilation"
+    EP = "ep"
     UNKNOWN = "unknown"
 
 
@@ -209,6 +210,7 @@ class ProviderType(Enum):
     SPOTIFY = "spotify"
     QOBUZ = "qobuz"
     TUNEIN = "tunein"
+    YTMUSIC = "ytmusic"
     DATABASE = "database"  # internal only
     URL = "url"  # internal only