solidworks-mcp-python 1.5.0__py3-none-any.whl

solidworks_mcp/adapters/com_executor.py

@@ -0,0 +1,252 @@
+"""
+Single-threaded executor for SolidWorks COM calls.
+
+Background: SolidWorks COM is STA (single-threaded apartment). An
+``IDispatch`` proxy obtained on thread A cannot be invoked from thread B —
+pywin32's late-binding surfaces this as
+``AttributeError: SldWorks.Application.<method>``. FastMCP dispatches async
+tool handlers on worker threads that are *not* the thread where
+``connect()`` ran, so any cached ``swApp`` reference breaks.
+
+This module provides a single dedicated STA worker thread (``ComExecutor``).
+All COM work is submitted to it as callables and awaited via ``Future``.
+Because exactly one thread ever touches COM:
+
+1. ``CoInitialize()`` is called once at thread startup.
+2. ``self.swApp`` and ``self.currentModel`` can be shared instance attributes
+   without marshalling — no thread-local trickery.
+3. STA constraints are satisfied (SW is happy).
+4. ``_FlagAsMethod`` results accumulate on the same object lifetime.
+
+Usage:
+
+    executor = ComExecutor()
+    executor.start()
+    try:
+        result = executor.submit(lambda: sw.ActiveDoc.GetTitle())
+    finally:
+        executor.stop()
+
+or with the synchronous helper:
+
+    with ComExecutor() as ex:
+        title = ex.run(lambda: sw.ActiveDoc.GetTitle())
+"""
+
+from __future__ import annotations
+
+import queue
+import threading
+from collections.abc import Callable
+from concurrent.futures import Future
+from typing import Any, TypeVar
+
+from loguru import logger
+
+try:
+    import pythoncom
+
+    PYWIN32_AVAILABLE = True
+except ImportError:
+    PYWIN32_AVAILABLE = False
+
+
+T = TypeVar("T")
+
+
+# Sentinel object used to signal the worker thread to exit.
+_SHUTDOWN = object()
+
+
+class ComExecutor:
+    """Single-threaded STA executor for SolidWorks COM calls.
+
+    Thread-safe: ``submit()`` / ``run()`` may be called from any thread.
+
+    Lifecycle:
+        - Construct: creates the executor (no thread yet).
+        - ``start()``: launches the worker thread and waits for it to
+          CoInitialize.
+        - ``submit(fn)``: schedules ``fn`` on the worker; returns a Future.
+        - ``run(fn)``: convenience wrapper around submit+result.
+        - ``stop()``: signals the worker to exit, joins the thread, then
+          CoUninitializes.
+    """
+
+    def __init__(self, name: str = "SolidWorks-COM") -> None:
+        """Create the executor (thread not yet running).
+
+        Args:
+            name: Thread name for debugging / logs.
+        """
+        self._name = name
+        self._queue: queue.Queue[Any] = queue.Queue()
+        self._thread: threading.Thread | None = None
+        # Set by worker thread once CoInitialize succeeds, allowing submit()
+        # to block until the executor is truly ready.
+        self._ready = threading.Event()
+        self._stopped = threading.Event()
+        # Set by worker thread when CoInitialize fails so start() can join
+        # the thread synchronously and callers see is_alive() == False.
+        self._init_failed = threading.Event()
+
+    # ---- Public API ----
+
+    def start(self, timeout: float = 10.0) -> None:
+        """Launch the worker thread and wait until it has CoInitialized.
+
+        Idempotent: calling ``start()`` on a running executor is a no-op.
+
+        Args:
+            timeout: Seconds to wait for CoInitialize to complete. If it
+                doesn't fire in time, raises RuntimeError.
+
+        Raises:
+            RuntimeError: Worker didn't become ready in time.
+        """
+        if self._thread is not None and self._thread.is_alive():
+            return
+
+        if not PYWIN32_AVAILABLE:
+            raise RuntimeError("pywin32 is required for ComExecutor; not available")
+
+        self._ready.clear()
+        self._stopped.clear()
+        self._init_failed.clear()
+        self._thread = threading.Thread(
+            target=self._worker, name=self._name, daemon=True
+        )
+        self._thread.start()
+
+        if not self._ready.wait(timeout):
+            raise RuntimeError(
+                f"ComExecutor worker '{self._name}' did not "
+                f"initialize within {timeout}s"
+            )
+
+        # If CoInitialize failed the worker exits immediately after setting
+        # _ready. Join here so callers see is_alive() == False synchronously.
+        if self._init_failed.is_set():
+            self._thread.join(timeout)
+
+    def stop(self, timeout: float = 5.0) -> None:
+        """Signal the worker to exit and wait for it to join.
+
+        After ``stop()`` returns, no further ``submit()`` calls will be
+        serviced. Idempotent.
+
+        Args:
+            timeout: Seconds to wait for the worker to exit cleanly before
+                abandoning the join.
+        """
+        if self._thread is None or not self._thread.is_alive():
+            return
+
+        self._queue.put(_SHUTDOWN)
+        self._thread.join(timeout)
+        if self._thread.is_alive():
+            logger.warning(
+                f"ComExecutor worker '{self._name}' did not exit "
+                f"within {timeout}s; abandoning"
+            )
+        self._thread = None
+        self._stopped.set()
+
+    def submit(self, fn: Callable[[], T]) -> Future[T]:
+        """Schedule ``fn`` to run on the worker thread.
+
+        The callable receives no arguments — close over any state needed
+        via the enclosing scope. The return value (or exception) is
+        propagated through the returned ``Future``.
+
+        Args:
+            fn: Zero-argument callable to run on the COM thread.
+
+        Returns:
+            Future that will hold the result or exception.
+
+        Raises:
+            RuntimeError: Executor isn't running.
+        """
+        if self._thread is None or not self._thread.is_alive():
+            raise RuntimeError(
+                f"ComExecutor '{self._name}' is not running; call start() first"
+            )
+
+        fut: Future[T] = Future()
+        self._queue.put((fn, fut))
+        return fut
+
+    def run(self, fn: Callable[[], T], timeout: float | None = None) -> T:
+        """Run ``fn`` on the worker and block until the result is ready.
+
+        Convenience wrapper around ``submit()`` + ``Future.result()``.
+
+        Args:
+            fn: Zero-argument callable to run on the COM thread.
+            timeout: Seconds to wait before raising TimeoutError.
+
+        Returns:
+            Whatever ``fn`` returned.
+
+        Raises:
+            Exception: Any exception raised by ``fn``, re-raised in the caller.
+            TimeoutError: If ``timeout`` elapses before ``fn`` finishes.
+        """
+        return self.submit(fn).result(timeout=timeout)
+
+    # ---- Context manager ----
+
+    def __enter__(self) -> ComExecutor:
+        self.start()
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        self.stop()
+
+    # ---- Worker ----
+
+    def _worker(self) -> None:
+        """Run on the dedicated thread; initialize COM, process work, cleanup.
+
+        Loop exits when ``_SHUTDOWN`` appears in the queue. Each work item
+        is a ``(callable, Future)`` tuple; the callable runs, and the
+        Future is set with either the result or the raised exception.
+        """
+        try:
+            pythoncom.CoInitialize()
+        except Exception as e:
+            logger.error(
+                f"CoInitialize failed in ComExecutor worker '{self._name}': {e!r}"
+            )
+            # Signal init failure then unblock start() so it can join this
+            # thread synchronously before returning.
+            self._init_failed.set()
+            self._ready.set()
+            return
+
+        self._ready.set()
+        logger.info(f"ComExecutor '{self._name}' ready")
+
+        try:
+            while True:
+                item = self._queue.get()
+                if item is _SHUTDOWN:
+                    break
+
+                fn, fut = item
+                if not fut.set_running_or_notify_cancel():
+                    continue
+
+                try:
+                    result = fn()
+                except BaseException as e:  # noqa: BLE001 — propagate everything
+                    fut.set_exception(e)
+                else:
+                    fut.set_result(result)
+        finally:
+            try:
+                pythoncom.CoUninitialize()
+            except Exception:
+                pass
+            logger.info(f"ComExecutor '{self._name}' stopped")

