sticker-convert 2.7.3__py3-none-any.whl → 2.7.4__py3-none-any.whl

sticker_convert/cli.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import signal
+import sys
 from argparse import Namespace
 from json.decoder import JSONDecodeError
 from math import ceil
@@ -8,7 +9,7 @@ from multiprocessing import cpu_count
 from pathlib import Path
 from typing import Any, Dict
 
-from sticker_convert.definitions import CONFIG_DIR, DEFAULT_DIR, ROOT_DIR
+from sticker_convert.definitions import CONFIG_DIR, DEFAULT_DIR
 from sticker_convert.job import Job
 from sticker_convert.job_option import CompOption, CredOption, InputOption, OutputOption
 from sticker_convert.utils.auth.get_kakao_auth import GetKakaoAuth
@@ -26,22 +27,17 @@ class CLI:
 
     def cli(self) -> None:
         try:
-            self.help: Dict[str, Dict[str, str]] = JsonManager.load_json(
-                ROOT_DIR / "resources/help.json"
-            )
-            self.input_presets = JsonManager.load_json(
-                ROOT_DIR / "resources/input.json"
-            )
-            self.compression_presets = JsonManager.load_json(
-                ROOT_DIR / "resources/compression.json"
-            )
-            self.output_presets = JsonManager.load_json(
-                ROOT_DIR / "resources/output.json"
-            )
+            from sticker_convert.utils.files.json_resources_loader import COMPRESSION_JSON, EMOJI_JSON, HELP_JSON, INPUT_JSON, OUTPUT_JSON
         except RuntimeError as e:
-            self.cb.msg(e.__str__)
+            self.cb.msg(str(e))
             return
 
