cdxcore 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

cdxcore/__init__.py

@@ -4,4 +4,4 @@ Created on June 2022
 @author: hansb
 """
 
-__version__ = "0.1.26"  # auto-updated by setup.py
+__version__ = "0.1.28"  # auto-updated by setup.py

cdxcore/deferred.py

@@ -180,7 +180,6 @@ from .err import verify
 from. util import qualified_name, fmt_list
 from .verbose import Context
 from collections.abc import Collection, Sequence, Mapping
-import gc as gc
 
 class _ParentDeleted:
     pass
@@ -273,48 +272,7 @@ class Deferred(object):
     ----------
     info : str
         Descriptive name of the usually not-yet-created object deferred actions
-        will act upon.
-        
-    deferred__eq__ : bool, optional
-        If ``False``, the default, the ``__eq__`` operator will not be deferred. That means
-        that you are able to use :func:`cdxcore.deferred.Deferred.Create` and :class:`cdxcore.deferred.Deferred`
-        objects in Python contexts which require ``__eq__``, for example using them in lists.
-            
-        By default this works:
-
-        .. code-block:: python
-
-            a = Create("A")
-            b = Create("B")
-            a in [b]  # -> returns False
-            b in [b]  # -> returns True
-
-        *However* that may also break your deferred semantics as the boolean returned by a deferred operator
-        may differ from the boolean returned by the non-deferred ``__eq__`` operator (e.g. comparison using ``id``).
-
-        Accordingly,
-
-        .. code-block:: python
-
-            a = Create("A",deferred__eq__=True)
-            b = Create("B",deferred__eq__=True)
-            a in [b]
-
-        will raise an error.
-        Note that this will be a :class:`cdxcore.deferred.NotSupportedError` for the attempt
-        to call ``__bool__`` on the
-        deferred ``__eq__`` operator:
-            
-        .. code-block:: python
-
-            NotSupportedError:(
-                '__bool__',
-                "Deferring action `__bool__` for '($A!=$B)' is "\
-                "not possible: '__bool__' must return a 'bool'.")
-        
-        Note that this setting does not affect ``__neq__`` or any other relational opertors.
-        
-        Set to ``True`` to defer ``__eq__``.
+        will act upon.        
     """
     @classmethod
     def Create( cls, info : str ):
