sticker-convert 2.1.5__py3-none-any.whl → 2.1.7__py3-none-any.whl

sticker_convert/downloaders/download_base.py

@@ -1,21 +1,35 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 from typing import Optional, Union
 
 import requests
 
+from ..job_option import CredOption # type: ignore
+
+
 class DownloadBase:
-    def __init__(self, url: str, out_dir: str, opt_cred: Optional[dict] = None, cb_msg=print, cb_msg_block=input, cb_bar=None):
+    def __init__(
+        self,
+        url: str,
+        out_dir: str,
+        opt_cred: Optional[CredOption] = None,
+        cb_msg=print,
+        cb_msg_block=input,
+        cb_bar=None,
+    ):
         self.url = url
         self.out_dir = out_dir
         self.opt_cred = opt_cred
         self.cb_msg = cb_msg
         self.cb_msg_block = cb_msg_block
         self.cb_bar = cb_bar
-    
-    def download_multiple_files(self, targets: list[tuple[str, str]], retries: int = 3, **kwargs):
+
+    def download_multiple_files(
+        self, targets: list[tuple[str, str]], retries: int = 3, **kwargs
+    ):
         # targets format: [(url1, dest2), (url2, dest2), ...]
         if self.cb_bar:
-            self.cb_bar(set_progress_mode='determinate', steps=len(targets))
+            self.cb_bar(set_progress_mode="determinate", steps=len(targets))
 
         for url, dest in targets:
             self.download_file(url, dest, retries, show_progress=False, **kwargs)
@@ -23,39 +37,49 @@ class DownloadBase:
             if self.cb_bar:
                 self.cb_bar(update_bar=True)
 
-    def download_file(self, url: str, dest: Optional[str] = None, retries: int = 3, show_progress: bool = True, **kwargs) -> Union[bool, bytes]:
-        result = b''
+    def download_file(
+        self,
+        url: str,
+        dest: Optional[str] = None,
+        retries: int = 3,
+        show_progress: bool = True,
+        **kwargs,
+    ) -> Union[bool, bytes]:
+        result = b""
         chunk_size = 102400
 
         for retry in range(retries):
             try:
                 response = requests.get(url, stream=True, **kwargs)
-                total_length = int(response.headers.get('content-length')) # type: ignore[arg-type]
+                total_length = int(response.headers.get("content-length"))  # type: ignore[arg-type]
 
                 if response.status_code != 200:
                     return False
                 else:
-                    self.cb_msg(f'Downloading {url}')
+                    self.cb_msg(f"Downloading {url}")
 
                 if self.cb_bar and show_progress:
-                    self.cb_bar(set_progress_mode='determinate', steps=(total_length/chunk_size) + 1)
+                    self.cb_bar(
+                        set_progress_mode="determinate",
+                        steps=(total_length / chunk_size) + 1,
+                    )
 
                 for chunk in response.iter_content(chunk_size=chunk_size):
                     if chunk:
                         result += chunk
                         if self.cb_bar and show_progress:
                             self.cb_bar(update_bar=True)
-                
+
                 break
             except requests.exceptions.RequestException:
-                self.cb_msg(f'Cannot download {url} (tried {retry+1}/{retries} times)')
-        
+                self.cb_msg(f"Cannot download {url} (tried {retry+1}/{retries} times)")
+
         if not result:
             return False
         elif dest:
-            with open(dest, 'wb+') as f:
+            with open(dest, "wb+") as f:
                 f.write(result)
-            self.cb_msg(f'Downloaded {url}')
+            self.cb_msg(f"Downloaded {url}")
             return True
-        else:    
-            return result
+        else:
+            return result

sticker_convert/downloaders/download_kakao.py

@@ -1,10 +1,5 @@
 #!/usr/bin/env python3
-'''
-References:
-https://github.com/blluv/KakaoTalkEmoticonDownloader
-https://github.com/star-39/moe-sticker-bot
-'''
-
+from __future__ import annotations
 import requests
 from bs4 import BeautifulSoup
 import json
@@ -14,146 +9,95 @@ import io
 from urllib.parse import urlparse
 from typing import Optional
 
