osbot-utils 1.60.0__tar.gz → 1.61.0__tar.gz

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.60.0
+Version: 1.61.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Project-URL: Repository, https://github.com/owasp-sbot/OSBot-Utils
 Description-Content-Type: text/markdown
 
@@ -22,7 +23,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.60.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.61.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.60.0 → osbot_utils-1.61.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.60.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.61.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.61.0/osbot_utils/helpers/Timestamp_Now.py

@@ -0,0 +1,13 @@
+from osbot_utils.utils.Misc import timestamp_now
+
+class Timestamp_Now(int):
+    def __new__(cls, value=None):
+        if value is None:
+            value = timestamp_now()
+        return int.__new__(cls, value)
+
+    def __init__(self, value=None):
+        self.value = value if value is not None else timestamp_now()
+
+    def __str__(self):
+        return str(self.value)

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/osbot_utils/helpers/flows/Flow.py

@@ -2,17 +2,17 @@ import asyncio
 import logging
 import typing
 
-from osbot_utils.helpers.Dependency_Manager import Dependency_Manager
-
-from osbot_utils.base_classes.Type_Safe             import Type_Safe
-from osbot_utils.helpers.CFormat                    import CFormat, f_dark_grey, f_magenta, f_bold
-from osbot_utils.helpers.flows.models.Flow__Config  import Flow__Config
-from osbot_utils.helpers.flows.Flow__Events         import flow_events
-from osbot_utils.testing.Stdout                     import Stdout
-from osbot_utils.utils.Misc                         import random_id, lower
-from osbot_utils.utils.Python_Logger                import Python_Logger
-from osbot_utils.utils.Str                          import ansis_to_texts
-from osbot_utils.utils.Threads                      import invoke_in_new_event_loop
+from osbot_utils.helpers.Dependency_Manager             import Dependency_Manager
+from osbot_utils.base_classes.Type_Safe                 import Type_Safe
+from osbot_utils.helpers.CFormat                        import CFormat, f_dark_grey, f_magenta, f_bold
+from osbot_utils.helpers.flows.models.Flow_Run__Config  import Flow_Run__Config
+from osbot_utils.helpers.flows.Flow__Events             import flow_events
+from osbot_utils.helpers.flows.models.Flow_Run__Event_Data import Flow_Run__Event_Data
+from osbot_utils.testing.Stdout                         import Stdout
+from osbot_utils.utils.Misc                             import random_id, lower
+from osbot_utils.utils.Python_Logger                    import Python_Logger
+from osbot_utils.utils.Str                              import ansis_to_texts
+from osbot_utils.utils.Threads                          import invoke_in_new_event_loop
 
 FLOW__RANDOM_ID__PREFIX    = 'flow_id__'
 FLOW__RANDOM_NAME__PREFIX  = 'flow_name__'
@@ -26,7 +26,7 @@ class Flow(Type_Safe):
     data               : dict                   # dict available to the tasks to add and collect data
     flow_id            : str
     flow_name          : str
-    flow_config        : Flow__Config
+    flow_config        : Flow_Run__Config
     flow_error         : Exception           = None
     flow_target        : callable
     flow_args          : tuple
@@ -39,20 +39,22 @@ class Flow(Type_Safe):
     resolved_args      : tuple
     resolved_kwargs    : dict
 
-    def add_flow_artifact(self, description=None, key=None, data=None, artifact_type=None):     # todo: figure out how to make this work since at the moment most are showing an unknown type 
-        result_data = dict(flow_run_id = self.flow_id,
-                           description = description    or 'description'                                                    ,
-                           key         = key            or 'an-artifact-key'                                                ,
-                           data        = data           or {"link": "https://www.google.com", "link_text": "link to Google"},       # test data to see if it worksw
-                           type        = artifact_type  or "link"                                                           )   # type clashed with built-in type
+    def add_flow_artifact(self, description=None, key=None, data=None, artifact_type=None):     # todo: figure out how to make this work since at the moment most are showing an unknown type
+        event_data = Flow_Run__Event_Data()
+        event_data.data= dict(artifact_data = dict(description = description or 'description',
+                                                   key         = key  or 'an-artifact-key',
+                                                   data        = data or {"link": "https://www.google.com", "link_text": "link to Google"},  # test data to see if it worksw
+                                                   type        = artifact_type or "link"))                                                   # type clashed with built-in type
+        event_data.flow_run_id = self.flow_id
+        flow_events.on__new_artifact(event_data)
 