+        self.help = HELP_JSON
+        self.input_presets = INPUT_JSON
+        self.compression_presets = COMPRESSION_JSON
+        self.output_presets = OUTPUT_JSON
+        self.emoji_list = EMOJI_JSON
+
         parser = argparse.ArgumentParser(
             description="CLI for stickers-convert",
             formatter_class=argparse.RawTextHelpFormatter,
@@ -186,7 +182,7 @@ class CLI:
 
         signal.signal(signal.SIGINT, job.cancel)
         status = job.start()
-        exit(status)
+        sys.exit(status)
 
     def get_opt_input(self, args: Namespace) -> InputOption:
         download_options = {
@@ -212,7 +208,7 @@ class CLI:
                 self.cb.msg(f"Detected URL input source: {download_option}")
             else:
                 self.cb.msg(f"Error: Unrecognied URL input source for url: {url}")
-                exit()
+                sys.exit()
 
         opt_input = InputOption(
             option=download_option,

sticker_convert/converter.py

@@ -6,25 +6,32 @@ from io import BytesIO
 from math import ceil, floor
 from pathlib import Path
 from queue import Queue
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, List, Literal, Optional, Tuple, Union, cast
 
 import numpy as np
 from PIL import Image
 
-if TYPE_CHECKING:
-    from av.video.plane import VideoPlane  # type: ignore
-
 from sticker_convert.job_option import CompOption
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.cache_store import CacheStore
 from sticker_convert.utils.media.codec_info import CodecInfo
 from sticker_convert.utils.media.format_verify import FormatVerify
 
-CbQueueItemType = Union[
-    Tuple[str, Optional[Tuple[str]], Optional[Dict[str, str]]],
-    str,
-    None,
-]
+if TYPE_CHECKING:
+    from av.video.plane import VideoPlane  # type: ignore
+
+MSG_START_COMP = "[I] Start compressing {} -> {}"
+MSG_SKIP_COMP = "[S] Compatible file found, skip compress and just copy {} -> {}"
+MSG_COMP = (
+    "[C] Compressing {} -> {} res={}x{}, "
+    "quality={}, fps={}, color={} (step {}-{}-{})"
+)
+MSG_REDO_COMP = "[{}] Compressed {} -> {} but size {} {} limit {}, recompressing"
+MSG_DONE_COMP = "[S] Successful compression {} -> {} size {} (step {})"
+MSG_FAIL_COMP = (
+    "[F] Failed Compression {} -> {}, "
+    "cannot get below limit {} with lowest quality under current settings (Best size: {})"
+)
 
 
 def rounding(value: float) -> Decimal:
@@ -32,8 +39,8 @@ def rounding(value: float) -> Decimal:
 
 
 def get_step_value(
-    max: Optional[int],
-    min: Optional[int],
+    max_step: Optional[int],
+    min_step: Optional[int],
     step: int,
     steps: int,
     power: float = 1.0,
@@ -49,14 +56,12 @@ def get_step_value(
     else:
         factor = 0
 
-    if max is not None and min is not None:
-        v = round((max - min) * step / steps * factor + min)
+    if max_step is not None and min_step is not None:
+        v = round((max_step - min_step) * step / steps * factor + min_step)
         if even is True and v % 2 == 1:
             return v + 1
-        else:
-            return v
-    else:
-        return None
+        return v
+    return None
 
 
 def useful_array(
@@ -71,19 +76,6 @@ def useful_array(
 
 
 class StickerConvert:
-    MSG_START_COMP = "[I] Start compressing {} -> {}"
-    MSG_SKIP_COMP = "[S] Compatible file found, skip compress and just copy {} -> {}"
-    MSG_COMP = (
-        "[C] Compressing {} -> {} res={}x{}, "
-        "quality={}, fps={}, color={} (step {}-{}-{})"
-    )
-    MSG_REDO_COMP = "[{}] Compressed {} -> {} but size {} {} limit {}, recompressing"
-    MSG_DONE_COMP = "[S] Successful compression {} -> {} size {} (step {})"
-    MSG_FAIL_COMP = (
-        "[F] Failed Compression {} -> {}, "
-        "cannot get below limit {} with lowest quality under current settings (Best size: {})"
-    )
-
     def __init__(
         self,
         in_f: Union[Path, Tuple[Path, bytes]],
@@ -91,7 +83,7 @@ class StickerConvert:
         opt_comp: CompOption,
         cb: "Union[Queue[CbQueueItemType], Callback]",
         #  cb_return: CallbackReturn
-    ):
+    ) -> None:
         self.in_f: Union[bytes, Path]
         if isinstance(in_f, Path):
             self.in_f = in_f
@@ -151,7 +143,7 @@ class StickerConvert:
         out_f: Path,
         opt_comp: CompOption,
         cb: "Union[Queue[CbQueueItemType], Callback]",
-        cb_return: CallbackReturn,
+        _cb_return: CallbackReturn,
     ) -> Tuple[bool, Path, Union[None, bytes, Path], int]:
         sticker = StickerConvert(in_f, out_f, opt_comp, cb)
         result = sticker._convert()
@@ -163,7 +155,7 @@ class StickerConvert:
         if result:
             return self.compress_done(result)
 
-        self.cb.put((self.MSG_START_COMP.format(self.in_f_name, self.out_f_name)))
+        self.cb.put((MSG_START_COMP.format(self.in_f_name, self.out_f_name)))
 
         steps_list = self.generate_steps_list()
 
@@ -195,7 +187,7 @@ class StickerConvert:
             self.color = param[4]
 
             self.tmp_f = BytesIO()
-            msg = self.MSG_COMP.format(
+            msg = MSG_COMP.format(
                 self.in_f_name,
                 self.out_f_name,
                 self.res_w,
@@ -261,7 +253,7 @@ class StickerConvert:
                 file_info=self.codec_info_orig,
             )
         ):
-            self.cb.put((self.MSG_SKIP_COMP.format(self.in_f_name, self.out_f_name)))
+            self.cb.put((MSG_SKIP_COMP.format(self.in_f_name, self.out_f_name)))
 
             if isinstance(self.in_f, Path):
                 with open(self.in_f, "rb") as f:
@@ -272,8 +264,8 @@ class StickerConvert:
                 self.result_size = len(self.in_f)
 
             return result
-        else:
-            return None
+
+        return None
 
     def generate_steps_list(self) -> List[Tuple[Optional[int], ...]]:
         steps_list: List[Tuple[Optional[int], ...]] = []
@@ -323,7 +315,7 @@ class StickerConvert:
         return steps_list
 
     def recompress(self, sign: str) -> None:
-        msg = self.MSG_REDO_COMP.format(
+        msg = MSG_REDO_COMP.format(
             sign, self.in_f_name, self.out_f_name, self.size, sign, self.size_max
         )
         self.cb.put(msg)
@@ -331,7 +323,7 @@ class StickerConvert:
     def compress_fail(
         self,
     ) -> Tuple[bool, Path, Union[None, bytes, Path], int]:
-        msg = self.MSG_FAIL_COMP.format(
+        msg = MSG_FAIL_COMP.format(
             self.in_f_name, self.out_f_name, self.size_max, self.size
         )
         self.cb.put(msg)
@@ -353,7 +345,7 @@ class StickerConvert:
                 f.write(data)
 
         if result_step:
-            msg = self.MSG_DONE_COMP.format(
+            msg = MSG_DONE_COMP.format(
                 self.in_f_name, self.out_f_name, self.result_size, result_step
             )
             self.cb.put(msg)
@@ -378,7 +370,7 @@ class StickerConvert:
     def _frames_import_pillow(self) -> None:
         with Image.open(self.in_f) as im:
             # Note: im.convert("RGBA") would return rgba image of current frame only
-            if "n_frames" in im.__dir__():
+            if "n_frames" in dir(im):
                 for i in range(im.n_frames):
                     im.seek(i)
                     self.frames_raw.append(np.asarray(im.convert("RGBA")))
@@ -516,11 +508,15 @@ class StickerConvert:
     ) -> "List[np.ndarray[Any, Any]]":
         frames_out: "List[np.ndarray[Any, Any]]" = []
 
-        resample: Literal[0, 1, 2, 3]
+        resample: Literal[0, 1, 2, 3, 4, 5]
         if self.opt_comp.scale_filter == "nearest":
             resample = Image.NEAREST
+        elif self.opt_comp.scale_filter == "box":
+            resample = Image.BOX
         elif self.opt_comp.scale_filter == "bilinear":
             resample = Image.BILINEAR
+        elif self.opt_comp.scale_filter == "hamming":
+            resample = Image.HAMMING
         elif self.opt_comp.scale_filter == "bicubic":
             resample = Image.BICUBIC
         elif self.opt_comp.scale_filter == "lanczos":
@@ -764,10 +760,10 @@ class StickerConvert:
             return image.copy()
         if self.opt_comp.quantize_method == "imagequant":
             return self._quantize_by_imagequant(image)
-        elif self.opt_comp.quantize_method == "fastoctree":
+        if self.opt_comp.quantize_method == "fastoctree":
             return self._quantize_by_fastoctree(image)
-        else:
-            return image
+
+        return image
 
     def _quantize_by_imagequant(self, image: Image.Image) -> Image.Image:
         import imagequant  # type: ignore
@@ -812,17 +808,17 @@ class StickerConvert:
             #
             # For GIF, we need to adjust fps such that delay is matching to hundreths of second
             return self._fix_fps_duration(fps, 100)
-        elif self.out_f.suffix in (".webp", ".apng", ".png"):
+        if self.out_f.suffix in (".webp", ".apng", ".png"):
             return self._fix_fps_duration(fps, 1000)
-        else:
-            return self._fix_fps_pyav(fps)
+
+        return self._fix_fps_pyav(fps)
 
     def _fix_fps_duration(self, fps: float, denominator: int) -> Fraction:
         delay = int(rounding(denominator / fps))
         fps_fraction = Fraction(denominator, delay)
         if self.opt_comp.fps_max and fps_fraction > self.opt_comp.fps_max:
             return Fraction(denominator, (delay + 1))
-        elif self.opt_comp.fps_min and fps_fraction < self.opt_comp.fps_min:
+        if self.opt_comp.fps_min and fps_fraction < self.opt_comp.fps_min:
             return Fraction(denominator, (delay - 1))
         return fps_fraction
 

sticker_convert/definitions.py

@@ -48,8 +48,7 @@ def check_root_dir_exe_writable() -> bool:
         or "site-packages" in ROOT_DIR_EXE.as_posix()
     ):
         return False
-    else:
-        return True
+    return True
 
 
 ROOT_DIR_EXE_WRITABLE = check_root_dir_exe_writable()
@@ -58,13 +57,11 @@ ROOT_DIR_EXE_WRITABLE = check_root_dir_exe_writable()
 def get_default_dir() -> Path:
     if ROOT_DIR_EXE_WRITABLE:
         return ROOT_DIR_EXE
-    else:
-        home_dir = Path.home()
-        desktop_dir = home_dir / "Desktop"
-        if desktop_dir.is_dir():
-            return desktop_dir
-        else:
-            return home_dir
+    home_dir = Path.home()
+    desktop_dir = home_dir / "Desktop"
+    if desktop_dir.is_dir():
+        return desktop_dir
+    return home_dir
 
 
 # Default directory for stickers_input and stickers_output
@@ -79,9 +76,8 @@ def get_config_dir() -> Path:
 
     if ROOT_DIR_EXE_WRITABLE:
         return ROOT_DIR_EXE
-    else:
-        os.makedirs(fallback_dir, exist_ok=True)
-        return fallback_dir
+    os.makedirs(fallback_dir, exist_ok=True)
+    return fallback_dir
 
 
 # Directory for saving configs

sticker_convert/downloaders/download_base.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 
 from pathlib import Path
 from queue import Queue
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, List, Optional, Tuple, Union
 
 import requests
 
 from sticker_convert.job_option import CredOption
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 
 
 class DownloadBase:
@@ -18,35 +18,20 @@ class DownloadBase:
         out_dir: Path,
         opt_cred: Optional[CredOption],
         cb: Union[
-            Queue[
-                Union[
-                    Tuple[str, Optional[Tuple[str]], Optional[Dict[str, Any]]],
-                    str,
-                    None,
-                ]
-            ],
+            Queue[CbQueueItemType],
             Callback,
         ],
         cb_return: CallbackReturn,
-    ):
-        self.url: str = url
-        self.out_dir: Path = out_dir
-        self.opt_cred: Optional[CredOption] = opt_cred
-        self.cb: Union[
-            Queue[
-                Union[
-                    Tuple[str, Optional[Tuple[str]], Optional[Dict[str, Any]]],
-                    str,
-                    None,
-                ]
-            ],
-            Callback,
-        ] = cb
-        self.cb_return: CallbackReturn = cb_return
+    ) -> None:
+        self.url = url
+        self.out_dir = out_dir
+        self.opt_cred = opt_cred
+        self.cb = cb
+        self.cb_return = cb_return
 
     def download_multiple_files(
         self, targets: List[Tuple[str, Path]], retries: int = 3, **kwargs: Any
-    ):
+    ) -> None:
         # targets format: [(url1, dest2), (url2, dest2), ...]
         self.cb.put(
             ("bar", None, {"set_progress_mode": "determinate", "steps": len(targets)})
@@ -75,8 +60,7 @@ class DownloadBase:
 
                 if response.status_code != 200:
                     return b""
-                else:
-                    self.cb.put(f"Downloading {url}")
+                self.cb.put(f"Downloading {url}")
 
                 if show_progress:
                     steps = (total_length / chunk_size) + 1
@@ -101,11 +85,10 @@ class DownloadBase:
 
         if not result:
             return b""
-        elif dest:
+        if dest:
             with open(dest, "wb+") as f:
                 f.write(result)
             msg = f"Downloaded {url}"
             self.cb.put(msg)
             return b""
-        else:
-            return result
+        return result

sticker_convert/downloaders/download_kakao.py

@@ -13,10 +13,9 @@ import requests
 from bs4 import BeautifulSoup
 from bs4.element import Tag
 
-from sticker_convert.converter import CbQueueItemType
 from sticker_convert.downloaders.download_base import DownloadBase
 from sticker_convert.job_option import CredOption
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 from sticker_convert.utils.media.decrypt_kakao import DecryptKakao
 
@@ -41,7 +40,7 @@ class MetadataKakao:
         data_urls = app_scheme_link_tag.get("data-url")
         if not data_urls:
             return None, None
-        elif isinstance(data_urls, list):
+        if isinstance(data_urls, list):
             data_url = data_urls[0]
         else:
             data_url = data_urls
@@ -113,7 +112,7 @@ class MetadataKakao:
 
 class DownloadKakao(DownloadBase):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super(DownloadKakao, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.pack_title: Optional[str] = None
         self.author: Optional[str] = None
 
@@ -129,13 +128,10 @@ class DownloadKakao(DownloadBase):
 
             if item_code:
                 return self.download_animated(item_code)
-            else:
-                self.cb.put(
-                    "Download failed: Cannot download metadata for sticker pack"
-                )
-                return False
+            self.cb.put("Download failed: Cannot download metadata for sticker pack")
+            return False
 
-        elif self.url.isnumeric() or self.url.startswith("kakaotalk://store/emoticon/"):
+        if self.url.isnumeric() or self.url.startswith("kakaotalk://store/emoticon/"):
             item_code = self.url.replace("kakaotalk://store/emoticon/", "")
 
             self.pack_title = None
@@ -150,7 +146,7 @@ class DownloadKakao(DownloadBase):
 
             return self.download_animated(item_code)
 
-        elif urlparse(self.url).netloc == "e.kakao.com":
+        if urlparse(self.url).netloc == "e.kakao.com":
             self.pack_title = self.url.replace("https://e.kakao.com/t/", "")
             (
                 self.author,
@@ -172,24 +168,22 @@ class DownloadKakao(DownloadBase):
                 item_code = MetadataKakao.get_item_code(title_ko, auth_token)
                 if item_code:
                     return self.download_animated(item_code)
+                msg = "Warning: Cannot get item code.\n"
+                msg += "Is auth_token invalid / expired? Try to regenerate it.\n"
+                msg += "Continue to download static stickers instead?"
+                self.cb.put(("ask_bool", (msg,), None))
+                if self.cb_return:
+                    response = self.cb_return.get_response()
                 else:
-                    msg = "Warning: Cannot get item code.\n"
-                    msg += "Is auth_token invalid / expired? Try to regenerate it.\n"
-                    msg += "Continue to download static stickers instead?"
-                    self.cb.put(("ask_bool", (msg,), None))
-                    if self.cb_return:
-                        response = self.cb_return.get_response()
-                    else:
-                        response = False
-
-                    if response is False:
-                        return False
+                    response = False
+
+                if response is False:
+                    return False
 
             return self.download_static(thumbnail_urls)
 
-        else:
-            self.cb.put("Download failed: Unrecognized URL")
-            return False
+        self.cb.put("Download failed: Unrecognized URL")
+        return False
 
     def download_static(self, thumbnail_urls: str) -> bool:
         MetadataHandler.set_metadata(

sticker_convert/downloaders/download_line.py

@@ -15,15 +15,14 @@ import requests
 from bs4 import BeautifulSoup
 from PIL import Image
 
-from sticker_convert.converter import CbQueueItemType
 from sticker_convert.downloaders.download_base import DownloadBase
 from sticker_convert.job_option import CredOption
 from sticker_convert.utils.auth.get_line_auth import GetLineAuth
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 from sticker_convert.utils.media.apple_png_normalize import ApplePngNormalize
 
-"""Reference: https://github.com/doubleplusc/Line-sticker-downloader/blob/master/sticker_dl.py"""
+# Reference: https://github.com/doubleplusc/Line-sticker-downloader/blob/master/sticker_dl.py
 
 
 class MetadataLine:
@@ -162,7 +161,7 @@ class MetadataLine:
 
 class DownloadLine(DownloadBase):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super(DownloadLine, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.headers = {
             "referer": "https://store.line.me",
             "user-agent": "Android",
@@ -227,7 +226,7 @@ class DownloadLine(DownloadBase):
         num: int,
         prefix: str = "",
         suffix: str = "",
-    ):
+    ) -> None:
         data = zf.read(f_path)
         ext = Path(f_path).suffix
         if ext == ".png" and not self.is_emoji and int() < 775:
@@ -444,13 +443,13 @@ class DownloadLine(DownloadBase):
             self.decompress_stickers(zip_file)
 
         custom_sticker_text_urls: List[Tuple[str, Path]] = []
-        if self.sticker_text_dict != {} and (
+        if self.sticker_text_dict and (
             self.resource_type == "PER_STICKER_TEXT"
-            or (self.resource_type == "NAME_TEXT" and self.cookies != {})
+            or (self.resource_type == "NAME_TEXT" and self.cookies)
         ):
             self.edit_custom_sticker_text()
             custom_sticker_text_urls = self.get_custom_sticker_text_urls()
-        elif self.resource_type == "NAME_TEXT" and self.cookies == {}:
+        elif self.resource_type == "NAME_TEXT" and not self.cookies:
             self.cb.put('Warning: Line "Custom stickers" is supplied as input')
             self.cb.put(
                 "However, adding custom message requires Line cookies, and it is not supplied"

sticker_convert/downloaders/download_signal.py

@@ -1,24 +1,23 @@
 #!/usr/bin/env python3
 from pathlib import Path
 from queue import Queue
-from typing import Any, Dict, Optional, Union
+from typing import Dict, Optional, Union
 
 import anyio
 from signalstickers_client import StickersClient  # type: ignore
 from signalstickers_client.errors import SignalException  # type: ignore
 from signalstickers_client.models import StickerPack  # type: ignore
 
-from sticker_convert.converter import CbQueueItemType
 from sticker_convert.downloaders.download_base import DownloadBase
 from sticker_convert.job_option import CredOption
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 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(DownloadSignal, self).__init__(*args, **kwargs)
+    # def __init__(self, *args: Any, **kwargs: Any) -> None:
+    #     super().__init__(*args, **kwargs)
 
     @staticmethod
     async def get_pack(pack_id: str, pack_key: str) -> StickerPack:

sticker_convert/downloaders/download_telegram.py

@@ -1,23 +1,22 @@
 #!/usr/bin/env python3
 from pathlib import Path
 from queue import Queue
-from typing import Any, Dict, Optional, Union
+from typing import Dict, Optional, Union
 from urllib.parse import urlparse
 
 import anyio
 from telegram import Bot
 from telegram.error import TelegramError
 
-from sticker_convert.converter import CbQueueItemType
 from sticker_convert.downloaders.download_base import DownloadBase
 from sticker_convert.job_option import CredOption
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 
 
 class DownloadTelegram(DownloadBase):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super(DownloadTelegram, self).__init__(*args, **kwargs)
+    # def __init__(self, *args: Any, **kwargs: Any) -> None:
+    #     super().__init__(*args, **kwargs)
 
     def download_stickers_telegram(self) -> bool:
         self.token = ""