9 files changed, 212 insertions, 166 deletions

diff --git a/pandora/client.py b/pandora/client.py
index e0d3da9..a98056c 100644
--- a/pandora/client.py
+++ b/pandora/client.py
@@ -29,8 +29,14 @@ class BaseAPIClient:
 
     ALL_QUALITIES = [LOW_AUDIO_QUALITY, MED_AUDIO_QUALITY, HIGH_AUDIO_QUALITY]
 
-    def __init__(self, transport, partner_user, partner_password, device,
-                 default_audio_quality=MED_AUDIO_QUALITY):
+    def __init__(
+        self,
+        transport,
+        partner_user,
+        partner_password,
+        device,
+        default_audio_quality=MED_AUDIO_QUALITY,
+    ):
         self.transport = transport
         self.partner_user = partner_user
         self.partner_password = partner_password
@@ -40,11 +46,13 @@ class BaseAPIClient:
         self.password = None
 
     def _partner_login(self):
-        partner = self.transport("auth.partnerLogin",
-                                 username=self.partner_user,
-                                 password=self.partner_password,
-                                 deviceModel=self.device,
-                                 version=self.transport.API_VERSION)
+        partner = self.transport(
+            "auth.partnerLogin",
+            username=self.partner_user,
+            password=self.partner_password,
+            deviceModel=self.device,
+            version=self.transport.API_VERSION,
+        )
 
         self.transport.set_partner(partner)
 
@@ -59,16 +67,18 @@ class BaseAPIClient:
         self._partner_login()
 
         try:
-            user = self.transport("auth.userLogin",
-                                  loginType="user",
-                                  username=self.username,
-                                  password=self.password,
-                                  includePandoraOneInfo=True,
-                                  includeSubscriptionExpiration=True,
-                                  returnCapped=True,
-                                  includeAdAttributes=True,
-                                  includeAdvertiserAttributes=True,
-                                  xplatformAdCapable=True)
+            user = self.transport(
+                "auth.userLogin",
+                loginType="user",
+                username=self.username,
+                password=self.password,
+                includePandoraOneInfo=True,
+                includeSubscriptionExpiration=True,
+                returnCapped=True,
+                includeAdAttributes=True,
+                includeAdvertiserAttributes=True,
+                xplatformAdCapable=True,
+            )
         except errors.InvalidPartnerLogin:
             raise errors.InvalidUserLogin()
 
@@ -80,7 +90,7 @@ class BaseAPIClient:
     def get_qualities(cls, start_at, return_all_if_invalid=True):
         try:
             idx = cls.ALL_QUALITIES.index(start_at)
-            return cls.ALL_QUALITIES[:idx + 1]
+            return cls.ALL_QUALITIES[: idx + 1]
         except ValueError:
             if return_all_if_invalid:
                 return cls.ALL_QUALITIES[:]
@@ -105,9 +115,9 @@ class APIClient(BaseAPIClient):
     def get_station_list(self):
         from .models.station import StationList
 
-        return StationList.from_json(self,
-                                     self("user.getStationList",
-                                          includeStationArtUrl=True))
+        return StationList.from_json(
+            self, self("user.getStationList", includeStationArtUrl=True)
+        )
 
     def get_station_list_checksum(self):
         return self("user.getStationListChecksum")["checksum"]
@@ -119,19 +129,21 @@ class APIClient(BaseAPIClient):
             additional_urls = []
 
         if isinstance(additional_urls, str):
-            raise TypeError('Additional urls should be a list')
+            raise TypeError("Additional urls should be a list")
 
         urls = [getattr(url, "value", url) for url in additional_urls]
 
-        resp = self("station.getPlaylist",
-                    stationToken=station_token,
-                    includeTrackLength=True,
-                    xplatformAdCapable=True,
-                    audioAdPodCapable=True,
-                    additionalAudioUrl=','.join(urls))
+        resp = self(
+            "station.getPlaylist",
+            stationToken=station_token,
+            includeTrackLength=True,
+            xplatformAdCapable=True,
+            audioAdPodCapable=True,
+            additionalAudioUrl=",".join(urls),
+        )
 
-        for item in resp['items']:
-            item['_paramAdditionalUrls'] = additional_urls
+        for item in resp["items"]:
+            item["_paramAdditionalUrls"] = additional_urls
 
         playlist = Playlist.from_json(self, resp)
 
@@ -145,58 +157,69 @@ class APIClient(BaseAPIClient):
     def get_bookmarks(self):
         from .models.bookmark import BookmarkList
 
