sticker-convert 2.8.12__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/chrome_remotedebug.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+import base64
+import io
+import json
+import os
+import platform
+import shutil
+import signal
+import socket
+import subprocess
+import time
+from typing import Any, Dict, List, Optional, Union, cast
+
+import requests
+import websocket
+from PIL import Image
+
+# References
+# https://github.com/yeongbin-jo/python-chromedriver-autoinstaller/blob/master/chromedriver_autoinstaller/utils.py
+# https://chromedevtools.github.io/devtools-protocol/
+
+
+BROWSER_PREF = [
+    "chrome",
+    "chrome-canary",
+    "chromium",
+    "msedge",
+    "msedge-beta",
+    "msedge-dev",
+    "msedge-canary",
+    "brave",
+    "brave-beta",
+    "brave-nightly",
+    "opera",
+    "opera-beta",
+    "opera-developer",
+]
+
+
+def get_free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("", 0))
+        port = sock.getsockname()[1]
+    return port
+
+
+class CRD:
+    def __init__(
+        self,
+        chrome_bin: str,
+        port: Optional[int] = None,
+        args: Optional[List[str]] = None,
+    ) -> None:
+        if port is None:
+            port = get_free_port()
+        self.port = port
+
+        launch_cmd: List[str] = []
+        if (
+            platform.system() == "Linux"
+            and os.environ.get("DISPLAY", False) is False
+            and shutil.which("xvfb-run")
+        ):
+            launch_cmd += ["xvfb-run", "--server-args='-screen 0, 1024x768x24'"]
+
+        launch_cmd += [
+            chrome_bin,
+            f"--remote-debugging-port={port}",
+            f"--remote-allow-origins=http://127.0.0.1:{port}",
+        ]
+        if args:
+            launch_cmd += args
+
+        # Adding --no-sandbox in Windows may cause Signal fail to launch
+        # https://github.com/laggykiller/sticker-convert/issues/274
+        if (
+            platform.system() != "Windows"
+            and "geteuid" in dir(os)
+            and os.geteuid() == 0
+        ) or os.path.isfile("/.dockerenv"):
+            launch_cmd.append("--no-sandbox")
+
+        self.chrome_proc = subprocess.Popen(launch_cmd)
+
+    @staticmethod
+    def get_chromium_path() -> Optional[str]:
+        if platform.system() == "Windows":
+            from sticker_convert.utils.chromiums.windows import get_chromium_path
+        elif platform.system() == "Darwin":
+            from sticker_convert.utils.chromiums.osx import get_chromium_path
+        else:
+            from sticker_convert.utils.chromiums.linux import get_chromium_path
+        return get_chromium_path()
+
+    def connect(self, target_id: int = 0) -> None:
+        self.cmd_id = 1
+        r = None
+        targets: List[Any] = []
+        for _ in range(30):
+            try:
+                r = requests.get(f"http://127.0.0.1:{self.port}/json")
+                targets = json.loads(r.text)
+                if len(targets) == 0:
+                    time.sleep(1)
+                    continue
+                break
+            except requests.exceptions.ConnectionError:
+                time.sleep(1)
+
+        if r is None:
+            raise RuntimeError("Cannot connect to chrome debugging port")
+
+        if len(targets) == 0:
+            raise RuntimeError("Cannot create websocket connection with debugger")
+
+        self.ws = websocket.create_connection(  # type: ignore
+            targets[target_id]["webSocketDebuggerUrl"]
+        )
+
+    def send_cmd(self, command: Dict[Any, Any]) -> Union[str, bytes]:
+        if command.get("id") is None:
+            command["id"] = self.cmd_id
+        for _ in range(3):
+            try:
+                self.ws.send(json.dumps(command))
+                r = self.ws.recv()
+                self.cmd_id += 1
+                return r
+            except BrokenPipeError:
+                self.connect()
+
+        raise RuntimeError("Websocket keep disconnecting")
+
+    def exec_js(self, js: str, context_id: Optional[int] = None) -> Union[str, bytes]:
+        command: Dict[str, Any] = {
+            "id": self.cmd_id,
+            "method": "Runtime.evaluate",
+            "params": {"expression": js},
+        }
+        if context_id is not None:
+            command["params"]["contextId"] = context_id
+        return self.send_cmd(command)
+
+    def set_transparent_bg(self) -> Union[str, bytes]:
+        command: Dict[str, Any] = {
+            "id": self.cmd_id,
+            "method": "Emulation.setDefaultBackgroundColorOverride",
+            "params": {"color": {"r": 0, "g": 0, "b": 0, "a": 0}},
+        }
+        return self.send_cmd(command)
+
+    def screenshot(self, clip: Optional[Dict[str, int]] = None) -> Image.Image:
+        command: Dict[str, Any] = {
+            "id": self.cmd_id,
+            "method": "Page.captureScreenshot",
+            "params": {"captureBeyondViewport": True, "optimizeForSpeed": True},
+        }
+        if clip:
+            command["params"]["clip"] = clip
+        result = self.send_cmd(command)
+        return Image.open(
+            io.BytesIO(base64.b64decode(json.loads(result)["result"]["data"]))
+        )
+
+    def get_curr_url(self) -> str:
+        r = self.exec_js("window.location.href")
+        return cast(
+            str, json.loads(r).get("result", {}).get("result", {}).get("value", "")
+        )
+
+    def navigate(self, url: str) -> None:
+        command = {"id": self.cmd_id, "method": "Page.navigate", "params": {"url": url}}
+        self.send_cmd(command)
+
+    def open_html_str(self, html: str) -> None:
+        command: Dict[str, Any] = {
+            "id": self.cmd_id,
+            "method": "Page.navigate",
+            "params": {"url": "about:blank"},
+        }
+        result = cast(str, self.send_cmd(command))
+        frame_id = json.loads(result).get("result", {}).get("frameId", None)
+        if frame_id is None:
+            raise RuntimeError(f"Cannot navigate to about:blank ({result})")
+
+        self.exec_js('document.getElementsByTagName("html")[0].remove()')
+
+        command = {
+            "id": self.cmd_id,
+            "method": "Page.setDocumentContent",
+            "params": {"frameId": frame_id, "html": html},
+        }
+        self.send_cmd(command)
+
+    def runtime_enable(self) -> None:
+        command = {
+            "method": "Runtime.enable",
+        }
+        self.send_cmd(command)
+
+    def runtime_disable(self) -> None:
+        command = {
+            "method": "Runtime.disable",
+        }
+        self.send_cmd(command)
+
+    def reload(self) -> None:
+        command = {
+            "method": "Page.reload",
+        }
+        self.send_cmd(command)
+
+    def close(self) -> None:
+        command = {
+            "method": "Browser.close",
+        }
+        self.send_cmd(command)
+        self.ws.close()
+        os.kill(self.chrome_proc.pid, signal.SIGTERM)

