WIP consolidating logic for property lock.

Author: jasongrout

python/ipywidgets/ipywidgets/widgets/widget.py

@@ -512,34 +512,47 @@ def send_state(self, key=None):
             A single property's name or iterable of property names to sync with the front-end.
         """
         state = self.get_state(key=key)
-        if len(state) > 0:
-            if JUPYTER_WIDGETS_ECHO:
-                echo_state = {}
-                if self._updated_attrs_from_frontend:
-                    for attr in self._updated_attrs_from_frontend:
-                        echo_state[attr] = state[attr]
-                        del state[attr]
-                    self._updated_attrs_from_frontend = None
-                state, buffer_paths, buffers = _remove_buffers(state)
-                echo_state, echo_buffer_paths, echo_buffers = _remove_buffers(echo_state)
-                msg = {'method': 'update', 'state': state, 'buffer_paths': buffer_paths}
-                if echo_state or echo_buffer_paths:
-                    msg['echo_state'] = echo_state
-                    msg['echo_buffer_paths'] = echo_buffer_paths
-                    buffers += echo_buffers
-                self._send(msg, buffers=buffers)
-                return
-
-            # TODO: _property_lock is our understanding of what the frontend thinks values are
-            # TODO: it is based on what we've sent the frontend
-            if self._property_lock:  # we need to keep this dict up to date with the front-end values
-                for name, value in state.items():
-                    if name in self._property_lock:
-                        self._property_lock[name] = value
-            state, buffer_paths, buffers = _remove_buffers(state)
-            msg = {'method': 'update', 'state': state, 'buffer_paths': buffer_paths}
-            self._send(msg, buffers=buffers)
+        if len(state) == 0:
+            return
 
+        # For any values that are currently locked (i.e., we are not echoing,
+        # and we are currently processing an update for), we need to update our
+        # notion of what the frontend value is.
+
+        # TODO: does this handle the case where we get an update from the
+        # frontend, in the middle of this we update the value *and send it*, and
+        # then at the end we have to evaluate whether to send an echo message.
+        # We need to send an echo message at some point so the originator can unblock
+        # other echo messages, and we don't want to send the same data twice. So probably
+        # the first time we send an update for an attribute back, we need to send it as an
+        # echo, and record that we've already sent it. So perhaps we just need to keep
+        # track of what echos we need to send, and we send at the end whatever echos still
+        # need to be sent.
+
+        # Sending echos at the end may send updates out of order, i.e., we may send
+        # some updates in the middle, then send echos at the end. perhaps we should immediately
+        # send echos just as we start processing the message?
+        if self._property_lock:
+            for name, value in state.items():
+                if name in self._property_lock:
+                    self._property_lock[name] = value
+
+
+        echo_state = {}
+        if self._updated_attrs_from_frontend:
+            for attr in self._updated_attrs_from_frontend:
+                echo_state[attr] = state[attr]
+                del state[attr]
+            self._updated_attrs_from_frontend = None
+        state, buffer_paths, buffers = _remove_buffers(state)
+        echo_state, echo_buffer_paths, echo_buffers = _remove_buffers(echo_state)
+        msg = {'method': 'update', 'state': state, 'buffer_paths': buffer_paths}
+        if echo_state or echo_buffer_paths:
+            msg['echo_state'] = echo_state
+            msg['echo_buffer_paths'] = echo_buffer_paths
+            buffers += echo_buffers
+        self._send(msg, buffers=buffers)
+        return
 
     def get_state(self, key=None, drop_defaults=False):
         """Gets the widget state, or a piece of it.