vsview-editor 0.1.0__py3-none-any.whl

vsview_editor/__init__.py

@@ -0,0 +1,19 @@
+import logging
+import os
+from typing import Any
+
+from vsview.api import get_console_level, hookimpl
+from vsview.api.workspace import PluginBaseWorkspace
+
+# Suppress internal Chromium C++ stderr output (LOG_FATAL = 3)
+if get_console_level() > logging.DEBUG:
+    name = "QTWEBENGINE_CHROMIUM_FLAGS"
+    os.environ[name] = " ".join([os.environ.setdefault(name, ""), "--log-level=3"]).strip()
+
+
+from .workspace import EditorWorkspace
+
+
+@hookimpl
+def vsview_register_workspace() -> type[PluginBaseWorkspace[Any, Any]]:
+    return EditorWorkspace

vsview_editor/console.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import sys
+import threading
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from io import StringIO
+from logging import Handler, Logger, LogRecord
+from typing import Literal, TextIO, override
+
+from jetpytools import CustomRuntimeError, Singleton, inject_self
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.text import Text
+
+from vsview.api import QObjectSet, get_console_level
+
+from .web import MonacoBridge
+
+IN_LOGGING = threading.local()
+EXECUTION_BRIDGE = ContextVar[MonacoBridge | None]("EXECUTION_BRIDGE", default=None)
+
+
+class EditorConsoleHandler(RichHandler):
+    def __init__(self, dispatch: Callable[[Literal["stderr", "stdout"], str], None]) -> None:
+        self.dispatch = dispatch
+        super().__init__(
+            console=Console(file=StringIO(), record=True),
+            rich_tracebacks=True,
+            log_time_format=lambda dt: Text("[{}.{:03d}]".format(dt.strftime("%H:%M:%S"), dt.microsecond // 1000)),
+        )
+
+    @override
+    def emit(self, record: LogRecord) -> None:
+        IN_LOGGING.depth = getattr(IN_LOGGING, "depth", 0) + 1
+        try:
+            self.console.width = GlobalConsoleHub.target_width
+            super().emit(record)
+            self.dispatch("stderr", self.console.export_text(clear=True, styles=True))
+        finally:
+            IN_LOGGING.depth -= 1
+
+
+class ConsoleStreamRedirector:
+    def __init__(self, name: Literal["stdout", "stderr"]) -> None:
+        self.name = name
+        self._original_stream: TextIO = getattr(sys, self.name)
+        self._installed = False
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(self._original_stream, name)
+
+    def install(self) -> None:
+        if self._installed:
+            raise CustomRuntimeError("This ConsoleStreamRedirector is already installed", self.install)
+
+        setattr(sys, self.name, self)
+        self._installed = True
+
+    def uninstall(self) -> None:
+        if not self._installed:
+            raise CustomRuntimeError("This ConsoleStreamRedirector is already uninstalled", self.uninstall)
+
+        setattr(sys, self.name, self._original_stream)
+        self._installed = False
+
+    def write(self, text: str) -> int:
+        res = self._original_stream.write(text)
+        # Suppress dispatching when text comes from an active logging emit() call
+        if text and getattr(IN_LOGGING, "depth", 0) == 0:
+            GlobalConsoleHub.dispatch({"stream": self.name, "text": text})
+        return res
+
+    def isatty(self) -> bool:
+        return getattr(self._original_stream, "isatty", lambda: False)()
+
+
+class GlobalConsoleHub(Singleton):
+    def __init__(self) -> None:
+        self._bridges = QObjectSet[MonacoBridge]()
+        self._bridge_widths = dict[MonacoBridge, int]()
+        self._stdout_redirector = ConsoleStreamRedirector("stdout")
+        self._stderr_redirector = ConsoleStreamRedirector("stderr")
+        self._log_handler: EditorConsoleHandler | None = None
+        self._orig_handler_handle: Callable[[Handler, LogRecord], int | None] | None = None
+        self._installed = False
+
+    @inject_self.property
+    def target_width(self) -> int:
+        if (target_bridge := EXECUTION_BRIDGE.get()) in self._bridge_widths:
+            return self._bridge_widths[target_bridge]
+
+        for bridge in self._bridges:
+            if bridge in self._bridge_widths:
+                return self._bridge_widths[bridge]
+
+        if self._log_handler:
+            return self._log_handler.console.width
+
+        return 80
+
+    @inject_self
+    def register(self, bridge: MonacoBridge) -> None:
+        self._bridges.add(bridge)
+        if not self._installed:
+            self._install_global_hooks()
+
+    @inject_self
+    def unregister(self, bridge: MonacoBridge) -> None:
+        self._bridges.discard(bridge)
+        self._bridge_widths.pop(bridge, None)
+        if not self._bridges and self._installed:
+            self._uninstall_global_hooks()
+
+    @inject_self
+    def set_width(self, bridge: MonacoBridge, width: int) -> None:
+        self._bridge_widths[bridge] = width
+        target_bridge = EXECUTION_BRIDGE.get()
+        if self._log_handler and (target_bridge == bridge or (target_bridge is None and bridge in self._bridges)):
+            self._log_handler.console.width = width
+
+    @inject_self
+    @contextmanager
+    def bind_execution(self, bridge: MonacoBridge) -> Generator[None]:
+        token = EXECUTION_BRIDGE.set(bridge)
+        try:
+            yield
+        finally:
+            EXECUTION_BRIDGE.reset(token)
+
+    @inject_self
+    def dispatch(self, payload: dict[str, str], target_bridge: MonacoBridge | None = None) -> None:
+        dest_bridge = target_bridge or EXECUTION_BRIDGE.get()
+        if dest_bridge is not None:
+            dest_bridge.dispatch("console.append", payload)
+        else:
+            for bridge in self._bridges:
+                bridge.dispatch("console.append", payload)
+
+    def _install_global_hooks(self) -> None:
+        self._stdout_redirector.install()
+        self._stderr_redirector.install()
+
+        self._orig_handler_handle = _orig_handler_handle = Handler.handle
+
+        def _protected_handle(handler_self: Handler, record: LogRecord) -> bool:
+            nonlocal _orig_handler_handle
+            IN_LOGGING.depth = getattr(IN_LOGGING, "depth", 0) + 1
+            try:
+                return _orig_handler_handle(handler_self, record)
+            finally:
+                IN_LOGGING.depth -= 1
+
+        setattr(Handler, "handle", _protected_handle)
+
+        self._log_handler = EditorConsoleHandler(dispatch=lambda s, t: self.dispatch({"stream": s, "text": t}))
+        self._log_handler.setLevel(get_console_level())
+        Logger.root.addHandler(self._log_handler)
+        self._installed = True
+
+    def _uninstall_global_hooks(self) -> None:
+        self._stdout_redirector.uninstall()
+        self._stderr_redirector.uninstall()
+
+        if self._orig_handler_handle is not None:
+            setattr(Handler, "handle", self._orig_handler_handle)
+            self._orig_handler_handle = None
+
+        if self._log_handler is not None:
+            Logger.root.removeHandler(self._log_handler)
+            self._log_handler = None
+        self._installed = False

vsview_editor/logging.py

@@ -0,0 +1,31 @@
+from logging import Logger, LogRecord, getLogger
+
+from jetpytools import SPath
+
+
+def context_filter(record: LogRecord) -> bool:
+    source: str | None = getattr(record, "js_source", None)
+    line: int | None = getattr(record, "js_lineno", None)
+
+    if source and line:
+        record.pathname = (SPath(__file__).parent / "web_dist" / "assets" / source).to_str()
+        record.filename = source
+        record.module = source
+        record.lineno = line
+
+    return True
+
+
+def setup_js_logger() -> Logger:
+    logger = getLogger("vsview_editor_js")
+
+    for h in logger.handlers[:]:
+        logger.removeHandler(h)
+    for f in logger.filters[:]:
+        logger.removeFilter(f)
+
+    logger.addFilter(context_filter)
+    return logger
+
+
+js_logger = setup_js_logger()

vsview_editor/lsp.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+import shutil
+import sys
+import urllib.parse
+import weakref
+from collections.abc import Sequence
+from dataclasses import dataclass
+from logging import getLogger
+from pathlib import Path
+
+from jetpytools import CustomValueError
+from PySide6.QtCore import QObject, QProcess, Slot
+from PySide6.QtNetwork import QHostAddress
+from PySide6.QtWebSockets import QWebSocket, QWebSocketServer
+
+from vsview.api import QObjectSet
+
+logger = getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class LSPConfig:
+    id: str
+    name: str
+    command: Sequence[str]
+    language: str
+    file_events_pattern: str | None
+    configuration_section: str | Sequence[str] | None = None
+
+    def __post_init__(self) -> None:
+        if not self.command:
+            raise CustomValueError("LSP config %r has an empty command list.", self.id)
+
+
+LSP_BASEDPYRIGHT_CONFIG = LSPConfig(
+    id="basedpyright",
+    name="Basedpyright Language Server",
+    command=["basedpyright-langserver", "--stdio"],
+    language="python",
+    file_events_pattern="**/*.py",
+    configuration_section=["basedpyright", "python"],
+)
+
+
+class LSPProcessServer(QObject):
+    """Manages a single LSP subprocess and its associated WebSocket bridge server."""
+
+    def __init__(self, config: LSPConfig, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self.config = config
+        self.server: QWebSocketServer | None = None
+        self.clients = QObjectSet[QWebSocket]()
+        self.process: QProcess | None = None
+        self._stdout_buffer = bytearray()
+        self.real_uri: str | None = None
+        self.uri_variations = list[str]()
+
+    def start(self, port: int = 0, workspace_dir: Path | None = None) -> int:
+        if not workspace_dir:
+            workspace_dir = Path.cwd()
+
+        self.real_uri = workspace_dir.as_uri()
+
+        # Build URI variations to replace in JSON-RPC messages from server -> client
+        self.uri_variations = [
+            self.real_uri,
+            self.real_uri.replace("file:///", "file://"),
+            self.real_uri.replace("file:///", "file:/"),
+            urllib.parse.quote(self.real_uri, safe=":/"),
+            urllib.parse.quote(self.real_uri.replace("file:///", "file://"), safe=":/"),
+            urllib.parse.quote(self.real_uri.replace("file:///", "file:/"), safe=":/"),
+        ]
+
+        executable_name = Path(self.config.command[0])
+        if executable_name.is_file():
+            binary = executable_name.resolve()
+        elif not (binary := shutil.which(executable_name)):
+            logger.error("LSP executable %r for %r not found in PATH.", executable_name, self.config.id)
+            return -1
+
+        self.server = QWebSocketServer(f"LSP Bridge ({self.config.name})", QWebSocketServer.SslMode.NonSecureMode, self)
+        if not self.server.listen(QHostAddress.SpecialAddress.LocalHost, port):
+            logger.error("Failed to start LSP WebSocket server for %r: %s", self.config.id, self.server.errorString())
+            return -1
+
+        actual_port = self.server.serverPort()
+        logger.debug("LSP WebSocket server for %r listening on 127.0.0.1:%d", self.config.id, actual_port)
+
+        self.server.newConnection.connect(self._on_new_connection)
+
+        self.process = QProcess(self)
+        self.process.readyReadStandardOutput.connect(self._on_stdout_ready)
+        self.process.readyReadStandardError.connect(self._on_stderr_ready)
+        self.process.errorOccurred.connect(self._on_process_error)
+
+        try:
+            self.process.start(str(binary), self.config.command[1:])
+        except Exception:
+            logger.exception("Failed to launch LSP subprocess for %r:", self.config.id)
+
+        return actual_port
+
+    def stop(self) -> None:
+        if self.clients:
+            for client in self.clients:
+                if client.isValid():
+                    client.close()
+                client.deleteLater()
+            self.clients.clear()
+
+        if self.server is not None:
+            server = self.server
+            self.server = None
+            server.close()
+            server.deleteLater()
+
+        if self.process is not None:
+            proc = self.process
+            self.process = None
+            logger.debug("Stopping LSP QProcess for %r (current state: %s)", self.config.id, proc.state())
+            proc.readyReadStandardOutput.disconnect(self._on_stdout_ready)
+            proc.readyReadStandardError.disconnect(self._on_stderr_ready)
+            proc.errorOccurred.disconnect(self._on_process_error)
+
+            if proc.state() != QProcess.ProcessState.NotRunning:
+                if sys.platform == "win32":
+                    proc.kill()
+                    if not proc.waitForFinished(3000):
+                        logger.warning(
+                            "LSP QProcess kill timed out for %r, state is still %s",
+                            self.config.id,
+                            proc.state(),
+                        )
+                else:
+                    proc.terminate()
+                    if not proc.waitForFinished(1000):
+                        proc.kill()
+                        proc.waitForFinished(1000)
+
+            proc.deleteLater()
+
+    @Slot()
+    def _on_new_connection(self) -> None:
+        if not self.server:
+            return
+        client = self.server.nextPendingConnection()
+        self.clients.add(client)
+        logger.debug("New LSP WebSocket connection established for %r", self.config.id)
+
+        client.textMessageReceived.connect(self._on_ws_message)
+
+        client_weak = weakref.ref(client)
+
+        @Slot()
+        def _on_client_disconnected() -> None:
+            if c := client_weak():
+                self.clients.discard(c)
+            logger.debug("LSP WebSocket connection closed for %r (Python)", self.config.id)
+
+        client.disconnected.connect(_on_client_disconnected)
+
+    @Slot(str)
+    def _on_ws_message(self, message: str) -> None:
+        """
+        Receive JSON-RPC from frontend WebSocket, translate virtual URI to real URI and forward to LSP stdin.
+        """
+        if not self.process or self.process.state() != QProcess.ProcessState.Running:
+            logger.warning("Cannot write to LSP stdin for %r: process is not running.", self.config.id)
+            return
+
+        if self.real_uri and "file:///workspace" in message:
+            message = message.replace("file:///workspace", self.real_uri)
+
+        body = message.encode("utf-8")
+        header = f"Content-Length: {len(body)}\r\n\r\n".encode()
+        self.process.write(header + body)
+
+    @Slot()
+    def _on_stdout_ready(self) -> None:
+        if not self.process:
+            return
+
+        self._stdout_buffer.extend(self.process.readAllStandardOutput().data())
+
+        while True:
+            header_end = self._stdout_buffer.find(b"\r\n\r\n")
+            if header_end == -1:
+                break
+
+            header_bytes = self._stdout_buffer[:header_end]
+            content_length = None
+            for line in header_bytes.split(b"\r\n"):
+                if line.startswith(b"Content-Length:"):
+                    content_length = int(line.split(b":")[1].strip())
+                    break
+
+            if content_length is None:
+                del self._stdout_buffer[: header_end + 4]
+                continue
+
+            total_needed = header_end + 4 + content_length
+            if len(self._stdout_buffer) < total_needed:
+                break  # Incomplete message body; await next read event
+
+            body_bytes = self._stdout_buffer[header_end + 4 : total_needed]
+            del self._stdout_buffer[:total_needed]
+
+            msg_str = body_bytes.decode("utf-8", errors="replace")
+            for var in self.uri_variations:
+                if var in msg_str:
+                    msg_str = msg_str.replace(var, "file:///workspace")
+
+            for client in self.clients:
+                if client.isValid():
+                    client.sendTextMessage(msg_str)
+
+    @Slot()
+    def _on_stderr_ready(self) -> None:
+        if not self.process:
+            return
+        output = bytes(self.process.readAllStandardError().data()).decode("utf-8", errors="replace").strip()
+        if output:
+            for line in output.splitlines():
+                logger.debug("[LSP %s stderr] %s", self.config.id, line)
+
+    @Slot(QProcess.ProcessError)
+    def _on_process_error(self, error: QProcess.ProcessError) -> None:
+        if self.process:
+            logger.error("LSP QProcess error for %r (%s): %s", self.config.id, error, self.process.errorString())
+
+
+class LSPProcessManager(QObject):
+    def __init__(self, parent: QObject) -> None:
+        super().__init__(parent)
+        self.servers = dict[str, LSPProcessServer]()
+
+    def start_server(
+        self,
+        config: LSPConfig,
+        port: int = 0,
+        workspace_dir: Path | None = None,
+    ) -> int:
+        if config.id in self.servers:
+            logger.debug("LSP server %r is already running. Stopping existing server first.", config.id)
+            self.stop_server(config.id)
+
+        server = LSPProcessServer(config, self)
+        actual_port = server.start(port=port, workspace_dir=workspace_dir)
+        if actual_port > 0:
+            self.servers[config.id] = server
+            return actual_port
+        return -1
+
+    def stop_server(self, server_id: str) -> None:
+        if server := self.servers.pop(server_id, None):
+            server.stop()
+
+    def stop(self, server_id: str | None = None) -> None:
+        if server_id is not None:
+            self.stop_server(server_id)
+        else:
+            for server in list(self.servers.values()):
+                server.stop()
+            self.servers.clear()