-from .download_base import DownloadBase # type: ignore
-from ..utils.metadata_handler import MetadataHandler # type: ignore
-
-class DecryptKakao:
-    @staticmethod
-    def generate_lfsr(key: str) -> list[int]:
-        d = list(key*2)
-        seq=[0,0,0]
-
-        seq[0] = 301989938
-        seq[1] = 623357073
-        seq[2] = -2004086252
-
-        i = 0
-
-        for i in range(0, 4):
-            seq[0] = ord(d[i]) | (seq[0] << 8)
-            seq[1] = ord(d[4+i]) | (seq[1] << 8)
-            seq[2] = ord(d[8+i]) | (seq[2] << 8)
-
-        seq[0] = seq[0] & 0xffffffff
-        seq[1] = seq[1] & 0xffffffff
-        seq[2] = seq[2] & 0xffffffff
-
-        return seq
+from .download_base import DownloadBase  # type: ignore
+from ..utils.files.metadata_handler import MetadataHandler  # type: ignore
+from ..utils.media.decrypt_kakao import DecryptKakao  # type: ignore
+from ..job_option import CredOption  # type: ignore
 
-    @staticmethod
-    def xor_byte(b: int, seq: list) -> int:
-        flag1=1
-        flag2=0
-        result=0
-        for _ in range(0, 8):
-            v10 = (seq[0] >> 1)
-            if (seq[0] << 31) & 0xffffffff:
-                seq[0] = (v10 ^ 0xC0000031)
-                v12 = (seq[1] >> 1)
-                if (seq[1] << 31) & 0xffffffff:
-                    seq[1] = ((v12 | 0xC0000000) ^ 0x20000010)
-                    flag1 = 1
-                else:
-                    seq[1] = (v12 & 0x3FFFFFFF)
-                    flag1 = 0
-            else:
-                seq[0] = v10
-                v11 = (seq[2] >> 1)
-                if (seq[2] << 31) & 0xffffffff:
-                    seq[2] = ((v11 | 0xF0000000) ^ 0x8000001)
-                    flag2 = 1
-                else:
-                    seq[2] = (v11 & 0xFFFFFFF)
-                    flag2 = 0
-
-            result = (flag1 ^ flag2 | 2 * result)
-        return (result ^ b)
-
-    @staticmethod
-    def xor_data(data: bytes) -> bytes:
-        dat = list(data)
-        s = DecryptKakao.generate_lfsr("a271730728cbe141e47fd9d677e9006d")
-        for i in range(0,128):
-            dat[i] = DecryptKakao.xor_byte(dat[i], s)
-        return bytes(dat)
 
 class MetadataKakao:
     @staticmethod
     def get_info_from_share_link(url: str) -> tuple[Optional[str], Optional[str]]:
-        headers = {
-            'User-Agent': 'Android'
-        }
+        headers = {"User-Agent": "Android"}
 
         response = requests.get(url, headers=headers)
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        pack_title_tag = soup.find('title')
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        pack_title_tag = soup.find("title")
         if not pack_title_tag:
             return None, None
-        
-        pack_title = pack_title_tag.string # type: ignore[union-attr]
 
-        data_url = soup.find('a', id='app_scheme_link').get('data-url') # type: ignore[union-attr]
+        pack_title = pack_title_tag.string  # type: ignore[union-attr]
+
+        data_url = soup.find("a", id="app_scheme_link").get("data-url")  # type: ignore[union-attr]
         if not data_url:
             return None, None
-        
-        item_code = data_url.replace('kakaotalk://store/emoticon/', '').split('?')[0] # type: ignore[union-attr]
+
+        item_code = data_url.replace("kakaotalk://store/emoticon/", "").split("?")[0]  # type: ignore[union-attr]
 
         return pack_title, item_code
 
     @staticmethod
-    def get_info_from_pack_title(pack_title: str) -> tuple[Optional[str], Optional[str], Optional[str]]:
-        pack_meta_r = requests.get(f'https://e.kakao.com/api/v1/items/t/{pack_title}')
+    def get_info_from_pack_title(
+        pack_title: str,
+    ) -> tuple[Optional[str], Optional[str], Optional[str]]:
+        pack_meta_r = requests.get(f"https://e.kakao.com/api/v1/items/t/{pack_title}")
 
         if pack_meta_r.status_code == 200:
             pack_meta = json.loads(pack_meta_r.text)
         else:
             return None, None, None
 
