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

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

@@ -1,80 +1,98 @@
-#!/usr/bin/env python3
-import json
-import platform
-from http.cookiejar import CookieJar
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import requests
-import rookiepy
-
-
-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,
-            rookiepy.librewolf,
-            rookiepy.chrome,
-            rookiepy.chromium,
-            rookiepy.brave,
-            rookiepy.edge,
-            rookiepy.opera,
-            rookiepy.vivaldi,
-        ]
-
-        if platform.system() == "Windows":
-            browsers.extend(
-                [
-                    rookiepy.opera_gx,
-                    rookiepy.internet_explorer,
-                ]
-            )
-        elif platform.system() == "Darwin":
-            browsers.extend(
-                [
-                    rookiepy.opera_gx,
-                    rookiepy.safari,
-                ]
-            )
-
-        cookies_dict = None
-        cookies_jar = None
-        for browser in browsers:
-            try:
-                cookies_dict = browser(["store.line.me"])
-                cookies_jar = rookiepy.to_cookiejar(cookies_dict)
-
-                if GetLineAuth.validate_cookies(cookies_jar):
-                    break
-
-            except Exception:
-                continue
-
-        if cookies_dict is None or cookies_jar is None:
-            return None
-
-        cookies_list = ["%s=%s" % (i["name"], i["value"]) for i in cookies_dict]
-        cookies = ";".join(cookies_list)
-
-        return cookies
-
-    @staticmethod
-    def validate_cookies(cookies: Union[CookieJar, Dict[str, str]]) -> bool:
-        headers = {
-            "x-requested-with": "XMLHttpRequest",
-        }
-
-        params = {"text": "test"}
-
-        response = requests.get(
-            "https://store.line.me/api/custom-sticker/validate/13782/en",
-            params=params,
-            cookies=cookies,  # type: ignore
-            headers=headers,
-        )
-
-        response_dict = json.loads(response.text)
-
-        if response_dict["errorMessage"]:
-            return False
-        return True
+#!/usr/bin/env python3
+import json
+import platform
+from http.cookiejar import CookieJar
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+import requests
+import rookiepy
+
+from sticker_convert.auth.auth_base import AuthBase
+from sticker_convert.utils.translate import I
+
+
+class AuthLine(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.OK_MSG = I("Got Line cookies successfully")
+        self.FAIL_MSG = I(
+            "Failed to get Line cookies. Have you logged in the web browser?"
+        )
+
+        super().__init__(*args, **kwargs)
+
+    def get_cred(self) -> Tuple[Optional[str], str]:
+        msg = I("Getting Line cookies")
+        self.cb.put(("msg_dynamic", (msg,), None))
+
+        browsers: List[Callable[..., Any]] = [
+            rookiepy.load,  # Supposed to load from any browser, but may fail
+            rookiepy.firefox,
+            rookiepy.librewolf,
+            rookiepy.chrome,
+            rookiepy.chromium,
+            rookiepy.brave,
+            rookiepy.edge,
+            rookiepy.opera,
+            rookiepy.vivaldi,
+        ]
+
+        if platform.system() == "Windows":
+            browsers.extend(
+                [
+                    rookiepy.opera_gx,
+                    rookiepy.internet_explorer,
+                ]
+            )
+        elif platform.system() == "Darwin":
+            browsers.extend(
+                [
+                    rookiepy.opera_gx,
+                    rookiepy.safari,
+                ]
+            )
+
+        cookies_dict = None
+        cookies_jar = None
+        for browser in browsers:
+            try:
+                cookies_dict = browser(["store.line.me"])
+                cookies_jar = rookiepy.to_cookiejar(cookies_dict)
+
+                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,
+                self.FAIL_MSG,
+            )
+
+        cookies_list = ["%s=%s" % (i["name"], i["value"]) for i in cookies_dict]
+        cookies = ";".join(cookies_list)
+
+        return cookies, self.OK_MSG
+
+    @staticmethod
+    def validate_cookies(cookies: Union[CookieJar, Dict[str, str]]) -> bool:
+        headers = {
+            "x-requested-with": "XMLHttpRequest",
+        }
+
+        params = {"text": "test"}
+
+        response = requests.get(
+            "https://store.line.me/api/custom-sticker/validate/13782/en",
+            params=params,
+            cookies=cookies,  # type: ignore
+            headers=headers,
+        )
+
+        response_dict = json.loads(response.text)
+
+        if response_dict["errorMessage"]:
+            return False
+        return True

