cdxcore 0.1.5__py3-none-any.whl → 0.1.9__py3-none-any.whl

tests/test_util.py

@@ -9,15 +9,34 @@ import numpy as np
 import datetime as datetime
 from zoneinfo import ZoneInfo
 
-"""
-import importlib as imp
-import source.util as _
-imp.reload(_)
-"""
-from cdxcore.util import isFunction, isAtomic, isFloat
+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
+    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] )
+
+    # 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 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 UtilTest(unittest.TestCase):
+class Test(unittest.TestCase):
 
     def test_fmt(self):
 
@@ -211,20 +230,40 @@ class UtilTest(unittest.TestCase):
         self.assertEqual( fmt_filename("K:X;Z"), "K;X;Z" )
         self.assertEqual( fmt_filename("*"), "@" )
         self.assertEqual( fmt_filename("."), "." )  # technically a valid filename, but a reserved name at that
+
+        with self.assertRaises(ValueError):
+            self.assertEqual( fmt_filename("2*2/4=x", by="wrong"), "2@2_4=x" )
+
+        BLANK =   {      '/' : "",
+                         '\\': "",
+                         '|' : "",
+                         ':' : "",
+                         '>' : "",
+                         '<' : "",
+                         '?' : "",
+                         '*' : "",
+                         } 
+        self.assertEqual( fmt_filename("2*2/4=x", by=BLANK), "224=x" )
+        
+        # is_filename
+        self.assertTrue( is_filename("hans") )
+        self.assertFalse( is_filename("h/ans") )
+        self.assertFalse( is_filename("h?ans") )
+        
         
     def test_basics(self):
 
-        # isFunction
-        self.assertFalse( isFunction(1) )
-        self.assertFalse( isFunction("text") )        
-        self.assertTrue( isFunction(self.test_basics) )
-        self.assertTrue( isFunction(lambda x: x) )
+        # is_function
+        self.assertFalse( is_function(1) )
+        self.assertFalse( is_function("text") )        
+        self.assertTrue( is_function(self.test_basics) )
+        self.assertTrue( is_function(lambda x: x) )
         
         def f(x,y):
             return x
-        self.assertTrue( isFunction(f) )
+        self.assertTrue( is_function(f) )
         def ff():
-            self.assertTrue( isFunction(ff) )
+            self.assertTrue( is_function(ff) )
         ff()
 
         class A(object):
@@ -249,79 +288,79 @@ class UtilTest(unittest.TestCase):
         a = A()
         b = B()
         c = C()
-        self.assertFalse( isFunction(A) )
-        self.assertFalse( isFunction(B) )
-        self.assertFalse( isFunction(C) )
-        self.assertFalse( isFunction(a) )
-        self.assertFalse( isFunction(b) )
-        self.assertFalse( isFunction(c) )
-        self.assertTrue( isFunction(A.__init__) )
-        self.assertTrue( isFunction(A.f) )
-        self.assertFalse( isFunction(A.square) )
-        self.assertTrue( isFunction(A.g) )
-        self.assertTrue( isFunction(a.__init__) )
-        self.assertTrue( isFunction(a.f) )
-        self.assertFalse( isFunction(a.square) )  # <-- properties are not considered as function
-        self.assertTrue( isFunction(a.g) )
-        self.assertTrue( isFunction(B.__init__) )
-        self.assertTrue( isFunction(B.__call__ ) )
-        self.assertTrue( isFunction(b.__init__) )
-        self.assertTrue( isFunction(b.__call__ ) )
-        self.assertFalse( isFunction(b) )         # <-- properties are not considered as function
+        self.assertFalse( is_function(A) )
+        self.assertFalse( is_function(B) )
+        self.assertFalse( is_function(C) )
+        self.assertFalse( is_function(a) )
+        self.assertFalse( is_function(b) )
+        self.assertFalse( is_function(c) )
+        self.assertTrue( is_function(A.__init__) )
+        self.assertTrue( is_function(A.f) )
+        self.assertFalse( is_function(A.square) )
+        self.assertTrue( is_function(A.g) )
+        self.assertTrue( is_function(a.__init__) )
+        self.assertTrue( is_function(a.f) )
+        self.assertFalse( is_function(a.square) )  # <-- properties are not considered as function
+        self.assertTrue( is_function(a.g) )
+        self.assertTrue( is_function(B.__init__) )
+        self.assertTrue( is_function(B.__call__ ) )
+        self.assertTrue( is_function(b.__init__) )
+        self.assertTrue( is_function(b.__call__ ) )
+        self.assertFalse( is_function(b) )         # <-- properties are not considered as function
         self.assertTrue( callable(b) )
