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

cdxcore/logger.py

@@ -1,319 +0,0 @@
-"""
-Basic log file logic
-"""
-
-from .util import _fmt, prnt, write
-import sys as sys
-import logging as logging
-import traceback as traceback
-import datetime as datetime
-
-_prnt = prnt
-_write = write
-
-class Logger(object):
-    """
-    Simple utility object to decorate loggers, plus:
-        - infor, warning, () also accept named argument formatting ie "The error is %(message)self" instead of positional %
-        - added Exceptn function which logs an error before returning an exception.
-          It also make sure an exception is only tracked once.
-    The point of this class is to be able to write
-        import base.logger as logger
-        _log = logger.getLogger(__file__)
-        ...
-        _log.verify( some_condition_we_want_met, "Error: cannot find %s", message)
-    and it will keep a log of that exception.
-    
-    Exceptions independent of logging level
-    
-        verify( cond, text, *args, **kwargs )
-            If cond is not met, raise an exception with util.fmt( text, *args, **kwargs )
-        
-        throw_if(cond, text, *args, **kwargs )
-            If cond is met, raise an exception with util.fmt( text, *args, **kwargs )
-
-        throw( text, *args, **kwargs )
-            Raise an exception with fmt( text, *args, **kwargs )
-        
-    Unconditional logging
-    
-        debug( text, *args, **kwargs )
-        info( text, *args, **kwargs )
-        warning( text, *args, **kwargs )
-        error( text, *args, **kwargs )
-        debug( text, *args, **kwargs )
-        
-    Conditional logging functions, verify version
-    
-        verify_debug( cond, text, *args, **kwargs )
-        verify_info( cond, text, *args, **kwargs )
-        verify_warning( cond, text, *args, **kwargs )
-
-        verify( cond, text, *args, **kwargs )
-    
-    Conditional logging functions, if version
-    
-        debug_if( text, *args, **kwargs )
-        info_if( text, *args, **kwargs )
-        warning_if( text, *args, **kwargs )
-        
-        throw_if( text, *args, **kwargs )
-
-        prnt_if( text, *args, **kwargs )      # with EOL
-        write_if( text, *args, **kwargs )     # without EOL
-    """
-    
-    CRITICAL = logging.CRITICAL
-    ERROR = logging.ERROR
-    WARNING = logging.WARNING
-    INFO = logging.INFO
-    DEBUG = logging.DEBUG
-    NOTSET = logging.NOTSET
-
-    def __init__(self,topic : str):
-        assert topic !="", "Logger cannot be empty"
-        setupAppLogging()   # ensure system is ready
-        i = topic.rfind('/')
-        if i == -1:
-            i = topic.rfind('\\')
-        if i != -1 and i<len(topic)-1:
-            topic = topic[i+1:]
-        self.logger   = logging.getLogger(topic)
-    
-    # Exception support
-    # -----------------
-
-    class LogException(Exception):
-        """ Placeholder exception class we use to identify our own exceptions """
-        
-        def __init__(self,text : str):
-            Exception.__init__(self,text)
-            
-    def Exceptn(self, text : str, *args, **kwargs ):
-        """
-        Returns an exception object with 'text' % kwargs and stores an 'error' message
-            If an exception is present, it will be printed, too.
-            If the base logger logs 'debug' information, the call stack will be printed as well
-            
-        Usage:
-            raise _log.Exceptn("Something happened")
-        """        
-        text = _fmt(text,args,kwargs)
-        (typ, val, trc) = sys.exc_info()
-        
-        # are we already throwing our own exception?
-        if typ is Logger.LogException:
-            return val               # --> already logged --> keep raising the exception but don't do anything
-        
-        # new exception?
-        if typ is None:
-            assert val is None and trc is None, "*** Internal error"
-            self.error( text )
-            return Logger.LogException("*** LogException: " + text)
-
-        # another exception is being thrown.
-        # we re-cast this as one of our own.
-        if text[-1] == ".":
-            text = text + " " + str(val)
-        else:
-            text = text + ". " + str(val)
-
-        # in debug, add trace information
-        if self.logger.getEffectiveLevel() <= logging.WARNING:
-            text = text.rstrip()
-            txt = traceback.format_exception(typ,val,trc,limit = 100)
-            for t in txt:
-                text += "\n  " + t[:-1]
-        self.error( text )
-
-        # return an exception with the corresponding text
-        return Logger.LogException("*** LogException: " + text)
-    
-    # logging() replacemets
-    # ---------------------
-    
-    def debug(self, text, *args, **kwargs ):
-        """ Reports debug information with new style formatting """
-        if self.logger.getEffectiveLevel() <= logging.DEBUG and len(text) > 0:
-            self.logger.debug(_fmt(text,args,kwargs))
-
-    def info(self, text, *args, **kwargs ):
-        """ Reports information with new style formatting """
-        if self.logger.getEffectiveLevel() <= logging.INFO and len(text) > 0:
-            self.logger.info(_fmt(text,args,kwargs))
-
-    def warning(self, text, *args, **kwargs ):
-        """ Reports a warning with new style formatting """
-        if self.logger.getEffectiveLevel() <= logging.WARNING and len(text) > 0:
-            self.logger.warning(_fmt(text,args,kwargs))
-    warn = warning
-    
-    def error(self, text, *args, **kwargs ):
-        """ Reports an error with new style formatting """
-        if self.logger.getEffectiveLevel() <= logging.ERROR and len(text) > 0:
-            self.logger.error(_fmt(text,args,kwargs))
-
-    def critical(self, text, *args, **kwargs ):
-        """ Reports a critial occcurance with new style formatting """
-        if self.logger.getEffectiveLevel() <= logging.CRITICAL and len(text) > 0:
-            self.logger.critical(_fmt(text,args,kwargs))
-            
-    def throw( self, text, *args, **kwargs ):     
-        """ Raise an exception """
-        raise self.Exceptn(text,*args,**kwargs)
-
-    @staticmethod
-    def prnt( text, *args, **kwargs ):
-        """ Simple print, with EOL """
-        _prnt(_fmt(text,args,kwargs))
-        
-    @staticmethod
-    def write(text, *args, **kwargs ):
-        """ Simple print, without EOL """
-        _write(_fmt(text,args,kwargs))
-    
-    # run time utilities with validity check
-    # --------------------------------------
-    
-    def verify(self, cond, text, *args, **kwargs ):
-        """
-        Verifies 'cond'. Raises an exception if 'cond' is not met with the specified text.
-        Usage:
-            _log.verify( i>0, "i must be positive, found %d", i)
-        """
-        if not cond:
-            self.throw(text,*args,**kwargs)
-                    
-    def verify_warning(self, cond, text, *args, **kwargs ):
-        """
-        Verifies 'cond'. If true, writes a warning and then continues
-        Usage
-            _log.verify_warning( i>0, "i must be positive, found %d", i)
-        """
-        if not cond:
-            self.warning(text, *args, **kwargs )
-            
-    verify_warn = verify_warning
-            
-    def verify_info(self, cond, text, *args, **kwargs ):
-        """ Verifies 'cond'. If true, writes log information and then continues  """
-        if not cond:
-            self.info(text, *args, **kwargs )
-
-    def verify_debug(self, cond, text, *args, **kwargs ):
-        """ Verifies 'cond'. If true, writes log debug and then continues """
-        if not cond:
-            self.debug(text, *args, **kwargs )
-
-    # if-action
-    # ---------
-    
-    def throw_if(self, cond, text, *args, **kwargs ):
-        """ Raises an exception if 'cond' is true. This is the reverse of verify() """
-        if cond:
-            raise self.Exceptn(text,*args,**kwargs)            
-    raise_if = throw_if
-
-    def warning_if(self, cond, text, *args, **kwargs ):
-        """ If 'cond' is true, writes a warning. Opposite condition than verify_warning """
-        if cond:
-            self.warning(text,*args,**kwargs)
-    warn_if = warning_if
-
-    def info_if(self, cond, text, *args, **kwargs ):
-        """ If 'cond' is true, writes information 'info'. Opposite condition than verify_info """
-        if cond:
-            self.info(text,*args,**kwargs)
-    
-    def debug_if(self, cond, text, *args, **kwargs ):
-        """ If 'cond' is true, writes debug 'info'. Opposite condition than verify_debug """
-        if cond:
-            self.debug(text,*args,**kwargs)
-
-    @staticmethod
-    def prnt_if(cond, text, *args, **kwargs ):
-        """ If 'cond' is True, prnt() text. Python 2.7 """
-        if cond:
-            Logger.prnt(text,*args,**kwargs)
-
-    @staticmethod
-    def write_if(cond, text, *args, **kwargs ):
-        """ If 'cond' is True, prnt() text """
-        if cond:
-            Logger.write(text,*args,**kwargs)
-            
-    # interface into logging
-    # ----------------------
-    
-    def setLevel(self, level):
-        """ logging.setLevel """
-        self.logger.setLevel(level)
-        
-    def getEffectiveLevel(self):
-        """ logging.getEffectiveLevel """
-        return self.logger.getEffectiveLevel()
-    
-# ====================================================================================================
-# setupAppLogging
-# ---------------
-# Defines logging at stderr and file level.
-# ====================================================================================================
-
-GLOBAL_LOG_DATA = "cdxbasics.logger"
-
-class RootLog(object):
-    def __init__(self, root):
-        self.handler = root
-        self.fileName = None
-
-rootLog = RootLog( logging.getLogger() )           # root level logger
-
-def setupAppLogging( levelPrint : int = logging.ERROR, 
-                     levelFile  : int = None
-                     ):
-    """
-    Application wide logging control - basically sets a log file path
-    This function will only called once.
-    Put this function into your root import
-    
-    Parameters
-    ----------
-        levelPrint   : printing level https://docs.python.org/3/library/logging.html
-        levelFile    : file level. Set to None to not write to file.
-    """
-
-    data =  globals().get(GLOBAL_LOG_DATA,None)
-    if data is None:
-        # logging for std derror
-        logging.basicConfig(level=min(levelPrint,levelFile) if not levelFile is None else levelPrint)
-        fmtt   = logging.Formatter(fmt="%(asctime)self %(levelname)-10s: %(message)self"  )
-        stdErr = logging.StreamHandler(sys.stdout)
-        stdErr.setLevel(levelPrint )
-        rootLog.handler.addHandler( stdErr )
-        data = {'strm':stdErr }    
-
-        if not levelFile is None:
-            # file system
-            import os
-            import os.path
-            import tempfile 
-            stamp    = datetime.datetime.now().strftime("%Y-%m-%d_%S%M%H")
-            pid      = os.getpid()      # note: process name is 'python.exe'
-            tmpDir   = tempfile.gettempdir()
-            logFile  = os.path.join(tmpDir,"py_logger_" + stamp + "_" + str(pid) + ".log")
-        
-            fileE = None
-            try:
-                fileE  = logging.FileHandler(logFile)
-                fileE.setFormatter(fmtt)
-                fileE.setLevel( levelFile )
-                rootLog.handler.addHandler( fileE )
-                data = {'strm':stdErr, 'file':fileE, 'logFileName':logFile }            
-            except:
-                pass
-                
-        globals()[GLOBAL_LOG_DATA] = data
-    
-    rootLog.fileName = data.get('logFileName', None)
-    return data
-

