sticker-convert 2.13.3.0__py3-none-any.whl → 2.17.0.0__py3-none-any.whl

sticker_convert/downloaders/download_ogq.py

@@ -1,79 +1,80 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, List, Optional, Tuple
-from urllib import parse
-
-import requests
-from bs4 import BeautifulSoup
-
-from sticker_convert.downloaders.download_base import DownloadBase
-from sticker_convert.job_option import CredOption, InputOption
-from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
-from sticker_convert.utils.files.metadata_handler import MetadataHandler
-
-# Reference: https://github.com/star-39/moe-sticker-bot/issues/49
-
-
-class DownloadOgq(DownloadBase):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.headers = {"User-Agent": "Mozilla/5.0"}
-
-    def download_stickers_ogq(self) -> Tuple[int, int]:
-        url_parse = parse.urlparse(self.url)
-        if (
-            url_parse.netloc != "ogqmarket.naver.com"
-            or url_parse.path.startswith("/artworks/sticker/detail") is False
-        ):
-            self.cb.put(f"Invalid url: {self.url}")
-        artwork_id = {
-            i.split("=")[0]: i.split("=")[1] for i in url_parse.query.split("&")
-        }["artworkId"]
-
-        html = requests.get(self.url, headers=self.headers).text
-        soup = BeautifulSoup(html, "html.parser")
-
-        author_tag = soup.select_one("div.info div.nickname span")  # type: ignore
-        author = author_tag.text.strip() if author_tag else "OGQ"
-        title_tag = soup.select_one("div.header div div.title p")  # type: ignore
-        title = title_tag.text.strip() if title_tag else artwork_id
-
-        seen: List[str] = []
-        imgs: List[str] = []
-        targets: List[Tuple[str, Path]] = []
-        n = 0
-        for img in soup.find_all("img", alt="sticker-detail-image-prevew"):
-            src = img.get("src")
-            if not src:
-                continue
-            src = src.split("?")[0]
-            if src in seen:
-                continue
-            seen.append(src)
-            imgs.append(src)
-            sticker_url = f"{src}?type=ma480_480"
-            sticker_url_parse = parse.urlparse(sticker_url)
-            ext = sticker_url_parse.path.split(".")[-1]
-            if sticker_url_parse.path.split("/")[-1].startswith("original_"):
-                path = self.out_dir / f"{n}.{ext}"
-            else:
-                path = self.out_dir / f"cover.{ext}"
-            targets.append((sticker_url, path))
-            n += 1
-
-        results = self.download_multiple_files(targets)
-        MetadataHandler.set_metadata(self.out_dir, title=title, author=author)
-
-        return len(results.values()), len(targets)
-
-    @staticmethod
-    def start(
-        opt_input: InputOption,
-        opt_cred: Optional[CredOption],
-        cb: CallbackProtocol,
-        cb_return: CallbackReturn,
-    ) -> Tuple[int, int]:
-        downloader = DownloadOgq(opt_input, opt_cred, cb, cb_return)
-        return downloader.download_stickers_ogq()
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, List, Optional, Tuple
+from urllib import parse
+
+import requests
+from bs4 import BeautifulSoup
+
+from sticker_convert.downloaders.download_base import DownloadBase
+from sticker_convert.job_option import CredOption, InputOption
+from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
+from sticker_convert.utils.files.metadata_handler import MetadataHandler
+from sticker_convert.utils.translate import I
+
+# Reference: https://github.com/star-39/moe-sticker-bot/issues/49
+
+
+class DownloadOgq(DownloadBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.headers = {"User-Agent": "Mozilla/5.0"}
+
+    def download_stickers_ogq(self) -> Tuple[int, int]:
+        url_parse = parse.urlparse(self.url)
+        if (
+            url_parse.netloc != "ogqmarket.naver.com"
+            or url_parse.path.startswith("/artworks/sticker/detail") is False
+        ):
+            self.cb.put(I("Invalid url: {}").format(self.url))
+        artwork_id = {
+            i.split("=")[0]: i.split("=")[1] for i in url_parse.query.split("&")
+        }["artworkId"]
+
+        html = requests.get(self.url, headers=self.headers).text
+        soup = BeautifulSoup(html, "html.parser")
+
+        author_tag = soup.select_one("div.info div.nickname span")  # type: ignore
+        author = author_tag.text.strip() if author_tag else "OGQ"
+        title_tag = soup.select_one("div.header div div.title p")  # type: ignore
+        title = title_tag.text.strip() if title_tag else artwork_id
+
+        seen: List[str] = []
+        imgs: List[str] = []
+        targets: List[Tuple[str, Path]] = []
+        n = 0
+        for img in soup.find_all("img", alt="sticker-detail-image-prevew"):
+            src = img.get("src")
+            if not src:
+                continue
+            src = src.split("?")[0]
+            if src in seen:
+                continue
+            seen.append(src)
+            imgs.append(src)
+            sticker_url = f"{src}?type=ma480_480"
+            sticker_url_parse = parse.urlparse(sticker_url)
+            ext = sticker_url_parse.path.split(".")[-1]
+            if sticker_url_parse.path.split("/")[-1].startswith("original_"):
+                path = self.out_dir / f"{n}.{ext}"
+            else:
+                path = self.out_dir / f"cover.{ext}"
+            targets.append((sticker_url, path))
+            n += 1
+
+        results = self.download_multiple_files(targets)
+        MetadataHandler.set_metadata(self.out_dir, title=title, author=author)
+
+        return len(results.values()), len(targets)
+
+    @staticmethod
+    def start(
+        opt_input: InputOption,
+        opt_cred: Optional[CredOption],
+        cb: CallbackProtocol,
+        cb_return: CallbackReturn,
+    ) -> Tuple[int, int]:
+        downloader = DownloadOgq(opt_input, opt_cred, cb, cb_return)
+        return downloader.download_stickers_ogq()

sticker_convert/downloaders/download_signal.py

@@ -1,105 +1,108 @@
-#!/usr/bin/env python3
-from pathlib import Path
-from typing import Dict, Optional, Tuple
-
-import anyio
-from signalstickers_client.errors import SignalException
-from signalstickers_client.models import StickerPack
-from signalstickers_client.stickersclient import StickersClient
-
-from sticker_convert.downloaders.download_base import DownloadBase
-from sticker_convert.job_option import CredOption, InputOption
-from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
-from sticker_convert.utils.files.metadata_handler import MetadataHandler
-from sticker_convert.utils.media.codec_info import CodecInfo
-
-
-class DownloadSignal(DownloadBase):
-    # def __init__(self, *args: Any, **kwargs: Any) -> None:
-    #     super().__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) -> None:
-        self.cb.put(
-            (
-                "bar",
-                None,
-                {
-                    "set_progress_mode": "determinate",
-                    "steps": len(pack.stickers),
-                },
-            )
-        )
-
-        emoji_dict: Dict[str, str] = {}
-        for sticker in pack.stickers:
-            f_id = str(sticker.id).zfill(3)
-            f_path = Path(self.out_dir, f_id)
-            with open(f_path, "wb") as f:
-                f.write(sticker.image_data)  # type: ignore
-
-            emoji_dict[f_id] = sticker.emoji  # type: ignore
-
-            codec = CodecInfo.get_file_codec(f_path)
-            if codec == "":
-                msg = f"Warning: Downloaded {f_path} but cannot get file codec"
-                self.cb.put(msg)
-            else:
-                f_path_new = Path(f"{f_path}.{codec}")
-                f_path.rename(f_path_new)
-                msg = f"Downloaded {f_id}.{codec}"
-                self.cb.put(msg)
-
-            self.cb.put("update_bar")
-
-        if pack.cover is not None and pack.cover.image_data is not None:
-            cover_path = Path(self.out_dir, "cover")
-            with open(cover_path, "wb") as f:
-                f.write(pack.cover.image_data)
-
-            cover_codec = CodecInfo.get_file_codec(cover_path)
-            if cover_codec == "":
-                cover_codec = "png"
-            cover_path_new = Path(self.out_dir, f"cover.{cover_codec}")
-            cover_path.rename(cover_path_new)
-            self.cb.put(f"Downloaded cover.{cover_codec}")
-
-        MetadataHandler.set_metadata(
-            self.out_dir, title=pack.title, author=pack.author, emoji_dict=emoji_dict
-        )
-
-    def download_stickers_signal(self) -> Tuple[int, int]:
-        if "signal.art" not in self.url and not self.url.startswith(
-            "sgnl://addstickers/"
-        ):
-            self.cb.put("Download failed: Unrecognized URL format")
-            return 0, 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 0, 0
-
-        self.save_stickers(pack)
-
-        return len(pack.stickers), len(pack.stickers)
-
-    @staticmethod
-    def start(
-        opt_input: InputOption,
-        opt_cred: Optional[CredOption],
-        cb: CallbackProtocol,
-        cb_return: CallbackReturn,
-    ) -> Tuple[int, int]:
-        downloader = DownloadSignal(opt_input, opt_cred, cb, cb_return)
-        return downloader.download_stickers_signal()
+#!/usr/bin/env python3
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+import anyio
+from signalstickers_client.errors import SignalException
+from signalstickers_client.models import StickerPack
+from signalstickers_client.stickersclient import StickersClient
+
+from sticker_convert.downloaders.download_base import DownloadBase
+from sticker_convert.job_option import CredOption, InputOption
+from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
+from sticker_convert.utils.files.metadata_handler import MetadataHandler
+from sticker_convert.utils.media.codec_info import CodecInfo
+from sticker_convert.utils.translate import I
+
+
+class DownloadSignal(DownloadBase):
+    # def __init__(self, *args: Any, **kwargs: Any) -> None:
+    #     super().__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) -> None:
+        self.cb.put(
+            (
+                "bar",
+                None,
+                {
+                    "set_progress_mode": "determinate",
+                    "steps": len(pack.stickers),
+                },
+            )
+        )
+
+        emoji_dict: Dict[str, str] = {}
+        for sticker in pack.stickers:
+            f_id = str(sticker.id).zfill(3)
+            f_path = Path(self.out_dir, f_id)
+            with open(f_path, "wb") as f:
+                f.write(sticker.image_data)  # type: ignore
+
+            emoji_dict[f_id] = sticker.emoji  # type: ignore
+
+            codec = CodecInfo.get_file_codec(f_path)
+            if codec == "":
+                msg = I("Warning: Downloaded {} but cannot get file codec").format(
+                    f_path
+                )
+                self.cb.put(msg)
+            else:
+                f_path_new = Path(f"{f_path}.{codec}")
+                f_path.rename(f_path_new)
+                msg = I("Downloaded {}.{}").format(f_id, codec)
+                self.cb.put(msg)
+
+            self.cb.put("update_bar")
+
+        if pack.cover is not None and pack.cover.image_data is not None:
+            cover_path = Path(self.out_dir, "cover")
+            with open(cover_path, "wb") as f:
+                f.write(pack.cover.image_data)
+
+            cover_codec = CodecInfo.get_file_codec(cover_path)
+            if cover_codec == "":
+                cover_codec = "png"
+            cover_path_new = Path(self.out_dir, f"cover.{cover_codec}")
+            cover_path.rename(cover_path_new)
+            self.cb.put(I("Downloaded cover.{}").format(cover_codec))
+
+        MetadataHandler.set_metadata(
+            self.out_dir, title=pack.title, author=pack.author, emoji_dict=emoji_dict
+        )
+
+    def download_stickers_signal(self) -> Tuple[int, int]:
+        if "signal.art" not in self.url and not self.url.startswith(
+            "sgnl://addstickers/"
+        ):
+            self.cb.put(I("Download failed: Unrecognized URL format"))
+            return 0, 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(I("Failed to download pack. Reason: {}").format(repr(e)))
+            return 0, 0
+
+        self.save_stickers(pack)
+
+        return len(pack.stickers), len(pack.stickers)
+
+    @staticmethod
+    def start(
+        opt_input: InputOption,
+        opt_cred: Optional[CredOption],
+        cb: CallbackProtocol,
+        cb_return: CallbackReturn,
+    ) -> Tuple[int, int]:
+        downloader = DownloadSignal(opt_input, opt_cred, cb, cb_return)
+        return downloader.download_stickers_signal()

sticker_convert/downloaders/download_telegram.py

@@ -1,55 +1,56 @@
-#!/usr/bin/env python3
-from pathlib import Path
-from typing import Optional, Tuple
-from urllib.parse import urlparse
-
-import anyio
-
-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
-
-
-class DownloadTelegram(DownloadBase):
-    # def __init__(self, *args: Any, **kwargs: Any) -> None:
-    #     super().__init__(*args, **kwargs)
-
-    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 0, 0
-
-        return anyio.run(self.save_stickers)
-
-    async def save_stickers(self) -> Tuple[int, int]:
-        tg_api: TelegramAPI
-        if self.input_option.endswith("telethon"):
-            tg_api = TelethonAPI()
-        else:
-            tg_api = BotAPI()
-
-        if self.opt_cred is None:
-            self.cb.put("Download failed: No credentials")
-            return 0, 0
-
-        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
-
-        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(
-        opt_input: InputOption,
-        opt_cred: Optional[CredOption],
-        cb: CallbackProtocol,
-        cb_return: CallbackReturn,
-    ) -> Tuple[int, int]:
-        downloader = DownloadTelegram(opt_input, opt_cred, cb, cb_return)
-        return downloader.download_stickers_telegram()
+#!/usr/bin/env python3
+from pathlib import Path
+from typing import Optional, Tuple
+from urllib.parse import urlparse
+
+import anyio
+
+from sticker_convert.auth.telegram_api import BotAPI, TelegramAPI, TelethonAPI
+from sticker_convert.downloaders.download_base import DownloadBase
+from sticker_convert.job_option import CredOption, InputOption
+from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
+from sticker_convert.utils.files.metadata_handler import MetadataHandler
+from sticker_convert.utils.translate import I
+
+
+class DownloadTelegram(DownloadBase):
+    # def __init__(self, *args: Any, **kwargs: Any) -> None:
+    #     super().__init__(*args, **kwargs)
+
+    def download_stickers_telegram(self) -> Tuple[int, int]:
+        if not ("telegram.me" in self.url or "t.me" in self.url):
+            self.cb.put(I("Download failed: Unrecognized URL format"))
+            return 0, 0
+
+        return anyio.run(self.save_stickers)
+
+    async def save_stickers(self) -> Tuple[int, int]:
+        tg_api: TelegramAPI
+        if self.input_option.endswith("telethon"):
+            tg_api = TelethonAPI()
+        else:
+            tg_api = BotAPI()
+
+        if self.opt_cred is None:
+            self.cb.put(I("Download failed: No credentials"))
+            return 0, 0
+
+        success = await tg_api.setup(self.opt_cred, False, self.cb, self.cb_return)
+        if success is False:
+            self.cb.put(I("Download failed: Invalid credentials"))
+            return 0, 0
+
+        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(
+        opt_input: InputOption,
+        opt_cred: Optional[CredOption],
+        cb: CallbackProtocol,
+        cb_return: CallbackReturn,
+    ) -> Tuple[int, int]:
+        downloader = DownloadTelegram(opt_input, opt_cred, cb, cb_return)
+        return downloader.download_stickers_telegram()