kisa-utils 0.42.9__py3-none-any.whl → 0.42.11__py3-none-any.whl

kisa_utils/queues/persistent.py

@@ -7,6 +7,8 @@ from kisa_utils import dates
 from kisa_utils.functionUtils import enforceRequirements
 from kisa_utils.structures.utils import Value
 
+from typing import Callable
+
 class __PersistentQueueSingleton(type):
     _instances = {}
 
@@ -26,7 +28,6 @@ class __PersistentQueueSingleton(type):
 
         return cls._instances[idKey]
 
-
 class PersistentQueue(metaclass=__PersistentQueueSingleton):
     __openedQueues:dict = {} # name: PersistentQueue
 
@@ -81,7 +82,8 @@ class PersistentQueue(metaclass=__PersistentQueueSingleton):
         self.append = queueCallsInThreads(self.append, group=self.id)
         self.peek = queueCallsInThreads(self.peek, group=self.id)
         self.pop = queueCallsInThreads(self.pop, group=self.id)
-
+        self.process = queueCallsInThreads(self.process, group=self.id)
+        
         self.__load__ = queueCallsInThreads(self.__load__, group = "pqueue__load__")
 
         if not (resp := self.__load__()):
@@ -162,6 +164,7 @@ class PersistentQueue(metaclass=__PersistentQueueSingleton):
         self.__length += 1
         return Ok(self.__length)
 
+    @enforceRequirements
     def peek(self, index:int, /) -> Response:
         '''
         get data at `index` without popping it from the queue
@@ -182,6 +185,7 @@ class PersistentQueue(metaclass=__PersistentQueueSingleton):
 
         return Ok(data)
 
+    @enforceRequirements
     def pop(self, index:int = 0, /) -> Response:
         '''
         get data at `index` and remove it from the queue
@@ -206,3 +210,93 @@ class PersistentQueue(metaclass=__PersistentQueueSingleton):
             self.__length -= 1
 
         return Ok(data)
+
+    @enforceRequirements
+    def process(self, index:int, handler:Callable[...,Response], /, *, popOnHandlerSuccess:bool=True, popOnHandlerError:bool=False) -> Response:
+        '''
+        process item at `index` by passing it as an argument to `handler`
+        Args:
+            index(int): the index to process
+            handler(Callable): a function/method that takes a single argument and returns a `Response` object
+            popOnHandlerSuccess(bool): a bool indicating if the item should be poppoed if `handler` returns as `Ok` object
+            popOnHandlerError(bool): a bool indicating if the item should be poppoed if `handler` returns as `Error` object
+
+        Returns:
+            `Ok` object with a KDict containing the processed item along with if or not it was popped if all goes well, `Error` object otherwise
+        '''
+
+        if not (resp := self.peek(index)):
+            return resp
+
+        item = resp.data
+        try:
+            handlerResp = handler(item)
+        except Exception as e:
+            return Error(str(e))
+
+        if not isinstance(handlerResp, Response):
+            return Error(f'{handler.__name__} did not return a {Response} object!')
+
+        popped:bool = False
+
+        if handlerResp and popOnHandlerSuccess:
+            if not (resp := self.pop(index)):
+                ...
+            popped = True
+
+        if not handlerResp and popOnHandlerError and not popped:
+            if not (resp := self.pop(index)):
+                ...
+            popped = True
+
+        if (popOnHandlerSuccess or popOnHandlerError) and not popped:
+            # what do we do in such a case?
+            ...
+
+        return Ok(KDict({
+            'item': item,
+            'popped': popped
+        }))
+
+    @enforceRequirements
+    def processAll(self, handler:Callable[...,Response], /, *, popOnHandlerSuccess:bool=True, popOnHandlerError:bool=False) -> Response:
+        '''
+        process item at `index` by passing it as an argument to `handler`
+        Args:
+            handler(Callable): a function/method that takes a single argument and returns a `Response` object
+            popOnHandlerSuccess(bool): a bool indicating if the item should be poppoed if `handler` returns as `Ok` object
+            popOnHandlerError(bool): a bool indicating if the item should be poppoed if `handler` returns as `Error` object
+
+        Returns:
+            `Ok` object with a KDict containing processedCount,PoppedCount,failedCount,failedLogs if all goes well, `Error` object otherwise
+        '''
+
+        index = 0
+
+        results = KDict({
+            'processedCount': 0,
+            'PoppedCount': 0,
+            'failedCount': 0,
+            'failedLogs': [],
+        })
+
+        while index < len(self):
+            if not (resp := self.process(index, handler, popOnHandlerSuccess=popOnHandlerSuccess, popOnHandlerError=popOnHandlerError)):
+                results.processedCount += 1
+                results.failedCount += 1
+                index += 1
+                results.failedLogs.append(KDict({
+                    'item': self.peek(index).data,
+                    'error': resp.log
+                }))
+                continue
+
+            results.processedCount += 1
+
+            popped = resp.data.popped
+            if popped:
+                results.PoppedCount += 1
+            else:
+                index += 1
+
+        return Ok(results)