-        return BookmarkList.from_json(self,
-                                      self("user.getBookmarks"))
+        return BookmarkList.from_json(self, self("user.getBookmarks"))
 
     def get_station(self, station_token):
         from .models.station import Station
 
-        return Station.from_json(self,
-                                 self("station.getStation",
-                                      stationToken=station_token,
-                                      includeExtendedAttributes=True))
+        return Station.from_json(
+            self,
+            self(
+                "station.getStation",
+                stationToken=station_token,
+                includeExtendedAttributes=True,
+            ),
+        )
 
     def add_artist_bookmark(self, track_token):
-        return self("bookmark.addArtistBookmark",
-                    trackToken=track_token)
+        return self("bookmark.addArtistBookmark", trackToken=track_token)
 
     def add_song_bookmark(self, track_token):
-        return self("bookmark.addSongBookmark",
-                    trackToken=track_token)
+        return self("bookmark.addSongBookmark", trackToken=track_token)
 
     def delete_song_bookmark(self, bookmark_token):
-        return self("bookmark.deleteSongBookmark",
-                    bookmarkToken=bookmark_token)
+        return self(
+            "bookmark.deleteSongBookmark", bookmarkToken=bookmark_token
+        )
 
     def delete_artist_bookmark(self, bookmark_token):
-        return self("bookmark.deleteArtistBookmark",
-                    bookmarkToken=bookmark_token)
+        return self(
+            "bookmark.deleteArtistBookmark", bookmarkToken=bookmark_token
+        )
 
-    def search(self, search_text,
-               include_near_matches=False,
-               include_genre_stations=False):
+    def search(
+        self,
+        search_text,
+        include_near_matches=False,
+        include_genre_stations=False,
+    ):
         from .models.search import SearchResult
 
         return SearchResult.from_json(
             self,
-            self("music.search",
-                 searchText=search_text,
-                 includeNearMatches=include_near_matches,
-                 includeGenreStations=include_genre_stations)
+            self(
+                "music.search",
+                searchText=search_text,
+                includeNearMatches=include_near_matches,
+                includeGenreStations=include_genre_stations,
+            ),
         )
 
     def add_feedback(self, track_token, positive):
-        return self("station.addFeedback",
-                    trackToken=track_token,
-                    isPositive=positive)
+        return self(
+            "station.addFeedback", trackToken=track_token, isPositive=positive
+        )
 
     def add_music(self, music_token, station_token):
-        return self("station.addMusic",
-                    musicToken=music_token,
-                    stationToken=station_token)
+        return self(
+            "station.addMusic",
+            musicToken=music_token,
+            stationToken=station_token,
+        )
 
-    def create_station(self, search_token=None, artist_token=None,
-                       track_token=None):
+    def create_station(
+        self, search_token=None, artist_token=None, track_token=None
+    ):
         from .models.station import Station
 
         kwargs = {}
@@ -210,26 +233,23 @@ class APIClient(BaseAPIClient):
         else:
             raise KeyError("Must pass a type of token")
 
-        return Station.from_json(self,
-                                 self("station.createStation", **kwargs))
+        return Station.from_json(self, self("station.createStation", **kwargs))
 
     def delete_feedback(self, feedback_id):
-        return self("station.deleteFeedback",
-                    feedbackId=feedback_id)
+        return self("station.deleteFeedback", feedbackId=feedback_id)
 
     def delete_music(self, seed_id):
-        return self("station.deleteMusic",
-                    seedId=seed_id)
+        return self("station.deleteMusic", seedId=seed_id)
 
     def delete_station(self, station_token):
-        return self("station.deleteStation",
-                    stationToken=station_token)
+        return self("station.deleteStation", stationToken=station_token)
 
     def get_genre_stations(self):
         from .models.station import GenreStationList
 
         genre_stations = GenreStationList.from_json(
-            self, self("station.getGenreStations"))
+            self, self("station.getGenreStations")
+        )
         genre_stations.checksum = self.get_genre_stations_checksum()
 
         return genre_stations
@@ -238,44 +258,45 @@ class APIClient(BaseAPIClient):
         return self("station.getGenreStationsChecksum")["checksum"]
 
     def rename_station(self, station_token, name):
-        return self("station.renameStation",
-                    stationToken=station_token,
-                    stationName=name)
+        return self(
+            "station.renameStation",
+            stationToken=station_token,
+            stationName=name,
+        )
 
     def explain_track(self, track_token):
