osbot-utils 2.30.0__tar.gz → 2.32.0__tar.gz

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.30.0
+Version: 2.32.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -23,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-v2.30.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.32.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-2.30.0 → osbot_utils-2.32.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-v2.30.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.32.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-2.30.0/osbot_utils/testing → osbot_utils-2.32.0/osbot_utils/helpers/duration}/Duration.py

@@ -1,32 +1,11 @@
-import inspect
-from datetime import timedelta
-from functools import wraps
+from datetime                       import timedelta
 
-from osbot_utils.utils.Call_Stack import Call_Stack
+from osbot_utils.helpers.duration.schemas.Schema__Duration import Schema__Duration
+from osbot_utils.utils.Call_Stack   import Call_Stack
+from osbot_utils.utils.Misc         import date_time_now, time_delta_to_str
 
-from osbot_utils.utils.Misc import date_time_now, time_delta_to_str
 
-
-def duration(func):
-    if inspect.iscoroutinefunction(func):
-        # It's an async function
-        @wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            with Duration(prefix=f'.{func.__name__} took'):
-                return await func(*args, **kwargs)
-        return async_wrapper
-    else:
-        # It's a regular function
-        @wraps(func)
-        def sync_wrapper(*args, **kwargs):
-            with Duration(prefix=f'.{func.__name__} took'):
-                return func(*args, **kwargs)
-        return sync_wrapper
-
-class Duration:
-    """
-    Helper class for to capture time duration
-    """
+class Duration:                                     # Helper class for to capture time duration
     def __init__(self, prefix="\nDuration:", print_result=True, use_utc=True, print_stack=False):
         self.use_utc            = use_utc
         self.print_result       = print_result
@@ -47,6 +26,15 @@ class Duration:
     def __exit__(self, exception_type, exception_value, exception_traceback):
         self.end()
 
+    def data(self) -> Schema__Duration: # Returns the duration data in Schema__Duration format.
+        if not self.duration:
+            raise ValueError("Duration has not been calculated yet. Call end() first.")
+
+        return Schema__Duration( utc                = self.use_utc               ,
+                                 timestamp_start    = self.start_time.timestamp(),
+                                 timestamp_end      = self.end_time  .timestamp(),
+                                 duration_seconds   = self.seconds             ())
+
     def start(self):
         self.start_time = date_time_now(use_utc=self.use_utc, return_str=False)
 

osbot_utils-2.32.0/osbot_utils/helpers/duration/decorators/duration.py

@@ -0,0 +1,21 @@
+import inspect
+from functools import wraps
+
+from osbot_utils.helpers.duration.Duration import Duration
+
+
+def duration(func):
+    if inspect.iscoroutinefunction(func):
+        # It's an async function
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            with Duration(prefix=f'.{func.__name__} took'):
+                return await func(*args, **kwargs)
+        return async_wrapper
+    else:
+        # It's a regular function
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            with Duration(prefix=f'.{func.__name__} took'):
+                return func(*args, **kwargs)
+        return sync_wrapper

{osbot_utils-2.30.0/osbot_utils/context_managers → osbot_utils-2.32.0/osbot_utils/helpers/duration/decorators}/print_duration.py

@@ -1,4 +1,4 @@
-from osbot_utils.context_managers.capture_duration import capture_duration
+from osbot_utils.helpers.duration.decorators.capture_duration import capture_duration
 
 
 class print_duration(capture_duration):

osbot_utils-2.32.0/osbot_utils/helpers/duration/schemas/Schema__Duration.py

@@ -0,0 +1,8 @@
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+
+class Schema__Duration(Type_Safe):
+    utc             : bool = True
+    timestamp_start : float
+    timestamp_end   : float
+    duration_seconds: float

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/osbot_utils/helpers/flows/Flow.py

@@ -1,21 +1,21 @@
 import asyncio
 import logging
 import typing
-
-from osbot_utils.helpers.Dependency_Manager                 import Dependency_Manager
-from osbot_utils.helpers.flows.actions.Flow__Data           import Flow__Data
-from osbot_utils.helpers.flows.models.Flow_Run__Event       import Flow_Run__Event
-from osbot_utils.type_safe.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.actions.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.Dev                                  import pprint
-from osbot_utils.utils.Misc                                 import random_id, lower, time_now
-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.helpers.flows.actions.Flow__Data               import Flow__Data
+from osbot_utils.helpers.flows.actions.Flow__Stats__Collector   import Flow__Stats__Collector
+from osbot_utils.helpers.flows.models.Flow_Run__Event           import Flow_Run__Event
+from osbot_utils.type_safe.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.actions.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.Dev                                      import pprint
+from osbot_utils.utils.Misc                                     import random_id, lower, time_now
+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__'
@@ -23,9 +23,10 @@ FLOW__LOGGING__LOG_FORMAT  = '%(asctime)s.%(msecs)03d | %(levelname)-8s | %(mess
 FLOW__LOGGING__DATE_FORMAT = '%H:%M:%S'
 
 
