sticker-convert 2.10.8__py3-none-any.whl → 2.11.0__py3-none-any.whl

sticker_convert/cli.py

@@ -20,6 +20,7 @@ from sticker_convert.utils.auth.get_kakao_desktop_auth import GetKakaoDesktopAut
 from sticker_convert.utils.auth.get_line_auth import GetLineAuth
 from sticker_convert.utils.auth.get_signal_auth import GetSignalAuth
 from sticker_convert.utils.auth.get_viber_auth import GetViberAuth
+from sticker_convert.utils.auth.telethon_setup import TelethonSetup
 from sticker_convert.utils.callback import Callback
 from sticker_convert.utils.files.json_manager import JsonManager
 from sticker_convert.utils.url_detect import UrlDetect
@@ -168,10 +169,12 @@ class CLI:
         parser_cred = parser.add_argument_group("Credentials options")
         flags_cred_bool = (
             "signal_get_auth",
+            "telethon_setup",
             "kakao_get_auth",
             "kakao_get_auth_desktop",
             "line_get_auth",
             "discord_get_auth",
+            "save_cred",
         )
         for k, v in self.help["cred"].items():
             keyword_args = {}
@@ -226,6 +229,7 @@ class CLI:
             "signal": args.download_signal,
             "line": args.download_line,
             "telegram": args.download_telegram,
+            "telegram_telethon": args.download_telegram_telethon,
             "kakao": args.download_kakao,
             "viber": args.download_viber,
             "discord": args.download_discord,
@@ -266,6 +270,14 @@ class CLI:
             export_option = "signal"
         elif args.export_telegram:
             export_option = "telegram"
+        elif args.export_telegram_emoji:
+            export_option = "telegram_emoji"
+        elif args.export_telegram_telethon:
+            export_option = "telegram_telethon"
+        elif args.export_telegram_emoji_telethon:
+            export_option = "telegram_emoji_telethon"
+        elif args.export_viber:
+            export_option = "viber"
         elif args.export_imessage:
             export_option = "imessage"
         else:
@@ -291,6 +303,10 @@ class CLI:
                         args.export_whatsapp,
                         args.export_signal,
                         args.export_telegram,
+                        args.export_telegram_emoji,
+                        args.export_telegram_telethon,
+                        args.export_telegram_emoji_telethon,
+                        args.export_viber,
                         args.export_imessage,
                     )
                 )
@@ -302,8 +318,12 @@ class CLI:
                 preset = "whatsapp"
             elif args.export_signal:
                 preset = "signal"
-            elif args.export_telegram:
+            elif args.export_telegram or args.export_telegram_telethon:
                 preset = "telegram"
+            elif args.export_telegram_emoji or args.export_telegram_emoji_telethon:
+                preset = "telegram_emoji"
+            elif args.export_viber:
+                preset = "viber"
             elif args.export_imessage:
                 preset = "imessage_small"
         elif args.preset == "auto":
@@ -316,6 +336,12 @@ class CLI:
                 self.cb.msg(
                     "Auto compression option set to no_compress (Reason: Export to local directory only)"
                 )
+            elif "telegram_emoji" in output_option:
+                preset = "telegram_emoji"
+                self.cb.msg(f"Auto compression option set to {preset}")
+            elif "telegram" in output_option:
+                preset = "telegram"
+                self.cb.msg(f"Auto compression option set to {preset}")
             elif output_option == "imessage":
                 preset = "imessage_small"
                 self.cb.msg(f"Auto compression option set to {preset}")
@@ -445,6 +471,8 @@ class CLI:
             telegram_userid=args.telegram_userid
             if args.telegram_userid
             else creds.get("telegram", {}).get("userid"),
+            telethon_api_id=creds.get("telethon", {}).get("api_id"),
+            telethon_api_hash=creds.get("telethon", {}).get("api_hash"),
             kakao_auth_token=args.kakao_auth_token
             if args.kakao_auth_token
             else creds.get("kakao", {}).get("auth_token"),
@@ -511,6 +539,16 @@ class CLI:
 
             self.cb.msg("Failed to get uuid and password")
 