kisa_utils/structures/validator.py

@@ -3,7 +3,7 @@ this modules handle data structure validation to ensure that
 data is passed in expected formats/structures
 '''
 
-from typing import Any, get_args, get_origin
+from typing import Any, get_args, get_origin, Callable
 from types import UnionType
 from kisa_utils.structures.utils import Value
 from kisa_utils.response import Response, Ok, Error
@@ -54,6 +54,14 @@ def validate(instance:Any, structure:Any, path:str='$') -> dict:
         result['status'] = True
         return result
     else:
+        if isinstance(structure, Callable):
+            if not callable(instance):
+                result['log'] = f'E07: types not similar:: {path}, expected a Callable but got {str(type(instance))[7:-1]}'
+            else:
+                result['status'] = True
+
+            return result
+
         # checking in both directions as dict and KDict can fail when you check 
         # `isinstance(dict, KDict)` but will pass when the arguments switch positions
         if (not isinstance(instance,type(structure))) and (not isinstance(structure, type(instance))):

kisa_utils/threads.py

@@ -10,6 +10,7 @@ from concurrent import futures
 import time
 import datetime
 import threading
+import inspect
 from . import codes
 from .response import Response, Ok, Error
 from typing import Callable
@@ -43,8 +44,8 @@ class Group:
         add a function to the group
         Args:
             function(Callable): the function to be run
-            args(tuple): arguments and key-word arguments to be passsed to `function`
-            kwargs(dict): arguments and key-word arguments to be passsed to `function`
+            args(tuple): arguments to be passsed to `function`
+            kwargs(dict): key-word arguments to be passsed to `function`
         '''
         if not callable(function):
             return Error(f'`{function}` is not callable')
@@ -120,8 +121,8 @@ def runOnce(function:Callable, *args:tuple, **kwargs:dict) -> Response:
     run a task in a separate thread
     Args:
         function(Callable): the function to be run
-        args(tuple): arguments and key-word arguments to be passsed to `function`
-        kwargs(dict): arguments and key-word arguments to be passsed to `function`
+        args(tuple): arguments to be passsed to `function`
+        kwargs(dict): key-word arguments to be passsed to `function`
     '''
     __initExecutor()
 
@@ -129,7 +130,7 @@ def runOnce(function:Callable, *args:tuple, **kwargs:dict) -> Response:
         return Error(f'`{function}` is not callable')
 
     try:
-        return Ok(__executor.run(function, *args, **kwargs))
+        return Ok(__executor.run(function, *args, **kwargs).result())
     except Exception as e:
         return Error(f'failed to run task: {e}')
 
@@ -139,7 +140,11 @@ def __loop(function:Callable, duration:float, *args:tuple, **kwargs:dict) -> Non
     '''
     while 1:
         time.sleep(duration)