-# todo: add flow duration
+# todo: replace the flow_id (and task_id) with either Obj_Id or Safe_Id
 class Flow(Type_Safe):
     flow_data          : Flow__Data
+    flow_stats         : Flow__Stats__Collector
     captured_exec_logs : list
     data               : dict                   # dict available to the tasks to add and collect data
     flow_id            : str                    # rename to flow_run_id (or also capture the flow_run_id)
@@ -82,6 +83,7 @@ class Flow(Type_Safe):
 
     def execute_flow(self, flow_run_params=None):                               # todo: see if it makes more sense to call this start_flow_run
         self.check_setup()
+        self.flow_stats.start(flow_id=self.flow_id, flow_name=self.flow_name)   # start the flow stats collector
         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)
@@ -101,6 +103,7 @@ class Flow(Type_Safe):
             self.log_error(self.cformat.red(f"Error executing flow: {error}"))
             self.flow_data.set_error(error)
 
+        self.flow_stats.end             (self.flow_error)
         self.log_captured_stdout        (stdout)
         self.print_flow_return_value    ()
         self.print_flow_finished_message()
@@ -119,6 +122,11 @@ class Flow(Type_Safe):
     def captured_logs(self):
         return ansis_to_texts(self.captured_exec_logs)
 
+    def durations(self):
+        return self.flow_stats.durations()
+
+    def durations__with_tasks_status(self):
+        return self.flow_stats.durations__with_tasks_status()
 
     async def invoke_flow_target__thread(self, flow):                               # this is a REALLY important method which is used to pin the flow object to the call stack
         return await flow.flow_target(*flow.resolved_args, **flow.resolved_kwargs)          #   which is then used by the Task.find_flow method to find it

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/osbot_utils/helpers/flows/Task.py

@@ -2,14 +2,15 @@ import inspect
 import traceback
 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.actions.Flow__Events         import flow_events
-from osbot_utils.testing.Stdout                             import Stdout
-from osbot_utils.helpers.CFormat                            import CFormat, f_dark_grey, f_red, f_blue, f_bold
-from osbot_utils.type_safe.Type_Safe                        import Type_Safe
-from osbot_utils.helpers.flows.Flow                         import Flow
+from osbot_utils.helpers.flows.actions.Task__Stats__Collector import Task__Stats__Collector
+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.actions.Flow__Events           import flow_events
+from osbot_utils.testing.Stdout                               import Stdout
+from osbot_utils.helpers.CFormat                              import CFormat, f_dark_grey, f_red, f_blue, f_bold
+from osbot_utils.type_safe.Type_Safe                          import Type_Safe
+from osbot_utils.helpers.flows.Flow                           import Flow
 
 TASK__RANDOM_ID__PREFIX    = 'task_id__'
 
@@ -18,6 +19,7 @@ TASK__RANDOM_ID__PREFIX    = 'task_id__'
 class Task(Type_Safe):
     data                : dict                          # dict available to the task to add and collect data
     task_id             : str
+    task_stats          : Task__Stats__Collector
     task_name           : str                           # make this the function mame
     cformat             : CFormat
     resolved_args       : tuple
@@ -63,6 +65,9 @@ class Task(Type_Safe):
         if not self.task_id:
             self.task_id = self.random_task_id()
 
+        execution_order = self.task_flow.flow_stats.get_next_execution_order()
+        self.task_stats.start(flow_id=self.task_flow.flow_id, task_id=self.task_id, task_name=self.task_name, execution_order=execution_order)
+
         self.on_task_start()
         flow_events.on__task__start(self.task_event_data())
 
@@ -105,6 +110,11 @@ class Task(Type_Safe):
         self.task_flow.log_captured_stdout(stdout)
 
     def execute__after(self):
+
+        self.task_stats.end(task_error=self.task_error)
+        self.task_flow.flow_stats.add_task_stats(self.task_stats.stats)
+
+
         self.print_task_return_value()
 
         if self.task_error:

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/osbot_utils/helpers/flows/actions/Flow__Data.py