-        flow_events.on__new_artifact(self, result_data )
 
     def add_flow_result(self, key, description):
-        result_data = dict(flow_run_id = self.flow_id,
-                           key         = key         ,
-                           description = description )
-        flow_events.on__new_result(self, result_data )
+        event_data = Flow_Run__Event_Data()
+        event_data.flow_run_id = self.flow_id
+        event_data.data        = dict(result_data = dict(key         = key         ,
+                                                         description = description ))
+        flow_events.on__new_result(event_data)
 
     def config_logger(self):
         with self.logger as _:
@@ -61,15 +63,12 @@ class Flow(Type_Safe):
             if self.flow_config.log_to_console:
                 _.add_console_logger()
 
-    def create_flow(self):
-        self.set_flow_name()
-        self.log_debug(f"Created flow run '{self.f__flow_id()}' for flow '{self.f__flow_name()}'")
-
     def execute(self):
         return self.execute_flow()
 
     def execute_flow(self, flow_run_params=None):                               # todo: see if it makes more sense to call this start_flow_run
-        flow_events.on__flow__start(self)
+        flow_events.on__flow__start(self.flow_event_data())
+        self.log_debug(f"Created flow run '{self.f__flow_id()}' for flow '{self.f__flow_name()}'")
         self.set_flow_run_params(flow_run_params)
 
         if self.flow_config.log_to_memory:
@@ -93,7 +92,7 @@ class Flow(Type_Safe):
             self.logger.remove_memory_logger()                                                          # todo: move to method that does post-execute tasks
         if self.flow_return_value:
             self.add_flow_result(key = 'flow-return-value', description=f'{self.flow_return_value}')
-        flow_events.on__flow__stop(self)
+        flow_events.on__flow__stop(self.flow_event_data())
         return self
 
     def captured_logs(self):
@@ -116,6 +115,11 @@ class Flow(Type_Safe):
     def f__flow_name(self):
         return self.cformat.blue(self.flow_name)
 
+    def flow_event_data(self):
+        kwargs = dict(flow_name   = self.flow_name  ,
+                      #flow_id     = self.flow_id    ,           # todo: add support for actually sending the flow_id value (not the flow_run_id)
+                      flow_run_id = self.flow_id    )
+        return Flow_Run__Event_Data(**kwargs)
 
     def log_captured_stdout(self, stdout):
         for line in stdout.value().splitlines():
@@ -142,7 +146,7 @@ class Flow(Type_Safe):
                           message     = message     ,
                           flow_run_id = self.flow_id,
                           task_run_id = task_run_id )
-            flow_events.on__flow_run__message(self, **kwargs)
+            flow_events.on__flow_run__message(**kwargs)
             if log_level == logging.DEBUG:
                 self.logger.debug(message)
             elif log_level == logging.ERROR:
@@ -216,11 +220,13 @@ class Flow(Type_Safe):
             self.log_info(f"flow_run_params: {flow_run_params}")
             self.add_flow_artifact(description="Data received via FastAPI's request.json()", key='post-data', data=flow_run_params)
 
-    def setup(self):
+    def setup(self, target, *args, **kwargs):
         with self as _:
             _.cformat.auto_bold = True
-            _.config_logger()
-            _.setup_flow_run()
+            _.set_flow_target (target, *args, **kwargs)
+            _.config_logger   ()
+            _.setup_flow_run  ()
+            _.set_flow_name   ()
         return self
 
     def setup_flow_run(self):

osbot_utils-1.61.0/osbot_utils/helpers/flows/Flow__Events.py

