Add ThreadLocalBox and Shim.

Technologicat · Technologicat · commit 1bb83f8e0ede · 2019-12-21T00:48:30.000+02:00
ThreadLocalBox is like box, but the contents are thread-local.

Shim holds a box (or a ThreadLocalBox), and redirects attribute accesses on the
shim to whatever object happens to currently be in the box. (E.g. the combo with
ThreadLocalBox can be used to redirect stdin/stdout only in particular threads.)
diff --git a/unpythonic/collections.py b/unpythonic/collections.py
@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 """Additional containers and container utilities."""
 
-__all__ = ["box", "unbox", "frozendict", "roview", "view", "ShadowedSequence",
+__all__ = ["box", "ThreadLocalBox", "unbox", "Shim",
+           "frozendict", "roview", "view", "ShadowedSequence",
            "mogrify",
            "get_abcs", "in_slice", "index_in_slice",
            "SequenceView", "MutableSequenceView"]  # ABCs
@@ -16,6 +17,7 @@
                             MappingView
 from inspect import isclass
 from operator import lt, le, ge, gt
+import threading
 
 from .llist import cons
 from .misc import getattrrec
@@ -201,7 +203,6 @@ def __eq__(self, other):
     def set(self, x):
         """Store a new value in the box, replacing the old one.
 
-        Syntactic sugar for assigning to the attribute `.x`.
         As a convenience, returns the new value.
 
         Since a function call is an expression, you can use this form
@@ -219,6 +220,39 @@ def __lshift__(self, x):
         for a `box`, so we just return the new value.)
         """
         return self.set(x)
+    def get(self):
+        """Return the value currently in the box.
+
+        The syntactic sugar for `b.get()` is `unbox(b)`.
+        """
+        return self.x
+
+# We re-implement instead of making `box` use an `env` as a place
+# so that the thread-locality feature is pay-as-you-go (no loss in
+# performance for the regular, non-thread-local `box`.)
+class ThreadLocalBox(box):
+    """Like box, but the store is thread-local."""
+    def __init__(self, x=None):
+        self.storage = threading.local()
+        self.storage.x = x
+    def __repr__(self):
+        """**WARNING**: the repr shows only the content seen by the current thread."""
+        return "ThreadLocalBox({})".format(repr(self.storage.x))
+    def __contains__(self, x):
+        return self.storage.x == x
+    def __iter__(self):
+        return (x for x in (self.storage.x,))
+    def __len(self):
+        return 1
+    def __eq__(self, other):
+        return other == self.storage.x
+    def set(self, x):
+        self.storage.x = x
+        return x
+    def __lshift__(self, x):
+        return self.set(x)
+    def get(self):
+        return self.storage.x
 
 def unbox(b):
     """Return the value from inside the box b.
@@ -230,7 +264,32 @@ def unbox(b):
     """
     if not isinstance(b, box):
         raise TypeError("Expected box, got {} with value '{}'".format(type(b), b))
-    return b.x
+    return b.get()
+
+class Shim:
+    """Attribute access redirector.
+
+    Hold a target object inside a box. When an attribute of this object
+    is accessed (whether to get or set it), redirect that attribute
+    access to the target currently inside the box.
+
+    The point is that the target may be switched at any time, simply by sending
+    a new value into the box instance you gave to the `Shim` constructor.
+
+    Another use case is to combo with `ThreadLocalBox`, e.g. to redirect
+    stdin/stdout only when used from some specific threads.
+    """
+    def __init__(self, thebox):
+        """thebox: a `box` instance that will hold the target."""
+        self._box = thebox
+    def __getattr__(self, k):
+        thing = unbox(self._box)
+        return getattr(thing, k)
+    def __setattr__(self, k, v):
+        if k == "_box":
+            return super().__setattr__(k, v)
+        thing = unbox(self._box)
+        return setattr(thing, k, v)
 
 _the_empty_frozendict = None
 class frozendict:
diff --git a/unpythonic/test/test_collections.py b/unpythonic/test/test_collections.py
@@ -2,8 +2,9 @@
 
 from collections.abc import Mapping, MutableMapping, Hashable, Container, Iterable, Sized
 from pickle import dumps, loads
+import threading
 
-from ..collections import box, unbox, frozendict, view, roview, ShadowedSequence, mogrify
+from ..collections import box, ThreadLocalBox, Shim, unbox, frozendict, view, roview, ShadowedSequence, mogrify
 
 def test():
     # box: mutable single-item container à la Racket
@@ -65,6 +66,41 @@ def f(b):
     b2 = loads(dumps(b1))  # pickling
     assert b2 == b1
 
+    # ThreadLocalBox: like box, but with thread-local contents
+    tlb = ThreadLocalBox(42)
+    assert unbox(tlb) == 42
+    def test_threadlocalbox_worker():
+        tlb << 17
+        assert unbox(tlb) == 17
+    t = threading.Thread(target=test_threadlocalbox_worker)
+    t.start()
+    t.join()
+    assert unbox(tlb) == 42  # In the main thread, this box still has the original value.
+
+    # Shim: redirect attribute accesses.
+    #
+    # The shim holds a box. Attribute accesses on the shim are redirected
+    # to whatever object currently happens to be inside the box.
+    class TestTarget:
+        def __init__(self, x):
+            self.x = x
+        def getme(self):
+            return self.x
+    b5 = box(TestTarget(21))
+    s = Shim(b5)  # This is modular so we could use a ThreadLocalBox just as well.
+    assert hasattr(s, "x")
+    assert hasattr(s, "getme")
+    assert s.x == 21
+    assert s.getme() == 21
+    s.y = "hi from injected attribute"  # We can also add or rebind attributes through the shim.
+    assert unbox(b5).y == "hi from injected attribute"
+    s.y = "hi again"
+    assert unbox(b5).y == "hi again"
+    b5 << TestTarget(42)  # After we send a different object into the box held by the shim...
+    assert s.x == 42      # ...the shim accesses the new object.
+    assert s.getme() == 42
+    assert not hasattr(s, "y")  # The new TestTarget instance doesn't have "y".
+
     # frozendict: like frozenset, but for dictionaries
     d3 = frozendict({'a': 1, 'b': 2})
     assert d3['a'] == 1