-        author = pack_meta['result']['artist']
-        title_ko = pack_meta['result']['title']
-        thumbnail_urls = pack_meta['result']['thumbnailUrls']
+        author = pack_meta["result"]["artist"]
+        title_ko = pack_meta["result"]["title"]
+        thumbnail_urls = pack_meta["result"]["thumbnailUrls"]
 
         return author, title_ko, thumbnail_urls
 
     @staticmethod
     def get_item_code(title_ko: str, auth_token: str) -> Optional[str]:
         headers = {
-            'Authorization': auth_token,
+            "Authorization": auth_token,
         }
 
-        data = {
-            'query': title_ko
-        }
+        data = {"query": title_ko}
+
+        response = requests.post(
+            "https://talk-pilsner.kakao.com/emoticon/item_store/instant_search",
+            headers=headers,
+            data=data,
+        )
 
-        response = requests.post('https://talk-pilsner.kakao.com/emoticon/item_store/instant_search', headers=headers, data=data)
-        
         if response.status_code != 200:
             return None
 
         response_json = json.loads(response.text)
-        item_code = response_json['emoticons'][0]['item_code']
+        item_code = response_json["emoticons"][0]["item_code"]
 
         return item_code
 
     @staticmethod
     def get_title_from_id(item_code: str, auth_token: str) -> Optional[str]:
         headers = {
-            'Authorization': auth_token,
+            "Authorization": auth_token,
         }
 
-        response = requests.post(f'https://talk-pilsner.kakao.com/emoticon/api/store/v3/items/{item_code}', headers=headers)
+        response = requests.post(
+            f"https://talk-pilsner.kakao.com/emoticon/api/store/v3/items/{item_code}",
+            headers=headers,
+        )
 
         if response.status_code != 200:
             return None
-        
+
         response_json = json.loads(response.text)
-        title = response_json['itemUnitInfo'][0]['title']
+        title = response_json["itemUnitInfo"][0]["title"]
         # play_path_format = response_json['itemUnitInfo'][0]['playPathFormat']
         # stickers_count = len(response_json['itemUnitInfo'][0]['sizes'])
 
         return title
 
+
 class DownloadKakao(DownloadBase):
     def __init__(self, *args, **kwargs):
         super(DownloadKakao, self).__init__(*args, **kwargs)
@@ -162,46 +106,58 @@ class DownloadKakao(DownloadBase):
 
     def download_stickers_kakao(self) -> bool:
         if self.opt_cred:
-            auth_token = self.opt_cred.get('kakao', {}).get('auth_token')
+            auth_token = self.opt_cred.kakao_auth_token
 
-        if urlparse(self.url).netloc == 'emoticon.kakao.com':
-            self.pack_title, item_code = MetadataKakao.get_info_from_share_link(self.url)
+        if urlparse(self.url).netloc == "emoticon.kakao.com":
+            self.pack_title, item_code = MetadataKakao.get_info_from_share_link(
+                self.url
+            )
 
             if item_code:
                 return self.download_animated(item_code)
             else:
-                self.cb_msg('Download failed: Cannot download metadata for sticker pack')
+                self.cb_msg(
+                    "Download failed: Cannot download metadata for sticker pack"
+                )
                 return False
 
-        elif self.url.isnumeric() or self.url.startswith('kakaotalk://store/emoticon/'):
-            item_code = self.url.replace('kakaotalk://store/emoticon/', '')
+        elif self.url.isnumeric() or self.url.startswith("kakaotalk://store/emoticon/"):
+            item_code = self.url.replace("kakaotalk://store/emoticon/", "")
 
             self.pack_title = None
             if auth_token:
-                self.pack_title = MetadataKakao.get_title_from_id(item_code, auth_token) # type: ignore[arg-type]
+                self.pack_title = MetadataKakao.get_title_from_id(item_code, auth_token)  # type: ignore[arg-type]
                 if not self.pack_title:
-                    self.cb_msg('Warning: Cannot get pack_title with auth_token.')
-                    self.cb_msg('Is auth_token invalid / expired? Try to regenerate it.')
-                    self.cb_msg('Continuing without getting pack_title')
-
-            return self.download_animated(item_code) # type: ignore[arg-type]
-
-        elif urlparse(self.url).netloc == 'e.kakao.com':
-            self.pack_title = self.url.replace('https://e.kakao.com/t/', '')
-            self.author, title_ko, thumbnail_urls = MetadataKakao.get_info_from_pack_title(self.pack_title)
+                    self.cb_msg("Warning: Cannot get pack_title with auth_token.")
+                    self.cb_msg(
+                        "Is auth_token invalid / expired? Try to regenerate it."
+                    )
+                    self.cb_msg("Continuing without getting pack_title")
+
+            return self.download_animated(item_code)  # type: ignore[arg-type]
+
+        elif urlparse(self.url).netloc == "e.kakao.com":
+            self.pack_title = self.url.replace("https://e.kakao.com/t/", "")
+            (
+                self.author,
+                title_ko,
+                thumbnail_urls,
+            ) = MetadataKakao.get_info_from_pack_title(self.pack_title)
 
             if not thumbnail_urls:
-                self.cb_msg('Download failed: Cannot download metadata for sticker pack')
+                self.cb_msg(
+                    "Download failed: Cannot download metadata for sticker pack"
+                )
                 return False
 
             if auth_token:
-                item_code = MetadataKakao.get_item_code(title_ko, auth_token) # type: ignore[arg-type]
+                item_code = MetadataKakao.get_item_code(title_ko, auth_token)  # type: ignore[arg-type]
                 if item_code:
                     return self.download_animated(item_code)
                 else:
-                    msg = 'Warning: Cannot get item code.\n'
-                    msg += 'Is auth_token invalid / expired? Try to regenerate it.\n'
-                    msg += 'Continue to download static stickers instead?'
+                    msg = "Warning: Cannot get item code.\n"
+                    msg += "Is auth_token invalid / expired? Try to regenerate it.\n"
+                    msg += "Continue to download static stickers instead?"
                     response = self.cb_msg_block(msg)
                     if response == False:
                         return False
@@ -209,66 +165,77 @@ class DownloadKakao(DownloadBase):
             return self.download_static(thumbnail_urls)
 
         else:
-            self.cb_msg('Download failed: Unrecognized URL')
+            self.cb_msg("Download failed: Unrecognized URL")
             return False
 
     def download_static(self, thumbnail_urls: str) -> bool:
-        MetadataHandler.set_metadata(self.out_dir, title=self.pack_title, author=self.author)
+        MetadataHandler.set_metadata(
+            self.out_dir, title=self.pack_title, author=self.author
+        )
 
         targets = []
 
         num = 0
         for url in thumbnail_urls:
-            dest = os.path.join(self.out_dir, str(num).zfill(3) + '.png')
+            dest = os.path.join(self.out_dir, str(num).zfill(3) + ".png")
             targets.append((url, dest))
             num += 1
 
         self.download_multiple_files(targets)
-        
+
         return True
-    
+
     def download_animated(self, item_code: str) -> bool:
-        MetadataHandler.set_metadata(self.out_dir, title=self.pack_title, author=self.author)
+        MetadataHandler.set_metadata(
+            self.out_dir, title=self.pack_title, author=self.author
+        )
 
         pack_url = f"http://item.kakaocdn.net/dw/{item_code}.file_pack.zip"
 
         zip_file = self.download_file(pack_url)
         if zip_file:
-            self.cb_msg(f'Downloaded {pack_url}')
+            self.cb_msg(f"Downloaded {pack_url}")
         else:
-            self.cb_msg(f'Cannot download {pack_url}')
+            self.cb_msg(f"Cannot download {pack_url}")
             return False
-                
+
         num = 0
         with zipfile.ZipFile(io.BytesIO(zip_file)) as zf:
-            self.cb_msg('Unzipping...')
+            self.cb_msg("Unzipping...")
             if self.cb_bar:
-                self.cb_bar(set_progress_mode='determinate', steps=len(zf.namelist()))
+                self.cb_bar(set_progress_mode="determinate", steps=len(zf.namelist()))
 
             for f_path in sorted(zf.namelist()):
                 _, ext = os.path.splitext(f_path)
 
-                if ext in ('.gif', '.webp'):
+                if ext in (".gif", ".webp"):
                     data = DecryptKakao.xor_data(zf.read(f_path))
-                    self.cb_msg(f'Decrypted {f_path}')
+                    self.cb_msg(f"Decrypted {f_path}")
                 else:
                     data = zf.read(f_path)
-                    self.cb_msg(f'Read {f_path}')
-                
+                    self.cb_msg(f"Read {f_path}")
+
                 out_path = os.path.join(self.out_dir, str(num).zfill(3) + ext)
-                with open(out_path, 'wb') as f:
+                with open(out_path, "wb") as f:
                     f.write(data)