@@ -0,0 +1,52 @@
+from osbot_utils.helpers.flows.models.Flow_Run__Event_Data import Flow_Run__Event_Data
+from osbot_utils.utils.Str                                  import ansi_to_text
+from osbot_utils.base_classes.Type_Safe                     import Type_Safe
+from osbot_utils.helpers.flows.models.Flow_Run__Event       import Flow_Run__Event
+from osbot_utils.helpers.flows.models.Flow_Run__Event_Type  import Flow_Run__Event_Type
+
+
+class Flow_Events(Type_Safe):
+    event_listeners : list
+
+    def on__flow__start(self, event_data: Flow_Run__Event_Data):
+        flow_event = Flow_Run__Event(event_type=Flow_Run__Event_Type.FLOW_START, event_data=event_data)
+        self.raise_event(flow_event)
+
+    def on__flow__stop(self, event_data: Flow_Run__Event_Data):                                                         # todo: see of flow_ended or flow_completed are better names
+        flow_event = Flow_Run__Event(event_type=Flow_Run__Event_Type.FLOW_STOP , event_data=event_data)
+        self.raise_event(flow_event)
+
+    def on__flow_run__message(self, log_level, flow_run_id, task_run_id, message):
+        event_data = Flow_Run__Event_Data()
+        event_data.flow_run_id = flow_run_id
+        event_data.task_run_id = task_run_id
+        event_data.data = dict(message_data = dict(log_level    = log_level             ,
+                                                   message      = message               ,
+                                                   message_text = ansi_to_text(message) ))
+        flow_event = Flow_Run__Event(event_type=Flow_Run__Event_Type.FLOW_MESSAGE, event_data=event_data)
+        self.raise_event(flow_event)
+
+    def on__new_artifact(self, event_data: Flow_Run__Event_Data):
+        flow_event = Flow_Run__Event(event_type=Flow_Run__Event_Type.NEW_ARTIFACT, event_data=event_data)
+        self.raise_event(flow_event)
+
+    def on__new_result(self, event_data: Flow_Run__Event_Data):
+        flow_event = Flow_Run__Event(event_type=Flow_Run__Event_Type.NEW_RESULT, event_data=event_data)
+        self.raise_event(flow_event)
+
+    def on__task__start(self, event_data: Flow_Run__Event_Data):
+        flow_event = Flow_Run__Event(event_type=Flow_Run__Event_Type.TASK_START, event_data=event_data)
+        self.raise_event(flow_event)
+
+    def on__task__stop(self, event_data: Flow_Run__Event_Data):                                                         # todo: see of flow_ended or flow_completed are better names
+        flow_event = Flow_Run__Event(event_type=Flow_Run__Event_Type.TASK_STOP , event_data=event_data)
+        self.raise_event(flow_event)
+
+    def raise_event(self, flow_event):
+        for listener in self.event_listeners:
+            try:
+                listener(flow_event)
+            except Exception as error:
+                print(f"Error in listener: {error}")
+
+flow_events = Flow_Events()

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/osbot_utils/helpers/flows/Task.py

@@ -2,6 +2,7 @@ import asyncio
 import inspect
 import typing
 
+from osbot_utils.helpers.flows.models.Flow_Run__Event_Data import Flow_Run__Event_Data
 from osbot_utils.utils.Misc                 import random_id, lower
 from osbot_utils.helpers.Dependency_Manager import Dependency_Manager
 from osbot_utils.helpers.flows.Flow__Events import flow_events
@@ -57,12 +58,19 @@ class Task(Type_Safe):
         if not self.task_id:
             self.task_id = self.random_task_id()
 
-        flow_events.on__task__start(self)
+        flow_events.on__task__start(self.task_event_data())
 
         self.task_flow.executed_tasks.append(self)
         self.log_debug(f"Executing task '{f_blue(self.task_name)}'")
         self.resolve_args_and_kwargs()
 
+    def task_event_data(self):
+        kwargs = dict(flow_name   = self.task_flow.flow_name,
+                      flow_run_id = self.task_flow.flow_id  ,
+                      task_name   = self.task_name          ,
+                      task_run_id = self.task_id            )
+        return Flow_Run__Event_Data(**kwargs)
+
     def resolve_args_and_kwargs(self):
         dependency_manager = Dependency_Manager()
         dependency_manager.add_dependency('this_task', self               )
