paraview-mcp-python 0.1.2__tar.gz → 0.1.3__tar.gz

{paraview_mcp_python-0.1.2 → paraview_mcp_python-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paraview-mcp-python
-Version: 0.1.2
+Version: 0.1.3
 Summary: MCP server for controlling ParaView via AI assistants
 Project-URL: Homepage, https://github.com/djeada/paraview-mcp-server
 Project-URL: Repository, https://github.com/djeada/paraview-mcp-server
@@ -163,6 +163,11 @@ Expected output:
 ParaView MCP GUI bridge started on 127.0.0.1:9876
 ```
 
+Do not start the live GUI bridge with `paraview --script
+scripts/start_paraview_gui_bridge.py`. ParaView runs startup scripts before the
+embedded GUI Python environment is fully ready for pipeline edits. Use **Tools
+-> Python Shell -> Run Script** for the live GUI bridge.
+
 If `paraview-mcp-python` is installed into ParaView's Python environment, you
 can also start the live GUI bridge directly from the Python Shell:
 

{paraview_mcp_python-0.1.2 → paraview_mcp_python-0.1.3}/README.md

@@ -130,6 +130,11 @@ Expected output:
 ParaView MCP GUI bridge started on 127.0.0.1:9876
 ```
 
+Do not start the live GUI bridge with `paraview --script
+scripts/start_paraview_gui_bridge.py`. ParaView runs startup scripts before the
+embedded GUI Python environment is fully ready for pipeline edits. Use **Tools
+-> Python Shell -> Run Script** for the live GUI bridge.
+
 If `paraview-mcp-python` is installed into ParaView's Python environment, you
 can also start the live GUI bridge directly from the Python Shell:
 

{paraview_mcp_python-0.1.2 → paraview_mcp_python-0.1.3}/bridge/command_handler.py

@@ -8,6 +8,7 @@ is available.
 from __future__ import annotations
 
 import logging
+import os
 from typing import TYPE_CHECKING, Any
 
 from bridge.models import (
@@ -346,7 +347,8 @@ class CommandHandler:
             camera.SetViewUp(*params["view_up"])
         if "parallel_scale" in params:
             camera.SetParallelScale(params["parallel_scale"])
-        view.StillRender()
+        if os.environ.get("PARAVIEW_MCP_GUI_BRIDGE") != "1":
+            view.StillRender()
         pos = list(camera.GetPosition())
         fp = list(camera.GetFocalPoint())
         up = list(camera.GetViewUp())

paraview_mcp_python-0.1.3/bridge/gui_bridge.py

@@ -0,0 +1,264 @@
+"""Helpers for starting the bridge from an already-open ParaView GUI session."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import logging
+import os
+import select
+import socket
+import traceback
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+from bridge.server import BUFFER_SIZE, HOST, PORT
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class _ClientState:
+    sock: socket.socket
+    buffer: bytes = b""
+
+
+class ParaViewGuiBridgeServer:
+    """Nonblocking TCP bridge polled from ParaView's GUI event loop."""
+
+    def __init__(self, host: str = HOST, port: int = PORT, poll_interval_ms: int = 50):
+        self._host = host
+        self._port = port
+        self._poll_interval_ms = poll_interval_ms
+        self._server_socket: socket.socket | None = None
+        self._clients: dict[socket.socket, _ClientState] = {}
+        self._running = False
+        self._interactor: Any | None = None
+        self._observer_id: int | None = None
+        self._timer_id: int | None = None
+        # Import here so this module can be imported without ParaView installed.
+        from bridge.command_handler import CommandHandler
+
+        self._handler = CommandHandler()
+
+    @property
+    def host(self) -> str:
+        return self._host
+
+    @property
+    def port(self) -> int:
+        return self._port
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def start(self) -> None:
+        if self._running:
+            return
+        self._interactor = self._get_render_window_interactor()
+        if not callable(getattr(self._interactor, "AddObserver", None)):
+            raise RuntimeError("ParaView render window interactor does not support VTK observers")
+        if not callable(getattr(self._interactor, "CreateRepeatingTimer", None)):
+            raise RuntimeError("ParaView render window interactor does not support repeating timers")
+
+        self._server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._server_socket.setblocking(False)
+        self._server_socket.bind((self._host, self._port))
+        self._host, self._port = self._server_socket.getsockname()[:2]
+        self._server_socket.listen(5)
+
+        self._observer_id = self._interactor.AddObserver("TimerEvent", self._on_timer)
+        self._timer_id = self._interactor.CreateRepeatingTimer(self._poll_interval_ms)
+        os.environ["PARAVIEW_MCP_GUI_BRIDGE"] = "1"
+        self._running = True
+        logger.info("ParaView GUI bridge listening on %s:%s", self._host, self._port)
+
+    def stop(self) -> None:
+        self._running = False
+        if self._interactor is not None and self._timer_id is not None:
+            destroy_timer = getattr(self._interactor, "DestroyTimer", None)
+            if callable(destroy_timer):
+                with contextlib.suppress(Exception):
+                    destroy_timer(self._timer_id)
+        if self._interactor is not None and self._observer_id is not None:
+            remove_observer = getattr(self._interactor, "RemoveObserver", None)
+            if callable(remove_observer):
+                with contextlib.suppress(Exception):
+                    remove_observer(self._observer_id)
+        self._timer_id = None
+        self._observer_id = None
+        self._interactor = None
+        os.environ.pop("PARAVIEW_MCP_GUI_BRIDGE", None)
+
+        for client in list(self._clients):
+            self._close_client(client)
+        if self._server_socket is not None:
+            with contextlib.suppress(OSError):
+                self._server_socket.close()
+            self._server_socket = None
+
+    def _on_timer(self, _obj: Any, _event: str) -> None:
+        self.poll()
+
+    def poll(self) -> None:
+        """Process pending socket work without blocking the GUI event loop."""
+        if not self._running or self._server_socket is None:
+            return
+        sockets = [self._server_socket, *self._clients]
+        try:
+            readable, _, errored = select.select(sockets, [], sockets, 0)
+        except OSError:
+            return
+
+        for sock in errored:
+            if sock is self._server_socket:
+                logger.error("ParaView GUI bridge server socket failed")
+                self.stop()
+                return
+            self._close_client(sock)
+
+        for sock in readable:
+            if sock is self._server_socket:
+                self._accept_ready_clients()
+                return
+            else:
+                if self._read_client(sock):
+                    return
+
+    def _accept_ready_clients(self) -> None:
+        if self._server_socket is None:
+            return
+        while True:
+            try:
+                conn, addr = self._server_socket.accept()
+            except BlockingIOError:
+                break
+            except OSError:
+                break
+            conn.setblocking(False)
+            self._clients[conn] = _ClientState(conn)
+            logger.info("Client connected from %s", addr)
+
+    def _read_client(self, sock: socket.socket) -> bool:
+        state = self._clients.get(sock)
+        if state is None:
+            return False
+        try:
+            data = sock.recv(BUFFER_SIZE)
+        except BlockingIOError:
+            return False
+        except OSError:
+            self._close_client(sock)
+            return False
+        if not data:
+            self._close_client(sock)
+            return False
+
+        state.buffer += data
+        while b"\n" in state.buffer:
+            line, state.buffer = state.buffer.split(b"\n", 1)
+            if not line.strip():
+                continue
+            try:
+                request = json.loads(line.decode("utf-8"))
+                response = self._process_request(request)
+            except Exception as exc:
+                response = {"id": None, "success": False, "error": str(exc)}
+            self._send_response(sock, response)
+            return True
+        return False
+
+    def _send_response(self, sock: socket.socket, response: dict[str, Any]) -> None:
+        try:
+            sock.sendall((json.dumps(response) + "\n").encode("utf-8"))
+        except OSError:
+            self._close_client(sock)
+
+    def _close_client(self, sock: socket.socket) -> None:
+        self._clients.pop(sock, None)
+        with contextlib.suppress(OSError):
+            sock.close()
+
+    def _process_request(self, request: dict[str, Any]) -> dict[str, Any]:
+        if not isinstance(request, dict):
+            raise TypeError("Request must be a JSON object")
+
+        req_id = request.get("id", str(uuid.uuid4()))
+        command = request.get("command")
+        params = request.get("params", {})
+        if not isinstance(command, str) or not command.strip():
+            return {"id": req_id, "success": False, "error": "Missing or invalid command"}
+        if not isinstance(params, dict):
+            return {"id": req_id, "success": False, "error": "Invalid params: expected JSON object"}
+        try:
+            result = self._handler.handle(command, params)
+            return {"id": req_id, "success": True, "result": result}
+        except Exception as exc:
+            logger.error("Command '%s' failed: %s\n%s", command, exc, traceback.format_exc())
+            return {"id": req_id, "success": False, "error": str(exc)}
+
+    @staticmethod
+    def _get_render_window_interactor() -> Any:
+        import paraview  # noqa: PLC0415
+        import paraview.simple as pvs  # noqa: PLC0415
+
+        if not getattr(paraview, "fromGUI", False):
+            raise RuntimeError(
+                "The live GUI bridge must be started from ParaView's Python Shell with Run Script. "
+                "Starting it with 'paraview --script' runs too early in ParaView startup and is not stable."
+            )
+
+        view = pvs.GetActiveViewOrCreate("RenderView")
+        render_window = view.GetRenderWindow()
+        interactor = render_window.GetInteractor()
+        if interactor is None:
+            raise RuntimeError("ParaView render window interactor is not available")
+        return interactor
+
+
+_SERVER: ParaViewGuiBridgeServer | None = None
+
+
+def start_gui_bridge(host: str = HOST, port: int = PORT) -> dict[str, Any]:
+    """Start the bridge inside the current ParaView GUI process."""
+    global _SERVER
+    if _SERVER is not None and _SERVER.is_running:
+        return {
+            "host": _SERVER.host,
+            "port": _SERVER.port,
+            "running": True,
+            "already_running": True,
+        }
+
+    server = ParaViewGuiBridgeServer(host=host, port=port)
+    server.start()
+    _SERVER = server
+    return {
+        "host": server.host,
+        "port": server.port,
+        "running": True,
+        "already_running": False,
+    }
+
+
+def stop_gui_bridge() -> dict[str, Any]:
+    """Stop the bridge started by :func:`start_gui_bridge`."""
+    global _SERVER
+    if _SERVER is None:
+        return {"running": False, "stopped": False}
+
+    host = _SERVER.host
+    port = _SERVER.port
+    _SERVER.stop()
+    _SERVER = None
+    return {"host": host, "port": port, "running": False, "stopped": True}
+
+
+def gui_bridge_status() -> dict[str, Any]:
+    """Return the current GUI bridge status."""
+    if _SERVER is None or not _SERVER.is_running:
+        return {"running": False}
+    return {"host": _SERVER.host, "port": _SERVER.port, "running": True}

{paraview_mcp_python-0.1.2 → paraview_mcp_python-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paraview-mcp-python"
-version = "0.1.2"
+version = "0.1.3"
 description = "MCP server for controlling ParaView via AI assistants"
 readme = "README.md"
 license = "MIT"

{paraview_mcp_python-0.1.2 → paraview_mcp_python-0.1.3}/scripts/start_paraview_gui_bridge.py

@@ -4,9 +4,8 @@ Run from ParaView:
 
     Tools -> Python Shell -> Run Script
 
-Select this file. The script starts the TCP bridge in a background thread and
-returns immediately, so the ParaView GUI remains usable. MCP commands will then
-modify this open ParaView session.
+Select this file. The script attaches the TCP bridge to ParaView's GUI event
+loop and returns immediately, so MCP commands modify this open ParaView session.
 """
 
 from __future__ import annotations
@@ -14,12 +13,22 @@ from __future__ import annotations
 import logging
 import os
 import sys
+from pathlib import Path
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
 
-REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if REPO_ROOT not in sys.path:
-    sys.path.insert(0, REPO_ROOT)
+SCRIPT_PATH = globals().get("__file__")
+ROOT_CANDIDATES = []
+if SCRIPT_PATH:
+    ROOT_CANDIDATES.append(Path(SCRIPT_PATH).resolve().parents[1])
+ROOT_CANDIDATES.extend([Path.cwd(), Path.cwd().parent])
+
+for candidate in ROOT_CANDIDATES:
+    if (candidate / "bridge" / "gui_bridge.py").is_file():
+        repo_root = str(candidate)
+        if repo_root not in sys.path:
+            sys.path.insert(0, repo_root)
+        break
 
 from bridge.gui_bridge import gui_bridge_status, start_gui_bridge, stop_gui_bridge  # noqa: E402
 

paraview_mcp_python-0.1.3/tests/test_gui_bridge.py

@@ -0,0 +1,143 @@
+"""Tests for the ParaView GUI bridge lifecycle helpers."""
+
+from __future__ import annotations
+
+import json
+import socket
+import sys
+from types import ModuleType
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from bridge import gui_bridge
+
+
+class FakeInteractor:
+    def __init__(self):
+        self.callback = None
+        self.removed_observer = None
+        self.destroyed_timer = None
+
+    def AddObserver(self, event_name, callback):  # noqa: N802
+        assert event_name == "TimerEvent"
+        self.callback = callback
+        return 100
+
+    def CreateRepeatingTimer(self, interval_ms):  # noqa: N802
+        assert interval_ms > 0
+        return 200
+
+    def DestroyTimer(self, timer_id):  # noqa: N802
+        self.destroyed_timer = timer_id
+
+    def RemoveObserver(self, observer_id):  # noqa: N802
+        self.removed_observer = observer_id
+
+
+class FakeRenderWindow:
+    def __init__(self, interactor):
+        self._interactor = interactor
+
+    def GetInteractor(self):  # noqa: N802
+        return self._interactor
+
+
+class FakeView:
+    def __init__(self, interactor):
+        self._interactor = interactor
+
+    def GetRenderWindow(self):  # noqa: N802
+        return FakeRenderWindow(self._interactor)
+
+
+@pytest.fixture
+def fake_interactor(monkeypatch):
+    interactor = FakeInteractor()
+    paraview_module = ModuleType("paraview")
+    paraview_module.fromGUI = True
+    simple_module = ModuleType("paraview.simple")
+    simple_module.GetActiveViewOrCreate = MagicMock(return_value=FakeView(interactor))
+    monkeypatch.setitem(sys.modules, "paraview", paraview_module)
+    monkeypatch.setitem(sys.modules, "paraview.simple", simple_module)
+    yield interactor
+    gui_bridge.stop_gui_bridge()
+
+
+def test_start_gui_bridge_is_non_blocking_and_reports_status(fake_interactor):
+    with patch("bridge.command_handler.CommandHandler", return_value=MagicMock()):
+        status = gui_bridge.start_gui_bridge(port=0)
+
+    assert fake_interactor.callback is not None
+    assert status["running"] is True
+    assert status["already_running"] is False
+    assert status["host"] == "127.0.0.1"
+    assert status["port"] > 0
+    assert gui_bridge.gui_bridge_status() == {
+        "host": status["host"],
+        "port": status["port"],
+        "running": True,
+    }
+
+
+def test_start_gui_bridge_is_idempotent(fake_interactor):
+    with patch("bridge.command_handler.CommandHandler", return_value=MagicMock()):
+        first = gui_bridge.start_gui_bridge(port=0)
+        second = gui_bridge.start_gui_bridge(port=0)
+
+    assert second == {
+        "host": first["host"],
+        "port": first["port"],
+        "running": True,
+        "already_running": True,
+    }
+
+
+def test_stop_gui_bridge_stops_running_server(fake_interactor):
+    with patch("bridge.command_handler.CommandHandler", return_value=MagicMock()):
+        started = gui_bridge.start_gui_bridge(port=0)
+
+    stopped = gui_bridge.stop_gui_bridge()
+
+    assert stopped == {
+        "host": started["host"],
+        "port": started["port"],
+        "running": False,
+        "stopped": True,
+    }
+    assert fake_interactor.destroyed_timer == 200
+    assert fake_interactor.removed_observer == 100
+    assert gui_bridge.gui_bridge_status() == {"running": False}
+
+
+def test_gui_bridge_processes_socket_request_from_poll_callback(fake_interactor):
+    handler = MagicMock()
+    handler.handle.return_value = {"source_count": 0}
+    with patch("bridge.command_handler.CommandHandler", return_value=handler):
+        started = gui_bridge.start_gui_bridge(port=0)
+
+    with socket.create_connection((started["host"], started["port"]), timeout=1) as client:
+        request = {"id": "abc", "command": "scene.get_info", "params": {}}
+        client.sendall((json.dumps(request) + "\n").encode("utf-8"))
+        assert fake_interactor.callback is not None
+        fake_interactor.callback(None, "TimerEvent")
+        fake_interactor.callback(None, "TimerEvent")
+        response = client.recv(65536)
+
+    assert json.loads(response.decode("utf-8")) == {
+        "id": "abc",
+        "success": True,
+        "result": {"source_count": 0},
+    }
+    handler.handle.assert_called_once_with("scene.get_info", {})
+
+
+def test_gui_bridge_rejects_command_line_startup(monkeypatch):
+    paraview_module = ModuleType("paraview")
+    paraview_module.fromGUI = False
+    simple_module = ModuleType("paraview.simple")
+    monkeypatch.setitem(sys.modules, "paraview", paraview_module)
+    monkeypatch.setitem(sys.modules, "paraview.simple", simple_module)
+
+    with pytest.raises(RuntimeError, match="Python Shell"):
+        gui_bridge.start_gui_bridge(port=0)

paraview_mcp_python-0.1.2/bridge/gui_bridge.py

@@ -1,55 +0,0 @@
-"""Helpers for starting the bridge from an already-open ParaView GUI session."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from bridge.server import HOST, PORT, ParaViewBridgeServer
-
-_SERVER: ParaViewBridgeServer | None = None
-
-
-def start_gui_bridge(host: str = HOST, port: int = PORT) -> dict[str, Any]:
-    """Start the bridge inside the current ParaView Python process.
-
-    This function is intentionally non-blocking so it can be called from the
-    ParaView GUI Python shell without freezing the application.
-    """
-    global _SERVER
-    if _SERVER is not None and _SERVER.is_running:
-        return {
-            "host": _SERVER.host,
-            "port": _SERVER.port,
-            "running": True,
-            "already_running": True,
-        }
-
-    server = ParaViewBridgeServer(host=host, port=port)
-    server.start()
-    _SERVER = server
-    return {
-        "host": server.host,
-        "port": server.port,
-        "running": True,
-        "already_running": False,
-    }
-
-
-def stop_gui_bridge() -> dict[str, Any]:
-    """Stop the bridge started by :func:`start_gui_bridge`."""
-    global _SERVER
-    if _SERVER is None:
-        return {"running": False, "stopped": False}
-
-    host = _SERVER.host
-    port = _SERVER.port
-    _SERVER.stop()
-    _SERVER = None
-    return {"host": host, "port": port, "running": False, "stopped": True}
-
-
-def gui_bridge_status() -> dict[str, Any]:
-    """Return the current GUI bridge status."""
-    if _SERVER is None or not _SERVER.is_running:
-        return {"running": False}
-    return {"host": _SERVER.host, "port": _SERVER.port, "running": True}

paraview_mcp_python-0.1.2/tests/test_gui_bridge.py

@@ -1,55 +0,0 @@
-"""Tests for the ParaView GUI bridge lifecycle helpers."""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-from bridge import gui_bridge
-
-
-def teardown_function(_function):
-    gui_bridge.stop_gui_bridge()
-
-
-def test_start_gui_bridge_is_non_blocking_and_reports_status():
-    with patch("bridge.command_handler.CommandHandler", return_value=MagicMock()):
-        status = gui_bridge.start_gui_bridge(port=0)
-
-    assert status["running"] is True
-    assert status["already_running"] is False
-    assert status["host"] == "127.0.0.1"
-    assert status["port"] > 0
-    assert gui_bridge.gui_bridge_status() == {
-        "host": status["host"],
-        "port": status["port"],
-        "running": True,
-    }
-
-
-def test_start_gui_bridge_is_idempotent():
-    with patch("bridge.command_handler.CommandHandler", return_value=MagicMock()):
-        first = gui_bridge.start_gui_bridge(port=0)
-        second = gui_bridge.start_gui_bridge(port=0)
-
-    assert first["running"] is True
-    assert second == {
-        "host": first["host"],
-        "port": first["port"],
-        "running": True,
-        "already_running": True,
-    }
-
-
-def test_stop_gui_bridge_stops_running_server():
-    with patch("bridge.command_handler.CommandHandler", return_value=MagicMock()):
-        started = gui_bridge.start_gui_bridge(port=0)
-
-    stopped = gui_bridge.stop_gui_bridge()
-
-    assert stopped == {
-        "host": started["host"],
-        "port": started["port"],
-        "running": False,
-        "stopped": True,
-    }
-    assert gui_bridge.gui_bridge_status() == {"running": False}