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

cdxcore/err.py

@@ -95,6 +95,11 @@ def _fmt( text : str, args = None, kwargs = None, f : Callable =  None ) -> str:
             return text % tuple(args)
         except TypeError as e:
             raise TypeError(e, text, args)
+    
+    # no keyword arguments --> must be plain text
+    if kwargs is None:
+        return text
+
     # text
     # python 2 and 3 mode
     kwargs = dict() if kwargs is None else kwargs
@@ -117,7 +122,7 @@ def fmt(text : str|Callable, * args, ** kwargs) -> str:
         one = 1
         fmt(lambda : f"one {one:d})   # using a lambda function
         fmt("one {one:d}", one=one)   # using python 3 string.format()
-        fmt("one %{one}ld", one=one)  # using python 2 style
+        fmt("one %(one)ld", one=one)  # using python 2 style
         fmt("one %ld", one)           # using c-style
     
     As shown, do not use f-strings directly as they are immediately executed in the scope they are typed in
@@ -164,7 +169,7 @@ def error( text : str|Callable, *args, exception : Exception = RuntimeError, **k
         one = 1
         error(lambda : f"one {one:d}")  # wrapped f-string
         error("one {one:d}", one=one)   # using python 3 string.format()
-        error("one %{one}ld", one=one)  # using python 2 style
+        error("one %(one)ld", one=one)  # using python 2 style
         error("one %ld", one)           # using c-style
     
     As shown, do not use f-strings directly as they are immediately executed in the scope they are typed in
@@ -214,7 +219,7 @@ def verify( cond : bool, text : str|Callable, *args, exception : Exception = Run
         good = False                           # some condition
         verify(good, lambda : f"one {one:d}")  # wrapped f-string
         verify(good, "one {one:d}", one=one)   # using python 3 string.format()
-        verify(good, "one %{one}ld", one=one)  # using python 2 style
+        verify(good, "one %(one)ld", one=one)  # using python 2 style
         verify(good, "one %ld", one)           # using c-style
     
     As shown, do not use f-strings directly as they are immediately executed in the scope they are typed in
@@ -268,7 +273,7 @@ def warn( text : str|Callable, *args, warning = RuntimeWarning, stack_level : in
         one = 1        
         warn(lambda : f"one {one:d}")  # wrapped f-string
         warn("one {one:d}", one=one)   # using python 3 string.format()
-        warn("one %{one}ld", one=one)  # using python 2 style
+        warn("one %(one)ld", one=one)  # using python 2 style
         warn("one %ld", one)           # using c-style
     
     As shown, do not use f-strings directly as they are immediately executed in the scope they are typed in
@@ -322,7 +327,7 @@ def warn_if( cond : bool, text : str|Callable, *args, warning = RuntimeWarning,
         bad = True                            # some conditon
         warn_if(bad,lambda : f"one {one:d}")  # wrapped f-string
         warn_if(bad,"one {one:d}", one=one)   # using python 3 string.format()
-        warn_if(bad,"one %{one}ld", one=one)  # using python 2 style
+        warn_if(bad,"one %(one)ld", one=one)  # using python 2 style
         warn_if(bad,"one %ld", one)           # using c-style
     
     As shown, do not use f-strings directly as they are immediately executed in the scope they are typed in

cdxcore/jcpool.py

@@ -51,7 +51,7 @@ class ParallelContextChannel( Context ):
         printing.
         """
         if get_thread_id() == self._maintid:
-            self._f_verbose.write(msg, end='', flush=flush)
+            self._f_verbose._raw(msg,end='',flush=flush)
         else:
             return self._queue.put( (msg, flush) )
 
@@ -125,13 +125,12 @@ class _ParallelContextOperator( object ):
                 raise r
             msg, flush = r
             if tme.interval_test(verbose_interval):
-                f_verbose.write(msg, end='', flush=flush)
+                f_verbose._raw(msg,end='',flush=flush)
 
     def __enter__(self):
         return self.mp_context
 
     def __exit__(self, *kargs, **kwargs):
-        #self.terminate()
         return False#raise exceptions
 
 class _DIF(object):

cdxcore/util.py

@@ -159,6 +159,77 @@ def getsizeof(obj):
     """
     return _get_recursive_size(obj,None)    
 
+def qualified_name( x, module : bool = False ):
+    """
+    Return qualified name including module name of some Python element.
+    
+    For the most part, this function will try to :func:`getattr` the ``__qualname__``
+    and ``__name__`` of ``x`` or its type. If all of these fail, an attempt is
+    made to convert ``type(x)`` into a string.
+    
+    **Class Properties**
+    
+    When reporting qualified names for a :dec:`property`, there is a nuance:
+    at class level, a property will be identified by its underlying function
+    name. Once an object is created, though, the property will be identified
+    by the return type of the property::
+        
+        class A(object):
+            @property
+                def p(self):
+                    return x
+
+        qualified_name(A.p)    # -> "A.p"
+        qualified_name(A().p)  # -> "int"
+           
+    Parameters
+    ----------
+        x : any
+            Some Python element.
+            
+        module : bool, optional
+            Whether to also return the containing module if available.
+    Returns
+    -------
+        qualified name : str
+            The name, if ``module`` is ``False``.
+            
+        (qualified name, module) : tuple
+            The name, if ``module`` is ``True``.
+            Note that the module name returned might be ``""`` if no module
+            name could be determined.
+            
+    Raises
+    ------
+        :class:`RuntimeError` if not qualfied name for ``x`` or its type could be found.
+    """
+    if x is None:
+        if not module:
+            return "None"
+        else:
+            return "None", ""
+    
+    # special cases
+    if isinstance(x, property):
+        x = x.fget
+    
+    name = getattr(x, "__qualname__", None)
+    if name is None:
+        name = getattr(x, "__name__", None)
+    if name is None:
+        name = getattr(type(x), "__qualname__", None)
+    if name is None:
+        name = getattr(type(x), "__name__", None)
+    if name is None:
+        name = str(type(x))
+    if not module:
+        return name
+
+    module = getattr(x, "__module__", None)
+    if module is None:
+        module = getattr(type(x), "__module__", "")
+    return name, module    
+
 # =============================================================================
 # string formatting
 # =============================================================================
@@ -279,7 +350,7 @@ def fmt_digits( integer : int, sep : str = "," ):
     String representation of an integer with 1000 separators: 10000 becomes "10,000".
     
     Parameters
-    --------
+    ----------
     integer : int
         The number. The function will :func:`int()` the input which allows
         for processing of a number of inputs (such as strings) but

cdxcore/verbose.py

@@ -592,8 +592,12 @@ class Context(object):
             See above 
         """
         message = self.fmt( level, message, *args, head=head, **kwargs )
+        self._raw(message,end=end,flush=True)
+            
+    def _raw( self, message : str, end : str, flush : bool ):
+        """ :meta private: used in JCPool """
         if not message is None:
-            self.crman.write(message,end=end,flush=True, channel=self.channel )
+            self.crman.write(message,end=end,flush=flush,channel=self.channel )
 
     def fmt( self, level : int, message : str|Callable, *args, head : bool = True, **kwargs ) -> str:
         """
@@ -809,6 +813,16 @@ class Context(object):
         """
         return Context( self, channel=channel ) if channel != self.channel else self
     
+    # Dummy context
+    # -------------
+    
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *kargs, **kwargs):
+        return False#raise exceptions
+
+    
     
 quiet         = Context(Context.QUIET)
 all_          = Context(Context.ALL)

{cdxcore-0.1.11.dist-info → cdxcore-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdxcore
-Version: 0.1.11
+Version: 0.1.13
 Summary: Basic Python Tools; upgraded cdxbasics
 Author-email: Hans Buehler <github@buehler.london>
 License-Expression: MIT

cdxcore-0.1.13.dist-info/RECORD

@@ -0,0 +1,37 @@
+cdxcore/__init__.py,sha256=sOrqASZiA2WU_hqqm2O-KjIob25zt7MqoB8EaHcMvjM,127
+cdxcore/config.py,sha256=YnIEJVFtMZ5EHlwzaB2JsSkCPhWPvEw9QSpe6mof_V4,98472
+cdxcore/crman.py,sha256=83oKpuzNy98ObpmUeJg2McGRxaLk2AP5lN1yd1F9ueQ,5759
+cdxcore/deferred.py,sha256=cPIvd0_CrC7Kn6dtaZXoHjWCA0L_3byPtLv8Op0uRI4,34181
+cdxcore/dynaplot.py,sha256=kwrH_WccpJcfS7n_gzdAr4QxQobvIZZrrxgdsKLKfj0,48552
+cdxcore/err.py,sha256=BwmhilSxofBjN_NSrekCHn8_Oz9U_XbbfTm5qFRUl90,14645
+cdxcore/jcpool.py,sha256=kurdafk6lerCkv52Wjh9UN7EFMP8Xp07iqB2adE5bfY,27302
+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=S-eaAlDfELZbOGyHCMO2M3TllOCpf9h8FgZV9pXgwZ4,34197
+cdxcore/verbose.py,sha256=66n9v2TduNWlochcV3mixSqyQzznO_H0LPrDgr9_dEo,30240
+cdxcore/version.py,sha256=m30oI2Ortg44dKSim-sIoeh9PioD1FWsSfVEP5rubhk,27173
+cdxcore-0.1.13.dist-info/licenses/LICENSE,sha256=M-cisgK9kb1bqVRJ7vrCxHcMQQfDxdY3c2YFJJWfNQg,1090
+docs/source/conf.py,sha256=Owctibh5XcSpSNcrpOr3ROIDjoklmFVrMhu8cOSe50o,4180
+tests/test_config.py,sha256=N86mH3y7k3LXEmU8uPLfrmRMZ-80VhlD35nBbpLmebg,15617
+tests/test_crman.py,sha256=YNNEAIcKvqfy9KifV1p1qzpphHIANrhjjPbccJFmzqk,1378
+tests/test_deferred.py,sha256=GKAI9m3vs2RCvRVJUg7E3VqJwlzZehwzZv-7nslRhrU,7355
+tests/test_err.py,sha256=4Pc7x2I0A_LBuiCMvstKNzN1JAcSPmm78dwLwp-N7s0,3146
+tests/test_jcpool.py,sha256=bcGC3UcJ7SOHVgzZ-cooEJgncLWmhutBfqH7P5qB-iw,7901
+tests/test_pretty.py,sha256=pVwTBjm3XqwEf2jq5GdZvT4cDSTGqiQFBMLqmGJYuB0,11644
+tests/test_subdir.py,sha256=Ab6pCrUnbMR3kpLsKcDwLUP5QY1HvFVTmSI9D1lXhbM,11444
+tests/test_uniquehash.py,sha256=n6ZCkdBw-iRsyzeAEmrnLK0hJLGH6l_Dtt_KIkSa6KA,24630
+tests/test_util.py,sha256=MXQMOmGjlBWTEwyW3JBTvZzlpMj5kDzThyhM2JwPZy8,23776
+tests/test_verbose.py,sha256=zXheIqAVOnwML2zsCjLugjYzB_KNzU_S4Xu2CSb4o10,4723
+tests/test_version.py,sha256=m_RODPDFlXTC1jAIczm3t1v6tXzqczDiUFFJtGvRG98,4381
+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.13.dist-info/METADATA,sha256=vEmQg3-9uwcgD18Jrml9koI6pduBQt-GG6lLnjPCw98,754
+cdxcore-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cdxcore-0.1.13.dist-info/top_level.txt,sha256=phNSwCyJFe7UP2YMoi8o6ykhotatlIbJHjTp9EHM51k,26
+cdxcore-0.1.13.dist-info/RECORD,,

tests/test_config.py

@@ -6,7 +6,6 @@ Created on Tue Apr 14 21:24:52 2020
 
 import unittest as unittest
 import dataclasses as dataclasses
-import sys as sys
 import os as os
 import pickle as pickle
 import tempfile as tempfile
@@ -16,7 +15,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
@@ -27,15 +25,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.config import Config, Int, Float
 from cdxcore.pretty import PrettyObject as pdct

tests/test_crman.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.crman import CRMan
 

tests/test_deferred.py

@@ -0,0 +1,277 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr 14 21:24:52 2020
+@author: hansb
+"""
+
+import unittest as unittest
+import numpy as np
+
+def import_local():
+    """
+    In order to be able to run our tests manually from the 'tests' directory
+    we force import from the local package.
+    """
+    me = "cdxcore"
+    import os
+    import sys
+    cwd = os.getcwd()
+    if cwd[-len(me):] == me:
+        return
+    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()
+
+from cdxcore.deferred import Deferred, ResolutionDependencyError
+
+class qB(object):
+    def __init__(self):
+        self.m = 1
+    def f(self,y):
+        return self.m+y
+
+class qA(object):
+
+    M = 7
+
+    def __init__(self):
+        self.m = 1
+        self.d = dict()
+        self.l = list()
+        self.b = qB()
+    
+    def f(self, y=2):
+        return self.m*y
+
+    def fq(self, q):
+        return self.m*q.m
+    
+    @property
+    def g(self):
+        return self.m*3
+
+    @staticmethod
+    def h(x,*,y=2):
+        return x*y
+
+    @property
+    def more(self):
+        return qB()
+
+    def moref(self):
+        return qB()
+
+    @classmethod
+    def j(cls, y=2):
+        return cls.M*y
+        
+    def __iter__(self):
+        for i in  range(self.x):
+            yield i
+            
+    def __call__(self, x):
+        return self.m*x
+    
+    def __getitem__(self, i):
+        return self.d[i]
+    
+    def __setitem__(self, i, v):
+        self.d[i] = v
+
+    def __eq__(self, other):
+        return self.m == other.m
+
+    def __iadd__(self, integer):
+        self.m += integer
+        return self
+
+    def __rxor__(self, integer):
+        r = qA()
+        r.m = self.m^integer
+        return r
+
+def some_function(x):
+    return x.m
+
+# for detecting collisions
+class AX(object):
+    def __init__(self):
+        self.x = 1
+    def f(self,other):
+        return self.x+(other.x if not isinstance(other, int) else other)
+        
+class Test(unittest.TestCase):
+
+    def test_deferred(self):
+        
+        # some basic Python tests
+        
+        with self.assertRaises(AttributeError):
+            getattr(int(1),"__getattr__") # __getattr__ can be read using 'getattr'
+        _ = getattr(int(1),"__setattr__")
+        _ = getattr(int(1),"__delattr__")
+            
+        # does it work?
+        # we test the results of executing some code directly or delayed
+        def test_iadd(a):
+            a+=1
+            return a
+
+        def tester(a,b):
+            am = a.m
+            return dict(
+                aM = a.M,
+                am = am,
+                ag = a.g,
+                af2 = a.f(2),
+                afm = a.f(am),
+                af23 = a.f(y=2)*3+1,
+                ah = a.h(x=3,y=4),
+                aj = a.j(5),
+                a2j = 2+a.j(5),
+                amm = a.more.m,
+                amff = a.moref().f(y=3),
+                afqb = a.fq( b ),
+                eq = a==b,
+                iadd = test_iadd(a).m,
+                rxor = (1^a).m,#
+                some = some_function(a)
+            )
+    
+
+        deferred_a = Deferred("a")
+        deferred_b = Deferred("b")
+        actual_a = qA()
+        actual_b = qA()
+        results_act = tester(actual_a, actual_b)
+        results_drf = tester(deferred_a, deferred_b)
+        
+        deferred_b.deferred_resolve( qA() )
+        deferred_a.deferred_resolve( qA() )
+        
+        results_tst = { k: v.deferred_action_result for k,v in results_drf.items() }
+
+        self.assertEqual( list(results_tst), list(results_act) )
+        for k, tst in results_tst.items():
+            act = results_act[k]
+            self.assertEqual( tst, act, msg=f"Step 1 {k} '{tst}' != '{act}'" )
+        
+        # ops
+
+        def c1(a):
+        	a+=3
+        	return a
+        def c2(a):
+        	a-=3
+        	return a
+        def c3(a):
+            a = a.astype(np.float32)
+            a/=3
+            return a
+        def c4(a):
+        	a//=3
+        	return a
+        def c5(a):
+        	a*=3
+        	return a
+        def c6(a):
+        	a^=3
+        	return a
+        def c7(a):
+        	a|=3
+        	return a
+        def c8(a):
+        	a&=3
+        	return a
+        def c9(a):
+        	a**=3
+        	return a
+        def cA(a):
+            a@=a.T
+            return a
+        def cB(a):
+        	a%=3
+        	return a
+        def test_op(a):
+            return dict(
+        		# left
+                a1 = a+3    ,
+                a2 = a-3    ,
+                a3 = a/3    ,
+                a4 = a//3   ,
+                a5 = a*3    ,
+                a6 = a^3    ,
+                a7 = a|3    ,
+                a8 = a&3    ,
+                a9 = a**3   ,
+                aA = a@np.full((2,1),2)    ,
+                aB = a%3    ,
+        		# right
+                b1 = 3+a    ,
+                b2 = 3-a    ,
+                b3 = 3/a    ,
+                b4 = 3//a   ,
+                b5 = 3*a    ,
+                b6 = 3^a    ,
+                b7 = 3|a    ,
+                b8 = 3&a    ,
+                b9 = 3**a   ,
+                bA = a.T @ a,
+                bB = 3%a    ,
+                bC = [3]+a  ,
+        		# in place
+        		c1 = c1(a),
+        		c2 = c2(a),
+                c3 = c3(a),
+                c4 = c4(a),
+                c5 = c5(a),
+                c6 = c6(a),
+                c7 = c7(a),
+                c8 = c8(a),
+                c9 = c9(a),
+                cB = cB(a)
+        	)
+
+        deferred_a = Deferred("a")
+        actual_a = np.full((4,2),3,dtype=np.int32)
+        results_act = test_op(actual_a)
+        results_drf = test_op(deferred_a)
+        
+        deferred_a.deferred_resolve( np.full((4,2),3,dtype=np.int32) )
+
+        results_act = { k: v.astype(np.int32) for k,v in results_act.items() }
+        results_tst = { k: v.deferred_action_result.astype(np.int32) for k,v in results_drf.items() }
+
+        self.assertEqual( list(results_tst), list(results_act) )
+        for k, tst in results_tst.items():
+            act = results_act[k]
+            self.assertEqual( act.shape, tst.shape, msg=k )
+            self.assertTrue( np.all( tst == act ), msg=f"Step 2 {k} '{tst}' != '{act}'" )
+
+        # info test
+        
+        a = Deferred("a")
+        b = Deferred("b")
+        _ = a.f( b.g(1) )
+        self.assertEqual( _.deferred_info, '$a.f({$b.g(1)})' )
+
+        a = Deferred("a")
+        b = Deferred("b")
+        _ = a.f( b.g(1) )
+        src = list(_.deferred_sources.values())
+        self.assertEqual( src, ['$a', '$b'] )
+        src = _.deferred_sources_names
+        self.assertEqual( src, ['$a', '$b'] )
+
+        # collision test
+        
+        a = Deferred("A")
+        b = Deferred("B")
+        _ = a.f(b) # <- execution  depends on b
+        
+        with self.assertRaises(ResolutionDependencyError):
+            a.deferred_resolve( AX() )  # <- must fail
+            
+if __name__ == '__main__':
+    unittest.main()

tests/test_err.py

@@ -5,13 +5,11 @@ Created on Tue Apr 14 21:24:52 2020
 """
 
 import unittest as unittest
-import warnings as warnings
 
 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,15 +20,9 @@ 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)
-            print("Reloaded", name)
-#import_local()
+import warnings as warnings
 
 from cdxcore.err import fmt, error, verify, warn, warn_if