-        return self("track.explainTrack",
-                    trackToken=track_token)
+        return self("track.explainTrack", trackToken=track_token)
 
     def set_quick_mix(self, *args):
-        return self("user.setQuickMix",
-                    quickMixStationIds=args)
+        return self("user.setQuickMix", quickMixStationIds=args)
 
     def sleep_song(self, track_token):
-        return self("user.sleepSong",
-                    trackToken=track_token)
+        return self("user.sleepSong", trackToken=track_token)
 
     def share_station(self, station_id, station_token, *emails):
-        return self("station.shareStation",
-                    stationId=station_id,
-                    stationToken=station_token,
-                    emails=emails)
+        return self(
+            "station.shareStation",
+            stationId=station_id,
+            stationToken=station_token,
+            emails=emails,
+        )
 
     def transform_shared_station(self, station_token):
-        return self("station.transformSharedStation",
-                    stationToken=station_token)
+        return self(
+            "station.transformSharedStation", stationToken=station_token
+        )
 
     def share_music(self, music_token, *emails):
-        return self("music.shareMusic",
-                    musicToken=music_token,
-                    email=emails[0])
+        return self(
+            "music.shareMusic", musicToken=music_token, email=emails[0]
+        )
 
     def get_ad_item(self, station_id, ad_token):
         from .models.ad import AdItem
 
         if not station_id:
-            raise errors.ParameterMissing("The 'station_id' param must be "
-                                          "defined, got: '{}'"
-                                          .format(station_id))
+            msg = "The 'station_id' param must be defined, got: '{}'"
+            raise errors.ParameterMissing(msg.format(station_id))
 
         ad_item = AdItem.from_json(self, self.get_ad_metadata(ad_token))
         ad_item.station_id = station_id
@@ -283,12 +304,14 @@ class APIClient(BaseAPIClient):
         return ad_item
 
     def get_ad_metadata(self, ad_token):
-        return self("ad.getAdMetadata",
-                    adToken=ad_token,
-                    returnAdTrackingTokens=True,
-                    supportAudioAds=True)
+        return self(
+            "ad.getAdMetadata",
+            adToken=ad_token,
+            returnAdTrackingTokens=True,
+            supportAudioAds=True,
+        )
 
     def register_ad(self, station_id, tokens):
-        return self("ad.registerAd",
-                    stationId=station_id,
-                    adTrackingTokens=tokens)
+        return self(
+            "ad.registerAd", stationId=station_id, adTrackingTokens=tokens
+        )
diff --git a/pandora/clientbuilder.py b/pandora/clientbuilder.py
index bc55cec..2b11ffb 100644
--- a/pandora/clientbuilder.py
+++ b/pandora/clientbuilder.py
@@ -70,8 +70,7 @@ class TranslatingDict(dict):
 
     def __setitem__(self, key, value):
         key = self.translate_key(key)
-        super().__setitem__(
-            key, self.translate_value(key, value))
+        super().__setitem__(key, self.translate_value(key, value))
 
 
 class APIClientBuilder:
@@ -99,19 +98,25 @@ class APIClientBuilder:
         self.client_class = client_class or self.DEFAULT_CLIENT_CLASS
 
     def build_from_settings_dict(self, settings):
-        enc = Encryptor(settings["DECRYPTION_KEY"],
-                        settings["ENCRYPTION_KEY"])
+        enc = Encryptor(settings["DECRYPTION_KEY"], settings["ENCRYPTION_KEY"])
 
-        trans = APITransport(enc,
-                             settings.get("API_HOST", DEFAULT_API_HOST),
-                             settings.get("PROXY", None))
+        trans = APITransport(
+            enc,
+            settings.get("API_HOST", DEFAULT_API_HOST),
+            settings.get("PROXY", None),
+        )
 
-        quality = settings.get("AUDIO_QUALITY",
-                               self.client_class.MED_AUDIO_QUALITY)
+        quality = settings.get(
+            "AUDIO_QUALITY", self.client_class.MED_AUDIO_QUALITY
+        )
 
-        return self.client_class(trans, settings["PARTNER_USER"],
-                                 settings["PARTNER_PASSWORD"],
-                                 settings["DEVICE"], quality)
+        return self.client_class(
+            trans,
+            settings["PARTNER_USER"],
+            settings["PARTNER_PASSWORD"],
+            settings["DEVICE"],
+            quality,
+        )
 
 
 class SettingsDict(TranslatingDict):
@@ -185,8 +190,9 @@ class FileBasedClientBuilder(APIClientBuilder):
         client = self.build_from_settings_dict(config)
 
         if self.authenticate:
-            client.login(config["USER"]["USERNAME"],
-                         config["USER"]["PASSWORD"])
+            client.login(
+                config["USER"]["USERNAME"], config["USER"]["PASSWORD"]
+            )
 
         return client
 
@@ -201,8 +207,9 @@ class PydoraConfigFileBuilder(FileBasedClientBuilder):
 
     @staticmethod
     def cfg_to_dict(cfg, key, kind=SettingsDict):
-        return kind((k.strip().upper(), v.strip())
-                    for k, v in cfg.items(key, raw=True))
+        return kind(
+            (k.strip().upper(), v.strip()) for k, v in cfg.items(key, raw=True)
+        )
 
     def parse_config(self):
         cfg = ConfigParser()
@@ -212,7 +219,8 @@ class PydoraConfigFileBuilder(FileBasedClientBuilder):
 
         settings = PydoraConfigFileBuilder.cfg_to_dict(cfg, "api")
         settings["user"] = PydoraConfigFileBuilder.cfg_to_dict(
-            cfg, "user", dict)
+            cfg, "user", dict
+        )
 
         return settings
 
diff --git a/pandora/errors.py b/pandora/errors.py
index c978708..3b03db2 100644
--- a/pandora/errors.py
+++ b/pandora/errors.py
@@ -86,10 +86,11 @@ class PandoraException(Exception):
         for code, api_message in __API_EXCEPTIONS__.items():
             name = PandoraException._format_name(api_message)
 
-            exception = type(name, (PandoraException,), {
-                "code": code,
-                "message": api_message,
-            })
+            exception = type(
+                name,
+                (PandoraException,),
+                {"code": code, "message": api_message,},
+            )
 
             export_to[name] = __API_EXCEPTIONS__[code] = exception
 
diff --git a/pandora/models/_base.py b/pandora/models/_base.py
index 6975d0a..8904be1 100644
--- a/pandora/models/_base.py
+++ b/pandora/models/_base.py
@@ -71,7 +71,6 @@ class DateField(SyntheticField):
 
 
 class ModelMetaClass(type):
-
     def __new__(cls, name, parents, dct):
         dct["_fields"] = fields = {}
         new_dct = dct.copy()
@@ -159,7 +158,8 @@ class PandoraModel(metaclass=ModelMetaClass):
         """
         items = [
             "=".join((key, repr(getattr(self, key))))
-            for key in sorted(self._fields.keys())]
+            for key in sorted(self._fields.keys())
+        ]
 
         if items:
             output = ", ".join(items)
@@ -167,8 +167,9 @@ class PandoraModel(metaclass=ModelMetaClass):
             output = None
 
         if and_also:
-            return "{}({}, {})".format(self.__class__.__name__,
-                                       output, and_also)
+            return "{}({}, {})".format(
+                self.__class__.__name__, output, and_also
+            )
         else:
             return "{}({})".format(self.__class__.__name__, output)
 
@@ -301,7 +302,8 @@ class PandoraDictListModel(PandoraModel, dict):
 
             for part in item[self.__list_key__]:
                 self[key].append(
-                    cls.__list_model__.from_json(api_client, part))
+                    cls.__list_model__.from_json(api_client, part)
+                )
 
         return self
 
diff --git a/pandora/models/ad.py b/pandora/models/ad.py
index ad4b7b0..48cd302 100644
--- a/pandora/models/ad.py
+++ b/pandora/models/ad.py
@@ -24,8 +24,9 @@ class AdItem(PlaylistModel):
         if self.tracking_tokens:
             self._api_client.register_ad(station_id, self.tracking_tokens)
         else:
-            raise ParameterMissing('No ad tracking tokens provided for '
-                                   'registration.')
+            raise ParameterMissing(
+                "No ad tracking tokens provided for registration."
+            )
 
     def prepare_playback(self):
         try:
diff --git a/pandora/models/playlist.py b/pandora/models/playlist.py
index 38afb00..8e0d22e 100644
--- a/pandora/models/playlist.py
+++ b/pandora/models/playlist.py
@@ -5,15 +5,15 @@ from ._base import Field, SyntheticField, PandoraModel, PandoraListModel
 
 
 class AdditionalAudioUrl(Enum):
-    HTTP_40_AAC_MONO = 'HTTP_40_AAC_MONO'
-    HTTP_64_AAC = 'HTTP_64_AAC'
-    HTTP_32_AACPLUS = 'HTTP_32_AACPLUS'
-    HTTP_64_AACPLUS = 'HTTP_64_AACPLUS'
-    HTTP_24_AACPLUS_ADTS = 'HTTP_24_AACPLUS_ADTS'
-    HTTP_32_AACPLUS_ADTS = 'HTTP_32_AACPLUS_ADTS'
-    HTTP_64_AACPLUS_ADTS = 'HTTP_64_AACPLUS_ADTS'
-    HTTP_128_MP3 = 'HTTP_128_MP3'
-    HTTP_32_WMA = 'HTTP_32_WMA'
+    HTTP_40_AAC_MONO = "HTTP_40_AAC_MONO"
+    HTTP_64_AAC = "HTTP_64_AAC"
+    HTTP_32_AACPLUS = "HTTP_32_AACPLUS"
+    HTTP_64_AACPLUS = "HTTP_64_AACPLUS"
+    HTTP_24_AACPLUS_ADTS = "HTTP_24_AACPLUS_ADTS"
+    HTTP_32_AACPLUS_ADTS = "HTTP_32_AACPLUS_ADTS"
+    HTTP_64_AACPLUS_ADTS = "HTTP_64_AACPLUS_ADTS"
+    HTTP_128_MP3 = "HTTP_128_MP3"
+    HTTP_32_WMA = "HTTP_32_WMA"
 
 
 class PandoraType(Enum):
@@ -28,14 +28,14 @@ class PandoraType(Enum):
 
     @staticmethod
     def from_string(value):
-        return {
+        types = {
             "TR": PandoraType.TRACK,
             "AR": PandoraType.ARTIST,
-        }.get(value, PandoraType.GENRE)
+        }
+        return types.get(value, PandoraType.GENRE)
 
 
 class AudioField(SyntheticField):
-
     def formatter(self, api_client, data, newval):
         """Get audio-related fields
 