-        self.assertFalse( isFunction(c) )
-        self.assertTrue( isFunction(i for i in c) )
-        self.assertTrue( isFunction(lambda x : x*x) )
+        self.assertFalse( is_function(c) )
+        self.assertTrue( is_function(i for i in c) )
+        self.assertTrue( is_function(lambda x : x*x) )
 
-        # isAtomic
-        self.assertTrue( isAtomic(0) )
-        self.assertTrue( isAtomic(0.1) )
-        self.assertTrue( isAtomic("c") )
-        self.assertFalse( isAtomic(b'\x02') )
-        self.assertTrue( isAtomic("text") )
-        self.assertFalse( isAtomic(complex(0.,-1)) )
-        self.assertTrue( isAtomic(True) )
-        self.assertTrue( isAtomic(1==0) )
-        self.assertTrue( isAtomic(datetime.date(year=2005, month=2, day=1)) )
-        self.assertFalse( isAtomic(datetime.time(hour=4)) )
-        self.assertFalse( isAtomic(datetime.datetime(year=2005, month=2, day=1, hour=4)) )
-        self.assertTrue( isAtomic(1==0) )
-        self.assertTrue( isAtomic(1==0) )
-        self.assertFalse( isAtomic(A) )
-        self.assertFalse( isAtomic(a) )
-        self.assertFalse( isAtomic(f) )
-        self.assertFalse( isAtomic([1,2]) )
-        self.assertFalse( isAtomic([]) )
-        self.assertFalse( isAtomic({}) )
-        self.assertFalse( isAtomic({'x':2}) )
-        self.assertFalse( isAtomic({'x':2}) )
+        # is_atomic
+        self.assertTrue( is_atomic(0) )
+        self.assertTrue( is_atomic(0.1) )
+        self.assertTrue( is_atomic("c") )
+        self.assertFalse( is_atomic(b'\x02') )
+        self.assertTrue( is_atomic("text") )
+        self.assertFalse( is_atomic(complex(0.,-1)) )
+        self.assertTrue( is_atomic(True) )
+        self.assertTrue( is_atomic(1==0) )
+        self.assertTrue( is_atomic(datetime.date(year=2005, month=2, day=1)) )
+        self.assertFalse( is_atomic(datetime.time(hour=4)) )
+        self.assertFalse( is_atomic(datetime.datetime(year=2005, month=2, day=1, hour=4)) )
+        self.assertTrue( is_atomic(1==0) )
+        self.assertTrue( is_atomic(1==0) )
+        self.assertFalse( is_atomic(A) )
+        self.assertFalse( is_atomic(a) )
+        self.assertFalse( is_atomic(f) )
+        self.assertFalse( is_atomic([1,2]) )
+        self.assertFalse( is_atomic([]) )
+        self.assertFalse( is_atomic({}) )
+        self.assertFalse( is_atomic({'x':2}) )
+        self.assertFalse( is_atomic({'x':2}) )
         
