cdxcore 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

tests/test_jcpool.py

@@ -1,4 +1,3 @@
-
 # -*- coding: utf-8 -*-
 """
 Created on Tue Apr 14 21:24:52 2020
@@ -11,7 +10,6 @@ def import_local():
     """
     In order to be able to run our tests manually from the 'tests' directory
     we force import from the local package.
-    We also force reloading all modules to make sure we are not running old code.
     """
     me = "cdxcore"
     import os
@@ -22,26 +20,18 @@ def import_local():
     assert cwd[-5:] == "tests",("Expected current working directory to be in a 'tests' directory", cwd[-5:], "from", cwd)
     assert cwd[-6] in ['/', '\\'],("Expected current working directory 'tests' to be lead by a '\\' or '/'", cwd[-6:], "from", cwd)
     sys.path.insert( 0, cwd[:-6] )
-
-    # reload modules
-    import importlib as imp
-    modules = sys.modules.copy()
-    for name, mdata in modules.items():
-        if name[:len(me)] == me:
-            imp.reload(mdata)
-            print("Reloaded", name)
-#import_local()
+import_local()
 
 from cdxcore.jcpool import JCPool, Context
 import numpy as np
 
 class Test(unittest.TestCase):
 
-    def test_pool(self):
+    def test_mp(self):
         
         self.maxDiff = None
         
-        pool    = JCPool(2)
+        pool    = JCPool(2, threading=False)
         
         class Channel(object):
             """ utility to collect all traced messages """
@@ -79,7 +69,83 @@ class Test(unittest.TestCase):
         verbose_main.write("Analysis done")
 
         l = sorted( channel.messages )
-        self.assertEqual( str(l), r"['00: 01:   Returned BTC -0.38, -0.42\n', '00: 01:   Returned GLD -0.47, -0.42\n', '00: 01:   Returned SPY -0.42, -0.41\n', '00: 02:     Result for BTC: -0.38, -0.42\n', '00: 02:     Result for GLD: -0.47, -0.42\n', '00: 02:     Result for SPY: -0.42, -0.41\n', '00: Analysis done\n', '00: Launching analysis\n']")
+        self.assertEqual( str(l), r"['00: Analysis done\n', '00: Launching analysis\n', '01:   Returned BTC -0.38, -0.42\n', '01:   Returned GLD -0.47, -0.42\n', '01:   Returned SPY -0.42, -0.41\n', '02:     Result for BTC: -0.38, -0.42\n', '02:     Result for GLD: -0.47, -0.42\n', '02:     Result for SPY: -0.42, -0.41\n']")
+
+        # dict mode
+        channel      = Channel()
+        verbose_main = Context("all", channel=channel)
+        
+        verbose_main.write("Launching analysis")
+        with pool.context( verbose_main ) as verbose:
+            l = pool.parallel_to_dict(
+                        { ticker: pool.delayed(f)( ticker=ticker, tdata=tdata, verbose=verbose(2) )
+                          for ticker, tdata in tickerdata.items() } )
+        verbose_main.write("Analysis done")
+        self.assertEqual( type(l), dict )
+
+        l = sorted( channel.messages )
+        self.assertEqual( str(l), r"['00: Analysis done\n', '00: Launching analysis\n', '02:     Result for BTC: -0.38, -0.42\n', '02:     Result for GLD: -0.47, -0.42\n', '02:     Result for SPY: -0.42, -0.41\n']")
+
+        # list mode            
+        channel      = Channel()
+        verbose_main = Context("all", channel=channel)
+        
+        verbose_main.write("Launching analysis")
+        with pool.context( verbose_main ) as verbose:
+            l = pool.parallel_to_list(
+                        pool.delayed(f)( ticker=ticker, tdata=tdata, verbose=verbose(2) )
+                        for ticker, tdata in tickerdata.items() )
+        verbose_main.write("Analysis done")
+        self.assertEqual( type(l), list )
+
+        l = sorted( channel.messages )
+        self.assertEqual( str(l), r"['00: Analysis done\n', '00: Launching analysis\n', '02:     Result for BTC: -0.38, -0.42\n', '02:     Result for GLD: -0.47, -0.42\n', '02:     Result for SPY: -0.42, -0.41\n']")
+
+    def test_mt(self):
+        
+        self.maxDiff = None
+        
+        pool    = JCPool(2, threading=True)
+        
+        class Channel(object):
+            """ utility to collect all traced messages """
+            def __init__(self):
+                self.messages = []
+            def __call__(self, msg, flush):
+                self.messages.append( msg )
+        
+        def f( ticker, tdata, verbose : Context ):
+            # some made up results
+            q  = np.quantile( tdata, 0.35, axis=0 )
+            tx = q[0]
+            ty = q[1]
+            # not in a unittest --> time.sleep( np.exp(tdata[0,0]) )
+            verbose.write(f"Result for {ticker}: {tx:.2f}, {ty:.2f}")
+            return tx, ty
+        
+        np.random.seed(1231)
+        tickerdata =\
+         { 'SPY': np.random.normal(size=(1000,2)),
+           'GLD': np.random.normal(size=(1000,2)), 
+           'BTC': np.random.normal(size=(1000,2))
+         } 
+
+        # iterator mode        
+        channel      = Channel()
+        verbose_main = Context("all", channel=channel)
+        
+        verbose_main.write("Launching analysis")
+        with pool.context( verbose_main ) as verbose:
+            for ticker, tx, ty in pool.parallel(
+                        { ticker: pool.delayed(f)( ticker=ticker, tdata=tdata, verbose=verbose(2) )
+                        for ticker, tdata in tickerdata.items() } ):
+                verbose.report(1,f"Returned {ticker} {tx:.2f}, {ty:.2f}")
+        verbose_main.write("Analysis done")
+
+        l = sorted( channel.messages )
+        self.assertEqual( str(l), r"['00: Analysis done\n', '00: Launching analysis\n', '01:   Returned BTC -0.38, -0.42\n', '01:   Returned GLD -0.47, -0.42\n', '01:   Returned SPY -0.42, -0.41\n', '02:     Result for BTC: -0.38, -0.42\n', '02:     Result for GLD: -0.47, -0.42\n', '02:     Result for SPY: -0.42, -0.41\n']")
+
+
 
         # dict mode
         channel      = Channel()
@@ -94,7 +160,7 @@ class Test(unittest.TestCase):
         self.assertEqual( type(l), dict )
 
         l = sorted( channel.messages )
-        self.assertEqual( str(l), r"['00: 02:     Result for BTC: -0.38, -0.42\n', '00: 02:     Result for GLD: -0.47, -0.42\n', '00: 02:     Result for SPY: -0.42, -0.41\n', '00: Analysis done\n', '00: Launching analysis\n']")
+        self.assertEqual( str(l), r"['00: Analysis done\n', '00: Launching analysis\n', '02:     Result for BTC: -0.38, -0.42\n', '02:     Result for GLD: -0.47, -0.42\n', '02:     Result for SPY: -0.42, -0.41\n']")
 
         # list mode            
         channel      = Channel()
@@ -109,8 +175,8 @@ class Test(unittest.TestCase):
         self.assertEqual( type(l), list )
 
         l = sorted( channel.messages )
-        self.assertEqual( str(l), r"['00: 02:     Result for BTC: -0.38, -0.42\n', '00: 02:     Result for GLD: -0.47, -0.42\n', '00: 02:     Result for SPY: -0.42, -0.41\n', '00: Analysis done\n', '00: Launching analysis\n']")
-            
+        self.assertEqual( str(l), r"['00: Analysis done\n', '00: Launching analysis\n', '02:     Result for BTC: -0.38, -0.42\n', '02:     Result for GLD: -0.47, -0.42\n', '02:     Result for SPY: -0.42, -0.41\n']")
+                        
 if __name__ == '__main__':
     unittest.main()
 

tests/test_pretty.py

@@ -18,7 +18,6 @@ def import_local():
     """
     In order to be able to run our tests manually from the 'tests' directory
     we force import from the local package.