@@ -61,9 +61,11 @@ class AudioField(SyntheticField):
         elif not url_map:  # No audio url available (e.g. ad tokens)
             return None
 
-        valid_audio_formats = [BaseAPIClient.HIGH_AUDIO_QUALITY,
-                               BaseAPIClient.MED_AUDIO_QUALITY,
-                               BaseAPIClient.LOW_AUDIO_QUALITY]
+        valid_audio_formats = [
+            BaseAPIClient.HIGH_AUDIO_QUALITY,
+            BaseAPIClient.MED_AUDIO_QUALITY,
+            BaseAPIClient.LOW_AUDIO_QUALITY,
+        ]
 
         # Only iterate over sublist, starting at preferred audio quality, or
         # from the beginning of the list if nothing is found. Ensures that the
@@ -84,7 +86,6 @@ class AudioField(SyntheticField):
 
 
 class AdditionalUrlField(SyntheticField):
-
     def formatter(self, api_client, data, newval):
         """Parse additional url fields and map them to inputs
 
@@ -94,7 +95,7 @@ class AdditionalUrlField(SyntheticField):
         if newval is None:
             return None
 
-        user_param = data['_paramAdditionalUrls']
+        user_param = data["_paramAdditionalUrls"]
         urls = {}
         if isinstance(newval, str):
             urls[user_param[0]] = newval
@@ -105,7 +106,6 @@ class AdditionalUrlField(SyntheticField):
 
 
 class PlaylistModel(PandoraModel):
-
     def get_is_playable(self):
         if not self.audio_url:
             return False
diff --git a/pandora/models/search.py b/pandora/models/search.py
index 94e6ee6..fe31561 100644
--- a/pandora/models/search.py
+++ b/pandora/models/search.py
@@ -12,13 +12,15 @@ class SearchResultItem(PandoraModel):
 
     @property
     def is_artist(self):
-        return isinstance(self, ArtistSearchResultItem) and \
-               self.token.startswith("R")
+        return isinstance(
+            self, ArtistSearchResultItem
+        ) and self.token.startswith("R")
 
     @property
     def is_composer(self):
-        return isinstance(self, ArtistSearchResultItem) and \
-               self.token.startswith("C")
+        return isinstance(
+            self, ArtistSearchResultItem
+        ) and self.token.startswith("C")
 
     @property
     def is_genre_station(self):
@@ -36,8 +38,9 @@ class SearchResultItem(PandoraModel):
         elif data["musicToken"].startswith("G"):
             return GenreStationSearchResultItem.from_json(api_client, data)
         else:
-            raise NotImplementedError("Unknown result token type '{}'"
-                                      .format(data["musicToken"]))
+            raise NotImplementedError(
+                "Unknown result token type '{}'".format(data["musicToken"])
+            )
 
 
 class ArtistSearchResultItem(SearchResultItem):
diff --git a/pandora/models/station.py b/pandora/models/station.py
index a1880ec..d3f6552 100644
--- a/pandora/models/station.py
+++ b/pandora/models/station.py
@@ -80,8 +80,7 @@ class Station(PandoraModel):
     feedback = Field("feedback", model=StationFeedback)
 
     def get_playlist(self, additional_urls=None):
-        return iter(self._api_client.get_playlist(self.token,
-                                                  additional_urls))
+        return iter(self._api_client.get_playlist(self.token, additional_urls))
 
 
 class StationList(PandoraListModel):
@@ -105,8 +104,10 @@ class GenreStation(PandoraModel):
     category = Field("categoryName")
 
     def get_playlist(self):
-        raise NotImplementedError("Genre stations do not have playlists. "
-                                  "Create a real station using the token.")
+        raise NotImplementedError(
+            "Genre stations do not have playlists. "
+            "Create a real station using the token."
+        )
 
 
 class GenreStationList(PandoraDictListModel):
diff --git a/pandora/transport.py b/pandora/transport.py
index edec8a8..84f153b 100644
--- a/pandora/transport.py
+++ b/pandora/transport.py
@@ -40,6 +40,7 @@ def retries(max_tries, exceptions=(Exception,)):
     function will only be retried if it raises one of the specified
     exceptions.
     """
