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

sticker_convert/converter.py

@@ -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()
@@ -811,8 +811,9 @@ 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
+            # Enabling below is too slow
+            # extra_kwargs["minimize_size"] = True
+            # extra_kwargs["method"] = 6
         else:
             raise RuntimeError(f"Invalid format {self.out_f.suffix}")
 

sticker_convert/downloaders/download_base.py

@@ -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,10 +62,10 @@ class DownloadSignal(DownloadBase):
             self.out_dir, title=pack.title, author=pack.author, emoji_dict=emoji_dict
         )
 
-    def download_stickers_signal(self) -> bool:
+    def download_stickers_signal(self) -> Tuple[int, int]:
         if "signal.art" not in self.url:
             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_key = self.url.split("&pack_key=")[1]
@@ -74,11 +74,11 @@ class DownloadSignal(DownloadBase):
             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 +86,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,6 +1,6 @@
 #!/usr/bin/env python3
 from pathlib import Path
-from typing import Dict, Optional, Union
+from typing import Dict, Optional, Tuple, Union
 from urllib.parse import urlparse
 
 import anyio
@@ -18,18 +18,18 @@ class DownloadTelegram(DownloadBase):
     # def __init__(self, *args: Any, **kwargs: Any) -> None:
     #     super().__init__(*args, **kwargs)
 
-    def download_stickers_telegram(self) -> bool:
+    def download_stickers_telegram(self) -> Tuple[int, int]:
         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
+            return 0, 0
 
         if not ("telegram.me" in self.url or "t.me" in self.url):
             self.cb.put("Download failed: Unrecognized URL format")
-            return False
+            return 0, 0
 
         self.title = Path(urlparse(self.url).path).name
 
@@ -37,7 +37,8 @@ class DownloadTelegram(DownloadBase):
 
         return anyio.run(self.save_stickers)
 
-    async def save_stickers(self) -> bool:
+    async def save_stickers(self) -> Tuple[int, int]:
+        results: dict[str, bool] = {}
         timeout = 30
         application = (  # type: ignore
             ApplicationBuilder()
@@ -65,7 +66,7 @@ class DownloadTelegram(DownloadBase):
                 self.cb.put(
                     f"Failed to download telegram sticker set {self.title} due to: {e}"
                 )
-                return False
+                return 0, 0
 
             self.cb.put(
                 (
@@ -79,14 +80,19 @@ class DownloadTelegram(DownloadBase):
             )
 
             async def download_sticker(
-                sticker: Union[PhotoSize, Sticker], f_id: str
+                sticker: Union[PhotoSize, Sticker], f_id: str, results: dict[str, bool]
             ) -> None:
-                sticker_file = await sticker.get_file(
-                    read_timeout=timeout,
-                    write_timeout=timeout,
-                    connect_timeout=timeout,
-                    pool_timeout=timeout,
-                )
+                try:
+                    sticker_file = await sticker.get_file(
+                        read_timeout=timeout,
+                        write_timeout=timeout,
+                        connect_timeout=timeout,
+                        pool_timeout=timeout,
+                    )
+                except TelegramError as e:
+                    self.cb.put(f"Failed to download {f_id}: {str(e)}")
+                    results[f_id] = False
+                    return
                 fpath = sticker_file.file_path
                 assert fpath is not None
                 ext = Path(fpath).suffix
@@ -102,21 +108,25 @@ class DownloadTelegram(DownloadBase):
                 if isinstance(sticker, Sticker) and sticker.emoji is not None:
                     self.emoji_dict[f_id] = sticker.emoji
                 self.cb.put(f"Downloaded {f_name}")
+                results[f_id] = True
                 if f_id != "cover":
                     self.cb.put("update_bar")
 
             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)
+                    tg.start_soon(download_sticker, sticker, f_id, results)
 
                 if sticker_set.thumbnail is not None:
-                    tg.start_soon(download_sticker, sticker_set.thumbnail, "cover")
+                    results_thumb: dict[str, bool] = {}
+                    tg.start_soon(
+                        download_sticker, sticker_set.thumbnail, "cover", results_thumb
+                    )
 
         MetadataHandler.set_metadata(
             self.out_dir, title=self.title, emoji_dict=self.emoji_dict
         )
-        return True
+        return sum(results.values()), len(sticker_set.stickers)
 
     @staticmethod
     def start(
@@ -124,6 +134,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()

sticker_convert/downloaders/download_viber.py

@@ -44,7 +44,7 @@ class DownloadViber(DownloadBase):
 
         return title, zip_url
 
-    def decompress(self, zip_file: bytes) -> None:
+    def decompress(self, zip_file: bytes) -> int:
         with zipfile.ZipFile(BytesIO(zip_file)) as zf:
             self.cb.put("Unzipping...")
 
@@ -69,19 +69,21 @@ class DownloadViber(DownloadBase):
 
                 self.cb.put("update_bar")
 
-    def download_stickers_viber(self) -> bool:
+            return len(zf_files)
+
+    def download_stickers_viber(self) -> Tuple[int, int]:
         pack_info = self.get_pack_info(self.url)
         if pack_info is None:
             self.cb.put("Download failed: Cannot get pack info")
-            return False
+            return 0, 0
         title, zip_url = pack_info
 
         zip_file = self.download_file(zip_url)
-        self.decompress(zip_file)
+        count = self.decompress(zip_file)
 
         MetadataHandler.set_metadata(self.out_dir, title=title)
 
-        return True
+        return count, count
 
     @staticmethod
     def start(
@@ -89,6 +91,6 @@ class DownloadViber(DownloadBase):
         opt_cred: Optional[CredOption],
         cb: CallbackProtocol,
         cb_return: CallbackReturn,
-    ) -> bool:
+    ) -> Tuple[int, int]:
         downloader = DownloadViber(opt_input, opt_cred, cb, cb_return)
         return downloader.download_stickers_viber()