cdxcore 0.1.14__py3-none-any.whl → 0.1.15__py3-none-any.whl

cdxcore/dynaplot.py

@@ -1,17 +1,17 @@
 """
-dynaplot
-Dynamic matplotlib in jupyer notebooks
+Overview
+--------
 
-    from dynaplot import figure
+Basic utilities for Python such as type management, formatting, some trivial timers.
+
+Import
+------
+.. code-block:: python
+
+    import cdxcore.util as util
     
-    fig = figure()
-    ax = fig.add_subplot()
-    ax.plot(x,y)
-    ax = fig.add_subplot()
-    ax.plot(x,z)
-    fig.close()
-
-Hans Buehler 2022
+Documentation
+-------------
 """
 import matplotlib.pyplot as plt
 from matplotlib.gridspec import GridSpec#NOQA
@@ -22,260 +22,10 @@ from IPython import display
 import io as io
 import gc as gc
 import types as types
-import numpy as np
-from .deferred import Deferred
-from .util import fmt as txtfmt
 from collections.abc import Collection
-import warnings as warnings
-
-def error( text, *args, exception = RuntimeError, **kwargs ):
-    raise exception( txtfmt(text, *args, **kwargs) )
-def verify( cond, text, *args, exception = RuntimeError, **kwargs ):
-    if not cond:
-        error( text, *args, **kwargs, exception=exception )
-def warn( text, *args, warning=warnings.RuntimeWarning, stack_level=1, **kwargs ):    
-    warnings.warn( txtfmt(text, *args, **kwargs), warning, stack_level=stack_level ) 
-def warn_if( cond, text, *args, warning=warnings.RuntimeWarning, stack_level=1, **kwargs ):    
-    if cond:
-        warn( text, *args, warning=warning, stack_level=stack_level, **kwargs )
-
-class AutoLimits( object ):
-    """
-    Max/Min limit manger for dynamic figures.
-
-    limits = MinMaxLimit( 0.05, 0.95 )
-    ax.add_subplot( x,y ,.. )
-    limits.update(x, y)
-    ax.add_subplot( x,z,.. )
-    limits.update(x, z)
-    limits.set_lims(ax)
-    """
-
-    def __init__(self, low_quantile, high_quantile, min_length : int = 10, lookback : int = None ):
-        """
-        Initialize MinMaxLimit.
-
-        Parameters
-        ----------
-            low_quantile : float
-                Lower quantile to use for computing a 'min' y value. Set to 0 to use 'min'.
-            high_quantile : float
-                Higher quantile to use for computing a 'min' y value. Set to 1 to use 'max'.
-            min_length : int
-                Minimum length data must have to use quantile(). If less data is presented,
-                use min/max, respectively.
-            lookback : int
-                How many steps to lookback for any calculation. None to use all steps
-        """
-
-        verify( low_quantile >=0., "'low_quantile' must not be negative", exception=ValueError )
-        verify( high_quantile <=1., "'high_quantile' must not exceed 1", exception=ValueError )
-        verify( low_quantile<=high_quantile, "'low_quantile' not exceed 'high_quantile'", exception=ValueError )
-        self.lo_q = low_quantile
-        self.hi_q = high_quantile
-        self.min_length = int(min_length)
-        self.lookback = int(lookback) if not lookback is None else None
-        self.max_y = None
-        self.min_y = None
-        self.min_x = None
-        self.max_x = None
-
-    def update(self, *args, axis=None ):
-        """
-        Add a data set to the min/max calc
-
-        If the x axis is ordinal first dimension of 'y':
-            update(y, axis=axis )
-            In this case x = np.linspace(1,y.shape[0],y.shape[0])
-
-        Specifcy x axis 
-            update(x, y, axis=axis )
-
-        Parameters
-        ----------
-            *args:
-                Either y or x,y
-            axis: 
-                along which axis to compute min/max/quantiles
-        """
-        assert len(args) in [1,2], ("'args' must be 1 or 2", len(args))
-
-        y = args[-1]
-        x = args[0] if len(args) > 1 else None
-
-        if len(y) == 0:
-            return
-        if axis is None:
-            axis  = None if len(y.shape) <= 1 else tuple(list(y.shape)[1])
-
-        y_len = y.shape[0]
-        if not self.lookback is None:
-            y = y[-self.lookback:,...]
-            x = x[-self.lookback:,...] if not x is None else None
-            
-        min_y = np.min( np.quantile( y, self.lo_q, axis=axis ) ) if self.lo_q > 0. and len(y) > self.min_length else np.min( y )
-        max_y = np.max( np.quantile( y, self.hi_q, axis=axis ) ) if self.hi_q < 1. and len(y) > self.min_length else np.max( y )
-        assert min_y <= max_y, ("Internal error", min_y, max_y, y)
-        self.min_y = min_y if self.min_y is None else min( self.min_y, min_y )
-        self.max_y = max_y if self.max_y is None else max( self.max_y, max_y )
-
-        if x is None:
-            self.min_x  = 1
-            self.max_x  = y_len if self.max_x is None else max( y_len, self.max_x )
-        else:
-            min_        = np.min( x )
-            max_        = np.max( x )
-            self.min_x  = min_ if self.max_x is None else min( self.min_x, min_ )
-            self.max_x  = max_ if self.max_x is None else max( self.max_x, max_ )
-
-        return self
-            
-    def set( self, *, min_x = None, max_x = None,
-                      min_y = None, max_y = None ) -> type:
-        """
-        Overwrite any of the extrema.
-        Imposing an extrema also sets the other side if this would violate the requrest eg if min_x is set the function also floors self.max_x at min_x
-        Returns 'self.'
-        """
-        verify( min_x is None or max_x is None or min_x <= max_x, "'min_x' and 'max_'x are in wrong order", min_x, max_x, exception=ValueError )
-        if not min_x is None:
-            self.min_x = min_x
-            self.max_x = min( self.max_x, min_x )
-        if not max_x is None:
-            self.min_x = max( self.min_x, max_x )
-            self.max_x = max_x
-
-        verify( min_y is None or max_y is None or min_y <= max_y, "'min_y' and 'max_'x are in wrong order", min_y, max_y, exception=ValueError )
-        if not min_y is None:
-            self.min_y = min_y
-            self.max_y = min( self.max_y, min_y )
-        if not max_y is None:
-            self.min_y = max( self.min_y, max_y )
-            self.max_y = max_y
-        return self
-
-    def bound( self, *,  min_x_at_least = None, max_x_at_most = None,  # <= boundary limits
-                         min_y_at_least = None, max_y_at_most = None,
-                         ):
-        """
-        Bound extrema
-        """
-        verify( min_x_at_least is None or max_x_at_most is None or min_x_at_least <= max_x_at_most, "'min_x_at_least' and 'max_x_at_most'x are in wrong order", min_x_at_least, max_x_at_most, exception=ValueError )
-        if not min_x_at_least is None:
-            self.min_x = max( self.min_x, min_x_at_least )
-            self.max_x = max( self.max_x, min_x_at_least )
-        if not max_x_at_most is None:
-            self.min_x = min( self.min_x, max_x_at_most )
-            self.max_x = min( self.max_x, max_x_at_most )
-            
-        verify( min_y_at_least is None or max_y_at_most is None or min_y_at_least <= max_y_at_most, "'min_y_at_least' and 'max_y_at_most'x are in wrong order", min_y_at_least, max_y_at_most, exception=ValueError )
-        if not min_y_at_least is None:
-            self.min_y = max( self.min_y, min_y_at_least )
-            self.max_y = max( self.max_y, min_y_at_least )
-        if not max_y_at_most is None:
-            self.min_y = min( self.min_y, max_y_at_most )
-            self.max_y = min( self.max_y, max_y_at_most )
-        return self
-
-    def set_a_lim( self, ax,*, is_x,
-                               min_d, 
-                               rspace,
-                               min_set = None,
-                               max_set = None,
-                               min_at_least = None,
-                               max_at_most = None ):
-        """ Utility function """
-        min_ = self.min_x if is_x else self.min_y
-        max_ = self.max_x if is_x else self.max_y
-        ax_scale = (ax.get_xaxis() if is_x else ax.get_yaxis()).get_scale()
-        label = "x" if is_x else "y"
-        f = ax.set_xlim if is_x else ax.set_ylim
-        
-        if min_ is None or max_ is None:
-            warn( "No data recevied yet; ignoring call" )
-            return
-        assert min_ <= max_, ("Internal error (1): min and max are not in order", label, min_, max_)
-
-        verify( min_set is None or max_set is None or min_set <= max_set, "'min_set_%s' exceeds 'max_set_%s': found %g and %g, respectively", label, label, min_set, max_set, exception=RuntimeError )
-        verify( min_at_least is None or max_at_most is None or min_at_least <= max_at_most, "'min_at_least_%s' exceeds 'max_at_most_%s': found %g and %g, respectively", label, label, min_at_least, max_at_most, exception=RuntimeError )
-
-        if not min_set is None:
-            min_ = min_set
-            max_ = max(min_set, max_)
-        if not max_set is None:
-            min_ = min(min_, max_set)
-            max_ = max_set
-        if not min_at_least is None:
-            min_ = max( min_, min_at_least )
-            max_ = max( max_, min_at_least )
-        if not max_at_most is None:
-            min_ = min( min_, max_at_most )
-            max_ = min( max_, max_at_most )
-        
-        assert min_ <= max_, ("Internal error (2): min and max are not in order", label, min_, max_)
-
-        if isinstance( max_, int ):
-            verify( ax_scale == "linear", "Only 'linear' %s axis supported for integer based %s coordinates; found '%s'", label, label, ax_scale, exception=AttributeError )
-            max_ = max(max_, min_+1)
-            f( min_, max_ )
-        else:
-            d = max( max_-min_, min_d ) * rspace
-            if ax_scale == "linear":
-                f( min_ - d, max_ + d )
-            else:
-                verify( ax_scale == "log", "Only 'linear' and 'log' %s axis scales are supported; found '%s'", label, ax_scale, exception=AttributeError )
-                verify( min_ > 0., "Minimum for 'log' %s axis must be positive; found %g", label, min_)
-                rdx = np.exp( d )
-                f( min_ / rdx, max_ * rdx )
-        return self
-
-    def set_ylim(self, ax, *, min_dy : float = 1E-4, yrspace : float = 0.001, min_set_y = None, max_set_y = None, min_y_at_least = None, max_y_at_most = None ):
-        """
-        Set x limits  for 'ax'. See set_lims()
-        """
-        return self.set_a_lim( ax, is_x=False, min_d=min_dy, rspace=yrspace, min_set=min_set_y, max_set=max_set_y, min_at_least=min_y_at_least, max_at_most=max_y_at_most )
-        
-    def set_xlim(self, ax, *, min_dx : float = 1E-4, xrspace : float = 0.001, min_set_x = None, max_set_x = None, min_x_at_least = None, max_x_at_most = None ):
-        """
-        Set x limits  for 'ax'. See set_lims()
-        """
-        return self.set_a_lim( ax, is_x=True, min_d=min_dx, rspace=xrspace, min_set=min_set_x, max_set=max_set_x, min_at_least=min_x_at_least, max_at_most=max_x_at_most )
-
-    def set_lims( self, ax, *, x : bool = True, y : bool = True,
-                               min_dx : float = 1E-4, min_dy = 1E-4, xrspace = 0.001, yrspace = 0.001,
-                               min_set_x = None, max_set_x = None, min_x_at_least = None, max_x_at_most = None,
-                               min_set_y = None, max_set_y = None, min_y_at_least = None, max_y_at_most = None):
-        """
-        Set x and/or y limits  for 'ax'.
-
-        For example for the x axis: let
-            dx := max( max_x - min_x, min_dx )*xrspace
-
-        For linear axes:
-            set_xlim( min_x - dy, max_x + dx )
-
-        For logarithmic axes
-            set_xlim( min_x * exp(-dx), max_x * exp(dx) )
-            
-        Parameters
-        ----------
-            ax :
-                matplotlib plot
-            x, y: bool
-                Whether to apply x and y limits.
-            min_dx, min_dy:
-                Minimum distance
-            xrspace, yspace:
-                How much of the distance to add to left and right.
-                The actual distance added to max_x is dx:=max(min_dx,max_x-min_x)*xrspace
-            min_set_x, max_set_x, min_set_y, max_set_y:
-                If not None, set the respective min/max accordingly.
-            min_x_at_least, max_x_at_most, min_y_at_least, max_y_at_most:
-                If not None, bound the respecitve min/max accordingly.
-        """
-        if x: self.set_xlim(ax, min_dx=min_dx, xrspace=xrspace, min_set_x=min_set_x, max_set_x=max_set_x, min_x_at_least=min_x_at_least, max_x_at_most=max_x_at_most)
-        if y: self.set_ylim(ax, min_dy=min_dy, yrspace=yrspace, min_set_y=min_set_y, max_set_y=max_set_y, min_y_at_least=min_y_at_least, max_y_at_most=max_y_at_most)
-        return self
+from .deferred import Deferred
+from .util import verify, warn
+from .dynaplotlimits import AutoLimits
 
 class DynamicAx(Deferred):
     """

cdxcore/dynaplotlimits.py

@@ -0,0 +1,245 @@
+"""
+Beta Version Do Not Use
+-----------------------
+"""
+from matplotlib.gridspec import GridSpec#NOQA
+import numpy as np
+from .err import verify, warn
+
+class AutoLimits( object ):
+    """
+    Max/Min limit manger for dynamic figures.
+
+    limits = MinMaxLimit( 0.05, 0.95 )
+    ax.add_subplot( x,y ,.. )
+    limits.update(x, y)
+    ax.add_subplot( x,z,.. )
+    limits.update(x, z)
+    limits.set_lims(ax)
+    """
+
+    def __init__(self, low_quantile, high_quantile, min_length : int = 10, lookback : int = None ):
+        """
+        Initialize MinMaxLimit.
+
+        Parameters
+        ----------
+            low_quantile : float
+                Lower quantile to use for computing a 'min' y value. Set to 0 to use 'min'.
+            high_quantile : float
+                Higher quantile to use for computing a 'min' y value. Set to 1 to use 'max'.
+            min_length : int
+                Minimum length data must have to use quantile(). If less data is presented,
+                use min/max, respectively.
+            lookback : int
+                How many steps to lookback for any calculation. None to use all steps
+        """
+
+        verify( low_quantile >=0., "'low_quantile' must not be negative", exception=ValueError )
+        verify( high_quantile <=1., "'high_quantile' must not exceed 1", exception=ValueError )
+        verify( low_quantile<=high_quantile, "'low_quantile' not exceed 'high_quantile'", exception=ValueError )
+        self.lo_q = low_quantile
+        self.hi_q = high_quantile
+        self.min_length = int(min_length)
+        self.lookback = int(lookback) if not lookback is None else None
+        self.max_y = None
+        self.min_y = None
+        self.min_x = None
+        self.max_x = None
+
+    def update(self, *args, axis=None ):
+        """
+        Add a data set to the min/max calc
+
+        If the x axis is ordinal first dimension of 'y':
+            update(y, axis=axis )
+            In this case x = np.linspace(1,y.shape[0],y.shape[0])
+
+        Specifcy x axis 
+            update(x, y, axis=axis )
+
+        Parameters
+        ----------
+            *args:
+                Either y or x,y
+            axis: 
+                along which axis to compute min/max/quantiles
+        """
+        assert len(args) in [1,2], ("'args' must be 1 or 2", len(args))
+
+        y = args[-1]
+        x = args[0] if len(args) > 1 else None
+
+        if len(y) == 0:
+            return
+        if axis is None:
+            axis  = None if len(y.shape) <= 1 else tuple(list(y.shape)[1])
+
+        y_len = y.shape[0]
+        if not self.lookback is None:
+            y = y[-self.lookback:,...]
+            x = x[-self.lookback:,...] if not x is None else None
+            
+        min_y = np.min( np.quantile( y, self.lo_q, axis=axis ) ) if self.lo_q > 0. and len(y) > self.min_length else np.min( y )
+        max_y = np.max( np.quantile( y, self.hi_q, axis=axis ) ) if self.hi_q < 1. and len(y) > self.min_length else np.max( y )
+        assert min_y <= max_y, ("Internal error", min_y, max_y, y)
+        self.min_y = min_y if self.min_y is None else min( self.min_y, min_y )
+        self.max_y = max_y if self.max_y is None else max( self.max_y, max_y )
+
+        if x is None:
+            self.min_x  = 1
+            self.max_x  = y_len if self.max_x is None else max( y_len, self.max_x )
+        else:
+            min_        = np.min( x )
+            max_        = np.max( x )
+            self.min_x  = min_ if self.max_x is None else min( self.min_x, min_ )
+            self.max_x  = max_ if self.max_x is None else max( self.max_x, max_ )
+
+        return self
+            
+    def set( self, *, min_x = None, max_x = None,
+                      min_y = None, max_y = None ) -> type:
+        """
+        Overwrite any of the extrema.
+        Imposing an extrema also sets the other side if this would violate the requrest eg if min_x is set the function also floors self.max_x at min_x
+        Returns 'self.'
+        """
+        verify( min_x is None or max_x is None or min_x <= max_x, "'min_x' and 'max_'x are in wrong order", min_x, max_x, exception=ValueError )
+        if not min_x is None:
+            self.min_x = min_x
+            self.max_x = min( self.max_x, min_x )
+        if not max_x is None:
+            self.min_x = max( self.min_x, max_x )
+            self.max_x = max_x
+
+        verify( min_y is None or max_y is None or min_y <= max_y, "'min_y' and 'max_'x are in wrong order", min_y, max_y, exception=ValueError )
+        if not min_y is None:
+            self.min_y = min_y
+            self.max_y = min( self.max_y, min_y )
+        if not max_y is None:
+            self.min_y = max( self.min_y, max_y )
+            self.max_y = max_y
+        return self
+
+    def bound( self, *,  min_x_at_least = None, max_x_at_most = None,  # <= boundary limits
+                         min_y_at_least = None, max_y_at_most = None,
+                         ):
+        """
+        Bound extrema
+        """
+        verify( min_x_at_least is None or max_x_at_most is None or min_x_at_least <= max_x_at_most, "'min_x_at_least' and 'max_x_at_most'x are in wrong order", min_x_at_least, max_x_at_most, exception=ValueError )
+        if not min_x_at_least is None:
+            self.min_x = max( self.min_x, min_x_at_least )
+            self.max_x = max( self.max_x, min_x_at_least )
+        if not max_x_at_most is None:
+            self.min_x = min( self.min_x, max_x_at_most )
+            self.max_x = min( self.max_x, max_x_at_most )
+            
+        verify( min_y_at_least is None or max_y_at_most is None or min_y_at_least <= max_y_at_most, "'min_y_at_least' and 'max_y_at_most'x are in wrong order", min_y_at_least, max_y_at_most, exception=ValueError )
+        if not min_y_at_least is None:
+            self.min_y = max( self.min_y, min_y_at_least )
+            self.max_y = max( self.max_y, min_y_at_least )
+        if not max_y_at_most is None:
+            self.min_y = min( self.min_y, max_y_at_most )
+            self.max_y = min( self.max_y, max_y_at_most )
+        return self
+
+    def set_a_lim( self, ax,*, is_x,
+                               min_d, 
+                               rspace,
+                               min_set = None,
+                               max_set = None,
+                               min_at_least = None,
+                               max_at_most = None ):
+        """ Utility function """
+        min_ = self.min_x if is_x else self.min_y
+        max_ = self.max_x if is_x else self.max_y
+        ax_scale = (ax.get_xaxis() if is_x else ax.get_yaxis()).get_scale()
+        label = "x" if is_x else "y"
+        f = ax.set_xlim if is_x else ax.set_ylim
+        
+        if min_ is None or max_ is None:
+            warn( "No data recevied yet; ignoring call" )
+            return
+        assert min_ <= max_, ("Internal error (1): min and max are not in order", label, min_, max_)
+
+        verify( min_set is None or max_set is None or min_set <= max_set, lambda : f"'min_set_{label}' exceeds 'max_set_{label}': found {min_set:.4g} and {max_set:.4g}, respectively", exception=RuntimeError )
+        verify( min_at_least is None or max_at_most is None or min_at_least <= max_at_most, lambda : f"'min_at_least_{label}' exceeds 'max_at_most_{label}': found {min_at_least:.4g} and {max_at_most:.4g}, respectively", exception=RuntimeError )
+
+        if not min_set is None:
+            min_ = min_set
+            max_ = max(min_set, max_)
+        if not max_set is None:
+            min_ = min(min_, max_set)
+            max_ = max_set
+        if not min_at_least is None:
+            min_ = max( min_, min_at_least )
+            max_ = max( max_, min_at_least )
+        if not max_at_most is None:
+            min_ = min( min_, max_at_most )
+            max_ = min( max_, max_at_most )
+        
+        assert min_ <= max_, ("Internal error (2): min and max are not in order", label, min_, max_)
+
+        if isinstance( max_, int ):
+            verify( ax_scale == "linear", lambda : f"Only 'linear' {label} axis supported for integer based {label} coordinates; found '{ax_scale}'", exception=AttributeError )
+            max_ = max(max_, min_+1)
+            f( min_, max_ )
+        else:
+            d = max( max_-min_, min_d ) * rspace
+            if ax_scale == "linear":
+                f( min_ - d, max_ + d )
+            else:
+                verify( ax_scale == "log", lambda : f"Only 'linear' and 'log' {label} axis scales are supported; found '{ax_scale}'", exception=AttributeError )
+                verify( min_ > 0., lambda : f"Minimum for 'log' {label} axis must be positive; found {min_:.4g}", exception=ValueError )
+                rdx = np.exp( d )
+                f( min_ / rdx, max_ * rdx )
+        return self
+
+    def set_ylim(self, ax, *, min_dy : float = 1E-4, yrspace : float = 0.001, min_set_y = None, max_set_y = None, min_y_at_least = None, max_y_at_most = None ):
+        """
+        Set x limits  for 'ax'. See set_lims()
+        """
+        return self.set_a_lim( ax, is_x=False, min_d=min_dy, rspace=yrspace, min_set=min_set_y, max_set=max_set_y, min_at_least=min_y_at_least, max_at_most=max_y_at_most )
+        
+    def set_xlim(self, ax, *, min_dx : float = 1E-4, xrspace : float = 0.001, min_set_x = None, max_set_x = None, min_x_at_least = None, max_x_at_most = None ):
+        """
+        Set x limits  for 'ax'. See set_lims()
+        """
+        return self.set_a_lim( ax, is_x=True, min_d=min_dx, rspace=xrspace, min_set=min_set_x, max_set=max_set_x, min_at_least=min_x_at_least, max_at_most=max_x_at_most )
+
+    def set_lims( self, ax, *, x : bool = True, y : bool = True,
+                               min_dx : float = 1E-4, min_dy = 1E-4, xrspace = 0.001, yrspace = 0.001,
+                               min_set_x = None, max_set_x = None, min_x_at_least = None, max_x_at_most = None,
+                               min_set_y = None, max_set_y = None, min_y_at_least = None, max_y_at_most = None):
+        """
+        Set x and/or y limits  for 'ax'.
+
+        For example for the x axis: let
+            dx := max( max_x - min_x, min_dx )*xrspace
+
+        For linear axes:
+            set_xlim( min_x - dy, max_x + dx )
+
+        For logarithmic axes
+            set_xlim( min_x * exp(-dx), max_x * exp(dx) )
+            
+        Parameters
+        ----------
+            ax :
+                matplotlib plot
+            x, y: bool
+                Whether to apply x and y limits.
+            min_dx, min_dy:
+                Minimum distance
+            xrspace, yspace:
+                How much of the distance to add to left and right.
+                The actual distance added to max_x is dx:=max(min_dx,max_x-min_x)*xrspace
+            min_set_x, max_set_x, min_set_y, max_set_y:
+                If not None, set the respective min/max accordingly.
+            min_x_at_least, max_x_at_most, min_y_at_least, max_y_at_most:
+                If not None, bound the respecitve min/max accordingly.
+        """
+        if x: self.set_xlim(ax, min_dx=min_dx, xrspace=xrspace, min_set_x=min_set_x, max_set_x=max_set_x, min_x_at_least=min_x_at_least, max_x_at_most=max_x_at_most)
+        if y: self.set_ylim(ax, min_dy=min_dy, yrspace=yrspace, min_set_y=min_set_y, max_set_y=max_set_y, min_y_at_least=min_y_at_least, max_y_at_most=max_y_at_most)
+        return self

cdxcore/util.py

@@ -935,13 +935,13 @@ class TrackTiming(object):
         return self._tracked
 
     def summary(self, fmat : str = "%(text)s: %(fmt_seconds)s", jn_fmt : str = ", " ) -> str:
-        """
+        r"""
         Generate summary string by applying some formatting
 
         Parameters
         ----------
         fmat : str, optional
-            Format string using ``%()``. Arguments are ```text``, ``seconds`` (as int) and ``fmt_seconds`` (a string).
+            Format string using ``%()``. Arguments are ``text``, ``seconds`` (as int) and ``fmt_seconds`` (a string).
             
             Default is ``"%(text)s: %(fmt_seconds)s"``.
 
@@ -997,7 +997,7 @@ class Timer(object):
     
     def interval_test( self, interval : float ) -> bool:
         r"""
