osbot-utils 1.43.0__tar.gz → 1.44.0__tar.gz

{osbot_utils-1.43.0 → osbot_utils-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.43.0
+Version: 1.44.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.43.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.44.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.43.0 → osbot_utils-1.44.0}/README.md

@@ -2,7 +2,7 @@
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.43.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.44.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

osbot_utils-1.44.0/osbot_utils/context_managers/async_invoke.py

@@ -0,0 +1,27 @@
+import logging
+from contextlib import contextmanager
+import asyncio
+
+@contextmanager
+def async_invoke():
+    logger         = logging.getLogger('asyncio')
+    level_original = logger.level
+    logger.level   = logging.INFO                          # this will suppress the asyncio debug messages which where showing in tests
+    try:
+        original_loop = asyncio.get_event_loop()
+    except RuntimeError:
+        original_loop = None
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    try:
+        yield loop.run_until_complete
+    finally:
+        loop.close()
+        if original_loop is not None:
+            asyncio.set_event_loop(original_loop)
+        else:
+            asyncio.set_event_loop(None)
+
+        logger.level = level_original                           # restore the original log level

osbot_utils-1.44.0/osbot_utils/helpers/pubsub/Event__Queue.py

@@ -0,0 +1,127 @@
+import time
+from queue                                                      import Queue, Empty
+from threading                                                  import Thread
+from osbot_utils.base_classes.Type_Safe                         import Type_Safe
+from osbot_utils.helpers.pubsub.schemas.Schema__Event           import Schema__Event
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Message  import Schema__Event__Message
+from osbot_utils.utils.Misc                                     import random_text, timestamp_utc_now, random_guid
+
+TIMEOUT__THREAD_JOIN              = 1.0                             # todo: see if this value is a good one to use here
+TIMEOUT__QUEUE_GET                = 1.0
+TIMEOUT__WAIT_FOR_QUEUE_COMPLETED = 0.05                            # todo: see if this value is too aggressive (or if will be better to use a value like 0.1 or 0.5)
+
+
+class Event__Queue(Type_Safe):
+    events              : list
+    event_class         : type
+    events_added        : int
+    events_completed    : int
+    events_failed       : int
+    log_events          : bool   = False
+    queue               : Queue
+    queue_name          : str    = random_text('event_queue')
+    queue_get_timeout   : float  = TIMEOUT__QUEUE_GET
+    running             : bool
+    thread              : Thread = None
+
+
+    def __init__(self, **kwargs):
+        self.event_class = Schema__Event
+        super().__init__(**kwargs)
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+        return False
+
+    def new_event_obj(self, **kwargs):
+        return self.event_class(**kwargs)
+
+    def handle_event(self, event):
+        if self.log_events:
+            self.events.append(event)
+        return True
+
+    def send_event(self, event: Schema__Event):
+        if isinstance(event, Schema__Event):
+            if not event.timestamp:
+                event.timestamp = timestamp_utc_now()
+            if not event.event_id:
+                event.event_id = random_guid()
+            self.events_added += 1
+            self.queue.put(event)
+            return True
+        return False
+
+    def send_data(self, event_data, **kwargs):
+        if type(event_data) is not dict:
+            event_data = {'data': event_data}
+        new_event = Schema__Event__Message(event_data=event_data, **kwargs)
+        if self.send_event(new_event):
+            return new_event
+
+    def send_message(self, message, **kwargs):
+        new_event = Schema__Event__Message(event_message=str(message), **kwargs)
+        if self.send_event(new_event):
+            return new_event
+
+    def start(self):
+        self.running = True
+        self.thread =  Thread(target=self.run_thread, daemon=True)
+        self.thread.start()
+        return self
+
+    def stop(self):
+        self.running = False                                         # will make the event loop stop at the next self.queue_get_timeout
+        return self
+
+    def queue_size(self):
+        return self.queue.qsize()
+
+    def run_thread(self):
+        while self.running:
+            try:
+                event = self.queue.get(timeout=self.queue_get_timeout)
+                if isinstance(event, self.event_class):
+                    self.handle_event(event)
+                    self.events_completed += 1
+            except Empty:
+                continue
+            except Exception as e:                          # todo: add way to handle this (which are errors in the handle_event), may call an on_event_handler_exceptions method
+                self.events_failed += 1
+                continue
+
+    def wait_micro_seconds(self, value=10):
+        time.sleep(0.000001 * value)
+
+
+    def wait_for_thread_ends(self):
+        self.thread.join()
+        return self
+
+    # todo see if there are valid use cases for wait_for_queue_empty , or the wait_for_queue_completed is the one that is always used
+    def wait_for_queue_empty(self, thread_join_timeout=TIMEOUT__THREAD_JOIN):             # this will start a new thread to wait for the main queue to be empty
+        def wait_until_queue_empty():
+            while self.running:
+                if self.queue.empty():
+                    break
+                time.sleep(0.01)
+
+        wait_thread = Thread(target=wait_until_queue_empty)
+        wait_thread.start()
+        wait_thread.join(timeout=thread_join_timeout)
+        return self.queue.empty()
+
+    def wait_for_queue_completed(self, thread_join_timeout=TIMEOUT__THREAD_JOIN):             # this will start a new thread to wait for the main queue to be empty
+        def wait_until_queue_completed():
+            while self.running:
+                if self.queue.empty() and self.events_added == self.events_completed :
+                    break
+                time.sleep(TIMEOUT__WAIT_FOR_QUEUE_COMPLETED)
+        wait_thread = Thread(target=wait_until_queue_completed)
+        wait_thread.start()
+        wait_thread.join(timeout=thread_join_timeout)
+        return self.queue.empty()

