fix(perf): prevent sending data back to client

Author: jourdain

examples/perf_v2.py

@@ -0,0 +1,54 @@
+import time
+
+from trame.app import TrameApp
+from trame.ui.html import DivLayout
+from trame.widgets import html
+from trame_dataclass.v2 import StateDataModel, Sync, watch
+
+
+class Data(StateDataModel):
+    value = Sync(int, 1)
+
+    @watch("value")
+    def _fake_busy(self, _):
+        time.sleep(0.1)
+
+
+class Test(TrameApp):
+    def __init__(self, server=None):
+        super().__init__(server)
+        self.data_1 = Data(self.server, enable_collaboration=True)
+        self.data_2 = Data(self.server, enable_collaboration=False)
+        self._build_ui()
+
+    def _build_ui(self):
+        with DivLayout(self.server) as self.ui:
+            with self.data_1.provide_as("data_slow"):
+                with self.data_2.provide_as("data_fast"):
+                    html.Div("Collaboration ON: {{ data_slow.value }}")
+                    html.Input(
+                        type="range",
+                        v_model_number="data_slow.value",
+                        min=0,
+                        max=500,
+                        step=1,
+                        style="width: 100%",
+                    )
+                    html.Div("Collaboration OFF (default): {{ data_fast.value }}")
+                    html.Input(
+                        type="range",
+                        v_model_number="data_fast.value",
+                        min=0,
+                        max=200,
+                        step=1,
+                        style="width: 100%",
+                    )
+
+
+def main():
+    app = Test()
+    app.server.start()
+
+
+if __name__ == "__main__":
+    main()

src/trame_dataclass/module/protocol_v2.py

@@ -16,7 +16,6 @@ def compute_definition(trame_dataclass_class):
 class TrameDataclassProtocol(LinkProtocol):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-
         self.class_definitions = {}
         self.next_class_definition_id = 1
 
@@ -77,14 +76,8 @@ def get_state(self, instance_id):
     def update_state(self, msg):
         for dc_id, state in msg.items():
             obj = get_instance(dc_id)
-            encoders = obj.ENCODERS
             if obj is not None:
-                for k, v in state.items():
-                    convert = encoders.get(k)
-                    if convert:
-                        setattr(obj, k, convert.decoder(v))
-                    else:
-                        setattr(obj, k, v)
+                obj.update_from_client_state(state)
 
     def push_delta(self, msg):
         self.publish("trame.dataclass.publish", msg)

src/trame_dataclass/v2.py

@@ -112,10 +112,15 @@ def can_be_decorated(x):
 
 def _save_field(name, src, dst, encoder=None):
     value = getattr(src, name)
+
     if encoder:
-        dst[name] = encoder(value)
-    else:
+        value = encoder(value)
+
+    if name not in dst or dst[name] != value:
         dst[name] = value
+        return True
+
+    return False
 
 
 def _setup_class_fields(owner):
@@ -145,13 +150,14 @@ class TypeValidation(Enum):
 
 
 class StateDataModel:
-    def __init__(self, trame_server=None, **kwargs):
+    def __init__(self, trame_server=None, enable_collaboration=False, **kwargs):
         self.__id = _next_id()
         self.__trame_server = trame_server
 
         # Register all instances
         INSTANCES[self.__id] = self
 
+        self._enable_collaboration = enable_collaboration
         self._server_state = {}
         self._client_state = {}
         self._dirty_set = set()
@@ -326,6 +332,9 @@ def client_state(self):
     def update_from_client_state(self, partial_state):
         encoders = self.ENCODERS
         for k, v in partial_state.items():
+            if not self._enable_collaboration:
+                self._client_state[k] = v
+
             convert = encoders.get(k)
             if convert:
                 setattr(self, k, convert.decoder(v))
@@ -336,7 +345,12 @@ def update_from_client_state(self, partial_state):
     def _id(self):
         return self.__id
 
-    def flush(self, dirty_set: set[str] | None = None):
+    def dirty(self, *keys):
+        """Mark variable dirty and trigger watchers"""
+        self._dirty_set.update(keys)
+        self._on_dirty()
+
+    def flush(self, dirty_set: set[str] | None = None, force_push=False):
         """Flush the data to the client."""
         if self._flush_impl is None:
             return
@@ -349,19 +363,25 @@ def flush(self, dirty_set: set[str] | None = None):
                 self._dirty_set.discard(name)
 
         key_to_send = list(dirty_set & self.CLIENT_NAMES)
+        modified_keys = []
         for name in key_to_send:
             encoder = None
             if name in self.ENCODERS:
                 encoder = self.ENCODERS[name].encoder
 
-            _save_field(name, self, self._client_state, encoder)
+            if _save_field(name, self, self._client_state, encoder):
+                modified_keys.append(name)
+
+        if force_push:
+            modified_keys = list(key_to_send)
 
         # Send data over the network
-        msg = {
-            "id": self._id,
-            "state": {k: self._client_state[k] for k in key_to_send},
-        }
-        self._flush_impl(msg)
+        if modified_keys:
+            msg = {
+                "id": self._id,
+                "state": {k: self._client_state[k] for k in modified_keys},
+            }
+            self._flush_impl(msg)
 
 
 # -----------------------------------------------------------------------------