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

osbot_utils/helpers/flows/Flow.py

@@ -0,0 +1,145 @@
+import logging
+import typing
+from functools import wraps
+
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+from osbot_utils.helpers.CFormat import CFormat, f_dark_grey, f_magenta
+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
+
+FLOW__RANDOM_ID__PREFIX    = 'flow_id__'
+FLOW__RANDOM_NAME__PREFIX  = 'flow_name__'
+FLOW__LOGGING__LOG_FORMAT  = '%(asctime)s.%(msecs)03d | %(levelname)-8s | %(message)s'
+FLOW__LOGGING__DATE_FORMAT = '%H:%M:%S'
+
+def flow(**flow_kwargs):
+
+    def decorator(function):
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            with Flow(**flow_kwargs) as flow:
+                flow.set_flow_target(function)
+                flow.setup()
+                flow.create_flow()
+                flow.execute_flow(*args, **kwargs)
+                return flow.return_value
+
+        return wrapper
+    return decorator
+
+
+class Flow(Type_Safe):
+    captured_exec_logs : list
+    flow_id            : str
+    flow_name          : str
+    flow_target        : callable
+    logger             : Python_Logger
+    cformat            : CFormat
+    log_to_console     : bool    = False
+    log_to_memory      : bool    = True
+    print_logs         : bool    = False
+    return_value       : typing.Any
+
+
+    def config_logger(self):
+        with self.logger as _:
+            _.set_log_level(logging.DEBUG)
+            _.set_log_format(log_format=FLOW__LOGGING__LOG_FORMAT, date_format=FLOW__LOGGING__DATE_FORMAT)
+            if self.log_to_console:
+                _.add_console_logger()
+
+
+    def debug(self, message):
+        self.logger.debug(message)
+
+    def create_flow(self):
+        self.set_flow_name()
+        self.debug(f"Created flow run '{self.f__flow_id()}' for flow '{self.f__flow_name()}'")
+
+    def execute_flow(self, *args, **kwargs):
+        if self.log_to_memory:
+            self.logger.add_memory_logger()                                     # todo: move to method that does pre-execute tasks
+
+        self.debug(f"Executing flow run '{self.f__flow_id()}''")
+        try:
+            with Stdout() as stdout:
+                self.return_value = self.flow_target(*args, **kwargs)           # todo, capture *args, **kwargs in logs
+        except Exception as error:
+            self.logger.error(self.cformat.red(f"Error executing flow: {error}"))
+        self.log_captured_stdout(stdout)
+        self.debug(f"{f_dark_grey('return value')}: {self.return_value}")
+        self.debug(f"Finished flow run '{self.f__flow_id()}''")
+
+        if self.log_to_memory:
+            self.captured_exec_logs = self.log_messages_with_colors()
+            self.logger.remove_memory_logger()                                  # todo: move to method that does post-execute tasks
+
+    def f__flow_id(self):
+        return self.cformat.green(self.flow_id)
+
+    def f__flow_name(self):
+        return self.cformat.blue(self.flow_name)
+
+    def info(self, message):
+        self.logger.info(message)
+
+    def log_captured_stdout(self, stdout):
+        for line in stdout.value().splitlines():
+            if line:
+                self.info(f_magenta(line))
+        if self.print_logs:
+            print()
+            print()
+            self.print_log_messages()
+
+
+    def log_messages(self):
+        return ansis_to_texts(self.log_messages_with_colors())
+
+    def log_messages_with_colors(self):
+        return self.logger.memory_handler_messages()
+
+    def print_log_messages(self, use_colors=True):
+        if use_colors:
+            for message in self.logger.memory_handler_messages():
+                print(message)
+        else:
+            for message in self.log_messages():
+                print(message)
+        return self
+    def random_flow_id(self):
+        return lower(random_id(prefix=FLOW__RANDOM_ID__PREFIX))
+
+    def random_flow_name(self):
+        return lower(random_id(prefix=FLOW__RANDOM_NAME__PREFIX))
+
+
+    def set_flow_target(self, target):
+        self.flow_target = target
+        return self
+
+    def set_flow_name(self, value=None):
+        if value:
+            self.flow_name = value
+        else:
+            if not self.flow_name:
+                if hasattr(self.flow_target, '__name__'):
+                    self.flow_name = self.flow_target.__name__
+                else:
+                    self.flow_name = self.random_flow_name()
+    def setup(self):
+        with self as _:
+            _.cformat.auto_bold = True
+            _.config_logger()
+            _.setup_flow_run()
+        return self
+
+    def setup_flow_run(self):
+        with self as _:
+            if not _.flow_id:
+                _.flow_id = self.random_flow_id()
+            #if not _.flow_name:
+            #    _.flow_name = self.flow_target.__name__
+                #self.random_flow_name()

