acoular 24.3__py3-none-any.whl → 24.7__py3-none-any.whl

acoular/h5cache.py

@@ -1,52 +1,48 @@
-# -*- coding: utf-8 -*-
-#pylint: disable-msg=E0611,C0111,C0103,R0901,R0902,R0903,R0904,W0232
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 
 # imports from other packages
-from __future__ import print_function
-from traits.api import HasPrivateTraits, Bool, Str, Dict, Instance, Delegate
-from os import path, mkdir, environ, listdir
-from weakref import WeakValueDictionary
 import gc
+from os import listdir, path
+from weakref import WeakValueDictionary
+
+from traits.api import Bool, Delegate, Dict, HasPrivateTraits, Instance
 
 from .configuration import Config, config
 from .h5files import _get_cachefile_class
 
-class H5cache_class(HasPrivateTraits):
-    """
-    Cache class that handles opening and closing 'tables.File' objects
-    """
+
+class HDF5Cache(HasPrivateTraits):
+    """Cache class that handles opening and closing 'tables.File' objects."""
 
     config = Instance(Config)
 
-    cache_dir = Delegate('config')    
+    cache_dir = Delegate('config')
 
     busy = Bool(False)
-    
+
     open_files = WeakValueDictionary()
-    
-    openFileReferenceCount = dict()
-    
+
+    open_file_reference = Dict()
+
     def _idle_if_busy(self):
         while self.busy:
             pass
 
-    def open_cachefile(self,cacheFileName,mode):
-        File = _get_cachefile_class()
-        return File(path.join(self.cache_dir, cacheFileName), mode)
-    
-    def close_cachefile(self,cachefile):
-        self.openFileReferenceCount.pop(get_basename(cachefile))
+    def open_cachefile(self, filename, mode):
+        file = _get_cachefile_class()
+        return file(path.join(self.cache_dir, filename), mode)
+
+    def close_cachefile(self, cachefile):
+        self.open_file_reference.pop(get_basename(cachefile))
         cachefile.close()
-        
-    def get_filename(self,file):
-        File = _get_cachefile_class()
-        if isinstance(file, File): 
+
+    def get_filename(self, file):
+        file_class = _get_cachefile_class()
+        if isinstance(file, file_class):
             return get_basename(file)
-        else:
-            return 0
+        return 0
 
     def get_open_cachefiles(self):
         try:
@@ -55,82 +51,77 @@ class H5cache_class(HasPrivateTraits):
             return iter(self.open_files.values())
 
     def close_unreferenced_cachefiles(self):
-        for openCacheFile in self.get_open_cachefiles():
-            if not self.is_reference_existent(openCacheFile):
-#                print("close unreferenced File:",get_basename(openCacheFile))
-                self.close_cachefile(openCacheFile)
+        for cachefile in self.get_open_cachefiles():
+            if not self.is_reference_existent(cachefile):
+                #                print("close unreferenced File:",get_basename(cachefile))
+                self.close_cachefile(cachefile)
 
-    def is_reference_existent(self,file):
-        existFlag = False
+    def is_reference_existent(self, file):
+        exist_flag = False
         # inspect all refererres to the file object
-        gc.collect() #clear garbage before collecting referrers
+        gc.collect()  # clear garbage before collecting referrers
         for ref in gc.get_referrers(file):
-            # does the file object have a referrer that has a 'h5f' 
+            # does the file object have a referrer that has a 'h5f'
             # attribute?
-            if isinstance(ref,dict) and 'h5f' in ref:
+            if isinstance(ref, dict) and 'h5f' in ref:
                 # file is still referred, must not be closed
-                existFlag = True
+                exist_flag = True
                 break
-        return existFlag
+        return exist_flag
 
-    def is_cachefile_existent(self,cacheFileName):
-        if cacheFileName in listdir(self.cache_dir):
+    def is_cachefile_existent(self, filename):
+        if filename in listdir(self.cache_dir):
             return True
-        else:
-            return False
+        return False
 
