-

cool-RR · cool-RR · commit abf3bb6d9de4 · 2015-12-14T22:22:36.000+02:00
diff --git a/source_py3/python_toolbox/context_management/__init__.py b/source_py3/python_toolbox/context_management/__init__.py
@@ -108,10 +108,8 @@ def do_stuff():
 your generator functions with `ContextManagerType`) to enjoy all these
 benefits.
 
-
-This package also defines a bunch of helpful context manager classes on top of
-`ContextManager`: Those are `BlankContextManager`, `ReentrantContextManager`
-and `DelegatingContextManager`. See these classes' docstrings for more info.
+This package also defines a bunch of helpful classes and modules related to
+context managers. See their docstrings for more info.
 '''
 
 # todo: review the few external tests that I'm skipping.
diff --git a/source_py3/python_toolbox/context_management/functions.py b/source_py3/python_toolbox/context_management/functions.py
@@ -63,8 +63,8 @@ def as_idempotent(context_manager):
     `ExitStack` closes. This way you don't risk an exception by having the
     context manager exit twice.
 
-    Note: The value returned by `reentrant_enter` will be returned by all the
-    no-op `__enter__` actions contained in the outermost suite.
+    Note: The first value returned by `__enter__` will be returned by all the
+    subsequent no-op `__enter__` calls.
     '''
     return _IdempotentContextManager(context_manager)
     
@@ -77,8 +77,8 @@ def as_reentrant(context_manager):
     times, and only after it's been exited the same number of times that it has
     been entered will the original `__exit__` method be called.
     
-    Note: The value returned by `reentrant_enter` will be returned by all the
-    no-op `__enter__` actions contained in the outermost suite.
+    Note: The first value returned by `__enter__` will be returned by all the
+    subsequent no-op `__enter__` calls.
     '''
     return _ReentrantContextManager(context_manager)
     
@@ -134,7 +134,9 @@ def __enter__(self):
     def __exit__(self, exc_type=None, exc_value=None, exc_traceback=None):
         assert self.depth >= 1
         if self.depth == 1:
-            exit_value = self.__exit__(exc_type, exc_value, exc_traceback)
+            exit_value = self.__wrapped__.__exit__(
+                exc_type, exc_value, exc_traceback
+            )
             self._enter_value = None
         else:
             exit_value = None
diff --git a/source_py3/python_toolbox/wx_tools/widgets/hue_selection_dialog/textual.py b/source_py3/python_toolbox/wx_tools/widgets/hue_selection_dialog/textual.py
@@ -14,8 +14,6 @@
 from python_toolbox import freezing
 from python_toolbox import wx_tools
 from python_toolbox.wx_tools.widgets.cute_panel import CutePanel
-from python_toolbox.context_management import ReentrantContextManager
-
 
 def ratio_to_round_degrees(ratio):
     return int(ratio * 360)
@@ -25,18 +23,6 @@ def degrees_to_ratio(degrees):
     return degrees / 360
 
 
-#class ValueFreezer(ReentrantContextManager):
-    #'''
-    #Freezer for not changing the `Textual`'s text value.
-
-    #Used as a context manager. Anything that happens inside the `with` suite
-    #will not cause the `Textual` to update its text value.
-    
-    #This is useful because when the `Textual`'s value changes, some platforms
-    #automatically select all the text in the `Textual`, which is really
-    #annoying if you're just typing in it.
-    #'''
-
 
 class Textual(CutePanel):
     '''Display (and allow modifying) the hue as a number 0-359.'''
diff --git a/source_py3/test_python_toolbox/test_context_management/test_as_idempotent.py b/source_py3/test_python_toolbox/test_context_management/test_as_idempotent.py
diff --git a/source_py3/test_python_toolbox/test_context_management/test_as_reentrant.py b/source_py3/test_python_toolbox/test_context_management/test_as_reentrant.py
@@ -78,19 +78,19 @@ def __exit__(self, exc_type, exc_value, exc_traceback):
             
             
 def test_exception_swallowing():
-    class SwallowingReentrantContextManager(ReentrantContextManager):
+    class SwallowingContextManager(ContextManager):
         def __init__(self):
             self.times_entered = 0
             self.times_exited = 0
-        def reentrant_enter(self):
+        def __enter__(self):
             self.times_entered += 1
             return self
-        def reentrant_exit(self, exc_type, exc_value, exc_traceback):
+        def __exit__(self, exc_type, exc_value, exc_traceback):
             self.times_exited += 1
             if isinstance(exc_value, MyException):
                 return True
             
-    swallowing_rcm = SwallowingReentrantContextManager()
+    swallowing_rcm = as_reentrant(SwallowingContextManager())
     
     my_set = set()
     
@@ -118,34 +118,35 @@ def test_order_of_depth_modification():
      
     depth_log = queue_module.Queue()
     
-    class JohnnyReentrantContextManager(ReentrantContextManager):
-        def reentrant_enter(self):
+    class JohnnyContextManager(ContextManager):
+        def __enter__(self):
             depth_log.put(self.depth)
             return self
-        def reentrant_exit(self, exc_type, exc_value, exc_traceback):
+        def __exit__(self, exc_type, exc_value, exc_traceback):
             depth_log.put(self.depth)
         
-    johnny_reentrant_context_manager = JohnnyReentrantContextManager()
+    johnny_reentrant_context_manager = as_reentrant(JohnnyContextManager())
     assert johnny_reentrant_context_manager.depth == 0
     with johnny_reentrant_context_manager:
         assert johnny_reentrant_context_manager.depth == 1
         
-        # `reentrant_enter` saw a depth of 0, because the depth increment
-        # happens *after* `reentrant_enter` is called:
+        # `.__wrapped__.__enter__` saw a depth of 0, because the depth
+        # increment happens *after* `.__wrapped__.__enter__` is called:
         assert depth_log.get(block=False) == 0
         
         with johnny_reentrant_context_manager:
             
             assert johnny_reentrant_context_manager.depth == 2
             assert depth_log.qsize() == 0 # We're in a depth greater than 1,
-                                          # so `reentrant_enter` wasn't even
-                                          # called.
+                                          # so `.__wrapped__.__enter__` wasn't 
+                                          # even called.
                                           
         assert johnny_reentrant_context_manager.depth == 1
         
         assert depth_log.qsize() == 0 # We came out of a depth greater than 1,
-                                      # so `reentrant_exit` wasn't even called.
+                                      # so `.__wrapped__.__enter__` wasn't even
+                                      # called.
                                       
-    # `reentrant_exit` saw a depth of 1, because the depth decrement happens
-    # *after* `reentrant_exit` is called:
+    # `.__wrapped__.__enter__` saw a depth of 1, because the depth decrement
+    # happens *after* `.__wrapped__.__enter__` is called:
     assert depth_log.get(block=False) == 1