+        if args.telethon_setup:
+            telethon_setup = TelethonSetup(opt_cred, self.cb.ask_str)
+            success, _, telethon_api_id, telethon_api_hash = telethon_setup.start()
+
+            if success:
+                opt_cred.telethon_api_id = telethon_api_id
+                opt_cred.telethon_api_hash = telethon_api_hash
+
+                self.cb.msg("Telethon setup successful")
+
         if args.line_get_auth:
             get_line_auth = GetLineAuth()
 

sticker_convert/converter.py

@@ -434,7 +434,7 @@ class StickerConvert:
                 # Pillow is not reliable for getting webp frame durations
                 durations: Optional[List[int]]
                 if im.format == "WEBP":
-                    _, _, _, durations = CodecInfo._get_file_fps_frames_duration_webp(
+                    _, _, _, durations = CodecInfo._get_file_fps_frames_duration_webp(  # type: ignore
                         self.in_f
                     )
                 else:
@@ -702,9 +702,9 @@ class StickerConvert:
                 self._frames_export_apng()
             else:
                 self._frames_export_png()
-        elif self.out_f.suffix == ".gif":
+        elif self.out_f.suffix in (".gif", ".webp"):
             self._frames_export_pil_anim()
-        elif self.out_f.suffix in (".webm", ".mp4", ".mkv", ".webp") or is_animated:
+        elif self.out_f.suffix in (".webm", ".mp4", ".mkv") or is_animated:
             self._frames_export_pyav()
         else:
             self._frames_export_pil()
@@ -764,7 +764,7 @@ class StickerConvert:
             format=self.out_f.suffix.replace(".", ""),
             options=options_container,
         ) as output:
-            out_stream = output.add_stream(codec, rate=self.fps, options=options_stream)
+            out_stream = output.add_stream(codec, rate=self.fps, options=options_stream)  # type: ignore
             out_stream = cast(VideoStream, out_stream)
             assert isinstance(self.res_w, int) and isinstance(self.res_h, int)
             out_stream.width = self.res_w
@@ -811,8 +811,12 @@ class StickerConvert:
         elif self.out_f.suffix == ".webp":
             im_out = [Image.fromarray(i) for i in self.frames_processed]  # type: ignore
             extra_kwargs["format"] = "WebP"
-            extra_kwargs["minimize_size"] = True
-            extra_kwargs["method"] = 6
+            extra_kwargs["allow_mixed"] = True
+            if self.quality:
+                if self.quality < 20:
+                    extra_kwargs["minimize_size"] = True
+                extra_kwargs["method"] = 4 + int(2 * (100 - self.quality) / 100)
+                extra_kwargs["alpha_quality"] = self.quality
         else:
             raise RuntimeError(f"Invalid format {self.out_f.suffix}")
 

sticker_convert/downloaders/download_base.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from functools import partial
 from pathlib import Path
-from typing import Any, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import anyio
 import httpx
@@ -34,18 +34,26 @@ class DownloadBase:
         retries: int = 3,
         headers: Optional[dict[Any, Any]] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Dict[str, bool]:
+        results: Dict[str, bool] = {}
         anyio.run(
             partial(
-                self.download_multiple_files_async, targets, retries, headers, **kwargs
+                self.download_multiple_files_async,
+                targets,
+                retries,
+                headers,
+                results,
+                **kwargs,
             )
         )
+        return results
 
     async def download_multiple_files_async(
         self,
         targets: List[Tuple[str, Path]],
         retries: int = 3,
         headers: Optional[dict[Any, Any]] = None,
+        results: Optional[dict[str, bool]] = None,
         **kwargs: Any,
     ) -> None:
         # targets format: [(url1, dest2), (url2, dest2), ...]
@@ -53,44 +61,56 @@ class DownloadBase:
             ("bar", None, {"set_progress_mode": "determinate", "steps": len(targets)})
         )
 
+        semaphore = anyio.Semaphore(4)
+
         async with httpx.AsyncClient() as client:
             async with anyio.create_task_group() as tg:
                 for url, dest in targets:
                     tg.start_soon(
                         self.download_file_async,
+                        semaphore,
                         client,
                         url,
                         dest,
                         retries,
                         headers,
+                        results,
                         **kwargs,
                     )
 
     async def download_file_async(
         self,
+        semaphore: anyio.Semaphore,
         client: httpx.AsyncClient,
         url: str,
         dest: Path,
         retries: int = 3,
         headers: Optional[dict[Any, Any]] = None,
+        results: Optional[dict[str, bool]] = None,
         **kwargs: Any,
     ) -> None:
-        self.cb.put(f"Downloading {url}")
-        for retry in range(retries):
-            response = await client.get(
-                url, follow_redirects=True, headers=headers, **kwargs
-            )
-
-            if response.is_success:
-                async with await anyio.open_file(dest, "wb+") as f:
-                    await f.write(response.content)
-                self.cb.put(f"Downloaded {url}")
-            else:
-                self.cb.put(
-                    f"Error {response.status_code}: {url} (tried {retry+1}/{retries} times)"
+        async with semaphore:
+            self.cb.put(f"Downloading {url}")
+            success = False
+            for retry in range(retries):
+                response = await client.get(
+                    url, follow_redirects=True, headers=headers, **kwargs
                 )
+                success = response.is_success
+
+                if success:
+                    async with await anyio.open_file(dest, "wb+") as f:
+                        await f.write(response.content)
+                    self.cb.put(f"Downloaded {url}")
+                else:
+                    self.cb.put(
+                        f"Error {response.status_code}: {url} (tried {retry+1}/{retries} times)"
+                    )
+
+            if results is not None:
+                results[url] = success
 
-        self.cb.put("update_bar")
+            self.cb.put("update_bar")
 
     def download_file(
         self,

sticker_convert/downloaders/download_discord.py

@@ -21,10 +21,10 @@ class DownloadDiscord(DownloadBase):
     # def __init__(self, *args: Any, **kwargs: Any) -> None:
     #     super().__init__(*args, **kwargs)
 
-    def download_stickers_discord(self) -> bool:
+    def download_stickers_discord(self) -> Tuple[int, int]:
         if self.opt_cred is None or self.opt_cred.discord_token == "":
             self.cb.put("Error: Downloading from Discord requires token")
-            return False
+            return 0, 0
 
         gid: Optional[str] = None
         if self.url.isnumeric():
@@ -36,7 +36,7 @@ class DownloadDiscord(DownloadBase):
 
         if gid is None or gid.isnumeric() is False:
             self.cb.put("Error: Invalid url")
-            return False
+            return 0, 0
 
         headers = {
             "Authorization": self.opt_cred.discord_token,
@@ -68,7 +68,7 @@ class DownloadDiscord(DownloadBase):
             f_path = Path(self.out_dir, f_name)
             targets.append((sticker_url, f_path))
 
-        self.download_multiple_files(targets)
+        results = self.download_multiple_files(targets)
 
         server_name = r_json["name"]
         MetadataHandler.set_metadata(
@@ -78,7 +78,7 @@ class DownloadDiscord(DownloadBase):
             emoji_dict=emoji_dict if self.input_option == "discord" else None,
         )
 
-        return True
+        return sum(results.values()), len(targets)
 
     @staticmethod
     def start(
@@ -86,6 +86,6 @@ class DownloadDiscord(DownloadBase):
         opt_cred: Optional[CredOption],
         cb: CallbackProtocol,
         cb_return: CallbackReturn,
-    ) -> bool:
+    ) -> Tuple[int, int]:
         downloader = DownloadDiscord(opt_input, opt_cred, cb, cb_return)
         return downloader.download_stickers_discord()

sticker_convert/downloaders/download_kakao.py

@@ -34,6 +34,11 @@ class daumtools {
         return dataDict['urlScheme'];
     }
 }
+class document {
+    static querySelectorAll(selectors) {
+        return [];
+    }
+}
 """
 
 
@@ -133,9 +138,21 @@ class DownloadKakao(DownloadBase):
         kakao_url = cast(str, ctx.eval(js))
         item_code = urlparse(kakao_url).path.split("/")[2]
 
+        # Share link redirect to preview link if use desktop headers
+        # This allows us to find pack author
+        headers_desktop = {"User-Agent": "Chrome"}
+
+        response = requests.get(url, headers=headers_desktop, allow_redirects=True)
+        response.url
+
+        pack_title_url = urlparse(response.url).path.split("/")[-1]
+        pack_info_unauthed = MetadataKakao.get_pack_info_unauthed(pack_title_url)
+        if pack_info_unauthed:
+            self.author = pack_info_unauthed["result"]["artist"]
+
         return pack_title, item_code
 
-    def download_stickers_kakao(self) -> bool:
+    def download_stickers_kakao(self) -> Tuple[int, int]:
         self.auth_token = None
         if self.opt_cred:
             self.auth_token = self.opt_cred.kakao_auth_token
@@ -146,7 +163,7 @@ class DownloadKakao(DownloadBase):
             if item_code:
                 return self.download_animated(item_code)
             self.cb.put("Download failed: Cannot download metadata for sticker pack")
-            return False
+            return 0, 0
 
         if self.url.isnumeric() or self.url.startswith("kakaotalk://store/emoticon/"):
             item_code = self.url.replace("kakaotalk://store/emoticon/", "")
@@ -177,7 +194,7 @@ class DownloadKakao(DownloadBase):
                 self.cb.put(
                     "Download failed: Cannot download metadata for sticker pack"
                 )
-                return False
+                return 0, 0
 
             self.author = self.pack_info_unauthed["result"]["artist"]
             title_ko = self.pack_info_unauthed["result"]["title"]
@@ -197,14 +214,15 @@ class DownloadKakao(DownloadBase):
                     response = False
 
                 if response is False:
-                    return False
+                    return 0, 0
 
             return self.download_static(thumbnail_urls)
 
         self.cb.put("Download failed: Unrecognized URL")
-        return False
+        return 0, 0
 
-    def download_static(self, thumbnail_urls: str) -> bool:
+    def download_static(self, thumbnail_urls: str) -> Tuple[int, int]:
+        headers = {"User-Agent": "Android"}
         MetadataHandler.set_metadata(
             self.out_dir, title=self.pack_title, author=self.author
         )
@@ -215,11 +233,11 @@ class DownloadKakao(DownloadBase):
             dest = Path(self.out_dir, str(num).zfill(3) + ".png")
             targets.append((url, dest))
 
-        self.download_multiple_files(targets)
+        results = self.download_multiple_files(targets, headers=headers)
 
-        return True
+        return sum(results.values()), len(targets)
 
-    def download_animated(self, item_code: str) -> bool:
+    def download_animated(self, item_code: str) -> Tuple[int, int]:
         MetadataHandler.set_metadata(
             self.out_dir, title=self.pack_title, author=self.author
         )
@@ -272,7 +290,7 @@ class DownloadKakao(DownloadBase):
                     break
             if play_ext == "":
                 self.cb.put(f"Failed to determine extension of {item_code}")
-                return False
+                return 0, 0
             else:
                 play_path_format = f"dw/{item_code}.{play_type}_0##{play_ext}"
         else:
@@ -308,7 +326,7 @@ class DownloadKakao(DownloadBase):
                 sound_dl_path = Path(self.out_dir, str(num).zfill(3) + sound_ext)
                 targets.append((sound_url, sound_dl_path))
 
-        self.download_multiple_files(targets, headers=headers)
+        results = self.download_multiple_files(targets, headers=headers)
 
         for target in targets:
             f_path = target[1]
@@ -326,7 +344,7 @@ class DownloadKakao(DownloadBase):
 
         self.cb.put(f"Finished getting {item_code}")
 
-        return True
+        return sum(results.values()), len(targets)
 
     @staticmethod
     def start(
@@ -334,6 +352,6 @@ class DownloadKakao(DownloadBase):
         opt_cred: Optional[CredOption],
         cb: CallbackProtocol,
         cb_return: CallbackReturn,
-    ) -> bool:
+    ) -> Tuple[int, int]:
         downloader = DownloadKakao(opt_input, opt_cred, cb, cb_return)
         return downloader.download_stickers_kakao()

sticker_convert/downloaders/download_line.py

@@ -400,13 +400,13 @@ class DownloadLine(DownloadBase):
 
                 self.cb.put(f"Combined {i.name.replace('-text.png', '.png')}")
 
-    def download_stickers_line(self) -> bool:
+    def download_stickers_line(self) -> Tuple[int, int]:
         url_data = MetadataLine.analyze_url(self.url)
         if url_data:
             self.pack_id, self.region, self.is_emoji = url_data
         else:
             self.cb.put("Download failed: Unsupported URL format")
-            return False
+            return 0, 0
 
         if self.is_emoji:
             metadata = MetadataLine.get_metadata_sticon(self.pack_id, self.region)
@@ -423,7 +423,7 @@ class DownloadLine(DownloadBase):
             ) = metadata
         else:
             self.cb.put("Download failed: Failed to get metadata")
-            return False
+            return 0, 0
 
         MetadataHandler.set_metadata(self.out_dir, title=self.title, author=self.author)
 
@@ -434,7 +434,7 @@ class DownloadLine(DownloadBase):
             self.cb.put(f"Downloaded {pack_url}")
         else:
             self.cb.put(f"Cannot download {pack_url}")
-            return False
+            return 0, 0
 
         if self.is_emoji:
             self.decompress_emoticon(zip_file)
@@ -458,7 +458,7 @@ class DownloadLine(DownloadBase):
         self.download_multiple_files(custom_sticker_text_urls, headers=self.headers)
         self.combine_custom_text()
 
-        return True
+        return len(self.pack_files), len(self.pack_files)
 
     @staticmethod
     def start(
@@ -466,6 +466,6 @@ class DownloadLine(DownloadBase):
         opt_cred: Optional[CredOption],
         cb: CallbackProtocol,
         cb_return: CallbackReturn,
-    ) -> bool:
+    ) -> Tuple[int, int]:
         downloader = DownloadLine(opt_input, opt_cred, cb, cb_return)
         return downloader.download_stickers_line()

sticker_convert/downloaders/download_signal.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Tuple
 
 import anyio
 from signalstickers_client.errors import SignalException
@@ -62,23 +62,25 @@ class DownloadSignal(DownloadBase):
             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:
+    def download_stickers_signal(self) -> Tuple[int, int]:
+        if "signal.art" not in self.url or not self.url.startswith(
+            "sgnl://addstickers/"
+        ):
             self.cb.put("Download failed: Unrecognized URL format")
-            return False
+            return 0, 0
 
-        pack_id = self.url.split("#pack_id=")[1].split("&pack_key=")[0]
+        pack_id = self.url.split("pack_id=")[1].split("&pack_key=")[0]
         pack_key = self.url.split("&pack_key=")[1]
 
         try:
             pack = anyio.run(DownloadSignal.get_pack, pack_id, pack_key)
         except SignalException as e:
             self.cb.put(f"Failed to download pack due to {repr(e)}")
-            return False
+            return 0, 0
 
         self.save_stickers(pack)
 
-        return True
+        return len(pack.stickers), len(pack.stickers)
 
     @staticmethod
     def start(
@@ -86,6 +88,6 @@ class DownloadSignal(DownloadBase):
         opt_cred: Optional[CredOption],
         cb: CallbackProtocol,
         cb_return: CallbackReturn,
-    ) -> bool:
+    ) -> Tuple[int, int]:
         downloader = DownloadSignal(opt_input, opt_cred, cb, cb_return)
         return downloader.download_stickers_signal()

sticker_convert/downloaders/download_telegram.py

@@ -1,15 +1,13 @@
 #!/usr/bin/env python3
 from pathlib import Path
-from typing import Dict, Optional, Union
+from typing import Optional, Tuple
 from urllib.parse import urlparse
 
 import anyio
-from telegram import PhotoSize, Sticker, StickerSet
-from telegram.error import TelegramError
-from telegram.ext import AIORateLimiter, ApplicationBuilder
 
 from sticker_convert.downloaders.download_base import DownloadBase
 from sticker_convert.job_option import CredOption, InputOption
+from sticker_convert.utils.auth.telegram_api import BotAPI, TelegramAPI, TelethonAPI
 from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 
@@ -18,105 +16,33 @@ class DownloadTelegram(DownloadBase):
     # def __init__(self, *args: Any, **kwargs: Any) -> None:
     #     super().__init__(*args, **kwargs)
 
-    def download_stickers_telegram(self) -> bool:
-        self.token = ""
-
-        if self.opt_cred:
-            self.token = self.opt_cred.telegram_token.strip()
-        if not self.token:
-            self.cb.put("Download failed: Token required for downloading from telegram")
-            return False
-
+    def download_stickers_telegram(self) -> Tuple[int, int]:
         if not ("telegram.me" in self.url or "t.me" in self.url):
             self.cb.put("Download failed: Unrecognized URL format")
-            return False
-
-        self.title = Path(urlparse(self.url).path).name
-
-        self.emoji_dict: Dict[str, str] = {}
+            return 0, 0
 
         return anyio.run(self.save_stickers)
 
-    async def save_stickers(self) -> bool:
-        timeout = 30
-        application = (  # type: ignore
-            ApplicationBuilder()
-            .token(self.token)
-            .rate_limiter(AIORateLimiter(max_retries=3))
-            .connect_timeout(timeout)
-            .pool_timeout(timeout)
-            .read_timeout(timeout)
-            .write_timeout(timeout)
-            .connection_pool_size(20)
-            .build()
-        )
-
-        async with application:
-            bot = application.bot
-            try:
-                sticker_set: StickerSet = await bot.get_sticker_set(
-                    self.title,
-                    read_timeout=timeout,
-                    write_timeout=timeout,
-                    connect_timeout=timeout,
-                    pool_timeout=timeout,
-                )
-            except TelegramError as e:
-                self.cb.put(
-                    f"Failed to download telegram sticker set {self.title} due to: {e}"
-                )
-                return False
-
-            self.cb.put(
-                (
-                    "bar",
-                    None,
-                    {
-                        "set_progress_mode": "determinate",
-                        "steps": len(sticker_set.stickers),
-                    },
-                )
-            )
-
-            async def download_sticker(
-                sticker: Union[PhotoSize, Sticker], f_id: str
-            ) -> None:
-                sticker_file = await sticker.get_file(
-                    read_timeout=timeout,
-                    write_timeout=timeout,
-                    connect_timeout=timeout,
-                    pool_timeout=timeout,
-                )
-                fpath = sticker_file.file_path
-                assert fpath is not None
-                ext = Path(fpath).suffix
-                f_name = f_id + ext
-                f_path = Path(self.out_dir, f_name)
-                await sticker_file.download_to_drive(
-                    custom_path=f_path,
-                    read_timeout=timeout,
-                    write_timeout=timeout,
-                    connect_timeout=timeout,
-                    pool_timeout=timeout,
-                )
-                if isinstance(sticker, Sticker) and sticker.emoji is not None:
-                    self.emoji_dict[f_id] = sticker.emoji
-                self.cb.put(f"Downloaded {f_name}")
-                if f_id != "cover":
-                    self.cb.put("update_bar")
+    async def save_stickers(self) -> Tuple[int, int]:
+        tg_api: TelegramAPI
+        if self.input_option.endswith("telethon"):
+            tg_api = TelethonAPI()
+        else:
+            tg_api = BotAPI()
 
-            async with anyio.create_task_group() as tg:
-                for num, sticker in enumerate(sticker_set.stickers):
-                    f_id = str(num).zfill(3)
-                    tg.start_soon(download_sticker, sticker, f_id)
+        if self.opt_cred is None:
+            self.cb.put("Download failed: No credentials")
+            return 0, 0
 
-                if sticker_set.thumbnail is not None:
-                    tg.start_soon(download_sticker, sticker_set.thumbnail, "cover")
+        success = await tg_api.setup(self.opt_cred, False, self.cb, self.cb_return)
+        if success is False:
+            self.cb.put("Download failed: Invalid credentials")
+            return 0, 0
 
-        MetadataHandler.set_metadata(
-            self.out_dir, title=self.title, emoji_dict=self.emoji_dict
-        )
-        return True
+        title = Path(urlparse(self.url).path).name
+        results, emoji_dict = await tg_api.pack_dl(title, self.out_dir)
+        MetadataHandler.set_metadata(self.out_dir, title=title, emoji_dict=emoji_dict)
+        return sum(results.values()), len(results)
 
     @staticmethod
     def start(
@@ -124,6 +50,6 @@ class DownloadTelegram(DownloadBase):
         opt_cred: Optional[CredOption],
         cb: CallbackProtocol,
         cb_return: CallbackReturn,
-    ) -> bool:
+    ) -> Tuple[int, int]:
         downloader = DownloadTelegram(opt_input, opt_cred, cb, cb_return)
         return downloader.download_stickers_telegram()