-    We also force reloading all modules to make sure we are not running old code.
     """
     me = "cdxcore"
     import os
@@ -29,15 +28,7 @@ def import_local():
     assert cwd[-5:] == "tests",("Expected current working directory to be in a 'tests' directory", cwd[-5:], "from", cwd)
     assert cwd[-6] in ['/', '\\'],("Expected current working directory 'tests' to be lead by a '\\' or '/'", cwd[-6:], "from", cwd)
     sys.path.insert( 0, cwd[:-6] )
-
-    # reload modules
-    import importlib as imp
-    modules = sys.modules.copy()
-    for name, mdata in modules.items():
-        if name[:len(me)] == me:
-            imp.reload(mdata)
-            print("Reloaded", name)
-#import_local()
+import_local()
 
 from cdxcore.pretty import PrettyObject, Sequence
 
@@ -47,8 +38,7 @@ class A1(PrettyObject):
 class A2(PrettyObject):
     def __init__(self, x): # mandatory argument
         self.x=x
-
-
+        
 class Test(unittest.TestCase):
     
 

tests/test_subdir.py

@@ -10,7 +10,6 @@ def import_local():
     """
     In order to be able to run our tests manually from the 'tests' directory
     we force import from the local package.
-    We also force reloading all modules to make sure we are not running old code.
     """
     me = "cdxcore"
     import os
@@ -21,14 +20,7 @@ def import_local():
     assert cwd[-5:] == "tests",("Expected current working directory to be in a 'tests' directory", cwd[-5:], "from", cwd)
     assert cwd[-6] in ['/', '\\'],("Expected current working directory 'tests' to be lead by a '\\' or '/'", cwd[-6:], "from", cwd)
     sys.path.insert( 0, cwd[:-6] )
-
-    # reload modules
-    import importlib as imp
-    modules = sys.modules.copy()
-    for name, mdata in modules.items():
-        if name[:len(me)] == me:
-            imp.reload(mdata)
-#import_local()
+import_local()
     
 """
 Imports

