5 files changed, 397 insertions, 316 deletions

diff --git a/tests/test_pandora/test_client.py b/tests/test_pandora/test_client.py
index 8144f42..1c5a229 100644
--- a/tests/test_pandora/test_client.py
+++ b/tests/test_pandora/test_client.py
@@ -13,7 +13,6 @@ from tests.test_pandora.test_models import TestAdItem
 
 
 class TestAPIClientLogin(TestCase):
-
     class StubTransport:
 
         API_VERSION = None
@@ -56,7 +55,6 @@ class TestAPIClientLogin(TestCase):
 
 
 class TestCallingAPIClient(TestCase):
-
     def test_call_should_retry_on_token_error(self):
         transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
 
@@ -70,37 +68,44 @@ class TestCallingAPIClient(TestCase):
         transport.assert_has_calls([call("method"), call("method")])
 
     def test_playlist_fetches_ads(self):
-        fake_playlist = {"items": [
-            {"songName": "test"},
-            {"adToken": "foo"},
-            {"songName": "test"},
-        ]}
-        with patch.object(APIClient, '__call__', return_value=fake_playlist):
+        fake_playlist = {
+            "items": [
+                {"songName": "test"},
+                {"adToken": "foo"},
+                {"songName": "test"},
+            ]
+        }
+        with patch.object(APIClient, "__call__", return_value=fake_playlist):
             client = APIClient(Mock(), None, None, None, None)
             client._authenticate = Mock()
 
-            items = client.get_playlist('token_mock')
+            items = client.get_playlist("token_mock")
             self.assertIsInstance(items[1], AdItem)
 
     def test_ad_support_enabled_parameters(self):
-        with patch.object(APIClient, '__call__') as playlist_mock:
+        with patch.object(APIClient, "__call__") as playlist_mock:
             transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
 
             client = APIClient(transport, None, None, None, None)
             client._authenticate = Mock()
 
-            client.get_playlist('token_mock')
+            client.get_playlist("token_mock")
 
-            playlist_mock.assert_has_calls([call("station.getPlaylist",
-                                                 additionalAudioUrl='',
-                                                 audioAdPodCapable=True,
-                                                 includeTrackLength=True,
-                                                 stationToken='token_mock',
-                                                 xplatformAdCapable=True)])
+            playlist_mock.assert_has_calls(
+                [
+                    call(
+                        "station.getPlaylist",
+                        additionalAudioUrl="",
+                        audioAdPodCapable=True,
+                        includeTrackLength=True,
+                        stationToken="token_mock",
+                        xplatformAdCapable=True,
+                    )
+                ]
+            )
 
 
 class TestGettingQualities(TestCase):
-
     def test_with_invalid_quality_returning_all(self):
         result = BaseAPIClient.get_qualities("foo", True)
         self.assertEqual(BaseAPIClient.ALL_QUALITIES, result)
@@ -111,20 +116,22 @@ class TestGettingQualities(TestCase):
 
     def test_with_valid_quality(self):
         result = BaseAPIClient.get_qualities(
-                BaseAPIClient.MED_AUDIO_QUALITY, False)
+            BaseAPIClient.MED_AUDIO_QUALITY, False
+        )
 
         expected = [
-                BaseAPIClient.LOW_AUDIO_QUALITY,
-                BaseAPIClient.MED_AUDIO_QUALITY]
+            BaseAPIClient.LOW_AUDIO_QUALITY,
+            BaseAPIClient.MED_AUDIO_QUALITY,
+        ]
 
         self.assertEqual(expected, result)
 
 
 class TestGettingAds(TestCase):
-
     def test_get_ad_item_(self):
         metamock = patch.object(
-            APIClient, '__call__', return_value=TestAdItem.JSON_DATA)
+            APIClient, "__call__", return_value=TestAdItem.JSON_DATA
+        )
 
         with metamock as ad_metadata_mock:
             transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
@@ -132,13 +139,20 @@ class TestGettingAds(TestCase):
             client = APIClient(transport, None, None, None, None)
             client._authenticate = Mock()
 
-            ad_item = client.get_ad_item('id_mock', 'token_mock')
-            assert ad_item.station_id == 'id_mock'
-            assert ad_item.ad_token == 'token_mock'
-
-            ad_metadata_mock.assert_has_calls([
-                call("ad.getAdMetadata", adToken='token_mock',
-                     returnAdTrackingTokens=True, supportAudioAds=True)])
+            ad_item = client.get_ad_item("id_mock", "token_mock")
+            assert ad_item.station_id == "id_mock"
+            assert ad_item.ad_token == "token_mock"
+
+            ad_metadata_mock.assert_has_calls(
+                [
+                    call(
+                        "ad.getAdMetadata",
+                        adToken="token_mock",
+                        returnAdTrackingTokens=True,
+                        supportAudioAds=True,
+                    )
+                ]
+            )
 
     def test_get_ad_item_with_no_station_id_specified_raises_exception(self):
         transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
@@ -147,28 +161,31 @@ class TestGettingAds(TestCase):
         client.get_ad_metadata = Mock()
 
         self.assertRaises(
-                errors.ParameterMissing, client.get_ad_item, '', 'token_mock')
+            errors.ParameterMissing, client.get_ad_item, "", "token_mock"
+        )
 
 
 class TestCreatingStation(TestCase):
-
     def test_using_search_token(self):
         client = APIClient(Mock(return_value={}), None, None, None, None)
         client.create_station(search_token="foo")
         client.transport.assert_called_with(
-            "station.createStation", musicToken="foo")
+            "station.createStation", musicToken="foo"
+        )
 
     def test_using_artist_token(self):
         client = APIClient(Mock(return_value={}), None, None, None, None)
         client.create_station(artist_token="foo")
         client.transport.assert_called_with(
-            "station.createStation", trackToken="foo", musicType="artist")
+            "station.createStation", trackToken="foo", musicType="artist"
+        )
 
     def test_using_track_token(self):
         client = APIClient(Mock(return_value={}), None, None, None, None)
         client.create_station(track_token="foo")
         client.transport.assert_called_with(
-            "station.createStation", trackToken="foo", musicType="song")
+            "station.createStation", trackToken="foo", musicType="song"
+        )
 
     def test_with_no_token(self):
         with self.assertRaises(KeyError):
@@ -177,25 +194,20 @@ class TestCreatingStation(TestCase):
 
 
 class TestCreatingGenreStation(TestCase):