sticker_convert/utils/chromiums/linux.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+import configparser
+import os
+import re
+from typing import Optional
+
+# Adopted from https://github.com/roniemartinez/browsers/blob/master/browsers/linux.py
+
+LINUX_DESKTOP_ENTRY_LIST = (
+    ("chrome", ("google-chrome",)),
+    ("chromium", ("chromium", "chromium_chromium")),
+    ("brave", ("brave-browser", "brave_brave")),
+    ("brave-beta", ("brave-browser-beta",)),
+    ("brave-nightly", ("brave-browser-nightly",)),
+    ("msedge", ("microsoft-edge",)),
+    ("opera", ("opera_opera",)),
+    ("opera-beta", ("opera-beta_opera-beta",)),
+    ("opera-developer", ("opera-developer_opera-developer",)),
+    ("vivaldi", ("vivaldi_vivaldi-stable",)),
+)
+
+# $XDG_DATA_HOME and $XDG_DATA_DIRS are not always set
+XDG_DATA_LOCATIONS = (
+    "~/.local/share/applications",
+    "/usr/share/applications",
+    "/var/lib/snapd/desktop/applications",
+)
+
+VERSION_PATTERN = re.compile(
+    r"\b(\S+\.\S+)\b"
+)  # simple pattern assuming all version strings have a dot on them
+
+
+def get_chromium_path() -> Optional[str]:
+    for _, desktop_entries in LINUX_DESKTOP_ENTRY_LIST:
+        for application_dir in XDG_DATA_LOCATIONS:
+            for desktop_entry in desktop_entries:
+                path = os.path.join(application_dir, f"{desktop_entry}.desktop")
+
+                if not os.path.isfile(path):
+                    continue
+
+                config = configparser.ConfigParser(interpolation=None)
+                config.read(path, encoding="utf-8")
+                executable_path = config.get("Desktop Entry", "Exec")
+
+                if executable_path.lower().endswith(" %u"):
+                    executable_path = executable_path[:-3].strip()
+
+                return executable_path
+
+    return None