osbot_utils/helpers/flows/Task.py

@@ -0,0 +1,18 @@
+import inspect
+
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+from osbot_utils.helpers.flows.Flow import Flow
+
+
+class Task(Type_Safe):
+    task_id       : str
+    task_name     : str
+
+    def find_flow(self):
+        stack = inspect.stack()
+        for frame_info in stack:
+            frame = frame_info.frame
+            if 'self' in frame.f_locals:
+                instance = frame.f_locals['self']
+                if type(instance) is Flow:
+                    return instance

osbot_utils/helpers/sqlite/{domains/schemas → cache}/Schema__Table__Requests.py

@@ -1,12 +1,14 @@
 from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
 
 class Schema__Table__Requests(Kwargs_To_Self):
+    comments      : str
+    metadata      : str
+    request_type  : str
     request_hash  : str
     request_data  : str
+    response_bytes: bytes
     response_hash : str
     response_data : str
-    response_bytes: bytes
-    cache_hits    : int                         # todo: to implement
+    response_type : str
+    source        : str
     timestamp     : int
-    latest        : bool                        # todo: add native bool support to sqlite
-    comments      : str

osbot_utils/helpers/sqlite/cache/Sqlite__Cache__Requests.py

@@ -0,0 +1,104 @@
+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
+from osbot_utils.helpers.cache_requests.Cache__Requests__Invoke             import Cache__Requests__Invoke
+from osbot_utils.helpers.cache_requests.Cache__Requests__Row                import Cache__Requests__Row
+from osbot_utils.helpers.sqlite.cache.Sqlite__Cache__Requests__Table        import Sqlite__Cache__Requests__Table
+from osbot_utils.helpers.sqlite.cache.Sqlite__Cache__Requests__Sqlite       import Sqlite__Cache__Requests__Sqlite
+
+
+class Sqlite__Cache__Requests(Type_Safe):
+    db_path    : None
+    db_name    : None
+    table_name : None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # todo refactor this whole section to a DI (DependencyInjection / Type_Registry class, which is the one responsible for creating these objects in the right order of dependency)
+
+        self.cache_config       = Cache__Requests__Config()
+        self.config             = self.cache_config
+
+        kwargs__cache_sqlite   = dict(config=self.cache_config, db_path=self.db_path, db_name=self.db_name, table_name=self.table_name)
+        self.cache_sqlite      = Sqlite__Cache__Requests__Sqlite (**kwargs__cache_sqlite)
+        self.sqlite_requests   = self.cache_sqlite.sqlite_requests
+
+        #self.cache_table       = self.cache_sqlite.cache_table
+        self.cache_table        = Sqlite__Cache__Requests__Table(cache_table=self.cache_sqlite.cache_table())
+
+
+        kwargs__cache_table    = dict(                        cache_table        = self.cache_table               )
+
+        kwargs__cache_data     = dict(**kwargs__cache_table,  cache_request_data = self.cache_request_data        ,
+                                                              config             = self.cache_config              )
+        self.cache_data        = Cache__Requests__Data(**kwargs__cache_data)
+
+        kwargs__cache_row      = dict(**kwargs__cache_table,  config             = self.cache_config              )
+        self.cache_row         = Cache__Requests__Row    (**kwargs__cache_row   )
+
+
+
+        kwargs__cache_actions = dict(**kwargs__cache_table, cache_row=self.cache_row)
+        self.cache_actions    = Cache__Requests__Actions(**kwargs__cache_actions  )
+
+        kwargs__cache_invoke  = dict(cache_data       = self.cache_data         ,
+                                     cache_actions    = self.cache_actions      ,
+                                     config           = self.cache_config       )
+        self.cache_invoke     = Cache__Requests__Invoke(**kwargs__cache_invoke)
+
+        self.apply_refactoring_patches()
+
+    def apply_refactoring_patches(self):
+        self.cache_add                       = self.cache_actions.cache_add
+        self.cache_delete                    = self.cache_actions.cache_delete
+        self.create_new_cache_row_data       = self.cache_actions.create_new_cache_row_data
+
+        self.cache_entries                   = self.cache_data.cache_entries
+        self.cache_entry                     = self.cache_data.cache_entry
+        self.cache_entry_comments            = self.cache_data.cache_entry_comments
+        self.cache_entry_comments_update     = self.cache_data.cache_entry_comments_update
+        self.cache_entry_for_request_params  = self.cache_data.cache_entry_for_request_params
+        self.response_data_for__request_hash = self.cache_data.response_data_for__request_hash
+        self.response_data__all              = self.cache_data.response_data__all
+        self.response_data_deserialize       = self.cache_data.response_data_deserialize
+        self.response_data_serialize         = self.cache_data.response_data_serialize
+
+        self.create_new_cache_obj            = self.cache_row.create_new_cache_obj
+
+        self.cache_table__clear              = self.cache_table.cache_table__clear
+        self.delete_where_request_data       = self.cache_table.delete_where_request_data
+        self.rows_where                      = self.cache_table.rows_where
+        self.rows_where__request_data        = self.cache_table.rows_where__request_data
+        self.rows_where__request_hash        = self.cache_table.rows_where__request_hash
+
+        self.disable                         = self.cache_config.disable
+        self.enable                          = self.cache_config.enable
+        self.only_from_cache                 = self.cache_config.only_from_cache
+        self.update                          = self.cache_config.update
+        self.set__add_timestamp              = self.cache_config.set__add_timestamp
+
+        self.invoke                          = self.cache_invoke.invoke
+        self.invoke_target                   = self.cache_invoke.invoke_target
+        #self.invoke_with_cache               = self.cache_invoke.invoke_with_cache
+        self.invoke_target__and_add_to_cache = self.cache_invoke.invoke_target__and_add_to_cache
+        self.transform_raw_response          = self.cache_invoke.transform_raw_response
+
+
+
+    # FOR NOW: these methods cannot be refactored
+
+    # this is the method that is current overwritten to create custom request data
+    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 invoke_with_cache(self, *args, **target_kwargs):
+        return self.cache_invoke.invoke_with_cache(*args, **target_kwargs)
+
+    def set_on_invoke_target(self, on_invoke_target  : types.FunctionType):
+        self.cache_invoke.on_invoke_target = on_invoke_target
+
+    def requests_data__all(self):                                                       # currently overwritten by Bedrock__Cache
+        return self.cache_data.requests_data__all()