osbot_utils-1.44.0/osbot_utils/helpers/pubsub/schemas/Schema__Event__Disconnect.py

@@ -0,0 +1,4 @@
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+
+class Schema__Event__Disconnect(Schema__Event):
+    event_type : str  = 'disconnect'

osbot_utils-1.44.0/osbot_utils/helpers/pubsub/schemas/Schema__Event__Execute_Method.py

@@ -0,0 +1,14 @@
+import types
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+
+class Schema__Event__Execute_Method(Schema__Event):
+    event_type       : str                 = 'execute-method'
+    execution_result : object              = None
+    method_target    : types.MethodType
+    method_args      : list
+    method_kwargs    : dict
+
+
+    def execute(self):
+        self.execution_result = self.method_target(*self.method_args, **self.method_kwargs)
+        return self.execution_result

{osbot_utils-1.43.0 → osbot_utils-1.44.0}/osbot_utils/helpers/trace/Trace_Call__Config.py

@@ -1,5 +1,4 @@
-from osbot_utils.utils.Dev import pprint
-
+from osbot_utils.utils.Dev                   import pprint
 from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
 
 PRINT_MAX_STRING_LENGTH    = 100
@@ -7,14 +6,12 @@ PRINT_PADDING__DURATION    = 100
 PRINT_PADDING_PARENT_INFO  = 60
 
 class Trace_Call__Config(Kwargs_To_Self):
-    title                      : str
     capture_locals             : bool = False
     capture_duration           : bool
     capture_extra_data         : bool
     capture_frame              : bool = True
     capture_frame_stats        : bool
     deep_copy_locals           : bool
-    trace_capture_lines        : bool
     ignore_start_with          : list
     print_padding_duration     : int = PRINT_PADDING__DURATION
     print_padding_parent_info  : int = PRINT_PADDING_PARENT_INFO
@@ -27,6 +24,7 @@ class Trace_Call__Config(Kwargs_To_Self):
     show_caller                : bool
     show_method_class          : bool = True
     show_source_code_path      : bool
+    title                      : str
     trace_capture_all          : bool
     trace_capture_source_code  : bool
     trace_capture_start_with   : list
@@ -34,6 +32,7 @@ class Trace_Call__Config(Kwargs_To_Self):
     trace_enabled              : bool = True
     trace_ignore_start_with    : list
     trace_ignore_contains      : list
+    trace_capture_lines        : bool
     trace_show_internals       : bool
     trace_up_to_depth          : int
     with_duration_bigger_than  : float

osbot_utils-1.44.0/osbot_utils/utils/Threads.py