-
     def test_has_initial_checksum(self):
         fake_data = {
-            "categories": [
-                {"categoryName": "foo", "stations": []},
-            ],
-
+            "categories": [{"categoryName": "foo", "stations": []},],
             # Not actually part of the genre station response but is needed to
             # fake out the mock for get_genre_stations_checksum
-            "checksum": "foo"
+            "checksum": "foo",
         }
-        with patch.object(APIClient, '__call__', return_value=fake_data):
+        with patch.object(APIClient, "__call__", return_value=fake_data):
             client = APIClient(Mock(), None, None, None, None)
             station = client.get_genre_stations()
             self.assertEqual(station.checksum, "foo")
 
 
 class TestAdditionalUrls(TestCase):
-
     def test_non_iterable_string(self):
         with self.assertRaises(TypeError):
             transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
@@ -203,7 +215,7 @@ class TestAdditionalUrls(TestCase):
             client = APIClient(transport, None, None, None, None)
             client._authenticate = Mock()
 
-            client.get_playlist('token_mock', additional_urls='')
+            client.get_playlist("token_mock", additional_urls="")
 
     def test_non_iterable_other(self):
         with self.assertRaises(TypeError):
@@ -212,50 +224,64 @@ class TestAdditionalUrls(TestCase):
             client = APIClient(transport, None, None, None, None)
             client._authenticate = Mock()
 
-            client.get_playlist('token_mock',
-                                additional_urls=AdditionalAudioUrl.HTTP_32_WMA)
+            client.get_playlist(
+                "token_mock", additional_urls=AdditionalAudioUrl.HTTP_32_WMA
+            )
 
     def test_without_enum(self):
-        with patch.object(APIClient, '__call__') as playlist_mock:
+        with patch.object(APIClient, "__call__") as playlist_mock:
             transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
 
             client = APIClient(transport, None, None, None, None)
             client._authenticate = Mock()
 
-            urls = ['HTTP_128_MP3',
-                    'HTTP_24_AACPLUS_ADTS']
+            urls = ["HTTP_128_MP3", "HTTP_24_AACPLUS_ADTS"]
 
-            desired = 'HTTP_128_MP3,HTTP_24_AACPLUS_ADTS'
+            desired = "HTTP_128_MP3,HTTP_24_AACPLUS_ADTS"
 
-            client.get_playlist('token_mock', additional_urls=urls)
+            client.get_playlist("token_mock", additional_urls=urls)
 
-            playlist_mock.assert_has_calls([call("station.getPlaylist",
-                                                 additionalAudioUrl=desired,
-                                                 audioAdPodCapable=True,
-                                                 includeTrackLength=True,
-                                                 stationToken='token_mock',
-                                                 xplatformAdCapable=True)])
+            playlist_mock.assert_has_calls(
+                [
+                    call(
+                        "station.getPlaylist",
+                        additionalAudioUrl=desired,
+                        audioAdPodCapable=True,
+                        includeTrackLength=True,
+                        stationToken="token_mock",
+                        xplatformAdCapable=True,
+                    )
+                ]
+            )
 
     def test_with_enum(self):
-        with patch.object(APIClient, '__call__') as playlist_mock:
+        with patch.object(APIClient, "__call__") as playlist_mock:
             transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
 
             client = APIClient(transport, None, None, None, None)
             client._authenticate = Mock()
 
-            urls = [AdditionalAudioUrl.HTTP_128_MP3,
-                    AdditionalAudioUrl.HTTP_24_AACPLUS_ADTS]
+            urls = [
+                AdditionalAudioUrl.HTTP_128_MP3,
+                AdditionalAudioUrl.HTTP_24_AACPLUS_ADTS,
+            ]
 
-            desired = 'HTTP_128_MP3,HTTP_24_AACPLUS_ADTS'
+            desired = "HTTP_128_MP3,HTTP_24_AACPLUS_ADTS"
 
-            client.get_playlist('token_mock', additional_urls=urls)
+            client.get_playlist("token_mock", additional_urls=urls)
 
-            playlist_mock.assert_has_calls([call("station.getPlaylist",
-                                                 additionalAudioUrl=desired,
-                                                 audioAdPodCapable=True,
-                                                 includeTrackLength=True,
-                                                 stationToken='token_mock',
-                                                 xplatformAdCapable=True)])
+            playlist_mock.assert_has_calls(
+                [
+                    call(
+                        "station.getPlaylist",
+                        additionalAudioUrl=desired,
+                        audioAdPodCapable=True,
+                        includeTrackLength=True,
+                        stationToken="token_mock",
+                        xplatformAdCapable=True,
+                    )
+                ]
+            )
 
 
 # On the surface this test class seems dumb because it's mostly just exercising
@@ -263,7 +289,6 @@ class TestAdditionalUrls(TestCase):
 # introduced to API client methods that will only be spotted at runtime (import
 # errors, etc...)
 class TestAPIClientExhaustive(TestCase):
-
     def setUp(self):
         self.transport = Mock()
         self.api = APIClient(self.transport, "puser", "ppass", "device")
@@ -271,23 +296,29 @@ class TestAPIClientExhaustive(TestCase):
     def test_register_ad(self):
         self.api.register_ad("sid", "tokens")
         self.transport.assert_called_with(
-            "ad.registerAd", stationId="sid", adTrackingTokens="tokens")
+            "ad.registerAd", stationId="sid", adTrackingTokens="tokens"
+        )
 
     def test_share_music(self):
         self.api.share_music("token", "foo@example.com")
         self.transport.assert_called_with(
-            "music.shareMusic", musicToken="token", email="foo@example.com")
+            "music.shareMusic", musicToken="token", email="foo@example.com"
+        )
 
     def test_transform_shared_station(self):
         self.api.transform_shared_station("token")
         self.transport.assert_called_with(
-            "station.transformSharedStation", stationToken="token")
+            "station.transformSharedStation", stationToken="token"
+        )
 
     def test_share_station(self):
         self.api.share_station("sid", "token", "foo@example.com")
         self.transport.assert_called_with(
-            "station.shareStation", stationId="sid", stationToken="token",
-            emails=("foo@example.com",))
+            "station.shareStation",
+            stationId="sid",
+            stationToken="token",
+            emails=("foo@example.com",),
+        )
 
     def test_sleep_song(self):
         self.api.sleep_song("token")