@@ -330,10 +288,11 @@ class Deferred(object):
     def __init__(self,     info           : str, *,   
                            action         : str = "",       
                            #     
-                           parent         : type = None,      
+                           parent         : type|None  = None,
+                           base_info      : bool|None = None,
                            # arguments passed to the action  
-                           args           : Collection = None,
-                           kwargs         : Mapping = None,   
+                           args           : Collection|None  = None,
+                           kwargs         : Mapping|None  = None,   
                            ):
         """
         Initialize a deferred action.
@@ -353,8 +312,7 @@ class Deferred(object):
         self._deferred_action         = action              # action code
         self._deferred_parent         = parent
         self._deferred_depth          = parent._deferred_depth+1 if not parent is None else 0
-        self._deferred__eq__          = parent._deferred__eq__ if not parent is None else False
-        self._deferred__hash__ = False
+        self._deferred_base_info      = parent._deferred_base_info if not parent is None else ( base_info if not base_info is None else False )
         self._deferred_args           = [] if args is None else list(args)
         self._deferred_kwargs         = {} if kwargs is None else dict(kwargs)
         self._deferred_live           = None           # once the object exists, it goes here.
@@ -621,7 +579,7 @@ class Deferred(object):
             for _ in sources:
                 s += _+","
             s = s[:-1]
-            verbose.write( f"{self._deferred_info} <= {s}" )
+            verbose.write( lambda : f"{self._deferred_info} <= {s}" )
         else:
             verbose.write( self._deferred_info )
                       
@@ -688,7 +646,6 @@ class Deferred(object):
                 raise e
             
             try:
-                        
                 live  = action( *args, **kwargs )
             except Exception as e:
                 arguments = self._deferred_fmt_args(args,kwargs)
@@ -701,7 +658,7 @@ class Deferred(object):
                 raise e
             del action
        
-        verbose.write(f"{self._deferred_info} -> '{qualified_name(live)}' : {self._deferred_to_str(live)}")
+        verbose.write(lambda : f"{self._deferred_info} -> '{qualified_name(live)}' : {self._deferred_to_str(live)}")
 
         # clear object
         # note that as soon as we write to self._deferred_live we can no longer
@@ -715,7 +672,6 @@ class Deferred(object):
         self._deferred_kwargs = None
         self._deferred_args   = None
         self._deferred_parent = _ParentDeleted()  # None is a valid parent --> choose someting bad
-        gc.collect()
         
         # action        
         self._deferred_was_resolved = True
@@ -755,7 +711,7 @@ class Deferred(object):
         verify( not element is None, lambda : f"You cannot resolve '{self._deferred_info}' with an empty 'element'")
         verbose = Context.quiet if verbose is None else verbose
         
-        verbose.write(f"{self._deferred_info} -> '{qualified_name(element)}' : {self._deferred_to_str(element)}")
+        verbose.write(lambda : f"{self._deferred_info} -> '{qualified_name(element)}' : {self._deferred_to_str(element)}")
         self._deferred_live         = element
         self._deferred_was_resolved = True
 
@@ -764,8 +720,7 @@ class Deferred(object):
             dlevel  = daction._deferred_depth
             daction._deferred_resolve( verbose=verbose(dlevel) )
             del daction 
-            
-        gc.collect()
+
         return element
     
     # Iteration
@@ -810,7 +765,7 @@ class Deferred(object):
                 verify( not fmt is None, lambda : f"Error defining action '{action}' for '{self._deferred_info}': 'fmt' not specified" )
     
                 def label(x):
-                    return x if not isinstance(x, Deferred) else x.__dict__.get('_deferred_info',action)
+                    return self._deferred_to_str(x) if not isinstance(x, Deferred) else x.__dict__.get('_deferred_info',action)
                 arguments           = { f"arg{i}" : label(arg) for i, arg in enumerate(args) }
                 arguments['parent'] = self._deferred_info
                 try:

cdxcore/dynaplot.py

@@ -614,7 +614,8 @@ class DynaFig(_DynaDeferred):
             verify( not 'figsize' in fig_kwargs, "Cannot specify both `figsize` and `fig_size`", exception=ValueError)
             fig_kwargs['figsize'] = fig_size
         
-        _DynaDeferred.__init__(self, f"figure('{str(title)[:20]}')" if not title is None else"figure()" )
+        dyna_title = title if len(title) <= 20 else ( title[:17] + "..." ) if not title is None else None
+        _DynaDeferred.__init__(self, f"figure('{dyna_title}')" if not title is None else "figure()" )
 
     def __str__(self):
         return self.deferred_info[1:]
@@ -953,6 +954,16 @@ class DynaFig(_DynaDeferred):
             ax.remove()
         if render:
             self.render()
+            
+    # context for cleaning up
+    # -----------------------
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, *args, **kwargs):
+        self.close()
+        return False
 
 def figure( title    : str = None, *,
             row_size : int = 5,

cdxcore/subdir.py

@@ -2801,14 +2801,14 @@ class SubDir(object):
     # caching
     # -------
 
-    def cache( self,  version             : str = None , *,
-                      dependencies        : list = None, 
-                      label               : Callable = None,
-                      uid                 : Callable = None,
-                      name                : str = None, 
-                      exclude_args        : list[str] = None,
-                      include_args        : list[str] = None,
-                      exclude_arg_types   : list[type] = None,
+    def cache( self,  version             : str|None = None , *,
+                      dependencies        : list|None = None, 
+                      label               : Callable|None = None,
+                      uid                 : Callable|None = None,
+                      name                : str|None = None, 
+                      exclude_args        : list[str]|None = None,
+                      include_args        : list[str]|None = None,
+                      exclude_arg_types   : list[type]|None = None,
                       version_auto_class  : bool = True):
         """
         Advanced versioned caching for callables.