osbot_utils/helpers/sqlite/{domains → cache}/Sqlite__Cache__Requests__Patch.py

@@ -1,20 +1,19 @@
 import types
 
-from osbot_utils.helpers.sqlite.domains.Sqlite__Cache__Requests import Sqlite__Cache__Requests
-from osbot_utils.utils.Dev import pprint
-from osbot_utils.utils.Misc import random_text
+from osbot_utils.helpers.sqlite.cache.Sqlite__Cache__Requests   import Sqlite__Cache__Requests
+from osbot_utils.utils.Misc                                     import random_text
 
 
 class Sqlite__Cache__Requests__Patch(Sqlite__Cache__Requests):
-    db_name             : str                = random_text('requests_cache_')
-    table_name          : str                = random_text('requests_table_')
-    pickle_response     : bool               = True
+    db_name             : str                #= random_text('requests_cache_')
+    table_name          : str                #= random_text('requests_table_')             # todo : remove this so that we default to an in memory db
     target_function     : types.FunctionType
     target_class        : object
     target_function_name: str
 
-    def __init__(self, db_path=None):
-        super().__init__(db_path=db_path, db_name=self.db_name, table_name=self.table_name)
+    def __init__(self, db_name=None, table_name=None, db_path=None):
+        super().__init__(db_path=db_path, db_name=db_name, table_name=table_name)
+        self.cache_config.pickle_response = True
 
     def __enter__(self):
         self.patch_apply()
