used black

bot/modules/soundcloud/__init__.py

@@ -7,4 +7,4 @@ soundcloud = SoundCloud(
     client_id=config.tokens.soundcloud.client_id,
 )
 
-__all__ = ['soundcloud', 'SoundCloudBytestream']
+__all__ = ["soundcloud", "SoundCloudBytestream"]

bot/modules/soundcloud/downloader.py

@@ -15,18 +15,9 @@ class SoundCloudBytestream:
     song: SongItem
 
     @classmethod
-    def from_bytes(
-            cls,
-            bytes_: bytes,
-            filename: str,
-            duration: int,
-            song: SongItem
-    ):
+    def from_bytes(cls, bytes_: bytes, filename: str, duration: int, song: SongItem):
         return cls(
-            file=bytes_,
-            filename=filename,
-            duration=int(duration / 1000),
-            song=song
+            file=bytes_, filename=filename, duration=int(duration / 1000), song=song
         )
 
 
@@ -40,60 +31,53 @@ class Downloader:
     song: SongItem
 
     @classmethod
-    async def build(
-            cls,
-            song_id: str,
-            driver: SoundCloudDriver
-    ):
+    async def build(cls, song_id: str, driver: SoundCloudDriver):
         track = await driver.get_track(song_id)
         song = SongItem.from_soundcloud(track)
 
-        if url := cls._try_get_progressive(track['media']['transcodings']):
+        if url := cls._try_get_progressive(track["media"]["transcodings"]):
             method = cls._progressive
         else:
-            url = track['media']['transcodings'][0]['url']
-            method = cls._hls if \
-                (track['media']['transcodings'][0]['format']['protocol']
-                 == 'hls') else cls._progressive
+            url = track["media"]["transcodings"][0]["url"]
+            method = (
+                cls._hls
+                if (track["media"]["transcodings"][0]["format"]["protocol"] == "hls")
+                else cls._progressive
+            )
 
         return cls(
             driver=driver,
-            duration=track['duration'],
+            duration=track["duration"],
             method=method,
             download_url=url,
             filename=f'{track["title"]}.mp3',
-            song=song
+            song=song,
         )
 
     @staticmethod
     def _try_get_progressive(urls: list) -> str | None:
         for transcode in urls:
-            if transcode['format']['protocol'] == 'progressive':
-                return transcode['url']
+            if transcode["format"]["protocol"] == "progressive":
+                return transcode["url"]
 
     async def _progressive(self, url: str) -> bytes:
         return await self.driver.engine.read_data(
-            url=(await self.driver.engine.get(
-                url
-            ))['url']
+            url=(await self.driver.engine.get(url))["url"]
         )
 
     async def _hls(self, url: str) -> bytes:
         m3u8_obj = m3u8.loads(
-            (await self.driver.engine.read_data(
-                (await self.driver.engine.get(
-                    url=url
-                ))['url']
-            )).decode()
+            (
+                await self.driver.engine.read_data(
+                    (await self.driver.engine.get(url=url))["url"]
+                )
+            ).decode()
         )
 
         content = bytearray()
         for segment in m3u8_obj.files:
             content.extend(
-                await self.driver.engine.read_data(
-                    url=segment,
-                    append_client_id=False
-                )
+                await self.driver.engine.read_data(url=segment, append_client_id=False)
             )
 
         return content
@@ -103,7 +87,7 @@ class Downloader:
             bytes_=await self.method(self, self.download_url),
             filename=self.filename,
             duration=self.duration,
-            song=self.song
+            song=self.song,
         )
 
 
@@ -112,7 +96,4 @@ class DownloaderBuilder:
     driver: SoundCloudDriver
 
     async def from_id(self, song_id: str):
-        return await Downloader.build(
-            song_id=song_id,
-            driver=self.driver
-        )
+        return await Downloader.build(song_id=song_id, driver=self.driver)

bot/modules/soundcloud/driver.py

@@ -8,23 +8,12 @@ class SoundCloudDriver:
     engine: SoundCloudEngine
 
     async def get_track(self, track_id: int | str):
-        return await self.engine.call(
-            f'tracks/{track_id}'
-        )
+        return await self.engine.call(f"tracks/{track_id}")
 
     async def search(self, query: str, limit: int = 30):
-        return (await self.engine.call(
-            'search/tracks',
-            params={
-                'q': query,
-                'limit': limit
-            }
-        ))['collection']
+        return (
+            await self.engine.call("search/tracks", params={"q": query, "limit": limit})
+        )["collection"]
 
     async def resolve_url(self, url: str):
-        return await self.engine.call(
-            'resolve',
-            params={
-                'url': url
-            }
-        )
+        return await self.engine.call("resolve", params={"url": url})

bot/modules/soundcloud/engine.py

@@ -8,27 +8,33 @@ class SoundCloudEngine:
 
     async def call(self, request_point: str, params: dict = None):
         return await self.get(
-            url=f'https://api-v2.soundcloud.com/{request_point}',
-            params=params
+            url=f"https://api-v2.soundcloud.com/{request_point}", params=params
         )
 
     async def get(self, url: str, params: dict = None):
         async with aiohttp.ClientSession() as session:
             async with session.get(
-                    url,
-                    params=(params or {}) | {
-                        'client_id': self.client_id,
-                    },
+                url,
+                params=(params or {})
+                | {
+                    "client_id": self.client_id,
+                },
             ) as r:
                 return await r.json()
 
-    async def read_data(self, url: str, params: dict = None,
-                        append_client_id: bool = True):
+    async def read_data(
+        self, url: str, params: dict = None, append_client_id: bool = True
+    ):
         async with aiohttp.ClientSession() as session:
             async with session.get(
-                    url,
-                    params=(params or {}) | ({
-                        'client_id': self.client_id,
-                    } if append_client_id else {}),
+                url,
+                params=(params or {})
+                | (
+                    {
+                        "client_id": self.client_id,
+                    }
+                    if append_client_id
+                    else {}
+                ),
             ) as r:
                 return await r.content.read()

bot/modules/soundcloud/song.py

@@ -9,13 +9,15 @@ class SongItem(BaseSongItem):
     @classmethod
     def from_soundcloud(cls, song_item: dict):
         return cls(
-            name=song_item['title'],
-            id=str(song_item['id']),
+            name=song_item["title"],
+            id=str(song_item["id"]),
             artists=[],
-            thumbnail=(song_item['artwork_url'] or song_item['user']['avatar_url'] or
-                       'https://soundcloud.com/images/default_avatar_large.png')
-            .replace('large.jpg', 't300x300.jpg'),
-            preview_url=None
+            thumbnail=(
+                song_item["artwork_url"]
+                or song_item["user"]["avatar_url"]
+                or "https://soundcloud.com/images/default_avatar_large.png"
+            ).replace("large.jpg", "t300x300.jpg"),
+            preview_url=None,
         )
 
     @property