-    def _increase_file_reference_counter(self, cacheFileName):
-        self.openFileReferenceCount[cacheFileName] = self.openFileReferenceCount.get(cacheFileName, 0) + 1
+    def _increase_file_reference_counter(self, filename):
+        self.open_file_reference[filename] = self.open_file_reference.get(filename, 0) + 1
 
-    def _decrease_file_reference_counter(self, cacheFileName):
-        self.openFileReferenceCount[cacheFileName] = self.openFileReferenceCount[cacheFileName] - 1
+    def _decrease_file_reference_counter(self, filename):
+        self.open_file_reference[filename] = self.open_file_reference[filename] - 1
 
     def _print_open_files(self):
-        print(list(self.openFileReferenceCount.items()))
-
-    def get_cache_file( self, obj, basename, mode='a' ):
-        '''
-        returns pytables .h5 file to h5f trait of calling object for caching
-        '''        
-        
-        self._idle_if_busy() # 
+        print(list(self.open_file_reference.items()))
+
+    def get_cache_file(self, obj, basename, mode='a'):
+        """Returns pytables .h5 file to h5f trait of calling object for caching."""
+        self._idle_if_busy()  #
         self.busy = True
 
-        cacheFileName = basename + '_cache.h5'
-        objFileName = self.get_filename(obj.h5f)
-        
-        if objFileName:
-            if objFileName == cacheFileName: 
+        filename = basename + '_cache.h5'
+        obj_filename = self.get_filename(obj.h5f)
+
+        if obj_filename:
+            if obj_filename == filename:
                 self.busy = False
                 return
-            else: # in case the base name has changed ( different source ) 
-                self._decrease_file_reference_counter(objFileName)
-
-        if cacheFileName not in self.open_files: # or tables.file._open_files.filenames
-            if (
-                config.global_caching == 'readonly' 
-                and not self.is_cachefile_existent(cacheFileName)
-                ): # condition ensures that cachefile is not created in readonly mode
+            self._decrease_file_reference_counter(obj_filename)
+
+        if filename not in self.open_files:  # or tables.file._open_files.filenames
+            if config.global_caching == 'readonly' and not self.is_cachefile_existent(
+                filename,
+            ):  # condition ensures that cachefile is not created in readonly mode
                 obj.h5f = None
                 self.busy = False
-#                self._print_open_files()   
+                #                self._print_open_files()
                 return
-            else:
-                if config.global_caching == 'readonly': mode = 'r'
-                f = self.open_cachefile(cacheFileName,mode)
-                self.open_files[cacheFileName] = f
-        
-        obj.h5f = self.open_files[cacheFileName]
-        self._increase_file_reference_counter(cacheFileName)
-        
+            if config.global_caching == 'readonly':
+                mode = 'r'
+            f = self.open_cachefile(filename, mode)
+            self.open_files[filename] = f
+
+        obj.h5f = self.open_files[filename]
+        self._increase_file_reference_counter(filename)
+
         # garbage collection
         self.close_unreferenced_cachefiles()
-        
+
         self.busy = False
-        self._print_open_files()   
+        self._print_open_files()
 
-H5cache = H5cache_class(config=config)
 
-def get_basename(file): 
-    return path.basename(file.filename)
+H5cache = HDF5Cache(config=config)
 
+
+def get_basename(file):
+    return path.basename(file.filename)

acoular/h5files.py

@@ -1,204 +1,221 @@
-# -*- coding: utf-8 -*-
-#pylint: disable-msg=E0611, E1101, C0103, R0901, R0902, R0903, R0904, W0232
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
-
-try:
-    import tables 
-    is_tables = True
-except:
-    is_tables = False
-    pass
-try:
-    import h5py
-    is_h5py = True
-except:
-    is_h5py = False
+# ------------------------------------------------------------------------------
 
 from .configuration import config
 
 
+class H5FileBase:
+    """Base class for File objects that handle writing and reading of .h5 files."""
 
-class H5FileBase(object):
-    '''
-    Base class for File objects that handle writing and reading of .h5 files 
-    '''
-    
-    def create_extendable_array(self,nodename,shape,precision,group=None):
+    def create_extendable_array(self, nodename, shape, precision, group=None):
         pass