-                
+
                 if self.cb_bar:
                     self.cb_bar(update_bar=True)
 
                 num += 1
 
-        self.cb_msg(f'Finished getting {pack_url}')
-        
+        self.cb_msg(f"Finished getting {pack_url}")
+
         return True
 
     @staticmethod
-    def start(url: str, out_dir: str, opt_cred: Optional[dict] = None, cb_msg=print, cb_msg_block=input, cb_bar=None) -> bool:
+    def start(
+        url: str,
+        out_dir: str,
+        opt_cred: Optional[CredOption] = None,
+        cb_msg=print,
+        cb_msg_block=input,
+        cb_bar=None,
+    ) -> bool:
         downloader = DownloadKakao(url, out_dir, opt_cred, cb_msg, cb_msg_block, cb_bar)
-        return downloader.download_stickers_kakao()
+        return downloader.download_stickers_kakao()

sticker_convert/downloaders/download_line.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 '''Reference: https://github.com/doubleplusc/Line-sticker-downloader/blob/master/sticker_dl.py'''
 
 import requests
@@ -13,9 +14,11 @@ from bs4 import BeautifulSoup
 from typing import Optional
 
 from .download_base import DownloadBase # type: ignore
-from ..auth.get_line_auth import GetLineAuth # type: ignore
-from ..utils.metadata_handler import MetadataHandler # type: ignore
-from ..utils.apple_png_normalize import ApplePngNormalize # type: ignore
+from ..utils.auth.get_line_auth import GetLineAuth # type: ignore
+from ..utils.files.metadata_handler import MetadataHandler # type: ignore
+from ..utils.media.apple_png_normalize import ApplePngNormalize # type: ignore
+from ..job_option import CredOption  # type: ignore
+
 
 class MetadataLine:
     @staticmethod
@@ -142,17 +145,25 @@ class DownloadLine(DownloadBase):
 
     def load_cookies(self) -> dict[str, str]:
         cookies = {}
-        if self.opt_cred and self.opt_cred.get('line', {}).get('cookies'):
+        if self.opt_cred and self.opt_cred.line_cookies:
+            line_cookies = self.opt_cred.line_cookies
+
             try:
-                for i in self.opt_cred['line']['cookies'].split(';'):
-                    c_key, c_value = i.split('=')
-                    cookies[c_key] = c_value
-                if not GetLineAuth.validate_cookies(cookies):
+                line_cookies_dict = json.loads(line_cookies)
+                for c in line_cookies_dict:
+                    cookies[c['name']] = c['value']
+            except json.decoder.JSONDecodeError:
+                try:
+                    for i in line_cookies.split(';'):
+                        c_key, c_value = i.split('=')
+                        cookies[c_key] = c_value
+                except ValueError:
                     self.cb_msg('Warning: Line cookies invalid, you will not be able to add text to "Custom stickers"')
-                    cookies = {}
-            except ValueError:
-                self.cb_msg('Warning: Line cookies invalid, you will not be able to add text to "Custom stickers"')
         
+            if not GetLineAuth.validate_cookies(cookies):
+                self.cb_msg('Warning: Line cookies invalid, you will not be able to add text to "Custom stickers"')
+                cookies = {}
+
         return cookies
 
     def get_pack_url(self) -> str:
@@ -372,6 +383,13 @@ class DownloadLine(DownloadBase):
         return True
 
     @staticmethod
-    def start(url: str, out_dir: str, opt_cred: Optional[dict] = None, cb_msg=print, cb_msg_block=input, cb_bar=None) -> bool:
+    def start(
+        url: str,
+        out_dir: str,
+        opt_cred: Optional[CredOption] = None,
+        cb_msg=print,
+        cb_msg_block=input,
+        cb_bar=None,
+    ) -> bool:
         downloader = DownloadLine(url, out_dir, opt_cred, cb_msg, cb_msg_block, cb_bar)
         return downloader.download_stickers_line()

sticker_convert/downloaders/download_signal.py

@@ -3,71 +3,87 @@ import os
 from typing import Optional
 
 import anyio
-from signalstickers_client import StickersClient # type: ignore
-from signalstickers_client.models import StickerPack # type: ignore
+from signalstickers_client import StickersClient  # type: ignore
+from signalstickers_client.models import StickerPack  # type: ignore
+
+from .download_base import DownloadBase  # type: ignore
+from ..utils.files.metadata_handler import MetadataHandler  # type: ignore
+from ..utils.media.codec_info import CodecInfo  # type: ignore
+from ..job_option import CredOption  # type: ignore
 
