Renamed the auth parameter of Spotify.__init__ to access_token for better clarity.

Removed the `client_credentials_manager` and `oauth_manager` parameters because they are redundant.

Replaced the `set_auth` and `auth_manager` properties with standard attributes.

Removed the following deprecated methods from `Spotify`:
* `playlist_tracks`
* `user_playlist`
* `user_playlist_tracks`
* `user_playlist_change_details`
* `user_playlist_unfollow`
* `user_playlist_add_tracks`
* `user_playlist_replace_tracks`
* `user_playlist_reorder_tracks`
* `user_playlist_remove_all_occurrences_of_tracks`
* `user_playlist_remove_specific_occurrences_of_tracks`
* `user_playlist_follow_playlist`
* `user_playlist_is_following`

Removed the deprecated `as_dict` parameter from the `get_access_token` method of `SpotifyOAuth` and `SpotifyPKCE`.

Removed the deprecated `get_cached_token` and `_save_token_info` methods of `SpotifyOAuth` and `SpotifyPKCE`.

Removed `SpotifyImplicitGrant`.

Removed `prompt_for_user_token`.

tests/integration/non_user_endpoints/test.py

@@ -70,7 +70,8 @@ class AuthTestSpotipy(unittest.TestCase):
     @classmethod
     def setUpClass(self):
         self.spotify = Spotify(
-            client_credentials_manager=SpotifyClientCredentials())
+            auth_manager=SpotifyClientCredentials()
+        )
         self.spotify.trace = False
 
     def test_audio_analysis(self):
@@ -341,9 +342,9 @@ class AuthTestSpotipy(unittest.TestCase):
         self.assertTrue(find_album())
 
     def test_search_timeout(self):