-    
-    def get_data_by_reference(self, nodename,group=None):
+
+    def get_data_by_reference(self, nodename, group=None):
         pass
-    
-    def set_node_attribute(self,node,attrname,value):
+
+    def set_node_attribute(self, node, attrname, value):
         pass
 
-    def get_node_attribute(self,node,attrname):
+    def get_node_attribute(self, node, attrname):
         pass
 
-    def append_data(self,node,data):
+    def append_data(self, node, data):
         pass
 
-    def remove_data(self,nodename):
-        pass           
-    
-    def create_new_group(self,name,group=None):
+    def remove_data(self, nodename):
         pass
 
-    def get_node_children(self, group):
-        yield
+    def create_new_group(self, name, group=None):
+        pass
 
 
-class H5CacheFileBase(object):
-    '''
-    Base class for File objects that handle writing and reading of .h5 cache files 
-    '''
-    
-    compressionFilter = None
+class H5CacheFileBase:
+    """Base class for File objects that handle writing and reading of .h5 cache files."""
+
+    compression_filter = None
+
+    def is_cached(self, nodename, group=None):
+        pass
 
-    
-    def is_cached(self,nodename,group=None):
+    def create_compressible_array(self, nodename, shape, precision, group=None):
         pass
-        
-    def create_compressible_array(self,nodename,shape,precision,group=None):
-        pass    
 
 
-if is_tables:
-    
+if config.have_tables:
+    import tables
+
     precision_to_atom = {
-        'float32' : tables.Float32Atom(),
-        'complex64' : tables.ComplexAtom(8),
-        'float64' : tables.Float64Atom(),
-        'complex128' : tables.ComplexAtom(16),
-        'bool' : tables.BoolAtom(),
-        'int32' : tables.Int32Atom(),
-        'int16' : tables.Int16Atom(),
-        'int8' : tables.Int8Atom(),        
-        }
-    
-    class H5FileTables(H5FileBase,tables.File):
-        
-        def create_extendable_array(self,nodename,shape,precision,group=None):
-            if not group: group = self.root
+        'float32': tables.Float32Atom(),
+        'complex64': tables.ComplexAtom(8),
+        'float64': tables.Float64Atom(),
+        'complex128': tables.ComplexAtom(16),
+        'bool': tables.BoolAtom(),
+        'int32': tables.Int32Atom(),
+        'int16': tables.Int16Atom(),
+        'int8': tables.Int8Atom(),
+    }
+
+    class H5FileTables(H5FileBase, tables.File):
+        def create_extendable_array(self, nodename, shape, precision, group=None):
+            if not group:
+                group = self.root
             atom = precision_to_atom[precision]
-            self.create_earray(group, nodename, atom, shape) 
-            
-        def get_data_by_reference(self, nodename,group=None):
-            if not group: group = self.root
+            self.create_earray(group, nodename, atom, shape)
+
+        def get_data_by_reference(self, nodename, group=None):
+            if not group:
+                group = self.root
             return self.get_node(group, nodename)
 
-        def set_node_attribute(self,node,attrname,value):
-            node.set_attr(attrname,value)
+        def set_node_attribute(self, node, attrname, value):
+            node.set_attr(attrname, value)
 
-        def get_node_attribute(self,node,attrname):
-            return node.get_attr(attrname)
+        def get_node_attribute(self, node, attrname):
+            return node._v_attrs[attrname]  # noqa: SLF001
 
-        def append_data(self,node,data):
+        def append_data(self, node, data):
             node.append(data)
-            
-        def remove_data(self,nodename):
-            self.remove_node('/',nodename,recursive=True)            
-    
-        def create_new_group(self,name,group=None):
-            if not group: group = self.root
-            return self.create_group(group,name)
+
+        def remove_data(self, nodename):
+            self.remove_node('/', nodename, recursive=True)
+
+        def create_new_group(self, name, group=None):
+            if not group:
+                group = self.root
+            return self.create_group(group, name)
 
         def get_child_nodes(self, nodename):
             for childnode in self.list_nodes(nodename):
                 yield (childnode.name, childnode)
 
