h2lib 13.0.605__cp38-cp38-win_amd64.whl → 13.0.705__cp38-cp38-win_amd64.whl

h2lib/_h2lib.py

@@ -1,42 +1,34 @@
-import os
-import numpy as np
+from contextlib import contextmanager
 from h2lib.dll_wrapper import DLLWrapper
 from h2lib.h2lib_signatures import H2LibSignatures
-from h2lib.utils import MultiProcessInterface, ProcessClass
-from contextlib import contextmanager
-
+import os
+import sys
 
-@contextmanager
-def set_LD_LIBRARY_PATH():
-    old = os.environ.get('LD_LIBRARY_PATH', "")
-    if '/lib/' in __file__:  # pragma: no cover  (only on linux)
-        lib_path = __file__[:__file__.index("/lib/") + 5]
-        os.environ['LD_LIBRARY_PATH'] = f'{lib_path}:{old}'
-    try:
-        yield
-    finally:
-        os.environ['LD_LIBRARY_PATH'] = old
+from multiclass_interface.multiprocess_interface import MultiProcessClassInterface, ProcessClass
+import numpy as np
 
 
 def H2Lib(suppress_output=False, subprocess=True):
-    if subprocess:
-        with set_LD_LIBRARY_PATH():
-            return H2LibProcess(suppress_output=suppress_output)
-    else:
-        return H2LibThread(suppress_output=suppress_output)
+    H2 = [H2LibThread, H2LibProcess][subprocess]
+    return H2(suppress_output=suppress_output)
 
 
 class H2LibThread(H2LibSignatures, DLLWrapper):
     _model_path = '.'
     _aero_sections_data_shape = {}
 
-    def __init__(self, filename=None, cwd='.', suppress_output=True):
+    def __init__(self, suppress_output=True, filename=None, cwd='.'):
         if filename is None:
             if os.name == 'nt':
                 filename = os.path.dirname(__file__) + '/HAWC2Lib.dll'
             else:
                 filename = os.path.dirname(__file__) + '/HAWC2Lib.so'  # pragma: no cover
+        # doubles the speed of single instances and 2N of N instances on linux
+        os.environ['MKL_THREADING_LAYER'] = 'sequential'
         filename = os.path.abspath(filename)
+        library_bin = os.path.abspath(os.path.join(os.path.dirname(sys.executable), '../Library/bin'))
+        if os.path.isdir(library_bin):  # pragma: no cover
+            os.add_dll_directory(library_bin)
         DLLWrapper.__init__(self, filename, cwd=cwd, cdecl=True)
         self.suppress_output = suppress_output
         self._initialized = False
@@ -56,13 +48,22 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         if self._initialized:
             self.finalize()
         DLLWrapper.close(self)
+        return "closed h2lib"
 
     def getState(self):
         return H2LibSignatures.getState(self, restype=np.int32)[1]
 
+    def work(self, time):
+        """Return number of loops"""
+        return H2LibSignatures.work(self, np.float64(time), restype=np.int64)[1]
+
+    def loop(self, N):
+        """Return time to compute N loops"""
+        return H2LibSignatures.loop(self, int(N), restype=np.float64)[1]
+
     def get_version(self):
         s = " " * 255
