-

cool-RR · cool-RR · commit dc4ee5e20580 · 2015-12-14T22:16:32.000+02:00
diff --git a/source_py3/python_toolbox/context_management/__init__.py b/source_py3/python_toolbox/context_management/__init__.py
@@ -131,6 +131,5 @@ def do_stuff():
 from .self_hook import SelfHook
 
 from .blank_context_manager import BlankContextManager
-from .reentrant_context_manager import ReentrantContextManager
 from .delegating_context_manager import DelegatingContextManager
-from .functions import nested, idempotentify
+from .functions import nested, as_idempotent, as_reentrant
diff --git a/source_py3/python_toolbox/context_management/functions.py b/source_py3/python_toolbox/context_management/functions.py
@@ -9,6 +9,8 @@
 
 import sys
 
+from python_toolbox import caching
+
 from .context_manager_type import ContextManagerType
 from .context_manager import ContextManager
 
@@ -42,8 +44,9 @@ def nested(*managers):
             # have been raised and caught by an exit method
             raise exc[1].with_traceback(exc[2])
     
-    
-def idempotentify(context_manager):
+
+
+def as_idempotent(context_manager):
     '''
     Wrap a context manager so repeated calls to enter and exit will be ignored.
     
@@ -59,33 +62,84 @@ def idempotentify(context_manager):
     `ExitStack`, but you also possibly want to exit it manually before the
     `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.
+    '''
+    return _IdempotentContextManager(context_manager)
+    
+            
+def as_reentrant(context_manager):
     '''
-    class _IdempotentContextManager:
-        # Not inheriting from `ContextManager` because this class is internal
-        # and not used beyond `idempotentify`, so no need for the extra
-        # baggage.
-        _entered = False
-        _enter_value = None
+    Wrap a context manager to make it reentant.
+    
+    A context manager wrapped with `as_reentrant` could be entered multiple
+    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.
+    '''
+    return _ReentrantContextManager(context_manager)
+    
+
+class _IdempotentContextManager(ContextManager):
+    _entered = False
+    _enter_value = None
+    
+    def __init__(self, wrapped_context_manager):
+        self.__wrapped__ = wrapped_context_manager
         
-        def __init__(self, wrapped_context_manager):
-            self.__wrapped__ = wrapped_context_manager
+    
+    def __enter__(self):
+        if not self._entered:
+            self._enter_value = self.__wrapped__.__enter__()
+            self._entered = True
+        return self._enter_value
             
         
-        def __enter__(self):
-            if not self._entered:
-                self._enter_value = self.__wrapped__.__enter__()
-                self._entered = True
-            return self._enter_value
-                
+    def __exit__(self, exc_type=None, exc_value=None, exc_traceback=None):
+        if self._entered:
+            exit_value = self.__wrapped__.__exit__(exc_type, exc_value,
+                                                   exc_traceback)
+            self._entered = False
+            self._enter_value = None
+            return exit_value
+
+class _ReentrantContextManager(ContextManager):
+
+    def __init__(self, wrapped_context_manager):
+        self.__wrapped__ = wrapped_context_manager
+        
+    depth = caching.CachedProperty(
+        0,
+        doc='''
+            The number of nested suites that entered this context manager.
             
-        def __exit__(self, exc_type=None, exc_value=None,
-                     exc_traceback=None):
-            if self._entered:
-                exit_value = self.__wrapped__.__exit__(exc_type, exc_value,
-                                                       exc_traceback)
-                self._entered = False
-                return exit_value
-                
-    return _IdempotentContextManager(context_manager)
+            When the context manager is completely unused, it's `0`. When
+            it's first used, it becomes `1`. When its entered again, it
+            becomes `2`. If it is then exited, it returns to `1`, etc.
+            '''
+    )
+
+    _enter_value = None
+    
+    def __enter__(self):
+        if self.depth == 0:
+            self._enter_value = self.__wrapped__.__enter__()
+        self.depth += 1
+        return self._enter_value
+    
     
-            
+    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)
+            self._enter_value = None
+        else:
+            exit_value = None
+        self.depth -= 1
+        return exit_value
+
+                
+
diff --git a/source_py3/python_toolbox/context_management/reentrant_context_manager.py b/source_py3/python_toolbox/context_management/reentrant_context_manager.py
diff --git a/source_py3/python_toolbox/emitting/emitter_system/emitter_system.py b/source_py3/python_toolbox/emitting/emitter_system/emitter_system.py
@@ -12,7 +12,6 @@
 
 from python_toolbox import freezing
 from python_toolbox import cute_iter_tools