sticker_convert/utils/chromiums/osx.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import glob
+import os
+import plistlib
+import subprocess
+from typing import Optional
+
+# Adopted from https://github.com/roniemartinez/browsers/blob/master/browsers/osx.py
+
+OSX_CHROMIUMS_BUNDLE_LIST = (
+    # browser name, bundle ID, version string
+    ("chrome", "com.google.Chrome", "CFBundleShortVersionString"),
+    ("chrome-beta", "com.google.Chrome.beta", "CFBundleShortVersionString"),
+    ("chrome-canary", "com.google.Chrome.canary", "CFBundleShortVersionString"),
+    ("chrome-dev", "com.google.Chrome.dev", "CFBundleShortVersionString"),
+    ("chrome-test", "com.google.chrome.for.testing", "CFBundleShortVersionString"),
+    ("chromium", "org.chromium.Chromium", "CFBundleShortVersionString"),
+    ("msedge", "com.microsoft.edgemac", "CFBundleShortVersionString"),
+    ("msedge-beta", "com.microsoft.edgemac.Beta", "CFBundleShortVersionString"),
+    ("msedge-dev", "com.microsoft.edgemac.Dev", "CFBundleShortVersionString"),
+    ("msedge-canary", "com.microsoft.edgemac.Canary", "CFBundleShortVersionString"),
+    ("brave", "com.brave.Browser", "CFBundleVersion"),
+    ("brave-beta", "com.brave.Browser.beta", "CFBundleVersion"),
+    ("brave-dev", "com.brave.Browser.dev", "CFBundleVersion"),
+    ("brave-nightly", "com.brave.Browser.nightly", "CFBundleVersion"),
+    ("opera", "com.operasoftware.Opera", "CFBundleVersion"),
+    ("opera-beta", "com.operasoftware.OperaNext", "CFBundleVersion"),
+    ("opera-developer", "com.operasoftware.OperaDeveloper", "CFBundleVersion"),
+    ("opera-gx", "com.operasoftware.OperaGX", "CFBundleVersion"),
+    ("opera-neon", "com.opera.Neon", "CFBundleShortVersionString"),
+    ("duckduckgo", "com.duckduckgo.macos.browser", "CFBundleShortVersionString"),
+    ("epic", "com.hiddenreflex.Epic", "CFBundleShortVersionString"),
+    ("vivaldi", "com.vivaldi.Vivaldi", "CFBundleShortVersionString"),
+    ("yandex", "ru.yandex.desktop.yandex-browser", "CFBundleShortVersionString"),
+)
+
+OSX_CHROMIUMS_BUNDLE_DICT = {item[1]: item for item in OSX_CHROMIUMS_BUNDLE_LIST}
+
+
+def get_chromium_path() -> Optional[str]:
+    for _, bundle_id, _ in OSX_CHROMIUMS_BUNDLE_LIST:
+        app_dirs = subprocess.getoutput(
+            f'mdfind "kMDItemCFBundleIdentifier == {bundle_id}"'
+        ).splitlines()
+        for app_dir in app_dirs:
+            plist_path = os.path.join(app_dir, "Contents/Info.plist")
+
+            with open(plist_path, "rb") as f:
+                plist = plistlib.load(f)
+                executable_name = plist["CFBundleExecutable"]
+                executable = os.path.join(app_dir, "Contents/MacOS", executable_name)
+                return executable
+
+    # Naively iterate /Applications folder in case the above check fails
+    for plist_path in glob.glob("/Applications/*.app/Contents/Info.plist"):
+        with open(plist_path, "rb") as f:
+            plist = plistlib.load(f)
+            bundle_id = plist.get("CFBundleIdentifier")
+            if bundle_id not in OSX_CHROMIUMS_BUNDLE_DICT:
+                continue
+
+            app_dir = os.path.dirname(os.path.dirname(plist_path))
+            executable_name = plist["CFBundleExecutable"]
+            executable = os.path.join(app_dir, "Contents/MacOS", executable_name)
+
+            return executable
+
+    return None