-        return H2LibSignatures.get_version(self, s)[0][0]
+        return H2LibSignatures.get_version(self, s)[0][0].strip()
 
     def get_wind_speed(self, pos_g):
         return self.get_lib_function('get_wind_speed')(np.asarray(pos_g, dtype=np.float64),
@@ -114,11 +115,11 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             sensor_line += ";"
         index_start, index_stop = 0, 0
         index_start, index_stop = H2LibSignatures.add_sensor(self, sensor_line.lower(), index_start, index_stop)[0][1:]
-        return list(range(index_start, index_stop + 1))
+        return tuple(range(index_start, index_stop + 1))
 
     def get_sensor_info(self, id):
         "return name, unit, description"
-        if isinstance(id, list):
+        if isinstance(id, tuple):
             return [self.get_sensor_info(i) for i in id]
         return [s[:-1].strip()  # remove null termination
                 for s in H2LibSignatures.get_sensor_info(self, id, name=" " * 30, unit=" " * 10, desc=" " * 512)[0][1:]]
@@ -207,7 +208,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         """
         if time is None:
             time = self.get_time()
-        return H2LibSignatures.set_windfield(self, np.asarray(uvw, dtype=np.float64),
+        return H2LibSignatures.set_windfield(self, np.asarray(uvw, dtype=np.float32),
                                              np.float64(box_offset_x), np.float64(time))
 
     # ===================================================================================================================
@@ -236,7 +237,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         return self._aero_sections_data_shape[rotor]
 
     def get_aerosections_position(self, rotor=0):
-        position = np.zeros(self.aero_sections_data_shape(rotor), dtype=np.float64)
+        position = np.zeros(self.aero_sections_data_shape(rotor), dtype=np.float64, order='F')
         return H2LibSignatures.get_aerosections_position(self, rotor + 1, position)[0][1]
 
     def set_aerosections_windspeed(self, uvw, rotor=0):
@@ -244,12 +245,12 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
 
     def get_aerosections_forces(self, rotor=0):
         shape = self.aero_sections_data_shape(rotor)
-        Fxyz = np.zeros(shape, dtype=np.float64)
+        Fxyz = np.zeros(shape, dtype=np.float64, order='F')
         return H2LibSignatures.get_aerosections_forces(self, rotor + 1, Fxyz)[0][1]
 
     def get_aerosections_moments(self, rotor=0):
         shape = self.aero_sections_data_shape(rotor)
-        Mxyz = np.zeros(shape, dtype=np.float64)
+        Mxyz = np.zeros(shape, dtype=np.float64, order='F')
         return H2LibSignatures.get_aerosections_moments(self, rotor + 1, Mxyz)[0][1]
 
     def get_bem_grid_dim(self, rotor=0):
@@ -260,11 +261,12 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         """returns azi, rad"""
         nazi, nrad = self.get_bem_grid_dim(rotor)
         return H2LibSignatures.get_bem_grid(self, rotor + 1,
-                                            np.zeros(nazi, dtype=np.float64), np.zeros(nrad, dtype=np.float64))[0][1:]
+                                            np.zeros(nazi, dtype=np.float64, order='F'),
+                                            np.zeros(nrad, dtype=np.float64, order='F'))[0][1:]
 
     def get_induction_polargrid(self, rotor=0):
         nazi, nrad = self.get_bem_grid_dim(rotor)
-        induction = np.zeros((nazi, nrad), dtype=np.float64)
+        induction = np.zeros((nazi, nrad), dtype=np.float64, order='F')
         return H2LibSignatures.get_induction_polargrid(self, rotor + 1, induction)[0][1]
 
     def get_induction_axisymmetric(self, rotor=0):
@@ -272,6 +274,10 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         induction = np.zeros(nrad, dtype=np.float64)
         return H2LibSignatures.get_induction_axisymmetric(self, rotor + 1, induction)[0][1]
 
+    def get_induction_rotoravg(self, rotor=0):
+        induction = np.float64(0)
+        return H2LibSignatures.get_induction_rotoravg(self, rotor + 1, induction)[0][1]
+
     def get_rotor_orientation(self, rotor=0, deg=False):
         """return yaw, tilt, azi(of first blade) in rad(default) or deg"""
         r = H2LibSignatures.get_rotor_orientation(self, rotor=rotor + 1, yaw=0., tilt=0., azi=0.)[0][1:]
@@ -294,15 +300,47 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         return [vy, vx, -vz]
 
 
-class H2LibProcess(ProcessClass, H2LibThread):
-    def __init__(self, suppress_output):
-        ProcessClass.__init__(self, cls=H2LibThread, cls_attrs=set(dir(H2LibThread)) - set(dir(ProcessClass)))
-        self(suppress_output=suppress_output)
+@contextmanager
+def set_LD_LIBRARY_PATH():
+    _file__ = np.__file__
+    old = os.environ.get('LD_LIBRARY_PATH', "")
+
+    if '/lib/' in _file__:  # pragma: no cover  (only on linux)
+        lib_path = _file__[:_file__.index("/lib/") + 5]
+        os.environ['LD_LIBRARY_PATH'] = f'{lib_path}:{old}'
+
+    try:
+        yield
+    finally:
+        os.environ['LD_LIBRARY_PATH'] = old
 
 
-class MultiH2Lib(MultiProcessInterface, H2LibThread):
-    def __init__(self, N, filename=None, cwd='.', suppress_output=False):
-        if not hasattr(suppress_output, '__len__'):
-            suppress_output = [suppress_output] * N
+class H2LibProcess(ProcessClass, H2LibThread):
+    def __init__(self, suppress_output, filename=None, cwd='.'):
         with set_LD_LIBRARY_PATH():
-            MultiProcessInterface.__init__(self, H2LibThread, [(filename, cwd, suppress_output[i]) for i in range(N)])
+            ProcessClass.__init__(self, cls=H2LibThread, cls_attrs=set(dir(H2LibThread)) - set(dir(ProcessClass)))
+            self(suppress_output=suppress_output, filename=filename, cwd=cwd)
+
+
+def MultiH2Lib(N, filename=None, cwd='.', suppress_output=False):
+
+    if not hasattr(suppress_output, '__len__'):
+        suppress_output = [suppress_output] * N
+    args = [(suppress_output[i], filename, cwd) for i in range(N)]
+
+    with set_LD_LIBRARY_PATH():
+        from multiclass_interface import mpi_interface
+        if mpi_interface.size > 1:  # pragma: no cover
+            # try:
+            #     with H2LibThread(filename):
+            #         pass
+            #     # LD_LIBRARY_PATH is set. Run H2LibThread directly in mpi processes
+            #     cls = H2LibThread
+            # except OSError:
+            #     # Set LD_LIBRARY_PATH in mpi workers and run H2LibThread from the workers via ProcessClass
+            #     cls = H2LibProcess
+            from multiclass_interface.mpi_interface import MPIClassInterface
+            cls = H2LibProcess
+            return MPIClassInterface(cls, args)
+        else:
+            return MultiProcessClassInterface(H2LibThread, args)

h2lib/_version.py

@@ -1,4 +1,4 @@
 # This file is autogenerated and should not be modified manually
-__version__ = '13.0.605'
-h2lib_version = '13.0.605'
-hawc2_version = '13.0.6+8-g2148dea'
+__version__ = '13.0.705'
+h2lib_version = '13.0.705'
+hawc2_version = '13.0.9'

h2lib/dll_wrapper.py

@@ -6,9 +6,7 @@ import platform
 import os
 import ctypes
 from _ctypes import POINTER
-from ctypes import c_int, c_double, c_char, c_char_p, c_long
-import tempfile
-import shutil
+from ctypes import c_int, c_double, c_char, c_char_p, c_long, c_longlong
 from contextlib import contextmanager
 try:
     from ctypes import windll
@@ -21,6 +19,7 @@ c_int_p = POINTER(ctypes.c_long)
 c_long_p = POINTER(ctypes.c_longlong)
 
 c_double_p = POINTER(ctypes.c_double)
+c_float_p = POINTER(ctypes.c_float)
 
 in_use = []
 
@@ -70,17 +69,88 @@ def cwd(f):
     return wrap
 
 
+def wrap(self, f, *args, **kwargs):
+    c_args = []
+    args = list(args)
+    for i, arg in enumerate(args):
+        if isinstance(arg, (list, tuple)):
+            if all([isinstance(e, int) for e in arg]):
+                # default to int64 which is default on linux but not windows
+                args[i] = np.array(arg, dtype=np.int64)
+            else:
+                args[i] = np.array(arg)
+        if isinstance(args[i], np.ndarray):
+
+            if self.fortran:
+                if not args[i].flags.f_contiguous:
+                    sys.stderr.write(f'argument {i} for {f.__name__} not f_contiguous\n')
+            else:
+                if not args[i].flags.c_contiguous:
+                    sys.stderr.write(f'argument {i} for {f.__name__} not c_contiguous\n')
+
+            args[i] = np.require(args[i], requirements=['C', 'F'][self.fortran])
+
+    for arg in args:
+        if isinstance(arg, int):
+            c_args.append(c_long_p(c_longlong(arg)))
+        elif isinstance(arg, float):
+            c_args.append(c_double_p(c_double(arg)))
+        elif isinstance(arg, str):
+            c_args.append(c_char_p(arg.encode('cp1252')))
+            # c_args.append(c_int_p(c_int(len(arg))))
+
+        elif isinstance(arg, np.ndarray):
+            if arg.dtype in [np.int32]:
+                c_args.append(arg.ctypes.data_as(c_int_p))
+            elif arg.dtype in [np.int64]:
+                c_args.append(arg.ctypes.data_as(c_long_p))
+            elif arg.dtype == np.float64:
+                c_args.append(arg.ctypes.data_as(c_double_p))
+            elif arg.dtype == np.float32:
+                c_args.append(arg.ctypes.data_as(c_float_p))
+            else:
+                raise NotImplementedError(arg.dtype)
+
+        else:
+            # raise NotImplementedError(arg.__class__.__name__)
+            c_args.append(arg)
+    if 'restype' in kwargs:
+        restype = kwargs['restype']
+        if hasattr(restype, 'dtype'):
+            restype = np.ctypeslib.as_ctypes_type(restype)
+        f.restype = restype
+    with chdir(self.cwd):
+        if self.suppress_output:
+            with SuppressStream(sys.stdout), SuppressStream(sys.stderr):
+                res = f(*c_args)
+        else:
+            res = f(*c_args)
+    ret_args = []
+    for arg in args:
+        c_arg = c_args.pop(0)
+        if isinstance(arg, (int, float)):
+            ret_args.append(c_arg.contents.value)
+        elif isinstance(arg, (str)):
+            ret_args.append(c_arg.value.decode('cp1252'))
+            # c_args.pop(0)
+        elif isinstance(arg, np.ndarray):
+            ret_args.append(arg)
+        else:
+            raise NotImplementedError(arg.__class__.__name__)
+    return ret_args, res
+
+
 class DLLWrapper(object):
     def __init__(self, filename, cwd='.', cdecl=True, fortran=True):
         self.filename = str(filename)
         if os.path.abspath(self.filename) in in_use:
             raise Exception(f'{os.path.abspath(self.filename)} already in use in current process.')
-        in_use.append(os.path.abspath(self.filename))
         self.cwd = cwd
         self.cdecl = cdecl
         self.fortran = fortran
         self.suppress_output = False
         self.open()
+        in_use.append(os.path.abspath(self.filename))
         atexit.register(self.close)
 
     @staticmethod
@@ -124,9 +194,10 @@ class DLLWrapper(object):
     def open(self):
         assert os.path.isfile(self.filename), os.path.abspath(self.filename)
         if self.cdecl:
-            if tuple(map(int, platform.python_version().split('.'))) < (3, 8):
+            try:
+                # python < (3, 8) and > 3.10?:
                 self.lib = ct.CDLL(self.filename)
-            else:
+            except BaseException:
                 self.lib = ct.CDLL(self.filename, winmode=ctypes.DEFAULT_MODE)
         else:
             self.lib = windll.LoadLibrary(self.filename)
@@ -148,82 +219,17 @@ class DLLWrapper(object):
 #         self.close()
 #         return False
 
-    def __getattribute__(self, name):
-        try:
-            return object.__getattribute__(self, name)
-        except AttributeError:
-            if name == 'lib':
-                raise Exception("DLL not loaded. Run using: 'with dll: ...'")
-            return self.get_lib_function(name)
+    def __getattr__(self, name):
+        if name == 'lib':
+            raise Exception("DLL not loaded. Run using: 'with dll: ...'")
+        return self.get_lib_function(name)
 
     def get_lib_function(self, name):
         try:
             f = getattr(self.lib, name)
         except AttributeError as e:
             raise AttributeError("Attribute '%s' not found in dll ('%s')" % (name, self.filename))
-
-        def wrap(*args, **kwargs):
-            c_args = []
-            args = list(args)
-            for i, arg in enumerate(args):
-                if isinstance(arg, (list, tuple)):
-                    if all([isinstance(e, int) for e in arg]):
-                        # default to int64 which is default on linux but not windows
-                        args[i] = np.array(arg, dtype=np.int64)
-                    else:
-                        args[i] = np.array(arg)
-                if isinstance(args[i], np.ndarray):
-                    if self.fortran:
-                        args[i] = np.asfortranarray(args[i])
-                    else:
-                        args[i] = np.ascontiguousarray(args[i])
-            for arg in args:
-                if isinstance(arg, int):
-                    c_args.append(c_int_p(c_int(arg)))
-                elif isinstance(arg, float):
-                    c_args.append(c_double_p(c_double(arg)))
-                elif isinstance(arg, str):
-                    c_args.append(c_char_p(arg.encode('cp1252')))
-                    # c_args.append(c_int_p(c_int(len(arg))))
-
-                elif isinstance(arg, np.ndarray):
-                    if arg.dtype in [np.int32]:
-                        c_args.append(arg.ctypes.data_as(c_int_p))
-                    elif arg.dtype in [np.int64]:
-                        c_args.append(arg.ctypes.data_as(c_long_p))
-                    elif arg.dtype == np.float64:
-                        c_args.append(arg.ctypes.data_as(c_double_p))
-                    else:
-                        raise NotImplementedError(arg.dtype)
-
-                else:
-                    # raise NotImplementedError(arg.__class__.__name__)
-                    c_args.append(arg)
-            if 'restype' in kwargs:
-                restype = kwargs['restype']
-                if hasattr(restype, 'dtype'):
-                    restype = np.ctypeslib.as_ctypes_type(restype)
-                f.restype = restype
-            with chdir(self.cwd):
-                if self.suppress_output:
-                    with SuppressStream(sys.stdout), SuppressStream(sys.stderr):
-                        res = f(*c_args)
-                else:
-                    res = f(*c_args)
-            ret_args = []
-            for arg in args:
-                c_arg = c_args.pop(0)
-                if isinstance(arg, (int, float)):
-                    ret_args.append(c_arg.contents.value)
-                elif isinstance(arg, (str)):
-                    ret_args.append(c_arg.value.decode('cp1252'))
-                    # c_args.pop(0)
-                elif isinstance(arg, np.ndarray):
-                    ret_args.append(arg)
-                else:
-                    raise NotImplementedError(arg.__class__.__name__)
-            return ret_args, res
-        return wrap
+        return lambda *args, **kwargs: wrap(self, f, *args, **kwargs)
 
     def version(self, function_name='get_version'):
         try:

h2lib/h2lib_signatures.py

@@ -33,6 +33,12 @@ end subroutine'''
 end subroutine'''
         return self.get_lib_function('extern_write_log')(c_msg, n, dll_name, error, warning)
 
+    def fail(self, str_arr):  # pragma: no cover
+        '''subroutine fail(str_arr) bind(C, name='fail')
+    character(kind=c_char, len=1), intent(inout)       :: str_arr(255)
+  end subroutine'''
+        return self.get_lib_function('fail')(str_arr)
+
     def finalize(self, ):
         '''SUBROUTINE finalize() bind(C, name="finalize")
 !DEC$ ATTRIBUTES DLLEXPORT :: finalize
@@ -115,6 +121,14 @@ END SUBROUTINE'''
   end subroutine'''
         return self.get_lib_function('get_induction_polargrid')(rotor, induction)
 
+    def get_induction_rotoravg(self, rotor, induction):
+        '''subroutine get_induction_rotoravg(rotor, induction) bind(C, name="get_induction_rotoravg")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_induction_rotoravg
+    integer*8, intent(in)        :: rotor
+    real(c_double), intent(out) :: induction
+  end subroutine'''
+        return self.get_lib_function('get_induction_rotoravg')(rotor, induction)
+
     def get_nSections(self, rotor, blade, restype):
         '''function get_nSections(rotor, blade) bind(C, name="get_nSections")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_nSections
@@ -181,10 +195,8 @@ END SUBROUTINE'''
         return self.get_lib_function('get_sensor_values')(ids, values, n)
 
     def get_time(self, time):
-        '''subroutine get_time(time) bind(C, name="get_time")
-      !DEC$ ATTRIBUTES DLLEXPORT :: get_time
-      double precision    :: time ! time [s]
-    end subroutine'''
+        '''subroutine
+subroutine'''
         return self.get_lib_function('get_time')(time)
 
     def get_version(self, s):
@@ -206,6 +218,15 @@ END SUBROUTINE'''
     end subroutine'''
         return self.get_lib_function('init_windfield')(Nxyz, dxyz, box_offset_yz, transport_speed)
 
+    def loop(self, N, restype):
+        '''function loop(N) bind(C, Name='loop')
+    !DEC$ ATTRIBUTES DLLEXPORT :: loop
+    integer*8, intent(in) :: N
+    real(c_double) :: loop,a
+    integer*8 :: i, j
+  end function'''
+        return self.get_lib_function('loop')(N, restype=restype)
+
     def myfunction(self, int, dbl, restype):
         '''function myfunction(int, dbl) bind(C, name='myfunction')
       !DEC$ ATTRIBUTES DLLEXPORT :: myfunction
@@ -258,7 +279,7 @@ END SUBROUTINE'''
 
     def set_windfield(self, uvw, box_offset_x, time):
         '''subroutine set_windfield(uvw, box_offset_x, time) bind(C, name="set_windfield")
-      real*8, intent(in) :: uvw(3, gwsd%TMOD%buffer_points_x,gwsd%TMOD%buffer_points_y,gwsd%TMOD%buffer_points_z)
+      real*4, intent(in) :: uvw(3, gwsd%TMOD%buffer_points_x,gwsd%TMOD%buffer_points_y,gwsd%TMOD%buffer_points_z)
       real*8, intent(in):: box_offset_x, time
     end subroutine'''
         return self.get_lib_function('set_windfield')(uvw, box_offset_x, time)
@@ -287,9 +308,11 @@ END SUBROUTINE'''
  end subroutine'''
         return self.get_lib_function('test_hdf5')()
 
-    def work(self, time):
-        '''subroutine work(time) bind(C, Name='work')
-    integer*8, intent(in) :: time
-    real*4 :: start_time
-  end subroutine'''
-        return self.get_lib_function('work')(time)
+    def work(self, time, restype):
+        '''function work(time) bind(C, Name='work')
+    !DEC$ ATTRIBUTES DLLEXPORT :: work
+    real(c_double), intent(in) :: time
+    real*4 :: start_time, t
+    integer*8 :: N, work
+  end function'''
+        return self.get_lib_function('work')(time, restype=restype)

{h2lib-13.0.605.dist-info → h2lib-13.0.705.dist-info}/METADATA

@@ -1,12 +1,15 @@
 Metadata-Version: 2.1
 Name: h2lib
-Version: 13.0.605
-Summary: Python interface to HAWC2 (13.0.6+8-g2148dea)
+Version: 13.0.705
+Summary: Python interface to HAWC2 (13.0.9)
 Download-URL: 
 Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
 Author-email: mmpe@dtu.dk
 Maintainer: 
 Maintainer-email: 
+Project-URL: Documentation, https://hawc2.pages.windenergy.dtu.dk/HAWC2Lib/
+Project-URL: Source, https://gitlab.windenergy.dtu.dk/HAWC2/HAWC2Lib
+Project-URL: Tracker, https://gitlab.windenergy.dtu.dk/HAWC2/HAWC2Lib/-/issues
 Requires-Dist: numpy
 Requires-Dist: intel-fortran-rt ==2021.3.0
 Requires-Dist: mkl ==2021.3.0

h2lib-13.0.705.dist-info/RECORD

@@ -0,0 +1,14 @@
+h2lib/HAWC2Lib.dll,sha256=GhnrcvnvBrC_KxHN2Asm1U7Ak6SW1axLhiBGPocwAvw,29301760
+h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
+h2lib/_h2lib.py,sha256=PvXyuoVW6IDbjeYWYtCHRYcpLMlZh7aCiJkfLBl88gg,14938
+h2lib/_version.py,sha256=xyyOn5ozEvCx53n7O9Ht13YA4b22VWeehuYZqCSUdEk,146
+h2lib/dll_wrapper.py,sha256=vO7IGbnPTpzrbjsvm-jRnYabXM97gCukJDTPJHDLEpA,11824
+h2lib/h2lib_signatures.py,sha256=uIcqvgVbm_L5C4jpHc9mBqz_6G5sLIk_6n2i-j1oA04,14500
+multiclass_interface/mpi_interface.py,sha256=eGftiuyQ3QkcenpEmbZjy_3VomWoXADnQsGUCFoFBvs,6274
+multiclass_interface/multi_object_list.py,sha256=5bEdwvtzQkPyBrS-W64i3EHJmuTfNGmRhGm5ToK7SXI,2072
+multiclass_interface/multiprocess_interface.py,sha256=L5G7-EL5rXQtze5-4oSTBFs0AjswbD2diNtt0ynfWOM,7271
+multiclass_interface/my_test_cls.py,sha256=7ZDsFkxrLfOY6q00U5Y-daxfuhATK-K5H04RP-VmQdE,850
+h2lib-13.0.705.dist-info/METADATA,sha256=54FEPqcr2y_3vR70shyoAVXYpWfUwFdJcDNWW-EFR3M,623
+h2lib-13.0.705.dist-info/WHEEL,sha256=3SeyPJ5-Us2Ct5GSftUVKtLSlm-bNefW4m5qd0GLzww,100
+h2lib-13.0.705.dist-info/top_level.txt,sha256=CafRr3oTgH80oaQrp2SGKlPcX7cag5ag4EGKAZAy1ow,27
+h2lib-13.0.705.dist-info/RECORD,,

{h2lib-13.0.605.dist-info → h2lib-13.0.705.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: false
 Tag: cp38-cp38-win_amd64
 

h2lib-13.0.705.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+h2lib
+multiclass_interface

multiclass_interface/mpi_interface.py

@@ -0,0 +1,184 @@
+import numpy as np
+import sys
+import os
+import subprocess
+import traceback
+import inspect
+from enum import Enum
+
+if 'SLURM_NTASKS' in os.environ:
+    mpi = int(os.environ['SLURM_NTASKS']) > 1
+elif any([k in os.environ for k in ['MPI_LOCALNRANKS', 'OMPI_COMM_WORLD_SIZE']]):
+    mpi = True
+else:
+    mpi = subprocess.run("python -c 'from mpi4py import MPI'", shell=True,
+                         check=False, stderr=subprocess.PIPE).returncode == 0
+
+if mpi:
+    from mpi4py import MPI
+    comm = MPI.COMM_WORLD
+    size = MPI.COMM_WORLD.Get_size()
+    rank = MPI.COMM_WORLD.Get_rank()
+    name = MPI.Get_processor_name()
+else:
+    size = 1
+
+MPIClassInterfaceAttributes = {'close', 'use_rank', 'cls', 'work_loop', 'object', '__class__','get_input','do_task', 'run_task', 'closed'}
+
+    
+LOOP_UNTIL_CLOSE=True
+TERMINATE_ON_CLOSE=True
+
+
+class MPIClassInterface():
+    def __init__(self, cls, args_lst):
+        if len(args_lst) > size:
+            if rank == 0:
+                raise Exception(f"Not enough mpi slots. Slots: {size}, Requested: {len(args_lst)}")
+            return
+        self.cls = cls
+        if rank < len(args_lst):
+            self.object = cls(*args_lst[rank])
+        else:
+            class Dummy():
+                def close(self):
+                    pass
+            self.object = Dummy()
+        self.closed=False
+
+        if rank == 0:
+            self.use_rank = np.array([True] * size)
+            self.use_rank[len(args_lst):] = False
+        elif LOOP_UNTIL_CLOSE:
+            self.work_loop()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def work_loop(self):
+        while True:
+            method, args, kwargs = comm.scatter(None)
+            comm.gather(self.do_task(method, args, kwargs))
+            if LOOP_UNTIL_CLOSE:
+                if method == 'close':
+                    if TERMINATE_ON_CLOSE:
+                        #comm.gather(f'Exit, rank {rank}')
+                        print ("sys.exit", rank, flush=True)
+                        sys.exit(0)
+                    else:
+                        raise ChildProcessError('MPI worker done')
+            else:
+                break    
+
+                    
+    def do_task(self, method, args, kwargs):
+        try:
+            if method == 'skip':
+                res = None
+            elif method=='setattr':
+                name, value = args
+                if hasattr(value, '__call__'):  
+                    def wrap(*args, func=value, **kwargs):
+                        if inspect.getfullargspec(func).args[:1] == ['self']:
+                            args = (self.object,) + args
+                        return func(*args, **kwargs)
+                    value = wrap
+                res = setattr(self.object, name, value)
+            else:
+                res = getattr(self.object, method)
+                if hasattr(res, '__call__'):
+                    res = res(*args, **kwargs)
+        except BaseException as e:
+            res = (e, traceback.format_exc())
+        return res
+        
+    def run_task(self, input_lst):
+        comm.scatter(input_lst, root=0)
+        if rank == 0:
+            method, args, kwargs = input_lst[0]
+            res = self.do_task(method, args, kwargs) 
+        else:
+            res = None
+        use_rank = self.use_rank
+       
+        res = [res for i, res in enumerate(comm.gather(res, root=0)) if use_rank[i]]
+        if rank==0:
+            for r in res:
+                if isinstance(r, tuple) and len(r) > 1 and isinstance(r[0], BaseException):
+                    raise r[0].__class__(r[1])
+        return res
+                
+    
+    def get_input(self, name, i, args, kwargs):
+        use_rank = self.use_rank
+        N = np.sum(use_rank)
+        if use_rank[i]:
+            def get_arg(arg):
+                if isinstance(arg, list) and len(arg) == N:
+                    return arg[np.where(use_rank)[0][i]]
+                else:
+                    return arg
+            return (name, [get_arg(arg) for arg in args], {k: get_arg(v) for k, v in kwargs.items()})
+        else:
+            return ('skip', [], {})
+    
+    def __getattribute__(self, name):
+        if name in MPIClassInterfaceAttributes:
+            return object.__getattribute__(self, name)
+        elif rank > 0:
+            self.work_loop()
+            return lambda *args, **kwargs:1
+        
+        def wrap(*args, **kwargs):
+            inp = [self.get_input(name, i, args, kwargs) for i in range(size)]
+            return self.run_task(inp)
+            
+        if hasattr(getattr(self.object, name), '__call__'):
+            return wrap
+        else:
+            return wrap()
+            
+    def __setattr__(self, name, value):
+        if rank > 0 or name in MPIClassInterfaceAttributes:
+            return object.__setattr__(self, name, value)
+        else:
+            inp = [self.get_input('setattr', i, (name, value), {}) for i in range(size)]
+            return self.run_task(inp)
+            
+
+    def __getitem__(self, slice):
+        use_rank = np.full_like(self.use_rank, False)
+        use_rank[slice] = True
+        if np.all(self.use_rank == use_rank):
+            return self
+        return SubsetMPIClassInterface(self.cls, self.object, use_rank)
+
+    def close(self):
+        if not self.closed:
+            if rank==0:
+                res = self.run_task([('close', [], {}) for _ in range(size)])
+            else:
+                self.work_loop()
+                res = None
+            self.closed=True
+                    
+                
+
+
+class SubsetMPIClassInterface(MPIClassInterface):
+    def __init__(self, cls, object, use_rank):
+        self.use_rank = use_rank
+        self.cls = cls
+        self.object = object
+
+    def __getitem__(self, slice):
+        l = np.arange(np.sum(self.use_rank))
+        if np.all(l == l[slice]):
+            return self
+        raise Exception('Cannot make subset of SubsetMPIClassInterface')
+
+    def close(self):
+        raise Exception('Cannot close SubsetMPIClassInterface. Please close all instances at once')

multiclass_interface/multi_object_list.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+
+class MultiObjectList():
+    def __init__(self, obj_lst, subset_cls=None):
+        self.obj_lst = np.atleast_1d(obj_lst)
+        self.subset_cls = subset_cls
+
+    def __str__(self):
+        return f'{self.__class__.__name__}({self.obj_lst})'
+
+    def get_obj_args_lst(self, args, kwargs):
+        N = len(self.obj_lst)
+
+        def get_obj_args(i):
+            def get_arg(arg):
+                if isinstance(arg, list) and len(arg) == N:
+                    return arg[i]
+                else:
+                    return arg
+            obj_args = [get_arg(arg) for arg in args]
+            obj_kwargs = {k: get_arg(v) for k, v in kwargs.items()}
+            return obj_args, obj_kwargs
+        return [get_obj_args(i) for i in range(N)]
+
+    def iscallable(self, name):
+        return hasattr(getattr(self.obj_lst[0], name), '__call__')
+
+    def __getitem__(self, s):
+        obj_lst = np.atleast_1d(self.obj_lst[s])
+        if len(obj_lst) == len(self.obj_lst) and np.all(obj_lst == self.obj_lst):
+            return self
+        subset_cls = self.subset_cls or MultiObjectList
+        return subset_cls(self.obj_lst[s])
+
+    def __getattr__(self, name):
+        att_lst = [getattr(obj, name) for obj in self.obj_lst]
+        if self.iscallable(name):
+            def wrap(*args, **kwargs):
+                return [att(*o_args, **o_kwargs)
+                        for att, (o_args, o_kwargs) in zip(att_lst, self.get_obj_args_lst(args, kwargs))]
+            return wrap
+        else:
+            return att_lst
+
+    def __setattr__(self, name, value):
+        if name in {'obj_lst', 'subset_cls'}:
+            return object.__setattr__(self, name, value)
+        obj_lst = self.obj_lst
+        for obj, (o_args, _) in zip(obj_lst, self.get_obj_args_lst((value,), {})):
+            setattr(obj, name, *o_args)
+
+
+class MultiClassInterface(MultiObjectList):
+    def __init__(self, cls, args_lst):
+        self.cls = cls
+        MultiObjectList.__init__(self, [cls(*args) for args in args_lst])

multiclass_interface/multiprocess_interface.py

@@ -0,0 +1,184 @@
+import multiprocessing
+import atexit
+import numpy as np
+from threading import Thread
+from functools import wraps
+import traceback
+from _queue import Empty
+import os
+from contextlib import contextmanager
+import sys
+import inspect
+from multiclass_interface.multi_object_list import MultiObjectList
+
+
+def run(cls, inputQueue, outputQueue, cls_args, **kwargs):
+    o = cls(*cls_args, **kwargs)
+    while True:
+        method, args, kwargs = inputQueue.get()
+        try:
+            if method == 'getattr':
+                name = args[0]
+                outputQueue.put(getattr(o, name))
+            elif method == 'setattr':
+                name, value = args
+                if hasattr(value, '__call__'):  # pragma: no cover # cov not registered?
+
+                    def wrap(*args, func=value, **kwargs):
+                        if inspect.getfullargspec(func).args[:1] == ['self']:
+                            args = (o,) + args
+                        return func(*args, **kwargs)
+                    outputQueue.put(setattr(o, name, wrap))
+                else:
+                    outputQueue.put(setattr(o, name, value))
+            elif method == 'iscallable':
+                name = args[0]
+                outputQueue.put(hasattr(getattr(o, name), '__call__'))
+            else:
+                att = getattr(o, method)
+                outputQueue.put(att(*args, **kwargs))
+                if method == 'close':
+                    outputQueue.put('Exit process')
+                    return
+        except BaseException as e:
+            outputQueue.put((e, traceback.format_exc()))
+
+
+class ProcessClass():
+    cls = None
+
+    def __init__(self, cls, cls_attrs={}):
+        self.cls_attrs = cls_attrs
+        self.cls = cls
+        self.ctx = multiprocessing.get_context('spawn')
+        self.inputQueue = self.ctx.Queue()
+        self.outputQueue = self.ctx.Queue()
+        atexit.register(self.close)
+        self.closed = False
+
+    def __call__(self, *args, **kwargs):
+        kwargs.update({'cls': self.cls, 'inputQueue': self.inputQueue, 'outputQueue': self.outputQueue,
+                       'cls_args': args})
+        s = 'vs_debug.py'
+        if s in "".join(traceback.format_stack()):  # pragma: no cover
+            self.process = Thread(target=run, kwargs=kwargs)  # use this to debug from Visual studio
+        else:
+            self.process = self.ctx.Process(target=run, kwargs=kwargs, daemon=True)
+
+        self.process.start()
+        return self
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __getattribute__(self, name):
+        try:
+            if name != 'cls_attrs' and name in self.cls_attrs:
+                raise AttributeError()
+            return object.__getattribute__(self, name)
+        except AttributeError:
+            if self.is_callable(name):
+                @wraps(getattr(self.cls, name, None))
+                def wrap(*args, wait_for_result=True, **kwargs):
+                    self.inputQueue.put((name, args, kwargs))
+                    if wait_for_result:
+                        return self.get_result(raise_exception=True,
+                                               cmd=lambda: f'executing {name}({", ".join(list(map(str,args))+["%s=%s"%(k,v) for k,v in kwargs.items()])})')
+                return wrap
+            else:
+                self.inputQueue.put(('getattr', (name,), {}))
+                return self.get_result(raise_exception=True, cmd=lambda: f"getting attribute '{name}'")
+
+    def is_callable(self, name):
+        self.inputQueue.put(('iscallable', (name,), {}))
+        return self.get_result(raise_exception=True, cmd=lambda: f"checking if '{name}' is callable")
+
+    def __setattr__(self, name, value):
+        if name in {'cls', 'ctx', 'inputQueue', 'outputQueue', 'closed', 'process', 'cls_attrs'}:
+            return object.__setattr__(self, name, value)
+        else:
+            self.inputQueue.put(('setattr', (name, value), {}))
+            return self.get_result(raise_exception=True, cmd=lambda: f"setting attribute '{name}'")
+
+    def get_result(self, raise_exception, cmd):
+        while True:
+            if self.process.is_alive() or self.closed:
+                try:
+                    res = self.outputQueue.get(timeout=2)
+                    if isinstance(res, tuple) and len(res) > 1 and isinstance(res[0], BaseException):
+                        res = res[0].__class__(res[1])
+                        if raise_exception:
+                            raise res
+                    return res
+                except Empty:
+                    pass  # time out. Check process is alive and try again
+            else:
+                if hasattr(cmd, '__call__'):
+                    cmd = cmd()
+                e = Exception(f'{self.cls.__name__} process died before or while {cmd}')
+                if raise_exception:
+                    raise e
+                return e
+
+    def close(self, wait_for_result=False):
+        if not self.closed:
+            self.inputQueue.put(('close', [], {}))
+            r = self.get_result(False, 'close')
+            self.process.join()
+            self.inputQueue.close()
+            self.outputQueue.close()
+            self.closed = True
+            return r
+
+
+class MultiProcessClassInterface(MultiObjectList):
+
+    def __init__(self, cls, args_lst, cls_attrs={}):
+        MultiObjectList.__init__(self, [ProcessClass(cls, cls_attrs)(*args) for args in args_lst], SubsetProcessWrapper)
+
+    def __getattr__(self, name):
+        obj_lst = self.obj_lst
+        if obj_lst[0].is_callable(name):
+            def wrap(*args, **kwargs):
+                for obj, (o_args, o_kwargs) in zip(obj_lst, self.get_obj_args_lst(args, kwargs)):
+                    getattr(obj, name)(*o_args, wait_for_result=False, **o_kwargs)
+                res = [o.get_result(raise_exception=False, cmd=lambda: f"executing {name}(...)")
+                       for o in obj_lst]
+                for r in res:
+                    if isinstance(r, Exception):
+                        raise r
+                return res
+            return wrap
+        else:
+            return [getattr(o, name) for o in obj_lst]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self, wait_for_result=False):
+        for obj in self.obj_lst:
+            obj.inputQueue.put(('close', [], {}))
+            obj.process.join()
+            obj.closed = True
+
+
+class SubsetProcessWrapper(MultiProcessClassInterface):
+    def __init__(self, obj_lst):
+        MultiObjectList.__init__(self, obj_lst)
+
+    def __getitem__(self, slice):
+        if np.all(np.atleast_1d(self.obj_lst[slice]) == self.obj_lst):
+            return self
+        raise Exception('Cannot make subset of SubsetProcessWrapper')
+
+    def __getattribute__(self, name):
+        if name == 'close':
+            raise Exception("Cannot close SubsetProcessWrapper. Please close all instances at once")
+
+        return MultiProcessClassInterface.__getattribute__(self, name)

multiclass_interface/my_test_cls.py

@@ -0,0 +1,33 @@
+import time
+import os
+
+
+class MyTest():
+    def __init__(self, id):
+        self.id = id
+        self.name = self.__class__.__name__
+
+    def get_id(self,):
+        return self.id
+
+    def work(self, t):
+        start_time = time.time()
+        s1 = f'{self.id} starts working for {t}s at t={start_time}. '
+        # print (s1)
+        while time.time() < start_time + t:
+            pass
+        s2 = f'{self.id} ends working at {time.time()}.'
+        # print (s2)
+        return s1 + s2
+
+    def return_input(self, *args, **kwargs):
+        return f"{self.id} got: {str(args)} and {str(kwargs)}"
+
+    def get_ld_library_path(self):
+        return os.environ['LD_LIBRARY_PATH']
+
+    def close(self):
+        return f"closing {self.get_id()}"
+
+    def raise_exception(self):
+        1 / 0  # raise ZeroDivisionError

h2lib/utils.py

@@ -1,149 +0,0 @@
-import multiprocessing
-import atexit
-import numpy as np
-from threading import Thread
-from functools import wraps
-import traceback
-
-
-def run(cls, inputQueue, outputQueue, cls_args, **kwargs):
-    o = cls(*cls_args, **kwargs)
-    while True:
-        method, args, kwargs = inputQueue.get()
-        # if method == "Sentinel":
-        #     outputQueue.put(method)
-        # else:
-        # print(method, args, kwargs)
-        att = getattr(o, method)
-        if hasattr(att, '__call__'):
-            outputQueue.put(att(*args, **kwargs))
-        else:
-            outputQueue.put(att)
-        if method == 'close':
-            outputQueue.put('Exit process')
-            return
-
-
-class ProcessClass():
-    cls = None
-
-    def __init__(self, cls, cls_attrs={}):
-        self.cls_attrs = cls_attrs
-        self.cls = cls
-        self.ctx = multiprocessing.get_context('spawn')
-        self.inputQueue = self.ctx.Queue()
-        self.outputQueue = self.ctx.Queue()
-        atexit.register(self.close)
-        self.closed = False
-
-    def __call__(self, *args, **kwargs):
-        kwargs.update({'cls': self.cls, 'inputQueue': self.inputQueue, 'outputQueue': self.outputQueue,
-                       'cls_args': args})
-        s = 'vs_debug.py'
-        if s in "".join(traceback.format_stack()):  # pragma: no cover
-            self.process = Thread(target=run, kwargs=kwargs)  # use this to debug from Visual studio
-        else:
-            self.process = self.ctx.Process(target=run, kwargs=kwargs, daemon=True)
-
-        self.process.start()
-        return self
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    def __getattribute__(self, name):
-        try:
-            if name != 'cls_attrs' and name in self.cls_attrs:
-                raise AttributeError()
-            return object.__getattribute__(self, name)
-        except AttributeError:
-            if hasattr(self.cls, name):
-                if hasattr(getattr(self.cls, name), '__call__'):
-                    @wraps(getattr(self.cls, name))
-                    def wrap(*args, wait_for_result=True, **kwargs):
-                        self.inputQueue.put((name, args, kwargs))
-                        if wait_for_result:
-                            return self.get_result()
-                    return wrap
-                else:
-                    self.inputQueue.put((name, (), {}))
-                    return self.get_result()
-            else:
-                raise AttributeError(f"'{self.cls.__name__}' object has no attribute '{name}'")
-
-    def get_result(self):
-        if self.process.is_alive() or self.closed:
-            return self.outputQueue.get()
-            # self.inputQueue.put(('Sentinel', (), {}))
-            # res_lst = []
-            # print('get result')
-            # while True:
-            #     print('get')
-            #     r = self.outputQueue.get()
-            #     print(' got')
-            #
-            #     if isinstance(r, str):
-            #         if r == 'Exit process':
-            #             return r
-            #         elif r == 'Sentinel':
-            #             return res_lst[0]
-            #         else:
-            #             res_lst.append(r)
-            #     else:
-            #         res_lst.append(r)
-
-        raise Exception(f'{self.cls.__name__} process died')
-
-    def close(self, wait_for_result=False):
-        self.inputQueue.put(('close', [], {}))
-        self.process.join()
-        self.closed = True
-
-
-class MultiProcessInterface():
-    def __init__(self, cls, args_lst):
-        self.cls = cls
-        self.obj_lst = [ProcessClass(cls)(*args) for args in args_lst]
-
-    def __getattribute__(self, name):
-        if name in ['obj_lst']:
-            return object.__getattribute__(self, name)
-
-        a_lst = self.obj_lst
-        if hasattr(getattr(self.obj_lst[0], name), '__call__'):
-            def wrap(*args, **kwargs):
-                for i, o in enumerate(self.obj_lst):
-                    def get_arg(arg):
-                        if isinstance(arg, list) and len(arg) == len(a_lst):
-                            return arg[i]
-                        else:
-                            return arg
-                    a_args = [get_arg(arg) for arg in args]
-                    a_kwargs = {k: get_arg(v) for k, v in kwargs.items()}
-                    getattr(o, name)(*a_args, wait_for_result=False, **a_kwargs)
-                if isinstance(self, SubsetProcessWrapper) and len(self.obj_lst) == 1:
-                    return self.obj_lst[0].get_result()
-                return [o.get_result() for o in self.obj_lst]
-            return wrap
-        else:
-            if isinstance(self, SubsetProcessWrapper) and len(self.obj_lst) == 1:
-                return getattr(self.obj_lst[0], name)
-            return [getattr(o, name) for o in self.obj_lst]
-
-    def __getitem__(self, slice):
-        lst = np.atleast_1d(np.array(self.obj_lst)[slice]).tolist()
-        return SubsetProcessWrapper(lst)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-
-class SubsetProcessWrapper(MultiProcessInterface):
-    def __init__(self, obj_lst):
-        self.obj_lst = obj_lst

h2lib-13.0.605.dist-info/RECORD

@@ -1,11 +0,0 @@
-h2lib/HAWC2Lib.dll,sha256=ftWvOdfiMu78t0_vMiZca3e7lJ2nOIgUyOgmHD31bZY,29311488
-h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
-h2lib/_h2lib.py,sha256=ZO2L9TWM3oJtkh3ixijw7o_8D1vyRd1fCIfNm2JdShA,13262
-h2lib/_version.py,sha256=fPq21FPnDoXOjYDsHMjXQQc1UKXkBMIKKOjGKNMZWh8,157
-h2lib/dll_wrapper.py,sha256=n--bPWNzJ2qR4F_kM8l2VI-impQRuAt7y8vA2cPF97c,11961
-h2lib/h2lib_signatures.py,sha256=KyhCNPmRoJasibDWQOOkUxganwXRFQBiwrus_iDGxpM,13579
-h2lib/utils.py,sha256=5EtSX4ByKg19TaI8EHtWa_C6A9jc6j5zGU1p0NHp6L0,5400
-h2lib-13.0.605.dist-info/METADATA,sha256=kYkdsl9WITSCHj8VZrGnco7P8oP_jj2vcO5OdsMGJ6Q,407
-h2lib-13.0.605.dist-info/WHEEL,sha256=KplWMgwSZbeAOumvxNxIrVbNPnn_LVzfBH7l38jDCVM,100
-h2lib-13.0.605.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
-h2lib-13.0.605.dist-info/RECORD,,

h2lib-13.0.605.dist-info/top_level.txt

@@ -1 +0,0 @@
-h2lib