include geometry previews in EM_embedded

em_embedded.py

@@ -42,116 +42,108 @@ except ModuleNotFoundError:
 pv.OFF_SCREEN = True
 
 
-class PrefixedStateProxy:
-    """State wrapper that automatically namespaces EM fields with a prefix."""
-
-    __slots__ = ("_prefix", "_state", "_pending_updates", "_pending_changes", "_cache")
-
-    def __init__(self, prefix: str):
-        object.__setattr__(self, "_prefix", prefix)
-        object.__setattr__(self, "_state", None)
-        object.__setattr__(self, "_pending_updates", {})
-        object.__setattr__(self, "_pending_changes", [])
-        object.__setattr__(self, "_cache", {})
-
-    # --- Binding ---
-    def bind(self, state):
-        object.__setattr__(self, "_state", state)
-        if self._pending_updates:
-            prefixed = {f"{self._prefix}{k}": v for k, v in self._pending_updates.items()}
-            state.update(prefixed)
-            self._pending_updates.clear()
-        for name, value in self._cache.items():
-            setattr(state, f"{self._prefix}{name}", value)
-        self._cache.clear()
-        for names, kwargs, func in self._pending_changes:
-            prefixed = tuple(f"{self._prefix}{n}" for n in names)
-            state.change(*prefixed, **kwargs)(func)
+# ============================================================================
+# DEFERRED STATE/CONTROLLER PROXY CLASSES
+# These allow using state.update(), @state.change(), and ctrl.xxx at module
+# load time, then applying them when set_server() is called.
+# ============================================================================
+
+class _DeferredStateProxy:
+    """
+    A proxy that collects state defaults and change decorators at module load time,
+    then applies them to the real server.state when bind() is called.
+    """
+
+    def __init__(self):
+        self._state = None
+        self._defaults = {}
+        self._pending_changes = []  # list of (keys, func)
+
+    def bind(self, real_state):
+        """Bind to the real state object and apply all pending operations."""
+        self._state = real_state
+        # Apply all collected defaults
+        if self._defaults:
+            real_state.update(self._defaults)
+            self._defaults.clear()
+        # Apply all pending @state.change decorators
+        for keys, func in self._pending_changes:
+            real_state.change(*keys)(func)
         self._pending_changes.clear()
 
     @property
-    def bound(self) -> bool:
+    def bound(self):
         return self._state is not None
 
-    # --- Core API ---
-    def update(self, values: dict):
-        if self._state is None:
-            self._pending_updates.update(values)
+    def update(self, d):
+        """Collect defaults; apply immediately if bound."""
+        if self._state is not None:
+            self._state.update(d)
         else:
-            prefixed = {f"{self._prefix}{k}": v for k, v in values.items()}
-            self._state.update(prefixed)
-
-    def change(self, *names, **kwargs):
-        prefix = self._prefix
+            self._defaults.update(d)
 
+    def change(self, *keys):
+        """
+        Decorator factory that mimics @state.change("key1", "key2").
+        If already bound, apply immediately. Otherwise, queue for later.
+        """
         def decorator(func):
-            # Wrap the user's callback to translate prefixed kwargs back to unprefixed
-            def wrapper(**kw):
-                translated = {}
-                for k, v in kw.items():
-                    if k.startswith(prefix):
-                        translated[k[len(prefix):]] = v
-                    else:
-                        translated[k] = v
-                return func(**translated)
-
             if self._state is not None:
-                prefixed = tuple(f"{prefix}{n}" for n in names)
-                return self._state.change(*prefixed, **kwargs)(wrapper)
-            self._pending_changes.append((names, kwargs, wrapper))
+                # Already bound - register directly
+                self._state.change(*keys)(func)
+            else:
+                # Queue for later
+                self._pending_changes.append((keys, func))
             return func
-
         return decorator
 
-    # --- Attribute proxying ---
     def __getattr__(self, name):
