osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/testing/Catch.py

@@ -0,0 +1,54 @@
+from pprint import pprint
+
+
+class Catch:
+    """
+    Helper class for cases when the native Python exception traces is too noisy
+    """
+    def __init__(self, log_exception=False, log_headers=True, logger=None, expected_error=None, catch_exception=True, expect_exception=False):
+        self.log_exception       = log_exception
+        self.log_headers         = log_headers
+        self.logger              = logger or print
+        self.exception_type      = None
+        self.exception_value     = None
+        self.exception_traceback = None
+        self.execution_complete  = False
+        self.expected_error      = expected_error
+        self.catch_exception     = catch_exception
+        self.expect_exception    = expect_exception             # this is useful for Unit tests
+
+    def __repr__(self):
+        if self.execution_complete:
+            return f'Catch: {self.exception_type} : {self.exception_value}'
+        else:
+            return f'Catch: (not executed yet)'
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.exception_type      = exception_type
+        self.exception_value     = exception_value
+        self.exception_traceback = exception_traceback
+        self.execution_complete  = True
+        if self.log_exception:
+            if exception_type is not None:
+                if self.log_headers:
+                    self.log()
+                    self.log("********* Catch ***********")
+                    self.log(exception_type)
+                    self.log()
+                self.log(exception_value)
+        if self.expected_error:
+            self.assert_error_is(self.expected_error)
+        if self.expect_exception and exception_type is None:
+            raise Exception(f'Expected exception: {self.expected_error} but no exception was raised')
+        if self.catch_exception:
+            return True     # returning true here will prevent the exception to be propagated (which is the objective of this class :) )
+        return False
+
+    def assert_error_is(self, expected_error):
+        assert str(self) == expected_error , str(self)
+
+    def log(self, message=''):
+        self.logger(message)

osbot_utils/testing/Duration.py