solidworks_mcp/adapters/complexity_analyzer.py

@@ -0,0 +1,272 @@
+"""Complexity analysis for routing operations between COM and VBA paths."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+
+@dataclass(frozen=True)
+class OperationProfile:
+    """Complexity profile metadata for an operation.
+
+    Attributes:
+        base_complexity (float): The base complexity value.
+        name (str): The name value.
+        vba_preferred (bool): The vba preferred value.
+    """
+
+    name: str
+    base_complexity: float
+    vba_preferred: bool = False
+
+
+class RoutingDecision(BaseModel):
+    """Complexity-based routing decision.
+
+    Attributes:
+        complexity_score (float): The complexity score value.
+        operation (str): The operation value.
+        parameter_count (int): The parameter count value.
+        prefer_vba (bool): The prefer vba value.
+        reason (str): The reason value.
+    """
+
+    operation: str
+    parameter_count: int
+    complexity_score: float
+    prefer_vba: bool
+    reason: str
+
+
+class ComplexityAnalyzer:
+    """Analyze operation complexity and recommend COM or VBA execution path.
+
+    Args:
+        parameter_threshold (int): The parameter threshold value. Defaults to 12.
+        score_threshold (float): The score threshold value. Defaults to 0.6.
+
+    Attributes:
+        _parameter_threshold (Any): The parameter threshold value.
+        _score_threshold (Any): The score threshold value.
+    """
+
+    def __init__(
+        self,
+        parameter_threshold: int = 12,
+        score_threshold: float = 0.6,
+    ) -> None:
+        """Initialize analyzer state.
+
+        Args:
+            parameter_threshold (int): The parameter threshold value. Defaults to 12.
+            score_threshold (float): The score threshold value. Defaults to 0.6.
+
+        Returns:
+            None: None.
+        """
+        self._parameter_threshold = max(parameter_threshold, 1)
+        self._score_threshold = max(min(score_threshold, 1.0), 0.1)
+        self._profiles: dict[str, OperationProfile] = self._default_profiles()
+        self._history: dict[str, dict[str, int]] = {}
+
+    def analyze(self, operation: str, payload: object) -> RoutingDecision:
+        """Produce a routing recommendation for an operation call.
+
+        Args:
+            operation (str): Callable object executed by the helper.
+            payload (object): The payload value.
+
+        Returns:
+            RoutingDecision: The result produced by the operation.
+        """
+        profile = self._profiles.get(
+            operation,
+            OperationProfile(name=operation, base_complexity=0.2, vba_preferred=False),
+        )
+        parameter_count = self._count_parameters(payload)
+
+        parameter_component = min(
+            parameter_count / float(self._parameter_threshold), 1.0
+        )
+        history_component = self._history_bias(operation)
+        complexity_score = min(
+            1.0,
+            (parameter_component * 0.45)
+            + (profile.base_complexity * 0.40)
+            + (history_component * 0.15),
+        )
+
+        prefer_vba = (
+            parameter_count > self._parameter_threshold
+            or profile.vba_preferred
+            or complexity_score >= self._score_threshold
+        )
+
+        reason = (
+            "parameter threshold exceeded"
+            if parameter_count > self._parameter_threshold
+            else "profile prefers VBA"
+            if profile.vba_preferred
+            else "complexity score exceeded threshold"
+            if complexity_score >= self._score_threshold
+            else "COM path preferred"
+        )
+
+        return RoutingDecision(
+            operation=operation,
+            parameter_count=parameter_count,
+            complexity_score=complexity_score,
+            prefer_vba=prefer_vba,
+            reason=reason,
+        )
+
+    def record_result(self, operation: str, route: str, success: bool) -> None:
+        """Record operation outcome for future routing influence.
+
+        Args:
+            operation (str): Callable object executed by the helper.
+            route (str): The route value.
+            success (bool): The success value.
+
+        Returns:
+            None: None.
+        """
+        history = self._history.setdefault(
+            operation,
+            {
+                "com_success": 0,
+                "com_failure": 0,
+                "vba_success": 0,
+                "vba_failure": 0,
+            },
+        )
+        key = f"{route}_{'success' if success else 'failure'}"
+        if key in history:
+            history[key] += 1
+
+    def _history_bias(self, operation: str) -> float:
+        """Compute historical bias toward VBA based on COM reliability.
+
+        Args:
+            operation (str): Callable object executed by the helper.
+
+        Returns:
+            float: The computed numeric result.
+        """
+        history = self._history.get(operation)
+        if history is None:
+            return 0.0
+
+        com_success = history.get("com_success", 0)
+        com_failure = history.get("com_failure", 0)
+        com_total = com_success + com_failure
+        if com_total == 0:
+            return 0.0
+
+        failure_ratio = com_failure / float(com_total)
+        return max(min(failure_ratio, 1.0), 0.0)
+
+    def _count_parameters(self, payload: object) -> int:
+        """Count meaningful parameters in payload recursively.
+
+        Args:
+            payload (object): The payload value.
+
+        Returns:
+            int: The computed numeric result.
+        """
+        if payload is None:
+            return 0
+
+        if isinstance(payload, BaseModel):
+            return self._count_parameters(payload.model_dump(exclude_none=True))
+
+        if isinstance(payload, Mapping):
+            total = 0
+            for value in payload.values():
+                total += self._count_parameters(value)
+            return max(total, len(payload))
+
+        if isinstance(payload, (list, tuple, set)):
+            return sum(self._count_parameters(item) for item in payload)
+
+        return 1
+
+    def _default_profiles(self) -> dict[str, OperationProfile]:
+        """Return default complexity profiles for high-impact operations.
+
+        Returns:
+            dict[str, OperationProfile]: A dictionary containing the resulting values.
+        """
+        return {
+            # Modeling operations - likely to benefit from VBA routing
+            "create_extrusion": OperationProfile(
+                name="create_extrusion", base_complexity=0.55, vba_preferred=False
+            ),
+            "create_revolve": OperationProfile(
+                name="create_revolve", base_complexity=0.50, vba_preferred=False
+            ),
+            "create_sweep": OperationProfile(
+                name="create_sweep", base_complexity=0.65, vba_preferred=True
+            ),
+            "create_loft": OperationProfile(
+                name="create_loft", base_complexity=0.70, vba_preferred=True
+            ),
+            "create_assembly": OperationProfile(
+                name="create_assembly", base_complexity=0.45, vba_preferred=False
+            ),
+            "create_part": OperationProfile(
+                name="create_part", base_complexity=0.30, vba_preferred=False
+            ),
+            "create_drawing": OperationProfile(
+                name="create_drawing", base_complexity=0.50, vba_preferred=False
+            ),
+            # Sketching operations - moderate complexity
+            "create_sketch": OperationProfile(
+                name="create_sketch", base_complexity=0.25, vba_preferred=False
+            ),
+            "add_circle": OperationProfile(
+                name="add_circle", base_complexity=0.20, vba_preferred=False
+            ),
+            "add_rectangle": OperationProfile(
+                name="add_rectangle", base_complexity=0.20, vba_preferred=False
+            ),
+            "add_line": OperationProfile(
+                name="add_line", base_complexity=0.15, vba_preferred=False
+            ),
+            "add_arc": OperationProfile(
+                name="add_arc", base_complexity=0.35, vba_preferred=False
+            ),
+            "add_spline": OperationProfile(
+                name="add_spline", base_complexity=0.50, vba_preferred=True
+            ),
+            "add_polygon": OperationProfile(
+                name="add_polygon", base_complexity=0.30, vba_preferred=False
+            ),
+            "add_sketch_constraint": OperationProfile(
+                name="add_sketch_constraint", base_complexity=0.40, vba_preferred=False
+            ),
+            "add_sketch_dimension": OperationProfile(
+                name="add_sketch_dimension", base_complexity=0.30, vba_preferred=False
+            ),
+            # Assembly operations
+            "insert_component": OperationProfile(
+                name="insert_component", base_complexity=0.40, vba_preferred=False
+            ),
+            "add_mate": OperationProfile(
+                name="add_mate", base_complexity=0.55, vba_preferred=False
+            ),
+            # Drawing operations
+            "create_drawing_view": OperationProfile(
+                name="create_drawing_view", base_complexity=0.45, vba_preferred=False
+            ),
+            "add_drawing_annotation": OperationProfile(
+                name="add_drawing_annotation", base_complexity=0.35, vba_preferred=False
+            ),
+            "add_dimension": OperationProfile(
+                name="add_dimension", base_complexity=0.40, vba_preferred=False
+            ),
+        }