@@ -296,22 +327,26 @@ class TestAPIClientExhaustive(TestCase):
     def test_set_quick_mix(self):
         self.api.set_quick_mix("id")
         self.transport.assert_called_with(
-            "user.setQuickMix", quickMixStationIds=("id",))
+            "user.setQuickMix", quickMixStationIds=("id",)
+        )
 
     def test_explain_track(self):
         self.api.explain_track("token")
         self.transport.assert_called_with(
-            "track.explainTrack", trackToken="token")
+            "track.explainTrack", trackToken="token"
+        )
 
     def test_rename_station(self):
         self.api.rename_station("token", "name")
         self.transport.assert_called_with(
-            "station.renameStation", stationToken="token", stationName="name")
+            "station.renameStation", stationToken="token", stationName="name"
+        )
 
     def test_delete_station(self):
         self.api.delete_station("token")
         self.transport.assert_called_with(
-            "station.deleteStation", stationToken="token")
+            "station.deleteStation", stationToken="token"
+        )
 
     def test_delete_music(self):
         self.api.delete_music("seed")
@@ -320,37 +355,44 @@ class TestAPIClientExhaustive(TestCase):
     def test_delete_feedback(self):
         self.api.delete_feedback("id")
         self.transport.assert_called_with(
-            "station.deleteFeedback", feedbackId="id")
+            "station.deleteFeedback", feedbackId="id"
+        )
 
     def test_add_music(self):
         self.api.add_music("mt", "st")
         self.transport.assert_called_with(
-            "station.addMusic", musicToken="mt", stationToken="st")
+            "station.addMusic", musicToken="mt", stationToken="st"
+        )
 
     def test_add_feedback(self):
         self.api.add_feedback("token", False)
         self.transport.assert_called_with(
-            "station.addFeedback", trackToken="token", isPositive=False)
+            "station.addFeedback", trackToken="token", isPositive=False
+        )
 
     def test_add_artist_bookmark(self):
         self.api.add_artist_bookmark("tt")
         self.transport.assert_called_with(
-            "bookmark.addArtistBookmark", trackToken="tt")
+            "bookmark.addArtistBookmark", trackToken="tt"
+        )
 
     def test_add_song_bookmark(self):
         self.api.add_song_bookmark("tt")
         self.transport.assert_called_with(
-            "bookmark.addSongBookmark", trackToken="tt")
+            "bookmark.addSongBookmark", trackToken="tt"
+        )
 
     def test_delete_song_bookmark(self):
         self.api.delete_song_bookmark("bt")
         self.transport.assert_called_with(
-            "bookmark.deleteSongBookmark", bookmarkToken="bt")
+            "bookmark.deleteSongBookmark", bookmarkToken="bt"
+        )
 
     def test_delete_artist_bookmark(self):
         self.api.delete_artist_bookmark("bt")
         self.transport.assert_called_with(
-            "bookmark.deleteArtistBookmark", bookmarkToken="bt")
+            "bookmark.deleteArtistBookmark", bookmarkToken="bt"
+        )
 
     def test_get_station_list_checksum(self):
         self.transport.return_value = {"checksum": "foo"}
@@ -364,7 +406,8 @@ class TestAPIClientExhaustive(TestCase):
         self.transport.return_value = {"stations": []}
         self.assertIsInstance(self.api.get_station_list(), StationList)
         self.transport.assert_called_with(
-            "user.getStationList", includeStationArtUrl=True)
+            "user.getStationList", includeStationArtUrl=True
+        )
 
     def test_get_bookmarks(self):
         self.transport.return_value = {}
@@ -375,14 +418,22 @@ class TestAPIClientExhaustive(TestCase):
         self.transport.return_value = {}
         self.assertIsInstance(self.api.get_station("st"), Station)
         self.transport.assert_called_with(
-            "station.getStation", stationToken="st",
-            includeExtendedAttributes=True)
+            "station.getStation",
+            stationToken="st",
+            includeExtendedAttributes=True,
+        )
 
     def test_search(self):
         self.transport.return_value = {}
-        self.assertIsInstance(self.api.search(
-            "text", include_near_matches=True, include_genre_stations=True),
-            SearchResult)
+        self.assertIsInstance(
+            self.api.search(
+                "text", include_near_matches=True, include_genre_stations=True
+            ),
+            SearchResult,
+        )
         self.transport.assert_called_with(
-            "music.search", searchText="text", includeNearMatches=True,
-            includeGenreStations=True)
+            "music.search",
+            searchText="text",
+            includeNearMatches=True,
+            includeGenreStations=True,
+        )
diff --git a/tests/test_pandora/test_clientbuilder.py b/tests/test_pandora/test_clientbuilder.py
index af0e219..17a4036 100644
--- a/tests/test_pandora/test_clientbuilder.py
+++ b/tests/test_pandora/test_clientbuilder.py
@@ -8,7 +8,6 @@ from pandora.transport import DEFAULT_API_HOST
 
 
 class TestTranslatingDict(TestCase):
-
     class TestDict(cb.TranslatingDict):
 
         KEY_TRANSLATIONS = {"FOO": "BAR"}
@@ -62,29 +61,32 @@ class TestTranslatingDict(TestCase):
 
 
 class TestSettingsDictBuilder(TestCase):
-
     @classmethod
     def _build_minimal(self):
-        return cb.SettingsDictBuilder({
-            "DECRYPTION_KEY": "blowfishkey",
-            "ENCRYPTION_KEY": "blowfishkey",
-            "PARTNER_USER": "user",
-            "PARTNER_PASSWORD": "pass",
-            "DEVICE": "dev",
-        }).build()
+        return cb.SettingsDictBuilder(
+            {
+                "DECRYPTION_KEY": "blowfishkey",
+                "ENCRYPTION_KEY": "blowfishkey",
+                "PARTNER_USER": "user",
+                "PARTNER_PASSWORD": "pass",
+                "DEVICE": "dev",
+            }
+        ).build()
 
     @classmethod
     def _build_maximal(self):
-        return cb.SettingsDictBuilder({
-            "DECRYPTION_KEY": "blowfishkey",
-            "ENCRYPTION_KEY": "blowfishkey",
-            "PARTNER_USER": "user",
-            "PARTNER_PASSWORD": "pass",
-            "DEVICE": "dev",
-            "PROXY": "proxy.example.com",
-            "AUDIO_QUALITY": "high",
-            "API_HOST": "example.com",
-        }).build()
+        return cb.SettingsDictBuilder(
+            {
+                "DECRYPTION_KEY": "blowfishkey",
+                "ENCRYPTION_KEY": "blowfishkey",
+                "PARTNER_USER": "user",
+                "PARTNER_PASSWORD": "pass",
+                "DEVICE": "dev",
+                "PROXY": "proxy.example.com",
+                "AUDIO_QUALITY": "high",
+                "API_HOST": "example.com",
+            }
+        ).build()
 
     def test_building(self):
         client = TestSettingsDictBuilder._build_minimal()