sticker_convert/auth/auth_signal.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+import json
+import os
+import platform
+import shutil
+import time
+import webbrowser
+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
+from sticker_convert.utils.translate import I
+
+
+class AuthSignal(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.MSG_NO_SIGDESK = I(
+            "Signal Desktop not detected.\n"
+            "Download and install Signal Desktop version\n"
+            "After installation, quit Signal Desktop before continuing"
+        )
+
+        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
+
+    def download_signal_desktop(self) -> None:
+        download_url = "https://signal.org/en/download/"
+
+        webbrowser.open(download_url)
+
+        self.cb.put(download_url)
+
+        self.cb.put(("ask_str", (self.MSG_NO_SIGDESK,), None))
+
+    def get_signal_bin_path(self) -> Optional[str]:
+        signal_paths: Tuple[Optional[str], ...]
+        if platform.system() == "Windows":
+            signal_paths = (
+                os.path.expandvars("%localappdata%/Programs/signal-desktop/Signal.exe"),
+                os.path.expandvars(
+                    "%localappdata%/Programs/signal-desktop-beta/Signal Beta.exe"
+                ),
+            )
+        elif platform.system() == "Darwin":
+            signal_paths = (
+                "/Applications/Signal.app/Contents/MacOS/Signal",
+                "/Applications/Signal Beta.app/Contents/MacOS/Signal Beta",
+            )
+        else:
+            signal_paths = (
+                shutil.which("signal-desktop"),
+                shutil.which("signal-desktop-beta"),
+                shutil.which("org.signal.Signal"),  # Flatpak
+                os.path.expanduser(
+                    "~/.local/share/flatpak/exports/bin/org.signal.Signal"
+                ),
+                "/var/lib/flatpak/exports/bin/org.signal.Signal",
+            )
+
+        for signal_path in signal_paths:
+            if signal_path is not None and os.path.isfile(signal_path):
+                return signal_path
+        return None
+
+    def get_cred(self) -> Tuple[Optional[str], Optional[str], str]:
+        msg = I("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, I("Failed to get uuid and password")
+
+        if platform.system() == "Windows":
+            killall("signal")
+        else:
+            killall("signal-desktop")
+
+        crd = CRD(signal_bin_path)
+        crd.connect()
+        # crd.runtime_enable()
+        # crd.reload()
+        # while True:
+        #     r = crd.ws.recv()
+        #     data = json.loads(r)
+        #     if data.get("method") == "Runtime.executionContextCreated":
+        #         print(data)
+        #     if (data.get("method") == "Runtime.executionContextCreated" and
+        #         data["params"]["context"]["name"] == "Electron Isolated Context"
+        #     ):
+        #         context_id = data["params"]["context"]["id"]
+        #         break
+        # crd.runtime_disable()
+        context_id = 2
+
+        uuid, password = None, None
+        while True:
+            try:
+                r = crd.exec_js(
+                    "window.reduxStore.getState().items.uuid_id", context_id
+                )
+            except RuntimeError:
+                break
+            if (
+                json.loads(r).get("result", {}).get("result", {}).get("type", "")
+                == "string"
+            ):
+                uuid = cast(str, json.loads(r)["result"]["result"]["value"])
+                break
+            time.sleep(1)
+        while True:
+            try:
+                r = crd.exec_js(
+                    "window.reduxStore.getState().items.password", context_id
+                )
+            except RuntimeError:
+                break
+            if (
+                json.loads(r).get("result", {}).get("result", {}).get("type", "")
+                == "string"
+            ):
+                password = cast(str, json.loads(r)["result"]["result"]["value"])
+                break
+            time.sleep(1)
+
+        crd.close()
+        self.cb.put(("msg_dynamic", (None,), None))
+        return (
+            uuid,
+            password,
+            I("Got uuid and password successfully:\nuuid={}\npassword={}").format(
+                uuid, password
+            ),
+        )

sticker_convert/auth/auth_telethon.py

@@ -0,0 +1,161 @@
+#!/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
+from sticker_convert.utils.translate import I
+
+
+class AuthTelethon(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.GUIDE_MSG = I(
+            "1. Visit {telegram_api_url}\n"
+            "2. Login using your phone number\n"
+            '3. Go to "API development tools"\n'
+            "4. Fill form\n"
+            "- App title: sticker-convert\n"
+            "- Short name: sticker-convert\n"
+            "- URL: www.telegram.org\n"
+            "- Platform: Desktop\n"
+            "- Description: sticker-convert\n"
+            "5. Note down api_id and api_hash\n"
+            "Continue when done"
+        )
+        self.TELEGRAM_API_URL = "https://my.telegram.org"
+        self.OK_MSG = I("Telethon setup successful")
+        self.FAIL_MSG = I("Telethon setup failed")
+
+        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 = error_msg + I("Enter phone number: ")
+                phone_number = self.cb.put(("ask_str", (msg,), None))
+                if phone_number == "":
+                    return False, client, 0, "", self.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 = error_msg + I("Enter code: ")
+                code = self.cb.put(("ask_str", (msg,), None))
+                if code == "":
+                    return False, client, 0, "", self.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,
+            self.OK_MSG if authed else self.FAIL_MSG,
+        )
+
+    def guide(self) -> None:
+        self.cb.put(
+            (
+                "msg_block",
+                (self.GUIDE_MSG.format(telegram_api_url=self.TELEGRAM_API_URL),),
+                None,
+            )
+        )
+
+    def get_api_info(self) -> bool:
+        api_id_ask = I("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 = I("Error: api_id should be numeric\n")
+
+        msg = I("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, "", self.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)