-        client_credentials_manager = SpotifyClientCredentials()
+        auth_manager = SpotifyClientCredentials()
         sp = spotipy.Spotify(requests_timeout=0.01,
-                             client_credentials_manager=client_credentials_manager)
+                             auth_manager=auth_manager)
 
         # depending on the timing or bandwidth, this raises a timeout or connection error
         self.assertRaises((requests.exceptions.Timeout, requests.exceptions.ConnectionError),
@@ -352,17 +353,15 @@ class AuthTestSpotipy(unittest.TestCase):
     @unittest.skip("flaky test, need a better method to test retries")
     def test_max_retries_reached_get(self):
         spotify_no_retry = Spotify(
-            client_credentials_manager=SpotifyClientCredentials(),
+            auth_manager=SpotifyClientCredentials(),
             retries=0)
-        i = 0
-        while i < 100:
+        for i in range(100):
             try:
                 spotify_no_retry.search(q='foo')
             except SpotifyException as e:
                 self.assertIsInstance(e, SpotifyException)
                 self.assertEqual(e.http_status, 429)
                 return
-            i += 1
         self.fail()
 
     def test_album_search(self):
@@ -460,7 +459,7 @@ class AuthTestSpotipy(unittest.TestCase):
         sess = requests.Session()
         sess.headers["user-agent"] = "spotipy-test"
         with_custom_session = spotipy.Spotify(
-            client_credentials_manager=SpotifyClientCredentials(),
+            auth_manager=SpotifyClientCredentials(),
             requests_session=sess)
         self.assertTrue(
             with_custom_session.user(
@@ -469,7 +468,7 @@ class AuthTestSpotipy(unittest.TestCase):
 
     def test_force_no_requests_session(self):
         with_no_session = spotipy.Spotify(
-            client_credentials_manager=SpotifyClientCredentials(),
+            auth_manager=SpotifyClientCredentials(),
             requests_session=False)
         self.assertNotIsInstance(with_no_session._session, requests.Session)
         user = with_no_session.user(user="akx")

tests/integration/user_endpoints/test.py

@@ -2,15 +2,30 @@ import os
 
 from spotipy import (
     CLIENT_CREDS_ENV_VARS as CCEV,
-    prompt_for_user_token,
     Spotify,
     SpotifyException,
-    SpotifyImplicitGrant,
-    SpotifyPKCE
+    SpotifyOAuth,
+    SpotifyPKCE,
+    CacheFileHandler
 )
 import unittest
 from tests import helpers
 
+def _make_spotify(scopes=None, retries=None):
+
+    retries = retries or Spotify.max_retries
+
+    auth_manager = SpotifyOAuth(
+        scope=scopes,
+        cache_handler=CacheFileHandler()
+    )
+
+    spotify = Spotify(
+        auth_manager=auth_manager,
+        retries=retries
+    )
+
+    return spotify
 
 class SpotipyPlaylistApiTest(unittest.TestCase):
     @classmethod
@@ -48,10 +63,10 @@ class SpotipyPlaylistApiTest(unittest.TestCase):
             'user-read-playback-state'
         )
 
-        token = prompt_for_user_token(cls.username, scope=scope)
+        cls.spotify = _make_spotify(scopes=scope)
+        cls.spotify_no_retry = _make_spotify(scopes=scope, retries=0)
+
 
-        cls.spotify = Spotify(auth=token)
-        cls.spotify_no_retry = Spotify(auth=token, retries=0)
         cls.new_playlist_name = 'spotipy-playlist-test'
         cls.new_playlist = helpers.get_spotify_playlist(
             cls.spotify, cls.new_playlist_name, cls.username) or \
@@ -201,17 +216,6 @@ class SpotipyPlaylistApiTest(unittest.TestCase):
             return
         self.fail()
 
-    def test_deprecated_starred(self):
-        pl = self.spotify.user_playlist(self.username)
-        self.assertTrue(pl["tracks"] is None)
-        self.assertTrue(pl["owner"] is None)
-
-    def test_deprecated_user_playlist(self):
-        # Test without user due to change from
-        # https://developer.spotify.com/community/news/2018/06/12/changes-to-playlist-uris/
-        pl = self.spotify.user_playlist(None, self.new_playlist['id'])
-        self.assertEqual(pl["tracks"]["total"], 0)
-
 
 class SpotipyLibraryApiTests(unittest.TestCase):
     @classmethod
@@ -240,10 +244,7 @@ class SpotipyLibraryApiTests(unittest.TestCase):
             'ugc-image-upload '
             'user-read-playback-state'
         )
-
-        token = prompt_for_user_token(cls.username, scope=scope)
-
-        cls.spotify = Spotify(auth=token)
+        cls.spotify = _make_spotify(scopes=scope)
 
     def test_track_bad_id(self):
         with self.assertRaises(SpotifyException):
@@ -330,9 +331,7 @@ class SpotipyUserApiTests(unittest.TestCase):
             'user-read-playback-state'
         )
 
-        token = prompt_for_user_token(cls.username, scope=scope)
-
-        cls.spotify = Spotify(auth=token)
+        cls.spotify = _make_spotify(scopes=scope)
 
     def test_basic_user_profile(self):
         user = self.spotify.user(self.username)
@@ -360,9 +359,7 @@ class SpotipyUserApiTests(unittest.TestCase):
 class SpotipyBrowseApiTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        username = os.getenv(CCEV['client_username'])
-        token = prompt_for_user_token(username)
-        cls.spotify = Spotify(auth=token)
+        cls.spotify = _make_spotify()
 
     def test_category(self):
         rock_cat_id = '0JQ5DAqbMKFDXXwE9BDJAr'
@@ -455,9 +452,7 @@ class SpotipyFollowApiTests(unittest.TestCase):
             'user-read-playback-state'
         )
 
-        token = prompt_for_user_token(cls.username, scope=scope)
-
-        cls.spotify = Spotify(auth=token)
+        cls.spotify = _make_spotify(scopes=scope)
 
     def test_current_user_follows(self):
         response = self.spotify.current_user_followed_artists()