@@ -3178,9 +3178,13 @@ class SubDir(object):
            :dec:`cdxcore.subdir.SubDir.cache`
            to provide version information at class level. Only version information are provided here.
            
+           You can use :dec:`cdxcore.subdir.SubDir.cache_class` as an alias.
+           
         2) Secondly, decorate ``__init__``. You do not need to specify a version
            for ``__init__`` as its version usually coincides with the version of the class. At ``__init__``
            you define how unique IDs are generated from the parameters passed to object construction.
+           
+           You can use :dec:`cdxcore.subdir.SubDir.cache_init` as an alias.
 
         Simple example:
             
@@ -3190,10 +3194,10 @@ class SubDir(object):
             cache   = SubDir("!/.cache")
             cache.delete_all_content()   # for illustration
             
-            @cache.cache("0.1")
+            @cache.cache_class("0.1")
             class A(object):
                 
-                @cache.cache(exclude_args=['debug'])
+                @cache.cache_init(exclude_args=['debug'])
                 def __init__(self, x, debug):
                     if debug:
                         print("__init__",x)
@@ -3216,10 +3220,10 @@ class SubDir(object):
         
         .. code-block:: python
         
-            @cache.cache("0.1")
+            @cache.cache_class("0.1")
             class A(object):
                 
-                @cache.cache("0.1", id=lambda x, debug: f"A.__init__(x={x})")  # <-- 'self' is not passed to the lambda function; no need to add **_
+                @cache.cache_init(id=lambda x, debug: f"A.__init__(x={x})")  # <-- 'self' is not passed to the lambda function; no need to add **_
                 def __init__(self, x, debug):
                     if debug:
                         print("__init__",x)
@@ -3227,35 +3231,79 @@ class SubDir(object):
 
         Decorating classes with ``__slots__`` does not yet work.
                                     
-        See also
-        ^^^^^^^^
+        Managing Caching Accross a Project
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-        For project-wide use it is usually inconvenient to control caching at the level of a 
+        For project-wide use it is usually convenient to control caching at the level of a 
         project-wide cache root directory.
-        See :class:`cdxcore.subdir.VersionedCacheRoot` for a thin convenience wrapper around a :class:`cdxcore.subdir.SubDir`
+        The classs :class:`cdxcore.subdir.VersionedCacheRoot` is a thin convenience wrapper around a :class:`cdxcore.subdir.SubDir`
         with a :class:`cdxcore.subdir.CacheController`.
         
+        The idea is to have a central file, ``cache.py`` which contains the central root for caching.
+        We recommend using an environment variable to be able to control the location of this directory
+        out side the code. Here is an example with an environment variable ``PROJECT_CACHE_DIR``::
+            
+            # file cache.py
+            
+            from cdxcore.subdir import VersionedCacheRoot
+            import os as os
+                        
+            cache_root = VersionedCacheRoot(
+                               os.getenv("PROJECT_CACHE_DIR", "!/.cache")
+                               )
+
+        In a particular project file, say ``pipeline.py`` create a file-local cache directory
+        and use it::
+            
+            # file pipeline.py
+            
+            from cache import cache_root
+            
+            cache_dir = cache_root("pipeline")
+            
+            @cache_dir.cache("0.1")
+            def f(x):
+                return x+2
+            
+            @cache_dir.cache("0.1", dependencies=[f])
+            def g(x)
+                return f(x)**2
+            
+            # ...
+            
+        In case you have issues with caching you can use the central root directory to turn on tracing 
+        accross your project:
+
+        .. code-block:: python
+           :emphasize-lines: 4
+
+            from cdxcore.verbose import Context
+            cache_root = VersionedCacheRoot(
+                               os.getenv("PROJECT_CACHE_DIR", "!/.cache"),
+                               debug_verbose=Context.all    # turn full traing on
+                            )
+
         Parameters
         ----------
-        version : str, optional
+        version : str | None, default ``None``
             Version of the function.
             