@@ -5,7 +5,6 @@ from osbot_utils.helpers.flows.models.Schema__Flow__Artifact    import Schema__F
 from osbot_utils.helpers.flows.models.Schema__Flow__Result      import Schema__Flow__Result
 from osbot_utils.helpers.flows.schemas.Schema__Flow             import Schema__Flow
 from osbot_utils.helpers.flows.schemas.Schema__Flow__Data       import Schema__Flow__Data
-#from osbot_utils.helpers.flows.schemas.Schema__Flow__Event     import Schema__Flow__Event
 from osbot_utils.helpers.flows.schemas.Schema__Flow__Log        import Schema__Flow__Log
 from osbot_utils.helpers.flows.schemas.Schema__Flow__Task__Data import Schema__Flow__Task__Data
 from osbot_utils.type_safe.Type_Safe                            import Type_Safe

osbot_utils-2.32.0/osbot_utils/helpers/flows/actions/Flow__Stats__Collector.py

@@ -0,0 +1,83 @@
+from typing                                                  import Dict
+from osbot_utils.helpers.duration.Duration                   import Duration
+from osbot_utils.helpers.flows.schemas.Schema__Flow__Status  import Schema__Flow__Status
+from osbot_utils.helpers.flows.schemas.Schema__Task__Stats   import Schema__Task__Stats
+from osbot_utils.helpers.flows.schemas.Schema__Flow__Stats   import Schema__Flow__Stats
+from osbot_utils.type_safe.Type_Safe                         import Type_Safe
+
+FLOW__ERROR_MESSAGE__TASK_FAILED = 'At least one task failed'
+
+class Flow__Stats__Collector(Type_Safe):
+    duration               : Duration
+    stats                  : Schema__Flow__Stats
+    task_execution_counter : int
+
+    def start(self, flow_id: str, flow_name:str):
+        self.duration.print_result = False
+        self.duration.start()
+        self.task_execution_counter = 0
+        with self.stats as _:
+            _.flow_id      = flow_id
+            _.flow_name    = flow_name
+            _.status       = Schema__Flow__Status.RUNNING
+        return self
+
+    def end(self, flow_error:Exception):
+        self.duration.end()
+        with self.stats as _:
+            _.duration     = self.duration.data()
+            _.total_tasks  = len(self.stats.tasks_stats)
+            _.failed_tasks = sum(1 for task in self.stats.tasks_stats.values() if task.status == Schema__Flow__Status.FAILED)
+
+            if flow_error:
+                _.status = Schema__Flow__Status.FAILED
+                _.error_message = str(flow_error)
+            elif _.failed_tasks:
+                _.status = Schema__Flow__Status.FAILED
+                _.error_message = FLOW__ERROR_MESSAGE__TASK_FAILED
+            else:
+                _.status = Schema__Flow__Status.COMPLETED
+        return self
+
+    def get_next_execution_order(self):                                                                                 # Get the next execution order number and increment the counter."""
+        self.task_execution_counter += 1
+        return self.task_execution_counter
+
+    def add_task_stats(self, task_stats: Schema__Task__Stats):                                                          # Add task stats to the collection.
+        self.stats.tasks_stats[task_stats.task_id] = task_stats
+        return self
+
+    def json(self):                                                                                                     # Return JSON representation of the stats.
+        return self.stats.json()
+
+    def durations__with_tasks_status(self):
+        with self.stats as _:
+            tasks_durations = dict()
+            flow_durations  = dict(flow_name     = _.flow_name                ,
+                                   flow_duration = _.duration.duration_seconds,
+                                   flow_status   = _.status.value             ,
+                                   flow_tasks    =  tasks_durations           )
+
+            for task_id, flow_task in self.stats.tasks_stats.items():
+                task_duration   = dict(task_name = flow_task.task_name                     ,
+                                       task_duration  = flow_task.duration.duration_seconds,
+                                       task_status    = flow_task.status.value             )
+                execution_order = flow_task.execution_order
+                tasks_durations[execution_order] = task_duration
+        return flow_durations
+
+    def durations(self):
+        with self.stats as _:
+            if _.status is None:
+                flow_durations = dict()
+            else:
+                tasks_durations = dict()
+                flow_durations  = dict(flow_name     = _.flow_name                ,
+                                       flow_duration = _.duration.duration_seconds,
+                                       flow_status   = _.status.value             ,
+                                       flow_tasks    =  tasks_durations           )
+
+                for task_id, flow_task in self.stats.tasks_stats.items():
+
+                    tasks_durations[flow_task.task_name] = flow_task.duration.duration_seconds
+        return flow_durations