-        self.assertEqual( isAtomic(np.int_(0)), True  )
-        self.assertEqual( isAtomic(np.int32(0)), True  )
-        self.assertEqual( isAtomic(np.int64(0)), True  )
-        self.assertEqual( isAtomic(np.complex128(0)), True  )
-        self.assertEqual( isAtomic(np.datetime64()), True  )
-        self.assertEqual( isAtomic(np.timedelta64()), True  )
-        self.assertEqual( isAtomic(np.ushort(0)), True  )
-        self.assertEqual( isAtomic(np.float32(0)), True  )
-        self.assertEqual( isAtomic(np.float64(0)), True  )
-        self.assertEqual( isAtomic(np.ulonglong(0)), True  )
-        self.assertEqual( isAtomic(np.longdouble(0)), True  )
-        self.assertEqual( isAtomic(np.half(0)), True  )
+        self.assertEqual( is_atomic(np.int_(0)), True  )
+        self.assertEqual( is_atomic(np.int32(0)), True  )
+        self.assertEqual( is_atomic(np.int64(0)), True  )
+        self.assertEqual( is_atomic(np.complex128(0)), True  )
+        self.assertEqual( is_atomic(np.datetime64()), True  )
+        self.assertEqual( is_atomic(np.timedelta64()), True  )
+        self.assertEqual( is_atomic(np.ushort(0)), True  )
+        self.assertEqual( is_atomic(np.float32(0)), True  )
+        self.assertEqual( is_atomic(np.float64(0)), True  )
+        self.assertEqual( is_atomic(np.ulonglong(0)), True  )
+        self.assertEqual( is_atomic(np.longdouble(0)), True  )
+        self.assertEqual( is_atomic(np.half(0)), True  )
 
-        # isFloat
-        self.assertFalse( isFloat(0) )
-        self.assertTrue( isFloat(0.1) )
-        self.assertFalse( isFloat(1==2) )
-        self.assertFalse( isFloat("0.1") )
-        self.assertFalse( isFloat(complex(0.,-1.)) )
-        self.assertTrue( isFloat(np.float16(0.1)) )
-        self.assertTrue( isFloat(np.float32(0.1)) )
-        self.assertTrue( isFloat(np.float64(0.1)) )
-        self.assertFalse( isFloat(np.int16(0.1)) )
-        self.assertFalse( isFloat(np.int32(0.1)) )
-        self.assertFalse( isFloat(np.int64(0.1)) )
-        self.assertFalse( isFloat(np.complex64(0.1)) )
+        # is_float
+        self.assertFalse( is_float(0) )
+        self.assertTrue( is_float(0.1) )
+        self.assertFalse( is_float(1==2) )
+        self.assertFalse( is_float("0.1") )
+        self.assertFalse( is_float(complex(0.,-1.)) )
+        self.assertTrue( is_float(np.float16(0.1)) )
+        self.assertTrue( is_float(np.float32(0.1)) )
+        self.assertTrue( is_float(np.float64(0.1)) )
+        self.assertFalse( is_float(np.int16(0.1)) )
+        self.assertFalse( is_float(np.int32(0.1)) )
+        self.assertFalse( is_float(np.int64(0.1)) )
+        self.assertFalse( is_float(np.complex64(0.1)) )
         
 if __name__ == '__main__':
     unittest.main()