@@ -0,0 +1,69 @@
+import inspect
+from datetime import timedelta
+from functools import wraps
+
+from osbot_utils.utils.Call_Stack import Call_Stack
+
+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
+    """
+    def __init__(self, prefix="\nDuration:", print_result=True, use_utc=True, print_stack=False):
+        self.use_utc            = use_utc
+        self.print_result       = print_result
+        self.prefix             = prefix
+        self.start_time         = None
+        self.end_time           = None
+        self.duration           = None
+        self.print_stack        = print_stack
+        if True or print_stack:
+            self.call_stack     = Call_Stack()
+
+    def __enter__(self):
+        if self.print_stack:
+            self.call_stack.capture()
+        self.start()
+        return self
+
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.end()
+
+    def start(self):
+        self.start_time = date_time_now(use_utc=self.use_utc, return_str=False)
+
+    def end(self):
+        self.end_time = date_time_now(use_utc=self.use_utc, return_str=False)
+        self.duration = self.end_time - self.start_time
+        if self.print_result:
+            print(f"{self.prefix} {time_delta_to_str(self.duration)}")
+            if self.print_stack:
+                self.call_stack.print()
+
+    def milliseconds(self):
+        return self.duration.total_seconds() * 1000
+
+    def seconds(self):
+        return self.duration.total_seconds()
+
+    def set_duration(self,seconds:int):
+        self.duration = timedelta(seconds=seconds)
+        return self

osbot_utils/testing/Hook_Method.py

@@ -0,0 +1,118 @@
+from osbot_utils.helpers.Print_Table import Print_Table
+from osbot_utils.utils.Call_Stack import Call_Stack
+
+from osbot_utils.testing.Duration import Duration
+
+class Hook_Method:
+
+    def __init__(self, target_module, target_method):
+        self.target_module   = target_module
+        self.target_method   = target_method
+        self.target          = getattr(target_module, target_method)
+        self.wrapper_method  = None
+        self.calls           = []
+        self.on_before_call  = []
+        self.on_after_call   = []
+        self.mock_call       = None
+
+    def __enter__(self):
+        self.wrap()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.unwrap()
+
+    def add_on_after_call(self, on_after_call):
+        """
+        method to be after before the Hooked call
+
+        method signature: def on_after_call(return_value,  *args, **kwargs):
+        should return: return_value
+        """
+        self.on_after_call.append(on_after_call)
+        return self
+
+    def add_on_before_call(self, on_before_call):
+        """
+        method to be called before the Hooked call
+
+        method signature: def on_after_call(*args, **kwargs):
+        should return: (args, kwargs)
+        """
+        self.on_before_call.append(on_before_call)
+        return self
+
+    def calls_count(self):
+        return len(self.calls)
+
+    def calls_last_one(self):
+        if len(self.calls) > 0:
+            return self.calls[-1]
+
+    def after_call(self, return_value, *args, **kwargs):
+        """
+        call all methods added via `add_on_after_call` with the params: return_value, *args, **kwargs
+        return value from each on_after_call will on override existing return_value
+        """
+        for method in self.on_after_call:
+            return_value = method(return_value, *args, **kwargs)
+        return return_value
+
+    def before_call(self, *args, **kwargs):
+        """
+        call all methods added via `add_on_before_call` with the params: *args, **kwargs
+        return value is expected to be args and kwargs on each on_after_call which will on override existing args and kwargs values
+        """
+        for method in self.on_before_call:
+            (args, kwargs) = method(*args, **kwargs)
+        return (args, kwargs)
+
+    def print(self):
+        print()
+        print()
+        with Print_Table() as _:
+            _.print(self.calls)
+
+    def set_mock_call(self, mock_call):
+        """
+        Use this to simulate a call to the Hooked Method (the
+        """
+        self.mock_call = mock_call
+
+    def wrap(self):
+
+        def wrapper_method(*args, **kwargs):
+            call_stack= Call_Stack().capture()
+            with Duration(print_result=False) as duration:
+                exception = None
+                if self.mock_call:
+                    return_value = self.mock_call(*args,**kwargs)
+                else:
+                    (args, kwargs) = self.before_call(*args, **kwargs)
+                    try:
+                        return_value   = self.target(*args, **kwargs)
+                        return_value   = self.after_call(return_value, args, kwargs)
+                    except Exception as error:
+                        return_value = None
+                        exception = error
+                        #raise error
+
+            call = {
+                        'args'        : args                ,
+                        'call_stack'  : call_stack          ,
+                        'exception'   : exception           ,
+                        'kwargs'      : kwargs              ,
+                        'return_value': return_value        ,
+                        'index'       : len(self.calls)     ,
+                        'duration'    : int(duration.seconds()*1000)
+                    }
+            self.calls.append(call)
+            return call['return_value']
+
+        self.wrapper_method = wrapper_method
+        setattr(self.target_module, self.target_method, self.wrapper_method)
+        return self.wrapper_method
+
+    def unwrap(self):
+        setattr(self.target_module, self.target_method, self.target)
+

osbot_utils/testing/Log_To_Queue.py

@@ -0,0 +1,46 @@
+# todo: finish code below so that log entries are stored in the queue
+#       expand to other capabilites of QueueHandler (namely using multiple handlers)
+# import logging
+# import queue
+# from io import StringIO
+# from logging.handlers import QueueListener, QueueHandler
+#
+#
+# class Log_To_Queue():
+#
+#     def __init__(self,logger):
+#         self.logger         = logger
+#         self.queue          = None
+#         self.queue_listener = None
+#         self.queue_handler  = None
+#
+#     def __enter__(self):
+#         self.add_handler()
+#         return self
+#
+#     def __exit__(self, exception_type, exception_value, exception_traceback):
+#         self.remove_handler()
+#
+#     def add_handler(self):
+#         self.queue          = queue.Queue(-1)
+#         self.queue_listener = QueueListener(self.queue)        # not using any handlers
+#         self.queue_handler  = QueueHandler (self.queue)
+#         self.logger.addHandler(self.queue_handler)
+#         self.queue_listener.start()
+#
+#     def contents(self):
+#         return "self.string_stream.getvalue()"
+#
+#     def set_level(self, level):
+#         self.logger.setLevel(level)
+#         return self
+#
+#     def set_level_critical(self): return self.set_level('CRITICAL') # level 50
+#     def set_level_debug   (self): return self.set_level('DEBUG'   ) # level 10
+#     def set_level_error   (self): return self.set_level('ERROR'   ) # level 40
+#     def set_level_info    (self): return self.set_level('INFO'    ) # level 20
+#     def set_level_warning (self): return self.set_level('WARNING' ) # level 30
+#
+#     def remove_handler(self):
+#         self.queue_listener.stop()
+#         self.logger.removeHandler(self.queue_handler)

osbot_utils/testing/Log_To_String.py

@@ -0,0 +1,37 @@
+import logging
+from io import StringIO
+
+class Log_To_String():
+
+    def __init__(self,logger):
+        self.logger         = logger
+        self.string_stream  = None
+        self.string_handler = None
+
+    def __enter__(self):
+        self.add_handler()
+        return self
+
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.remove_handler()
+
+    def add_handler(self):
+        self.string_stream = StringIO()
+        self.string_handler = logging.StreamHandler(self.string_stream)
+        self.logger.addHandler(self.string_handler)
+
+    def contents(self):
+        return self.string_stream.getvalue()
+
+    def set_level(self, level):
+        self.logger.setLevel(level)
+        return self
+
+    def set_level_critical(self): return self.set_level('CRITICAL') # level 50
+    def set_level_debug   (self): return self.set_level('DEBUG'   ) # level 10
+    def set_level_error   (self): return self.set_level('ERROR'   ) # level 40
+    def set_level_info    (self): return self.set_level('INFO'    ) # level 20
+    def set_level_warning (self): return self.set_level('WARNING' ) # level 30
+
+    def remove_handler(self):
+        self.logger.removeHandler(self.string_handler)

osbot_utils/testing/Logging.py

@@ -0,0 +1,81 @@
+import inspect
+import logging
+from io import StringIO
+
+import sys
+
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+
+#DEFAULT_LOG_FORMAT  = '%(asctime)s.%(msecs)03d %(levelname)s - %(message)s'
+DEFAULT_LOG_FORMAT  = '%(levelname)s - %(message)s'
+DEFAULT_LOG_LEVEL   = logging.DEBUG
+DEFAULT_DATE_FORMAT = '%M:%S'
+class Logging:
+
+    def __init__(self, target=None, log_level: int = None, log_format=None, log_to_console=False, date_format=None):
+        self.target      = target
+        self.log_level   = log_level   or DEFAULT_LOG_LEVEL
+        self.log_format  = log_format  or DEFAULT_LOG_FORMAT
+        self.date_format = date_format or DEFAULT_DATE_FORMAT
+        if log_to_console:
+            self.log_to_sys_stdout()
+
+    def __enter__(self): return self
+    def __exit__ (self, exc_type, exc_val, exc_tb): pass
+
+    def add_stream_handler(self, stream):
+        stream_handler = logging.StreamHandler(stream=stream)
+        self.logger().addHandler(stream_handler)
+        self.set_logger_level()
+        self.set_format(stream_handler)
+
+        return stream_handler
+
+    @cache_on_self
+    def logger(self):
+        if self.target is not None:
+            if inspect.isclass(self.target) or inspect.ismodule(self.target):
+                self.target = self.target.__name__
+        return logging.getLogger(self.target)
+
+    def enable_log_to_console(self, log_level=logging.INFO):
+        self.log_to_sys_stdout()
+        self.set_logger_level(log_level)
+        return self
+
+    def enable_pycharm_logging(self):
+        if self.is_pycharm_running():
+            self.log_to_sys_stdout()
+        return self
+
+    def is_pycharm_running(self) -> bool:
+        first_arg = sys.argv[0]
+        return ('docrunner.py' in first_arg) or ('pytest_runner.py' in first_arg)
+
+    def log_to_sys_stdout(self):
+        return self.add_stream_handler(sys.stdout)
+
+    def log_to_string_io(self):
+        log_stream = StringIO()
+        return self.add_stream_handler(log_stream)
+
+
+    def set_format(self, stream_handler):
+        formatter = logging.Formatter(fmt=self.log_format, datefmt=self.date_format)
+        stream_handler.setFormatter(formatter)
+        return formatter
+
+    def set_format_on_all_handlers(self):
+        for handler in logging.root.handlers[:]:
+            handler.setFormatter(logging.Formatter(fmt=self.log_format, datefmt=self.date_format))
+        return self
+
+    def set_logger_level(self, level=None):
+        self.logger().setLevel(level or self.log_level)
+
+
+    def info    (self,message, *args, **kwargs): self.logger().info     (message, *args, **kwargs)
+    def warning (self,message, *args, **kwargs): self.logger().warning  (message, *args, **kwargs)
+    def debug   (self,message, *args, **kwargs): self.logger().debug    (message, *args, **kwargs)
+    def error   (self,message, *args, **kwargs): self.logger().error    (message, *args, **kwargs)
+    def critical(self,message, *args, **kwargs): self.logger().critical (message, *args, **kwargs)

osbot_utils/testing/Patch_Print.py

@@ -0,0 +1,52 @@
+from unittest.mock import patch, MagicMock, _patch
+from osbot_utils.utils.Dev import pprint
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+
+class Patch_Print(Kwargs_To_Self):
+    enabled        : bool      = True
+    expected_calls : list
+    mocked_print   : MagicMock
+    patched_print  : _patch
+    print_calls    : bool
+
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def __enter__(self):
+        if self.enabled:
+            self.patched_print = patch('builtins.print')
+            self.mocked_print = self.patched_print.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.enabled:
+            self.patched_print.stop()
+
+            if self.print_calls:
+                pprint(self.calls())
+                #print(self.mocked_print.call_args_list)
+
+            if self.expected_calls:
+                assert self.calls() == self.expected_calls
+
+    def call_args_list(self):
+        if self.mocked_print:
+            return self.mocked_print.call_args_list
+        return []
+
+    def calls(self):
+        calls_data = []
+        if self.mocked_print:
+            for call in self.mocked_print.call_args_list:
+                if len(call.args) == 0 and call.kwargs == {}:
+                    call_data = ''
+                elif len(call.args) == 1 and call.kwargs == {}:
+                    call_data = call.args[0]
+                else:
+                    call_data = (call.args,  call.kwargs)
+                calls_data.append(call_data)
+        return calls_data
+
+

osbot_utils/testing/Profiler.py

@@ -0,0 +1,89 @@
+import sys
+
+# see https://explog.in/notes/settrace.html for ideas on how to expand this class
+
+class Profiler:
+
+    def __init__(self):
+        self.events = []
+        self.profile_options   = self.default_profile_options()
+        self.previous_profiler = self.current_profiler()
+        self.on_event = None
+
+    def __enter__(self):
+        sys.setprofile(self.profiling_function)
+        return self
+
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        sys.setprofile(self.previous_profiler)
+
+    def add_values(self, profile_options, source):
+        item = {}
+        for arg_name in set(profile_options):
+            option =  profile_options.get(arg_name)
+            value  = getattr(source, arg_name)
+            if type(option) is dict:
+                item[arg_name] = self.add_values(option, value)
+            else:
+                if profile_options.get(arg_name):
+                    if arg_name == 'f_locals':
+                        item[arg_name] = value.copy()           # create a copy of the var
+                    else:
+                        item[arg_name] = value
+        return item
+
+    def current_profiler(self):
+        return sys.getprofile()
+
+    def default_profile_options(self):
+        return {
+            'f_back'         : False,
+            'f_builtins'     : False,
+            'f_code'         : {
+                'co_argcount'       : True ,
+                'co_cellvars'       : True ,
+                'co_code'           : True ,
+                'co_consts'         : True ,
+                'co_filename'       : True ,
+                'co_firstlineno'    : True ,
+                'co_flags'          : True ,
+                'co_freevars'       : True ,
+                'co_kwonlyargcount' : True ,
+                'co_lnotab'         : True ,
+                'co_name'           : True ,
+                'co_names'          : True ,
+                'co_nlocals'        : True ,
+                'co_posonlyargcount': True ,
+                'co_stacksize'      : True ,
+                'co_varnames'       : True ,
+            } ,
+            'f_globals'      : False,
+            'f_lasti'        : True ,
+            'f_lineno'       : True ,
+            'f_locals'       : True ,
+            'f_trace'        : True ,
+            'f_trace_lines'  : True ,
+            'f_trace_opcodes': True
+        }
+
+    def get_last_event(self):
+        return self.events.pop()
+
+    def get_f_locals(self):
+        return self.get_last_event().get('f_locals')
+
+    def get_f_locals_variable(self, var_name):
+        return self.get_f_locals().get(var_name)
+
+    def profiling_function(self, frame, event, arg):
+        if type(frame.f_locals.get('self')) != Profiler:                    # dont' capture traces of the current (Trace) class
+            item = self.add_values(self.profile_options, frame)
+            item['arg'  ] = arg
+            item['event'] = event
+            self.events.append(item)
+            if self.on_event:
+                self.on_event(self,frame, event, arg)                         # allow the caler to see and modify the data (after its data been captured)
+
+    def set_on_event(self, on_event):
+        self.on_event = on_event
+        return self

osbot_utils/testing/Stderr.py

@@ -0,0 +1,19 @@
+import io
+from contextlib import redirect_stderr
+
+
+class Stderr:
+    def __init__(self):
+        self.output          = io.StringIO()
+        self.redirect_stderr = redirect_stderr(self.output)
+
+    def __enter__(self):
+        self.redirect_stderr.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.redirect_stderr.__exit__(exc_type, exc_val, exc_tb)
+
+    def value(self):
+        return self.output.getvalue()
+

osbot_utils/testing/Stdout.py

@@ -0,0 +1,19 @@
+import io
+from contextlib import redirect_stdout
+
+
+class Stdout:
+    def __init__(self):
+        self.output          = io.StringIO()
+        self.redirect_stdout = redirect_stdout(self.output)
+
+    def __enter__(self):
+        self.redirect_stdout.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.redirect_stdout.__exit__(exc_type, exc_val, exc_tb)
+
+    def value(self):
+        return self.output.getvalue()
+

osbot_utils/testing/Temp_File.py

@@ -0,0 +1,46 @@
+from osbot_utils.utils.Files import Files, file_delete, folder_delete_all, files_list, file_create, file_name, \
+    parent_folder, file_exists, file_contents
+from osbot_utils.utils.Misc import random_filename
+
+
+class Temp_File:
+    def __init__(self, contents='...', extension='tmp'):
+        self.tmp_file            = random_filename(extension)
+        self.tmp_folder          = None
+        self.file_path           = None
+        self.original_contents   = contents
+
+    def __enter__(self):
+        self.tmp_folder = Files.temp_folder(prefix='temp_folder_')
+        self.file_path = Files.path_combine(self.tmp_folder, self.tmp_file)
+        file_create(self.file_path, self.original_contents)
+        return self
+
+    def __exit__(self, type, value, traceback):
+        file_delete      (self.file_path)
+        folder_delete_all(self.tmp_folder)
+
+    def contents(self):
+        return file_contents(self.file_path)
+
+    def delete(self):
+        return file_delete(self.file_path)
+
+    def exists(self):
+        return file_exists(self.file_path)
+
+    def file_name(self):
+        return file_name(self.path())
+
+    def files_in_folder(self):
+        return files_list(self.tmp_folder)
+
+    def folder(self):
+        return parent_folder(self.path())
+
+    def path(self):
+        return self.file_path
+
+    def write(self, contents):
+        file_create(self.file_path, contents)
+        return self