@@ -24,6 +23,9 @@ class Sqlite__Cache__Requests__Patch(Sqlite__Cache__Requests):
         self.patch_restore()
         return
 
+    def database(self):
+        return self.cache_table.database
+
     def delete(self):
         return self.sqlite_requests.delete()
 

osbot_utils/helpers/sqlite/cache/Sqlite__Cache__Requests__Sqlite.py

@@ -0,0 +1,18 @@
+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.sqlite.cache.Sqlite__DB__Requests      import Sqlite__DB__Requests
+
+
+class Sqlite__Cache__Requests__Sqlite(Type_Safe):
+    sqlite_requests : Sqlite__DB__Requests              = None
+    config          : Cache__Requests__Config
+    db_path         : str
+    db_name         : str
+    table_name      : str
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.sqlite_requests = Sqlite__DB__Requests(db_path=self.db_path, db_name=self.db_name, table_name=self.table_name)
+
+    def cache_table(self):
+        return self.sqlite_requests.table_requests()
+

osbot_utils/helpers/sqlite/cache/Sqlite__Cache__Requests__Table.py

@@ -0,0 +1,48 @@
+from osbot_utils.helpers.cache_requests.Cache__Requests__Table import Cache__Requests__Table
+from osbot_utils.helpers.sqlite.Sqlite__Table                  import Sqlite__Table
+from osbot_utils.utils.Json import json_dumps
+
+
+class Sqlite__Cache__Requests__Table(Cache__Requests__Table):
+    cache_table : Sqlite__Table
+
+    def __init__(self, **kwargs):
+        super().__init__( **kwargs)
+
+        self.table_name           = self.cache_table.table_name
+        self._table_create        = self.cache_table._table_create
+        self.database             = self.cache_table.database
+        self.clear                = self.cache_table.clear
+        self.exists               = self.cache_table.exists
+        self.indexes              = self.cache_table.indexes
+        self.new_row_obj          = self.cache_table.new_row_obj
+        self.row_add_and_commit   = self.cache_table.row_add_and_commit
+        self.row_update           = self.cache_table.row_update
+        self.row_schema           = self.cache_table.row_schema
+        self.rows                 = self.cache_table.rows
+        self.rows_delete_where    = self.cache_table.rows_delete_where
+        self.schema__by_name_type = self.cache_table.schema__by_name_type
+        self.select_rows_where    = self.cache_table.select_rows_where
+        self.size                 = self.cache_table.size
+
+    def cache_table__clear(self):
+        return self.cache_table.clear()
+
+    def delete_where_request_data(self, request_data):                                      # todo: check if it is ok to use the request_data as a query target, or if we should use the request_hash variable
+        if type(request_data) is dict:                                                      # if we get an request_data obj
+            request_data = json_dumps(request_data)                                         # convert it to the json dump
+        if type(request_data) is str:                                                       # make sure we have a string
+            if len(self.rows_where__request_data(request_data)) > 0:                        # make sure there is at least one entry to delete
+                self.cache_table.rows_delete_where(request_data=request_data)             # delete it
+                return len(self.rows_where__request_data(request_data)) == 0                # confirm it was deleted
+        return False                                                                        # if anything was not right, return False
+
+    def rows_where(self, **kwargs):
+        return self.cache_table.select_rows_where(**kwargs)
+
+    def rows_where__request_data(self, request_data):
+        return self.rows_where(request_data=request_data)
+
+    def rows_where__request_hash(self, request_hash):
+        return self.rows_where(request_hash=request_hash)
+

