dynassign: make _DynLiveView a singleton

Technologicat · Technologicat · commit 1a0f0f5078ab · 2020-01-13T00:06:28.000+02:00
This lets us get rid of the thread-local observer registry, as well as the
destructor of _DynLiveView, since there is now always exactly one observer
monitoring _EnvBlock enter/exit events.

Concurrent iteration of the singleton's items() has been tested to work
correctly.

Removing the destructor improves PyPy compatibility, since in PyPy __del__
methods may be called at an arbitrary time later (at next garbage collection
time; no reference counting in PyPy's GC), if at all. Also, __del__ methods
are not very pythonic. Good riddance!

This also gets rid of a mysterious bug involving the REPL server (see comment
in the deleted destructor code).
diff --git a/unpythonic/dynassign.py b/unpythonic/dynassign.py
@@ -27,47 +27,25 @@ def _getstack():
             _L._stack = _mainthread_stack.copy()
     return _L._stack
 
-def _getobservers():
-    if not hasattr(_L, "_observers"):
-        _L._observers = {}
-    return _L._observers
-
 class _EnvBlock(object):
     def __init__(self, bindings):
         self.bindings = bindings
     def __enter__(self):
         if self.bindings:  # optimization, skip pushing an empty scope
             _getstack().append(self.bindings)
-            for o in _getobservers().values():
-                o._refresh()
+            _DynLiveView._refresh()
     def __exit__(self, t, v, tb):
         if self.bindings:
             _getstack().pop()
-            for o in _getobservers().values():
-                o._refresh()
+            _DynLiveView._refresh()
 
 class _DynLiveView(ChainMap):
     def __init__(self):
         super().__init__(self)
         self._refresh()
-        _getobservers()[id(self)] = self
-    def __del__(self):
-        # No idea how, but our REPL server can trigger a KeyError here
-        # if the user views `help()`, which causes the client to get stuck.
-        # Then pressing `q` in the server console to quit the help, and then
-        # asking the REPL client (which is now responsive again) to disconnect
-        # (Ctrl+D), triggers the `KeyError` when the server cleans up the
-        # disconnected session.
-        #
-        # Anyway, if `id(self)` is not in the current thread's observers,
-        # we don't need to do anything here, so the Right Thing to do is
-        # to absorb `KeyError` if it occurs.
-        try:
-            del _getobservers()[id(self)]
-        except KeyError:
-            pass
     def _refresh(self):
         self.maps = list(reversed(_getstack())) + [_global_dynvars]
+_DynLiveView = _DynLiveView()  # singleton
 
 class _Env(object):
     """This module exports a singleton, ``dyn``, which provides dynamic assignment
@@ -211,7 +189,7 @@ def asdict(self):
         When new dynamic scopes begin or old ones exit, its ``.maps`` attribute
         is automatically updated to reflect the changes.
         """
-        return _DynLiveView()
+        return _DynLiveView
 
     def __iter__(self):
         return iter(self.asdict())
diff --git a/unpythonic/test/test_dynassign.py b/unpythonic/test/test_dynassign.py
@@ -130,6 +130,13 @@ def noimplicits(kvs):
         assert noimplicits(items) == (("a", 1), ("b", 2),
                                       ("im_always_there", True))
 
+    # the view is a singleton, so let's test it supports concurrent iteration correctly.
+    view = dyn.asdict()
+    i1 = iter(view.items())
+    i2 = iter(view.items())
+    for a, b in zip(i1, i2):
+        assert a == b
+
     print("All tests PASSED")
 
 if __name__ == '__main__':