@@ -510,9 +505,7 @@ class SpotipyPlayerApiTests(unittest.TestCase):
             'user-read-playback-state'
         )
 
-        token = prompt_for_user_token(cls.username, scope=scope)
-
-        cls.spotify = Spotify(auth=token)
+        cls.spotify = _make_spotify(scopes=scope)
 
     def test_devices(self):
         # No devices playing by default
@@ -526,23 +519,6 @@ class SpotipyPlayerApiTests(unittest.TestCase):
         # not much more to test if account is inactive and has no recently played tracks
 
 
-class SpotipyImplicitGrantTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        scope = (
-            'user-follow-read '
-            'user-follow-modify '
-        )
-        auth_manager = SpotifyImplicitGrant(scope=scope,
-                                            cache_path=".cache-implicittest")
-        cls.spotify = Spotify(auth_manager=auth_manager)
-
-    def test_current_user(self):
-        c_user = self.spotify.current_user()
-        user = self.spotify.user(c_user['id'])
-        self.assertEqual(c_user['display_name'], user['display_name'])
-
-
 class SpotifyPKCETests(unittest.TestCase):
 
     @classmethod
@@ -551,7 +527,8 @@ class SpotifyPKCETests(unittest.TestCase):
             'user-follow-read '
             'user-follow-modify '
         )
-        auth_manager = SpotifyPKCE(scope=scope, cache_path=".cache-pkcetest")
+        cache_handler = CacheFileHandler(cache_path=".cache-pkcetest")
+        auth_manager = SpotifyPKCE(scope=scope, cache_handler=cache_handler)
         cls.spotify = Spotify(auth_manager=auth_manager)
 
     def test_current_user(self):

tests/unit/test_oauth.py

@@ -5,10 +5,11 @@ import unittest
 import unittest.mock as mock
 import urllib.parse as urllibparse
 
-from spotipy import SpotifyOAuth, SpotifyImplicitGrant, SpotifyPKCE
-from spotipy.cache_handler import MemoryCacheHandler
+from spotipy import SpotifyOAuth, SpotifyPKCE
+from spotipy.cache_handler import CacheHandler
 from spotipy.oauth2 import SpotifyClientCredentials, SpotifyOauthError
 from spotipy.oauth2 import SpotifyStateError
+from spotipy import CacheFileHandler
 
 patch = mock.patch
 DEFAULT = mock.DEFAULT
@@ -38,10 +39,6 @@ def _make_oauth(*args, **kwargs):
     return SpotifyOAuth("CLID", "CLISEC", "REDIR", "STATE", *args, **kwargs)
 
 
-def _make_implicitgrantauth(*args, **kwargs):
-    return SpotifyImplicitGrant("CLID", "REDIR", "STATE", *args, **kwargs)
-
-
 def _make_pkceauth(*args, **kwargs):
     return SpotifyPKCE("CLID", "REDIR", "STATE", *args, **kwargs)
 
@@ -60,13 +57,12 @@ class OAuthCacheTest(unittest.TestCase):
         opener.return_value = _token_file(json.dumps(tok, ensure_ascii=False))
         is_token_expired.return_value = False
 