tests/test_uniquehash.py

@@ -14,7 +14,6 @@ def import_local():
     """
     In order to be able to run our tests manually from the 'tests' directory
     we force import from the local package.
-    We also force reloading all modules to make sure we are not running old code.
     """
     me = "cdxcore"
     import os
@@ -25,14 +24,7 @@ def import_local():
     assert cwd[-5:] == "tests",("Expected current working directory to be in a 'tests' directory", cwd[-5:], "from", cwd)
     assert cwd[-6] in ['/', '\\'],("Expected current working directory 'tests' to be lead by a '\\' or '/'", cwd[-6:], "from", cwd)
     sys.path.insert( 0, cwd[:-6] )
-
-    # reload modules
-    import importlib as imp
-    modules = sys.modules.copy()
-    for name, mdata in modules.items():
-        if name[:len(me)] == me:
-            imp.reload(mdata)
-#import_local()
+import_local()
     
 """
 Imports

tests/test_util.py

@@ -13,7 +13,6 @@ def import_local():
     """
     In order to be able to run our tests manually from the 'tests' directory
     we force import from the local package.
-    We also force reloading all modules to make sure we are not running old code.
     """
     me = "cdxcore"
     import os
@@ -24,18 +23,36 @@ def import_local():
     assert cwd[-5:] == "tests",("Expected current working directory to be in a 'tests' directory", cwd[-5:], "from", cwd)
     assert cwd[-6] in ['/', '\\'],("Expected current working directory 'tests' to be lead by a '\\' or '/'", cwd[-6:], "from", cwd)
     sys.path.insert( 0, cwd[:-6] )
+import_local()
 
-    # reload modules
-    import importlib as imp
-    modules = sys.modules.copy()
-    for name, mdata in modules.items():
-        if name[:len(me)] == me:
-            imp.reload(mdata)
-#import_local()
-
-from cdxcore.util import is_function, is_atomic, is_float, is_filename
+from cdxcore.util import is_function, is_atomic, is_float, is_filename, qualified_name
 from cdxcore.util import fmt, fmt_seconds, fmt_list, fmt_dict, fmt_big_number, fmt_digits, fmt_big_byte_number, fmt_datetime, fmt_date, fmt_time, fmt_timedelta, fmt_filename, DEF_FILE_NAME_MAP
 
+class qA(object):
+
+    M = 0
+
+    def __init__(self):
+        self.m = 1
+    
+    def f(self):
+        pass
+    
+    @property
+    def g(self):
+        return 1
+
+    @staticmethod
+    def h():
+        pass
+
+    @classmethod
+    def j(cls):
+        pass
+        
+    def __iter__(self):
+        yield 1
+
 class Test(unittest.TestCase):
 
     def test_fmt(self):
@@ -361,6 +378,79 @@ class Test(unittest.TestCase):
         self.assertFalse( is_float(np.int32(0.1)) )
         self.assertFalse( is_float(np.int64(0.1)) )
         self.assertFalse( is_float(np.complex64(0.1)) )
+
+        # qualified
+
+        class qB(object):
+        
+            M = 0
+        
+            def __init__(self):
+                self.m = 1
+            
+            def f(self):
+                pass
+            
+            @property
+            def g(self):
+                return 1
+        
+            @staticmethod
+            def h():
+                pass
+        
+            @classmethod
+            def j(cls):
+                pass
+                
+            def __iter__(self):
+                yield 1
+                
+        qa = qA()
+        qb = qB()
+        
+        modname = __name__
+
+        self.assertEqual( qualified_name(qualified_name,True), ("qualified_name", "cdxcore.util"))
+        self.assertEqual( qualified_name(is_atomic,True), ("is_atomic", "cdxcore.util"))
+        self.assertEqual( qualified_name(datetime.datetime,True), ("datetime", "datetime"))
+        self.assertEqual( qualified_name(datetime.datetime.date,True), ("datetime.date", "builtins"))
+        self.assertEqual( qualified_name(datetime.datetime.now(),True), ("datetime", "datetime"))
+        self.assertEqual( qualified_name(datetime.datetime.now().date(),True), ("date", "datetime"))
+        
+        self.assertEqual( qualified_name(qA), "qA")
+        self.assertEqual( qualified_name(qA,True), ("qA",modname) )
+        self.assertEqual( qualified_name(qA.M,True), ("int","builtins") )
+        self.assertEqual( qualified_name(qA.f,True), ("qA.f",modname) )
+        self.assertEqual( qualified_name(qA.g,True), ("qA.g",modname) ) # <-- property function
+        self.assertEqual( qualified_name(qA.h,True), ("qA.h",modname) )
+        self.assertEqual( qualified_name(qA.j,True), ("qA.j",modname) )
+        
+        self.assertEqual( qualified_name(qa), "qA")
+        self.assertEqual( qualified_name(qa,True), ("qA",modname) )
+        self.assertEqual( qualified_name(qa.M,True), ("int","builtins") )
+        self.assertEqual( qualified_name(qa.m,True), ("int","builtins") )
+        self.assertEqual( qualified_name(qa.f,True), ("qA.f",modname) )
+        self.assertEqual( qualified_name(qa.g,True), ("int","builtins") )   # <-- property type
+        self.assertEqual( qualified_name(qa.h,True), ("qA.h",modname) )
+        self.assertEqual( qualified_name(qa.j,True), ("qA.j",modname) )
+        
+        self.assertEqual( qualified_name(qB), "Test.test_basics.<locals>.qB")
+        self.assertEqual( qualified_name(qB,True), ("Test.test_basics.<locals>.qB",modname) )
+        self.assertEqual( qualified_name(qB.M,True), ("int","builtins") )
+        self.assertEqual( qualified_name(qB.f,True), ("Test.test_basics.<locals>.qB.f",modname) )
+        self.assertEqual( qualified_name(qB.g,True), ("Test.test_basics.<locals>.qB.g",modname) ) # <-- property function
+        self.assertEqual( qualified_name(qB.h,True), ("Test.test_basics.<locals>.qB.h",modname) )
+        self.assertEqual( qualified_name(qB.j,True), ("Test.test_basics.<locals>.qB.j",modname) )
+        
+        self.assertEqual( qualified_name(qb), "Test.test_basics.<locals>.qB")
+        self.assertEqual( qualified_name(qb,True), ("Test.test_basics.<locals>.qB",modname) )
+        self.assertEqual( qualified_name(qb.M,True), ("int","builtins") )
+        self.assertEqual( qualified_name(qb.m,True), ("int","builtins") )
+        self.assertEqual( qualified_name(qb.f,True), ("Test.test_basics.<locals>.qB.f",modname) )
+        self.assertEqual( qualified_name(qb.g,True), ("int","builtins") )   # <-- property type
+        self.assertEqual( qualified_name(qb.h,True), ("Test.test_basics.<locals>.qB.h",modname) )
+        self.assertEqual( qualified_name(qb.j,True), ("Test.test_basics.<locals>.qB.j",modname) )
         
 if __name__ == '__main__':
     unittest.main()

tests/test_verbose.py

@@ -10,7 +10,6 @@ def import_local():
     """
     In order to be able to run our tests manually from the 'tests' directory
     we force import from the local package.
