Remove 'no cover' pragmas

6 files changed, 42 insertions, 42 deletions

diff --git a/pandora/client.py b/pandora/client.py
index bb30738..e0d3da9 100644
--- a/pandora/client.py
+++ b/pandora/client.py
@@ -102,14 +102,14 @@ class APIClient(BaseAPIClient):
     This is what clients should actually use.
     """
 
-    def get_station_list(self):  # pragma: no cover
+    def get_station_list(self):
         from .models.station import StationList
 
         return StationList.from_json(self,
                                      self("user.getStationList",
                                           includeStationArtUrl=True))
 
-    def get_station_list_checksum(self):  # pragma: no cover
+    def get_station_list_checksum(self):
         return self("user.getStationListChecksum")["checksum"]
 
     def get_playlist(self, station_token, additional_urls=None):
@@ -142,13 +142,13 @@ class APIClient(BaseAPIClient):
 
         return playlist
 
-    def get_bookmarks(self):  # pragma: no cover
+    def get_bookmarks(self):
         from .models.bookmark import BookmarkList
 
         return BookmarkList.from_json(self,
                                       self("user.getBookmarks"))
 
-    def get_station(self, station_token):  # pragma: no cover
+    def get_station(self, station_token):
         from .models.station import Station
 
         return Station.from_json(self,
@@ -156,25 +156,25 @@ class APIClient(BaseAPIClient):
                                       stationToken=station_token,
                                       includeExtendedAttributes=True))
 
-    def add_artist_bookmark(self, track_token):  # pragma: no cover
+    def add_artist_bookmark(self, track_token):
         return self("bookmark.addArtistBookmark",
                     trackToken=track_token)
 
-    def add_song_bookmark(self, track_token):  # pragma: no cover
+    def add_song_bookmark(self, track_token):
         return self("bookmark.addSongBookmark",
                     trackToken=track_token)
 
-    def delete_song_bookmark(self, bookmark_token):  # pragma: no cover
+    def delete_song_bookmark(self, bookmark_token):
         return self("bookmark.deleteSongBookmark",
                     bookmarkToken=bookmark_token)
 
-    def delete_artist_bookmark(self, bookmark_token):  # pragma: no cover
+    def delete_artist_bookmark(self, bookmark_token):
         return self("bookmark.deleteArtistBookmark",
                     bookmarkToken=bookmark_token)
 
     def search(self, search_text,
                include_near_matches=False,
-               include_genre_stations=False):  # pragma: no cover
+               include_genre_stations=False):
         from .models.search import SearchResult
 
         return SearchResult.from_json(
@@ -185,12 +185,12 @@ class APIClient(BaseAPIClient):
                  includeGenreStations=include_genre_stations)
         )
 
-    def add_feedback(self, track_token, positive):  # pragma: no cover
+    def add_feedback(self, track_token, positive):
         return self("station.addFeedback",
                     trackToken=track_token,
                     isPositive=positive)
 
-    def add_music(self, music_token, station_token):  # pragma: no cover
+    def add_music(self, music_token, station_token):
         return self("station.addMusic",
                     musicToken=music_token,
                     stationToken=station_token)
@@ -213,15 +213,15 @@ class APIClient(BaseAPIClient):
         return Station.from_json(self,
                                  self("station.createStation", **kwargs))
 
-    def delete_feedback(self, feedback_id):  # pragma: no cover
+    def delete_feedback(self, feedback_id):
         return self("station.deleteFeedback",
                     feedbackId=feedback_id)
 
-    def delete_music(self, seed_id):  # pragma: no cover
+    def delete_music(self, seed_id):
         return self("station.deleteMusic",
                     seedId=seed_id)
 
-    def delete_station(self, station_token):  # pragma: no cover
+    def delete_station(self, station_token):
         return self("station.deleteStation",
                     stationToken=station_token)
 
@@ -234,37 +234,37 @@ class APIClient(BaseAPIClient):
 
         return genre_stations
 
-    def get_genre_stations_checksum(self):  # pragma: no cover
+    def get_genre_stations_checksum(self):
         return self("station.getGenreStationsChecksum")["checksum"]
 
-    def rename_station(self, station_token, name):  # pragma: no cover
+    def rename_station(self, station_token, name):
         return self("station.renameStation",
                     stationToken=station_token,
                     stationName=name)
 
-    def explain_track(self, track_token):  # pragma: no cover
+    def explain_track(self, track_token):
         return self("track.explainTrack",
                     trackToken=track_token)
 
-    def set_quick_mix(self, *args):  # pragma: no cover
+    def set_quick_mix(self, *args):
         return self("user.setQuickMix",
                     quickMixStationIds=args)
 
-    def sleep_song(self, track_token):  # pragma: no cover
+    def sleep_song(self, track_token):
         return self("user.sleepSong",
                     trackToken=track_token)
 
-    def share_station(self, station_id, station_token, *emails):  # pragma: nc
+    def share_station(self, station_id, station_token, *emails):
         return self("station.shareStation",
                     stationId=station_id,
                     stationToken=station_token,
                     emails=emails)
 
-    def transform_shared_station(self, station_token):  # pragma: no cover
+    def transform_shared_station(self, station_token):
         return self("station.transformSharedStation",
                     stationToken=station_token)
 
-    def share_music(self, music_token, *emails):  # pragma: no cover
+    def share_music(self, music_token, *emails):
         return self("music.shareMusic",
                     musicToken=music_token,
                     email=emails[0])
@@ -282,13 +282,13 @@ class APIClient(BaseAPIClient):
         ad_item.ad_token = ad_token
         return ad_item
 
-    def get_ad_metadata(self, ad_token):  # pragma: no cover
+    def get_ad_metadata(self, ad_token):
         return self("ad.getAdMetadata",
                     adToken=ad_token,
                     returnAdTrackingTokens=True,
                     supportAudioAds=True)
 
-    def register_ad(self, station_id, tokens):  # pragma: no cover
+    def register_ad(self, station_id, tokens):
         return self("ad.registerAd",
                     stationId=station_id,
                     adTrackingTokens=tokens)
diff --git a/pandora/models/_base.py b/pandora/models/_base.py
index 5689cdf..6975d0a 100644
--- a/pandora/models/_base.py
+++ b/pandora/models/_base.py
@@ -38,7 +38,7 @@ class SyntheticField(namedtuple("SyntheticField", ["field"])):
     payload.
     """
 