@@ -97,14 +99,15 @@ class TestSettingsDictBuilder(TestCase):
         self.assertEqual({}, client.transport._http.proxies)
         self.assertEqual(DEFAULT_API_HOST, client.transport.api_host)
         self.assertEqual(
-            APIClient.MED_AUDIO_QUALITY, client.default_audio_quality)
+            APIClient.MED_AUDIO_QUALITY, client.default_audio_quality
+        )
 
     def test_validate_client(self):
         client = TestSettingsDictBuilder._build_maximal()
         expected_proxies = {
-                "http": "proxy.example.com",
-                "https": "proxy.example.com"
-                }
+            "http": "proxy.example.com",
+            "https": "proxy.example.com",
+        }
 
         self.assertIsNotNone(client.transport.cryptor.bf_in)
         self.assertIsNotNone(client.transport.cryptor.bf_out)
@@ -119,7 +122,6 @@ class TestSettingsDictBuilder(TestCase):
 
 
 class TestFileBasedBuilder(TestCase):
-
     class StubBuilder(cb.FileBasedClientBuilder):
 
         DEFAULT_CONFIG_FILE = "foo"
@@ -170,7 +172,6 @@ class TestFileBasedBuilder(TestCase):
 
 
 class TestPydoraConfigFileBuilder(TestCase):
-
     def test_cfg_to_dict(self):
         cfg = Mock()
         cfg.items = Mock(return_value=[("a", "b"), ("c", "d")])
@@ -184,38 +185,43 @@ class TestPydoraConfigFileBuilder(TestCase):
         path = os.path.join(os.path.dirname(__file__), "pydora.cfg")
         cfg = cb.PydoraConfigFileBuilder(path).parse_config()
 
-        self.assertDictEqual(cfg, {
-            "AUDIO_QUALITY": "test_quality",
-            "DECRYPTION_KEY": "test_decryption_key",
-            "DEVICE": "test_device",
-            "ENCRYPTION_KEY": "test_encryption_key",
-            "PARTNER_PASSWORD": "test_partner_password",
-            "PARTNER_USER": "test_partner_username",
-            "API_HOST": "test_host",
-            "USER": {
-                "USERNAME": "test_username",
-                "PASSWORD": "test_password",
-                }
-            })
+        self.assertDictEqual(
+            cfg,
+            {
+                "AUDIO_QUALITY": "test_quality",
+                "DECRYPTION_KEY": "test_decryption_key",
+                "DEVICE": "test_device",
+                "ENCRYPTION_KEY": "test_encryption_key",
+                "PARTNER_PASSWORD": "test_partner_password",
+                "PARTNER_USER": "test_partner_username",
+                "API_HOST": "test_host",
+                "USER": {
+                    "USERNAME": "test_username",
+                    "PASSWORD": "test_password",
+                },
+            },
+        )
 
 
 class TestPianobarConfigFileBuilder(TestCase):
-
     def test_integration(self):
         path = os.path.join(os.path.dirname(__file__), "pianobar.cfg")
         cfg = cb.PianobarConfigFileBuilder(path).parse_config()
 
-        self.assertDictEqual(cfg, {
-            "AUDIO_QUALITY": "test_qualityQuality",
-            "DECRYPTION_KEY": "test_decryption_key",
-            "DEVICE": "test_device",
-            "ENCRYPTION_KEY": "test_encryption_key",
-            "PARTNER_PASSWORD": "test_partner_password",
-            "PARTNER_USER": "test_partner_username",
-            "API_HOST": "test_host/services/json/",
-            "PROXY": "test_proxy",
-            "USER": {
-                "USERNAME": "test_username",
-                "PASSWORD": "test_password",
-                }
-            })
+        self.assertDictEqual(
+            cfg,
+            {
+                "AUDIO_QUALITY": "test_qualityQuality",
+                "DECRYPTION_KEY": "test_decryption_key",
+                "DEVICE": "test_device",
+                "ENCRYPTION_KEY": "test_encryption_key",
+                "PARTNER_PASSWORD": "test_partner_password",
+                "PARTNER_USER": "test_partner_username",
+                "API_HOST": "test_host/services/json/",
+                "PROXY": "test_proxy",
+                "USER": {
+                    "USERNAME": "test_username",
+                    "PASSWORD": "test_password",
+                },
+            },
+        )
diff --git a/tests/test_pandora/test_errors.py b/tests/test_pandora/test_errors.py
index 778771a..d9df41f 100644
--- a/tests/test_pandora/test_errors.py
+++ b/tests/test_pandora/test_errors.py
@@ -4,7 +4,6 @@ from pandora.errors import InternalServerError, PandoraException
 
 
 class TestPandoraExceptionConstructionFromErrorCode(TestCase):
-
     def test_it_returns_specific_error_class_if_possible(self):
         error = PandoraException.from_code(0, "Test Message")
         self.assertIsInstance(error, InternalServerError)
diff --git a/tests/test_pandora/test_models.py b/tests/test_pandora/test_models.py
index cb650df..16307b4 100644
--- a/tests/test_pandora/test_models.py
+++ b/tests/test_pandora/test_models.py
@@ -14,7 +14,6 @@ import pandora.models.playlist as plm
 
 
 class TestField(TestCase):
-
     def test_defaults(self):
         field = m.Field("name")
 
@@ -24,7 +23,6 @@ class TestField(TestCase):
 
 
 class TestModelMetaClass(TestCase):
-
     class TestModel(metaclass=m.ModelMetaClass):
 
         foo = "bar"
@@ -40,7 +38,6 @@ class TestModelMetaClass(TestCase):
 
 
 class TestDateField(TestCase):
-
     class SampleModel(m.PandoraModel):
 
         date_field = m.DateField("foo")
@@ -57,34 +54,26 @@ class TestDateField(TestCase):
 
 
 class TestAdditionalUrlField(TestCase):
-
     def test_single_url(self):
-        dummy_data = {
-                '_paramAdditionalUrls': ['foo']
-                }
+        dummy_data = {"_paramAdditionalUrls": ["foo"]}
 
         field = plm.AdditionalUrlField("additionalAudioUrl")
 
-        ret = field.formatter(None, dummy_data, 'test')
+        ret = field.formatter(None, dummy_data, "test")
 
-        self.assertEqual(ret, {'foo': 'test'})
+        self.assertEqual(ret, {"foo": "test"})
 
     def test_multiple_urls(self):
-        dummy_data = {
-                '_paramAdditionalUrls': [
-                    'abc',
-                    'def',
-                    ]
-                }
+        dummy_data = {"_paramAdditionalUrls": ["abc", "def",]}
 
         field = plm.AdditionalUrlField("additionalAudioUrl")
 