-            * If ``None`` then ``F`` must be decorated with :dec:`cdxcore.version.version`.
-            * If set, the function ``F`` is first decorated with :dec:`cdxcore.version.version`.
+            * If ``None`` then a common `F`` must be decorated manually with :dec:`cdxcore.version.version`.
+            * If set, the function ``F`` is automatically first decorated with :dec:`cdxcore.version.version` for you.
             
-        dependencies : list[type], optional
+        dependencies : list[type] | None, default ``None``
             A list of version dependencies, either by reference or by name.
             See :dec:`cdxcore.version.version` for details on name lookup if strings are used.
         
-        label : str | Callable
-            Specify a human-readable label for the function call given its parameters.
+        label : str | Callable | None, default ``None``
+            Specify a human-readabl label for the function call given its parameters.
             This label is used to generate the cache file name, and is also printed in when tracing
             hashing operations. Labels are not assumed to be unique, hence a unique hash of
             the label and the parameters to this function will be appended to generate
             the actual cache file name.
             
-            Use ``uid`` instead if ``label`` represents valid unique filenames.
-            
+            Use ``uid`` instead if ``label`` represents valid unique filenames. You cannot specify both ``uid`` and ``label``.
+            If neither ``uid`` and ``label`` are present, ``name`` will be used.
             
             **Usage:**
             
@@ -3271,30 +3319,34 @@ class SubDir(object):
             
             ``label`` cannot be used alongside ``uid``.
             
-        uid : str | Callable
+        uid : str | Callable | None, default ``None``
             Alternative to ``label`` which is assumed to generate a unique cache file name. It has the same
-            semantics as ``label``. When used, parameters to the decorated function are not hashed.
+            semantics as ``label``. When used, parameters to the decorated function are not hashed
+            as the ``uid`` is assumed to be already unique. The string must be a valid file name
             
-            ``uid`` be used alongside ``label``.
+            Use ``label`` if the id is not unique. You cannot specify both ``uid`` and ``label``.
+            If neither ``uid`` and ``label`` are present, ``name`` will be used (as non-unique ``label``).
         
-        name : str, optional
-            Name of this function which is used either on its own if neither ``label`` not ``uid`` are used.
-            If either of them is used, ``name`` is passed as a parameter to either the callable or the
-            formatting operator.
+        name : str | None, default ``None``
+            Name of this function which is used either on its own if neither ``label`` not ``uid`` are used,
+            or which passed as a parameter ``name`` to either the callable or the
+            formatting operator. See above for more details.
             
             If ``name`` is not specified it defaults to ``__qualname__`` expanded
             by the module name the function is defined in.
         
-        include_args : list[str]
+        include_args : list[str] | None, default ``None``
             List of arguments to include in generating an unqiue ID, or ``None`` for all.
         
-        exclude_args : list[str]:
-            List of arguments to exclude from generating an unique ID.
+        exclude_args : list[str] | None, default ``None``
+            List of arguments to exclude from generating an unique ID. Examples of such non-functional arguments
+            are workflow controls (debugging) and i/o elements.
             
-        exclude_arg_types : list[type]
-            List of parameter types to exclude from generating an unique ID.
+        exclude_arg_types : list[type] | None, default ``None``
+            List of parameter types to exclude from generating an unique ID. Examples of such non-functional arguments
+            are workflow controls (debugging) and i/o elements.
             
-        version_auto_class : bool
+        version_auto_class : bool, default ``True``
             Whether to automaticallty add version dependencies on base classes or, for member functions, on containing
             classes. This is the ``auto_class`` parameter for :dec:`cdxcore.version.version`.
             
@@ -3326,12 +3378,39 @@ class SubDir(object):
                 
             The decorated ``F()`` has additional function parameters, namely:
                 
-            * ``override_cache_mode`` : allows to override caching mode temporarily, in particular you can set it to ``"off"``.
-            * ``track_cached_files`` : allows passing a :class:`cdxcore.subdir.CacheTracker`
+            * ``override_cache_mode`` : ``CacheMode`` | None, default ``None``
+            
+              Allows overriding the ``CacheMode`` temporarily, in particular you can set it to ``"off"``.
+               
+            * ``track_cached_files`` : :class:`cdxcore.subdir.CacheTracker` | None, default ``None``
+            
+              Allows passing a :class:`cdxcore.subdir.CacheTracker`
               object to keep track of all
               files used (loaded from or saved to). 
               The function :meth:`cdxcore.subdir.CacheTracker.delete_cache_files` can be used
               to delete all files involved in caching.
+
+            * ``return_cache_uid`` : bool, default ``False``
+            
+              If ``True``, then the decorated function will return a tuple ``uid, result``
+              where ``uid`` is the unique filename generated for this function call,
+              and where ``result`` is the actual result from the function, cached or not.
+              
+              Usage::
+                  
+                  from cdxcore.subdir import SubDir
+                  cache_dir = SubDir("!/.cache")
+                  
+                  @cache_dir.cache()
+                  def f(x, y):
+                      return x*y
+                  
+                  uid, xy = f( x=1, y=2, return_cache_uid=True )
+                  
+              This pattern is thread-safe when compared to using::
+              
+                  xy = f( x=1, y=2 )
+                  uid = f.cache_info.filename
         """
         return CacheCallable(subdir = self,
                              version = version,
@@ -3361,17 +3440,41 @@ class SubDir(object):
             @cache.cache_class("0.1")
             class A(object):
                 
-                @cache.cache(exclude_args=['debug'])
+                @cache.cache_init(exclude_args=['debug'])
                 def __init__(self, x, debug):
                     if debug:
                         print("__init__",x)
                     self.x = x
 
         """
-        return self.cache( name=name,
-                           version=version,
-                           dependencies=dependencies,
-                           version_auto_class=version_auto_class)        
+        return self.cache( name=name, version=version, dependencies=dependencies, version_auto_class=version_auto_class)        
+
+    def cache_init(  self, 
+                     label               : Callable = None,
+                     uid                 : Callable = None,
+                     exclude_args        : list[str] = None,
+                     include_args        : list[str] = None,
+                     exclude_arg_types   : list[type] = None,
+                     ):
+        """
+        Short-cut for :dec:`cdxcore.subdir.SubDir.cache` applied to decorating ``__init__``
+        with a reduced number of available parameters.
+        
+        Example::
+
+            cache   = SubDir("!/.cache")
+            
+            @cache.cache_class("0.1")
+            class A(object):
+                
+                @cache.cache_init(exclude_args=['debug'])
+                def __init__(self, x, debug):
+                    if debug:
+                        print("__init__",x)
+                    self.x = x
+
+        """
+        return self.cache( label=label, uid=uid, exclude_args=exclude_args, include_args=include_args, exclude_arg_types=exclude_arg_types )        
 
 # ========================================================================
 # Caching, convenience
@@ -3444,6 +3547,9 @@ def VersionedCacheRoot( directory          : str, *,
         
         * ``hash_length``: length used for hashes, see :class:`cdxcore.uniquehash.UniqueHash`.
         
+        * ``debug_verbose`` set to ``Context.all`` after importing ``from cdxcore.verbose import Context``
+          will turn on tracing all caching operations.
+        
     Returns
     -------
     Root : :class:`cdxcore.subdir.SubDir`
@@ -3768,8 +3874,9 @@ class CacheCallable(object):
         exclude_types = ( self._exclude_arg_types if not self._exclude_arg_types is None else set() )\
                       | ( self.global_exclude_arg_types if not self.global_exclude_arg_types is None else set())
 
-        def execute( *args, override_cache_mode : CacheMode = None, 
-                            track_cached_files  : CacheTracker = None,
+        def execute( *args, override_cache_mode : CacheMode|None = None, 
+                            track_cached_files  : CacheTracker|None = None,
+                            return_cache_uid    : bool = False,
                             **kwargs ):     
             """
             Cached execution of the wrapped function
@@ -3899,7 +4006,7 @@ class CacheCallable(object):
             # -------------------------
 
             execute.cache_info.label    = str(label) if not label is None else None
-            execute.cache_info.filename = filename
+            execute.cache_info.filename = filename # that is the unique ID for this call
             execute.cache_info.version  = version_
             
             if self.cache_controller.keep_last_arguments:
@@ -3937,6 +4044,8 @@ class CacheCallable(object):
                         assert r.__magic_cache_call_init__ is None, ("**** Internal error. __init__ should reset __magic_cache_call_init__", F.__qualname__, label)
                         r.__magic_cache_call_init__ = False # since we called __new__, __init__ will be called next
 
+                    if return_cache_uid:
+                        return filename, r
                     return r
             
             r = F(*args, **kwargs)
@@ -3966,6 +4075,9 @@ class CacheCallable(object):
                     debug_verbose.write(f"cache({name}): called '{label}' version 'version {version_}' and wrote result into '{self._subdir.full_file_name(filename)}'.")
                 else:
                     debug_verbose.write(f"cache({name}): called '{label}' version 'version {version_}' but did *not* write into '{self._subdir.full_file_name(filename)}'.")
+
+            if return_cache_uid:
+                return filename, r
             return r
 
         update_wrapper( wrapper=execute, wrapped=F )

{cdxcore-0.1.26.dist-info → cdxcore-0.1.28.dist-info}/METADATA

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

{cdxcore-0.1.26.dist-info → cdxcore-0.1.28.dist-info}/RECORD

@@ -1,20 +1,20 @@
-cdxcore/__init__.py,sha256=fkVQQ_XdGdXhWA35RMrTjwmBD2jNYOcKPhNKMgPF8Vw,127
+cdxcore/__init__.py,sha256=eAlbvVVYLS8fmoJ4F2yMdJWFO8woTjXMND4ABmbz1sw,127
 cdxcore/config.py,sha256=RaxpAnTEyGXLiq-1O2prXFBb2sdyqB6hHDHPAFGe2k0,98472
-cdxcore/deferred.py,sha256=5bREI2IQ3uW3EMDcAO17gJbVnbUIV__-bdEUQpZIEeU,44684
+cdxcore/deferred.py,sha256=41buUit1SOAnhVSrzlzM5hd2OOhnAS2QRDSWEpjXfdE,43138
 cdxcore/dynalimits.py,sha256=TXEwa4wCdeM5epG1ceezaHwvmhnbU-oXlXpHNbOMQR8,11293
-cdxcore/dynaplot.py,sha256=1g4IFTfUir13BEDNxDXxUvlwh__kq5n0kgehZ-e8ah4,51031
+cdxcore/dynaplot.py,sha256=Bnjt9GEkPRXcsSqbVSsr08d71dhTZXrVab-zPxLEkaA,51355
 cdxcore/err.py,sha256=3JP1IZDMIKayTt-ZNV9PCYdjtvkybQTjZOrRmBZWyfg,14709
 cdxcore/filelock.py,sha256=D2U8rzxYkeuDc8RLRbePBQ939PPxcJuRC8sahmVx-x8,34781
 cdxcore/jcpool.py,sha256=Vw8o8S4_qTVQNIr2sRaBR_kHz_wO0zpYs0QjlKSYFz8,27280
 cdxcore/npio.py,sha256=SVpKkFt6lyRogkns-oky0wEiWgVTalgB0OdaSvyWtlU,24212
 cdxcore/npshm.py,sha256=9buYPNJoNlw69NZQ-nLF13PEWBWNx51a0gjQw5Gc24U,18368
 cdxcore/pretty.py,sha256=FsI62rlaqRX1E-uPCSnu0M4UoCQ5Z55TDvYPnzTNO70,17220
-cdxcore/subdir.py,sha256=QnFgWq464KtoFXedAuo1r5PHvsN3whDs_WA_vXf5BdQ,179560
+cdxcore/subdir.py,sha256=S-ir_1pUQxQI8B3JkflLzvA3P0_XkBU-Qqkm3S9Fi_M,184881
 cdxcore/uniquehash.py,sha256=WCtieiRBavfpSVT-hW4QNYGHFrfgXG3kJuTUtAi9_b0,50729
 cdxcore/util.py,sha256=dqCEhrDvUM4qjeUwb6n8jPfS8WC4Navcj83gDjXfRFE,39349
 cdxcore/verbose.py,sha256=vsjGTVnAHMPg2L2RfsowWKKPjUSnQJ3F653vDTydBkI,30223
 cdxcore/version.py,sha256=S3H0ktEZsM0zAj3EQ5AdrZ2KxWhQtemd8clzEFE9hOQ,27160
-cdxcore-0.1.26.dist-info/licenses/LICENSE,sha256=M-cisgK9kb1bqVRJ7vrCxHcMQQfDxdY3c2YFJJWfNQg,1090
+cdxcore-0.1.28.dist-info/licenses/LICENSE,sha256=M-cisgK9kb1bqVRJ7vrCxHcMQQfDxdY3c2YFJJWfNQg,1090
 docs/source/conf.py,sha256=yn3LYgw3sT45mUyll-B2emVp6jg7H6KfAHOcBg_MNv4,4182
 tests/test_config.py,sha256=N86mH3y7k3LXEmU8uPLfrmRMZ-80VhlD35nBbpLmebg,15617
 tests/test_deferred.py,sha256=4Xsb76r-XqHKiBuHa4jbErjMWbrgHXfPwewzzY4lf9Y,7922
@@ -23,7 +23,7 @@ tests/test_jcpool.py,sha256=bcGC3UcJ7SOHVgzZ-cooEJgncLWmhutBfqH7P5qB-iw,7901
 tests/test_npio.py,sha256=v-_oO7bj9obSJD4TBk4gBM8ACL62DMNjyQ-iZmvOOdw,3039
 tests/test_npshm.py,sha256=uVivQ3zI4_v3a4qDIY-1gjf5_2pEtKM00VlC3hubUl8,3270
 tests/test_pretty.py,sha256=pVwTBjm3XqwEf2jq5GdZvT4cDSTGqiQFBMLqmGJYuB0,11644
-tests/test_subdir.py,sha256=Ab6pCrUnbMR3kpLsKcDwLUP5QY1HvFVTmSI9D1lXhbM,11444
+tests/test_subdir.py,sha256=LGofLSthZMmZBOAq_XwYOOS2nmhdGgrNJuHN3Sl8ZFM,13026
 tests/test_uniquehash.py,sha256=n6ZCkdBw-iRsyzeAEmrnLK0hJLGH6l_Dtt_KIkSa6KA,24630
 tests/test_util.py,sha256=mwtz3o_RiLNn808928xP4jawHmGNxzUXiatMh0zBc3o,24342
 tests/test_verbose.py,sha256=zXheIqAVOnwML2zsCjLugjYzB_KNzU_S4Xu2CSb4o10,4723
@@ -34,7 +34,7 @@ tmp/npsh1.py,sha256=mNucUl2-jNmE84GlMlliB4aJ0UQ9FqdymgcY_9mLeZY,15432
 tmp/sharedarray.py,sha256=dNOT1ObCc3nM3qA3OA508NcENIBnkmWMxRPCqvMVa8A,12862
 up/git_message.py,sha256=EfSH7Pit3ZoCiRqSMwRCUN_QyuwreU4LTIyGSutBlm4,123
 up/pip_modify_setup.py,sha256=Esaml4yA9tFsqxLhk5bWSwvKCURONjQqfyChgFV2TSY,1584
-cdxcore-0.1.26.dist-info/METADATA,sha256=YT7I_dWXka3a7RSKznr_zZO-9WC_LFmMy0DkyGSDJdE,5939
-cdxcore-0.1.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cdxcore-0.1.26.dist-info/top_level.txt,sha256=phNSwCyJFe7UP2YMoi8o6ykhotatlIbJHjTp9EHM51k,26
-cdxcore-0.1.26.dist-info/RECORD,,
+cdxcore-0.1.28.dist-info/METADATA,sha256=pQce48t_g2AM8yerQ7Ltd7ddv4DbPszOXa25upO2AOs,5939
+cdxcore-0.1.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cdxcore-0.1.28.dist-info/top_level.txt,sha256=phNSwCyJFe7UP2YMoi8o6ykhotatlIbJHjTp9EHM51k,26
+cdxcore-0.1.28.dist-info/RECORD,,

tests/test_subdir.py

@@ -25,14 +25,14 @@ import_local()
 """
 Imports
 """
-from cdxcore.subdir import SubDir, CacheMode, VersionError, VersionPresentError
+from cdxcore.subdir import SubDir, CacheMode, VersionError, VersionPresentError, VersionedCacheRoot
 import numpy as np
 
 class Test(unittest.TestCase):
 
     def test_subdir(self):
 
-        sub = SubDir("!/.tmp_test_for_cdxbasics.subdir", delete_everything=True )
+        sub = SubDir("?/.tmp_test_for_cdxbasics.subdir", delete_everything=True )
         sub['y'] = 2
         sub.write('z',3)
         sub.write_string('l',"hallo")
@@ -193,11 +193,8 @@ class Test(unittest.TestCase):
         with self.assertRaises(VersionError):
             r = sub.read("test", None, version="2", raise_on_error=True)
             # wrong version
-        sub.delete_everything()
         
     def test_new(self):
-        
-        
         subdir = SubDir("my_directory")      # relative to current working directory
         subdir = SubDir("./my_directory")    # relative to current working directory
         subdir = SubDir("~/my_directory")    # relative to home directory
@@ -248,8 +245,6 @@ class Test(unittest.TestCase):
         test_format( SubDir.GZIP, True )
         test_format( SubDir.JSON_PICKLE )
 
-
-
     def test_cache_mode(self):
 
         on = CacheMode("on")
@@ -275,6 +270,66 @@ class Test(unittest.TestCase):
         self.assertEqual( [ x.write for x in allc ], [True, True, False, False, True, False] )
         self.assertEqual( [ x.delete for x in allc ], [False, False, False, True, True, False ] )
         self.assertEqual( [ x.del_incomp for x in allc ], [True, False, False, True, True, False ] )            
+
+class A(object):
+    def __init__(self, x):
+        self.x = x
+class B(object):
+    def __init__(self, x):
+        self.x = x
+        
+class Test(unittest.TestCase):
+
+    def test_cache( self ):
+        
+        sub = VersionedCacheRoot("?/subdir_cache_test", exclude_arg_types=[A] )
+        
+        @sub.cache("1.0")
+        def f(x):
+            return x
+        
+        _ = f(1)
+        _ = f(1)
+        self.assertTrue( f.cache_info.last_cached )
+
+        @sub.cache("1.0")
+        def g(x):
+            return x
+        
+        # a new B object each time -> no caching
+        _ = f(B(1))
+        _ = f(B(2))
+        self.assertFalse( f.cache_info.last_cached )
+
+        # same B object each time -> no caching
+        _ = f(B(1))
+        _ = f(B(1))
+        self.assertTrue( f.cache_info.last_cached )
+        
+        # a new A object each time -> caching, as we ignore 'A' types
+        _ = f(A(1))
+        _ = f(A(2))
+        self.assertTrue( f.cache_info.last_cached )
+        
+        @sub.cache("1.0", label=lambda x, **_: f"f({x})")
+        def f(x):
+            return x
+        
+        _ = f(1)
+        self.assertEqual( f.cache_info.filename[:5], "f(1) " )
+        uid, _ = f(1, return_cache_uid=True)
+        self.assertEqual( uid[:5], "f(1) " )
+        
+        @sub.cache("1.0", uid=lambda x, **_: f"f({x})")
+        def f(x):
+            return x
+        
+        _ = f(1)
+        self.assertEqual( f.cache_info.filename, "f(1)" )
+        uid, _ = f(1, return_cache_uid=True)
+        self.assertEqual( uid, "f(1)" )
+        
+        
 if __name__ == '__main__':
     unittest.main()