-from .download_base import DownloadBase # type: ignore
-from ..utils.metadata_handler import MetadataHandler # type: ignore
-from ..utils.codec_info import CodecInfo # type: ignore
 
 class DownloadSignal(DownloadBase):
     def __init__(self, *args, **kwargs):
         super(DownloadSignal, self).__init__(*args, **kwargs)
-        
+
     @staticmethod
     async def get_pack(pack_id: str, pack_key: str) -> StickerPack:
         async with StickersClient() as client:
             pack = await client.get_pack(pack_id, pack_key)
-        
+
         return pack
 
     def save_stickers(self, pack: StickerPack):
         if self.cb_bar:
-            self.cb_bar(set_progress_mode='determinate', steps=len(pack.stickers))
+            self.cb_bar(set_progress_mode="determinate", steps=len(pack.stickers))
 
         emoji_dict = {}
         for sticker in pack.stickers:
             f_id = str(sticker.id).zfill(3)
-            f_path = os.path.join(self.out_dir, f'{f_id}')
-            with open(f_path, "wb",) as f:
+            f_path = os.path.join(self.out_dir, f"{f_id}")
+            with open(
+                f_path,
+                "wb",
+            ) as f:
                 f.write(sticker.image_data)
 
             emoji_dict[f_id] = sticker.emoji
 
             codec = CodecInfo.get_file_codec(f_path)
-            if 'apng' in codec:
-                f_path_new = f_path + '.apng'
-            elif 'png' in codec:
-                f_path_new = f_path + '.png'
-            elif 'webp' in codec:
-                f_path_new = f_path + '.webp'
+            if "apng" in codec:
+                f_path_new = f_path + ".apng"
+            elif "png" in codec:
+                f_path_new = f_path + ".png"
+            elif "webp" in codec:
+                f_path_new = f_path + ".webp"
             else:
-                self.cb_msg(f'Unknown codec {codec}, defaulting to webp')
-                codec = 'webp'
-                f_path_new = f_path + '.webp'
-            
+                self.cb_msg(f"Unknown codec {codec}, defaulting to webp")
+                codec = "webp"
+                f_path_new = f_path + ".webp"
+
             os.rename(f_path, f_path_new)
-            
-            self.cb_msg(f'Downloaded {f_id}.{codec}')
+
+            self.cb_msg(f"Downloaded {f_id}.{codec}")
             if self.cb_bar:
                 self.cb_bar(update_bar=True)
-        
-        MetadataHandler.set_metadata(self.out_dir, title=pack.title, author=pack.author, emoji_dict=emoji_dict)
+
+        MetadataHandler.set_metadata(
+            self.out_dir, title=pack.title, author=pack.author, emoji_dict=emoji_dict
+        )
 
     def download_stickers_signal(self) -> bool:
-        if 'signal.art' not in self.url:
-            self.cb_msg('Download failed: Unrecognized URL format')
+        if "signal.art" not in self.url:
+            self.cb_msg("Download failed: Unrecognized URL format")
             return False
 
-        pack_id = self.url.split('#pack_id=')[1].split('&pack_key=')[0]
-        pack_key = self.url.split('&pack_key=')[1]
+        pack_id = self.url.split("#pack_id=")[1].split("&pack_key=")[0]
+        pack_key = self.url.split("&pack_key=")[1]
 
         pack = anyio.run(DownloadSignal.get_pack, pack_id, pack_key)
         self.save_stickers(pack)
 
         return True
-    
+
     @staticmethod
-    def start(url: str, out_dir: str, opt_cred: Optional[dict] = None, cb_msg=print, cb_msg_block=input, cb_bar=None) -> bool:
-        downloader = DownloadSignal(url, out_dir, opt_cred, cb_msg, cb_msg_block, cb_bar)
-        return downloader.download_stickers_signal()
+    def start(
+        url: str,
+        out_dir: str,
+        opt_cred: Optional[CredOption] = None,
+        cb_msg=print,
+        cb_msg_block=input,
+        cb_bar=None,
+    ) -> bool:
+        downloader = DownloadSignal(
+            url, out_dir, opt_cred, cb_msg, cb_msg_block, cb_bar
+        )
+        return downloader.download_stickers_signal()