-        ret = field.formatter(None, dummy_data, ['foo', 'bar'])
+        ret = field.formatter(None, dummy_data, ["foo", "bar"])
 
         expected = {
-                'abc': 'foo',
-                'def': 'bar',
-                }
+            "abc": "foo",
+            "def": "bar",
+        }
 
         self.assertEqual(ret, expected)
 
@@ -99,7 +88,6 @@ class TestPandoraModel(TestCase):
     }
 
     class TestModel(m.PandoraModel):
-
         class SubModel(m.PandoraModel):
 
             field1 = m.Field("field1")
@@ -116,7 +104,6 @@ class TestPandoraModel(TestCase):
         pass
 
     class ExtraReprModel(m.PandoraModel):
-
         def __repr__(self):
             return self._base_repr("Foo")
 
@@ -153,9 +140,11 @@ class TestPandoraModel(TestCase):
         self.assertEqual("a string", result[1].field1)
 
     def test_repr(self):
-        expected = ("TestModel(field1='a string', field2=['test2'], field3=42,"
-                    " field4=SubModel(field1='foo'), "
-                    "field5=[SubModel(field1='foo'), SubModel(field1='bar')])")
+        expected = (
+            "TestModel(field1='a string', field2=['test2'], field3=42,"
+            " field4=SubModel(field1='foo'), "
+            "field5=[SubModel(field1='foo'), SubModel(field1='bar')])"
+        )
         result = self.TestModel.from_json(None, self.JSON_DATA)
         self.assertEqual(expected, repr(result))
 
@@ -179,12 +168,12 @@ class TestSubModel(m.PandoraModel):
 class TestPandoraListModel(TestCase):
 
     JSON_DATA = {
-            "field1": 42,
-            "field2": [
-                {"idx": "foo", "fieldS1": "Foo"},
-                {"idx": "bar", "fieldS1": "Bar"},
-                ]
-            }
+        "field1": 42,
+        "field2": [
+            {"idx": "foo", "fieldS1": "Foo"},
+            {"idx": "bar", "fieldS1": "Bar"},
+        ],
+    }
 
     class TestModel(m.PandoraListModel):
 
@@ -204,8 +193,10 @@ class TestPandoraListModel(TestCase):
         self.assertEqual("Bar", self.result[1].fieldS1)
 
     def test_repr(self):
-        expected = ("TestModel(field1=42, [TestSubModel(fieldS1='Foo', "
-                    "idx='foo'), TestSubModel(fieldS1='Bar', idx='bar')])")
+        expected = (
+            "TestModel(field1=42, [TestSubModel(fieldS1='Foo', "
+            "idx='foo'), TestSubModel(fieldS1='Bar', idx='bar')])"
+        )
         self.assertEqual(expected, repr(self.result))
 
     def test_indexed_model(self):
@@ -232,17 +223,17 @@ class TestPandoraListModel(TestCase):
 class TestPandoraDictListModel(TestCase):
 
     JSON_DATA = {
-            "field1": 42,
-            "fieldD1": [
-                {
-                    "dictKey": "Foobear",
-                    "listKey": [
-                        {"idx": "foo", "fieldS1": "Foo"},
-                        {"idx": "bar", "fieldS1": "Bar"},
-                    ]
-                }
-            ]
-        }
+        "field1": 42,
+        "fieldD1": [
+            {
+                "dictKey": "Foobear",
+                "listKey": [
+                    {"idx": "foo", "fieldS1": "Foo"},
+                    {"idx": "bar", "fieldS1": "Bar"},
+                ],
+            }
+        ],
+    }
 
     class TestModel(m.PandoraDictListModel):
 
@@ -266,9 +257,11 @@ class TestPandoraDictListModel(TestCase):
         self.assertEqual("bar", self.result["Foobear"][1].idx)
 
     def test_repr(self):
-        expected = ("TestModel(field1=42, {'Foobear': "
-                    "[TestSubModel(fieldS1='Foo', idx='foo'), "
-                    "TestSubModel(fieldS1='Bar', idx='bar')]})")
+        expected = (
+            "TestModel(field1=42, {'Foobear': "
+            "[TestSubModel(fieldS1='Foo', idx='foo'), "
+            "TestSubModel(fieldS1='Bar', idx='bar')]})"
+        )
         self.assertEqual(expected, repr(self.result))
 
 
@@ -320,7 +313,6 @@ class TestPlaylistItemModel(TestCase):
 
 
 class TestPlaylistModel(TestCase):
-
     def setUp(self):
         self.client = Mock()
         self.playlist = plm.PlaylistModel(self.client)