@@ -0,0 +1,27 @@
+import asyncio
+import logging
+import typing
+
+def invoke_async_function(target: typing.Coroutine):
+    """Run an asynchronous coroutine in a new event loop."""
+    logger         = logging.getLogger('asyncio')
+    level_original = logger.level
+    logger.level   = logging.INFO  # this will suppress the asyncio debug messages which where showing in tests
+    try:
+        original_loop = asyncio.get_event_loop()
+    except RuntimeError:
+        original_loop = None  # No event loop was set
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(target)
+    finally:
+        loop.close()
+        # Restore the original event loop
+        if original_loop is not None:
+            asyncio.set_event_loop(original_loop)
+        else:
+            asyncio.set_event_loop(None)
+
+        logger.level = level_original  # restore the original log level

osbot_utils-1.44.0/osbot_utils/version

@@ -0,0 +1 @@
+v1.44.0

{osbot_utils-1.43.0 → osbot_utils-1.44.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v1.43.0"
+version     = "v1.44.0"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <dinis.cruz@owasp.org>"]
 license     = "MIT"

osbot_utils-1.43.0/osbot_utils/helpers/pubsub/Event__Queue.py

@@ -1,95 +0,0 @@
-import time
-from enum import Enum
-from queue                                      import Queue, Empty
-from threading                                  import Thread
-from typing import Any
-
-from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
-from osbot_utils.helpers.pubsub.schemas.Schema__Event__Message import Schema__Event__Message
-from osbot_utils.utils                                import Misc
-from osbot_utils.base_classes.Kwargs_To_Self          import Kwargs_To_Self
-from osbot_utils.utils.Misc import random_text, wait_for, timestamp_utc_now, random_guid
-
-QUEUE_WAIT_TIMEOUT  = 1.0                           # todo: see if this value is a good one to use here
-
-class Event__Queue(Kwargs_To_Self):
-    events       : list
-    event_class  : type
-    log_events   : bool   = False
-    queue        : Queue
-    queue_name   : str    = random_text('event_queue')
-    queue_timeout: float  = QUEUE_WAIT_TIMEOUT
-    running      : bool
-    thread       : Thread = None
-
-
-    def __init__(self, **kwargs):
-        self.event_class = Schema__Event
-        super().__init__(**kwargs)
-
-    def __enter__(self):
-        self.start()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.stop()
-        return False
-
-    def new_event_obj(self, **kwargs):
-        return self.event_class(**kwargs)
-
-    def handle_event(self, event):
-        if self.log_events:
-            self.events.append(event)
-        return True
-
-    def send_event(self, event: Schema__Event):
-        if isinstance(event, Schema__Event):
-            if not event.timestamp:
-                event.timestamp = timestamp_utc_now()
-            if not event.event_id:
-                event.event_id = random_guid()
-            self.queue.put(event)
-            return True
-        return False
-
-    def send_data(self, event_data, **kwargs):
-        if type(event_data) is not dict:
-            event_data = {'data': event_data}
-        new_event = Schema__Event__Message(event_data=event_data, **kwargs)
-        if self.send_event(new_event):
-            return new_event
-
-    def send_message(self, message, **kwargs):
-        new_event = Schema__Event__Message(event_message=str(message), **kwargs)
-        if self.send_event(new_event):
-            return new_event
-
-    def start(self):
-        self.running = True
-        self.thread =  Thread(target=self.run_thread, daemon=True)
-        self.thread.start()
-        return self
-
-    def stop(self):
-        self.running = False
-        return self
-
-    def run_thread(self):
-        while self.running:
-            try:
-                event = self.queue.get(timeout=self.queue_timeout)
-                if isinstance(event, self.event_class):
-                    self.handle_event(event)
-            except Empty:
-                continue
-            except Exception as e:                          # todo: add way to handle this (which are errors in the handle_event), may call an on_event_handler_exceptions method
-                continue
-
-    def wait_micro_seconds(self, value=10):
-        time.sleep(0.000001 * value)
-
-
-    def wait_for_thread_ends(self):
-        self.thread.join()
-        return self

osbot_utils-1.43.0/osbot_utils/helpers/pubsub/schemas/Schema__Event__Disconnect.py

@@ -1,7 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
-from osbot_utils.utils.Misc import random_guid
-
-
-class Schema__Event__Disconnect(Schema__Event):
-    event_type : str  = 'disconnect'

osbot_utils-1.43.0/osbot_utils/version

@@ -1 +0,0 @@
-v1.43.0