-    We also force reloading all modules to make sure we are not running old code.
     """
     me = "cdxcore"
     import os
@@ -21,15 +20,7 @@ def import_local():
     assert cwd[-5:] == "tests",("Expected current working directory to be in a 'tests' directory", cwd[-5:], "from", cwd)
     assert cwd[-6] in ['/', '\\'],("Expected current working directory 'tests' to be lead by a '\\' or '/'", cwd[-6:], "from", cwd)
     sys.path.insert( 0, cwd[:-6] )
-
-    # reload modules
-    import importlib as imp
-    modules = sys.modules.copy()
-    for name, mdata in modules.items():
-        if name[:len(me)] == me:
-            imp.reload(mdata)
-            print("Reloaded", name)
-#import_local()
+import_local()
 
 from cdxcore.verbose import Context
 from cdxcore.uniquehash import unique_hash32 as unique_hash

tests/test_version.py

@@ -10,7 +10,6 @@ def import_local():
     """
     In order to be able to run our tests manually from the 'tests' directory
     we force import from the local package.
-    We also force reloading all modules to make sure we are not running old code.
     """
     me = "cdxcore"
     import os
@@ -21,14 +20,7 @@ def import_local():
     assert cwd[-5:] == "tests",("Expected current working directory to be in a 'tests' directory", cwd[-5:], "from", cwd)
     assert cwd[-6] in ['/', '\\'],("Expected current working directory 'tests' to be lead by a '\\' or '/'", cwd[-6:], "from", cwd)
     sys.path.insert( 0, cwd[:-6] )
-
-    # reload modules
-    import importlib as imp
-    modules = sys.modules.copy()
-    for name, mdata in modules.items():
-        if name[:len(me)] == me:
-            imp.reload(mdata)
-#import_local()
+import_local()
     
 """
 Imports