cdxcore/prettydict.py

@@ -1,388 +0,0 @@
-"""
-prettyict
-Dictionaries with member synthax access
-Hans Buehler 2022
-"""
-
-from collections import OrderedDict
-from sortedcontainers import SortedDict
-import dataclasses as dataclasses
-from dataclasses import Field
-import types as types
-from collections.abc import Mapping
-
-class PrettyDict(dict):
-    """
-    Dictionary which allows accessing its members with member notation, e.g.        
-        pdct = PrettyDict()
-        pdct.x = 1
-        x = pdct.x
-        
-    Functions will be made members, i.e the following works as expected
-        def mult_x(self, a):
-            return self.x * a
-        pdct.mult_x = mult_x
-        pdct.mult_x(2) --> 2
-        
-    To assign a static member use []:
-        def mult(a,b):
-            return a*b
-        pdct['mult'] = mult
-        pdct.mult(1,3) --> 3
-        
-    IMPORTANT
-    Attributes starting with '__' are handled as standard attributes.
-    In other words, 
-        pdct = PrettyDict()
-        pdct.__x = 1
-        _ = pdct['__x']   <- throws an exception
-    This allows re-use of general operator handling.        
-    """
-    
-    def __getattr__(self, key : str): 
-        """ Equyivalent to self[key] """
-        if key[:2] == "__": raise AttributeError(key) # you cannot treat private members as dictionary members
-        return self[key]
-    def __delattr__(self, key : str):
-        """ Equyivalent to del self[key] """
-        if key[:2] == "__": raise AttributeError(key) # you cannot treat private members as dictionary members
-        del self[key]
-    def __setattr__(self, key : str, value):
-        """ Equivalent to self[key] = value """
-        if key[:2] == "__":
-            return dict.__setattr__(self, key, value)
-        if isinstance(value,types.FunctionType):
-            # bind function to this object
-            value = types.MethodType(value,self)
-        elif isinstance(value,types.MethodType):
-            # re-point the method to the current instance
-            value = types.MethodType(value.__func__,self)
-        self[key] = value
-    def __call__(self, key : str, *default):
-        """ Equivalent of self.get(key,default) """
-        if len(default) > 1:
-            raise NotImplementedError("Cannot pass more than one default parameter.")
-        return self.get(key,default[0]) if len(default) == 1 else  self.get(key)
-
-    def as_field(self) -> Field:
-        """
-        Returns a PrettyDictField wrapper around self for use in dataclasses
-        See PrettyDictField documentation for an example
-        """
-        return PrettyDictField(self)
-        
-class PrettyOrderedDict(OrderedDict):
-    """
-    Ordered dictionary which allows accessing its members with member notation, e.g.        
-        pdct = PrettyDict()
-        pdct.x = 1
-        x = pdct.x
-        
-    Functions will be made members, i.e the following works as expected
-        def mult_x(self, a):
-            return self.x * a
-        pdct.mult_x = mult_x
-        pdct.mult_x(2) --> 2
-        
-    To assign a static member use []:
-        def mult(a,b):
-            return a*b
-        pdct['mult'] = mult
-        pdct.mult(1,3) --> 3        
-
-    IMPORTANT
-    Attributes starting with '__' are handled as standard attributes.
-    In other words, 
-        pdct = PrettyOrderedDict()
-        pdct.__x = 1
-        _ = pdct['__x']   <- throws an exception
-    This allows re-use of general operator handling.        
-    """
-
-    def __getattr__(self, key : str):
-        """ Equyivalent to self[key] """
-        if key[:2] == "__": raise AttributeError(key) # you cannot treat private members as dictionary members
-        return self[key]
-    def __delattr__(self, key : str):
-        """ Equyivalent to del self[key] """
-        if key[:2] == "__": raise AttributeError(key) # you cannot treat private members as dictionary members
-        del self[key]
-    def __setattr__(self, key : str, value):
-        """ Equivalent to self[key] = value """
-        if key[:2] == "__":
-            return OrderedDict.__setattr__(self, key, value)
-        if isinstance(value,types.FunctionType):
-            # bind function to this object
-            value = types.MethodType(value,self)
-        elif isinstance(value,types.MethodType):
-            # re-point the method to the current instance
-            value = types.MethodType(value.__func__,self)
-        self[key] = value
-    def __call__(self, key : str, *default):
-        """ Equivalent of self.get(key,default) """
-        if len(default) > 1:
-            raise NotImplementedError("Cannot pass more than one default parameter.")
-        return self.get(key,default[0]) if len(default) == 1 else  self.get(key)
-
-    # pickling    
-    def __getstate__(self):
-        """ Return state to pickle """
-        return self.__dict__
-    def __setstate__(self, state):
-        """ Restore pickle """
-        self.__dict__.update(state)
-    
-    def as_field(self) -> Field:
-        """
-        Returns a PrettyDictField wrapper around 'self' for use in dataclasses
-        See PrettyDictField documentation for an example
-        """
-        return PrettyDictField(self)
-
-    @property
-    def at_pos(self):
-        """
-        Element access
-        
-        at_pos[position] returns an element or elements at an ordinal position.
-            It returns a single element if 'position' refers to only one field.
-            If 'position' is a slice then the respecitve list of fields is returned
-            
-        at_pos[position] = item assigns an item or an ordinal position
-            If 'position' refers to a single element, 'item' must be that item
-            If 'position' is a slice then 'item' must resolve to a list of the required size.
-            
-        Key access
-        
-        at_pos.keys[position] returns the key or keys at 'position'
-        
-        at_pos.items[position] returns the tuple (key, element) or a list thereof for `position`            
-        """
-        class Access:
-            """ 
-            Wrapper object to allow index access for at_pos
-            """
-            def __init__(self):
-                self.__keys = None
-            
-            def __getitem__(_, position):
-                key = _.keys[position]
-                return self[key] if not isinstance(key,list) else [ self[k] for k in key ]
-            def __setitem__(_, position, item ):
-                key = _.keys[position]
-                if not isinstance(key,list):
-                    self[key] = item
-                else:
-                    for k, i in zip(key, item):
-                        self[k] = i
-            @property
-            def keys(_) -> list:
-                """ Returns the list of keys of the original dictionary """
-                if _.__keys is None:
-                    _.__keys = list(self.keys())
-                return _.__keys
-            @property
-            def items(_) -> list:
-                """ Returns the list of keys of the original dictionary """
-                class ItemAccess(object):
-                    def __getitem__(_x, position):
-                        key = _.keys[position]
-                        return (key, self[key]) if not isinstance(key,list) else [ (k,self[k]) for k in key ]                
-                return ItemAccess()
-                
-        return Access()
-
-    @property
-    def key_at_pos(self) -> list:
-        """
-        key_at_pos returns the list of keys, hence key_at_pos[i] returns the ith key
-        """
-        return list(self)
-
-    @property
-    def item_at_pos(self) -> list:
-        """
-        key_at_pos returns the list of keys, hence key_at_pos[i] returns the ith key
-        """
-        return list(self)
-    
-pdct = PrettyOrderedDict
-    
-class BETA_PrettySortedDict(SortedDict):
-    """
-    *NOT WORKING WELL*
-    Sorted dictionary which allows accessing its members with member notation, e.g.        
-        pdct = PrettyDict()
-        pdct.x = 1
-        x = pdct.x
-        
-    Functions will be made members, i.e the following works as expected
-        def mult_x(self, a):
-            return self.x * a
-        pdct.mult_x = mult_x
-        pdct.mult_x(2) --> 2
-        
-    To assign a static member use []:
-        def mult(a,b):
-            return a*b
-        pdct['mult'] = mult
-        pdct.mult(1,3) --> 3       
-        
-    IMPORTANT
-    Attributes starting with '_' (one underscore) are handled as standard attributes.
-    In other words, 
-        pdct = PrettyOrderedDict()
-        pdct._x = 1
-        _ = pdct['_x']   <- throws an exception
-    This allows re-use of general operator handling.   
-    The reason the sorted class disallow '_' (as opposed to the other two classes who merely disallow '__')     
-    is that SortedDict() uses protected members.
-    """
-
-    def __getattr__(self, key : str):
-        """ Equyivalent to self[key] """
-        if key[:1] == "_": raise AttributeError(key) # you cannot treat protected or private members as dictionary members
-        return self[key]
-    def __delattr__(self, key : str):
-        """ Equyivalent to del self[key] """
-        if key[:2] == "__": raise AttributeError(key) # you cannot treat private members as dictionary members
-        del self[key]
-    def __setattr__(self, key : str, value):
-        """ Equivalent to self[key] = value """
-        if key[:1] == "_":
-            return SortedDict.__setattr__(self, key, value)
-        if isinstance(value,types.FunctionType):
-            # bind function to this object
-            value = types.MethodType(value,self)
-        elif isinstance(value,types.MethodType):
-            # re-point the method to the current instance
-            value = types.MethodType(value.__func__,self)
-        self[key] = value
-    def __call__(self, key : str, *default):
-        """ Equivalent of self.get(key,default) """
-        if len(default) > 1:
-            raise NotImplementedError("Cannot pass more than one default parameter.")
-        return self.get(key,default[0]) if len(default) == 1 else  self.get(key)
-    
-class PrettyDictField(object):
-    """
-    Simplististc 'read only' wrapper for PrettyOrderedDict objects.
-    Useful for Flax
-
-        import dataclasses as dataclasses
-        import jax.numpy as jnp
-        import jax as jax
-        from options.cdxbasics.config import Config, ConfigField
-        import types as types
-        
-        class A( nn.Module ):
-            pdct : PrettyOrderedDictField = PrettyOrderedDictField.Field()
-        
-            def setup(self):
-                self.dense = nn.Dense(1)
-        
-            def __call__(self, x):
-                a = self.pdct.a
-                return self.dense(x)*a
-        
-        r = PrettyOrderedDict(a=1.)
-        a = A( r.as_field() )
-        
-        key1, key2 = jax.random.split(jax.random.key(0))
-        x = jnp.zeros((10,10))
-        param = a.init( key1, x )
-        y = a.apply( param, x )
-        
-    The class will traverse pretty dictionaries of pretty dictionaries correctly.
-    However, it has some limitations as it does not handle custom lists of pretty dicts.
-    """
-    def __init__(self, pdct : PrettyOrderedDict = None, **kwargs):
-        """ Initialize with an input dictionary and potential overwrites """
-        if not pdct is None:
-            if type(pdct).__name__ == type(self).__name__ and len(kwargs) == 0:
-                # copy
-                self.__pdct = PrettyOrderedDict( pdct.__pdct )
-                return
-            if not isinstance(pdct, Mapping): raise ValueError("'pdct' must be a Mapping")
-            self.__pdct = PrettyOrderedDict(pdct)
-            self.__pdct.update(kwargs)
-        else:
-            self.__pdct = PrettyOrderedDict(**kwargs) 
-        def rec(x):
-            for k, v in x.items():
-                if isinstance(v, (PrettyDict, PrettyOrderedDict)):
-                    x[k] = PrettyDictField(v)
-                elif isinstance(v, Mapping):
-                    rec(v)
-        rec(self.__pdct)
-            
-    def as_dict(self) -> PrettyOrderedDict:
-        """ Return copy of underlying dictionary """
-        return PrettyOrderedDict( self.__pdct )
-
-    def as_field(self) -> Field:
-        """
-        Returns a PrettyDictField wrapper around self for use in dataclasse
-        This function makes a (shallow enough) copy of the current field.
-        It is present so iterative applications of as_field() are convenient.        
-        """
-        return PrettyDictField(self)
-            
-    @staticmethod
-    def default():
-        return PrettyDictField()
-    
-    @staticmethod
-    def Field( default : PrettyOrderedDict = None, **kwargs):
-        """
-        Returns a dataclasses.field for PrettyDictField
-        """
-        if default is None and len(kwargs) == 0:
-            return dataclasses.field( default_factory=PrettyDictField )
-        
-        if not default is None:
-            default.upate(kwargs)
-        else:
-            default = kwargs
-        def factory():
-            return PrettyDictField(default)
-        return dataclasses.field( default_factory=factory )
-
-    # mimic the underlying dictionary
-    # -------------------------------
-    
-    def __getattr__(self, key):
-        if key[:2] == "__":
-            return object.__getattr__(self,key)
-        return self.__pdct.__getattr__(key)
-    def __getitem__(self, key):
-        return self.__pdct[key]
-    def __call__(self, *kargs, **kwargs):
-        return self.__pdct(*kargs, **kwargs)
-    def __eq__(self, other):
-        if type(other).__name__ == "PrettyOrderedDict":
-            return self.__pdct == other
-        else:
-            return self.__pdct == other.pdct
-    def keys(self):
-        return self.__pdct.keys()
-    def items(self):
-        return self.__pdct.items()
-    def values(self):
-        return self.__pdct.values()
-    def __hash__(self):
-        h = 0
-        for k, v in self.items():
-            h ^= hash(k) ^ hash(v)
-        return h
-    def __iter__(self):
-        return self.__pdct.__iter__()
-    def __contains__(self, key):
-        return self.__pdct.__contains__(key)
-    def __len__(self):
-        return self.__pdct.__len__()
-    def __str__(self):
-        return self.__pdct.__str__()
-    def __repr__(self):
-        return self.__pdct.__repr__()
-