sticker_convert/utils/chromiums/windows.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+import os
+from typing import Optional
+
+# Not adopting approach of reading registry like https://github.com/roniemartinez/browsers
+# As trigger antivirus
+
+PF32 = os.environ.get("PROGRAMW6432")
+PF64 = os.environ.get("PROGRAMFILES")
+LAD = os.environ.get("LOCALAPPDATA")
+
+WINDOWS_CHROMIUMS_PATHS = (
+    f"{PF64}\\Google\\Chrome\\Application\\chrome.exe",  # chromium
+    f"{PF32}\\Google\\Chrome\\Application\\chrome.exe",  # chromium
+    f"{LAD}\\Google\\Chrome SxS\\Application\\chrome.exe",  # chromium-canary
+    f"{PF64}\\Opera\\opera.exe",  # opera
+    f"{PF32}\\Opera\\opera.exe",  # opera
+    f"{LAD}\\Programs\\Opera\\opera.exe",  # opera
+    f"{LAD}\\Programs\\Opera\\launcher.exe",  # opera
+    f"{LAD}\\Programs\\Opera Beta\\opera.exe",  # opera-beta
+    f"{LAD}\\Programs\\Opera Beta\\launcher.exe",  # opera-beta
+    f"{LAD}\\Programs\\Opera Developer\\opera.exe",  # opera-developer
+    f"{LAD}\\Programs\\Opera Developer\\launcher.exe",  # opera-developer
+    f"{PF64}\\Microsoft\\Edge\\Application\\msedge.exe",  # msedge
+    f"{PF32}\\Microsoft\\Edge\\Application\\msedge.exe",  # msedge
+    f"{PF64}\\Microsoft\\Edge Beta\\Application\\msedge.exe",  # msedge-beta
+    f"{PF32}\\Microsoft\\Edge Beta\\Application\\msedge.exe",  # msedge-beta
+    f"{PF64}\\Microsoft\\Edge Dev\\Application\\msedge.exe",  # msedge-dev
+    f"{PF32}\\Microsoft\\Edge Dev\\Application\\msedge.exe",  # msedge-dev
+    f"{LAD}\\Microsoft\\Edge SxS\\Application\\msedge.exe",  # msedge-canary
+    f"{PF64}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",  # brave
+    f"{PF32}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",  # brave
+    f"{PF64}\\BraveSoftware\\Brave-Browser-Beta\\Application\\brave.exe",  # brave-beta
+    f"{PF32}\\BraveSoftware\\Brave-Browser-Beta\\Application\\brave.exe",  # brave-beta
+    f"{PF64}\\BraveSoftware\\Brave-Browser-Nightly\\Application\\brave.exe",  # brave-nightly
+    f"{PF32}\\BraveSoftware\\Brave-Browser-Nightly\\Application\\brave.exe",  # brave-nightly
+)
+
+
+def get_chromium_path() -> Optional[str]:
+    for path in WINDOWS_CHROMIUMS_PATHS:
+        if os.path.exists(path):
+            return path
+
+    return None