-    def formatter(self, api_client, data, newval):  # pragma: no cover
+    def formatter(self, api_client, data, newval):
         """Format Value for Model
 
         The return value of this method is used as a value for the field in the
diff --git a/pandora/models/ad.py b/pandora/models/ad.py
index 040c76b..ad4b7b0 100644
--- a/pandora/models/ad.py
+++ b/pandora/models/ad.py
@@ -35,17 +35,17 @@ class AdItem(PlaylistModel):
                 raise exc
         return super().prepare_playback()
 
-    def thumbs_up(self):  # pragma: no cover
+    def thumbs_up(self):
         return
 
-    def thumbs_down(self):  # pragma: no cover
+    def thumbs_down(self):
         return
 
-    def bookmark_song(self):  # pragma: no cover
+    def bookmark_song(self):
         return
 
-    def bookmark_artist(self):  # pragma: no cover
+    def bookmark_artist(self):
         return
 
-    def sleep(self):  # pragma: no cover
+    def sleep(self):
         return
diff --git a/pandora/models/playlist.py b/pandora/models/playlist.py
index bd135db..38afb00 100644
--- a/pandora/models/playlist.py
+++ b/pandora/models/playlist.py
@@ -119,19 +119,19 @@ class PlaylistModel(PandoraModel):
         """
         return self
 
-    def thumbs_up(self):  # pragma: no cover
+    def thumbs_up(self):
         raise NotImplementedError
 
-    def thumbs_down(self):  # pragma: no cover
+    def thumbs_down(self):
         raise NotImplementedError
 
-    def bookmark_song(self):  # pragma: no cover
+    def bookmark_song(self):
         raise NotImplementedError
 
-    def bookmark_artist(self):  # pragma: no cover
+    def bookmark_artist(self):
         raise NotImplementedError
 
-    def sleep(self):  # pragma: no cover
+    def sleep(self):
         raise NotImplementedError
 
 
@@ -175,19 +175,19 @@ class PlaylistItem(PlaylistModel):
     def is_ad(self):
         return self.ad_token is not None
 
-    def thumbs_up(self):  # pragma: no cover
+    def thumbs_up(self):
         return self._api_client.add_feedback(self.track_token, True)
 
-    def thumbs_down(self):  # pragma: no cover
+    def thumbs_down(self):
         return self._api_client.add_feedback(self.track_token, False)
 
-    def bookmark_song(self):  # pragma: no cover
+    def bookmark_song(self):
         return self._api_client.add_song_bookmark(self.track_token)
 
-    def bookmark_artist(self):  # pragma: no cover
+    def bookmark_artist(self):
         return self._api_client.add_artist_bookmark(self.track_token)
 
-    def sleep(self):  # pragma: no cover
+    def sleep(self):
         return self._api_client.sleep_song(self.track_token)
 
 
diff --git a/pandora/models/search.py b/pandora/models/search.py
index 89def8e..94e6ee6 100644
--- a/pandora/models/search.py
+++ b/pandora/models/search.py
@@ -24,7 +24,7 @@ class SearchResultItem(PandoraModel):
     def is_genre_station(self):
         return isinstance(self, GenreStationSearchResultItem)
 
-    def create_station(self):  # pragma: no cover
+    def create_station(self):
         raise NotImplementedError
 
     @classmethod
diff --git a/pandora/models/station.py b/pandora/models/station.py
index d4f4846..a1880ec 100644
--- a/pandora/models/station.py
+++ b/pandora/models/station.py
@@ -104,7 +104,7 @@ class GenreStation(PandoraModel):
     token = Field("stationToken")
     category = Field("categoryName")
 
-    def get_playlist(self):  # pragma: no cover
+    def get_playlist(self):
         raise NotImplementedError("Genre stations do not have playlists. "
                                   "Create a real station using the token.")