@@ -97,7 +105,7 @@ class Task(Type_Safe):
 
         self.print_task_finished_message()
 
-        flow_events.on__task__stop(self)
+        flow_events.on__task__stop(self.task_event_data())
         return self.task_return_value
 
 

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/osbot_utils/helpers/flows/decorators/flow.py

@@ -10,9 +10,7 @@ def flow(**flow_kwargs):
         @wraps(function)
         def wrapper(*args: Any, **kwargs: Any) -> Flow:
             with Flow(**flow_kwargs) as _:
-                _.set_flow_target(function, *args, **kwargs)
-                _.setup()
-                _.create_flow()
+                _.setup(function, *args, **kwargs)
                 return _
         return wrapper
     return decorator

osbot_utils-1.60.0/osbot_utils/helpers/flows/models/Flow__Config.py → osbot_utils-1.61.0/osbot_utils/helpers/flows/models/Flow_Run__Config.py

@@ -1,7 +1,7 @@
 from osbot_utils.base_classes.Type_Safe import Type_Safe
 
 
-class Flow__Config(Type_Safe):
+class Flow_Run__Config(Type_Safe):
     add_task_to_self       : bool = True
     log_to_console         : bool = False
     log_to_memory          : bool = True

osbot_utils-1.61.0/osbot_utils/helpers/flows/models/Flow_Run__Event.py

@@ -0,0 +1,15 @@
+from osbot_utils.helpers.Random_Guid import Random_Guid
+
+from osbot_utils.base_classes.Type_Safe                     import Type_Safe
+from osbot_utils.helpers.Timestamp_Now                      import Timestamp_Now
+from osbot_utils.helpers.flows.models.Flow_Run__Event_Data  import Flow_Run__Event_Data
+from osbot_utils.helpers.flows.models.Flow_Run__Event_Type  import Flow_Run__Event_Type
+
+
+
+class Flow_Run__Event(Type_Safe):
+    event_id    : Random_Guid
+    event_type  : Flow_Run__Event_Type
+    event_data  : Flow_Run__Event_Data
+    timestamp   : Timestamp_Now
+

osbot_utils-1.61.0/osbot_utils/helpers/flows/models/Flow_Run__Event_Data.py

@@ -0,0 +1,14 @@
+import logging
+
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+
+class Flow_Run__Event_Data(Type_Safe):
+    data        : dict
+    event_source: str
+    flow_id     : str = None
+    flow_name   : str = None
+    flow_run_id : str = None
+    log_level   : int = logging.INFO
+    task_name   : str = None
+    task_run_id : str = None

osbot_utils-1.60.0/osbot_utils/helpers/flows/models/Flow__Event_Type.py → osbot_utils-1.61.0/osbot_utils/helpers/flows/models/Flow_Run__Event_Type.py

@@ -1,6 +1,8 @@
+from enum import Enum
+
 from osbot_utils.base_classes.Type_Safe import Type_Safe
 
-class Flow__Event_Type(Type_Safe):
+class Flow_Run__Event_Type(Enum):
     FLOW_MESSAGE: str = 'flow_message'
     FLOW_START  : str = 'flow_start'
     FLOW_STOP   : str = 'flow_stop'

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/osbot_utils/utils/Json.py

@@ -1,9 +1,9 @@
 import json
 import os
 
-from osbot_utils.utils.Misc import str_lines, str_md5, str_sha256
+from osbot_utils.utils.Misc  import str_lines, str_md5, str_sha256
 from osbot_utils.utils.Files import file_create_gz, file_create, load_file_gz, file_contents, file_lines, file_lines_gz
-from osbot_utils.utils.Zip import str_to_gz, gz_to_str
+from osbot_utils.utils.Zip   import str_to_gz, gz_to_str
 
 
 def json_dumps(python_object, indent=4, pretty=True, sort_keys=False, default=str, raise_exception=False):

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/osbot_utils/utils/Misc.py

@@ -513,5 +513,6 @@ random_guid         = random_uuid
 random_value        = random_string
 
 time_utc            = time_now
+timestamp_now       = timestamp_utc_now
 wait_for            = wait
 

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/osbot_utils/utils/Objects.py