-from python_toolbox.context_management import ReentrantContextManager
 
 from .emitter import Emitter
 
diff --git a/source_py3/python_toolbox/freezing/delegatee_context_manager.py b/source_py3/python_toolbox/freezing/delegatee_context_manager.py
@@ -4,7 +4,7 @@
 from python_toolbox import context_management
 
 
-class DelegateeContextManager(context_management.ReentrantContextManager):
+class DelegateeContextManager(context_management.ContextManager):
     '''Inner context manager used internally by `Freezer`.'''
     
     def __init__(self, freezer):
diff --git a/source_py3/python_toolbox/freezing/freezer.py b/source_py3/python_toolbox/freezing/freezer.py
@@ -31,11 +31,15 @@ class Freezer(context_management.DelegatingContextManager):
     in the logic of the parent object.
     '''
     
-    delegatee_context_manager = caching.CachedProperty(DelegateeContextManager)
+    delegatee_context_manager = caching.CachedProperty(
+        lambda self: context_management.as_reentrant(DelegateeContextManager)
+    )
     '''The context manager which implements our `__enter__` and `__exit__`.'''
     
     
-    frozen = misc_tools.ProxyProperty('.delegatee_context_manager.depth')
+    frozen = misc_tools.ProxyProperty(
+        '.delegatee_context_manager.__wrapped__.depth'
+    )
     '''
     An integer specifying the freezer's level of frozenness.
     
diff --git a/source_py3/test_python_toolbox/test_caching/test_cached_property.py b/source_py3/test_python_toolbox/test_caching/test_cached_property.py
@@ -9,6 +9,9 @@
 from python_toolbox import misc_tools
 
 from python_toolbox.caching import cache, CachedType, CachedProperty
+from python_toolbox.context_management import as_idempotent, ContextManager
+
+get_depth_counting_context_manager = lambda: as_reentrant(ContextManager())
 
 
 @misc_tools.set_attributes(i=0)
@@ -180,7 +183,7 @@ def test_decorating():
     
     class A:
         reentrant_context_manager = CachedProperty(
-            lambda self: context_management.ReentrantContextManager()
+            lambda self: get_depth_counting_context_manager()
         )
         
         @reentrant_context_manager
diff --git a/source_py3/test_python_toolbox/test_context_management/test_idempotentify.py b/source_py3/test_python_toolbox/test_context_management/test_idempotentify.py
@@ -3,7 +3,7 @@
 
 import queue as queue_module
 
-from python_toolbox.context_management import idempotentify, ContextManager
+from python_toolbox.context_management import as_idempotent, ContextManager
 from python_toolbox import cute_testing
 
 
@@ -20,7 +20,7 @@ def manage_context(self):
             
             
 
-def test_idempotentify():
+def test_as_idempotent():
     some_context_manager = SomeContextManager()
     assert some_context_manager.x == 0
     with some_context_manager as enter_result:
@@ -58,7 +58,7 @@ def test_idempotentify():
     
         
     another_context_manager = SomeContextManager()
-    idempotent_context_manager = idempotentify(another_context_manager)
+    idempotent_context_manager = as_idempotent(another_context_manager)
     
     assert another_context_manager is idempotent_context_manager.__wrapped__
 
diff --git a/source_py3/test_python_toolbox/test_context_management/test_nested.py b/source_py3/test_python_toolbox/test_context_management/test_nested.py
@@ -6,16 +6,18 @@
 from python_toolbox import freezing
 from python_toolbox import cute_testing
 
-from python_toolbox.context_management import ReentrantContextManager, nested
+from python_toolbox.context_management import (ContextManager, nested,
+                                               as_reentrant)
 
+get_depth_counting_context_manager = lambda: as_reentrant(ContextManager())
 
 
 def test_nested():
     '''Test the basic workings of `nested`.'''
     
-    a = ReentrantContextManager()
-    b = ReentrantContextManager()
-    c = ReentrantContextManager()
+    a = get_depth_counting_context_manager()
+    b = get_depth_counting_context_manager()
+    c = get_depth_counting_context_manager()
     
     with nested(a):
         assert (a.depth, b.depth, c.depth) == (1, 0, 0)
diff --git a/source_py3/test_python_toolbox/test_context_management/test_reentrant_context_manager.py b/source_py3/test_python_toolbox/test_context_management/test_reentrant_context_manager.py