-        function(*args, **kwargs)
+        try:
+            function(*args, **kwargs)
+        except Exception as e:
+            print(f'`[run-every ERR] `{inspect.getsourcefile(function)}::{function.__name__}` failed with exception: e`')
+
 
 def runEvery(function:Callable, duration:float, *args:tuple, **kwargs:dict) -> dict[str,str|bool]:
     '''
@@ -147,8 +152,8 @@ def runEvery(function:Callable, duration:float, *args:tuple, **kwargs:dict) -> d
     Args:
         function(Callable): the function to call every `duration`
         duration(float): the time(in SECONDS) after which to run `function` periodically
-        args(tuple): arguments and key-word arguments to be passsed to `function`
-        kwargs(dict): arguments and key-word arguments to be passsed to `function`
+        args(tuple): arguments to be passsed to `function`
+        kwargs(dict): key-word arguments to be passsed to `function`
 
     Returns:
         dict in form
@@ -178,6 +183,8 @@ def runEvery(function:Callable, duration:float, *args:tuple, **kwargs:dict) -> d
         reply['log'] = f'failed to run task: {e}'
         return reply
 
+    # future.result()
+
     reply['status'] = True
     return reply
 
@@ -213,9 +220,10 @@ def __loopRoutineThreads():
 
             try:
                 future = __executor.run(data['function'],*data['args'], **data['kwargs'])         
+                # future.result()
                 currentMinuteData['functionsAlreadyRun'][functionName] = None
             except Exception as e:
-                print(f'[routine-loop]: {e}')
+                print(f'[routine-loop ERR]: {e}')
                 pass
 
 def runAt(function:Callable, timesOfDay:list[tuple[int,int]], weekDays:list[int], *args:tuple, tzHoursFromUTC:float = +3.00, **kwargs:dict) -> Response:
@@ -227,8 +235,8 @@ def runAt(function:Callable, timesOfDay:list[tuple[int,int]], weekDays:list[int]
         weekDays(list[int]): a list of `ints` each ranging `0-6, inclusive` indicating a day of the week where `0=sunday` and `6=saturday`
         tzHoursFromUTC(float): hours to add/subtract from UTC. this allows for `timesOfDay` to be seen in a particular timezone. 
                                     the default value is `+3.00` ie `EAT` so times in `timesOfDay` are in EAT
-        args(tuple): arguments and key-word arguments to be passsed to `function`
-        kwargs(dict): arguments and key-word arguments to be passsed to `function`
+        args(tuple): arguments to be passsed to `function`
+        kwargs(dict): key-word arguments to be passsed to `function`
     
     '''
 
@@ -282,7 +290,8 @@ def __initExecutor():
     if __executor: return
 
     __executor = __Executor()
-    __executor.run(__loopRoutineThreads)
+    future = __executor.run(__loopRoutineThreads)
+    # future.result()
 
 # futures.as_completed([__executor.run(__loopRoutineThreads)])
 