cdxcore-0.1.11.dist-info/RECORD

@@ -1,36 +0,0 @@
-cdxcore/__init__.py,sha256=QkwdykAwr_r64uUVCGkEd6qZ7xPa-uKA44rrlJGMtKI,127
-cdxcore/config.py,sha256=YnIEJVFtMZ5EHlwzaB2JsSkCPhWPvEw9QSpe6mof_V4,98472
-cdxcore/crman.py,sha256=83oKpuzNy98ObpmUeJg2McGRxaLk2AP5lN1yd1F9ueQ,5759
-cdxcore/err.py,sha256=SIJMBXKXYI_hiysv5iSPRy0w_BbxyTDPbNEs56Y94Rk,14541
-cdxcore/jcpool.py,sha256=uQyOBmOz7EPBsXU96J6Zb2Y-YmA2GwfsRYj6NzFEPKc,27335
-cdxcore/pretty.py,sha256=iUpgUCwmI8yb5O-WZFJEk3QvNYcj_GIFHUgZ5lK8F2I,17082
-cdxcore/pretty.py_bak.py,sha256=JgWr5044HzCNGG0wKSAWlWiPRs7-bNzkwiKH0T3n0to,28658
-cdxcore/subdir.py,sha256=NScdtAG-Wrt0D7_FcpO62qzII4bS9ABXFerkILPg4uE,173864
-cdxcore/uniquehash.py,sha256=g-D8pqPIppSdRq5QfdE5aP3paZ-NkXWHfnn-uNB7fmg,50648
-cdxcore/util.py,sha256=0fp0EzeZvnje1Q7SUcgB_JtKpsYgGTfvlHVfq0mE_ug,31930
-cdxcore/verbose.py,sha256=nKNoZQwl3eF1zBf-JZwPC-lL9d_o5mJsDsSUMixTMLw,29882
-cdxcore/version.py,sha256=m30oI2Ortg44dKSim-sIoeh9PioD1FWsSfVEP5rubhk,27173
-cdxcore-0.1.11.dist-info/licenses/LICENSE,sha256=M-cisgK9kb1bqVRJ7vrCxHcMQQfDxdY3c2YFJJWfNQg,1090
-docs/source/conf.py,sha256=Owctibh5XcSpSNcrpOr3ROIDjoklmFVrMhu8cOSe50o,4180
-tests/test_config.py,sha256=0U9vFIKDex0Il-7Vc_C4saAuXoHIsdQ8YhhS8AO7FQI,15950
-tests/test_crman.py,sha256=hek6a-51-i6o5XhDa1vqFjUKYJggJ3pnb0Am0wunhwY,1692
-tests/test_err.py,sha256=VbVmbaB6o49G-n3t7yuJ4M0d9pyUQyJuVDqK-xRrLo8,3458
-tests/test_jcpool.py,sha256=vgKt5wTz1BXt8ruubtE2qINIlqH507IoTC1lpP7nejQ,4733
-tests/test_pretty.py,sha256=5TmF7c1TRDSN-YR5yo04SiLJiW3bZaxpXHJ-4ZEO8hg,11952
-tests/test_subdir.py,sha256=tO-zoOIKQtZEMpQM-tsrisyLRmMH8txCSOzh6jPRhYY,11721
-tests/test_uniquehash.py,sha256=ldoQLT77R7odMAok4Yo3jmiUIH3VPHKoSiSLKbbM_mo,24907
-tests/test_util.py,sha256=DZ6AlPFDNNlkqP5MlM1BUwmBJvEj4WCFqZcdh_Isflw,19955
-tests/test_verbose.py,sha256=7JGCLKHU1HovO6UYSLLcJQxjaZxYJejS1fl8O3Sgk9w,5037
-tests/test_version.py,sha256=eq7bNT0GefbUkwEzo658UUxgBCiR7CDhuIxAmnnI-qQ,4658
-tmp/deferred.py,sha256=TirvzxYXWnZkOWuEMB7qsf6auilfy4VD_zPknYCjrnw,9401
-tmp/dynaplot.py,sha256=kwrH_WccpJcfS7n_gzdAr4QxQobvIZZrrxgdsKLKfj0,48552
-tmp/filelock.py,sha256=HqnHZhSCESaOA3ClrdWPW_GZpyo7c3VRSEofAV-khKM,18137
-tmp/np.py,sha256=2MynhiaTfmx984Gz7TwfZH3t7GCmCAQiyeWzDDCL6_k,47686
-tmp/npio.py,sha256=4Kwp5H4MgKHkOEhu4UJ5CcwpM7Pm8UFkaoL5FvOEFRI,10310
-tmp/sharedarray.py,sha256=JuHuSlxA0evD0a-bEZgTFrfdlVPMgzfQNgfSjr1212w,11484
-up/git_message.py,sha256=EfSH7Pit3ZoCiRqSMwRCUN_QyuwreU4LTIyGSutBlm4,123
-up/pip_modify_setup.py,sha256=Esaml4yA9tFsqxLhk5bWSwvKCURONjQqfyChgFV2TSY,1584
-cdxcore-0.1.11.dist-info/METADATA,sha256=q8JLhUt0fOG-sxNyd_8GJKg-DBhFwjBOVaEpo00bVbE,754
-cdxcore-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cdxcore-0.1.11.dist-info/top_level.txt,sha256=phNSwCyJFe7UP2YMoi8o6ykhotatlIbJHjTp9EHM51k,26
-cdxcore-0.1.11.dist-info/RECORD,,