@@ -1,5 +1,6 @@
 # todo add tests
 import inspect
+import json
 import pickle
 import sys
 import types
@@ -151,6 +152,9 @@ def obj_to_dict(target):
         return {obj_to_dict(item) for item in target}
     return target                                                                   # Return non-object types as is
 
+def str_to_obj(target):
+    return dict_to_obj(json.loads(target))
+
 def enum_from_value(enum_type, value):
     try:
         return enum_type[value]         # Attempt to convert the value to an Enum member by name
@@ -390,6 +394,8 @@ def value_type_matches_obj_annotation_for_attr(target, attr_name, value):
 base_types          = base_classes
 bytes_to_obj        = pickle_load_from_bytes
 
+json_to_obj         = str_to_obj
+
 full_type_name      = class_full_name
 
 obj_list_set        = obj_keys

osbot_utils-1.61.0/osbot_utils/version

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

{osbot_utils-1.60.0 → osbot_utils-1.61.0}/pyproject.toml

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

osbot_utils-1.60.0/osbot_utils/helpers/flows/Flow__Events.py

@@ -1,53 +0,0 @@
-from osbot_utils.utils.Str import ansis_to_texts, ansi_to_text
-
-from osbot_utils.utils.Dev import pprint
-
-from osbot_utils.base_classes.Type_Safe                 import Type_Safe
-from osbot_utils.helpers.flows.models.Flow__Event       import Flow__Event
-from osbot_utils.helpers.flows.models.Flow__Event_Type  import Flow__Event_Type
-
-
-class Flow_Events(Type_Safe):
-    event_listeners : list
-
-    def on__flow__start(self, flow):
-        flow_event = Flow__Event(event_type=Flow__Event_Type.FLOW_START, event_source=flow)
-        self.raise_event(flow_event)
-
-    def on__flow__stop(self, flow):                                                         # todo: see of flow_ended or flow_completed are better names
-        flow_event = Flow__Event(event_type=Flow__Event_Type.FLOW_STOP , event_source=flow)
-        self.raise_event(flow_event)
-
-    def on__flow_run__message(self, flow, log_level, flow_run_id, task_run_id, message):
-        event_data = dict(flow_run_id  = flow_run_id           ,
-                          log_level    = log_level             ,
-                          message      = message               ,
-                          message_text = ansi_to_text(message) ,
-                          task_run_id = task_run_id            )
-        flow_event = Flow__Event(event_type=Flow__Event_Type.FLOW_MESSAGE, event_source=flow, event_data=event_data)
-        self.raise_event(flow_event)
-
-    def on__new_artifact(self, flow, result_data):
-        flow_event = Flow__Event(event_type=Flow__Event_Type.NEW_ARTIFACT , event_source=flow, event_data=result_data)
-        self.raise_event(flow_event)
-
-    def on__new_result(self, flow, result_data):
-        flow_event = Flow__Event(event_type=Flow__Event_Type.NEW_RESULT , event_source=flow, event_data=result_data)
-        self.raise_event(flow_event)
-
-    def on__task__start(self, task):
-        flow_event = Flow__Event(event_type=Flow__Event_Type.TASK_START, event_source=task)
-        self.raise_event(flow_event)
-
-    def on__task__stop(self, task):                                                         # todo: see of flow_ended or flow_completed are better names
-        flow_event = Flow__Event(event_type=Flow__Event_Type.TASK_STOP , event_source=task)
-        self.raise_event(flow_event)
-
-    def raise_event(self, flow_event):
-        for listener in self.event_listeners:
-            try:
-                listener(flow_event)
-            except Exception as error:
-                print(f"Error in listener: {error}")
-
-flow_events = Flow_Events()

osbot_utils-1.60.0/osbot_utils/helpers/flows/models/Flow__Event.py

@@ -1,6 +0,0 @@
-from osbot_utils.base_classes.Type_Safe import Type_Safe
-
-class Flow__Event(Type_Safe):
-    event_type  : str
-    event_source: object
-    event_data  : dict

osbot_utils-1.60.0/osbot_utils/version

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