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

sticker_convert/auth/auth_base.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+from typing import Optional
+
+from sticker_convert.job_option import CredOption
+from sticker_convert.utils.callback import CallbackCli, CallbackProtocol
+
+
+class AuthBase:
+    def __init__(
+        self,
+        opt_cred: CredOption,
+        cb: Optional[CallbackProtocol] = None,
+    ) -> None:
+        self.opt_cred = opt_cred
+        self.cb: CallbackProtocol
+        if cb is None:
+            self.cb = CallbackCli()
+        else:
+            self.cb = cb

sticker_convert/{utils/auth/get_discord_auth.py → auth/auth_discord.py}

@@ -4,23 +4,27 @@ import os
 import platform
 import shutil
 import time
-from typing import Callable, Optional, Tuple
+from pathlib import Path
+from typing import Any, Optional, Tuple
 from urllib.parse import urlparse
 
+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
+from sticker_convert.utils.process import find_pid_by_name, killall
 
+OK_MSG = "Got token successfully:\ntoken={token}"
+FAIL_MSG = "Failed to get token"
 
-class GetDiscordAuth:
-    def __init__(self, cb_msg: Callable[..., None] = print) -> None:
+
+class AuthDiscord(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_msg = cb_msg
-
     def get_discord_bin_path(self) -> Optional[str]:
         discord_bin: Optional[str]
         if platform.system() == "Windows":
@@ -42,6 +46,8 @@ class GetDiscordAuth:
             for discord_dir, discord_bin in discord_win_dirs:
                 app_dir: Optional[str] = None
                 chrome_path: Optional[str] = None
+                if os.path.isdir(discord_dir) is False:
+                    continue
                 for i in [j for j in os.listdir(discord_dir) if j.startswith("app-")]:
                     app_dir = os.path.join(discord_dir, i)
                     chrome_path = os.path.join(app_dir, discord_bin)
@@ -67,6 +73,9 @@ class GetDiscordAuth:
         return None
 
     def get_cred(self) -> Tuple[Optional[str], str]:
+        msg = "Getting Discord authorization token..."
+        self.cb.put(("msg_dynamic", (msg,), None))
+
         using_discord_app = False
         chrome_path = self.get_discord_bin_path()
         if chrome_path is not None:
@@ -74,14 +83,26 @@ class GetDiscordAuth:
         else:
             chrome_path = CRD.get_chromium_path()
         if chrome_path is None:
+            self.cb.put(("msg_dynamic", (None,), None))
             return (
                 None,
                 "Please install Discord Desktop or Chrome/Chromium and try again",
             )
 
         token = None
-        if using_discord_app:
-            killall("discord")
+
+        if find_pid_by_name(Path(chrome_path).name):
+            response = self.cb.put(
+                (
+                    "ask_bool",
+                    (f"All {Path(chrome_path).name} will be closed. Continue?",),
+                    None,
+                )
+            )
+            if response is True:
+                killall(Path(chrome_path).name.lower())
+            else:
+                return None, FAIL_MSG
 
         crd = CRD(chrome_path)
         while True:
@@ -98,9 +119,14 @@ class GetDiscordAuth:
 
         while True:
             try:
-                r = crd.exec_js(
-                    "(webpackChunkdiscord_app.push([[''],{},e=>{m=[];for(let c in e.c)m.push(e.c[c])}]),m).find(m=>m?.exports?.default?.getToken!==void 0).exports.default.getToken();"
-                )
+                if using_discord_app:
+                    r = crd.exec_js(
+                        "(webpackChunkdiscord_app.push([[''],{},e=>{m=[];for(let c in e.c)m.push(e.c[c])}]),m).find(m=>m?.exports?.default?.getToken!==void 0).exports.default.getToken();"
+                    )
+                else:
+                    r = crd.exec_js(
+                        "const iframe=document.createElement('iframe');JSON.parse(document.body.appendChild(iframe).contentWindow.localStorage.token);"
+                    )
             except RuntimeError:
                 break
             if (
@@ -112,7 +138,8 @@ class GetDiscordAuth:
             time.sleep(1)
         crd.close()
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if token is None:
-            return None, "Failed to get token"
+            return None, FAIL_MSG
 
-        return token, f"Got token successfully:\ntoken={token}"
+        return token, OK_MSG.format(token=token)

sticker_convert/{utils/auth/get_kakao_auth_android_login.py → auth/auth_kakao_android_login.py}

@@ -2,31 +2,24 @@
 import json
 import secrets
 import uuid
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 from urllib.parse import parse_qs, urlparse
 
 import requests
 from bs4 import BeautifulSoup
 
-from sticker_convert.job_option import CredOption
+from sticker_convert.auth.auth_base import AuthBase
 
+OK_MSG = "Got auth_token successfully:\n{auth_token=}\n"
 
-class GetKakaoAuthAndroidLogin:
-    def __init__(
-        self,
-        opt_cred: CredOption,
-        cb_msg: Callable[..., None] = print,
-        cb_msg_block: Callable[..., Any] = input,
-        cb_ask_str: Callable[..., str] = input,
-    ) -> None:
-        self.username = opt_cred.kakao_username
-        self.password = opt_cred.kakao_password
-        self.country_code = opt_cred.kakao_country_code
-        self.phone_number = opt_cred.kakao_phone_number
 
-        self.cb_msg = cb_msg
-        self.cb_msg_block = cb_msg_block
-        self.cb_ask_str = cb_ask_str
+class AuthKakaoAndroidLogin(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.username = self.opt_cred.kakao_username
+        self.password = self.opt_cred.kakao_password
+        self.country_code = self.opt_cred.kakao_country_code
+        self.phone_number = self.opt_cred.kakao_phone_number
 
         self.device_uuid = secrets.token_hex(32)
         self.device_ssaid = secrets.token_hex(20)
@@ -67,8 +60,9 @@ class GetKakaoAuthAndroidLogin:
                 return a.get("href").split("/")[-1]
         return "25.2.1"
 
-    def login(self) -> bool:
-        self.cb_msg("Logging in")
+    def login(self) -> Tuple[bool, str]:
+        msg = "Getting Kakao authorization token by Android login: Logging in"
+        self.cb.put(("msg_dynamic", (msg,), None))
 
         json_data = {
             "id": self.username,
@@ -83,29 +77,29 @@ class GetKakaoAuthAndroidLogin:
 
         response_json = json.loads(response.text)
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at login: {response.text}")
-            return False
+            return False, f"Failed at login: {response.text}"
 
         self.headers["Ss"] = response.headers["Set-SS"]
         self.country_dicts = response_json["viewData"]["countries"]["all"]
 
-        return True
+        return True, ""
 
-    def get_country_iso(self) -> bool:
+    def get_country_iso(self) -> Tuple[bool, str]:
         self.country_iso = None
         for country_dict in self.country_dicts:
             if country_dict["code"] == self.country_code:
                 self.country_iso = country_dict["iso"]
 
         if not self.country_iso:
-            self.cb_msg_block("Invalid country code")
-            return False
+            return False, "Invalid country code"
 
-        return True
+        return True, ""
 
-    def enter_phone(self) -> bool:
-        self.cb_msg("Submitting phone number")
+    def enter_phone(self) -> Tuple[bool, str]:
+        msg = "Getting Kakao authorization token by Android login: Submitting phone number"
+        self.cb.put(("msg_dynamic", (msg,), None))
 
         json_data: Dict[str, Any] = {
             "countryCode": self.country_code,
@@ -123,9 +117,9 @@ class GetKakaoAuthAndroidLogin:
 
         response_json = json.loads(response.text)
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at entering phone number: {response.text}")
-            return False
+            return False, f"Failed at entering phone number: {response.text}"
 
         self.verify_method = response_json["view"]
 
@@ -135,12 +129,9 @@ class GetKakaoAuthAndroidLogin:
             dest_number = response_json["viewData"]["moNumber"]
             msg = response_json["viewData"]["moMessage"]
             return self.verify_send_sms(dest_number, msg)
-        self.cb_msg_block(f"Unknown verification method: {response.text}")
-        return False
-
-    def verify_send_sms(self, dest_number: str, msg: str) -> bool:
-        self.cb_msg("Verification by sending SMS")
+        return False, f"Unknown verification method: {response.text}"
 
+    def verify_send_sms(self, dest_number: str, verify_msg: str) -> Tuple[bool, str]:
         response = requests.post(
             "https://katalk.kakao.com/android/account2/mo-sent", headers=self.headers
         )
@@ -148,15 +139,20 @@ class GetKakaoAuthAndroidLogin:
         response_json = json.loads(response.text)
 
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at confirm sending SMS: {response.text}")
-            return False
+            return False, f"Failed at confirm sending SMS: {response.text}"
 
         prompt = f"Send this SMS message to number {dest_number} then press enter:"
-        self.cb_msg(msg)
-        if self.cb_ask_str != input:
-            self.cb_ask_str(prompt, initialvalue=msg, cli_show_initialvalue=False)
-        else:
-            input(prompt)
+        self.cb.put(
+            (
+                "ask_str",
+                None,
+                {
+                    "msg": prompt,
+                    "initialvalue": verify_msg,
+                    "cli_show_initialvalue": False,
+                },
+            )
+        )
 
         response = requests.post(
             "https://katalk.kakao.com/android/account2/mo-confirm", headers=self.headers
@@ -165,21 +161,18 @@ class GetKakaoAuthAndroidLogin:
         response_json = json.loads(response.text)
 
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at verifying SMS sent: {response.text}")
-            return False
+            return False, f"Failed at verifying SMS sent: {response.text}"
 
         if response_json.get("reason") or "error" in response_json.get("message", ""):
-            self.cb_msg_block(f"Failed at verifying SMS sent: {response.text}")
-            return False
+            return False, f"Failed at verifying SMS sent: {response.text}"
 
         self.confirm_url = response_json.get("viewData", {}).get("url")
 
-        return True
-
-    def verify_receive_sms(self) -> bool:
-        self.cb_msg("Verification by receiving SMS")
+        return True, ""
 
-        passcode = self.cb_ask_str("Enter passcode received from SMS:")
+    def verify_receive_sms(self) -> Tuple[bool, str]:
+        msg = "Enter passcode received from SMS:"
+        passcode = self.cb.put(("ask_str", (msg,), None))
 
         json_data = {
             "passcode": passcode,
@@ -193,16 +186,19 @@ class GetKakaoAuthAndroidLogin:
 
         response_json = json.loads(response.text)
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at verifying passcode: {response.text}")
-            return False
+            return False, f"Failed at verifying passcode: {response.text}"
 
         self.confirm_url = response_json.get("viewData", {}).get("url")
 
-        return True
+        return True, ""
 
-    def confirm_device_change(self) -> bool:
-        self.cb_msg("Confirm device change")
+    def confirm_device_change(self) -> Tuple[bool, str]:
+        msg = (
+            "Getting Kakao authorization token by Android login: Confirm device change"
+        )
+        self.cb.put(("msg_dynamic", (msg,), None))
 
         confirm_url_parsed = urlparse(self.confirm_url)  # type: ignore
         confirm_url_qs = parse_qs(confirm_url_parsed.query)  # type: ignore
@@ -238,14 +234,15 @@ class GetKakaoAuthAndroidLogin:
 
         response_json = json.loads(response.text)
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at confirm device change: {response.text}")
-            return False
+            return False, f"Failed at confirm device change: {response.text}"
 
-        return True
+        return True, ""
 
-    def passcode_callback(self) -> bool:
-        self.cb_msg("Passcode callback")
+    def passcode_callback(self) -> Tuple[bool, str]:
+        msg = "Getting Kakao authorization token by Android login: Passcode callback"
+        self.cb.put(("msg_dynamic", (msg,), None))
 
         response = requests.get(
             "https://katalk.kakao.com/android/account2/passcode/callback",
@@ -254,14 +251,15 @@ class GetKakaoAuthAndroidLogin:
 
         response_json = json.loads(response.text)
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at passcode callback: {response.text}")
-            return False
+            return False, f"Failed at passcode callback: {response.text}"
 
-        return True
+        return True, ""
 
-    def skip_restoration(self) -> bool:
-        self.cb_msg("Skip restoration")
+    def skip_restoration(self) -> Tuple[bool, str]:
+        msg = "Getting Kakao authorization token by Android login: Skip restoration"
+        self.cb.put(("msg_dynamic", (msg,), None))
 
         response = requests.post(
             "https://katalk.kakao.com/android/account2/skip-restoration",
@@ -270,19 +268,19 @@ class GetKakaoAuthAndroidLogin:
         response_json = json.loads(response.text)
 
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at skip restoration: {response.text}")
-            return False
+            return False, f"Failed at skip restoration: {response.text}"
 
         self.nickname = response_json.get("viewData", {}).get("nickname")
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if self.nickname is None:
-            self.cb_msg_block(f"Failed at passcode callback: {response.text}")
-            return False
+            return False, f"Failed at passcode callback: {response.text}"
 
-        return True
+        return True, ""
 
-    def get_profile(self) -> bool:
-        self.cb_msg("Get profile")
+    def get_profile(self) -> Tuple[bool, str]:
+        msg = "Getting Kakao authorization token by Android login: Get profile"
+        self.cb.put(("msg_dynamic", (msg,), None))
 
         json_data = {
             "nickname": self.nickname,
@@ -298,18 +296,16 @@ class GetKakaoAuthAndroidLogin:
 
         response_json = json.loads(response.text)
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if response_json["status"] != 0:
-            self.cb_msg_block(f"Failed at get profile: {response.text}")
-            return False
+            return False, f"Failed at get profile: {response.text}"
 
         self.access_token = response_json["signupData"]["oauth2Token"]["accessToken"]
 
-        return True
-
-    def get_cred(self) -> Optional[str]:
-        self.cb_msg("Get authorization token")
+        return True, ""
 
-        authorization_token = None
+    def get_cred(self) -> Tuple[Optional[str], str]:
+        auth_token = None
 
         steps = (
             self.login,
@@ -322,9 +318,9 @@ class GetKakaoAuthAndroidLogin:
         )
 
         for step in steps:
-            success = step()
+            success, msg = step()
             if not success:
-                return None
+                return None, msg
 
-        authorization_token = self.access_token + "-" + self.device_uuid
-        return authorization_token
+        auth_token = self.access_token + "-" + self.device_uuid
+        return auth_token, OK_MSG.format(auth_token=auth_token)

sticker_convert/{utils/auth/get_kakao_auth_desktop_login.py → auth/auth_kakao_desktop_login.py}

@@ -4,40 +4,36 @@ import hashlib
 import json
 import os
 import platform
+import re
 import shutil
 import socket
 import subprocess
 import time
 import uuid
-from typing import Any, Callable, Optional, Tuple
+from typing import Any, Optional, Tuple
 
 import requests
+from bs4 import BeautifulSoup
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
-from sticker_convert.job_option import CredOption
+from sticker_convert.auth.auth_base import AuthBase
 
+OK_MSG = "Login successful, auth_token: {auth_token}"
 
-class GetKakaoAuthDesktopLogin:
-    def __init__(
-        self,
-        opt_cred: CredOption,
-        cb_msg: Callable[..., None] = print,
-        cb_msg_block: Callable[..., Any] = input,
-        cb_ask_str: Callable[..., str] = input,
-    ) -> None:
-        self.opt_cred = opt_cred
-        self.username = opt_cred.kakao_username
-        self.password = opt_cred.kakao_password
 
-        self.cb_msg = cb_msg
-        self.cb_msg_block = cb_msg_block
-        self.cb_ask_str = cb_ask_str
+class AuthKakaoDesktopLogin(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.username = self.opt_cred.kakao_username
+        self.password = self.opt_cred.kakao_password
 
         if platform.system() == "Darwin":
             self.plat = "mac"
             user_agent_os = "Mc"
             self.os_version = platform.mac_ver()[0]
-            version = "25.2.0"
+            version = self.macos_get_ver()
+            if version is None:
+                version = "25.2.0"
         else:
             self.plat = "win32"
             user_agent_os = "Wd"
@@ -45,7 +41,9 @@ class GetKakaoAuthDesktopLogin:
                 self.os_version = platform.uname().version
             else:
                 self.os_version = "10.0"
-            version = "25.7.7"
+            version = self.windows_get_ver()
+            if version is None:
+                version = "25.8.2"
 
         user_agent = f"KT/{version} {user_agent_os}/{self.os_version} en"
         self.headers = {
@@ -59,6 +57,8 @@ class GetKakaoAuthDesktopLogin:
         }
 
         self.device_name = socket.gethostname()
+        if platform.system() != "Darwin":
+            self.device_name = self.device_name.upper()
         self.device_uuid = self.get_device_uuid()
 
         hash = hashlib.sha512(
@@ -74,6 +74,31 @@ class GetKakaoAuthDesktopLogin:
     def pkcs7_pad(self, m: str) -> str:
         return m + chr(16 - len(m) % 16) * (16 - len(m) % 16)
 
+    def windows_get_ver(self) -> Optional[str]:
+        r = requests.get(
+            "https://api.github.com/repos/microsoft/winget-pkgs/contents/manifests/k/Kakao/KakaoTalk"
+        )
+        rjson = json.loads(r.text)
+        if len(rjson) == 0:
+            return None
+        ver = rjson[-1]["name"]
+        return ".".join(ver.split(".")[:3])
+
+    def macos_get_ver(self) -> Optional[str]:
+        country = "us"
+        app_name = "kakaotalk-messenger"
+        app_id = "362057947"
+
+        url = f"https://apps.apple.com/{country}/app/{app_name}/id{app_id}"
+
+        r = requests.get(url)
+        soup = BeautifulSoup(r.text, "html.parser")
+        version_tag = soup.find("p", {"class": re.compile(".*latest__version")})
+        version_str = None
+        if version_tag is not None:
+            version_str = version_tag.text.replace("Version ", "")
+        return version_str
+
     def windows_get_pragma(self, use_wine: bool = False) -> Optional[str]:
         sys_uuid = None
         hdd_model = None
@@ -248,28 +273,44 @@ class GetKakaoAuthDesktopLogin:
         return json.loads(response.text)
 
     def get_cred(self) -> Tuple[Optional[str], str]:
-        self.cb_msg("Get authorization token")
+        msg = "Getting Kakao authorization token by desktop login..."
+        self.cb.put(("msg_dynamic", (msg,), None))
         rjson = self.login()
         access_token = rjson.get("access_token")
         if access_token is not None:
             auth_token = access_token + "-" + self.device_uuid
-            return auth_token, f"Login successful, auth_token: {auth_token}"
+            return auth_token, OK_MSG.format(auth_token=auth_token)
 
         rjson = self.generate_passcode()
         if rjson.get("status") != 0:
             return None, f"Failed to generate passcode: {rjson}"
         passcode = rjson["passcode"]
 
-        start_time = time.time()
-        register_success = False
-        while time.time() - start_time < 60:
-            self.cb_ask_str(f"Please enter passcode within 1 minute: {passcode}")
+        fail_reason = None
+        self.cb.put(("msg_dynamic", (None,), None))
+        while True:
             rjson = self.register_device()
             if rjson["status"] == 0:
-                register_success = True
                 break
-        if register_success is False:
-            return None, f"Failed to register device: {rjson}"
+            elif rjson["status"] == -110:
+                fail_reason = "Timeout"
+                break
+            elif rjson["status"] != -100:
+                fail_reason = str(rjson)
+                break
+            time_remaining = rjson.get("remainingSeconds")
+            next_req_time = rjson.get("nextRequestIntervalInSeconds")
+            if time_remaining is None or next_req_time is None:
+                fail_reason = str(rjson)
+            msg = f"Please enter passcode in Kakao app on mobile device within {time_remaining} seconds: {passcode}"
+            msg_dynamic_window_exist = self.cb.put(("msg_dynamic", (msg,), None))
+            if msg_dynamic_window_exist is False:
+                fail_reason = "Cancelled"
+                break
+            time.sleep(next_req_time)
+        self.cb.put(("msg_dynamic", (None,), None))
+        if fail_reason is not None:
+            return None, f"Failed to register device: {fail_reason}"
 
         rjson = self.login()
         if rjson.get("status") == -101:
@@ -279,4 +320,4 @@ class GetKakaoAuthDesktopLogin:
             return None, f"Failed to login after registering device: {rjson}"
 
         auth_token = access_token + "-" + self.device_uuid
-        return auth_token, f"Login successful, auth_token: {auth_token}"
+        return auth_token, OK_MSG.format(auth_token=auth_token)