-        spot = _make_oauth(scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+        spot = _make_oauth(scope, cache_handler=cache_handler)
         cached_tok = spot.validate_token(spot.cache_handler.get_cached_token())
-        cached_tok_legacy = spot.get_cached_token()
 
         opener.assert_called_with(path)
         self.assertIsNotNone(cached_tok)
-        self.assertIsNotNone(cached_tok_legacy)
         self.assertEqual(refresh_access_token.call_count, 0)
 
     @patch.multiple(SpotifyOAuth,
@@ -83,7 +79,8 @@ class OAuthCacheTest(unittest.TestCase):
         opener.return_value = token_file
         refresh_access_token.return_value = fresh_tok
 
-        spot = _make_oauth(scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+        spot = _make_oauth(scope, cache_handler=cache_handler)
         spot.validate_token(spot.cache_handler.get_cached_token())
 
         is_token_expired.assert_called_with(expired_tok)
@@ -103,7 +100,9 @@ class OAuthCacheTest(unittest.TestCase):
         opener.return_value = _token_file(json.dumps(tok, ensure_ascii=False))
         is_token_expired.return_value = False
 
-        spot = _make_oauth(requested_scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+
+        spot = _make_oauth(requested_scope, cache_handler=cache_handler)
         cached_tok = spot.validate_token(spot.cache_handler.get_cached_token())
 
         opener.assert_called_with(path)
@@ -119,27 +118,13 @@ class OAuthCacheTest(unittest.TestCase):
         fi = _fake_file()
         opener.return_value = fi
 
-        spot = SpotifyOAuth("CLID", "CLISEC", "REDIR", "STATE", scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+        spot = SpotifyOAuth("CLID", "CLISEC", "REDIR", "STATE", scope, cache_handler=cache_handler)
         spot.cache_handler.save_token_to_cache(tok)
 
         opener.assert_called_with(path, 'w')
         self.assertTrue(fi.write.called)
 
-    @patch('spotipy.cache_handler.open', create=True)
-    def test_saves_to_cache_path_legacy(self, opener):
-        scope = "playlist-modify-private"
-        path = ".cache-username"
-        tok = _make_fake_token(1, 1, scope)
-
-        fi = _fake_file()
-        opener.return_value = fi
-
-        spot = SpotifyOAuth("CLID", "CLISEC", "REDIR", "STATE", scope, path)
-        spot._save_token_info(tok)
-
-        opener.assert_called_with(path, 'w')
-        self.assertTrue(fi.write.called)
-
     def test_cache_handler(self):
         scope = "playlist-modify-private"
         tok = _make_fake_token(1, 1, scope)
@@ -243,142 +228,6 @@ class TestSpotifyClientCredentials(unittest.TestCase):
             oauth.get_access_token(check_cache=False)
         self.assertEqual(error.exception.error, 'invalid_client')
 
-
-class ImplicitGrantCacheTest(unittest.TestCase):
-
-    @patch.object(SpotifyImplicitGrant, "is_token_expired", DEFAULT)
-    @patch('spotipy.cache_handler.open', create=True)
-    def test_gets_from_cache_path(self, opener, is_token_expired):
-        scope = "playlist-modify-private"
-        path = ".cache-username"
-        tok = _make_fake_token(1, 1, scope)
-
-        opener.return_value = _token_file(json.dumps(tok, ensure_ascii=False))
-        is_token_expired.return_value = False
-
-        spot = _make_implicitgrantauth(scope, path)
-        cached_tok = spot.cache_handler.get_cached_token()
-        cached_tok_legacy = spot.get_cached_token()
-
-        opener.assert_called_with(path)
-        self.assertIsNotNone(cached_tok)
-        self.assertIsNotNone(cached_tok_legacy)
-
-    @patch.object(SpotifyImplicitGrant, "is_token_expired", DEFAULT)
-    @patch('spotipy.cache_handler.open', create=True)
-    def test_expired_token_returns_none(self, opener, is_token_expired):
-        scope = "playlist-modify-private"
-        path = ".cache-username"
-        expired_tok = _make_fake_token(0, None, scope)
-
-        token_file = _token_file(json.dumps(expired_tok, ensure_ascii=False))
-        opener.return_value = token_file
-
-        spot = _make_implicitgrantauth(scope, path)
-        cached_tok = spot.validate_token(spot.cache_handler.get_cached_token())
-
-        is_token_expired.assert_called_with(expired_tok)
-        opener.assert_any_call(path)
-        self.assertIsNone(cached_tok)
-
-    @patch.object(SpotifyImplicitGrant, "is_token_expired", DEFAULT)
-    @patch('spotipy.cache_handler.open', create=True)
-    def test_badly_scoped_token_bails(self, opener, is_token_expired):
-        token_scope = "playlist-modify-public"
-        requested_scope = "playlist-modify-private"
-        path = ".cache-username"
-        tok = _make_fake_token(1, 1, token_scope)
-
-        opener.return_value = _token_file(json.dumps(tok, ensure_ascii=False))
-        is_token_expired.return_value = False
-
-        spot = _make_implicitgrantauth(requested_scope, path)
-        cached_tok = spot.validate_token(spot.cache_handler.get_cached_token())
-
-        opener.assert_called_with(path)
-        self.assertIsNone(cached_tok)
-
-    @patch('spotipy.cache_handler.open', create=True)
-    def test_saves_to_cache_path(self, opener):
-        scope = "playlist-modify-private"
-        path = ".cache-username"
-        tok = _make_fake_token(1, 1, scope)
-
-        fi = _fake_file()
-        opener.return_value = fi
-
-        spot = SpotifyImplicitGrant("CLID", "REDIR", "STATE", scope, path)
-        spot.cache_handler.save_token_to_cache(tok)
-
-        opener.assert_called_with(path, 'w')
-        self.assertTrue(fi.write.called)
-
-    @patch('spotipy.cache_handler.open', create=True)
-    def test_saves_to_cache_path_legacy(self, opener):
-        scope = "playlist-modify-private"
-        path = ".cache-username"
-        tok = _make_fake_token(1, 1, scope)
-
-        fi = _fake_file()
-        opener.return_value = fi
-
-        spot = SpotifyImplicitGrant("CLID", "REDIR", "STATE", scope, path)
-        spot._save_token_info(tok)
-
-        opener.assert_called_with(path, 'w')
-        self.assertTrue(fi.write.called)
-
-
-class TestSpotifyImplicitGrant(unittest.TestCase):
-
-    def test_get_authorize_url_doesnt_pass_state_by_default(self):
-        auth = SpotifyImplicitGrant("CLID", "REDIR")
-
-        url = auth.get_authorize_url()
-
-        parsed_url = urllibparse.urlparse(url)
-        parsed_qs = urllibparse.parse_qs(parsed_url.query)
-        self.assertNotIn('state', parsed_qs)
-
-    def test_get_authorize_url_passes_state_from_constructor(self):
-        state = "STATE"
-        auth = SpotifyImplicitGrant("CLID", "REDIR", state)
-
-        url = auth.get_authorize_url()
-
-        parsed_url = urllibparse.urlparse(url)
-        parsed_qs = urllibparse.parse_qs(parsed_url.query)
-        self.assertEqual(parsed_qs['state'][0], state)
-
-    def test_get_authorize_url_passes_state_from_func_call(self):
-        state = "STATE"
-        auth = SpotifyImplicitGrant("CLID", "REDIR", "NOT STATE")
-
-        url = auth.get_authorize_url(state=state)
-
-        parsed_url = urllibparse.urlparse(url)
-        parsed_qs = urllibparse.parse_qs(parsed_url.query)
-        self.assertEqual(parsed_qs['state'][0], state)
-
-    def test_get_authorize_url_does_not_show_dialog_by_default(self):
-        auth = SpotifyImplicitGrant("CLID", "REDIR")
-
-        url = auth.get_authorize_url()
-
-        parsed_url = urllibparse.urlparse(url)
-        parsed_qs = urllibparse.parse_qs(parsed_url.query)
-        self.assertNotIn('show_dialog', parsed_qs)
-
-    def test_get_authorize_url_shows_dialog_when_requested(self):
-        auth = SpotifyImplicitGrant("CLID", "REDIR", show_dialog=True)
-
-        url = auth.get_authorize_url()
-
-        parsed_url = urllibparse.urlparse(url)
-        parsed_qs = urllibparse.parse_qs(parsed_url.query)
-        self.assertTrue(parsed_qs['show_dialog'])
-
-
 class SpotifyPKCECacheTest(unittest.TestCase):
 
     @patch.multiple(SpotifyPKCE,
@@ -393,13 +242,12 @@ class SpotifyPKCECacheTest(unittest.TestCase):
         opener.return_value = _token_file(json.dumps(tok, ensure_ascii=False))
         is_token_expired.return_value = False
 
-        spot = _make_pkceauth(scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+        spot = _make_pkceauth(scope, cache_handler=cache_handler)
         cached_tok = spot.cache_handler.get_cached_token()
-        cached_tok_legacy = spot.get_cached_token()
 
         opener.assert_called_with(path)
         self.assertIsNotNone(cached_tok)
-        self.assertIsNotNone(cached_tok_legacy)
         self.assertEqual(refresh_access_token.call_count, 0)
 
     @patch.multiple(SpotifyPKCE,
@@ -416,7 +264,8 @@ class SpotifyPKCECacheTest(unittest.TestCase):
         opener.return_value = token_file
         refresh_access_token.return_value = fresh_tok
 
-        spot = _make_pkceauth(scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+        spot = _make_pkceauth(scope, cache_handler=cache_handler)
         spot.validate_token(spot.cache_handler.get_cached_token())
 
         is_token_expired.assert_called_with(expired_tok)
@@ -436,7 +285,8 @@ class SpotifyPKCECacheTest(unittest.TestCase):
         opener.return_value = _token_file(json.dumps(tok, ensure_ascii=False))
         is_token_expired.return_value = False
 
-        spot = _make_pkceauth(requested_scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+        spot = _make_pkceauth(requested_scope, cache_handler=cache_handler)
         cached_tok = spot.validate_token(spot.cache_handler.get_cached_token())
 
         opener.assert_called_with(path)
@@ -452,27 +302,13 @@ class SpotifyPKCECacheTest(unittest.TestCase):
         fi = _fake_file()
         opener.return_value = fi
 
-        spot = SpotifyPKCE("CLID", "REDIR", "STATE", scope, path)
+        cache_handler = CacheFileHandler(cache_path=path)
+        spot = SpotifyPKCE("CLID", "REDIR", "STATE", scope, cache_handler=cache_handler)
         spot.cache_handler.save_token_to_cache(tok)
 
         opener.assert_called_with(path, 'w')
         self.assertTrue(fi.write.called)
 
-    @patch('spotipy.cache_handler.open', create=True)
-    def test_saves_to_cache_path_legacy(self, opener):
-        scope = "playlist-modify-private"
-        path = ".cache-username"
-        tok = _make_fake_token(1, 1, scope)
-
-        fi = _fake_file()
-        opener.return_value = fi
-
-        spot = SpotifyPKCE("CLID", "REDIR", "STATE", scope, path)
-        spot._save_token_info(tok)
-
-        opener.assert_called_with(path, 'w')
-        self.assertTrue(fi.write.called)
-
 
 class TestSpotifyPKCE(unittest.TestCase):
 

tests/unit/test_scopes.py

@@ -88,3 +88,28 @@ class SpotipyScopeTest(TestCase):
         self.assertEqual(normalized_scope_string_2, "")
 
         self.assertIsNone(self.normalize_scope(None))
+
+    def test_all_scopes(self):
+        expected_scopes = {
+            Scope.user_read_currently_playing,
+            Scope.playlist_read_collaborative,
+            Scope.playlist_modify_private,
+            Scope.user_read_playback_position,
+            Scope.user_library_modify,
+            Scope.user_top_read,
+            Scope.user_read_playback_state,
+            Scope.user_read_email,
+            Scope.ugc_image_upload,
+            Scope.user_read_private,
+            Scope.playlist_modify_public,
+            Scope.user_library_read,
+            Scope.streaming,
+            Scope.user_read_recently_played,
+            Scope.user_follow_read,
+            Scope.user_follow_modify,
+            Scope.app_remote_control,
+            Scope.playlist_read_private,
+            Scope.user_modify_playback_state,
+        }
+
+        self.assertEqual(expected_scopes, Scope.all())