osbot-utils 1.17.0__py3-none-any.whl → 1.20.0__py3-none-any.whl

osbot_utils/base_classes/Kwargs_To_Self.py

@@ -6,10 +6,9 @@ import inspect
 import sys
 import types
 import typing
-from decimal import Decimal
+from decimal                                    import Decimal
 from enum                                       import Enum, EnumMeta
 from typing                                     import List
-
 from osbot_utils.base_classes.Type_Safe__List   import Type_Safe__List
 from osbot_utils.utils.Dev                      import pprint
 from osbot_utils.utils.Json                     import json_parse
@@ -48,57 +47,7 @@ immutable_types = (bool, int, float, complex, str, tuple, frozenset, bytes, None
 #      for example if we have an method like def add_node(self, title: str, call_index: int):
 #          throw an exception if the type of the value passed in is not the same as the one defined in the method
 
-class Kwargs_To_Self:               # todo: check if the description below is still relevant (since a lot has changed since it was created)
-    """
-    A mixin class to strictly assign keyword arguments to pre-defined instance attributes during initialization.
-
-    This base class provides an __init__ method that assigns values from keyword
-    arguments to instance attributes. If an attribute with the same name as a key
-    from the kwargs is defined in the class, it will be set to the value from kwargs.
-    If the key does not match any predefined attribute names, an exception is raised.
-
-    This behavior enforces strict control over the attributes of instances, ensuring
-    that only predefined attributes can be set at the time of instantiation and avoids
-    silent attribute creation which can lead to bugs in the code.
-
-    Usage:
-        class MyConfigurableClass(Kwargs_To_Self):
-            attribute1 = 'default_value'
-            attribute2 = True
-            attribute3 : str
-            attribute4 : list
-            attribute4 : int = 42
-
-            # Other methods can be added here
-
-        # Correctly override default values by passing keyword arguments
-        instance = MyConfigurableClass(attribute1='new_value', attribute2=False)
-
-        # This will raise an exception as 'attribute3' is not predefined
-        # instance = MyConfigurableClass(attribute3='invalid_attribute')
-
-        this will also assign the default value to any variable that has a type defined.
-        In the example above the default values (mapped by __default__kwargs__ and __locals__) will be:
-            attribute1 = 'default_value'
-            attribute2 = True
-            attribute3 = ''             # default value of str
-            attribute4 = []             # default value of list
-            attribute4 = 42             # defined value in the class
-
-    Note:
-        It is important that all attributes which may be set at instantiation are
-        predefined in the class. Failure to do so will result in an exception being
-        raised.
-
-    Methods:
-        __init__(**kwargs): The initializer that handles the assignment of keyword
-                            arguments to instance attributes. It enforces strict
-                            attribute assignment rules, only allowing attributes
-                            that are already defined in the class to be set.
-    """
-
-    #__lock_attributes__ = False
-    #__type_safety__     = True
+class Kwargs_To_Self:
 
     def __init__(self, **kwargs):
         """
@@ -150,7 +99,7 @@ class Kwargs_To_Self:               # todo: check if the description below is st
             #     raise AttributeError(f"'[Object Locked] Current object is locked (with __lock_attributes__=True) which prevents new attributes allocations (i.e. setattr calls). In this case  {type(self).__name__}' object has no attribute '{name}'") from None
 
         if value is not None:
-            check_1 = value_type_matches_obj_annotation_for_attr(self, name, value)
+            check_1 = value_type_matches_obj_annotation_for_attr      (self, name, value)
             check_2 = value_type_matches_obj_annotation_for_union_attr(self, name, value)
             if (check_1 is False and check_2 is None  or
                 check_1 is None  and check_2 is False or

osbot_utils/base_classes/Type_Safe.py

@@ -0,0 +1,6 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+# todo: refactor all of Kwargs_To_Self into this class (in a way to minimize the side effects, since
+#        Kwargs_To_Self is used in many places in the codebase)
+
+Type_Safe = Kwargs_To_Self

osbot_utils/context_managers/disable_root_loggers.py

@@ -0,0 +1,30 @@
+import logging
+
+from osbot_utils.utils.Dev import pprint
+from osbot_utils.utils.Misc import timestamp_utc_now
+
+
+class disable_root_loggers():
+    def __init__(self):
+        self.original_root_loggers  = []
+
+
+    def __enter__(self):
+
+        self.capture_root_loggers()                                         # capture current loggers
+        logging.root.handlers.clear()                                       # removes all loggers
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.restore_root_loggers()                                         # restores original loggers
+        return False                                                        # ensures that any exceptions that happened are rethrown
+
+    def capture_root_loggers(self):
+        for logger in logging.root.handlers:
+            self.original_root_loggers.append(logger)
+        return self
+
+    def restore_root_loggers(self):
+        for logger in self.original_root_loggers:
+            logging.root.handlers.append(logger)
+        return self

osbot_utils/helpers/CFormat.py

@@ -0,0 +1,147 @@
+# note these attributes will be replaced by methods by CPrint. This is done like this in order to:
+#     - Have code complete on CPrint
+#     - not have the write the code for each of the methods
+#     - have a good and logical place to capture the ID of the color
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+
+class CFormat_Colors:
+    black            = "30"
+    blue             = "34"
+    cyan             = "36"
+    grey             = "38;5;15"
+    green            = "32"
+    none             = "0"           # no color # note: this is using the ascii color reset code, see if there are any side effects
+    magenta          = "35"
+    red              = "31"
+    white            = "38;5;15"
+    yellow           = "33"
+    bright_black     = "90"
+    bright_red       = "91"
+    bright_green     = "92"
+    bright_yellow    = "93"
+    bright_blue      = "94"
+    bright_magenta   = "95"
+    bright_cyan      = "96"
+    bright_white     = "97"
+    dark_red         = "38;5;124"            # see https://github.com/fidian/ansi for a full list
+    dark_grey        = "38;5;8"
+
+    bold             = "1"         # ANSI escape code for bold
+    italic           = "3"         # ANSI escape code for italic
+    underline        = "4"         # ANSI escape code for underline
+    blink            = "5"         # (no visual change in pycharm console) ANSI escape code for blink (not widely supported)
+    inverse          = "7"         # ANSI escape code for inverse/negative
+    strikethrough    = "9"         # ANSI escape code for strikethrough
+    double_underline = "21"        # ANSI escape code for double underline
+    faint            = "2"         # (no visual change in pycharm console)  ANSI escape code for faint/dim
+    framed           = "51"        # ANSI escape code for framed (rarely supported)
+    encircled        = "52"        # ANSI escape code for encircled (rarely supported)
+    overlined        = "53"        # (no visual change in pycharm console) ANSI escape code for overlined
+
+class CFormat(CFormat_Colors, Type_Safe):
+    apply_colors: bool = True
+    auto_bold   : bool = False
+
+    def __getattribute__(self, name):                                                       # this will replace the attributes defined in colors with methods that will call add_to_current_line with the params provided
+        if name != '__getattribute__' and hasattr(CFormat_Colors, name):                                                           # if name is one of the colors defined in Colors
+            def method(*args, **kwargs):                                                    # create a method to replace the attribute
+                return self.apply_color_to_text(name, *args, **kwargs)                           # pass the data to add_with_color
+            return method
+        return super().__getattribute__(name)                                               # if the attribute name is not one of the attributes defined in colors, restore the normal behaviour of __getattribute__
+
+    def rgb(self, r, g, b, *args):
+        color_code = f"38;2;{r};{g};{b}"
+        return self.text_with_colors(color_code, *args)
+
+    def bg_rgb(self, r, g, b, *args):
+        color_code = f"48;2;{r};{g};{b}"
+        return self.text_with_colors(color_code, *args)
+
+    def cmyk(self, c, m, y, k, *args):
+        # CMYK to RGB conversion
+        r = 255 * (1 - c / 100) * (1 - k / 100)
+        g = 255 * (1 - m / 100) * (1 - k / 100)
+        b = 255 * (1 - y / 100) * (1 - k / 100)
+        color_code = f"38;2;{int(r)};{int(g)};{int(b)}"
+        return self.text_with_colors(color_code, *args)
+
+    def bg_cmyk(self, c, m, y, k, *args):
+        # CMYK to RGB conversion
+        r = 255 * (1 - c / 100) * (1 - k / 100)
+        g = 255 * (1 - m / 100) * (1 - k / 100)
+        b = 255 * (1 - y / 100) * (1 - k / 100)
+        color_code = f"48;2;{int(r)};{int(g)};{int(b)}"
+        return self.text_with_colors(color_code, *args)
+
+    def hex(self, hex_code, *args):
+        # Convert hex to RGB
+        hex_code = hex_code.lstrip('#')
+        r, g, b = int(hex_code[0:2], 16), int(hex_code[2:4], 16), int(hex_code[4:6], 16)
+        color_code = f"38;2;{r};{g};{b}"
+        return self.text_with_colors(color_code, *args)
+
+    def bg_hex(self, hex_code, *args):
+        # Convert hex to RGB
+        hex_code = hex_code.lstrip('#')
+        r, g, b = int(hex_code[0:2], 16), int(hex_code[2:4], 16), int(hex_code[4:6], 16)
+        color_code = f"48;2;{r};{g};{b}"
+        return self.text_with_colors(color_code, *args)
+
+    def apply_color_to_text(self, color_name, *args, **kwargs):
+        color_code = getattr(CFormat_Colors, color_name)                                            # capture the color from the Colors class
+        return self.apply_color_code_to_text(color_code, *args, **kwargs)
+
+    def apply_color_code_to_text(self, color_code, *args, **kwargs):
+        return self.text_with_colors(color_code, *args, **kwargs)
+
+    def text_with_colors(self, color_code, *args, **kwargs):
+        args = [str(arg) for arg in args]  # Convert all non-string arguments to strings
+        text = "".join(args)
+        if self.apply_colors:
+            color_start      = f"\033[{color_code}m"                                            # ANSI color code start and end
+            color_end        = "\033[0m"
+            text_with_color  = f"{color_start}{text}{color_end}"
+            if self.auto_bold:
+                return f"\033[1m{text_with_color}\033[0m"
+            return text_with_color
+        else:
+            return text
+
+cformat = CFormat()
+
+# ascii formating static helper methods
+f_bold             = cformat.bold
+f_italic           = cformat.italic
+f_underline        = cformat.underline
+f_blink            = cformat.blink
+f_inverse          = cformat.inverse
+f_strikethrough    = cformat.strikethrough
+f_double_underline = cformat.double_underline
+f_faint            = cformat.faint
+f_framed           = cformat.framed
+f_encircled        = cformat.encircled
+f_overlined        = cformat.overlined
+
+
+# ascii colors static helper methods
+f_black          = cformat.black
+f_red            = cformat.red
+f_blue           = cformat.blue
+f_cyan           = cformat.cyan
+f_grey           = cformat.grey
+f_green          = cformat.green
+f_none           = cformat.none
+f_magenta        = cformat.magenta
+f_white          = cformat.white
+f_yellow         = cformat.yellow
+f_bright_black   = cformat.bright_black
+f_bright_red     = cformat.bright_red
+f_bright_green   = cformat.bright_green
+f_bright_yellow  = cformat.bright_yellow
+f_bright_blue    = cformat.bright_blue
+f_bright_magenta = cformat.bright_magenta
+f_bright_cyan    = cformat.bright_cyan
+f_bright_white   = cformat.bright_white
+f_dark_red       = cformat.dark_red
+f_dark_grey      = cformat.dark_grey

osbot_utils/helpers/CPrint.py

@@ -1,65 +1,20 @@
 from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.CFormat import CFormat, CFormat_Colors
 
 
-# note these attributes will be replaced by methods by CPrint. This is done like this in order to:
-#     - Have code complete on CPrint
-#     - not have the write the code for each of the methods
-#     - have a good and logical place to capture the ID of the color
-
-class Colors:
-    black           = "30"
-    blue            = "34"
-    cyan            = "36"
-    grey            = "38;5;15"
-    green           = "32"
-    none            = "0"
-    magenta         = "35"
-    red             = "31"
-    white           = "38;5;15"
-    yellow          = "33"
-    bright_black    = "90"
-    bright_red      = "91"
-    bright_green    = "92"
-    bright_yellow   = "93"
-    bright_blue     = "94"
-    bright_magenta  = "95"
-    bright_cyan     = "96"
-    bright_white    = "97"
-    dark_red        = "38;5;124"            # see https://github.com/fidian/ansi for a full list
-
-
-class CPrint(Colors, Kwargs_To_Self):
-    apply_colors   : bool = True
+class CPrint(CFormat):
     auto_new_line  : bool = True
     auto_print     : bool = True
     clear_on_print : bool = True
     current_line   : str
     lines          : list
 
-    def __getattribute__(self, name):                                                       # this will replace the attributes defined in colors with methods that will call add_to_current_line with the params provided
-        if name != '__getattribute__' and hasattr(Colors, name):                                                           # if name is one of the colors defined in Colors
-            def method(*args, **kwargs):                                                    # create a method to replace the attribute
-                return self.add_with_color(name, *args, **kwargs)                     # pass the data to add_with_color
-            return method
-        return super().__getattribute__(name)                                               # if the attribute name is not one of the attributes defined in colors, restore the normal behaviour of __getattribute__
-
-    def add_with_color(self, color_name, *args, **kwargs):
-        color_code = getattr(Colors, color_name)                                            # capture the color from the Colors class
-        self.add_to_current_line(color_code, *args, **kwargs)                         # add the color code to the current line
+    def apply_color_code_to_text(self, color_code, *args, **kwargs):
+        self.add_to_current_line(color_code, *args, **kwargs)
         return self
 
     def add_to_current_line(self, color_code, *args, **kwargs):
-        args             = [str(arg) for arg in args]                                           # Convert all non-string arguments to strings
-        text             = "".join(args)                                                        # Concatenate all arguments without a space (to have beter support for multi-prints per line)
-        if self.apply_colors:
-            color_start      = f"\033[{color_code}m"                                            # ANSI color code start and end
-            color_end        = "\033[0m"
-            kwargs['end']    = ''                                                               # remove the default print end (which is \n)
-
-            text_with_colors = f"{color_start}{text}{color_end}"
-            self.current_line += text_with_colors
-        else:
-            self.current_line += text
+        self.current_line += self.text_with_colors(color_code, *args, **kwargs)
         self.apply_config_options()
         return self
 

osbot_utils/helpers/Print_Table.py

@@ -1,5 +1,5 @@
 from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.utils.Misc import ansi_text_visible_length
+from osbot_utils.utils.Str                   import ansi_text_visible_length
 
 raw_data = """|-------------------------------------------------------------------------------------|
 | BOTO3 REST calls (via BaseClient._make_api_call)                                    |

osbot_utils/helpers/cache_requests/Cache__Requests__Actions.py

@@ -0,0 +1,23 @@
+from osbot_utils.base_classes.Type_Safe                             import Type_Safe
+from osbot_utils.helpers.cache_requests.Cache__Requests__Row        import Cache__Requests__Row
+from osbot_utils.helpers.cache_requests.Cache__Requests__Table      import Cache__Requests__Table
+from osbot_utils.utils.Json                                         import json_dumps
+from osbot_utils.utils.Misc                                         import str_sha256
+
+
+class Cache__Requests__Actions(Type_Safe):
+    cache_table      : Cache__Requests__Table
+    cache_row        : Cache__Requests__Row
+
+    def cache_add(self, request_data, response_data):
+        new_row_obj = self.cache_row.create_new_cache_obj(request_data, response_data)
+        return self.cache_table.row_add_and_commit(new_row_obj)
+
+    def cache_delete(self, request_data):
+        request_data        = json_dumps(request_data)
+        request_data_sha256 = str_sha256(request_data)
+        return self.cache_table.rows_delete_where(request_hash=request_data_sha256)
+
+    def create_new_cache_row_data(self, request_data, response_data):
+        new_row_data        = self.cache_row.create_new_cache_row_data(request_data, response_data)
+        return new_row_data

osbot_utils/helpers/cache_requests/Cache__Requests__Config.py

@@ -0,0 +1,32 @@
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+
+class Cache__Requests__Config(Type_Safe):
+    add_timestamp       : bool   = True
+    add_source_location  :bool    = True
+    enabled             : bool   = True
+    update_mode         : bool   = False
+    cache_only_mode     : bool   = False
+    pickle_response     : bool   = False
+    capture_exceptions  : bool   = False                # once this is working, it might be more useful to have this set to true
+    exception_classes   : list
+
+    def disable(self):
+        self.enabled = False
+        return self
+
+    def enable(self):
+        self.enabled = True
+        return self
+
+    def only_from_cache(self, value=True):
+        self.cache_only_mode = value
+        return self
+
+    def set__add_timestamp(self, value):
+        self.add_timestamp = value
+        return self
+
+    def update(self, value=True):
+        self.update_mode = value
+        return self

osbot_utils/helpers/cache_requests/Cache__Requests__Data.py

@@ -0,0 +1,105 @@
+import types
+from osbot_utils.base_classes.Type_Safe                                     import Type_Safe
+from osbot_utils.helpers.cache_requests.Cache__Requests__Config             import Cache__Requests__Config
+from osbot_utils.helpers.cache_requests.Cache__Requests__Table              import Cache__Requests__Table
+from osbot_utils.utils.Json                                                 import json_dumps, json_loads
+from osbot_utils.utils.Misc                                                 import str_sha256
+from osbot_utils.utils.Objects                                              import pickle_save_to_bytes, pickle_load_from_bytes
+
+
+class Cache__Requests__Data(Type_Safe):
+    cache_table        : Cache__Requests__Table
+    cache_request_data : types.MethodType
+    config             : Cache__Requests__Config
+
+    def cache_entries(self):
+        return self.cache_table.rows()
+
+    def cache_entry(self, request_data):
+        request_data        = json_dumps(request_data)
+        request_data_sha256 = str_sha256(request_data)
+        data                = self.cache_table.select_rows_where(request_hash=request_data_sha256)
+
+        if len(data) > 0:                                   # todo: add logic to handle (or log), where there are multiple entries with the same hash
+            return data[0]
+        return {}
+
+    def cache_entry_comments(self, *args, **target_kwargs):
+        cache_entry = self.cache_entry_for_request_params(*args, **target_kwargs)
+        return cache_entry.get('comments')
+
+    def cache_entry_comments_update(self, new_comments, *args, **target_kwargs):
+        cache_entry      = self.cache_entry_for_request_params(*args, **target_kwargs)
+        request_hash     = cache_entry.get('request_hash')
+        update_fields    = dict(comments=new_comments)
+        query_conditions = dict(request_hash=request_hash)
+        result           = self.cache_table.row_update(update_fields, query_conditions)
+        return result
+
+    def cache_entry_for_request_params(self, *args, **target_kwargs):
+        request_data = self.cache_request_data(*args, **target_kwargs)
+        return self.cache_entry(request_data)
+
+
+
+    def response_data_for__request_hash(self, request_hash):
+        rows = self.cache_table.rows_where__request_hash(request_hash)
+        if len(rows) > 0:
+            cache_entry       = rows[0]
+            response_data_obj = self.response_data_deserialize(cache_entry)
+            return response_data_obj
+        return {}
+
+    def requests_data__all(self):
+        requests_data = []
+        for row in self.cache_table.rows():
+            req_id           = row.get('id')
+            request_data     = row.get('request_data')
+            request_hash     = row.get('request_hash')
+            request_comments = row.get('comments')
+
+            request_data_obj = dict(request_data = request_data    ,
+                                    _id          = req_id          ,
+                                    _hash        =  request_hash   ,
+                                    _comments    = request_comments)
+
+            requests_data.append(request_data_obj)
+        return requests_data
+
+    def response_data__all(self):
+        responses_data = []
+        for row in self.cache_table.rows():
+            response_data_obj = self.convert_row__to__response_data_obj(row)
+            responses_data.append(response_data_obj)
+        return responses_data
+
+    def convert_row__to__response_data_obj(self, row):
+        row_id            = row.get('id'           )
+        comments          = row.get('comments'     )
+        request_hash      = row.get('request_hash' )
+        response_hash     = row.get('response_hash')
+        response_data     = self.response_data_deserialize(row)
+        response_data_obj = dict( comments      = comments      ,
+                                  row_id        = row_id        ,
+                                  request_hash  = request_hash  ,
+                                  response_hash = response_hash ,
+                                  response_data = response_data )
+        return response_data_obj
+
+    def response_data_deserialize(self, cache_entry):
+        if self.config.pickle_response:                                             # todo: refactor our this logic, since this needs to be done in sync with the response_type value
+            response_bytes = cache_entry.get('response_bytes')
+            response_data_obj =  pickle_load_from_bytes(response_bytes)
+        else:
+            response_data = cache_entry.get('response_data')
+            response_data_obj = json_loads(response_data)                           # todo: review the other scenarios of response_type
+        if self.config.capture_exceptions:
+            if (type(response_data_obj) is Exception or                             # raise if it is an exception
+                type(response_data_obj) in self.config.exception_classes):          # or if one of the types that have been set as being exception classes
+                    raise response_data_obj
+        return response_data_obj
+
+    def response_data_serialize(self, response_data):
+        if self.config.pickle_response:
+            return pickle_save_to_bytes(response_data)
+        return response_data

osbot_utils/helpers/cache_requests/Cache__Requests__Invoke.py

@@ -0,0 +1,55 @@
+import types
+
+from osbot_utils.base_classes.Type_Safe                                 import Type_Safe
+from osbot_utils.helpers.cache_requests.Cache__Requests__Actions        import Cache__Requests__Actions
+from osbot_utils.helpers.cache_requests.Cache__Requests__Config         import Cache__Requests__Config
+from osbot_utils.helpers.cache_requests.Cache__Requests__Data           import Cache__Requests__Data
+
+
+class Cache__Requests__Invoke(Type_Safe):
+    cache_actions    : Cache__Requests__Actions
+    cache_data       : Cache__Requests__Data
+    config           : Cache__Requests__Config
+    on_invoke_target : types.FunctionType
+
+    def invoke(self, target, target_args, target_kwargs):
+        return self.invoke_with_cache(target, target_args, target_kwargs)
+
+    def invoke_target(self, target, target_args, target_kwargs):
+        if self.on_invoke_target:
+            raw_response = self.on_invoke_target(target, target_args, target_kwargs)
+        else:
+            raw_response = target(*target_args, **target_kwargs)
+        return self.transform_raw_response(raw_response)
+
+    def invoke_with_cache(self, target, target_args, target_kwargs, request_data=None):
+        if self.config.enabled is False:
+            if self.config.cache_only_mode:
+                return None
+            return self.invoke_target(target, target_args, target_kwargs)
+        if request_data is None:
+            request_data  = self.cache_data.cache_request_data(*target_args, **target_kwargs)
+        cache_entry   = self.cache_data.cache_entry(request_data)
+        if cache_entry:
+            if self.config.update_mode is True:
+                self.cache_actions.cache_delete(request_data)
+            else:
+                return self.cache_data.response_data_deserialize(cache_entry)
+        if self.config.cache_only_mode is False:
+            return self.invoke_target__and_add_to_cache(request_data, target, target_args, target_kwargs)
+
+
+    def invoke_target__and_add_to_cache(self,request_data, target, target_args, target_kwargs):
+        try:
+            response_data_obj = self.invoke_target(target, target_args, target_kwargs)
+            response_data     = self.cache_data.response_data_serialize(response_data_obj)
+            self.cache_actions.cache_add(request_data=request_data, response_data=response_data)
+            return response_data_obj
+        except Exception as exception:
+            if self.config.capture_exceptions:
+                response_data     = self.cache_data.response_data_serialize(exception)
+                self.cache_actions.cache_add(request_data=request_data, response_data=response_data)
+            raise exception
+
+    def transform_raw_response(self, raw_response):
+        return raw_response

osbot_utils/helpers/cache_requests/Cache__Requests__Row.py

@@ -0,0 +1,64 @@
+from osbot_utils.base_classes.Type_Safe                         import Type_Safe
+from osbot_utils.helpers.cache_requests.Cache__Requests__Config import Cache__Requests__Config
+from osbot_utils.helpers.cache_requests.Cache__Requests__Table  import Cache__Requests__Table
+from osbot_utils.utils.Json                                     import json_dumps
+from osbot_utils.utils.Misc                                     import str_sha256, timestamp_utc_now, bytes_sha256
+
+
+
+class Cache__Requests__Row(Type_Safe):
+    config      : Cache__Requests__Config
+    cache_table : Cache__Requests__Table
+
+    # todo: duplicated method with Sqlite__Cache__Requests (which is the one that is being overwritten)
+    #       this need to change to use the 'cache_key' workflow
+    def cache_request_data(self, *args, **target_kwargs):
+        return {'args'  : list(args)    ,
+                'kwargs': target_kwargs }                   # convert the args tuple to a list since that is what it will be once it is serialised
+
+    def create_new_cache_obj(self, request_data, response_data):
+        new_row_data = self.create_new_cache_row_data(request_data, response_data)
+        new_row_obj = self.cache_table.new_row_obj(new_row_data)
+        return new_row_obj
+
+    def create_new_cache_row_data(self, request_data, response_data):       # todo refactor this method into sub methods (one that map the request and one that maps the response)
+        request_data_json  = json_dumps(request_data)
+        request_data_hash  = str_sha256(request_data_json)
+        if self.config.add_timestamp:
+            timestamp = timestamp_utc_now()
+        else:
+            timestamp = 0
+        cache_cata = dict(request_data   = request_data_json   ,
+                          request_hash   = request_data_hash   ,
+                          timestamp      = timestamp           )
+
+        self.map_response_data(cache_cata, response_data)
+        return cache_cata
+
+    def map_response_data(self, cache_cata, response_data):
+        response_data_str   = ''
+        response_data_bytes = b''
+        if self.config.pickle_response:
+            response_type             = 'pickle'
+            response_data_bytes       = response_data
+            response_data_hash        = bytes_sha256(response_data_bytes)
+
+        else:
+            if type(response_data)   is bytes:
+                response_type         = 'bytes'
+                response_data_bytes   =  response_data
+                response_data_hash    = bytes_sha256(response_data_bytes)
+            elif type(response_data) is dict:
+                response_type         = 'dict'
+                response_data_str     = json_dumps(response_data)
+                response_data_hash    = str_sha256(response_data_str)
+            else:
+                response_type         = 'str'
+                response_data_str     = str(response_data)
+                response_data_hash    = str_sha256(response_data_str)
+
+        cache_cata['response_bytes'] = response_data_bytes
+        cache_cata['response_data' ]  = response_data_str
+        cache_cata['response_hash' ]  = response_data_hash
+        cache_cata['response_type' ]  = response_type
+

osbot_utils/helpers/cache_requests/Cache__Requests__Table.py

@@ -0,0 +1,16 @@
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+
+class Cache__Requests__Table(Type_Safe):
+
+    def _table_create(self):
+        raise NotImplementedError
+
+    def clear(self):
+        raise NotImplementedError
+
+    def row_add_and_commit(self, row_obj=None):
+        raise NotImplementedError
+
+    def rows_delete_where(self, **query_conditions):
+        raise NotImplementedError

osbot_utils/helpers/cache_requests/flows/flow__Cache__Requests.py

@@ -0,0 +1,11 @@
+import functools
+
+from osbot_utils.helpers.flows.Flow import flow
+
+
+class flow__Cache_Requests:
+
+    @flow()
+    def invoke_function(self, function, *args, **kwargs):
+        print('in invoke function')
+        return function(*args, **kwargs)