-        if name in {"_prefix", "_state", "_pending_updates", "_pending_changes", "_cache", "bind", "bound", "update", "change"}:
-            return object.__getattribute__(self, name)
-        if self._state is not None:
-            return getattr(self._state, f"{self._prefix}{name}")
-        if name in self._pending_updates:
-            return self._pending_updates[name]
-        if name in self._cache:
-            return self._cache[name]
-        raise AttributeError(name)
+        if name.startswith("_"):
+            raise AttributeError(name)
+        if self._state is None:
+            raise AttributeError(f"State not bound yet; cannot access '{name}'")
+        return getattr(self._state, name)
 
     def __setattr__(self, name, value):
-        if name in {"_prefix", "_state", "_pending_updates", "_pending_changes", "_cache"}:
+        if name.startswith("_"):
             object.__setattr__(self, name, value)
         elif self._state is not None:
-            setattr(self._state, f"{self._prefix}{name}", value)
+            setattr(self._state, name, value)
         else:
-            self._cache[name] = value
+            # Store as a default
+            self._defaults[name] = value
 
 
-class ControllerProxy:
-    """Controller proxy that queues attribute bindings until a server is set."""
-
-    __slots__ = ("_ctrl", "_pending")
+class _DeferredControllerProxy:
+    """
+    A proxy that collects controller attribute assignments at module load time,
+    then applies them when bind() is called.
+    """
 
     def __init__(self):
-        object.__setattr__(self, "_ctrl", None)
-        object.__setattr__(self, "_pending", {})
+        self._ctrl = None
+        self._pending = {}
 
-    def bind(self, ctrl):
-        object.__setattr__(self, "_ctrl", ctrl)
+    def bind(self, real_ctrl):
+        """Bind to the real controller and apply pending attributes."""
+        self._ctrl = real_ctrl
         for name, value in self._pending.items():
-            setattr(ctrl, name, value)
+            setattr(real_ctrl, name, value)
         self._pending.clear()
 
     @property
-    def bound(self) -> bool:
+    def bound(self):
         return self._ctrl is not None
 
     def __getattr__(self, name):
-        if name in {"_ctrl", "_pending", "bind", "bound"}:
-            return object.__getattribute__(self, name)
+        if name.startswith("_"):
+            raise AttributeError(name)
         if self._ctrl is None:
-            raise AttributeError(f"Controller not set; cannot access '{name}'")
+            raise AttributeError(f"Controller not bound yet; cannot access '{name}'")
         return getattr(self._ctrl, name)
 
     def __setattr__(self, name, value):
-        if name in {"_ctrl", "_pending", "bind", "bound"}:
+        if name.startswith("_"):
             object.__setattr__(self, name, value)
         elif self._ctrl is not None:
             setattr(self._ctrl, name, value)
@@ -159,9 +151,10 @@ class ControllerProxy:
             self._pending[name] = value
 
 
+# Module-level proxies (will be bound when set_server is called)
 _server = None
-state = PrefixedStateProxy("em_")
-ctrl = ControllerProxy()
+state = _DeferredStateProxy()
+ctrl = _DeferredControllerProxy()
 
 
 def _noop(*_, **__):
@@ -193,6 +186,11 @@ def init_state(force: bool = False):
         return
     if force:
         reset_to_defaults()
+    # Initialize preview after state is bound
+    try:
+        update_initial_state_preview()
+    except Exception:
+        pass  # Ignore if preview can't be initialized yet
 
 # Cache for QPU Plotly export/selection (Python-side)
 qpu_ts_cache = {
@@ -3797,5 +3795,4 @@ def on_qpu_plot_filter_change(qpu_plot_filter, **kwargs):
     # No-op: updates handled by controller bound to the VSelect to avoid double refresh
     return
 
-# --- Initial Setup Call ---
-update_initial_state_preview()
+# Note: update_initial_state_preview() is called from init_state() after the server is bound