+        def node_to_dict(self, nodename):
+            """Recursively convert an HDF5 node to a dictionary."""
+            node = self.get_node(nodename)
+            # initialize node-dict with node's own attributes
+            result = {attr: node._v_attrs[attr] for attr in node._v_attrs._f_list()}  # noqa: SLF001
+            if isinstance(node, tables.Group):
+                # if node is a group, recursively add its children
+                for childname in node._v_children:  # noqa: SLF001
+                    result[childname] = self.node_to_dict(f'{nodename}/{childname}')
+            elif isinstance(node, tables.Leaf):
+                # if node contains only data, add it
+                return node
+            else:
+                return None
+            return result
 
     class H5CacheFileTables(H5FileTables, H5CacheFileBase):
-        
-        compressionFilter = tables.Filters(complevel=5, complib='blosc')
-        
-        def is_cached(self,nodename,group=None):
-            if not group: group = self.root
-            if nodename in group: 
+        compression_filter = tables.Filters(complevel=5, complib='blosc')
+
+        def is_cached(self, nodename, group=None):
+            if not group:
+                group = self.root
+            if nodename in group:
                 return True
-            else:
-                return False
-            
-        def create_compressible_array(self,nodename,shape,precision,group=None):
-            if not group: group = self.root
+            return False
+
+        def create_compressible_array(self, nodename, shape, precision, group=None):
+            if not group:
+                group = self.root
             atom = precision_to_atom[precision]
-            self.create_carray(group, nodename, atom, shape, 
-                                        filters=self.compressionFilter)
-
-    
-
-if is_h5py:
-    
-    class H5FileH5py(H5FileBase,h5py.File):
-        
-        def _get_in_file_path(self,nodename,group=None):
-            if not group: return '/'+nodename
-            else: return group+'/'+nodename
-
-        def create_array(self,where, name, obj):
-            self.create_dataset(f'{where}/{name}',data=obj)
-                  
-        def create_extendable_array(self,nodename,shape,precision,group=None):
-            in_file_path = self._get_in_file_path(nodename,group)
-            self.create_dataset(in_file_path, shape=shape, dtype=precision,
-                                maxshape=(None,shape[1])) 
-            
-        def get_data_by_reference(self,nodename,group=None):
-            in_file_path = self._get_in_file_path(nodename,group)
+            self.create_carray(group, nodename, atom, shape, filters=self.compression_filter)
+
+
+if config.have_h5py:
+    import h5py
+
+    class H5FileH5py(H5FileBase, h5py.File):
+        def _get_in_file_path(self, nodename, group=None):
+            if not group:
+                return '/' + nodename
+            return group + '/' + nodename
+
+        def create_array(self, where, name, obj):
+            self.create_dataset(f'{where}/{name}', data=obj)
+
+        def create_extendable_array(self, nodename, shape, precision, group=None):
+            in_file_path = self._get_in_file_path(nodename, group)
+            self.create_dataset(in_file_path, shape=shape, dtype=precision, maxshape=(None, shape[1]))
+
+        def get_data_by_reference(self, nodename, group=None):
+            in_file_path = self._get_in_file_path(nodename, group)
             return self[in_file_path]
 
-        def set_node_attribute(self,node,attrname,value):
+        def set_node_attribute(self, node, attrname, value):
             node.attrs[attrname] = value
 
-        def get_node_attribute(self,node,attrname):
+        def get_node_attribute(self, node, attrname):
             return node.attrs[attrname]
 
-        def append_data(self,node,data):
-            oldShape = node.shape
-            newShape = (oldShape[0] + data.shape[0], data.shape[1])
-            node.resize(newShape)
-            node[oldShape[0]:newShape[0],:] = data
-    
-        def remove_data(self,nodename,group=None):
-            in_file_path = self._get_in_file_path(nodename,group)
+        def append_data(self, node, data):
+            old_shape = node.shape
+            new_shape = (old_shape[0] + data.shape[0], data.shape[1])
+            node.resize(new_shape)
+            node[old_shape[0] : new_shape[0], :] = data
+
+        def remove_data(self, nodename, group=None):
+            in_file_path = self._get_in_file_path(nodename, group)
             del self[in_file_path]
 
