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

sticker_convert/resources/output.json

@@ -23,6 +23,22 @@
             "author": false
         }
     },
+    "telegram_telethon": {
+        "full_name": "Upload to Telegram with Telethon",
+        "help": "Upload to Telegram with Telethon *Not recommended, but allow link not end with _by_xxxbot*",
+        "metadata_requirements": {
+            "title": true,
+            "author": false
+        }
+    },
+    "telegram_emoji_telethon": {
+        "full_name": "Upload to Telegram with Telethon (Custom emoji)",
+        "help": "Upload to Telegram with Telethon (Custom emoji) *Not recommended, but allow link not end with _by_xxxbot*",
+        "metadata_requirements": {
+            "title": true,
+            "author": false
+        }
+    },
     "viber": {
         "full_name": "Upload to Viber",
         "help": "Upload to Viber",

sticker_convert/uploaders/compress_wastickers.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 import copy
-import shutil
 import zipfile
 from pathlib import Path
 from typing import Any, List, Tuple
@@ -9,7 +8,6 @@ from sticker_convert.converter import StickerConvert
 from sticker_convert.job_option import CompOption, CredOption, OutputOption
 from sticker_convert.uploaders.upload_base import UploadBase
 from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
-from sticker_convert.utils.files.cache_store import CacheStore
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 from sticker_convert.utils.files.sanitize_filename import sanitize_filename
 from sticker_convert.utils.media.codec_info import CodecInfo
@@ -70,8 +68,65 @@ class CompressWastickers(UploadBase):
         stickers_total = 0
         for pack_title, stickers in packs.items():
             stickers_total += len(stickers)
-            # Originally the Sticker Maker application name the files with int(time.time())
-            with CacheStore.get_cache_store(path=self.opt_comp.cache_dir) as tempdir:
+            out_f = Path(
+                self.opt_output.dir, sanitize_filename(pack_title + ".wastickers")
+            ).as_posix()
+
+            MetadataHandler.set_metadata(
+                self.opt_output.dir, author=author, title=title, newline=True
+            )
+            with zipfile.ZipFile(out_f, "w", zipfile.ZIP_DEFLATED) as zipf:
+                cover_opt_comp_merged = copy.deepcopy(self.opt_comp)
+                cover_opt_comp_merged.merge(self.spec_cover)
+
+                cover_path_old = MetadataHandler.get_cover(self.opt_output.dir)
+                cover_path_new = Path("bytes.png")
+                if cover_path_old is None:
+                    # First image in the directory, extracting first frame
+                    first_image = [
+                        i
+                        for i in sorted(self.opt_output.dir.iterdir())
+                        if Path(self.opt_output.dir, i.name).is_file()
+                        and i.suffix not in (".txt", ".m4a", ".wastickers")
+                    ][0]
+                    self.cb.put(f"Creating cover using {first_image.name}")
+                    success, _, cover_data, _ = StickerConvert.convert(
+                        Path(self.opt_output.dir, first_image),
+                        cover_path_new,
+                        cover_opt_comp_merged,
+                        self.cb,
+                        self.cb_return,
+                    )
+                    if not success:
+                        self.cb.put(
+                            f"Warning: Cannot compress cover {first_image.name}, unable to create .wastickers"
+                        )
+                        continue
+                else:
+                    if not FormatVerify.check_file(
+                        cover_path_old, spec=self.spec_cover
+                    ):
+                        success, _, cover_data, _ = StickerConvert.convert(
+                            cover_path_old,
+                            cover_path_new,
+                            cover_opt_comp_merged,
+                            self.cb,
+                            self.cb_return,
+                        )
+                        if not success:
+                            self.cb.put(
+                                f"Warning: Cannot compress cover {cover_path_old.name}, unable to create .wastickers"
+                            )
+                            continue
+                    else:
+                        with open(cover_path_old, "rb") as f:
+                            cover_data = f.read()
+
+                assert isinstance(cover_data, bytes)
+                zipf.writestr("tray.png", cover_data)
+                zipf.write(Path(self.opt_output.dir, "author.txt"), "author.txt")
+                zipf.write(Path(self.opt_output.dir, "title.txt"), "title.txt")
+
                 for num, src in enumerate(stickers):
                     self.cb.put(f"Verifying {src} for compressing into .wastickers")
 
@@ -79,72 +134,37 @@ class CompressWastickers(UploadBase):
                         ext = ".webp"
                     else:
                         ext = ".png"
+                    dst = f"bytes{ext}"
 
-                    dst = Path(tempdir, f"sticker_{num+1}{ext}")
-
-                    if FormatVerify.check_file(
-                        src, spec=self.webp_spec
-                    ) or FormatVerify.check_file(src, spec=self.png_spec):
-                        shutil.copy(src, dst)
-                    else:
-                        StickerConvert.convert(
+                    if not (
+                        FormatVerify.check_file(src, spec=self.webp_spec)
+                        or FormatVerify.check_file(src, spec=self.png_spec)
+                    ):
+                        success, _, image_data, _ = StickerConvert.convert(
                             Path(src),
                             Path(dst),
                             self.opt_comp_merged,
                             self.cb,
                             self.cb_return,
                         )
+                        assert isinstance(image_data, bytes)
+                        if not success:
+                            self.cb.put(
+                                f"Warning: Cannot compress file {Path(src).name}, skip this file..."
+                            )
+                            continue
+                    else:
+                        with open(src, "rb") as f:
+                            image_data = f.read()
 
-                out_f = Path(
-                    self.opt_output.dir, sanitize_filename(pack_title + ".wastickers")
-                ).as_posix()
-
-                self.add_metadata(Path(tempdir), pack_title, author)
-                with zipfile.ZipFile(out_f, "w", zipfile.ZIP_DEFLATED) as zipf:
-                    for file in Path(tempdir).iterdir():
-                        file_path = Path(tempdir, file.name)
-                        zipf.write(file_path, arcname=file_path.name)
+                    # Originally the Sticker Maker application name the files with int(time.time())
+                    zipf.writestr(f"sticker_{num + 1}{ext}", image_data)
 
             self.cb.put((out_f))
             urls.append(out_f)
 
         return stickers_total, stickers_total, urls
 
-    def add_metadata(self, pack_dir: Path, title: str, author: str) -> None:
-        opt_comp_merged = copy.deepcopy(self.opt_comp)
-        opt_comp_merged.merge(self.spec_cover)
-
-        cover_path_old = MetadataHandler.get_cover(self.opt_output.dir)
-        cover_path_new = Path(pack_dir, "tray.png")
-        if cover_path_old:
-            if FormatVerify.check_file(cover_path_old, spec=self.spec_cover):
-                shutil.copy(cover_path_old, cover_path_new)
-            else:
-                StickerConvert.convert(
-                    cover_path_old,
-                    cover_path_new,
-                    opt_comp_merged,
-                    self.cb,
-                    self.cb_return,
-                )
-        else:
-            # First image in the directory, extracting first frame
-            first_image = [
-                i
-                for i in sorted(self.opt_output.dir.iterdir())
-                if Path(self.opt_output.dir, i.name).is_file()
-                and i.suffix not in (".txt", ".m4a", ".wastickers")
-            ][0]
-            StickerConvert.convert(
-                Path(self.opt_output.dir, first_image),
-                cover_path_new,
-                opt_comp_merged,
-                self.cb,
-                self.cb_return,
-            )
-
-        MetadataHandler.set_metadata(pack_dir, author=author, title=title, newline=True)
-
     @staticmethod
     def start(
         opt_output: OutputOption,

sticker_convert/uploaders/upload_telegram.py

@@ -1,20 +1,19 @@
 #!/usr/bin/env python3
 import copy
-import re
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union, cast
 
 import anyio
-from telegram import InputSticker, Sticker
-from telegram.error import BadRequest, TelegramError
-from telegram.ext import AIORateLimiter, ApplicationBuilder
+from telegram import Sticker
 
 from sticker_convert.converter import StickerConvert
 from sticker_convert.job_option import CompOption, CredOption, OutputOption
 from sticker_convert.uploaders.upload_base import UploadBase
+from sticker_convert.utils.auth.telegram_api import BotAPI, TelegramAPI, TelegramSticker, TelethonAPI
 from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
 from sticker_convert.utils.emoji import extract_emojis
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
+from sticker_convert.utils.media.codec_info import CodecInfo
 from sticker_convert.utils.media.format_verify import FormatVerify
 
 
@@ -70,256 +69,190 @@ class UploadTelegram(UploadBase):
 
     async def upload_pack(
         self, pack_title: str, stickers: List[Path], emoji_dict: Dict[str, str]
-    ) -> Optional[str]:
-        token = self.opt_cred.telegram_token.strip()
-        assert token
-        timeout = 10 * len(stickers)
-
-        application = (  # type: ignore
-            ApplicationBuilder()
-            .token(self.opt_cred.telegram_token.strip())
-            .rate_limiter(AIORateLimiter(max_retries=3))
-            .connect_timeout(timeout)
-            .pool_timeout(timeout)
-            .read_timeout(timeout)
-            .write_timeout(timeout)
-            .connection_pool_size(len(stickers))
-            .build()
-        )
-
-        async with application:
-            bot = application.bot
-            pack_short_name = (
-                pack_title.replace(" ", "_") + "_by_" + bot.name.replace("@", "")
-            )
-            pack_short_name = re.sub(
-                "[^0-9a-zA-Z]+", "_", pack_short_name
-            )  # name used in url, only alphanum and underscore only
-
-            sticker_set: Any = None
-            try:
-                sticker_set = await bot.get_sticker_set(
-                    pack_short_name,
-                    read_timeout=30,
-                    write_timeout=30,
-                    connect_timeout=30,
-                    pool_timeout=30,
+    ) -> Tuple[Optional[str], int, int]:
+        tg_api: TelegramAPI
+        if self.opt_output.option.endswith("telethon"):
+            tg_api = TelethonAPI()
+        else:
+            tg_api = BotAPI()
+
+        is_emoji = False
+        if "emoji" in self.opt_output.option:
+            is_emoji = True
+
+        success = await tg_api.setup(self.opt_cred, True, self.cb, self.cb_return)
+        if success is False:
+            self.cb.put("Download failed: Invalid credentials")
+            return None, len(stickers), 0
+
+        pack_short_name = await tg_api.set_upload_pack_short_name(pack_title)
+        await tg_api.set_upload_pack_type(is_emoji)
+        pack_exist = await tg_api.check_pack_exist()
+        if pack_exist:
+            question = f"Warning: Pack {pack_short_name} already exists.\n"
+            question += "Delete all stickers in pack?\n"
+            question += "Note: After recreating set, please wait for about 3 minutes for the set to reappear."
+
+            self.cb.put(
+                (
+                    "ask_bool",
+                    (question,),
+                    None,
                 )
-            except TelegramError:
-                pass
+            )
+            if self.cb_return:
+                response = self.cb_return.get_response()
+            else:
+                response = False
+
+            if response is True:
+                self.cb.put(f"Deleting all stickers from pack {pack_short_name}")
+                await tg_api.pack_del()
+                pack_exist = False
+            else:
+                self.cb.put(f"Not deleting existing pack {pack_short_name}")
+
+        if self.opt_output.option == "telegram_emoji":
+            sticker_type = Sticker.CUSTOM_EMOJI
+        else:
+            sticker_type = Sticker.REGULAR
 
-            if sticker_set is not None:
-                question = f"Warning: Pack {pack_short_name} already exists.\n"
-                question += "Delete all stickers in pack?\n"
-                question += "Note: After recreating set, please wait for about 3 minutes for the set to reappear."
+        stickers_list: List[TelegramSticker] = []
+        sticker_format = None
+        for src in stickers:
+            self.cb.put(f"Verifying {src} for uploading to telegram")
 
+            emoji = extract_emojis(emoji_dict.get(Path(src).stem, ""))
+            if emoji == "":
                 self.cb.put(
-                    (
-                        "ask_bool",
-                        (question,),
-                        None,
-                    )
+                    f"Warning: Cannot find emoji for file {Path(src).name}, using default emoji..."
                 )
-                if self.cb_return:
-                    response = self.cb_return.get_response()
-                else:
-                    response = False
-
-                if response is True:
-                    self.cb.put(f"Deleting all stickers from pack {pack_short_name}")
-                    try:
-                        await bot.delete_sticker_set(pack_short_name)
-                    except BadRequest as e:
-                        self.cb.put(
-                            f"Cannot delete sticker set {pack_short_name} due to {e}"
-                        )
-                        if str(e) == "Stickerpack_not_found":
-                            self.cb.put(
-                                "Hint: You might had deleted and recreated pack too quickly. Wait about 3 minutes and try again."
-                            )
-                        return None
-                    except TelegramError as e:
-                        self.cb.put(
-                            f"Cannot delete sticker set {pack_short_name} due to {e}"
-                        )
-                        return None
-                    sticker_set = None
-                else:
-                    self.cb.put(f"Not deleting existing pack {pack_short_name}")
+                emoji_list = [self.opt_comp.default_emoji]
+
+            if len(emoji) > 20:
+                self.cb.put(
+                    f"Warning: {len(emoji)} emoji for file {Path(src).name}, exceeding limit of 20, keep first 20 only..."
+                )
+            emoji_list = [*emoji][:20]
+
+            ext = Path(src).suffix
+            if ext == ".tgs":
+                spec_choice = self.tgs_spec
+                sticker_format = "animated"
+            elif ext == ".webm":
+                spec_choice = self.webm_spec
+                sticker_format = "video"
+            else:
+                ext = ".png"
+                spec_choice = self.png_spec
+                sticker_format = "static"
 
             if self.opt_output.option == "telegram_emoji":
-                sticker_type = Sticker.CUSTOM_EMOJI
+                spec_choice.set_res(100)
+
+            file_info = CodecInfo(src)
+            check_file_result = (
+                FormatVerify.check_file_fps(
+                    src, fps=spec_choice.get_fps(), file_info=file_info
+                )
+                and FormatVerify.check_file_duration(
+                    src, duration=spec_choice.get_duration(), file_info=file_info
+                )
+                and FormatVerify.check_file_size(
+                    src, size=spec_choice.get_size_max(), file_info=file_info
+                )
+                and FormatVerify.check_format(
+                    src, fmt=spec_choice.get_format(), file_info=file_info
+                )
+            )
+            if sticker_format == "video":
+                # For video stickers (Only)
+                # Allow file with one of the dimension = 512 but another <512
+                # https://core.telegram.org/stickers#video-requirements
+                check_file_result = check_file_result and (
+                    file_info.res[0] == 512 or file_info.res[1] == 512
+                )
+                check_file_result = check_file_result and (
+                    file_info.res[0] <= 512 and file_info.res[1] <= 512
+                )
             else:
-                sticker_type = Sticker.REGULAR
-
-            init_input_stickers: List[InputSticker] = []
-            extra_input_stickers: List[Tuple[InputSticker, Path]] = []
-            sticker_format = None
-            for src in stickers:
-                self.cb.put(f"Verifying {src} for uploading to telegram")
-
-                emoji = extract_emojis(emoji_dict.get(Path(src).stem, ""))
-                if emoji == "":
-                    self.cb.put(
-                        f"Warning: Cannot find emoji for file {Path(src).name}, using default emoji..."
-                    )
-                    emoji_list = [self.opt_comp.default_emoji]
-
-                if len(emoji) > 20:
-                    self.cb.put(
-                        f"Warning: {len(emoji)} emoji for file {Path(src).name}, exceeding limit of 20, keep first 20 only..."
-                    )
-                emoji_list = [*emoji][:20]
-
-                ext = Path(src).suffix
-                if ext == ".tgs":
-                    spec_choice = self.tgs_spec
-                    sticker_format = "animated"
-                elif ext == ".webm":
-                    spec_choice = self.webm_spec
-                    sticker_format = "video"
-                else:
-                    ext = ".png"
-                    spec_choice = self.png_spec
-                    sticker_format = "static"
-
-                if self.opt_output.option == "telegram_emoji":
-                    spec_choice.set_res(100)
-
-                if FormatVerify.check_file(src, spec=spec_choice):
-                    with open(src, "rb") as f:
-                        sticker_bytes = f.read()
-                else:
-                    _, _, convert_result, _ = StickerConvert.convert(
-                        Path(src),
-                        Path(f"bytes{ext}"),
-                        self.opt_comp_merged,
-                        self.cb,
-                        self.cb_return,
-                    )
-                    sticker_bytes = cast(bytes, convert_result)
+                check_file_result = (
+                    check_file_result
+                    and file_info.res[0] == 512
+                    and file_info.res[1] == 512
+                )
+                # It is important to check if webp and png are static only
+                check_file_result = check_file_result and FormatVerify.check_animated(
+                    src, animated=spec_choice.animated, file_info=file_info
+                )
 
-                input_sticker = InputSticker(
-                    sticker=sticker_bytes,
-                    emoji_list=emoji_list,
-                    format=sticker_format,
+            if check_file_result:
+                with open(src, "rb") as f:
+                    sticker_bytes = f.read()
+            else:
+                _, _, convert_result, _ = StickerConvert.convert(
+                    Path(src),
+                    Path(f"bytes{ext}"),
+                    self.opt_comp_merged,
+                    self.cb,
+                    self.cb_return,
                 )
+                sticker_bytes = cast(bytes, convert_result)
 
-                if sticker_set is None and len(init_input_stickers) < 50:
-                    init_input_stickers.append(input_sticker)
-                else:
-                    extra_input_stickers.append((input_sticker, src))
+            stickers_list.append((src, sticker_bytes, emoji_list, sticker_format))
 
-            if len(init_input_stickers) > 0:
-                self.cb.put(
-                    f"Creating pack and bulk uploading {len(init_input_stickers)} stickers of {pack_short_name}"
-                )
-                try:
-                    await bot.create_new_sticker_set(
-                        user_id=self.telegram_userid,
-                        name=pack_short_name,
-                        title=pack_title,
-                        stickers=init_input_stickers,
-                        sticker_type=sticker_type,
-                    )
-                    sticker_set = True
-                    self.cb.put(
-                        f"Created pack and bulk uploaded {len(init_input_stickers)} stickers of {pack_short_name}"
-                    )
-                except TelegramError as e:
-                    self.cb.put(
-                        f"Cannot create pack and bulk upload {len(init_input_stickers)} stickers of {pack_short_name} due to {e}"
-                    )
-                    return None
-
-            for input_sticker, src in extra_input_stickers:
-                try:
-                    # We could use tg.start_soon() here
-                    # But this would disrupt the order of stickers
-                    await bot.add_sticker_to_set(
-                        user_id=self.telegram_userid,
-                        name=pack_short_name,
-                        sticker=input_sticker,
-                    )
-                    self.cb.put(f"Uploaded sticker {src} of {pack_short_name}")
-                except BadRequest as e:
-                    self.cb.put(
-                        f"Cannot upload sticker {src} of {pack_short_name} due to {e}"
-                    )
-                    if str(e) == "Stickerpack_not_found":
-                        self.cb.put(
-                            "Hint: You might had deleted and recreated pack too quickly. Wait about 3 minutes and try again."
-                        )
-                except TelegramError as e:
-                    self.cb.put(
-                        f"Cannot upload sticker {src} of {pack_short_name} due to {e}"
-                    )
-
-            cover_path = MetadataHandler.get_cover(self.opt_output.dir)
-            if cover_path:
-                thumbnail_bytes: Union[None, bytes, Path] = None
-                cover_ext = Path(cover_path).suffix
-
-                if cover_ext == ".tgs":
-                    thumbnail_format = "animated"
-                    cover_spec_choice = self.tgs_cover_spec
-                elif cover_ext == ".webm":
-                    thumbnail_format = "video"
-                    cover_spec_choice = self.webm_cover_spec
-                else:
-                    cover_ext = ".png"
-                    thumbnail_format = "static"
-                    cover_spec_choice = self.png_cover_spec
-
-                if FormatVerify.check_file(cover_path, spec=cover_spec_choice):
-                    with open(cover_path, "rb") as f:
-                        thumbnail_bytes = f.read()
-                else:
-                    _, _, thumbnail_bytes, _ = StickerConvert.convert(
+        if pack_exist is False:
+            stickers_total, stickers_ok = await tg_api.pack_new(
+                stickers_list, sticker_type
+            )
+            pack_exist = True
+        else:
+            stickers_total, stickers_ok = await tg_api.pack_add(
+                stickers_list, sticker_type
+            )
+
+        cover_path = MetadataHandler.get_cover(self.opt_output.dir)
+        if cover_path:
+            thumbnail_bytes: Union[None, bytes, Path] = None
+            cover_ext = Path(cover_path).suffix
+
+            if cover_ext == ".tgs":
+                thumbnail_format = "animated"
+                cover_spec_choice = self.tgs_cover_spec
+            elif cover_ext == ".webm":
+                thumbnail_format = "video"
+                cover_spec_choice = self.webm_cover_spec
+            else:
+                cover_ext = ".png"
+                thumbnail_format = "static"
+                cover_spec_choice = self.png_cover_spec
+
+            if FormatVerify.check_file(cover_path, spec=cover_spec_choice):
+                with open(cover_path, "rb") as f:
+                    thumbnail_bytes = f.read()
+            else:
+                _, _, thumbnail_bytes, _ = cast(
+                    Tuple[Any, Any, bytes, Any],
+                    StickerConvert.convert(
                         cover_path,
                         Path(f"bytes{cover_ext}"),
                         self.opt_comp_cover_merged,
                         self.cb,
                         self.cb_return,
-                    )
-
-                try:
-                    self.cb.put(
-                        f"Uploading cover (thumbnail) of pack {pack_short_name}"
-                    )
-                    await bot.set_sticker_set_thumbnail(
-                        name=pack_short_name,
-                        user_id=self.telegram_userid,
-                        thumbnail=thumbnail_bytes,
-                        format=thumbnail_format,
-                    )
-                    self.cb.put(f"Uploaded cover (thumbnail) of pack {pack_short_name}")
-                except TelegramError as e:
-                    self.cb.put(
-                        f"Cannot upload cover (thumbnail) of pack {pack_short_name} due to {e}"
-                    )
-
-            self.cb.put(f"Finish uploading {pack_short_name}")
+                    ),
+                )
 
-        if self.opt_output.option == "telegram_emoji":
-            result = f"https://t.me/addemoji/{pack_short_name}"
-        else:
-            result = f"https://t.me/addstickers/{pack_short_name}"
-        return result
+            await tg_api.pack_thumbnail(
+                (cover_path, thumbnail_bytes, [], thumbnail_format)
+            )
+
+        self.cb.put(f"Finish uploading {pack_short_name}")
+        await tg_api.exit()
+        return await tg_api.get_pack_url(), stickers_total, stickers_ok
 
     def upload_stickers_telegram(self) -> Tuple[int, int, List[str]]:
         urls: List[str] = []
 
-        if not (self.opt_cred.telegram_token and self.opt_cred.telegram_userid):
-            self.cb.put("Token and userid required for uploading to telegram")
-            return 0, 0, urls
-
-        if self.opt_cred.telegram_userid.isnumeric():
-            self.telegram_userid = int(self.opt_cred.telegram_userid)
-        else:
-            self.cb.put("Invalid userid, should contain numbers only")
-            return 0, 0, urls
-
         title, _, emoji_dict = MetadataHandler.get_metadata(
             self.opt_output.dir,
             title=self.opt_output.title,
@@ -367,11 +300,14 @@ class UploadTelegram(UploadBase):
         for pack_title, stickers in packs.items():
             stickers_total += len(stickers)
             self.cb.put(f"Uploading pack {pack_title}")
-            result = anyio.run(self.upload_pack, pack_title, stickers, emoji_dict)
+            result, stickers_total_pack, stickers_ok_pack = anyio.run(
+                self.upload_pack, pack_title, stickers, emoji_dict
+            )
             if result:
                 self.cb.put((result))
                 urls.append(result)
-                stickers_ok += len(stickers)
+            stickers_total += stickers_total_pack
+            stickers_ok += stickers_ok_pack
 
         return stickers_ok, stickers_total, urls