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

sticker_convert/downloaders/download_ogq.py

@@ -0,0 +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
+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,92 +1,108 @@
-#!/usr/bin/env python3
-from pathlib import Path
-from typing import Dict, Optional
-
-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
-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")
-
-        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.put("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]
-
-        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
-
-        self.save_stickers(pack)
-
-        return True
-
-    @staticmethod
-    def start(
-        url: str,
-        out_dir: Path,
-        opt_cred: Optional[CredOption],
-        cb: CallbackProtocol,
-        cb_return: CallbackReturn,
-    ) -> bool:
-        downloader = DownloadSignal(url, out_dir, 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,130 +1,56 @@
-#!/usr/bin/env python3
-from pathlib import Path
-from typing import Dict, Optional, Union
-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
-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) -> 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
-
-        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 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 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 sticker_set.thumbnail is not None:
-                    tg.start_soon(download_sticker, sticker_set.thumbnail, "cover")
-
-        MetadataHandler.set_metadata(
-            self.out_dir, title=self.title, emoji_dict=self.emoji_dict
-        )
-        return True
-
-    @staticmethod
-    def start(
-        url: str,
-        out_dir: Path,
-        opt_cred: Optional[CredOption],
-        cb: CallbackProtocol,
-        cb_return: CallbackReturn,
-    ) -> bool:
-        downloader = DownloadTelegram(url, out_dir, 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()