osbot_utils-2.32.0/osbot_utils/helpers/flows/actions/Task__Stats__Collector.py

@@ -0,0 +1,34 @@
+from osbot_utils.helpers.duration.Duration                  import Duration
+from osbot_utils.helpers.flows.schemas.Schema__Flow__Status import Schema__Flow__Status
+from osbot_utils.helpers.flows.schemas.Schema__Task__Stats  import Schema__Task__Stats
+from osbot_utils.type_safe.Type_Safe                        import Type_Safe
+
+class Task__Stats__Collector(Type_Safe):
+    duration       : Duration
+    stats          : Schema__Task__Stats
+
+    def start(self, flow_id: str, task_id: str, task_name: str , execution_order:int):
+        self.duration.print_result = False
+        self.duration.start()
+        with self.stats as _:
+            _.parent_flow_id  = flow_id
+            _.execution_order = execution_order
+            _.status          = Schema__Flow__Status.RUNNING
+            _.task_id         = task_id
+            _.task_name       = task_name
+        return self
+
+    def end(self, task_error: Exception):
+        self.duration.end()
+        with self.stats as _:
+            _.duration = self.duration.data()
+            if task_error:
+                _.status        = Schema__Flow__Status.FAILED
+                _.error_message = str(task_error)
+            else:
+                _.status = Schema__Flow__Status.COMPLETED
+        return self
+
+
+    def json(self):                                                                                                     # Return JSON representation of the stats.
+        return self.stats.json()

osbot_utils-2.32.0/osbot_utils/helpers/flows/schemas/Schema__Flow__Stats.py

@@ -0,0 +1,16 @@
+from typing                                                 import Dict
+from osbot_utils.helpers.duration.schemas.Schema__Duration  import Schema__Duration
+from osbot_utils.helpers.flows.schemas.Schema__Flow__Status import Schema__Flow__Status
+from osbot_utils.helpers.flows.schemas.Schema__Task__Stats  import Schema__Task__Stats
+from osbot_utils.type_safe.Type_Safe                        import Type_Safe
+
+
+class Schema__Flow__Stats(Type_Safe):
+    duration     : Schema__Duration                         # How long the flow took to execute
+    error_message: str                             =  None  # Error message if flow failed
+    failed_tasks : int                                      # Number of failed tasks
+    flow_id      : str                                      # Unique identifier for the flow
+    flow_name    : str                                      # Name of the flow
+    status       : Schema__Flow__Status                     # 'completed', 'failed', 'running'
+    tasks_stats  : Dict[str, Schema__Task__Stats]           # Map of task_id to task stats
+    total_tasks  : int                                      # Total number of tasks executed

osbot_utils-2.32.0/osbot_utils/helpers/flows/schemas/Schema__Flow__Status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class Schema__Flow__Status(Enum):
+    COMPLETED: str = 'completed'
+    FAILED   : str = 'failed'
+    STOPPED  : str = 'stopped'
+    RUNNING  : str = 'running'

osbot_utils-2.32.0/osbot_utils/helpers/flows/schemas/Schema__Task__Stats.py

@@ -0,0 +1,13 @@
+from osbot_utils.helpers.duration.schemas.Schema__Duration  import Schema__Duration
+from osbot_utils.helpers.flows.schemas.Schema__Flow__Status import Schema__Flow__Status
+from osbot_utils.type_safe.Type_Safe                        import Type_Safe
+
+
+class Schema__Task__Stats(Type_Safe):
+    task_id        : str                        # Unique identifier for the task
+    task_name      : str                        # Name of the task
+    execution_order: int                        # Order in which the task was executed
+    duration       : Schema__Duration           # How long the task took to execute
+    status         : Schema__Flow__Status       # 'completed', 'failed', 'running'
+    parent_flow_id : str                        # ID of the flow that contains this task
+    error_message  : str           = None       # Error message if task failed

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/osbot_utils/helpers/ssh/SCP.py

