sticker-convert 2.14.0.0__py3-none-any.whl → 2.15.0.0__py3-none-any.whl

sticker_convert/{utils/auth/get_kakao_auth_desktop_memdump.py → auth/auth_kakao_desktop_memdump.py}

@@ -4,11 +4,10 @@ import platform
 import re
 import subprocess
 import time
-from functools import partial
-from getpass import getpass
 from pathlib import Path
-from typing import Callable, Optional, Tuple, Union, cast
+from typing import Any, Optional, Tuple, Union, cast
 
+from sticker_convert.auth.auth_base import AuthBase
 from sticker_convert.utils.process import find_pid_by_name, get_mem, killall
 
 MSG_NO_BIN = """Kakao Desktop not detected.
@@ -26,13 +25,9 @@ MSG_LAUNCH_FAIL = "Failed to launch Kakao"
 MSG_PERMISSION_ERROR = "Failed to read Kakao process memory"
 
 
-class GetKakaoAuthDesktopMemdump:
-    def __init__(self, cb_ask_str: Callable[..., str] = input) -> None:
-        self.cb_ask_str = cb_ask_str
-        if platform.system() == "Windows":
-            self.auth_token_length = 64
-        else:
-            self.auth_token_length = 52
+class AuthKakaoDesktopMemdump(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
 
     def launch_kakao(self, kakao_bin_path: str) -> None:
         if platform.system() == "Windows":
@@ -73,11 +68,12 @@ class GetKakaoAuthDesktopMemdump:
                 ):
                     auth_token_addr = cast(int, address) + 15
                     auth_token_bytes = process.read_process_memory(
-                        auth_token_addr, bytes, self.auth_token_length + 1
+                        auth_token_addr, bytes, 200
                     )
-                    if auth_token_bytes[-1:] != b"\x00":
+                    auth_token_term = auth_token_bytes.find(b"\x00")
+                    if auth_token_term == -1:
                         continue
-                    auth_token_candidate = auth_token_bytes[:-1].decode(
+                    auth_token_candidate = auth_token_bytes[:auth_token_term].decode(
                         encoding="ascii"
                     )
                     if len(auth_token_candidate) > 150:
@@ -114,12 +110,18 @@ class GetKakaoAuthDesktopMemdump:
             if relaunch and self.relaunch_kakao(kakao_bin_path) is None:
                 return None, MSG_LAUNCH_FAIL
 
-        if self.cb_ask_str == input:
-            pw_func = getpass
-        else:
-            pw_func = partial(
-                self.cb_ask_str, initialvalue="", cli_show_initialvalue=False
+        def pw_func(msg: str) -> str:
+            return self.cb.put(
+                (
+                    "ask_str",
+                    None,
+                    {
+                        "message": msg,
+                        "password": True,
+                    },
+                )
             )
+
         s = get_mem(kakao_pid, pw_func, is_wine)
 
         if s is None:
@@ -129,12 +131,13 @@ class GetKakaoAuthDesktopMemdump:
         for i in re.finditer(b"authorization: ", s):
             auth_token_addr = i.start() + 15
 
-            auth_token_bytes = s[
-                auth_token_addr : auth_token_addr + self.auth_token_length + 1
-            ]
-            if auth_token_bytes[-1:] != b"\x00":
-                return None, MSG_NO_AUTH
-            auth_token_candidate = auth_token_bytes[:-1].decode(encoding="ascii")
+            auth_token_bytes = s[auth_token_addr : auth_token_addr + 200]
+            auth_token_term = auth_token_bytes.find(b"\x00")
+            if auth_token_term == -1:
+                continue
+            auth_token_candidate = auth_token_bytes[:auth_token_term].decode(
+                encoding="ascii"
+            )
             if len(auth_token_candidate) > 150:
                 auth_token = auth_token_candidate
                 break
@@ -247,6 +250,8 @@ class GetKakaoAuthDesktopMemdump:
         # - Slow
         # - Cannot run on macOS
 
+        msg = "Getting Kakao authorization token by Desktop memdump...\n(This may take a minute)"
+        self.cb.put(("msg_dynamic", (msg,), None))
         if not kakao_bin_path:
             kakao_bin_path = self.get_kakao_desktop()
 
@@ -262,4 +267,6 @@ class GetKakaoAuthDesktopMemdump:
         else:
             kakao_auth, msg = self.get_auth_by_dump(kakao_bin_path)
 
+        self.cb.put(("msg_dynamic", (None,), None))
+
         return kakao_auth, msg

sticker_convert/{utils/auth/get_line_auth.py → auth/auth_line.py}

@@ -2,14 +2,25 @@
 import json
 import platform
 from http.cookiejar import CookieJar
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import requests
 import rookiepy
 
+from sticker_convert.auth.auth_base import AuthBase
+
+OK_MSG = "Got Line cookies successfully"
+FAIL_MSG = "Failed to get Line cookies. Have you logged in the web browser?"
+
+
+class AuthLine(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    def get_cred(self) -> Tuple[Optional[str], str]:
+        msg = "Getting Line cookies"
+        self.cb.put(("msg_dynamic", (msg,), None))
 
-class GetLineAuth:
-    def get_cred(self) -> Optional[str]:
         browsers: List[Callable[..., Any]] = [
             rookiepy.load,  # Supposed to load from any browser, but may fail
             rookiepy.firefox,
@@ -44,19 +55,23 @@ class GetLineAuth:
                 cookies_dict = browser(["store.line.me"])
                 cookies_jar = rookiepy.to_cookiejar(cookies_dict)
 
-                if GetLineAuth.validate_cookies(cookies_jar):
+                if AuthLine.validate_cookies(cookies_jar):
                     break
 
             except Exception:
                 continue
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if cookies_dict is None or cookies_jar is None:
-            return None
+            return (
+                None,
+                "Failed to get Line cookies. Have you logged in the web browser?",
+            )
 
         cookies_list = ["%s=%s" % (i["name"], i["value"]) for i in cookies_dict]
         cookies = ";".join(cookies_list)
 
-        return cookies
+        return cookies, OK_MSG
 
     @staticmethod
     def validate_cookies(cookies: Union[CookieJar, Dict[str, str]]) -> bool:

sticker_convert/{utils/auth/get_signal_auth.py → auth/auth_signal.py}

@@ -5,43 +5,33 @@ import platform
 import shutil
 import time
 import webbrowser
-from typing import Callable, Optional, Tuple, cast
+from typing import Any, Optional, Tuple, cast
 
+from sticker_convert.auth.auth_base import AuthBase
 from sticker_convert.definitions import CONFIG_DIR
 from sticker_convert.utils.chrome_remotedebug import CRD
 from sticker_convert.utils.process import killall
 
 
-class GetSignalAuth:
-    def __init__(
-        self,
-        cb_msg: Callable[..., None] = print,
-        cb_ask_str: Callable[..., str] = input,
-    ) -> None:
+class AuthSignal(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
         chromedriver_download_dir = CONFIG_DIR / "bin"
         os.makedirs(chromedriver_download_dir, exist_ok=True)
 
         self.chromedriver_download_dir = chromedriver_download_dir
 
-        self.cb_ask_str = cb_ask_str
-        self.cb_msg = cb_msg
-
     def download_signal_desktop(self) -> None:
         download_url = "https://signal.org/en/download/"
 
         webbrowser.open(download_url)
 
-        self.cb_msg(download_url)
+        self.cb.put(download_url)
 
         prompt = "Signal Desktop not detected.\n"
         prompt += "Download and install Signal Desktop version\n"
         prompt += "After installation, quit Signal Desktop before continuing"
-        if self.cb_ask_str != input:
-            self.cb_ask_str(
-                prompt, initialvalue=download_url, cli_show_initialvalue=False
-            )
-        else:
-            self.cb_msg(prompt)
+        self.cb.put(("ask_str", (prompt,), None))
 
     def get_signal_bin_path(self) -> Optional[str]:
         signal_paths: Tuple[Optional[str], ...]
@@ -73,11 +63,14 @@ class GetSignalAuth:
                 return signal_path
         return None
 
-    def get_cred(self) -> Tuple[Optional[str], Optional[str]]:
+    def get_cred(self) -> Tuple[Optional[str], Optional[str], str]:
+        msg = "Getting Signal credentials..."
+        self.cb.put(("msg_dynamic", (msg,), None))
         signal_bin_path = self.get_signal_bin_path()
         if signal_bin_path is None:
+            self.cb.put(("msg_dynamic", (None,), None))
             self.download_signal_desktop()
-            return None, None
+            return None, None, "Failed to get uuid and password"
 
         if platform.system() == "Windows":
             killall("signal")
@@ -132,4 +125,9 @@ class GetSignalAuth:
             time.sleep(1)
 
         crd.close()
-        return uuid, password
+        self.cb.put(("msg_dynamic", (None,), None))
+        return (
+            uuid,
+            password,
+            f"Got uuid and password successfully:\nuuid={uuid}\npassword={password}",
+        )

sticker_convert/auth/auth_telethon.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+from typing import Any, Optional, Tuple
+
+import anyio
+from telethon import TelegramClient  # type: ignore
+from telethon.errors import RPCError, SessionPasswordNeededError  # type: ignore
+
+from sticker_convert.auth.auth_base import AuthBase
+from sticker_convert.definitions import CONFIG_DIR
+
+GUIDE_MSG = """1. Visit https://my.telegram.org
+2. Login using your phone number
+3. Go to "API development tools"
+4. Fill form
+- App title: sticker-convert
+- Short name: sticker-convert
+- URL: www.telegram.org
+- Platform: Desktop
+- Description: sticker-convert
+5. Note down api_id and api_hash
+Continue when done"""
+OK_MSG = "Telethon setup successful"
+FAIL_MSG = "Telethon setup failed"
+
+
+class AuthTelethon(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    async def signin_async(
+        self, try_sign_in: bool = True
+    ) -> Tuple[bool, TelegramClient, int, str, str]:
+        client = TelegramClient(
+            CONFIG_DIR / f"telethon-{self.opt_cred.telethon_api_id}.session",
+            self.opt_cred.telethon_api_id,
+            self.opt_cred.telethon_api_hash,
+        )
+
+        await client.connect()
+        authed = await client.is_user_authorized()
+        if authed is False and try_sign_in is True:
+            error_msg = ""
+            while True:
+                msg = f"{error_msg}Enter phone number: "
+                phone_number = self.cb.put(("ask_str", (msg,), None))
+                if phone_number == "":
+                    return False, client, 0, "", FAIL_MSG
+                try:
+                    await client.send_code_request(phone_number)
+                    break
+                except RPCError as e:
+                    error_msg = f"Error: {e}\n"
+
+            error_msg = ""
+            while True:
+                msg = f"{error_msg}Enter code: "
+                code = self.cb.put(("ask_str", (msg,), None))
+                if code == "":
+                    return False, client, 0, "", FAIL_MSG
+                try:
+                    await client.sign_in(phone_number, code)
+                    break
+                except SessionPasswordNeededError:
+                    password = self.cb.put(
+                        (
+                            "ask_str",
+                            None,
+                            {"question": "Enter password: ", "password": True},
+                        )
+                    )
+                    try:
+                        await client.sign_in(password=password)
+                        break
+                    except RPCError as e:
+                        error_msg = f"Error: {e}\n"
+                except RPCError as e:
+                    error_msg = f"Error: {e}\n"
+            authed = await client.is_user_authorized()
+
+        return (
+            authed,
+            client,
+            self.opt_cred.telethon_api_id,
+            self.opt_cred.telethon_api_hash,
+            OK_MSG if authed else FAIL_MSG,
+        )
+
+    def guide(self) -> None:
+        self.cb.put(("msg_block", (GUIDE_MSG,), None))
+
+    def get_api_info(self) -> bool:
+        api_id_ask = "Enter api_id: "
+        wrong_hint = ""
+
+        while True:
+            telethon_api_id = self.cb.put(
+                (
+                    "ask_str",
+                    None,
+                    {
+                        "question": wrong_hint + api_id_ask,
+                        "initialvalue": str(self.opt_cred.telethon_api_id),
+                    },
+                )
+            )
+            if telethon_api_id == "":
+                return False
+            elif telethon_api_id.isnumeric():
+                self.opt_cred.telethon_api_id = int(telethon_api_id)
+                break
+            else:
+                wrong_hint = "Error: api_id should be numeric\n"
+
+        msg = "Enter api_hash: "
+        self.opt_cred.telethon_api_hash = self.cb.put(
+            (
+                "ask_str",
+                None,
+                {"question": msg, "initialvalue": self.opt_cred.telethon_api_hash},
+            )
+        )
+        if self.opt_cred.telethon_api_hash == "":
+            return False
+        return True
+
+    async def start_async(
+        self, check_auth_only: bool = False
+    ) -> Tuple[bool, Optional[TelegramClient], int, str, str]:
+        if self.opt_cred.telethon_api_id != 0 and self.opt_cred.telethon_api_hash != "":
+            success, client, api_id, api_hash, msg = await self.signin_async(
+                try_sign_in=False
+            )
+            if check_auth_only:
+                client.disconnect()
+            if success is True:
+                return success, client, api_id, api_hash, msg
+
+        self.guide()
+        cred_valid = self.get_api_info()
+        if cred_valid:
+            success, client, api_id, api_hash, msg = await self.signin_async()
+            if check_auth_only:
+                client.disconnect()
+            return success, client, api_id, api_hash, msg
+        else:
+            return False, None, 0, "", FAIL_MSG
+
+    def start(
+        self, check_auth_only: bool = False
+    ) -> Tuple[bool, Optional[TelegramClient], int, str, str]:
+        return anyio.run(self.start_async, check_auth_only)

sticker_convert/{utils/auth/get_viber_auth.py → auth/auth_viber.py}

@@ -5,11 +5,10 @@ import platform
 import shutil
 import subprocess
 import time
-from functools import partial
-from getpass import getpass
 from pathlib import Path
-from typing import Callable, List, Optional, Tuple, cast
+from typing import Any, Callable, List, Optional, Tuple, cast
 
+from sticker_convert.auth.auth_base import AuthBase
 from sticker_convert.utils.process import check_admin, find_pid_by_name, get_mem, killall
 
 MSG_NO_BIN = """Viber Desktop not detected.
