qtmonaco 0.1.1__tar.gz

qtmonaco-0.1.1/.gitignore

@@ -0,0 +1,183 @@
+**/*_venv
+**/.idea
+*.log
+**/__pycache__
+**/.DS_Store
+**/out
+**/.vscode
+**/.pytest_cache
+**/*.egg*
+.python-version
+
+# file writer data
+**.h5
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+*.rcc
+node_modules
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Output from end2end testing
+tests/reference_failures/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/**/_build/
+docs/**/autodoc/
+docs/**/_autosummary/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+**.prof
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

qtmonaco-0.1.1/CHANGELOG.md

@@ -0,0 +1,25 @@
+# CHANGELOG
+
+
+## v0.1.1 (2025-07-11)
+
+### Bug Fixes
+
+- Fix release step
+  ([`182c7de`](https://github.com/bec-project/qtmonaco/commit/182c7dec74c46437e1a56d03c53b9992b135ad90))
+
+
+## v0.1.0 (2025-07-11)
+
+### Continuous Integration
+
+- Add pypi build and upload
+  ([`25ea54a`](https://github.com/bec-project/qtmonaco/commit/25ea54a80e6fd54a215cb3679ca80e8e49c8e97b))
+
+- Init
+  ([`0b5ef18`](https://github.com/bec-project/qtmonaco/commit/0b5ef1858bc95ec93e6c8abb993b1e01f8772cac))
+
+### Features
+
+- Add qt bridge
+  ([`7361271`](https://github.com/bec-project/qtmonaco/commit/73612710b57424234900863606fe3aa74ad6754f))

qtmonaco-0.1.1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: qtmonaco
+Version: 0.1.1
+Summary: Qt Monaco is a Python library for working with the Monaco Editor in Qt applications.
+Project-URL: Bug Tracker, https://github.com/bec-project/qtmonaco/issues
+Project-URL: Homepage, https://github.com/bec-project/qtmonaco
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: pyside6~=6.8.2
+Requires-Dist: python-lsp-server[all,websockets]~=1.12
+Requires-Dist: qtpy~=2.4
+Provides-Extra: dev
+Requires-Dist: coverage~=7.0; extra == 'dev'
+Requires-Dist: isort>=5.13.2,~=5.13; extra == 'dev'
+Requires-Dist: pytest-cov~=6.1.1; extra == 'dev'
+Requires-Dist: pytest-qt~=4.4; extra == 'dev'
+Requires-Dist: pytest-random-order~=1.1; extra == 'dev'
+Requires-Dist: pytest-timeout~=2.2; extra == 'dev'
+Requires-Dist: pytest-xvfb~=3.0; extra == 'dev'
+Requires-Dist: pytest~=8.0; extra == 'dev'

qtmonaco-0.1.1/generate_rcc.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Generate QRC and RCC files from dist directory for PySide6.
+
+This script creates a Qt Resource Collection (.qrc) file from the dist directory
+and automatically compiles it to a binary RCC file for use in PySide6 applications.
+
+Usage:
+    python generate_qrc.py
+"""
+
+import os
+import subprocess
+import xml.etree.ElementTree as ET
+from typing import List
+
+
+def get_file_list(build_dir: str) -> List[str]:
+    """
+    Get list of all files in build directory, excluding certain extensions.
+
+    Args:
+        build_dir: Path to build directory
+
+    Returns:
+        List of file paths relative to build_dir
+    """
+    exclude_extensions = {".map", ".txt", ".md"}
+
+    files = []
+    for root, dirs, filenames in os.walk(build_dir):
+        # Skip hidden directories and common build artifacts
+        dirs[:] = [
+            d for d in dirs if not d.startswith(".") and d not in {"node_modules", "__pycache__"}
+        ]
+
+        for filename in filenames:
+            file_path = os.path.join(root, filename)
+            relative_path = os.path.relpath(file_path, build_dir)
+
+            # Skip files with excluded extensions
+            if not any(relative_path.endswith(ext) for ext in exclude_extensions):
+                files.append(relative_path)
+
+    return sorted(files)
+
+
+def create_qrc_content(files: List[str], build_dir: str) -> str:
+    """
+    Create QRC XML content from file list.
+
+    Args:
+        files: List of file paths relative to build directory
+        build_dir: Build directory path to include in file paths
+
+    Returns:
+        QRC XML content as string
+    """
+    # Create root element
+    root = ET.Element("RCC")
+    root.set("version", "1.0")
+
+    # Create qresource element
+    qresource = ET.SubElement(root, "qresource")
+    qresource.set("prefix", "/monaco")
+
+    # Add each file with build directory prefix
+    for file_path in files:
+        file_element = ET.SubElement(qresource, "file")
+        # Include build directory in the path
+        full_path = os.path.join("dist", file_path)
+        file_element.text = str(full_path).replace("\\", "/")  # Use forward slashes for Qt
+
+    # Pretty print the XML
+    ET.indent(root, space="  ")
+
+    # Create XML declaration and return
+    xml_str = ET.tostring(root, encoding="unicode", xml_declaration=False)
+    return f'<?xml version="1.0" encoding="UTF-8"?>\n{xml_str}\n'
+
+
+def compile_to_rcc(qrc_file: str, rcc_file: str) -> bool:
+    """
+    Compile QRC file to binary RCC file using pyside6-rcc.
+
+    Args:
+        qrc_file: Path to QRC file
+        rcc_file: Path to output RCC file
+
+    Returns:
+        True if compilation was successful, False otherwise
+    """
+    try:
+        cmd = ["pyside6-rcc", qrc_file, "-o", rcc_file, "--binary"]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Error compiling QRC to RCC: {e}")
+        print(f"stderr: {e.stderr}")
+        return False
+    except FileNotFoundError:
+        print("Error: pyside6-rcc not found. Make sure PySide6 is installed.")
+        return False
+
+
+def main():
+
+    build_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "dist")
+    rcc_build_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), "build")
+    qrc_file = "monaco_resources.qrc"
+    rcc_file = os.path.join(rcc_build_dir, "monaco.rcc")
+
+    # Validate build directory
+    if not os.path.exists(build_dir):
+        print(f"Error: Build directory '{build_dir}' does not exist")
+        print("Make sure to run 'npm run build' first")
+        return 1
+
+    # Get file list
+    files = get_file_list(build_dir)
+
+    if not files:
+        print(f"Warning: No files found in '{build_dir}'")
+        return 1
+
+    print(f"Found {len(files)} files in '{build_dir}':")
+    for file_path in files[:5]:  # Show first 5 files
+        print(f"  {file_path}")
+    if len(files) > 5:
+        print(f"  ... and {len(files) - 5} more files")
+
+    # Generate QRC content
+    qrc_content = create_qrc_content(files, build_dir)
+
+    # Write QRC file
+    with open(qrc_file, "w", encoding="utf-8") as f:
+        f.write(qrc_content)
+
+    print(f"\n✓ Generated QRC file: {qrc_file}")
+
+    # Compile to RCC
+    print("Compiling to RCC file...")
+    os.makedirs(rcc_build_dir, exist_ok=True)  # Ensure build directory exists
+    if compile_to_rcc(qrc_file, rcc_file):
+        print(f"✓ Generated RCC file: {rcc_file}")
+
+        # Clean up QRC file since we only need the RCC
+        os.remove(qrc_file)
+        print("✓ Cleaned up temporary QRC file")
+
+        print("\n🎉 Success!")
+        return 0
+    print("✗ Failed to compile RCC file")
+    return 1
+
+
+if __name__ == "__main__":
+    exit(main())

qtmonaco-0.1.1/pyproject.toml

@@ -0,0 +1,102 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "qtmonaco"
+version = "0.1.1"
+description = "Qt Monaco is a Python library for working with the Monaco Editor in Qt applications."
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "PySide6~=6.8.2",
+    "qtpy~=2.4",
+    "python-lsp-server[all,websockets] ~= 1.12",
+]
+
+[project.optional-dependencies]
+dev = [
+    "coverage~=7.0",
+    "isort~=5.13, >=5.13.2",
+    "pytest-qt~=4.4",
+    "pytest-random-order~=1.1",
+    "pytest-timeout~=2.2",
+    "pytest-xvfb~=3.0",
+    "pytest~=8.0",
+    "pytest-cov~=6.1.1",
+]
+
+[project.urls]
+"Bug Tracker" = "https://github.com/bec-project/qtmonaco/issues"
+Homepage = "https://github.com/bec-project/qtmonaco"
+
+[tool.hatch.build.targets.wheel]
+include = ["*"]
+exclude = ["docs/**", "tests/**"]
+
+[tool.hatch.build.targets.sdist]
+include = ["*"]
+exclude = ["docs/**", "tests/**"]
+
+[tool.black]
+line-length = 100
+skip-magic-trailing-comma = true
+
+[tool.isort]
+profile = "black"
+line_length = 100
+multi_line_output = 3
+include_trailing_comma = true
+known_first_party = ["bec_widgets"]
+
+[tool.semantic_release]
+build_command = "pip install build wheel && python -m build"
+version_toml = ["pyproject.toml:project.version"]
+
+[tool.semantic_release.commit_author]
+env = "GIT_COMMIT_AUTHOR"
+default = "semantic-release <semantic-release>"
+
+[tool.semantic_release.commit_parser_options]
+allowed_tags = [
+    "build",
+    "chore",
+    "ci",
+    "docs",
+    "feat",
+    "fix",
+    "perf",
+    "style",
+    "refactor",
+    "test",
+]
+minor_tags = ["feat"]
+patch_tags = ["fix", "perf"]
+default_bump_level = 0
+
+[tool.semantic_release.remote]
+name = "origin"
+type = "github"
+ignore_token_for_push = true
+
+[tool.semantic_release.remote.token]
+env = "GH_TOKEN"
+
+[tool.semantic_release.publish]
+dist_glob_patterns = ["dist/*"]
+upload_to_vcs_release = true
+
+[tool.coverage.report]
+skip_empty = true # exclude empty *files*, e.g. __init__.py, from the report
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "return NotImplemented",
+    "raise NotImplementedError",
+    "\\.\\.\\.",
+    'if __name__ == "__main__":',
+]

qtmonaco-0.1.1/qtmonaco/bridge_base.py

@@ -0,0 +1,65 @@
+import json
+
+from qtpy.QtCore import QObject, Signal, Slot
+
+
+class BaseBridge(QObject):
+    initialized = Signal()
+    sendDataChanged = Signal(str, str)
+    completion = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self._initialized = False
+        self._buffer = []
+        self.initialized.connect(self._process_startup_buffer)
+
+    def _process_startup_buffer(self):
+        """
+        Process the buffer of data that was sent before the bridge was initialized.
+        This is useful for sending initial data to the JavaScript side.
+        """
+        for name, value in self._buffer:
+            self._send_to_js(name, value)
+        self._buffer.clear()
+
+        # Update the local buffer by reading the current state
+        # This is mostly to ensure that we are in sync with the JS side
+        self._send_to_js("read", "")
+
+    def _send_to_js(self, name, value):
+        if not self._initialized:
+            self._buffer.append((name, value))
+            return
+        data = json.dumps(value)
+        self.sendDataChanged.emit(name, data)
+
+    @Slot(str, str)
+    def receive_from_js(self, name, value):
+        data = json.loads(value)
+
+        if name == "bridge_initialized":
+            self._initialized = data
+            self.initialized.emit()
+            return
+        if name == "setValue":
+            self.on_value_changed(data)
+            return
+        print(f"Received from JS: {name} = {data}")
+        self.setProperty(name, data)
+
+    @property
+    def bridge_initialized(self):
+        return self._initialized
+
+    @bridge_initialized.setter
+    def bridge_initialized(self, value):
+        if self._initialized != value:
+            self._initialized = value
+            self.initialized.emit()
+
+    def on_value_changed(self, value):
+        """
+        Placeholder method to handle value changes.
+        This can be overridden in subclasses to implement specific behavior.
+        """

qtmonaco-0.1.1/qtmonaco/editor_bridge.py

@@ -0,0 +1,200 @@
+import json
+from typing import Literal
+
+from qtpy.QtCore import QObject, Signal, Slot
+
+
+class Connector(QObject):
+    javascript_data_sent = Signal(str, str)
+    javascript_data_received = Signal(str, str)
+
+    """
+    A base class for connecting Python and JavaScript.
+    This class provides a mechanism to send and receive data between Python and JavaScript.
+    It uses Qt's signal-slot mechanism to handle communication.
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self._initialized = False
+        self._buffer = []
+
+    def _process_startup_buffer(self):
+        """
+        Process the buffer of data that was sent before the bridge was initialized.
+        This is useful for sending initial data to the JavaScript side.
+        """
+        for name, value in self._buffer:
+            self.send(name, value)
+        self._buffer.clear()
+
+        # Update the local buffer by reading the current state
+        # This is mostly to ensure that we are in sync with the JS side
+        self.send("read", "")
+
+    def send(self, name, value):
+        """
+        Send data to the JavaScript side.
+        Args:
+            name (str): The name of the data to send.
+            value (any): The value to send, which will be serialized to JSON.
+        """
+        if not self._initialized:
+            self._buffer.append((name, value))
+            return
+        data = json.dumps(value)
+        self.javascript_data_sent.emit(name, data)
+
+    @Slot(str, str)
+    def _receive(self, name: str, value: str):
+        """
+        Receive data from the JavaScript side.
+        This method is called when the JavaScript side sends data to the Python side.
+        Args:
+
+
+        """
+        self.javascript_data_received.emit(name, value)
+
+    def set_initialized(self):
+        """
+        Set the initialized state of the connector.
+        This method is used to indicate that the connector is ready to send and receive data.
+        Args:
+            value (bool): The new initialized state.
+        """
+        self._initialized = True
+        self._process_startup_buffer()
+
+
+class EditorBridge(QObject):
+    text_changed = Signal()
+    language_changed = Signal()
+    theme_changed = Signal()
+    initialized = Signal()
+    completion = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self._connector = Connector(parent=self)
+        self._connector.javascript_data_received.connect(self.on_new_data_received)
+        self._value = ""
+        self._language = ""
+        self._theme = ""
+        self._readonly = False
+        self._initialized = False
+        self._buffer = []
+        self.initialized.connect(self._connector.set_initialized)
+
+    def on_new_data_received(self, name: str, value: str):
+        """
+        Handle new data received from JavaScript.
+        This method is called when the JavaScript side sends data to the Python side.
+        """
+        data = json.loads(value)
+        if hasattr(self, name):
+            method = getattr(self, name)
+            if callable(method):
+                method(data)
+                return
+            if hasattr(self, name):
+                setattr(self, name, data)
+                return
+        else:
+            print(f"Warning: No method or property named '{name}' in EditorBridge.")
+
+    @property
+    def bridge_initialized(self):
+        return self._initialized
+
+    @bridge_initialized.setter
+    def bridge_initialized(self, value):
+        if self._initialized != value:
+            self._initialized = value
+            self.initialized.emit()
+
+    def on_value_changed(self, value):
+        """Handle value changes from the JavaScript side."""
+        self._current_text(value)
+
+    def _current_text(self, value: str):
+        if self._value == value:
+            return
+        self._value = value
+        self.text_changed.emit()
+
+    def set_text(self, value: str):
+        """
+        Set the value in the editor.
+
+        Args:
+            value (str): The new value to set in the editor.
+        """
+        if self._value == value:
+            return
+        if self._readonly:
+            raise ValueError("Editor is in read-only mode, cannot set value.")
+        if not isinstance(value, str):
+            raise TypeError("Value must be a string.")
+        self._value = value
+        self.text_changed.emit()
+
+    def get_language(self):
+        return self._language
+
+    def set_language(self, language):
+        self._language = language
+        self._connector.send("language", language)
+        self.language_changed.emit()
+
+    def get_theme(self):
+        return self._theme
+
+    def set_theme(self, theme):
+        self._theme = theme
+        self._connector.send("theme", theme)
+        self.theme_changed.emit()
+
+    def set_readonly(self, read_only: bool):
+        """Set the editor to read-only mode."""
+        self._connector.send("readonly", read_only)
+        self._readonly = read_only
+
+    @property
+    def value(self):
+        return self._value
+
+    @property
+    def language(self):
+        return self._language
+
+    @property
+    def theme(self):
+        return self._theme
+
+    def set_host(self, host: str):
+        """
+        Set the host for the editor.
+
+        Args:
+            host (str): The host URL for the editor.
+        """
+        self._connector.send("lsp_url", host)
+
+    def set_cursor(
+        self,
+        line: int,
+        column: int = 1,
+        move_to_position: Literal[None, "center", "top", "position"] = None,
+    ):
+        """
+        Set the cursor position in the editor.
+
+        Args:
+            line (int): Line number (1-based).
+            column (int): Column number (1-based), defaults to 1.
+            move_to_position (Literal[None, "center", "top", "position"], optional): Position to move the cursor to.
+        """
+        self._connector.send(
+            "set_cursor", {"line": line, "column": column, "moveToPosition": move_to_position}
+        )

qtmonaco-0.1.1/qtmonaco/monaco_page.py

@@ -0,0 +1,10 @@
+import logging
+
+from qtpy.QtWebEngineCore import QWebEnginePage
+
+logger = logging.getLogger(__name__)
+
+
+class MonacoPage(QWebEnginePage):
+    def javaScriptConsoleMessage(self, level, message, line, source):
+        print(f"[JS Console] {level.name} at line {line} in {source}: {message}")

qtmonaco-0.1.1/qtmonaco/monaco_web_view.py

@@ -0,0 +1,134 @@
+from typing import Literal
+
+from qtpy.QtCore import Signal
+from qtpy.QtWebChannel import QWebChannel
+from qtpy.QtWebEngineWidgets import QWebEngineView
+
+from qtmonaco.editor_bridge import EditorBridge
+from qtmonaco.monaco_page import MonacoPage
+from qtmonaco.resource_loader import get_monaco_base_url, get_monaco_html
+
+
+def get_pylsp_host() -> str:
+    """
+    Get the host address for the PyLSP server.
+    This function initializes the PyLSP server if it is not already running
+    and returns the host address in the format 'localhost:port'.
+    Returns:
+        str: The host address of the PyLSP server.
+    """
+    # lazy import to only load when needed
+    # pylint: disable=import-outside-toplevel
+    from qtmonaco.pylsp_provider import pylsp_server
+
+    if not pylsp_server.is_running():
+        pylsp_server.start()
+
+    return f"localhost:{pylsp_server.port}"
+
+
+class Monaco(QWebEngineView):
+    initialized = Signal()
+    textChanged = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+
+        self.pylsp_host = get_pylsp_host()
+
+        self._setup_page()
+        self._setup_bridge()
+        self._load_editor()
+
+    def _setup_page(self):
+        """Initialize the web engine page."""
+        page = MonacoPage(parent=self)
+        self.setPage(page)
+
+    def _setup_bridge(self):
+        """Initialize the bridge for communication with JavaScript."""
+        self._channel = QWebChannel(self)
+        self._bridge = EditorBridge()
+
+        self.page().setWebChannel(self._channel)
+        self._channel.registerObject("connector", self._bridge._connector)
+
+        self._bridge.initialized.connect(self._set_host)
+        self._bridge.initialized.connect(self.initialized)
+        self._bridge.text_changed.connect(lambda: self.textChanged.emit(self._bridge.value))
+
+    def _load_editor(self):
+        """Load the Monaco Editor HTML content."""
+        raw_html = get_monaco_html()
+        base_url = get_monaco_base_url()
+        self.setHtml(raw_html, base_url)
+
+    def _set_host(self):
+        """Set the LSP host once the bridge is initialized."""
+        self._bridge.set_host(self.pylsp_host)
+
+    # Public API methods
+    def text(self):
+        return self._bridge.value
+
+    def set_text(self, text: str):
+        self._bridge.set_text(text)
+
+    def set_cursor(
+        self,
+        line: int,
+        column: int = 1,
+        move_to_position: Literal[None, "center", "top", "position"] = None,
+    ):
+        """Set the cursor position in the editor.
+
+        Args:
+            line (int): Line number (1-based)
+            column (int): Column number (1-based), defaults to 1
+        """
+        self._bridge.set_cursor(line, column, move_to_position)
+
+    def get_language(self) -> str:
+        """Get the current programming language for syntax highlighting in the editor."""
+        return self._bridge.get_language()
+
+    def set_language(self, language: str):
+        """Set the programming language for syntax highlighting in the editor.
+
+        Args:
+            language (str): The programming language to set (e.g., "python", "javascript").
+        """
+        self._bridge.set_language(language)
+
+    def get_theme(self):
+        return self._bridge.get_theme()
+
+    def set_theme(self, theme: str):
+        """Set the theme for the Monaco editor.
+
+        Args:
+            theme (str): The theme to apply (e.g., "vs", "vs-dark").
+        """
+        self._bridge.set_theme(theme)
+
+    def set_read_only(self, read_only: bool):
+        """Set the editor to read-only mode."""
+        self._bridge.set_readonly(read_only)
+
+    def shutdown(self):
+        if hasattr(self._bridge, "shutdown"):
+            self._bridge.shutdown()
+
+
+if __name__ == "__main__":
+    import logging
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    logging.basicConfig(level=logging.INFO)
+
+    app = QApplication(sys.argv)
+    editor = Monaco()
+    editor.show()
+    sys.exit(app.exec_())

qtmonaco-0.1.1/qtmonaco/pylsp_provider.py

@@ -0,0 +1,61 @@
+import atexit
+import logging
+import signal
+import socket
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+
+class PyLSPProvider:
+    """A provider for the PyLSP server."""
+
+    def __init__(self):
+        self.port = None
+        self.server_process = None
+        atexit.register(self.stop)
+        signal.signal(signal.SIGINT, self._handle_signal)
+        signal.signal(signal.SIGTERM, self._handle_signal)
+
+    def _find_free_port(self):
+        """Find a free port for the PyLSP server."""
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("localhost", 0))
+            self.port = s.getsockname()[1]
+        return self.port
+
+    def start(self):
+        """Start the PyLSP server."""
+        if self.port is None:
+            self._find_free_port()
+        # Here you would start the PyLSP server using the found port
+        logger.info(f"Starting PyLSP server on port {self.port}")
+        self.server_process = subprocess.Popen(
+            ["pylsp", "--ws", "--port", str(self.port)],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+    def stop(self):
+        """Stop the PyLSP server."""
+        if not self.server_process:
+            return
+
+        self.server_process.terminate()
+        try:
+            self.server_process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            self.server_process.kill()
+        self.server_process = None
+        self.port = None
+
+    def _handle_signal(self, signum, frame):
+        """Handle termination signals."""
+        self.stop()
+
+    def is_running(self):
+        """Check if the PyLSP server is running."""
+        return self.server_process is not None and self.server_process.poll() is None
+
+
+pylsp_server = PyLSPProvider()

qtmonaco-0.1.1/qtmonaco/resource_loader.py

@@ -0,0 +1,28 @@
+import os
+
+from qtpy.QtCore import QFile, QIODevice, QResource, QUrl
+
+QResource.registerResource(
+    os.path.join(os.path.dirname(os.path.dirname(__file__)), "build/monaco.rcc")
+)
+
+
+def load_resource_html(resource_path: str) -> str:
+    """Load HTML content from Qt resources."""
+    file = QFile(resource_path)
+    if file.open(QIODevice.OpenModeFlag.ReadOnly):
+        content = file.readAll()
+        file.close()
+        return content.toStdString()
+    else:
+        raise FileNotFoundError(f"Resource not found: {resource_path}")
+
+
+def get_monaco_html():
+    """Get Monaco Editor HTML content from Qt resources."""
+    return load_resource_html(":/monaco/dist/index.html")
+
+
+def get_monaco_base_url():
+    """Get the base URL for Monaco Editor resources."""
+    return QUrl("qrc:/monaco/dist/")