-        Tests if `interval` seconds have passed.
+        Tests if ``interval`` seconds have passed.
         If yes, reset timer and return True. Otherwise return False.
         
         Usage::
@@ -1006,8 +1006,8 @@ class Timer(object):
             tme = Timer()
             for i in range(n):
                 if tme.test_dt_seconds(2.):
-                    print(f"\r{i+1}/{n} done. Time taken so far {tme}.", end='', flush=True)
-            print("\rDone. This took {tme}.")
+                    print(f"\\r{i+1}/{n} done. Time taken so far {tme}.", end='', flush=True)
+            print("\\rDone. This took {tme}.")
 
         """
         if interval is None:

cdxcore/version.py

@@ -1,4 +1,4 @@
-"""
+r"""
 Overview
 --------
 
@@ -117,12 +117,12 @@ Decorated Function Information
 A decorated function or class has a member ``version`` of type :class:`cdxcore.version.Version` which has the following
 key properties:
 
-* :attr:`cdxcore.version.Version.input`: the input version as defined with :dec:`cdxcore.version.version.
+* :attr:`cdxcore.version.Version.input`: the input version as defined with :dec:`cdxcore.version.version`.
 * :attr:`cdxcore.version.Version.full`: a fully qualified version with all dependent functions and classes in human readable form.
 * :attr:`cdxcore.version.Version.unique_id48`,
   :attr:`cdxcore.version.Version.unique_id64`:
   unique hashes of :attr:`cdxcore.version.Version.full` of 48 or 64 characters,
-  respectively. You can use the function :meth:`cdxcore.version.Version.unique_id
+  respectively. You can use the function :meth:`cdxcore.version.Version.unique_id`
   to compute hash IDs of any length.
 * :attr:`cdxcore.version.Version.dependencies`: a hierarchical list of dependencies for systematic inspection.
 

{cdxcore-0.1.14.dist-info → cdxcore-0.1.15.dist-info}/METADATA

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

{cdxcore-0.1.14.dist-info → cdxcore-0.1.15.dist-info}/RECORD

@@ -1,22 +1,23 @@
-cdxcore/__init__.py,sha256=R9JQzThLS2EKfQZMbocqPtP7h86zUNQQZXyJvd4OfOg,127
+cdxcore/__init__.py,sha256=DDe92gvSbMoVPmYZeQq5stY46fOBgfwbVmoWCwe1P3M,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/crman.py,sha256=D2KE_T5nHi0PdLRiNARHPAy-nidr38BD2dRpj0XHvXM,5760
+cdxcore/deferred.py,sha256=zrMGN9FfDi-0ZJ9SdgNB4C2CeUvjFFoWBSQskFubGlc,40486
+cdxcore/dynaplot.py,sha256=IaAhFPPhs_ag3ptA16ZwY0Z8BX-ogv2WEr--czHxYtI,36578
+cdxcore/dynaplotlimits.py,sha256=YEPUELCbqjvfLtH45VzcXmfKH9_jdGGraM_R2I_KXDU,11530
 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/util.py,sha256=o4J3IY3q2N87ZaUoljAhZroo7co0P2BiGb6JANKeJX4,34201
 cdxcore/verbose.py,sha256=66n9v2TduNWlochcV3mixSqyQzznO_H0LPrDgr9_dEo,30240
-cdxcore/version.py,sha256=m30oI2Ortg44dKSim-sIoeh9PioD1FWsSfVEP5rubhk,27173
-cdxcore-0.1.14.dist-info/licenses/LICENSE,sha256=M-cisgK9kb1bqVRJ7vrCxHcMQQfDxdY3c2YFJJWfNQg,1090
-docs/source/conf.py,sha256=Owctibh5XcSpSNcrpOr3ROIDjoklmFVrMhu8cOSe50o,4180
+cdxcore/version.py,sha256=bEAYXKlDuEVB9mazfaGRldVlpOWobKXZfkT8HrQSDZ4,27176
+cdxcore-0.1.15.dist-info/licenses/LICENSE,sha256=M-cisgK9kb1bqVRJ7vrCxHcMQQfDxdY3c2YFJJWfNQg,1090
+docs/source/conf.py,sha256=uYnpLfkcoaIB4IgrneDIfGwwK6_9T6KTS2k6lI-s4Ww,4038
 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_deferred.py,sha256=I0VNkAzlivefezT8Cgspt_SYb8yfqipJvtQXrNHS0Xs,7930
 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
@@ -25,13 +26,14 @@ tests/test_uniquehash.py,sha256=n6ZCkdBw-iRsyzeAEmrnLK0hJLGH6l_Dtt_KIkSa6KA,2463
 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/deferred-hierarchical.py,sha256=JXzvQa3wiM3S685vdTri2uDBS1jFo7KIljxSUFSVEF4,30714
 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.14.dist-info/METADATA,sha256=uDJxPG9h8DYY-4xTGQxom-eGhC9k-DT4knV_Wt_Ri-c,754
-cdxcore-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cdxcore-0.1.14.dist-info/top_level.txt,sha256=phNSwCyJFe7UP2YMoi8o6ykhotatlIbJHjTp9EHM51k,26
-cdxcore-0.1.14.dist-info/RECORD,,
+cdxcore-0.1.15.dist-info/METADATA,sha256=PoBrfdw__2k-E7vh2E61vsP2XMOARpT9nkUYv0wy-7g,754
+cdxcore-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cdxcore-0.1.15.dist-info/top_level.txt,sha256=phNSwCyJFe7UP2YMoi8o6ykhotatlIbJHjTp9EHM51k,26
+cdxcore-0.1.15.dist-info/RECORD,,