tests/test_verbose.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr 14 21:24:52 2020
+@author: hansb
+"""
+
+import unittest as unittest
+
+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
+    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] )
+
+    # 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()
+
+from cdxcore.verbose import Context
+from cdxcore.uniquehash import unique_hash32 as unique_hash
+
+class Test(unittest.TestCase):
+
+    def test_verbose(self):
+        
+        class Channel(object):
+            def __init__(self):
+                self.track = []
+            def __call__(self, msg : str, flush : bool ):
+                self.track.append( (msg, flush) )
+            def __str__(self):
+                return str( self.track )
+        
+        def f_sub( num=3, context = Context.quiet ):
+            context.report(0, "Entering loop")
+            for i in range(num):
+                context.report(1, "Number %ld", i)
+
+        def f_main( context = Context.quiet ):
+            context.write( "First step" )
+            # ... do something
+            context.report( 1, "Intermediate step 1" )
+            context.report( 1, "Intermediate step 2\nwith newlines" )
+            # ... do something
+            f_sub( context=context(1) )
+            # ... do something
+            context.write( "Final step" )
+
+        channel = Channel()
+        context = Context(1,channel=channel)
+        f_main(context)
+        self.assertEqual( str(channel), r"[('00: First step\n', True), ('01:   Intermediate step 1\n', True), ('01:   Intermediate step 2\n01:   with newlines\n', True), ('01:   Entering loop\n', True), ('00: Final step\n', True)]")
+
+        channel = Channel()
+        context = Context(2,channel=channel)
+        f_main(context)
+        self.assertEqual( str(channel), r"[('00: First step\n', True), ('01:   Intermediate step 1\n', True), ('01:   Intermediate step 2\n01:   with newlines\n', True), ('01:   Entering loop\n', True), ('02:     Number 0\n', True), ('02:     Number 1\n', True), ('02:     Number 2\n', True), ('00: Final step\n', True)]")
+
+        channel = Channel()
+        context = Context("all",channel=channel)
+        f_main(context)
+        self.assertEqual( str(channel), r"[('00: First step\n', True), ('01:   Intermediate step 1\n', True), ('01:   Intermediate step 2\n01:   with newlines\n', True), ('01:   Entering loop\n', True), ('02:     Number 0\n', True), ('02:     Number 1\n', True), ('02:     Number 2\n', True), ('00: Final step\n', True)]")
+
+        channel = Channel()
+        context = Context(None,channel=channel)
+        f_main(context)
+        self.assertEqual( str(channel), r"[('00: First step\n', True), ('01:   Intermediate step 1\n', True), ('01:   Intermediate step 2\n01:   with newlines\n', True), ('01:   Entering loop\n', True), ('02:     Number 0\n', True), ('02:     Number 1\n', True), ('02:     Number 2\n', True), ('00: Final step\n', True)]")
+
+        channel = Channel()
+        context = Context("quiet",channel=channel)
+        f_main(context)
+        self.assertEqual( str(channel), r"[]")
+
+        verbose1 = Context(1)
+        verbose1.level = 2
+        verbose2 = Context(2,indent=3)
+        verbose2.level = 3
+        self.assertEqual( unique_hash( verbose1 ), unique_hash( verbose2 ) )    
+        
+        verbose = Context("all")
+        self.assertEqual( verbose.fmt(0,"test {x}", x=1),   "00: test 1")
+        self.assertEqual( verbose.fmt(1,"test %(x)d", x=1), "01:   test 1")
+        self.assertEqual( verbose.fmt(2,"test %d", 1),      "02:     test 1")
+        verbose = Context(1)
+        self.assertEqual( verbose.fmt(0,"test {x}", x=1),   "00: test 1")
+        self.assertEqual( verbose.fmt(1,"test %(x)d", x=1), "01:   test 1")
+        self.assertEqual( verbose.fmt(2,"test %d", 1),      None)
+        verbose = Context(1)
+        x = 1
+        self.assertEqual( verbose.fmt(0,lambda : f"test {x}"),   "00: test 1")
+        
+        def f():
+            raise RuntimeError("I should not happen")
+        verbose.fmt(2,f)
+        def f():
+            raise RuntimeError("I should happen")
+        with self.assertRaises(RuntimeError):
+            verbose.fmt(1,f)
+
+        
+if __name__ == '__main__':
+    unittest.main()
+
+

tests/test_version.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr 14 21:24:52 2020
+@author: hansb
+"""
+
+import unittest as unittest
+
+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
+    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] )
+
+    # 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()
+    
+"""
+Imports
+"""
+from cdxcore.version import version
+
+@version("1.0")
+def f(x):
+    return x
+@version("2.0", dependencies=[f])
+def g1(x):
+    return f(x)
+@version("2.1", dependencies=[f])
+def g2(x):
+    return f(x)
+class A(object):
+    @version("2.2")
+    def r1(self, x):
+        return x
+    @version("2.3", dependencies=['A.r1', 'g1'])
+    def r2(self, x):
+        return x
+@version("XV")
+class B(object):
+    def f(self, x):
+        return x
+    @version("1")
+    def t1(self):
+        return
+    @version("2", auto_class=True)
+    def t2(self):
+        return
+    @version("3", auto_class=False)
+    def t3(self):
+        return
+
+@version("3.0", dependencies=['g1', g2, 'A.r1', A.r2, B])
+def h(x,y):
+    a = A()
+    return g1(x)+g2(y)+a.r1(x)+a.r2(y)
+
+@version("0.0.1")
+class baseA(object):
+    pass
+@version("0.0.2")
+class baseB(baseA):
+    pass
+@version("0.0.3", auto_class=False)
+class baseC(baseA):
+    pass
+
+bA = baseA()
+
+@version("2", dependencies=[bA]) # <- actually not a great use case to make a function dependent on an object (instead of the class)
+def baf(x):
+    return x
+
+class AA(object):
+    def __init__(self, x=2):
+        self.x = x
+    @version(version="0.4.1")
+    def h(self, y):
+        return self.x*y
+
+@version(version="0.3.0")
+def Ah(x,y):
+    return x+y
+
+@version(version="0.0.2", dependencies=[Ah])
+def Af(x,y):
+    return Ah(y,x)
+
+@version(version="0.0.1", dependencies=["Af", AA.h])
+def Ag(x,z):
+    a = AA()
+    return Af(x*2,z)+a.h(z)
+
+class Test(unittest.TestCase):
+    
+    def test_version(self):
+        # test dependency
+        
+        a = A()
+        b = B()
+        bA = baseA()
+        bB = baseB()
+        bC = baseC()
+        
+        self.assertEqual( h.version.input, "3.0" )
+        self.assertEqual( h.version.full, "3.0 { A.r1: 2.2, A.r2: 2.3 { A.r1: 2.2, g1: 2.0 { f: 1.0 } }, B: XV, g1: 2.0 { f: 1.0 }, g2: 2.1 { f: 1.0 } }" )
+        self.assertEqual( h.version.unique_id48, "3.0 { A.r1: 2.2, A.r2: 2.3 { A.r1: 2.2, 2695aabd" )
+        self.assertEqual( h.version.is_dependent( g2 ), "2.1" )
+        self.assertEqual( h.version.is_dependent( "g2" ), "2.1" )
+        self.assertEqual( h.version.is_dependent( f ), "1.0" )
+        self.assertEqual( h.version.is_dependent( "f" ), "1.0" )
+        self.assertEqual( h.version.is_dependent( B ), "XV" )
+        self.assertEqual( h.version.is_dependent( b ), "XV" )
+        self.assertEqual( h.version.is_dependent( A.r2 ), "2.3" )
+        self.assertEqual( h.version.is_dependent( a.r2 ), "2.3" )
+        self.assertEqual( b.t1.version.full, "1 { B: XV }" )
+        self.assertEqual( b.t2.version.full, "2 { B: XV }" )
+        self.assertEqual( b.t3.version.full, "3" )
+        self.assertEqual( baf.version.full, "2 { baseA: 0.0.1 }" )
+
+        self.assertEqual( baseA.version.full, "0.0.1")
+        self.assertEqual( baseB.version.full, "0.0.2 { baseA: 0.0.1 }")
+        self.assertEqual( baseC.version.full, "0.0.3")
+        self.assertEqual( bA.version.full, "0.0.1")
+        self.assertEqual( bB.version.full, "0.0.2 { baseA: 0.0.1 }")
+        self.assertEqual( bC.version.full, "0.0.3")
+
+        Ag(1,2)
+        
+        self.assertEqual( Ag.version.input, "0.0.1")
+        self.assertEqual( Ag.version.full, "0.0.1 { AA.h: 0.4.1, Af: 0.0.2 { Ah: 0.3.0 } }")
+        self.assertEqual( Ag.version.unique_id48, "0.0.1 { AA.h: 0.4.1, Af: 0.0.2 { Ah: 0.3.0 } }")
+        self.assertEqual( Ag.version.dependencies,('0.0.1', {'AA.h': '0.4.1', 'Af': ('0.0.2', {'Ah': '0.3.0'})}) )
+            
+if __name__ == '__main__':
+    unittest.main()
+
+

up/git_message.py

@@ -2,6 +2,6 @@
 Produce message with cdxbasics code
 """
 
-import cdxbasics as cdxbasics
-print("Code base %s" % cdxbasics.__version__)
+import cdxcore as cdxcore
+print("Code base %s" % cdxcore.__version__)