Update tidalapi dependency version to 0.8.8 (#136)

Fixes #135 #134

example_config.yml

@@ -2,7 +2,8 @@ spotify:
   client_id: your_client_id
   client_secret: your_client_secret
   username: your_spotify_username
-  redirect_uri: http://localhost:8888/callback
+  redirect_uri: http://127.0.0.1:8888/callback
+  open_browser: True # Set to False if using a headless server environment
 
 
 # uncomment this block if you want to only sync specific playlist IDs

pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotify_to_tidal"
-version = "1.0.1"
+version = "1.0.4"
 requires-python = ">= 3.10"
 
 dependencies = [
   "spotipy~=2.24.0",
-  "tidalapi==0.7.6",
+  "tidalapi==0.8.8",
   "pyyaml~=6.0",
   "tqdm~=4.64",
   "sqlalchemy~=2.0",

readme.md

@@ -19,6 +19,7 @@ Setup
 Usage
 ----
 To synchronize all of your Spotify playlists with your Tidal account run the following from the project root directory
+Windows ignores python module paths by default, but you can run them using `python3 -m spotify_to_tidal`
 
 ```bash
 spotify_to_tidal

src/spotify_to_tidal/auth.py

@@ -15,11 +15,12 @@ SPOTIFY_SCOPES = 'playlist-read-private, user-library-read'
 
 def open_spotify_session(config) -> spotipy.Spotify:
     credentials_manager = spotipy.SpotifyOAuth(username=config['username'],
-				       scope=SPOTIFY_SCOPES,
-				       client_id=config['client_id'],
-				       client_secret=config['client_secret'],
-				       redirect_uri=config['redirect_uri'],
-				       requests_timeout=2)
+       scope=SPOTIFY_SCOPES,
+       client_id=config['client_id'],
+       client_secret=config['client_secret'],
+       redirect_uri=config['redirect_uri'],
+       requests_timeout=2,
+       open_browser=config.get('open_browser', True))
     try:
         credentials_manager.get_access_token(as_dict=False)
     except spotipy.SpotifyOauthError:

src/spotify_to_tidal/sync.py

@@ -178,12 +178,18 @@ async def _fetch_all_from_spotify_in_chunks(fetch_function: Callable) -> List[di
 
 async def get_tracks_from_spotify_playlist(spotify_session: spotipy.Spotify, spotify_playlist):
     def _get_tracks_from_spotify_playlist(offset: int, playlist_id: str):
-        fields = "next,total,limit,items(track(name,album(name,artists),artists,track_number,duration_ms,id,external_ids(isrc)))"
+        fields = "next,total,limit,items(track(name,album(name,artists),artists,track_number,duration_ms,id,external_ids(isrc))),type"
         return spotify_session.playlist_tracks(playlist_id=playlist_id, fields=fields, offset=offset)
 
     print(f"Loading tracks from Spotify playlist '{spotify_playlist['name']}'")
-    return await repeat_on_request_error( _fetch_all_from_spotify_in_chunks, lambda offset: _get_tracks_from_spotify_playlist(offset=offset, playlist_id=spotify_playlist["id"]))
-
+    items = await repeat_on_request_error( _fetch_all_from_spotify_in_chunks, lambda offset: _get_tracks_from_spotify_playlist(offset=offset, playlist_id=spotify_playlist["id"]))
+    track_filter = lambda item: item.get('type', 'track') == 'track' # type may be 'episode' also
+    sanity_filter = lambda item: ('album' in item
+                                  and 'name' in item['album']
+                                  and 'artists' in item['album']
+                                  and len(item['album']['artists']) > 0
+                                  and item['album']['artists'][0]['name'] is not None)
+    return list(filter(sanity_filter, filter(track_filter, items)))
 
 def populate_track_match_cache(spotify_tracks_: Sequence[t_spotify.SpotifyTrack], tidal_tracks_: Sequence[tidalapi.Track]):
     """ Populate the track match cache with all the existing tracks in Tidal playlist corresponding to Spotify playlist """
@@ -282,14 +288,18 @@ async def search_new_tracks_on_tidal(tidal_session: tidalapi.Session, spotify_tr
             
 async def sync_playlist(spotify_session: spotipy.Spotify, tidal_session: tidalapi.Session, spotify_playlist, tidal_playlist: tidalapi.Playlist | None, config: dict):
     """ sync given playlist to tidal """
-    # Create a new Tidal playlist if required
-    if not tidal_playlist:
+    # Get the tracks from both Spotify and Tidal, creating a new Tidal playlist if necessary
+    spotify_tracks = await get_tracks_from_spotify_playlist(spotify_session, spotify_playlist)
+    if len(spotify_tracks) == 0:
+        return # nothing to do
+    if tidal_playlist:
+        old_tidal_tracks = await get_all_playlist_tracks(tidal_playlist)
+    else:
         print(f"No playlist found on Tidal corresponding to Spotify playlist: '{spotify_playlist['name']}', creating new playlist")
         tidal_playlist =  tidal_session.user.create_playlist(spotify_playlist['name'], spotify_playlist['description'])
+        old_tidal_tracks = []
 
     # Extract the new tracks from the playlist that we haven't already seen before
-    spotify_tracks = await get_tracks_from_spotify_playlist(spotify_session, spotify_playlist)
-    old_tidal_tracks = await get_all_playlist_tracks(tidal_playlist)
     populate_track_match_cache(spotify_tracks, old_tidal_tracks)
     await search_new_tracks_on_tidal(tidal_session, spotify_tracks, spotify_playlist['name'], config)
     new_tidal_track_ids = get_tracks_for_new_tidal_playlist(spotify_tracks)
@@ -381,7 +391,7 @@ async def get_playlists_from_spotify(spotify_session: spotipy.Spotify, config):
             playlists.extend([p for p in extra_result['items']])
 
     # filter out playlists that don't belong to us or are on the exclude list
-    my_playlist_filter = lambda p: p['owner']['id'] == user_id
+    my_playlist_filter = lambda p: p and p['owner']['id'] == user_id
     exclude_filter = lambda p: not p['id'] in exclude_list
     return list(filter( exclude_filter, filter( my_playlist_filter, playlists )))
 

tests/unit/test_auth.py

@@ -23,7 +23,8 @@ def test_open_spotify_session(mocker):
         "username": "test_user",
         "client_id": "test_client_id",
         "client_secret": "test_client_secret",
-        "redirect_uri": "http://localhost/",
+        "redirect_uri": "http://127.0.0.1/",
+        "open_browser": True,
     }
 
     # Create a mock SpotifyOAuth instance
@@ -39,8 +40,9 @@ def test_open_spotify_session(mocker):
         scope=SPOTIFY_SCOPES,
         client_id="test_client_id",
         client_secret="test_client_secret",
-        redirect_uri="http://localhost/",
+        redirect_uri="http://127.0.0.1/",
         requests_timeout=2,
+        open_browser=True,
     )
 
     # Assert that the Spotify instance was created
@@ -62,7 +64,7 @@ def test_open_spotify_session_oauth_error(mocker):
         "username": "test_user",
         "client_id": "test_client_id",
         "client_secret": "test_client_secret",
-        "redirect_uri": "http://localhost/",
+        "redirect_uri": "http://127.0.0.1/",
     }
 
     # Mock sys.exit to prevent the test from exiting