@@ -354,47 +346,47 @@ class TestPlaylistModel(TestCase):
 class TestAdItem(TestCase):
 
     JSON_DATA = {
-        'audioUrlMap': {
-            'mediumQuality': {
-                'audioUrl': 'med_url_mock',
-                'bitrate': '64',
-                'protocol': 'http',
-                'encoding': 'aacplus'
+        "audioUrlMap": {
+            "mediumQuality": {
+                "audioUrl": "med_url_mock",
+                "bitrate": "64",
+                "protocol": "http",
+                "encoding": "aacplus",
             },
-            'highQuality': {
-                'audioUrl': 'high_url_mock',
-                'bitrate': '64',
-                'protocol': 'http',
-                'encoding': 'aacplus'
+            "highQuality": {
+                "audioUrl": "high_url_mock",
+                "bitrate": "64",
+                "protocol": "http",
+                "encoding": "aacplus",
+            },
+            "lowQuality": {
+                "audioUrl": "low_url_mock",
+                "bitrate": "32",
+                "protocol": "http",
+                "encoding": "aacplus",
             },
-            'lowQuality': {
-                'audioUrl': 'low_url_mock',
-                'bitrate': '32',
-                'protocol': 'http',
-                'encoding': 'aacplus'
-            }
         },
-        'clickThroughUrl': 'click_url_mock',
-        'imageUrl': 'img_url_mock',
-        'companyName': '',
-        'title': '',
-        'trackGain': '0.0',
-        'adTrackingTokens': ['token_1_mock', 'token_2_mock']
+        "clickThroughUrl": "click_url_mock",
+        "imageUrl": "img_url_mock",
+        "companyName": "",
+        "title": "",
+        "trackGain": "0.0",
+        "adTrackingTokens": ["token_1_mock", "token_2_mock"],
     }
 
     def setUp(self):
         api_client_mock = Mock(spec=APIClient)
         api_client_mock.default_audio_quality = APIClient.HIGH_AUDIO_QUALITY
         self.result = am.AdItem.from_json(api_client_mock, self.JSON_DATA)
-        self.result.station_id = 'station_id_mock'
-        self.result.ad_token = 'token_mock'
+        self.result.station_id = "station_id_mock"
+        self.result.ad_token = "token_mock"
 
     def test_is_ad_is_true(self):
         assert self.result.is_ad is True
 
     def test_register_ad(self):
         self.result._api_client.register_ad = Mock()
-        self.result.register_ad('id_mock')
+        self.result.register_ad("id_mock")
 
         assert self.result._api_client.register_ad.called
 
@@ -403,12 +395,12 @@ class TestAdItem(TestCase):
             self.result.tracking_tokens = []
             self.result._api_client.register_ad = Mock(spec=am.AdItem)
 
-            self.result.register_ad('id_mock')
+            self.result.register_ad("id_mock")
 
             assert self.result._api_client.register_ad.called
 
     def test_prepare_playback(self):
-        with patch.object(plm.PlaylistModel, 'prepare_playback') as super_mock:
+        with patch.object(plm.PlaylistModel, "prepare_playback") as super_mock:
 
             self.result.register_ad = Mock()
             self.result.prepare_playback()
@@ -416,21 +408,26 @@ class TestAdItem(TestCase):
             assert super_mock.called
 
     def test_prepare_playback_raises_paramater_missing(self):
-        with patch.object(plm.PlaylistModel, 'prepare_playback') as super_mock:
+        with patch.object(plm.PlaylistModel, "prepare_playback") as super_mock:
 
-            self.result.register_ad = Mock(side_effect=ParameterMissing(
-                'No ad tracking tokens provided for registration.')
-                                           )
+            self.result.register_ad = Mock(
+                side_effect=ParameterMissing(
+                    "No ad tracking tokens provided for registration."
+                )
+            )
             self.assertRaises(ParameterMissing, self.result.prepare_playback)
             assert self.result.register_ad.called
             assert not super_mock.called
 
     def test_prepare_playback_handles_paramater_missing_if_no_tokens(self):
-        with patch.object(plm.PlaylistModel, 'prepare_playback') as super_mock:
+        with patch.object(plm.PlaylistModel, "prepare_playback") as super_mock:
 
             self.result.tracking_tokens = []
-            self.result.register_ad = Mock(side_effect=ParameterMissing(
-                'No ad tracking tokens provided for registration.'))
+            self.result.register_ad = Mock(
+                side_effect=ParameterMissing(
+                    "No ad tracking tokens provided for registration."
+                )
+            )
             self.result.prepare_playback()
             assert self.result.register_ad.called
             assert super_mock.called
@@ -449,43 +446,45 @@ class TestSearchResultItem(TestCase):
         "artistName": "artist_name_mock",
         "musicToken": "S0000000",
         "songName": "song_name_mock",
-        "score": 100
+        "score": 100,
     }
 
     ARTIST_JSON_DATA = {
         "artistName": "artist_name_mock",
         "musicToken": "R0000000",
         "likelyMatch": False,
-        "score": 100
+        "score": 100,
     }
 
     COMPOSER_JSON_DATA = {
         "artistName": "composer_name_mock",
         "musicToken": "C0000000",
         "likelyMatch": False,
-        "score": 100
+        "score": 100,
     }
 
     GENRE_JSON_DATA = {
         "stationName": "station_name_mock",
         "musicToken": "G0000000",
-        "score": 100
+        "score": 100,
     }
 
     UNKNOWN_JSON_DATA = {
         "stationName": "unknown_name_mock",
         "musicToken": "U0000000",
-        "score": 100
+        "score": 100,
     }
 
     def setUp(self):
         self.api_client_mock = Mock(spec=APIClient)
-        self.api_client_mock.default_audio_quality = \
+        self.api_client_mock.default_audio_quality = (
             APIClient.HIGH_AUDIO_QUALITY
+        )
 
     def test_is_song(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.SONG_JSON_DATA)
+            self.api_client_mock, self.SONG_JSON_DATA
+        )
         assert result.is_song
         assert not result.is_artist
         assert not result.is_composer
@@ -493,7 +492,8 @@ class TestSearchResultItem(TestCase):
 
     def test_is_artist(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.ARTIST_JSON_DATA)
+            self.api_client_mock, self.ARTIST_JSON_DATA
+        )
         assert not result.is_song
         assert result.is_artist
         assert not result.is_composer
@@ -501,7 +501,8 @@ class TestSearchResultItem(TestCase):
 
     def test_is_composer(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.COMPOSER_JSON_DATA)
+            self.api_client_mock, self.COMPOSER_JSON_DATA
+        )
         assert not result.is_song
         assert not result.is_artist
         assert result.is_composer
@@ -509,7 +510,8 @@ class TestSearchResultItem(TestCase):
 
     def test_is_genre_station(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.GENRE_JSON_DATA)
+            self.api_client_mock, self.GENRE_JSON_DATA
+        )
         assert not result.is_song
         assert not result.is_artist
         assert not result.is_composer
@@ -518,7 +520,8 @@ class TestSearchResultItem(TestCase):
     def test_fails_if_unknown(self):
         with self.assertRaises(NotImplementedError):
             sm.SearchResultItem.from_json(
-                self.api_client_mock, self.UNKNOWN_JSON_DATA)
+                self.api_client_mock, self.UNKNOWN_JSON_DATA
+            )
 
     def test_interface(self):
         result = sm.SearchResultItem(self.api_client_mock)
@@ -533,44 +536,51 @@ class TestArtistSearchResultItem(TestCase):
         "artistName": "artist_name_mock",
         "musicToken": "R0000000",
         "likelyMatch": False,
-        "score": 100
+        "score": 100,
     }
 
     COMPOSER_JSON_DATA = {
         "artistName": "composer_name_mock",
         "musicToken": "C0000000",
         "likelyMatch": False,
-        "score": 100
+        "score": 100,
     }
 
     def setUp(self):
         self.api_client_mock = Mock(spec=APIClient)
-        self.api_client_mock.default_audio_quality = \
+        self.api_client_mock.default_audio_quality = (
             APIClient.HIGH_AUDIO_QUALITY
+        )
 
     def test_repr(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.ARTIST_JSON_DATA)
+            self.api_client_mock, self.ARTIST_JSON_DATA
+        )
         expected = (
             "ArtistSearchResultItem(artist='artist_name_mock', "
-            "likely_match=False, score=100, token='R0000000')")
+            "likely_match=False, score=100, token='R0000000')"
+        )
         self.assertEqual(expected, repr(result))
 
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.COMPOSER_JSON_DATA)
+            self.api_client_mock, self.COMPOSER_JSON_DATA
+        )
         expected = (
             "ArtistSearchResultItem(artist='composer_name_mock', "
-            "likely_match=False, score=100, token='C0000000')")
+            "likely_match=False, score=100, token='C0000000')"
+        )
         self.assertEqual(expected, repr(result))
 
     def test_create_station(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.ARTIST_JSON_DATA)
