pycforge 0.15.2__py3-none-any.whl

pycforge/ide/positions.py

@@ -0,0 +1,220 @@
+"""Immutable text-position indexes for bounded workspace projection."""
+
+from __future__ import annotations
+
+from bisect import bisect_right
+from concurrent.futures import CancelledError, Future
+from dataclasses import dataclass
+from threading import Condition, Thread, current_thread
+from typing import Callable
+
+
+@dataclass(frozen=True, slots=True)
+class TextPositionIndex:
+    """Line and UTF-16 facts built once for one exact immutable string."""
+
+    text_length: int
+    line_starts: tuple[int, ...]
+    utf16_line_starts: tuple[int, ...]
+    utf16_compatible: bool
+
+    @property
+    def line_count(self) -> int:
+        return len(self.line_starts)
+
+    def character_offset(self, line: int, column: int) -> int:
+        """Translate a one-based line and zero-based column without rescanning."""
+
+        if not isinstance(line, int) or not isinstance(column, int):
+            return 0
+        if line < 1:
+            return 0
+        if line > len(self.line_starts):
+            return self.text_length
+        start = self.line_starts[line - 1]
+        end = (
+            self.line_starts[line]
+            if line < len(self.line_starts)
+            else self.text_length
+        )
+        return min(self.text_length, start + min(max(0, column), end - start))
+
+    def qt_position(self, text: str, offset: int) -> int:
+        """Translate a Python code-point offset to a Qt UTF-16 position."""
+
+        clipped = min(self.text_length, max(0, offset))
+        if self.utf16_compatible:
+            return clipped
+        line_index = max(0, bisect_right(self.line_starts, clipped) - 1)
+        line_start = self.line_starts[line_index]
+        qt_start = self.utf16_line_starts[line_index]
+        return qt_start + len(
+            text[line_start:clipped].encode("utf-16-le")
+        ) // 2
+
+    def qt_range(
+        self,
+        text: str,
+        start: int,
+        end: int,
+    ) -> tuple[int, int]:
+        return self.qt_position(text, start), self.qt_position(text, end)
+
+
+def build_text_position_index(
+    text: str,
+    *,
+    cancelled: Callable[[], bool] | None = None,
+) -> TextPositionIndex:
+    """Build source-proportional position facts outside the GUI thread."""
+
+    if not isinstance(text, str):
+        raise TypeError("position-index text must be a string")
+    line_starts = [0]
+    utf16_line_starts = [0]
+    utf16_offset = 0
+    utf16_compatible = True
+    for offset, character in enumerate(text):
+        if (
+            cancelled is not None
+            and offset % 65_536 == 0
+            and cancelled()
+        ):
+            raise CancelledError("position index was superseded")
+        astral = ord(character) > 0xFFFF
+        if astral:
+            utf16_compatible = False
+        utf16_offset += 2 if astral else 1
+        if character == "\n":
+            line_starts.append(offset + 1)
+            utf16_line_starts.append(utf16_offset)
+    return TextPositionIndex(
+        text_length=len(text),
+        line_starts=tuple(line_starts),
+        utf16_line_starts=tuple(utf16_line_starts),
+        utf16_compatible=utf16_compatible,
+    )
+
+
+PositionIndexListener = Callable[[int, str, TextPositionIndex], None]
+
+
+@dataclass(slots=True)
+class _IndexJob:
+    submission: int
+    generation: int
+    text: str
+    future: Future[TextPositionIndex]
+
+
+class TextPositionIndexService:
+    """One-active/one-latest-pending text index builder."""
+
+    def __init__(
+        self,
+        listener: PositionIndexListener | None = None,
+    ) -> None:
+        self._listener = listener
+        self._condition = Condition()
+        self._submission = 0
+        self._active: _IndexJob | None = None
+        self._pending: _IndexJob | None = None
+        self._closed = False
+        self._thread = Thread(
+            target=self._run,
+            name="pycforge-output-position-index",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def submit(
+        self,
+        generation: int,
+        text: str,
+    ) -> Future[TextPositionIndex]:
+        future: Future[TextPositionIndex] = Future()
+        with self._condition:
+            if self._closed:
+                raise RuntimeError("position index service is closed")
+            self._submission += 1
+            job = _IndexJob(self._submission, generation, text, future)
+            replaced = self._pending
+            self._pending = job
+            if replaced is not None:
+                replaced.future.cancel()
+            self._condition.notify()
+        return future
+
+    def close(
+        self,
+        *,
+        wait: bool = False,
+        timeout: float | None = None,
+    ) -> None:
+        with self._condition:
+            if not self._closed:
+                self._closed = True
+                pending = self._pending
+                self._pending = None
+                if pending is not None:
+                    pending.future.cancel()
+                self._condition.notify_all()
+        if wait and current_thread() is not self._thread:
+            self._thread.join(timeout)
+
+    def _superseded(self, submission: int) -> bool:
+        with self._condition:
+            return self._closed or submission != self._submission
+
+    def _run(self) -> None:
+        while True:
+            with self._condition:
+                while self._pending is None and not self._closed:
+                    self._condition.wait()
+                if self._pending is None and self._closed:
+                    return
+                job = self._pending
+                self._pending = None
+                self._active = job
+            assert job is not None
+            if not job.future.set_running_or_notify_cancel():
+                with self._condition:
+                    if self._active is job:
+                        self._active = None
+                    self._condition.notify_all()
+                continue
+            try:
+                index = build_text_position_index(
+                    job.text,
+                    cancelled=lambda: self._superseded(job.submission),
+                )
+            except BaseException as exc:
+                if not job.future.done():
+                    job.future.set_exception(exc)
+                index = None
+            with self._condition:
+                if self._active is job:
+                    self._active = None
+                publishable = (
+                    index is not None
+                    and not self._closed
+                    and job.submission == self._submission
+                    and self._pending is None
+                )
+                self._condition.notify_all()
+            if index is None:
+                continue
+            if not job.future.done():
+                job.future.set_result(index)
+            if publishable and self._listener is not None:
+                try:
+                    self._listener(job.generation, job.text, index)
+                except Exception:
+                    pass
+
+
+__all__ = [
+    "TextPositionIndex",
+    "TextPositionIndexService",
+    "build_text_position_index",
+]

pycforge/ide/process_worker.py

@@ -0,0 +1,130 @@
+"""Spawn-safe child-process entry point for one PyCForge conversion request."""
+
+from __future__ import annotations
+
+from threading import Thread
+
+from pycforge.converter.core.cancellation import CancellationToken
+from pycforge.converter.core.progress import ConversionProgress
+from pycforge.converter.facade import PythonToCConverter
+
+from .worker_protocol import (
+    ByteConnection,
+    WorkerProtocolError,
+    WorkerRequest,
+    encode_failure,
+    encode_progress,
+    encode_terminal,
+    receive_control,
+    receive_request,
+    send_event,
+)
+
+
+def worker_main(
+    request_connection: ByteConnection,
+    event_connection: ByteConnection,
+    control_connection: ByteConnection,
+) -> None:
+    """Receive, convert, publish one terminal event, and exit.
+
+    Conversion runs only in this child process.  The small daemon listener
+    translates the sole control command into the converter's existing local
+    ``CancellationToken``; the converter facade itself remains unchanged.
+    """
+
+    request: WorkerRequest | None = None
+    token = CancellationToken()
+    try:
+        request = receive_request(request_connection)
+        _close_quietly(request_connection)
+        Thread(
+            target=_listen_for_cancel,
+            args=(control_connection, request, token),
+            name=f"pycforge-cancel-{request.generation}",
+            daemon=True,
+        ).start()
+
+        def report(progress: ConversionProgress) -> None:
+            send_event(event_connection, encode_progress(request, progress))
+
+        result = PythonToCConverter().convert(
+            request.request,
+            observation=request.observation,
+            cancellation=token,
+            progress=report,
+        )
+        send_event(event_connection, encode_terminal(request, result))
+    except WorkerProtocolError as exc:
+        _send_failure_quietly(
+            event_connection,
+            request,
+            "protocol-error",
+            str(exc),
+        )
+    except MemoryError:
+        _send_failure_quietly(
+            event_connection,
+            request,
+            "worker-resource-exhaustion",
+            "converter worker exhausted its bounded process resources",
+        )
+    except (EOFError, BrokenPipeError, OSError):
+        _send_failure_quietly(
+            event_connection,
+            request,
+            "request-transport-error",
+            "converter worker transport closed before terminal publication",
+        )
+    except Exception:
+        _send_failure_quietly(
+            event_connection,
+            request,
+            "worker-internal-error",
+            "converter worker failed before terminal publication",
+        )
+    finally:
+        _close_quietly(request_connection)
+        _close_quietly(control_connection)
+        _close_quietly(event_connection)
+
+
+def _listen_for_cancel(
+    connection: ByteConnection,
+    request: WorkerRequest,
+    token: CancellationToken,
+) -> None:
+    try:
+        control = receive_control(connection)
+        if (
+            control.generation == request.generation
+            and control.bundle_fingerprint == request.bundle_fingerprint
+            and control.transport_fingerprint == request.transport_fingerprint
+        ):
+            token.cancel()
+    except (WorkerProtocolError, EOFError, BrokenPipeError, OSError):
+        return
+    finally:
+        _close_quietly(connection)
+
+
+def _send_failure_quietly(
+    connection: ByteConnection,
+    request: WorkerRequest | None,
+    classification: str,
+    message: str,
+) -> None:
+    try:
+        send_event(
+            connection,
+            encode_failure(request, classification, message),
+        )
+    except (WorkerProtocolError, EOFError, BrokenPipeError, OSError):
+        pass
+
+
+def _close_quietly(connection: ByteConnection) -> None:
+    try:
+        connection.close()
+    except (BrokenPipeError, OSError):
+        pass

pycforge/ide/qt.py

@@ -0,0 +1,230 @@
+"""Professional PyQt5 workspace for the PyCForge facade.
+
+The desktop surface remains presentation and orchestration only. It never
+executes Python, compiles generated C, resolves imports through the host, or
+changes converter contracts. The module is import-safe when PyQt5 is absent.
+
+The implementation is decomposed into cohesive mixins so the active workspace
+surface stays reviewable: shell construction, document actions, bounded
+snapshot projection, settings/file observation, and guarded close behavior.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pycforge._version import __version__
+
+from .controller import WorkspaceController
+from .qt_contract import (
+    SETTINGS_APPLICATION,
+    SETTINGS_ORGANIZATION,
+    SETTINGS_SCHEMA_VERSION,
+    coerce_settings_schema_version,
+    diagnostic_character_range,
+    line_column_offset,
+    mapping_character_range,
+    python_offset_to_qt_position,
+    qt_position_to_python_offset,
+    qt_range,
+)
+from .theme import apply_pycforge_theme
+
+
+# Preserve the original private helper spelling used by the workspace tests
+# and downstream integrations.
+_coerce_settings_schema_version = coerce_settings_schema_version
+_qt_range = qt_range
+
+
+try:
+    from PyQt5.QtCore import (
+        QFileSystemWatcher,
+        QSettings,
+        Qt,
+        QTimer,
+        pyqtSignal,
+    )
+    from PyQt5.QtWidgets import QApplication, QMainWindow
+except (ImportError, ModuleNotFoundError) as exc:
+    QT_AVAILABLE = False
+    _QT_ERROR = exc
+else:
+    QT_AVAILABLE = True
+    _QT_ERROR = None
+
+
+if QT_AVAILABLE:
+    from .qt_close import QtCloseMixin
+    from .qt_documents import QtDocumentActionsMixin
+    from .qt_projection import QtProjectionMixin
+    from .qt_shell import QtShellMixin
+    from .qt_state import QtStateMixin
+    from .qt_workspace_features import QtWorkspaceFeaturesMixin
+
+    class MainWindow(
+        QtShellMixin,
+        QtWorkspaceFeaturesMixin,
+        QtDocumentActionsMixin,
+        QtProjectionMixin,
+        QtStateMixin,
+        QtCloseMixin,
+        QMainWindow,
+    ):
+        """Python-first SourceBundle workspace with immutable C presentation."""
+
+        snapshot_ready = pyqtSignal(object)
+        structure_ready = pyqtSignal(object)
+        operation_error = pyqtSignal(str)
+        io_finished = pyqtSignal(object, object)
+
+        _STAGE_LABELS = {
+            "frontend.source_document": "Reading source bundle",
+            "frontend.parse": "Parsing Python documents",
+            "frontend.normalize": "Normalizing Python IR",
+            "modules.resolve": "Resolving module bundle",
+            "analysis.plan": "Analyzing and planning",
+            "lowering.first_slice": (
+                "Lowering, resolving helpers, and validating C"
+            ),
+        }
+        _SUCCESS_STATES = {
+            "converted",
+            "warning",
+            "approximation",
+            "observer-incomplete",
+        }
+
+        def __init__(
+            self,
+            controller: WorkspaceController | None = None,
+        ):
+            super().__init__()
+            self.controller = controller or WorkspaceController()
+            self.settings = QSettings(
+                SETTINGS_ORGANIZATION,
+                SETTINGS_APPLICATION,
+            )
+            self._prepare_settings()
+            self._displayed_document_id: str | None = None
+            self._displayed_source_key: tuple[str, int] | None = None
+            self._displayed_output_key: (
+                tuple[int | None, int] | None
+            ) = None
+            self._output_projection_key: (
+                tuple[int | None, int] | None
+            ) = None
+            self._output_projection_offset = 0
+            self._output_projection_text = ""
+            self._navigator_key: tuple[Any, ...] | None = None
+            self._detail_projection_key: (
+                tuple[Any, ...] | None
+            ) = None
+            self._source_marker_key: tuple[Any, ...] | None = None
+            self._output_marker_key: tuple[Any, ...] | None = None
+            self._last_snapshot = None
+            self._progress_sequence: int | None = None
+            self._closing = False
+            self._close_save_pending = 0
+            self._close_save_failed = False
+            self._applying_source_text = False
+            self._source_sync_pending = False
+            self._source_sync_document_id: str | None = None
+            self._source_sync_timer = QTimer(self)
+            self._source_sync_timer.setSingleShot(True)
+            self._source_sync_timer.setInterval(120)
+            self._source_sync_timer.timeout.connect(
+                self._flush_pending_source_sync
+            )
+            self._known_file_fingerprints: dict[str, str] = {}
+            self._watcher_projection_key: (
+                tuple[Any, ...] | None
+            ) = None
+            self._recent_paths = self._load_recent_paths()
+            self._last_directory = self._setting_text(
+                "workspace/last_directory", ""
+            )
+            self._initialize_workspace_features()
+
+            self.setObjectName("PyCForgeMainWindow")
+            self.setWindowTitle(f"PyCForge {__version__} — Workspace")
+            self.resize(1420, 880)
+            self.setMinimumSize(960, 620)
+
+            self._build_workspace()
+            self._build_actions()
+            self._build_toolbar()
+            self._build_menus()
+            self._wire_workspace()
+            self._restore_workspace_state()
+
+            self.file_watcher = QFileSystemWatcher(self)
+            self.file_watcher.fileChanged.connect(
+                self._external_file_changed
+            )
+
+            self.snapshot_ready.connect(self._apply_snapshot)
+            self.operation_error.connect(
+                lambda message: self.toast.show_message(
+                    message, "error"
+                )
+            )
+            self.io_finished.connect(
+                lambda callback, future: callback(future)
+            )
+            self._snapshot_listener = self.snapshot_ready.emit
+            self.controller.subscribe(self._snapshot_listener)
+            self._apply_snapshot(self.controller.snapshot)
+
+
+# Static integration vocabulary remains documented at the public module seam
+# after decomposition. Runtime implementations live in the cohesive mixins:
+# CodeEditor(language="python"), CodeEditor(language="c"), DocumentNavigator(),
+# FindReplaceBar(), DiagnosticsView(), MappingsView(), QProgressBar;
+# toolbar.setObjectName("PyCForgeToolbar");
+# self.controller.save_generated_c_linked_async(), snapshot.can_save_c;
+# self.output.setReadOnly(True), self.output.setVisible(False),
+# self.tabs.setVisible(False); action label "Show C"; progress delay 180 ms.
+
+
+def run() -> int:
+    if not QT_AVAILABLE:
+        raise RuntimeError(
+            "PyQt5 is required for the PyCForge workspace"
+        ) from _QT_ERROR
+    if QApplication.instance() is None:
+        QApplication.setAttribute(
+            Qt.AA_EnableHighDpiScaling, True
+        )
+        QApplication.setAttribute(
+            Qt.AA_UseHighDpiPixmaps, True
+        )
+    app = QApplication.instance() or QApplication([])
+    app.setApplicationName("PyCForge")
+    app.setOrganizationName("PyCForge")
+    apply_pycforge_theme(app)
+    window = MainWindow()
+    window.show()
+    return app.exec_()
+
+
+__all__ = [
+    "MainWindow",
+    "QT_AVAILABLE",
+    "SETTINGS_SCHEMA_VERSION",
+    "diagnostic_character_range",
+    "line_column_offset",
+    "mapping_character_range",
+    "python_offset_to_qt_position",
+    "qt_position_to_python_offset",
+    "run",
+] if QT_AVAILABLE else [
+    "QT_AVAILABLE",
+    "SETTINGS_SCHEMA_VERSION",
+    "diagnostic_character_range",
+    "line_column_offset",
+    "mapping_character_range",
+    "python_offset_to_qt_position",
+    "qt_position_to_python_offset",
+    "run",
+]