h2lib 13.0.707__cp39-cp39-win_amd64.whl → 13.1.2__cp39-cp39-win_amd64.whl

h2lib/_version.py

@@ -1,4 +1,4 @@
 # This file is autogenerated and should not be modified manually
-__version__ = '13.0.707'
-h2lib_version = '13.0.707'
-hawc2_version = '13.0.9'
+__version__ = '13.1.2'
+h2lib_version = '13.1.2'
+hawc2_version = '13.0.15+2-g7269dc1'

{h2lib-13.0.707.dist-info → h2lib-13.1.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: h2lib
-Version: 13.0.707
-Summary: Python interface to HAWC2 (13.0.9)
+Version: 13.1.2
+Summary: Python interface to HAWC2 (13.0.15+2-g7269dc1)
 Download-URL: 
 Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
 Author-email: mmpe@dtu.dk
@@ -13,6 +13,7 @@ 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
+Requires-Dist: multiclass-interface
 Provides-Extra: test
 Requires-Dist: h2lib-tests ; extra == 'test'
 

h2lib-13.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+h2lib/HAWC2Lib.dll,sha256=T33F05MmIn4mQh63pYmL4_Jv6upICD-1oTledbiPI2A,29719552
+h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
+h2lib/_h2lib.py,sha256=PvXyuoVW6IDbjeYWYtCHRYcpLMlZh7aCiJkfLBl88gg,14938
+h2lib/_version.py,sha256=GnnP65jb_Q4MiTpjuuKjBhKDmw3s72xWWC6wOQilXYQ,154
+h2lib/dll_wrapper.py,sha256=vO7IGbnPTpzrbjsvm-jRnYabXM97gCukJDTPJHDLEpA,11824
+h2lib/h2lib_signatures.py,sha256=uIcqvgVbm_L5C4jpHc9mBqz_6G5sLIk_6n2i-j1oA04,14500
+h2lib-13.1.2.dist-info/METADATA,sha256=TIiOlfYvYN6WCivYlC1i8Na7V6tDIeyeiyx0jXWC3cU,670
+h2lib-13.1.2.dist-info/WHEEL,sha256=Z6c-bE0pUM47a70GvqO_SvH_XXU0lm62gEAKtoNJ08A,100
+h2lib-13.1.2.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
+h2lib-13.1.2.dist-info/RECORD,,

{h2lib-13.0.707.dist-info → h2lib-13.1.2.dist-info}/WHEEL

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

h2lib-13.1.2.dist-info/top_level.txt

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

h2lib-13.0.707.dist-info/RECORD

@@ -1,14 +0,0 @@
-h2lib/HAWC2Lib.dll,sha256=ZazvaRRCDiES0BaTcf6nB5akjZ1_dtjhlQyHE906_qE,29301760
-h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
-h2lib/_h2lib.py,sha256=PvXyuoVW6IDbjeYWYtCHRYcpLMlZh7aCiJkfLBl88gg,14938
-h2lib/_version.py,sha256=DTOnJ6TejF5GJdfnnNFQacsquZHuaLQ3ESheiuYsWeI,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=kby28wjkWPBpNEz76NyQlx6GH1h7C-3gKV2-jBTQ37I,7547
-multiclass_interface/my_test_cls.py,sha256=7ZDsFkxrLfOY6q00U5Y-daxfuhATK-K5H04RP-VmQdE,850
-h2lib-13.0.707.dist-info/METADATA,sha256=eKyPVPgLJpVJR4QTl1GHXLBUHz4QiCWRI19CdkFzZIg,623
-h2lib-13.0.707.dist-info/WHEEL,sha256=GZFS91_ufm4WrNPBaFVPB9MvOXR6bMZQhPcZRRTN5YM,100
-h2lib-13.0.707.dist-info/top_level.txt,sha256=CafRr3oTgH80oaQrp2SGKlPcX7cag5ag4EGKAZAy1ow,27
-h2lib-13.0.707.dist-info/RECORD,,

h2lib-13.0.707.dist-info/top_level.txt

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

multiclass_interface/mpi_interface.py

@@ -1,184 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,193 +0,0 @@
-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))
-        except BaseException as e:
-            outputQueue.put((e, traceback.format_exc()))
-        finally:
-            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:
-            return self.getattr(name, None)
-
-    def getattr(self, name, is_callable):
-        if is_callable is None:
-            is_callable = self.is_callable(name)
-        if is_callable:
-            @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.get_result(False, 'get process exit message')
-            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)):
-                    obj.getattr(name, True)(*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 [o.getattr(name, False) 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.close()
-            # if not obj.closed:
-            #     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

@@ -1,33 +0,0 @@
-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