osbot_utils/helpers/sqlite/{domains → cache}/Sqlite__DB__Requests.py

@@ -1,7 +1,6 @@
-from osbot_utils.decorators.methods.cache_on_self import cache_on_self
-from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local               import Sqlite__DB__Local
-from osbot_utils.helpers.sqlite.domains.schemas.Schema__Table__Requests import Schema__Table__Requests
-from osbot_utils.utils.Misc import random_text
+from osbot_utils.decorators.methods.cache_on_self               import cache_on_self
+from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local       import Sqlite__DB__Local
+from osbot_utils.helpers.sqlite.cache.Schema__Table__Requests   import Schema__Table__Requests
 
 SQLITE_TABLE__REQUESTS = 'requests'
 
@@ -12,11 +11,13 @@ class Sqlite__DB__Requests(Sqlite__DB__Local):
     def __init__(self,db_path=None, db_name=None, table_name=None):
         self.table_name   = table_name or SQLITE_TABLE__REQUESTS
         self.table_schema = Schema__Table__Requests
-        super().__init__(db_path=db_path, db_name=db_name)
-        # if not self.table_name:
-        #     self.table_name = 'temp_table'
+        in_memory         = not (db_path or db_name)
+        super().__init__(db_path=db_path, db_name=db_name, in_memory=in_memory)
         self.setup()
 
+    def __repr__(self):
+        return f'{self.__class__.__name__} [ db_name={self.db_name} | table_name={self.table_name} | in_memory={self.in_memory} ]'
+
     @cache_on_self
     def table_requests(self):
         return self.table(self.table_name)

osbot_utils/helpers/sqlite/cache/TestCase__Sqlite__Cache__Requests.py

@@ -0,0 +1,35 @@
+from unittest import TestCase
+
+from osbot_utils.helpers.sqlite.cache.Sqlite__Cache__Requests import Sqlite__Cache__Requests
+from osbot_utils.utils.Misc import random_text
+
+
+class TestCase__Sqlite__Cache__Requests(TestCase):
+    sqlite_cache_requests : Sqlite__Cache__Requests
+
+    @classmethod
+    def setUpClass(cls):
+        cls.sqlite_cache_requests = Sqlite__Cache__Requests()
+        cls.sqlite_cache_requests.set__add_timestamp(False)                   # disabling timestamp since it complicates the test data verification below
+        assert cls.sqlite_cache_requests.sqlite_requests.in_memory is True    # confirm we have an in-memory db
+
+    def tearDown(self):
+        self.sqlite_cache_requests.cache_table.clear()
+
+    def add_test_requests(self, count=10):
+        def invoke_target(*args, **target_kwargs):
+            return {'type'          : 'response'                       ,
+                    'source'        : 'add_test_requests.invoke_target',
+                    'request_args'  : args                             ,
+                    'request_kwargs': target_kwargs                    }
+
+        for i in range(count):
+            an_key        = random_text('an_key')
+            an_dict       = {'the': random_text('random_request')}
+            target        = invoke_target
+            target_args   = ['abc']
+            target_kwargs = {'an_key': an_key, 'an_dict': an_dict}
+            response = self.sqlite_cache_requests.invoke(target, target_args, target_kwargs)
+            # todo add comments to the entry
+            #self.sqlite_cache_requests.cache_entry_comments_update()
+            #pprint(response)

osbot_utils/helpers/sqlite/domains/Sqlite__DB__Local.py

@@ -9,10 +9,14 @@ ENV_NAME_PATH_LOCAL_DBS = 'PATH_LOCAL_DBS'
 class Sqlite__DB__Local(Sqlite__Database):
     db_name: str
 