@@ -1,9 +1,9 @@
-from osbot_utils.context_managers.capture_duration  import capture_duration
-from osbot_utils.helpers.ssh.SSH__Execute           import SSH__Execute
-from osbot_utils.testing.Temp_Zip                   import Temp_Zip
-from osbot_utils.utils.Files                        import file_not_exists, file_name
-from osbot_utils.utils.Process                      import start_process
-from osbot_utils.utils.Status                       import status_error
+from osbot_utils.helpers.duration.decorators.capture_duration  import capture_duration
+from osbot_utils.helpers.ssh.SSH__Execute                      import SSH__Execute
+from osbot_utils.testing.Temp_Zip                              import Temp_Zip
+from osbot_utils.utils.Files                                   import file_not_exists, file_name
+from osbot_utils.utils.Process                                 import start_process
+from osbot_utils.utils.Status                                  import status_error
 
 
 

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/osbot_utils/helpers/ssh/SSH__Execute.py

@@ -1,13 +1,13 @@
-from osbot_utils.type_safe.Type_Safe import Type_Safe
-from osbot_utils.context_managers.capture_duration          import capture_duration
-from osbot_utils.decorators.lists.group_by                  import group_by
-from osbot_utils.decorators.lists.index_by                  import index_by
-from osbot_utils.utils.Dev                                  import pprint
-from osbot_utils.utils.Env                                  import get_env
-from osbot_utils.utils.Http import is_port_open
-from osbot_utils.utils.Misc                                 import str_to_int, str_to_bool
-from osbot_utils.utils.Process import start_process, run_process
-from osbot_utils.utils.Status                               import status_error
+from osbot_utils.type_safe.Type_Safe                            import Type_Safe
+from osbot_utils.helpers.duration.decorators.capture_duration   import capture_duration
+from osbot_utils.decorators.lists.group_by                      import group_by
+from osbot_utils.decorators.lists.index_by                      import index_by
+from osbot_utils.utils.Dev                                      import pprint
+from osbot_utils.utils.Env                                      import get_env
+from osbot_utils.utils.Http                                     import is_port_open
+from osbot_utils.utils.Misc                                     import str_to_int, str_to_bool
+from osbot_utils.utils.Process                                  import start_process, run_process
+from osbot_utils.utils.Status                                   import status_error
 
 ENV_VAR__SSH__HOST              = 'SSH__HOST'
 ENV_VAR__SSH__PORT              = 'SSH__PORT'

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/osbot_utils/testing/Hook_Method.py

@@ -1,7 +1,8 @@
-from osbot_utils.helpers.Print_Table import Print_Table
-from osbot_utils.utils.Call_Stack import Call_Stack
+from osbot_utils.helpers.Print_Table            import Print_Table
+from osbot_utils.helpers.duration.Duration      import Duration
+from osbot_utils.utils.Call_Stack               import Call_Stack
+
 
-from osbot_utils.testing.Duration import Duration
 
 class Hook_Method:
 

osbot_utils-2.32.0/osbot_utils/type_safe/shared/Type_Safe__Shared__Variables.py

@@ -0,0 +1,8 @@
+import types
+from enum import EnumMeta
+
+from osbot_utils.helpers.Safe_Id            import Safe_Id
+
+IMMUTABLE_TYPES = (bool, int, float, complex, str, bytes, types.NoneType, EnumMeta, type,
+                   Safe_Id          # ok to add since these classes use str as a base class
+                   )

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/osbot_utils/type_safe/steps/Type_Safe__Step__From_Json.py

@@ -176,7 +176,7 @@ class Type_Safe__Step__From_Json:
         if type(json_data) is str:
             json_data = json_parse(json_data)
         if json_data:                                           # if there is no data or is {} then don't create an object (since this could be caused by bad data being provided)
-            return self.deserialize_from_dict(_cls(), json_data,raise_on_not_found=raise_on_not_found)
+            return self.deserialize_from_dict(_cls(), json_data, raise_on_not_found=raise_on_not_found)
         return _cls()
 
 type_safe_step_from_json = Type_Safe__Step__From_Json()

osbot_utils-2.32.0/osbot_utils/version

@@ -0,0 +1 @@
+v2.32.0

{osbot_utils-2.30.0 → osbot_utils-2.32.0}/pyproject.toml

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

osbot_utils-2.30.0/osbot_utils/type_safe/shared/Type_Safe__Shared__Variables.py

@@ -1,4 +0,0 @@
-import types
-from enum import EnumMeta
-
-IMMUTABLE_TYPES = (bool, int, float, complex, str, bytes, types.NoneType, EnumMeta, type)

osbot_utils-2.30.0/osbot_utils/version

@@ -1 +0,0 @@
-v2.30.0