@@ -27,9 +26,9 @@ MSG_LAUNCH_FAIL = "Failed to launch Viber"
 MSG_PERMISSION_ERROR = "Failed to read Viber process memory"
 
 
-class GetViberAuth:
-    def __init__(self, cb_ask_str: Callable[..., str] = input) -> None:
-        self.cb_ask_str = cb_ask_str
+class AuthViber(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
 
     def relaunch_viber(self, viber_bin_path: str) -> Optional[int]:
         killed = killall("viber")
@@ -124,12 +123,18 @@ class GetViberAuth:
         if viber_pid is None:
             return None, MSG_LAUNCH_FAIL
 
-        if self.cb_ask_str == input:
-            pw_func = getpass
-        else:
-            pw_func = partial(
-                self.cb_ask_str, initialvalue="", cli_show_initialvalue=False
+        def pw_func(msg: str) -> str:
+            return self.cb.put(
+                (
+                    "ask_str",
+                    None,
+                    {
+                        "message": msg,
+                        "password": True,
+                    },
+                )
             )
+
         s = get_mem(viber_pid, pw_func)
 
         if s is None:
@@ -189,6 +194,8 @@ class GetViberAuth:
         self,
         viber_bin_path: Optional[str] = None,
     ) -> Tuple[Optional[str], str]:
+        msg = "Getting Viber credentials...\n(This may take a minute)"
+        self.cb.put(("msg_dynamic", (msg,), None))
         if not viber_bin_path:
             viber_bin_path = self.get_viber_desktop()
 
@@ -232,4 +239,5 @@ class GetViberAuth:
                 break
 
         killall("viber")
+        self.cb.put(("msg_dynamic", (None,), None))
         return viber_auth, msg

sticker_convert/{utils/auth → auth}/telegram_api.py

@@ -3,7 +3,7 @@ import re
 import time
 from collections import defaultdict
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Protocol, Tuple, Union, cast
+from typing import Any, Dict, List, Protocol, Tuple, Union, cast
 
 import anyio
 from telegram import InputSticker, PhotoSize, Sticker
@@ -15,8 +15,8 @@ from telethon.functions import messages  # type: ignore
 from telethon.tl.types.messages import StickerSet as TLStickerSet  # type: ignore
 from telethon.types import DocumentAttributeFilename, InputStickerSetShortName, InputStickerSetThumb, Message, TypeDocument  # type: ignore
 
+from sticker_convert.auth.auth_telethon import AuthTelethon
 from sticker_convert.job_option import CredOption
-from sticker_convert.utils.auth.telethon_setup import TelethonSetup
 from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
 
 # sticker_path: Path, sticker_bytes: bytes, emoji_list: List[str], sticker_format: str
@@ -343,8 +343,8 @@ class TelethonAPI(TelegramAPI):
         self.cb = cb
         self.cb_return = cb_return
 
-        success, client, _, _ = await TelethonSetup(
-            self.opt_cred, self.cb_ask_str
+        success, client, _, _, _ = await AuthTelethon(
+            self.opt_cred, self.cb
         ).start_async()
 
         if success is True and client is not None:
@@ -354,15 +354,6 @@ class TelethonAPI(TelegramAPI):
     async def exit(self) -> None:
         self.client.disconnect()
 
-    def cb_ask_str(
-        self, msg: Optional[str] = None, initialvalue: Optional[str] = None
-    ) -> str:
-        self.cb.put(("ask_str", (msg,), None))
-        response = self.cb_return.get_response()
-
-        assert isinstance(response, str)
-        return response
-
     async def set_upload_pack_short_name(self, pack_title: str) -> str:
         self.pack_title = pack_title
         self.pack_short_name = re.sub(