tmp/deferred.py

@@ -1,220 +0,0 @@
-"""
-deferred
-Deferred action wrapping
-Hans Buehler 2022
-"""
-from .util import fmt_list
-from .logger import Logger
-_log = Logger(__file__)
-
-class Deferred(object):
-    """
-    Defer an action such as function calls, item access, and attribute access to a later stage.
-    This is used in dynaplot:
-
-        fig = figure()                # the DynanicFig returned by figure() is derived from Deferred
-        ax  = fig.add_subplot()       # Deferred call for add_subplot()
-        lns = ax.plot( x, y )[0]      # This is a deferred call: plot() and then [] are iteratively deferred.
-        fig.render()                  # renders the figure and executes first plot() then [0]
-        lns.set_ydata( y2 )           # we can now access the resulting Line2D object via the Deferred wrapper
-        fig.render()                  # update graph
-
-    Typically, a code user would create a class which can defer actions by deriving from this class.
-    For example assume there is a class A which we want to defer.
-
-    class A(object):
-        def __init__(self, x):
-            self.x = x
-        def a_function(self, y):
-            return self.x * y
-        def __getitem__(self, y):
-            return self.x * y
-        def __call__(self, y):
-            return self.x * y
-
-    class DeferredA( Deferred ):
-        def __init__( self ):
-            Deferred.__init__( info = "A" )  # give me a name
-        def create( self, *kargs_A, **kwargs_A ):
-            # deferred creation
-            a = A(*kargs_A,**kwargs_A)
-            self._dereference( a )
-
-    deferred_A = DeferredA()
-    fx = deferred_A.a_function( 1. )         # will defer call to 'a_function'
-    ix = deferred_A[2.]                      # will defer index access
-    cl = deferred_A(3.)                      # will defer __call__
-
-    deferred_A.create( 1, x=2 )             # actually create A
-                                            # This will trigger execution of all deferred actions
-                                            # in order.
-
-    Not that Deferred() works iteratively, e.g. all values returned from a function call, __call__, or __getitem__ are themselves
-    deferred automatically. Deferred() is also able to defer item and attribute assignments.
-
-    See cdxbasics.dynaplot.DynamicFig as an example.
-    """
-
-    TYPE_SELF     = 0
-    TYPE_CALL     = 1
-    TYPE_ITEM     = 2
-    TYPE_SET_ITEM = 4
-    TYPE_ATTR     = 3
-    TYPE_SET_ATTR = 5
-
-    TYPES =  [ TYPE_SELF, TYPE_CALL, TYPE_ITEM, TYPE_SET_ITEM, TYPE_ATTR, TYPE_SET_ATTR ]
-
-    def __init__(self, info : str, *, typ : int = TYPE_SELF, ref = None):
-        """
-        Initialize a deferred action.
-        Typically, a code user would derive from this class and initialize __init__
-        with only the first 'info' argument giving their class a good name for error
-        messages.
-        See cdxbasics.dynaplot.DynamicFig as an example
-
-        Parameters
-        ----------
-            info : str
-                Description of the underlying deferred parent operation/class for error messages.
-            typ : int
-                one of the TYPE_ values describing the type of action to be deferred.
-            ref :
-                argument for the action, e.g.
-                    TYPE_SELF: None
-                    TYPE_CALL: tuple of (argc, argv)
-                    TYPE_ITEM: key for []
-                    TYPE_ATTR: string name of the attribute
-        """
-        _log.verify( typ in Deferred.TYPES, "'type' must be in %s, found %ld", fmt_list(Deferred.TYPES), typ )
-
-        if typ == Deferred.TYPE_CALL:
-            assert isinstance(ref,tuple) and len(ref) == 2, "Internal error: tuple of size 2 expected. Found %s" % str(ref)
-            self._ref = ( list(ref[0]), dict(ref[1]) )
-        elif typ == Deferred.TYPE_ITEM:
-            self._ref = ref
-        elif typ == Deferred.TYPE_SET_ITEM:
-            assert isinstance(ref, tuple) and len(ref) == 2, "Internal error: tuple of size 2 expected. Found %s" % str(ref)
-            self._ref = ref
-        elif typ == Deferred.TYPE_ATTR:
-            self._ref = str(ref)
-        elif typ == Deferred.TYPE_SET_ATTR:
-            assert isinstance(ref, tuple) and len(ref) == 2, "Internal error: tuple of size 2 expected. Found %s" % str(ref)
-            self._ref = ref
-        else:
-            _log.verify( ref is None, "'ref' must be none for TYPE_SELF")
-            self._ref = None
-
-        self._type         = typ
-        self._info         = info
-        self._live         = None
-        self._was_executed = False
-        self._caught       = []
-
-    @property
-    def cdx_deferred_result(self):
-        """ Returns the result of the deferred action """
-        if not self._was_executed: _log.throw( "Deferred action %s has not been executed yet", self._info )
-        return self._live
-    
-    def _dereference(self, owner):
-        """
-        Execute deferred action with 'owner' as the object the action is to be performed upon.
-        If the current type is TYPE_SELF then the result is simply 'owner'
-        """
-        # execute the deferred action
-        if self._was_executed:
-            _log.throw("Deferred action %s has already been executed", self._info )
-
-        if self._type == Deferred.TYPE_CALL:
-            try:
-                live  = owner( *self._ref[0], **self._ref[1] )
-            except Exception as e:
-                _log.error("Error resolving deferred call to '%s': %s; "
-                           "positional arguments: %s; "
-                           "keyword arguments: %s", self._info, e, str(self._ref[0])[:100], str(self._ref[1])[:100])
-                raise e
-
-        elif self._type == Deferred.TYPE_ITEM:
-            try:
-                live  = owner[ self._ref ]
-            except Exception as e:
-                _log.error("Error resolving deferred item access to '%s', trying to access item '%s': %s", self._info, str(self._ref)[:100], e)
-                raise e
-
-        elif self._type == Deferred.TYPE_SET_ITEM:
-            try:
-                owner[ self._ref[0] ] = self._ref[1]
-                live = None
-            except Exception as e:
-                _log.error("Error resolving deferred item assignment for '%s': tried to set item '%s' to '%s': %s", self._info, str(self._ref[0])[:100], str(self._ref[1])[:100], e)
-                raise e
-
-        elif self._type == Deferred.TYPE_ATTR:
-            try:
-                live  = getattr( owner, self._ref )
-            except Exception as e:
-                _log.error("Error resolving deferred attribute access to '%s', trying to read attribute '%s': %s", self._info, str(self._ref)[:100], e)
-                raise e
-
-        elif self._type == Deferred.TYPE_SET_ATTR:
-            try:
-                owner.__setattr__( self._ref[0], self._ref[1] )
-                live = None
-            except Exception as e:
-                _log.error("Error resolving deferred attribute assignment to '%s': tried to set attribute '%s' to '%s': %s", self._info, str(self._ref[0])[:100], str(self._ref[1])[:100], e)
-                raise e
-
-        else:
-            # TYPE_SELF
-            live  = owner
-
-        self._live         = live
-        self._was_executed = True
-
-        # execute all deferred calls for this object
-        for catch in self._caught:
-            catch._dereference( live )
-        self._caught = None
-
-    def __call__(self, *kargs, **kwargs):
-        """ Deferred call () """
-        if self._was_executed:
-            return self.cdx_deferred_result(*kargs, **kwargs)
-        deferred = Deferred( typ=Deferred.TYPE_CALL, ref=(kargs,kwargs), info="%s(%s)" % (self._info, "..." if len(kwargs)+len(kargs)>0 else "") )
-        self._caught.append( deferred )
-        return deferred
-
-    def __getitem__(self, key):
-        """ Deferred reading item [] """
-        if self._was_executed:
-            return self.cdx_deferred_result[key]
-        deferred = Deferred( typ=Deferred.TYPE_ITEM, ref=key, info="%s[%s]" % (self._info, str(key)))
-        self._caught.append( deferred )
-        return deferred
-
-    def __setitem__(self, key, value):
-        """ Deferred item assignment [] """
-        if self._was_executed:
-            self.cdx_deferred_result[key] = value
-        else:
-            deferred = Deferred( typ=Deferred.TYPE_SET_ITEM, ref=(key, value), info="%s[%s] = %s" % (self._info, str(key), str(value)[:100]))
-            self._caught.append( deferred )
-
-    def __getattr__(self, attr):
-        """ Deferred attribute access """
-        attr = str(attr)
-        if self._was_executed:
-            return getattr(self.cdx_deferred_result,attr)
-        deferred = Deferred( typ=Deferred.TYPE_ATTR, ref=attr, info="%s.%s" % (self._info,attr))
-        self._caught.append( deferred )
-        return deferred
-
-    def __setattr_(self, attr, value):
-        """ Deferred attribute access """
-        attr = str(attr)
-        if self._was_executed:
-            self.cdx_deferred_result.__setattr__(attr, value)
-        else:
-            deferred = Deferred( typ=Deferred.TYPE_SET_ATTR, ref=(attr,value), info="%s.%s = %s" % (self._info,attr,str(value)[:100]))
-            self._caught.append( deferred )
-