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

sticker_convert/utils/callback.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+from functools import partial
+from getpass import getpass
 from multiprocessing import Event, Manager
 from multiprocessing.managers import ListProxy, SyncManager
 from queue import Queue
@@ -19,6 +21,9 @@ if TYPE_CHECKING:
     ResponseListType = ListProxy[ResponseItemType]  # type: ignore
     CbQueueType = Queue[CbQueueItemType]  # type: ignore
     WorkQueueType = Queue[WorkQueueItemType]  # type: ignore
+    from ttkbootstrap import Toplevel  # type: ignore
+
+    from sticker_convert.gui import GUI  # type: ignore
 else:
     ResultsListType = List[Any]
     ResponseListType = List[ResponseItemType]
@@ -51,12 +56,13 @@ class CallbackProtocol(Protocol):
     def put(self, i: Union[CbQueueItemType, str]) -> Any: ...
 
 
-class Callback(CallbackProtocol):
+class CallbackCli(CallbackProtocol):
     def __init__(
         self,
         msg: Optional[Callable[..., None]] = None,
         bar: Optional[Callable[..., None]] = None,
         msg_block: Optional[Callable[..., None]] = None,
+        msg_dynamic: Optional[Callable[..., bool]] = None,
         ask_bool: Optional[Callable[..., bool]] = None,
         ask_str: Optional[Callable[..., str]] = None,
         silent: bool = False,
@@ -80,6 +86,11 @@ class Callback(CallbackProtocol):
         else:
             self.msg_block = self.cb_msg_block
 
+        if msg_dynamic:
+            self.msg_dynamic = msg_dynamic
+        else:
+            self.msg_dynamic = self.cb_msg_dynamic
+
         if ask_bool:
             self.ask_bool = ask_bool
         else:
@@ -136,6 +147,16 @@ class Callback(CallbackProtocol):
         if not self.no_confirm:
             input("Press Enter to continue...")
 
+    def cb_msg_dynamic(self, *args: Any) -> bool:
+        message = args[0]
+
+        if message is None:
+            print()
+        else:
+            print(message, end="\r", flush=True)
+
+        return True
+
     def cb_ask_bool(self, *args: Any, **kwargs: Any) -> bool:
         question = args[0]
 
@@ -158,17 +179,23 @@ class Callback(CallbackProtocol):
 
     def cb_ask_str(
         self,
-        msg: Optional[str] = None,
+        question: Optional[str] = None,
         initialvalue: Optional[str] = None,
         cli_show_initialvalue: bool = True,
+        password: bool = False,
     ) -> str:
-        self.msg(msg)
+        self.msg(question)
 
         hint = ""
         if cli_show_initialvalue and initialvalue:
             hint = f" [Default: {initialvalue}]"
 
-        response = input(f"Enter your response and press enter{hint} > ")
+        if password is True:
+            if question is None:
+                question = "Password: "
+            response = getpass(question)
+        else:
+            response = input(f"Enter your response and press enter{hint} > ")
 
         if initialvalue and not response:
             response = initialvalue
@@ -179,7 +206,210 @@ class Callback(CallbackProtocol):
         if isinstance(i, tuple):
             action = i[0]
             if len(i) >= 2:
-                args: Tuple[str, ...] = i[1] if i[1] else tuple()
+                args: Tuple[Any, ...] = i[1] if i[1] else tuple()
+            else:
+                args = tuple()
+            if len(i) >= 3:
+                kwargs: Dict[str, Any] = i[2] if i[2] else {}
+            else:
+                kwargs = {}
+        else:
+            action = i
+            args = tuple()
+            kwargs = {}
+
+        # Fake implementation for Queue.put()
+        if action is None:
+            return None
+        if action == "msg":
+            self.msg(*args, **kwargs)
+        elif action == "bar":
+            self.bar(**kwargs)
+        elif action == "update_bar":
+            self.bar(update_bar=1)
+        elif action == "msg_block":
+            return self.msg_block(*args, **kwargs)
+        elif action == "msg_dynamic":
+            return self.msg_dynamic(*args, **kwargs)
+        elif action == "ask_bool":
+            return self.ask_bool(*args, **kwargs)
+        elif action == "ask_str":
+            return self.ask_str(*args, **kwargs)
+        else:
+            self.msg(action)
+        return None
+
+
+class CallbackGui(CallbackProtocol):
+    def __init__(self, gui: "GUI"):
+        from ttkbootstrap import Label, Progressbar, StringVar  # type: ignore
+
+        from sticker_convert.gui_components.windows.base_window import BaseWindow
+        from sticker_convert.job import Job
+
+        self.gui = gui
+        self.job: Optional[Job] = None
+        self.msg_dynamic_window: Optional[BaseWindow] = None
+        self.message_var = StringVar(self.gui)
+        self.msg_dynamic_label: Optional[Label] = None
+        self.msg_dynamic_bar: Optional[Progressbar] = None
+
+        self.ask_str = self.cb_ask_str
+        self.ask_bool = self.cb_ask_bool
+        self.msg = self.cb_msg
+        self.msg_block = self.cb_msg_block
+        self.msg_dynamic = self.cb_msg_dynamic
+        self.bar = self.cb_bar
+
+    def cb_ask_str(
+        self,
+        question: str,
+        initialvalue: Optional[str] = None,
+        cli_show_initialvalue: bool = True,
+        password: bool = False,
+        parent: Optional[object] = None,
+    ) -> str:
+        from ttkbootstrap import Querybox  # type: ignore
+
+        self.gui.action = partial(
+            Querybox.get_string,  # type: ignore
+            question,
+            title="sticker-convert",
+            initialvalue=initialvalue,
+            parent=parent,
+        )
+        self.gui.event_generate("<<exec_in_main>>")
+        self.gui.response_event.wait()
+        self.gui.response_event.clear()
+
+        if self.gui.response is None:
+            return ""
+        elif isinstance(self.gui.response, str):
+            return self.gui.response
+        else:
+            raise RuntimeError(f"Invalid response in cb_ask_str: {self.gui.response}")
+
+    def cb_ask_bool(self, question: str, parent: Optional["Toplevel"] = None) -> bool:
+        from ttkbootstrap.dialogs import Messagebox  # type: ignore
+
+        self.gui.action = partial(
+            Messagebox.yesno,  # type: ignore
+            question,
+            title="sticker-convert",
+            parent=parent,
+        )
+        self.gui.event_generate("<<exec_in_main>>")
+        self.gui.response_event.wait()
+        self.gui.response_event.clear()
+
+        if self.gui.response == "Yes":
+            return True
+        return False
+
+    def cb_msg(self, *args: Any, **kwargs: Any) -> None:
+        self.gui.progress_frame.update_message_box(*args, **kwargs)
+
+    def cb_msg_block(
+        self,
+        message: Optional[str] = None,
+        parent: Optional[object] = None,
+        **_kwargs: Any,
+    ) -> Any:
+        from ttkbootstrap.dialogs import Messagebox  # type: ignore
+
+        self.gui.action = partial(
+            Messagebox.show_info,  # type: ignore
+            message,
+            title="sticker-convert",
+            parent=parent,
+        )
+        self.gui.event_generate("<<exec_in_main>>")
+        self.gui.response_event.wait()
+        self.gui.response_event.clear()
+
+        return self.gui.response
+
+    def cb_msg_dynamic(
+        self,
+        message: Optional[str] = None,
+        parent: Optional["Toplevel"] = None,
+        **_kwargs: Any,
+    ) -> bool:
+        from ttkbootstrap import Label, Progressbar  # type: ignore
+
+        from sticker_convert.gui_components.gui_utils import GUIUtils
+        from sticker_convert.gui_components.windows.base_window import BaseWindow
+
+        self.gui.action = None
+        if self.msg_dynamic_window is None:
+            if message is not None:
+                self.msg_dynamic_window = BaseWindow(self.gui, parent)
+                self.msg_dynamic_window.wm_title("sticker-convert")
+                self.message_var.set(message)
+                self.msg_dynamic_label = Label(
+                    self.msg_dynamic_window.scrollable_frame,
+                    textvariable=self.message_var,
+                )
+                self.msg_dynamic_bar = Progressbar(
+                    self.msg_dynamic_window.scrollable_frame,
+                    orient="horizontal",
+                    mode="indeterminate",
+                )
+                self.msg_dynamic_bar.start(50)
+                self.msg_dynamic_label.pack()
+                self.msg_dynamic_bar.pack(fill="x")
+                self.gui.action = partial(
+                    GUIUtils.finalize_window, self.msg_dynamic_window
+                )
+                print(message, end="\r", flush=True)
+                ret = True
+            else:
+                print()
+                ret = False
+        elif self.msg_dynamic_window.winfo_exists() == 0:
+            self.msg_dynamic_window = None
+            print()
+            ret = False
+        else:
+            if message is None:
+
+                def _action():
+                    assert self.msg_dynamic_window is not None
+                    self.msg_dynamic_window.destroy()
+                    self.msg_dynamic_window = None
+
+                self.gui.action = _action
+                print()
+                ret = False
+            else:
+                self.gui.action = partial(self.message_var.set, message)
+                print(message, end="\r", flush=True)
+                ret = True
+
+        if self.gui.action is not None:
+            self.gui.event_generate("<<exec_in_main>>")
+            self.gui.response_event.wait()
+            self.gui.response_event.clear()
+
+        return ret
+
+    def cb_bar(
+        self,
+        set_progress_mode: Optional[str] = None,
+        steps: int = 0,
+        update_bar: int = 0,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self.gui.progress_frame.update_progress_bar(
+            set_progress_mode, steps, update_bar, *args, **kwargs
+        )
+
+    def put(self, i: Union[CbQueueItemType, str]) -> Union[str, bool, None]:
+        if isinstance(i, tuple):
+            action = i[0]
+            if len(i) >= 2:
+                args: Tuple[Any, ...] = i[1] if i[1] else tuple()
             else:
                 args = tuple()
             if len(i) >= 3:
@@ -202,10 +432,12 @@ class Callback(CallbackProtocol):
             self.bar(update_bar=1)
         elif action == "msg_block":
             return self.msg_block(*args, **kwargs)
+        elif action == "msg_dynamic":
+            return self.msg_dynamic(*args, **kwargs)
         elif action == "ask_bool":
             return self.ask_bool(*args, **kwargs)
         elif action == "ask_str":
-            return self.ask_str(**kwargs)
+            return self.ask_str(*args, **kwargs)
         else:
             self.msg(action)
         return None

sticker_convert/utils/emoji.py

@@ -1,11 +1,23 @@
 #!/usr/bin/env python3
-from typing import List
+from typing import Callable, List, Sequence, Set
 
-from sticker_convert.utils.files.json_resources_loader import EMOJI_JSON
+from ugrapheme import graphemes  # type: ignore
+
+from sticker_convert.utils.files.json_resources_loader import load_resource_json
+
+graphemes: Callable[[str], Sequence[str]]  # type: ignore
+
+
+# https://stackoverflow.com/a/480227
+# Return list of unique items of list while preserve order
+def uniques(seq: List[str]):
+    seen: Set[str] = set()
+    seen_add = seen.add
+    return [x for x in seq if not (x in seen or seen_add(x))]
 
 
 def get_emoji_list() -> List[str]:
-    return [i["emoji"] for i in EMOJI_JSON]
+    return [i["emoji"] for i in load_resource_json("emoji")]
 
 
 EMOJI_LIST = get_emoji_list()
@@ -13,4 +25,4 @@ EMOJI_LIST = get_emoji_list()
 
 # https://stackoverflow.com/a/43146653
 def extract_emojis(s: str) -> str:
-    return "".join(set(c for c in s if c in EMOJI_LIST))
+    return "".join(uniques(list(c for c in graphemes(s) if c in EMOJI_LIST)))

sticker_convert/utils/files/json_resources_loader.py

@@ -1,27 +1,32 @@
-from typing import Any, Dict
+#!/usr/bin/env python3
+from typing import Any, Dict, cast
 
 from mergedeep import merge  # type: ignore
 
-from sticker_convert.definitions import CONFIG_DIR, ROOT_DIR
+from sticker_convert.definitions import CONFIG_DIR, ROOT_DIR, RUNTIME_STATE
 from sticker_convert.utils.files.json_manager import JsonManager
 
 
-def _load_compression() -> Dict[Any, Any]:
-    compression_json = JsonManager.load_json(ROOT_DIR / "resources/compression.json")
-    custom_preset_json_path = CONFIG_DIR / "custom_preset.json"
-    if custom_preset_json_path.exists():
-        custom_preset_json = JsonManager.load_json(custom_preset_json_path)
-        compression_json: Dict[Any, Any] = merge(  # type: ignore
-            compression_json,  # type: ignore
-            custom_preset_json,
-        )
-    return compression_json
+def load_resource_json(json_name: str) -> Dict[Any, Any]:
+    if RUNTIME_STATE.get(f"{json_name}_json") is not None:
+        return cast(Dict[Any, Any], RUNTIME_STATE[f"{json_name}_json"])
+    else:
+        loaded_json = JsonManager.load_json(ROOT_DIR / f"resources/{json_name}.json")
 
+        json_to_merge = None
+        lang = RUNTIME_STATE["LANG"]
+        if lang != "en_US":
+            # Translated json
+            json_to_merge = ROOT_DIR / f"resources/{json_name}.{lang}.json"
+        if json_name == "compression":
+            # Custom preset json
+            json_to_merge = CONFIG_DIR / "custom_preset.json"
 
-HELP_JSON: Dict[str, Dict[str, str]] = JsonManager.load_json(
-    ROOT_DIR / "resources/help.json"
-)
-INPUT_JSON = JsonManager.load_json(ROOT_DIR / "resources/input.json")
-COMPRESSION_JSON = _load_compression()
-OUTPUT_JSON = JsonManager.load_json(ROOT_DIR / "resources/output.json")
-EMOJI_JSON = JsonManager.load_json(ROOT_DIR / "resources/emoji.json")
+        if json_to_merge and json_to_merge.exists():
+            custom_preset_json = JsonManager.load_json(json_to_merge)
+            loaded_json: Dict[Any, Any] = merge(  # type: ignore
+                loaded_json,  # type: ignore
+                custom_preset_json,
+            )
+        RUNTIME_STATE[f"{json_name}_json"] = loaded_json
+        return loaded_json

sticker_convert/utils/files/metadata_handler.py

@@ -5,7 +5,7 @@ import json
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-from sticker_convert.utils.files.json_resources_loader import INPUT_JSON, OUTPUT_JSON
+from sticker_convert.utils.files.json_resources_loader import load_resource_json
 from sticker_convert.utils.media.codec_info import CodecInfo
 
 RELATED_EXTENSIONS = (
@@ -166,7 +166,7 @@ class MetadataHandler:
         Does not check if metadata provided via user input in GUI or flag options
         metadata = 'title' or 'author'
         """
-        input_presets = INPUT_JSON
+        input_presets = load_resource_json("input")
         assert input_presets
 
         if input_option == "local":
@@ -185,7 +185,7 @@ class MetadataHandler:
     @staticmethod
     def check_metadata_required(output_option: str, metadata: str) -> bool:
         # metadata = 'title' or 'author'
-        output_presets = OUTPUT_JSON
+        output_presets = load_resource_json("output")
         assert output_presets
         return output_presets[output_option]["metadata_requirements"][metadata]
 

sticker_convert/utils/translate.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+import gettext
+import locale
+import platform
+import sys
+from json import JSONDecodeError
+from multiprocessing import current_process
+from typing import Any, Callable, Dict, cast
+
+from sticker_convert.definitions import CONFIG_DIR, ROOT_DIR, RUNTIME_STATE
+from sticker_convert.utils.files.json_manager import JsonManager
+
+LANG_DICT = {
+    "en_US": ("en_US",),
+    "ja_JP": ("ja_jp",),
+    "zh_CN": ("zh_chs", "zh_cn", "zh_sg"),
+    "zh_TW": ("zh_tw", "zh_hk", "zh_mo", "zh_cht"),
+}
+
+
+def get_default_lang() -> str:
+    lang = locale.getlocale()[0]
+    winlang = ""
+    if platform.system() == "Windows":
+        import ctypes
+
+        windll = ctypes.windll.kernel32  # type: ignore
+        winlang_id = cast(int, windll.GetUserDefaultUILanguage())  # type: ignore
+        winlang = cast(str, locale.windows_locale[winlang_id])  # type: ignore
+
+    for k, v in LANG_DICT.items():
+        for i in v:
+            if (
+                lang is not None and lang.lower().startswith(i)
+            ) or winlang.lower().startswith(i):
+                return k
+
+    return "en_US"
+
+
+def get_lang() -> str:
+    # Priority 1: From --lang CLI flag
+    is_lang = False
+    lang = None
+    for i in sys.argv:
+        if is_lang:
+            return i
+        if i == "--lang":
+            is_lang = True
+
+    # Priority 2: From config
+    settings_path = CONFIG_DIR / "config.json"
+    if settings_path.is_file():
+        try:
+            settings: Dict[Any, Any] = JsonManager.load_json(settings_path)
+            lang = settings.get("lang")
+            if lang:
+                if lang in LANG_DICT:
+                    return lang
+                elif lang != "auto":
+                    return "en_US"
+        except JSONDecodeError:
+            pass
+
+    # Priority 3: Default locale
+    lang = get_default_lang()
+    return lang
+
+
+LANG = RUNTIME_STATE.get("LANG", get_lang())
+RUNTIME_STATE["LANG"] = LANG
+
+
+def gettext_dummy(x: str) -> str:
+    return x
+
+
+def get_translator() -> Callable[[str], str]:
+    if RUNTIME_STATE.get("TRANS") is not None:
+        return RUNTIME_STATE["TRANS"]
+
+    try:
+        trans: Callable[[str], str] = gettext.translation(
+            "base", ROOT_DIR / "locales", languages=[RUNTIME_STATE["LANG"]]
+        ).gettext
+    except FileNotFoundError:
+        if current_process().name == "MainProcess":
+            print(f"Warning: Cannot find locales/{LANG}/LC_MESSAGES/base.mo")
+            print(
+                "Please generate by running scripts/update-locales.sh in root of repo"
+            )
+            print("Fallback to using English...")
+        trans = gettext_dummy
+    RUNTIME_STATE["TRANS"] = trans
+    return trans
+
+
+def I(x: str) -> str:  # noqa: E743
+    return get_translator()(x)
+
+
+SUPPORTED_LANG = {
+    I("Auto"): "auto",
+    "English": "en_US",
+    "繁體中文": "zh_TW",
+    "简体中文": "zh_CN",
+    "日本語": "ja_JP",
+}

sticker_convert/utils/url_detect.py

@@ -1,37 +1,40 @@
-#!/usr/bin/env python3
-import string
-from typing import Optional
-from urllib.parse import urlparse
-
-
-class UrlDetect:
-    @staticmethod
-    def detect(url: str) -> Optional[str]:
-        domain = urlparse(url).netloc
-
-        if domain == "signal.art" or url.startswith("sgnl://addstickers/"):
-            return "signal"
-
-        if domain in ("telegram.me", "t.me"):
-            return "telegram"
-
-        if (
-            domain in ("store.line.me", "line.me")
-            or url.startswith("line://shop/detail/")
-            or (len(url) == 24 and all(c in string.hexdigits for c in url))
-        ):
-            return "line"
-
-        if domain in ("e.kakao.com", "emoticon.kakao.com"):
-            return "kakao"
-
-        if domain == "www.band.us":
-            return "band"
-
-        if domain == "stickers.viber.com":
-            return "viber"
-
-        if domain == "discord.com":
-            return "discord"
-
-        return None
+#!/usr/bin/env python3
+import string
+from typing import Optional
+from urllib.parse import urlparse
+
+
+class UrlDetect:
+    @staticmethod
+    def detect(url: str) -> Optional[str]:
+        domain = urlparse(url).netloc
+
+        if domain == "signal.art" or url.startswith("sgnl://addstickers/"):
+            return "signal"
+
+        if domain in ("telegram.me", "t.me"):
+            return "telegram"
+
+        if (
+            domain in ("store.line.me", "line.me")
+            or url.startswith("line://shop/detail/")
+            or (len(url) == 24 and all(c in string.hexdigits for c in url))
+        ):
+            return "line"
+
+        if domain in ("e.kakao.com", "emoticon.kakao.com"):
+            return "kakao"
+
+        if domain == "www.band.us":
+            return "band"
+
+        if domain == "ogqmarket.naver.com":
+            return "ogq"
+
+        if domain == "stickers.viber.com":
+            return "viber"
+
+        if domain == "discord.com":
+            return "discord"
+
+        return None

sticker_convert/version.py

@@ -1,3 +1,3 @@
 #!/usr/bin/env python3
 
-__version__ = "2.13.3.0"
+__version__ = "2.17.0.0"