-        def create_new_group(self,name,group=None):
-            in_file_path = self._get_in_file_path(name,group)
-            self.create_group(in_file_path)    
+        def create_new_group(self, name, group=None):
+            in_file_path = self._get_in_file_path(name, group)
+            self.create_group(in_file_path)
             return in_file_path
 
         def get_child_nodes(self, nodename):
             for childnode in self[nodename]:
                 yield (childnode, self[f'{nodename}/{childnode}'])
 
+        def node_to_dict(self, nodename):
+            """Recursively convert an HDF5 node to a dictionary."""
+            node = self[nodename]
+            # initialize node-dict with node's own attributes
+            result = {attr: node.attrs[attr] for attr in node.attrs}
+            if isinstance(node, h5py.Group):
+                # if node is a group, recursively add its children
+                for childname in node:
+                    result[childname] = self.node_to_dict(f'{nodename}/{childname}')
+            elif isinstance(node, h5py.Dataset):
+                # if node contains only data, add it
+                return node
+            else:
+                return None
+            return result
 
     class H5CacheFileH5py(H5CacheFileBase, H5FileH5py):
+        compression_filter = 'lzf'
+        #        compression_filter = 'blosc' # unavailable...
 
-        compressionFilter = "lzf"
-#        compressionFilter = 'blosc' # unavailable...
-    
-        def is_cached(self,nodename,group=None):
-            if not group: group = '/'
-            if group+nodename in self: 
+        def is_cached(self, nodename, group=None):
+            if not group:
+                group = '/'
+            if group + nodename in self:
                 return True
-            else:
-                return False
-            
-        def create_compressible_array(self,nodename,shape,precision,group=None):
-            in_file_path = self._get_in_file_path(nodename,group)
-            self.create_dataset(in_file_path, dtype=precision, shape=shape, 
-                                        compression=self.compressionFilter,
-                                        chunks=True)        
+            return False
 
+        def create_compressible_array(self, nodename, shape, precision, group=None):
+            in_file_path = self._get_in_file_path(nodename, group)
+            self.create_dataset(
+                in_file_path,
+                dtype=precision,
+                shape=shape,
+                compression=self.compression_filter,
+                chunks=True,
+            )
 
 
 def _get_h5file_class():
-    if config.h5library == "pytables": return H5FileTables
-    elif config.h5library == "h5py": return H5FileH5py    
+    if config.h5library in ['pytables', 'tables']:
+        return H5FileTables
+    if config.h5library == 'h5py':
+        return H5FileH5py
+    return None
+
 
 def _get_cachefile_class():
-    if config.h5library == "pytables": return H5CacheFileTables
-    elif config.h5library == "h5py": return H5CacheFileH5py
+    if config.h5library in ['pytables', 'tables']:
+        return H5CacheFileTables
+    if config.h5library == 'h5py':
+        return H5CacheFileH5py
+    return None

acoular/internal.py

@@ -1,26 +1,25 @@
-# coding=UTF-8
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 
 from hashlib import md5
 
-def digest( obj, name='digest'):
-    str_ = [str(obj.__class__).encode("UTF-8")]
+
+def digest(obj, name='digest'):
+    str_ = [str(obj.__class__).encode('UTF-8')]
     for do_ in obj.trait(name).depends_on:
         vobj = obj
         try:
-            for i in do_.split('.'):               
+            for i in do_.split('.'):
                 vobj = list(vobj.trait_get(i.rstrip('[]')).values())[0]
-            str_.append(str(vobj).encode("UTF-8"))
-        except:
+            str_.append(str(vobj).encode('UTF-8'))
+        except:  # noqa: E722
             pass
-    return '_' + md5(''.encode("UTF-8").join(str_)).hexdigest()
+    return '_' + md5(b''.join(str_)).hexdigest()
+
 
-def ldigest(l):
+def ldigest(obj_list):
     str_ = []
-    for i in l:
+    for i in obj_list:
         str_.append(str(i.digest).encode('UTF-8'))
-    return '_' + md5(''.encode("UTF-8").join(str_)).hexdigest()
-
-
+    return '_' + md5(b''.join(str_)).hexdigest()