+            self.api_client_mock, self.ARTIST_JSON_DATA
+        )
         result._api_client.create_station = Mock()
 
         result.create_station()
         result._api_client.create_station.assert_called_with(
-            artist_token=result.token)
+            artist_token=result.token
+        )
 
 
 class TestSongSearchResultItem(TestCase):
@@ -579,30 +589,35 @@ class TestSongSearchResultItem(TestCase):
         "artistName": "artist_name_mock",
         "musicToken": "S0000000",
         "songName": "song_name_mock",
-        "score": 100
+        "score": 100,
     }
 
     def setUp(self):
         self.api_client_mock = Mock(spec=APIClient)
-        self.api_client_mock.default_audio_quality = \
+        self.api_client_mock.default_audio_quality = (
             APIClient.HIGH_AUDIO_QUALITY
+        )
 
     def test_repr(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.SONG_JSON_DATA)
+            self.api_client_mock, self.SONG_JSON_DATA
+        )
         expected = (
             "SongSearchResultItem(artist='artist_name_mock', score=100, "
-            "song_name='song_name_mock', token='S0000000')")
+            "song_name='song_name_mock', token='S0000000')"
+        )
         self.assertEqual(expected, repr(result))
 
     def test_create_station(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.SONG_JSON_DATA)
+            self.api_client_mock, self.SONG_JSON_DATA
+        )
         result._api_client.create_station = Mock()
 
         result.create_station()
         result._api_client.create_station.assert_called_with(
-            track_token=result.token)
+            track_token=result.token
+        )
 
 
 class TestGenreStationSearchResultItem(TestCase):
@@ -610,61 +625,69 @@ class TestGenreStationSearchResultItem(TestCase):
     GENRE_JSON_DATA = {
         "stationName": "station_name_mock",
         "musicToken": "G0000000",
-        "score": 100
+        "score": 100,
     }
 
     def setUp(self):
         self.api_client_mock = Mock(spec=APIClient)
-        self.api_client_mock.default_audio_quality = \
+        self.api_client_mock.default_audio_quality = (
             APIClient.HIGH_AUDIO_QUALITY
+        )
 
     def test_repr(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.GENRE_JSON_DATA)
+            self.api_client_mock, self.GENRE_JSON_DATA
+        )
         expected = (
             "GenreStationSearchResultItem(score=100, "
-            "station_name='station_name_mock', token='G0000000')")
+            "station_name='station_name_mock', token='G0000000')"
+        )
         self.assertEqual(expected, repr(result))
 
     def test_create_station(self):
         result = sm.SearchResultItem.from_json(
-            self.api_client_mock, self.GENRE_JSON_DATA)
+            self.api_client_mock, self.GENRE_JSON_DATA
+        )
         result._api_client.create_station = Mock()
 
         result.create_station()
         result._api_client.create_station.assert_called_with(
-            search_token=result.token)
+            search_token=result.token
+        )
 
 
 class TestSearchResult(TestCase):
 
     JSON_DATA = {
-        'nearMatchesAvailable': True,
-        'explanation': '',
-        'songs': [{
-            'artistName': 'song_artist_mock',
-            'musicToken': 'S0000000',
-            'songName': 'song_name_mock',
-            'score': 100
-        }],
-        'artists': [{
-            'artistName': 'artist_mock',
-            'musicToken': 'R000000',
-            'likelyMatch': False,
-            'score': 80
-        }],
-        'genreStations': [{
-            'musicToken': 'G0000',
-            'stationName': 'station_mock',
-            'score': 50
-        }]
+        "nearMatchesAvailable": True,
+        "explanation": "",
+        "songs": [
+            {
+                "artistName": "song_artist_mock",
+                "musicToken": "S0000000",
+                "songName": "song_name_mock",
+                "score": 100,
+            }
+        ],
+        "artists": [
+            {
+                "artistName": "artist_mock",
+                "musicToken": "R000000",
+                "likelyMatch": False,
+                "score": 80,
+            }
+        ],
+        "genreStations": [
+            {"musicToken": "G0000", "stationName": "station_mock", "score": 50}
+        ],
     }
 
     def setUp(self):
         api_client_mock = Mock(spec=APIClient)
         api_client_mock.default_audio_quality = APIClient.HIGH_AUDIO_QUALITY
         self.result = sm.SearchResult.from_json(
-            api_client_mock, self.JSON_DATA)
+            api_client_mock, self.JSON_DATA
+        )
 
     def test_repr(self):
         expected = (
@@ -676,7 +699,8 @@ class TestSearchResult(TestCase):
             "nearest_matches_available=True, "
             "songs=[SongSearchResultItem(artist='song_artist_mock', "
             "score=100, song_name='song_name_mock', "
-            "token='S0000000')])")
+            "token='S0000000')])"
+        )
         self.assertEqual(expected, repr(self.result))
 
 
@@ -684,9 +708,7 @@ class TestGenreStationList(TestCase):
 
     TEST_DATA = {
         "checksum": "bar",
-        "categories": [
-            {"categoryName": "foo", "stations": []},
-        ]
+        "categories": [{"categoryName": "foo", "stations": []},],
     }
 
     def test_has_changed(self):
@@ -706,7 +728,8 @@ class TestGenreStation(TestCase):
         genre_station = stm.GenreStation.from_json(api_client, self.TEST_DATA)
 
         with self.assertRaisesRegex(
-                NotImplementedError, "Genre stations do not have playlists.*"):
+            NotImplementedError, "Genre stations do not have playlists.*"
+        ):
             genre_station.get_playlist()
 
 
@@ -750,7 +773,6 @@ class TestBookmark(TestCase):
 
 
 class TestPandoraType(TestCase):
-
     def test_it_can_be_built_from_a_model(self):
         pt = plm.PandoraType.from_model(None, "TR")
         self.assertIs(plm.PandoraType.TRACK, pt)
@@ -765,7 +787,6 @@ class TestPandoraType(TestCase):
 
 
 class TestSyntheticField(TestCase):
-
     def test_interface(self):
         sf = m.SyntheticField(field="foo")
 
diff --git a/tests/test_pandora/test_transport.py b/tests/test_pandora/test_transport.py
index 851fa06..28ca6b2 100644
--- a/tests/test_pandora/test_transport.py
+++ b/tests/test_pandora/test_transport.py
@@ -16,12 +16,12 @@ class SysCallError(Exception):
 
 
 class TestTransport(TestCase):