+
     def decorator(func):
         def function(*args, **kwargs):
 
@@ -55,8 +56,9 @@ def retries(max_tries, exceptions=(Exception,)):
                     if isinstance(exc, PandoraException):
                         raise
                     if retries_left > 0:
-                        time.sleep(delay_exponential(
-                            0.5, 2, max_tries - retries_left))
+                        time.sleep(
+                            delay_exponential(0.5, 2, max_tries - retries_left)
+                        )
                     else:
                         raise
 
@@ -76,11 +78,12 @@ def delay_exponential(base, growth_factor, attempts):
     Base must be greater than 0, otherwise a ValueError will be
     raised.
     """
-    if base == 'rand':
+    if base == "rand":
         base = random.random()
     elif base <= 0:
-        raise ValueError("The 'base' param must be greater than 0, "
-                         "got: {}".format(base))
+        raise ValueError(
+            "The 'base' param must be greater than 0, got: {}".format(base)
+        )
     time_to_sleep = base * (growth_factor ** (attempts - 1))
     return time_to_sleep
 
@@ -95,8 +98,8 @@ class RetryingSession(requests.Session):
 
     def __init__(self):
         super().__init__()
-        self.mount('https://', HTTPAdapter(max_retries=3))
-        self.mount('http://', HTTPAdapter(max_retries=3))
+        self.mount("https://", HTTPAdapter(max_retries=3))
+        self.mount("http://", HTTPAdapter(max_retries=3))
 
 
 class APITransport:
@@ -109,10 +112,14 @@ class APITransport:
 
     API_VERSION = "5"
 
-    REQUIRE_RESET = ("auth.partnerLogin", )
-    NO_ENCRYPT = ("auth.partnerLogin", )
-    REQUIRE_TLS = ("auth.partnerLogin", "auth.userLogin",
-                   "station.getPlaylist", "user.createUser")
+    REQUIRE_RESET = ("auth.partnerLogin",)
+    NO_ENCRYPT = ("auth.partnerLogin",)
+    REQUIRE_TLS = (
+        "auth.partnerLogin",
+        "auth.userLogin",
+        "station.getPlaylist",
+        "user.createUser",
+    )
 
     def __init__(self, cryptor, api_host=DEFAULT_API_HOST, proxy=None):
         self.cryptor = cryptor
@@ -199,8 +206,8 @@ class APITransport:
 
     def _build_url(self, method):
         return "{}://{}".format(
-            "https" if method in self.REQUIRE_TLS else "http",
-            self.api_host)
+            "https" if method in self.REQUIRE_TLS else "http", self.api_host
+        )
 
     def _build_data(self, method, data):
         data["userAuthToken"] = self.user_auth_token
@@ -260,7 +267,7 @@ class BlowfishCryptor:
 
         computed = b"".join([chr(pad_size).encode("ascii")] * pad_size)
         if not data[-pad_size:] == computed:
-            raise ValueError('Invalid padding')
+            raise ValueError("Invalid padding")
 
         return data[:-pad_size]