-    def __init__(self, db_path=None, db_name=None):
+    def __init__(self, db_path=None, db_name=None, in_memory=False):
+
         if hasattr(self, 'db_name') is False:
             self.db_name = db_name or random_text('db_local') + '.sqlite'
-        super().__init__(db_path=db_path or self.path_local_db())
+        if in_memory:
+            super().__init__()
+        else:
+            super().__init__(db_path=db_path or self.path_local_db())  # todo: add option to run this in memory, without creating a temp file
 
     def path_db_folder(self):
         return environ.get(ENV_NAME_PATH_LOCAL_DBS) or current_temp_folder()

osbot_utils/helpers/{SCP.py → ssh/SCP.py}

@@ -1,14 +1,13 @@
-from osbot_utils.context_managers.capture_duration import capture_duration
-from osbot_utils.helpers.SSH import SSH
-from osbot_utils.testing.Temp_Zip import Temp_Zip
-from osbot_utils.utils.Dev import pprint
-from osbot_utils.utils.Files import file_exists, file_not_exists, file_name
-from osbot_utils.utils.Process import start_process
-from osbot_utils.utils.Status import status_error
-from osbot_utils.utils.Zip import zip_folder
+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
 
 
-class SCP(SSH):
+
+class SCP(SSH__Execute):
 
     def copy_file_to_host(self, local_file, host_file=None):
         if file_not_exists(local_file):
@@ -31,20 +30,24 @@ class SCP(SSH):
         if file_not_exists(local_folder):
             return status_error(error="in copy_folder_as_zip_to_host, local_folder provided doesn't exist in current host", data={'local_folder':local_folder})
         with Temp_Zip(target=local_folder) as temp_zip:
-            host_file = temp_zip.file_name()
-            kwargs    = dict(local_file = temp_zip.path(),
-                             host_file  = host_file      )
-            self.mkdir(unzip_to_folder)
-            self.copy_file_to_host(**kwargs)
-            command = f'unzip {host_file} -d {unzip_to_folder}'
-            self.execute_command(command)
-            self.rm(host_file)
-
-
-
+            host_file        = temp_zip.file_name()
+            kwargs           = dict(local_file = temp_zip.path(),
+                                    host_file  = host_file      )
+            command_unzip    = f'unzip {host_file} -d {unzip_to_folder}'
+            result_ssh_mkdir = self.mkdir(unzip_to_folder)
+            result_scp_zip   = self.copy_file_to_host(**kwargs)
+            result_ssh_unzip = self.execute_command(command_unzip)
+            result_rm_zip    = self.rm(host_file)
+            return dict(result_ssh_mkdir=result_ssh_mkdir ,
+                        result_scp_zip  =result_scp_zip   ,
+                        result_ssh_unzip=result_ssh_unzip ,
+                        result_rm_zip   =result_rm_zip    )
 
     def execute_scp_command(self, scp_args):
         if self.ssh_host and self.ssh_key_file and self.ssh_key_user and scp_args:
+            if scp_args[0] == '-p':         # todo refactor this to a better method/class to create the ssh and scp args
+                scp_args[0] = '-P'          #      this hack is to handle the fact that ssh and scp use different flags for the port!! WTF!! :)
+
             with capture_duration() as duration:
                 result = start_process("scp", scp_args)  # execute scp command using subprocess.run(...)
             result['duration'] = duration.data()

osbot_utils/helpers/ssh/SSH.py

