py-neuromodulation 0.0.7__py3-none-any.whl → 0.1.1__py3-none-any.whl

py_neuromodulation/gui/backend/app_utils.py

@@ -0,0 +1,306 @@
+import multiprocessing as mp
+import logging
+from typing import Sequence
+import sys
+from pathlib import Path
+from py_neuromodulation.utils.types import _PathLike
+from functools import lru_cache
+import platform
+from py_neuromodulation import logger
+
+
+def force_terminate_process(
+    process: mp.Process, name: str, logger: logging.Logger | None = None
+) -> None:
+    log = logger.debug if logger else print
+
+    import psutil
+
+    p = psutil.Process(process.pid)
+    try:
+        log(f"Terminating process {name}")
+        for child in p.children(recursive=True):
+            log(f"Terminating child process {child.pid}")
+            child.terminate()
+        p.terminate()
+        p.wait(timeout=3)
+    except psutil.NoSuchProcess:
+        log(f"Process {name} has already exited.")
+    except psutil.TimeoutExpired:
+        log(f"Forcefully killing {name}...")
+        p.kill()
+
+
+def create_logger(name, color: str, level=logging.INFO):
+    """Function to set up a logger with color coded output"""
+    color = ansi_color(color=color, bright=True, styles=["BOLD"])
+    logger = logging.getLogger(name)
+    log_format = f"{color}[%(name)s %(levelname)s (%(asctime)s)]:{ansi_color(styles=['RESET'])} %(message)s"
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(logging.Formatter(log_format, "%H:%M:%S"))
+    stream_handler.setStream(sys.stderr)
+    logger.setLevel(level)
+    logger.addHandler(stream_handler)
+
+    return logger
+
+
+def ansi_color(
+    color: str = "DEFAULT",
+    bright: bool = True,
+    styles: Sequence[str] = [],
+    bg_color: str = "DEFAULT",
+    bg_bright: bool = True,
+) -> str:
+    """
+    Function to generate ANSI color codes for colored text in the terminal.
+    See https://en.wikipedia.org/wiki/ANSI_escape_code
+
+    Returns:
+        str: ANSI color code
+    """
+    ANSI_COLORS = {
+        # https://en.wikipedia.org/wiki/ANSI_escape_code
+        "BLACK": 30,
+        "RED": 31,
+        "GREEN": 32,
+        "YELLOW": 33,
+        "BLUE": 34,
+        "MAGENTA": 35,
+        "CYAN": 36,
+        "WHITE": 37,
+        "DEFAULT": 39,
+    }
+
+    ANSI_STYLES = {
+        "RESET": 0,
+        "BOLD": 1,
+        "FAINT": 2,
+        "ITALIC": 3,
+        "UNDERLINE": 4,
+        "BLINK": 5,
+        "NEGATIVE": 7,
+        "CROSSED": 9,
+    }
+
+    color = color.upper()
+    bg_color = bg_color.upper()
+    styles = [style.upper() for style in styles]
+
+    if color not in ANSI_COLORS.keys() or bg_color not in ANSI_COLORS.keys():
+        raise ValueError(f"Invalid color: {color}")
+
+    for style in styles:
+        if style not in ANSI_STYLES.keys():
+            raise ValueError(f"Invalid style: {style}")
+
+    color_code = str(ANSI_COLORS[color] + (60 if bright else 0))
+    bg_color_code = str(ANSI_COLORS[bg_color] + 10 + (60 if bg_bright else 0))
+    style_codes = ";".join((str(ANSI_STYLES[style]) for style in styles))
+
+    return f"\033[{style_codes};{color_code};{bg_color_code}m"
+
+
+ansi_reset = ansi_color(styles=["RESET"])
+
+
+def is_hidden(filepath: _PathLike) -> bool:
+    """Check if a file or directory is hidden.
+
+    Args:
+        filepath (str): Path to the file or directory.
+
+    Returns:
+        bool: True if the file or directory is hidden, False otherwise.
+    """
+    from pathlib import Path
+
+    filepath = Path(filepath)
+
+    if sys.platform.startswith("win"):
+        import ctypes
+
+        try:
+            attrs = ctypes.windll.kernel32.GetFileAttributesW(str(filepath))
+            assert attrs != -1
+            result = bool(attrs & 2) or filepath.name.startswith(".")
+        except (AttributeError, AssertionError):
+            result = filepath.name.startswith(".")
+    else:
+        result = filepath.name.startswith(".")
+
+    return result
+
+
+@lru_cache(maxsize=1)
+def get_quick_access():
+    system = platform.system()
+    if system == "Windows":
+        return get_windows_quick_access()
+    elif system == "Darwin":  # macOS
+        return get_macos_quick_access()
+    else:  # Linux, Unix, etc.
+        return {"items": []}
+
+
+def get_windows_quick_access():
+    quick_access_items = []
+
+    # Add available drives
+    available_drives = [
+        f"{d}:\\" for d in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" if Path(f"{d}:").exists()
+    ]
+    for drive in available_drives:
+        quick_access_items.append(
+            {"name": f"Drive ({drive})", "type": "drive", "path": drive}
+        )
+
+    # Get user's pinned folders
+    pinned_folders = get_pinned_folders_windows()
+    for folder in pinned_folders:
+        path = Path(folder["Path"])
+        if path.exists():
+            quick_access_items.append(
+                {"name": folder["Name"], "type": "folder", "path": str(path)}
+            )
+
+    # Get user's home directory
+    home_path = Path.home()
+
+    # Add common folders if they're not already in pinned folders
+    common_folders = [
+        ("Desktop", "Desktop"),
+        ("Documents", "Documents"),
+        ("Downloads", "Downloads"),
+        ("Pictures", "Pictures"),
+        ("Music", "Music"),
+        ("Videos", "Videos"),
+    ]
+
+    for folder_name, folder_path in common_folders:
+        full_path = home_path / folder_path
+        if full_path.exists() and str(full_path) not in [
+            item["path"] for item in quick_access_items
+        ]:
+            quick_access_items.append(
+                {"name": folder_name, "type": "folder", "path": str(full_path)}
+            )
+
+    # Add user's home directory if not already included
+    if str(home_path) not in [item["path"] for item in quick_access_items]:
+        quick_access_items.append(
+            {"name": "Home", "type": "folder", "path": str(home_path)}
+        )
+
+    return {"items": quick_access_items}
+
+
+def get_pinned_folders_windows():
+    import subprocess
+    import json
+
+    powershell_command = """
+    $shell = New-Object -ComObject Shell.Application
+    $quickaccess = $shell.Namespace("shell:::{679f85cb-0220-4080-b29b-5540cc05aab6}").Items()
+    $pinned = $quickaccess | Where-Object { $_.IsFolder } | ForEach-Object {
+        [PSCustomObject]@{
+            Name = $_.Name
+            Path = $_.Path
+        }
+    }
+    $pinned | ConvertTo-Json
+    """
+
+    try:
+        result = subprocess.run(
+            ["powershell", "-Command", powershell_command],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return json.loads(result.stdout)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error running PowerShell command: {e}")
+        return []
+    except json.JSONDecodeError as e:
+        logger.error(f"Error decoding JSON: {e}")
+        return []
+
+
+def get_macos_quick_access():
+    quick_access_folders = get_macos_favorites()
+    quick_access_items = []
+
+    quick_access_items.append({"name": "Computer", "type": "drive", "path": "/"})
+
+    # Add Volumes for macOS
+    volumes_path = Path("/Volumes")
+    if volumes_path.exists():
+        for volume in volumes_path.iterdir():
+            if volume.is_mount():
+                quick_access_items.append(
+                    {"name": volume.name, "type": "drive", "path": str(volume)}
+                )
+
+    # Add quick access folders
+    for folder in quick_access_folders:
+        path = Path(folder["Path"])
+        if path.exists():
+            quick_access_items.append(
+                {"name": folder["Name"], "type": "folder", "path": str(path)}
+            )
+
+    # Add user's home directory if not already included
+    home_path = str(Path.home())
+    if home_path not in [item["path"] for item in quick_access_items]:
+        quick_access_items.append({"name": "Home", "type": "folder", "path": home_path})
+
+    return {"items": quick_access_items}
+
+
+def get_macos_favorites():
+    import subprocess
+    import json
+
+    favorites = []
+
+    try:
+        # Common locations in macOS
+        common_locations = [
+            ("Desktop", Path.home() / "Desktop"),
+            ("Documents", Path.home() / "Documents"),
+            ("Downloads", Path.home() / "Downloads"),
+            ("Pictures", Path.home() / "Pictures"),
+            ("Music", Path.home() / "Music"),
+            ("Movies", Path.home() / "Movies"),
+        ]
+
+        for name, path in common_locations:
+            if path.exists():
+                favorites.append({"Name": name, "Path": str(path)})
+
+        # Get user-defined favorites from sidebar plist
+        plist_path = (
+            Path.home()
+            / "Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.FavoriteItems.sfl2"
+        )
+        if plist_path.exists():
+            try:
+                result = subprocess.run(
+                    ["plutil", "-convert", "json", "-o", "-", str(plist_path)],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                plist_data = json.loads(result.stdout)
+                for item in plist_data.get("Bookmark", []):
+                    if "Name" in item and "URL" in item:
+                        path = item["URL"].replace("file://", "")
+                        favorites.append({"Name": item["Name"], "Path": path})
+            except (subprocess.CalledProcessError, json.JSONDecodeError) as e:
+                logger.error(f"Error processing macOS favorites: {e}")
+
+    except Exception as e:
+        logger.error(f"Error getting macOS favorites: {e}")
+
+    return favorites

py_neuromodulation/gui/backend/app_window.py

@@ -0,0 +1,202 @@
+import threading
+import time
+import logging
+import requests
+
+from .app_utils import ansi_color, ansi_reset
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import webview
+
+DEV = True
+
+VITE_URL = "http://localhost:54321"
+FASTAPI_URL = "http://localhost:50001"
+APP_URL = VITE_URL if DEV else FASTAPI_URL
+
+USER_AGENT = "PyNmWebView"
+
+
+class WebViewWindow:
+    def __init__(self, debug: bool = False) -> None:
+        import webview
+
+        self.debug = debug
+        self.api = WebViewWindowApi()
+
+        self.window = webview.create_window(
+            title="PyNeuromodulation GUI",
+            url=APP_URL,
+            min_size=(1200, 800),
+            frameless=True,
+            resizable=True,
+            easy_drag=False,
+            js_api=self.api,
+        )
+
+        self.api.register_window(self.window)
+        # Customize PyWebView logging format
+        color = ansi_color(color="CYAN", styles=["BOLD"])
+        logger = logging.getLogger("pywebview")
+        formatter = logging.Formatter(
+            f"{color}[PyWebView %(levelname)s (%(asctime)s)]:{ansi_reset} %(message)s",
+            datefmt="%H:%M:%S",
+        )
+        logger.handlers[0].setFormatter(formatter)
+
+    def start(self):
+        import webview
+
+        # Set timer to load SPA after a delay
+        if DEV:
+            self.wait_for_vite_server()
+
+        webview.start(debug=self.debug, user_agent=USER_AGENT)
+
+    def wait_for_vite_server(self):
+        while True:
+            if self.is_vite_server_running():
+                break
+            time.sleep(0.1)  # Wait for 1 second before checking again
+
+    def is_vite_server_running(self):
+        try:
+            response = requests.get(VITE_URL, timeout=1)
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+
+    # Register event handlers
+    def register_event_handler(self, event_type, handler):
+        # https://pywebview.flowrl.com/guide/api.html#window-events
+        match event_type:
+            case "closed":
+                self.window.events.closed += handler
+            case "closing":
+                self.window.events.closing += handler
+            case "loaded":
+                self.window.events.loaded += handler
+            case "minimized":
+                self.window.events.minimized += handler
+            case "maximized":
+                self.window.events.maximized += handler
+            case "resized":
+                self.window.events.resized += handler
+            case "restore":
+                self.window.events.restore += handler
+            case "shown":
+                self.window.events.shown += handler
+
+
+# API class implementing all the methods available in the PyWebView Window object
+# API Reference: https://pywebview.flowrl.com/guide/api.html#webview-window
+class WebViewWindowApi:
+    def __init__(self):
+        self._window: "webview.Window"
+        self.is_resizing = False
+        self.start_x = 0
+        self.start_y = 0
+        self.start_width = 0
+        self.start_height = 0
+
+    # Function to store the reference to the PyWevView window
+    def register_window(self, window: "webview.Window"):
+        self._window = window
+
+    # Functions to handle window resizing
+    def start_resize(self, start_x, start_y):
+        self.is_resizing = True
+        self.start_x = start_x
+        self.start_y = start_y
+        self.start_width, self.start_height = self.get_size()
+        threading.Thread(target=self._resize_loop).start()
+
+    def stop_resize(self):
+        self.is_resizing = False
+
+    def update_resize(self, current_x, current_y):
+        if self.is_resizing:
+            dx = current_x - self.start_x
+            dy = current_y - self.start_y
+            new_width = max(self.start_width + dx, 200)  # Minimum width
+            new_height = max(self.start_height + dy, 200)  # Minimum height
+            self.set_size(int(new_width), int(new_height))
+
+    def _resize_loop(self):
+        while self.is_resizing:
+            time.sleep(0.01)  # Small delay to prevent excessive CPU usage
+
+    # All API methods from the PyWebView docs
+    def close_window(self):
+        self._window.destroy()
+
+    def maximize_window(self):
+        self._window.maximize()
+
+    def minimize_window(self):
+        self._window.minimize()
+
+    def restore_window(self):
+        self._window.restore()
+
+    def toggle_fullscreen(self):
+        self._window.toggle_fullscreen()
+
+    def set_title(self, title: str):
+        self._window.title = title
+
+    def get_position(self):
+        return (self._window.x, self._window.y)
+
+    def set_position(self, x: int, y: int):
+        self._window.move(x, y)
+
+    def get_size(self):
+        return (self._window.width, self._window.height)
+
+    def set_size(self, width: int, height: int):
+        self._window.resize(width, height)
+
+    def set_on_top(self, on_top: bool):
+        self._window.on_top = on_top
+
+    def show(self):
+        self._window.show()
+
+    def hide(self):
+        self._window.hide()
+
+    def create_file_dialog(
+        self,
+        dialog_type: int = 10,  # webview.OPEN_DIALOG,
+        directory="",
+        allow_multiple=False,
+        save_filename="",
+        file_types=(),
+    ):
+        return self._window.create_file_dialog(
+            dialog_type, directory, allow_multiple, save_filename, file_types
+        )
+
+    def create_confirmation_dialog(self, title, message):
+        return self._window.create_confirmation_dialog(title, message)
+
+    def load_url(self, url):
+        self._window.load_url(url)
+
+    def load_html(self, content, base_uri: str):
+        self._window.load_html(content, base_uri)
+
+    def load_css(self, css):
+        self._window.load_css(css)
+
+    def evaluate_js(self, script, callback=None):
+        return self._window.evaluate_js(script, callback)
+
+    def get_current_url(self):
+        return self._window.get_current_url()
+
+    def get_elements(self, selector):
+        return self._window.get_elements(selector)