-
     def test_test_url_should_return_true_if_request_okay(self):
         transport = t.APITransport(Mock())
         transport._http = Mock()
         transport._http.head.return_value = Mock(
-            status_code=requests.codes.not_found)
+            status_code=requests.codes.not_found
+        )
 
         self.assertFalse(transport.test_url("foo"))
 
@@ -34,7 +34,8 @@ class TestTransport(TestCase):
 
             time.sleep = Mock()
             client.transport._make_http_request = Mock(
-                    side_effect=SysCallError("error_mock"))
+                side_effect=SysCallError("error_mock")
+            )
             client.transport._start_request = Mock()
 
             client("method")
@@ -48,7 +49,8 @@ class TestTransport(TestCase):
 
             time.sleep = Mock()
             client.transport._make_http_request = Mock(
-                    side_effect=PandoraException("error_mock"))
+                side_effect=PandoraException("error_mock")
+            )
             client.transport._start_request = Mock()
 
             client("method")
@@ -62,7 +64,8 @@ class TestTransport(TestCase):
 
             time.sleep = Mock()
             client.transport._make_http_request = Mock(
-                    side_effect=InvalidAuthToken("error_mock"))
+                side_effect=InvalidAuthToken("error_mock")
+            )
             client.transport._start_request = Mock()
 
             client._authenticate = Mock()
@@ -82,11 +85,11 @@ class TestTransport(TestCase):
         transport._http.post.return_value = http_result
 
         self.assertEqual(
-            "bar", transport(t.APITransport.NO_ENCRYPT[0], foo="bar"))
+            "bar", transport(t.APITransport.NO_ENCRYPT[0], foo="bar")
+        )
 
 
 class TestTransportSetters(TestCase):
-
     def setUp(self):
         self.cryptor = Mock()
         self.transport = t.APITransport(self.cryptor)
@@ -94,27 +97,29 @@ class TestTransportSetters(TestCase):
     def test_set_partner(self):
         self.cryptor.decrypt_sync_time.return_value = 456
 
-        self.transport.set_partner({
-            "syncTime": "123",
-            "partnerAuthToken": "partner_auth_token",
-            "partnerId": "partner_id",
-        })
+        self.transport.set_partner(
+            {
+                "syncTime": "123",
+                "partnerAuthToken": "partner_auth_token",
+                "partnerId": "partner_id",
+            }
+        )
 
         self.cryptor.decrypt_sync_time.assert_called_with("123")
         self.assertEqual("partner_auth_token", self.transport.auth_token)
         self.assertEqual("partner_id", self.transport.partner_id)
         self.assertEqual(
-            "partner_auth_token", self.transport.partner_auth_token)
+            "partner_auth_token", self.transport.partner_auth_token
+        )
 
         self.transport.start_time = 10
         with patch.object(time, "time", return_value=30):
             self.assertEqual(476, self.transport.sync_time)
 
     def test_set_user(self):
-        self.transport.set_user({
-            "userId": "user",
-            "userAuthToken": "auth",
-        })
+        self.transport.set_user(
+            {"userId": "user", "userAuthToken": "auth",}
+        )
 
         self.assertEqual("user", self.transport.user_id)
         self.assertEqual("auth", self.transport.user_auth_token)
@@ -126,7 +131,6 @@ class TestTransportSetters(TestCase):
 
 
 class TestDelayExponential(TestCase):
-
     def test_fixed_delay(self):
         self.assertEqual(8, t.delay_exponential(2, 2, 3))
 
@@ -143,7 +147,6 @@ class TestDelayExponential(TestCase):
 
 
 class TestRetries(TestCase):
-
     def test_no_retries_returns_none(self):
         @t.retries(0)
         def foo():
@@ -178,7 +181,6 @@ class TestParseResponse(TestCase):
 
 
 class TestTransportRequestPrep(TestCase):
-
     def setUp(self):
         self.cryptor = Mock()
         self.transport = t.APITransport(self.cryptor)
@@ -207,7 +209,8 @@ class TestTransportRequestPrep(TestCase):
 
         self.transport._http = http
         res = self.transport._make_http_request(
-            "/url", b"data", {"a": None, "b": "c"})
+            "/url", b"data", {"a": None, "b": "c"}
+        )
 
         http.post.assert_called_with("/url", data=b"data", params={"b": "c"})
         retval.raise_for_status.assert_called_with()
@@ -237,7 +240,8 @@ class TestTransportRequestPrep(TestCase):
 
         with patch.object(time, "time", return_value=20):
             val = self.transport._build_data(
-                t.APITransport.NO_ENCRYPT[0], {"a": "b", "c": None})
+                t.APITransport.NO_ENCRYPT[0], {"a": "b", "c": None}
+            )
 
         val = json.loads(val)
         self.assertEqual("b", val["a"])
@@ -247,7 +251,6 @@ class TestTransportRequestPrep(TestCase):
 
 # All Cryptor implementations must pass these test cases unmodified
 class CommonCryptorTestCases:
-
     def test_decrypt_invalid_padding(self):
         with self.assertRaises(ValueError):
             data = b"12345678\x00"
@@ -267,7 +270,6 @@ class CommonCryptorTestCases:
 
 
 class TestPurePythonBlowfishCryptor(TestCase, CommonCryptorTestCases):
-
     def setUp(self):
         # Ugh... blowfish can't even be *imported* in python2
         if not t.blowfish:
@@ -288,7 +290,6 @@ class TestEncryptor(TestCase):
     ENCODED_TIME = "31353037343131313539"
 
     class NoopCrypto:
-
         def __init__(self, key):
             pass
 
@@ -303,14 +304,17 @@ class TestEncryptor(TestCase):
 
     def test_decrypt(self):
         self.assertEqual(
-            {"foo": "bar"}, self.cryptor.decrypt(self.ENCODED_JSON))
+            {"foo": "bar"}, self.cryptor.decrypt(self.ENCODED_JSON)
+        )
 
     def test_encrypt(self):
         self.assertEqual(
             self.ENCODED_JSON.encode("ascii"),
-            self.cryptor.encrypt(self.UNENCODED_JSON))
+            self.cryptor.encrypt(self.UNENCODED_JSON),
+        )
 
     def test_decrypt_sync_time(self):
         self.assertEqual(
             self.EXPECTED_TIME,
-            self.cryptor.decrypt_sync_time(self.ENCODED_TIME))
+            self.cryptor.decrypt_sync_time(self.ENCODED_TIME),
+        )