Merge pull request #104 from kokarare1212/deepsource-fix-1466be2d

Refactor unnecessary `else` / `elif` when `if` block has a `return` statement

librespot/audio/__init__.py

@@ -169,33 +169,31 @@ class AbsChunkedInputStream(io.BytesIO, HaltListener):
             buffer.seek(0)
             self.__pos += buffer.getbuffer().nbytes
             return buffer.read()
-        else:
+        buffer = io.BytesIO()
-            buffer = io.BytesIO()
+        chunk = int(self.__pos / (128 * 1024))
-            chunk = int(self.__pos / (128 * 1024))
+        chunk_off = int(self.__pos % (128 * 1024))
-            chunk_off = int(self.__pos % (128 * 1024))
+        chunk_end = int(__size / (128 * 1024))
-            chunk_end = int(__size / (128 * 1024))
+        chunk_end_off = int(__size % (128 * 1024))
-            chunk_end_off = int(__size % (128 * 1024))
+        if chunk_end > self.size():
-            if chunk_end > self.size():
+            chunk_end = int(self.size() / (128 * 1024))
-                chunk_end = int(self.size() / (128 * 1024))
+            chunk_end_off = int(self.size() % (128 * 1024))
-                chunk_end_off = int(self.size() % (128 * 1024))
+        if chunk_off + __size > len(self.buffer()[chunk]):
-            if chunk_off + __size > len(self.buffer()[chunk]):
+            self.check_availability(chunk, True, False)
+            buffer.write(self.buffer()[chunk][chunk_off:])
+            chunk += 1
+            while chunk <= chunk_end:
                 self.check_availability(chunk, True, False)
-                buffer.write(self.buffer()[chunk][chunk_off:])
+                if chunk == chunk_end:
+                    buffer.write(self.buffer()[chunk][:chunk_end_off])
+                else:
+                    buffer.write(self.buffer()[chunk])
                 chunk += 1
-                while chunk <= chunk_end:
+        else:
-                    self.check_availability(chunk, True, False)
+            self.check_availability(chunk, True, False)
-                    if chunk == chunk_end:
+            buffer.write(self.buffer()[chunk][chunk_off:chunk_off + __size])
-                        buffer.write(self.buffer()[chunk][:chunk_end_off])
+        buffer.seek(0)
-                    else:
+        self.__pos += buffer.getbuffer().nbytes
-                        buffer.write(self.buffer()[chunk])
+        return buffer.read()
-                    chunk += 1
-            else:
-                self.check_availability(chunk, True, False)
-                buffer.write(self.buffer()[chunk][chunk_off:chunk_off +
-                                                  __size])
-            buffer.seek(0)
-            self.__pos += buffer.getbuffer().nbytes
-            return buffer.read()
 
     def notify_chunk_available(self, index: int) -> None:
         self.available_chunks()[index] = True
@@ -718,11 +716,10 @@ class PlayableContentFeeder:
         if type(playable_id) is TrackId:
             return self.load_track(playable_id, audio_quality_picker, preload,
                                    halt_listener)
-        elif type(playable_id) is EpisodeId:
+        if type(playable_id) is EpisodeId:
             return self.load_episode(playable_id, audio_quality_picker,
                                      preload, halt_listener)
-        else:
+        raise TypeError("Unknown content: {}".format(playable_id))
-            raise TypeError("Unknown content: {}".format(playable_id))
 
     def load_stream(self, file: Metadata.AudioFile, track: Metadata.Track,
                     episode: Metadata.Episode, preload: bool,
@@ -736,7 +733,7 @@ class PlayableContentFeeder:
                                                 response, preload, halt_lister)
             return CdnFeedHelper.load_episode(self.__session, episode, file,
                                               response, preload, halt_lister)
-        elif response.result == StorageResolve.StorageResolveResponse.Result.STORAGE:
+        if response.result == StorageResolve.StorageResolveResponse.Result.STORAGE:
             if track is None:
                 pass
         elif response.result == StorageResolve.StorageResolveResponse.Result.RESTRICTED:
@@ -753,14 +750,12 @@ class PlayableContentFeeder:
         if episode.external_url:
             return CdnFeedHelper.load_episode_external(self.__session, episode,
                                                        halt_listener)
-        else:
+        file = audio_quality_picker.get_file(episode.audio)
-            file = audio_quality_picker.get_file(episode.audio)
+        if file is None:
-            if file is None:
+            self.logger.fatal(
-                self.logger.fatal(
+                "Couldn't find any suitable audio file, available: {}".format(
-                    "Couldn't find any suitable audio file, available: {}".
+                    episode.audio))
-                    format(episode.audio))
+        return self.load_stream(file, None, episode, preload, halt_listener)
-            return self.load_stream(file, None, episode, preload,
-                                    halt_listener)
 
     def load_track(self, track_id_or_track: typing.Union[TrackId,
                                                          Metadata.Track],

librespot/core.py

@@ -563,14 +563,13 @@ class MessageType(enum.Enum):
     def parse(_typ: str):
         if _typ == MessageType.MESSAGE.value:
             return MessageType.MESSAGE
-        elif _typ == MessageType.PING.value:
+        if _typ == MessageType.PING.value:
             return MessageType.PING
-        elif _typ == MessageType.PONG.value:
+        if _typ == MessageType.PONG.value:
             return MessageType.PONG
-        elif _typ == MessageType.REQUEST.value:
+        if _typ == MessageType.REQUEST.value:
             return MessageType.REQUEST
-        else:
+        raise TypeError("Unknown MessageType: {}".format(_typ))
-            raise TypeError("Unknown MessageType: {}".format(_typ))
 
 
 class Session(Closeable, MessageListener, SubListener):

librespot/metadata.py

@@ -38,10 +38,9 @@ class PlayableId:
             return UnsupportedId(uri)
         if TrackId.pattern.search(uri) is not None:
             return TrackId.from_uri(uri)
-        elif EpisodeId.pattern.search(uri) is not None:
+        if EpisodeId.pattern.search(uri) is not None:
             return EpisodeId.from_uri(uri)
-        else:
+        raise TypeError("Unknown uri: {}".format(uri))
-            raise TypeError("Unknown uri: {}".format(uri))
 
     @staticmethod
     def is_supported(uri: str):