sticker-convert 2.13.3.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.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 GetKakaoAuth:
-    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 GetKakaoAuth:
                 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 GetKakaoAuth:
 
         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 GetKakaoAuth:
 
         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 GetKakaoAuth:
             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 GetKakaoAuth:
         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 GetKakaoAuth:
         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 GetKakaoAuth:
 
         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 GetKakaoAuth:
 
         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 GetKakaoAuth:
 
         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 GetKakaoAuth:
         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 GetKakaoAuth:
 
         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 GetKakaoAuth:
         )
 
         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)