rdelaage/librespot-python
1
0
Fork 0
mirror of https://github.com/kokarare1212/librespot-python.git synced 2024-09-27 15:01:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

Restyled by yapf

Browse Source
This commit is contained in:
Restyled.io 2021-05-21 03:50:21 +00:00
parent 80fc2bc837
commit f0f0afd28c
1 changed files with 39 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
librespot/audio/cdn/CdnManager.py
View File

@ -37,9 +37,9 @@ class CdnManager:
def get_head(self, file_id: bytes): def get_head(self, file_id: bytes):
resp = self._session.client().get( resp = self._session.client().get(
self._session.get_user_attribute( self._session.get_user_attribute(
"head-files-url", "https://heads-fa.spotify.com/head/{file_id}" "head-files-url",
).replace("{file_id}", Utils.bytes_to_hex(file_id)) "https://heads-fa.spotify.com/head/{file_id}").replace(
) "{file_id}", Utils.bytes_to_hex(file_id)))
if resp.status_code != 200: if resp.status_code != 200:
raise IOError("{}".format(resp.status_code)) raise IOError("{}".format(resp.status_code))
@ -50,9 +50,9 @@ class CdnManager:
return body return body
def stream_external_episode( def stream_external_episode(self, episode: Metadata.Episode,
self, episode: Metadata.Episode, external_url: str, halt_listener: HaltListener external_url: str,
): halt_listener: HaltListener):
return CdnManager.Streamer( return CdnManager.Streamer(
self._session, self._session,
StreamId(episode), StreamId(episode),
@ -84,8 +84,7 @@ class CdnManager:
resp = self._session.api().send( resp = self._session.api().send(
"GET", "GET",
"/storage-resolve/files/audio/interactive/{}".format( "/storage-resolve/files/audio/interactive/{}".format(
Utils.bytes_to_hex(file_id) Utils.bytes_to_hex(file_id)),
),
None, None,
None, None,
) )
@ -101,13 +100,11 @@ class CdnManager:
proto.ParseFromString(body) proto.ParseFromString(body)
if proto.result == StorageResolve.StorageResolveResponse.Result.CDN: if proto.result == StorageResolve.StorageResolveResponse.Result.CDN:
url = random.choice(proto.cdnurl) url = random.choice(proto.cdnurl)
self._LOGGER.debug( self._LOGGER.debug("Fetched CDN url for {}: {}".format(
"Fetched CDN url for {}: {}".format(Utils.bytes_to_hex(file_id), url) Utils.bytes_to_hex(file_id), url))
)
return url return url
raise CdnManager.CdnException( raise CdnManager.CdnException(
"Could not retrieve CDN url! result: {}".format(proto.result) "Could not retrieve CDN url! result: {}".format(proto.result))
)
class CdnException(Exception): class CdnException(Exception):
pass pass
@ -161,14 +158,13 @@ class CdnManager:
continue continue
if s[0][:i] == "exp": if s[0][:i] == "exp":
expire_at = int(s[0][i + 1 :]) expire_at = int(s[0][i + 1:])
break break
if expire_at is None: if expire_at is None:
self._expiration = -1 self._expiration = -1
self._cdnManager._LOGGER.warning( self._cdnManager._LOGGER.warning(
"Invalid __token__ in CDN url: {}".format(url) "Invalid __token__ in CDN url: {}".format(url))
)
return return
self._expiration = expire_at * 1000 self._expiration = expire_at * 1000
@ -178,10 +174,8 @@ class CdnManager:
except ValueError: except ValueError:
self._expiration = -1 self._expiration = -1
self._cdnManager._LOGGER.warning( self._cdnManager._LOGGER.warning(
"Couldn't extract expiration, invalid parameter in CDN url: ".format( "Couldn't extract expiration, invalid parameter in CDN url: "
url .format(url))
)
)
return return
self._expiration = int(token_url.query[:i]) * 1000 self._expiration = int(token_url.query[:i]) * 1000
@ -190,8 +184,8 @@ class CdnManager:
self._expiration = -1 self._expiration = -1
class Streamer( class Streamer(
GeneralAudioStream.GeneralAudioStream, GeneralAudioStream.GeneralAudioStream,
GeneralWritableStream.GeneralWritableStream, GeneralWritableStream.GeneralWritableStream,
): ):
_session: Session = None _session: Session = None
_streamId: StreamId = None _streamId: StreamId = None
@ -224,38 +218,39 @@ class CdnManager:
self._cdnUrl = cdn_url self._cdnUrl = cdn_url
self._haltListener = halt_listener self._haltListener = halt_listener
resp = self.request(range_start=0, range_end=ChannelManager.CHUNK_SIZE - 1) resp = self.request(range_start=0,
range_end=ChannelManager.CHUNK_SIZE - 1)
content_range = resp._headers.get("Content-Range") content_range = resp._headers.get("Content-Range")
if content_range is None: if content_range is None:
raise IOError("Missing Content-Range header!") raise IOError("Missing Content-Range header!")
split = Utils.split(content_range, "/") split = Utils.split(content_range, "/")
self._size = int(split[1]) self._size = int(split[1])
self._chunks = int(math.ceil(self._size / ChannelManager.CHUNK_SIZE)) self._chunks = int(
math.ceil(self._size / ChannelManager.CHUNK_SIZE))
first_chunk = resp._buffer first_chunk = resp._buffer
self._available = [False for _ in range(self._chunks)] self._available = [False for _ in range(self._chunks)]
self._requested = [False for _ in range(self._chunks)] self._requested = [False for _ in range(self._chunks)]
self._buffer = [bytearray() for _ in range(self._chunks)] self._buffer = [bytearray() for _ in range(self._chunks)]
self._internalStream = CdnManager.Streamer.InternalStream(self, False) self._internalStream = CdnManager.Streamer.InternalStream(
self, False)
self._requested[0] = True self._requested[0] = True
self.write_chunk(first_chunk, 0, False) self.write_chunk(first_chunk, 0, False)
def write_chunk(self, chunk: bytes, chunk_index: int, cached: bool) -> None: def write_chunk(self, chunk: bytes, chunk_index: int,
cached: bool) -> None:
if self._internalStream.is_closed(): if self._internalStream.is_closed():
return return
self._session._LOGGER.debug( self._session._LOGGER.debug(
"Chunk {}/{} completed, cached: {}, stream: {}".format( "Chunk {}/{} completed, cached: {}, stream: {}".format(
chunk_index + 1, self._chunks, cached, self.describe() chunk_index + 1, self._chunks, cached, self.describe()))
)
)
self._buffer[chunk_index] = self._audioDecrypt.decrypt_chunk( self._buffer[chunk_index] = self._audioDecrypt.decrypt_chunk(
chunk_index, chunk chunk_index, chunk)
)
self._internalStream.notify_chunk_available(chunk_index) self._internalStream.notify_chunk_available(chunk_index)
def stream(self) -> AbsChunkedInputStream: def stream(self) -> AbsChunkedInputStream:
@ -266,7 +261,8 @@ class CdnManager:
def describe(self) -> str: def describe(self) -> str:
if self._streamId.is_episode(): if self._streamId.is_episode():
return "episode_gid: {}".format(self._streamId.get_episode_gid()) return "episode_gid: {}".format(
self._streamId.get_episode_gid())
return "file_id: {}".format(self._streamId.get_file_id()) return "file_id: {}".format(self._streamId.get_file_id())
def decrypt_time_ms(self) -> int: def decrypt_time_ms(self) -> int:
@ -276,9 +272,10 @@ class CdnManager:
resp = self.request(index) resp = self.request(index)
self.write_chunk(resp._buffer, index, False) self.write_chunk(resp._buffer, index, False)
def request( def request(self,
self, chunk: int = None, range_start: int = None, range_end: int = None chunk: int = None,
) -> CdnManager.InternalResponse: range_start: int = None,
range_end: int = None) -> CdnManager.InternalResponse:
if chunk is None and range_start is None and range_end is None: if chunk is None and range_start is None and range_end is None:
raise TypeError() raise TypeError()
@ -288,7 +285,9 @@ class CdnManager:
resp = self._session.client().get( resp = self._session.client().get(
self._cdnUrl._url, self._cdnUrl._url,
headers={"Range": "bytes={}-{}".format(range_start, range_end)}, headers={
"Range": "bytes={}-{}".format(range_start, range_end)
},
) )
if resp.status_code != 206: if resp.status_code != 206:
@ -324,21 +323,16 @@ class CdnManager:
def request_chunk_from_stream(self, index: int) -> None: def request_chunk_from_stream(self, index: int) -> None:
self.streamer._executorService.submit( self.streamer._executorService.submit(
lambda: self.streamer.request_chunk(index) lambda: self.streamer.request_chunk(index))
)
def stream_read_halted(self, chunk: int, _time: int) -> None: def stream_read_halted(self, chunk: int, _time: int) -> None:
if self.streamer._haltListener is not None: if self.streamer._haltListener is not None:
self.streamer._executorService.submit( self.streamer._executorService.submit(
lambda: self.streamer._haltListener.stream_read_halted( lambda: self.streamer._haltListener.stream_read_halted(
chunk, _time chunk, _time))
)
)
def stream_read_resumed(self, chunk: int, _time: int) -> None: def stream_read_resumed(self, chunk: int, _time: int) -> None:
if self.streamer._haltListener is not None: if self.streamer._haltListener is not None:
self.streamer._executorService.submit( self.streamer._executorService.submit(
lambda: self.streamer._haltListener.stream_read_resumed( lambda: self.streamer._haltListener.
chunk, _time stream_read_resumed(chunk, _time))
)
)