{kisa_utils-0.42.9.dist-info → kisa_utils-0.42.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kisa-utils
-Version: 0.42.9
+Version: 0.42.11
 Summary: Utility functions and modules for KISA Developers
 Author: Tom Bukenya
 Author-email: glayn2bukman@gmail.com

{kisa_utils-0.42.9.dist-info → kisa_utils-0.42.11.dist-info}/RECORD

@@ -13,12 +13,12 @@ kisa_utils/remote.py,sha256=0RDrfC4RUW4m6JLziC0_EXJYqzWp38Rw8NDroJ0MuqI,2149
 kisa_utils/response.py,sha256=asETUBkeF5OlSTwa-coa7lZDCKmQlHCmHf6eaZFl8CU,4560
 kisa_utils/standardize.py,sha256=nt-uzHQFoKxGscD_MpDYXw65Teg3724whAqa6Kh_zhE,2231
 kisa_utils/storage.py,sha256=6NdEVrHMS7WB_vmCwiGigIinu-EjxalFJhk1kj-_vWs,5990
-kisa_utils/threads.py,sha256=qQqsf64YHMyLpboq5AEXKxYqf3iXUhxiJe6Ymg-vlxI,12840
+kisa_utils/threads.py,sha256=U1hVCmDoCrWsi8fOJptewJ0Q0hXtGn8UZVT52pbC36E,12979
 kisa_utils/token.py,sha256=Y2qglWYWpmHxoXBh-TH0r1as0uPV5LLqMNcunLvM4vM,7850
 kisa_utils/permissions/__config__.py,sha256=i3ELkOydDnjKx2ozQTxLZdZ8DXSeUncnl2kRxANjFmM,613
 kisa_utils/permissions/__init__.py,sha256=iAsGEf5Ktw3gPJ5ZKL8BnuqX8e_S4QgsCVgfaRYi4Qg,48068
 kisa_utils/queues/__init__.py,sha256=VvhceyN5qeiMel1JFQwLRuVk48oBXaWvDtriCubDOms,48
-kisa_utils/queues/persistent.py,sha256=KueLVqkVcTqvVe5yt9DEM_PvtUEannukixRS8icONTI,6872
+kisa_utils/queues/persistent.py,sha256=b731r1NJkOxlJdkYoxDx2Ojf8loTCY87sd-1_xWn_L4,10431
 kisa_utils/queues/callables/__init__.py,sha256=OJL3AQnaAS1Eek4H6WBH3WefA2wf-x03cwFmRSK8hoU,141
 kisa_utils/queues/callables/enqueueFunctionCalls.py,sha256=VIliaMvw4MUdOqts0dXdZCYNxs-QrOVjIRAR3scGrRM,11786
 kisa_utils/queues/callables/executorQueues.py,sha256=x6bAqxBSZRZ_kL8CK1lSN6JYAYFLxzM84LC1RmwaOLw,6626
@@ -26,8 +26,8 @@ kisa_utils/servers/__init__.py,sha256=lPqDyGTrFo0qwPZ2WA9Xtcpc5D8AIU4huqgFx1iZf6
 kisa_utils/servers/flask.py,sha256=XZYY1pWnP1mSvaS5Uv8G3EFJV5BJBQtU2gDbO8suvLc,40422
 kisa_utils/structures/__init__.py,sha256=JBU1j3A42jQ62ALKnsS1Hav9YXcYwjDw1wQJtohXPbU,83
 kisa_utils/structures/utils.py,sha256=665rXIapGwFqejizeJwy3DryeskCQOdgP25BCdLkGvk,2898
-kisa_utils/structures/validator.py,sha256=JhD9jcfbjTwBr_7OfuNaJd_cYr7wR2emFhsCEo5MCHQ,4323
-kisa_utils-0.42.9.dist-info/METADATA,sha256=ggmPfO1oysfdUkAExab5IOmqtA6pgvrD5O_orx1WzaU,477
-kisa_utils-0.42.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-kisa_utils-0.42.9.dist-info/top_level.txt,sha256=GFOLXZYqpBG9xtscGa2uGJAEiZ5NwsqHBH9NylnB29M,11
-kisa_utils-0.42.9.dist-info/RECORD,,
+kisa_utils/structures/validator.py,sha256=oCSgY_itst6bZdC5g8yVU4-lSH2xnUsOx3X-oPyV7nA,4626
+kisa_utils-0.42.11.dist-info/METADATA,sha256=RRVFT0IudGdenO9WQWlCG9AXy2RBec1YTC7pB-VhAlw,478
+kisa_utils-0.42.11.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+kisa_utils-0.42.11.dist-info/top_level.txt,sha256=GFOLXZYqpBG9xtscGa2uGJAEiZ5NwsqHBH9NylnB29M,11
+kisa_utils-0.42.11.dist-info/RECORD,,