@@ -0,0 +1,30 @@
+from osbot_utils.base_classes.Kwargs_To_Self        import Kwargs_To_Self
+from osbot_utils.decorators.methods.cache_on_self   import cache_on_self
+from osbot_utils.helpers.ssh.SCP                    import SCP
+from osbot_utils.helpers.ssh.SSH__Execute           import SSH__Execute
+from osbot_utils.helpers.ssh.SSH__Linux             import SSH__Linux
+from osbot_utils.helpers.ssh.SSH__Python            import SSH__Python
+
+class SSH(Kwargs_To_Self):
+
+    def setup(self):
+        self.ssh_execute().setup()
+        return self
+
+    @cache_on_self
+    def scp(self):
+        kwargs = self.ssh_execute().__locals__()        # get the current ssh config details
+        scp = SCP(**kwargs)                             # use it in the ctor of SCP
+        return scp
+
+    @cache_on_self
+    def ssh_execute(self):
+        return SSH__Execute()
+
+    @cache_on_self
+    def ssh_linux(self):
+        return SSH__Linux(ssh_execute = self.ssh_execute())
+
+    @cache_on_self
+    def ssh_python(self):
+        return SSH__Python(ssh_execute = self.ssh_execute(), ssh_linux = self.ssh_linux())

osbot_utils/helpers/ssh/SSH__Cache__Requests.py

@@ -0,0 +1,66 @@
+from osbot_utils.helpers.sqlite.cache.Sqlite__Cache__Requests__Patch    import Sqlite__Cache__Requests__Patch
+from osbot_utils.helpers.ssh.SSH__Execute import SSH__Execute
+from osbot_utils.utils.Call_Stack import call_stack_frames_data
+from osbot_utils.utils.Dev import pprint
+from osbot_utils.utils.Json                                             import json_to_str, json_loads
+from osbot_utils.utils.Python_Logger import Python_Logger
+from osbot_utils.utils.Toml                                             import dict_to_toml, toml_to_dict
+
+SQLITE_DB_NAME__SSH_REQUESTS_CACHE = 'ssh_requests_cache.sqlite'
+SQLITE_TABLE_NAME__SSH_REQUESTS    = 'ssh_requests'
+
+
+
+class SSH__Cache__Requests(Sqlite__Cache__Requests__Patch):
+    db_path                           : str
+    db_name                           : str  = SQLITE_DB_NAME__SSH_REQUESTS_CACHE
+    table_name                        : str  = SQLITE_TABLE_NAME__SSH_REQUESTS
+    add_caller_signature_to_cache_key : bool = True
+    print_ssh_execution_stdout        : bool = False
+    logging                           : Python_Logger
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.target_class           = SSH__Execute
+        self.target_function        = SSH__Execute.execute_command
+        self.target_function_name   = "execute_command"
+        self.print_requests         = False
+        self.logging.add_console_logger()
+
+
+    def invoke_target(self, target, target_args, target_kwargs):
+        if self.print_requests:
+            print(f'[invoke_target]: {target_args}')
+        return super().invoke_target(target, target_args, target_kwargs)
+
+    def invoke_with_cache(self, **invoke_kwargs):
+        result = super().invoke_with_cache(**invoke_kwargs)
+        stdout = result.get('stdout')
+        if self.print_ssh_execution_stdout and stdout:
+            #print(stdout)
+            self.logging.info('\n\n' + stdout)
+        return result
+
+    def request_data(self, *args, **kwargs):
+        ssh                 = args[0]
+        ssh_host            = ssh.ssh_host
+        args_with_out_self  = args[1:]
+        request_data = dict(args             = args_with_out_self,
+                            kwargs           = kwargs            ,
+                            ssh_host         = ssh_host          )
+        if self.add_caller_signature_to_cache_key:
+            frames              = call_stack_frames_data(8)                 # todo: refactor this to separate method
+            caller_signature = (f"{frames[0].get('name')}:{frames[0].get('lineno')}  | "
+                                f"{frames[1].get('name')}:{frames[1].get('lineno')}  | "
+                                f"{frames[2].get('name')}:{frames[2].get('lineno')}'")
+            request_data['caller_signature'] = caller_signature            # this adds support for different caches to the same method call (main limitation is that it is directly tied with the line numbers)
+
+        return dict_to_toml(request_data)
+
+    def requests_data__all(self):
+        requests_data__all = super().requests_data__all()
+        for item in requests_data__all:
+            request_data_raw      = item.get('request_data')
+            request_data_original = toml_to_dict(json_loads(request_data_raw))
+            item['request_data']  = request_data_original
+        return requests_data__all