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

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.604.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: h2lib
-Version: 13.0.604
-Summary: Python interface to HAWC2 (13.0.6+5-g438f4c5)
-Download-URL: 
-Author: S.G.Horcas and N.G.Ramos
-Author-email: 
-Maintainer: 
-Maintainer-email: 
-Requires-Dist: numpy
-Requires-Dist: intel-fortran-rt ==2021.3.0
-Requires-Dist: mkl ==2021.3.0
-Provides-Extra: test
-Requires-Dist: h2lib-tests ; extra == 'test'
-

h2lib-13.0.604.dist-info/RECORD

@@ -1,11 +0,0 @@
-h2lib/HAWC2Lib.dll,sha256=UJUTEQmd7XG_pjM92kNDutX_fNX9YQzlMpg9UFm2kIE,29309952
-h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
-h2lib/_h2lib.py,sha256=bW67zt5aBWshTCNMM3BV10xvrPGs-8uTrMo65AbskEA,12011
-h2lib/_version.py,sha256=JOfUkYqbKt7CtLcwwE8OpdNNvdDbDsa-8kVL-OEpFhU,157
-h2lib/dll_wrapper.py,sha256=jFCcT1gnjIl6k_I5nvzeLgG75I0D5VTiWwwWKV7M77w,11962
-h2lib/h2lib_signatures.py,sha256=u-xOD-7dpoxOtG2K5a9ARHzchpg-nBV6Grt4iBDXV1o,12811
-h2lib/utils.py,sha256=5EtSX4ByKg19TaI8EHtWa_C6A9jc6j5zGU1p0NHp6L0,5400
-h2lib-13.0.604.dist-info/METADATA,sha256=ytTx9p2B2dLeHd_7iBFNgn1msrx7fvPu-v6w2Uek0Fg,378
-h2lib-13.0.604.dist-info/WHEEL,sha256=KplWMgwSZbeAOumvxNxIrVbNPnn_LVzfBH7l38jDCVM,100
-h2lib-13.0.604.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
-h2lib-13.0.604.dist-info/RECORD,,

h2lib-13.0.604.dist-info/top_level.txt

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