osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/helpers/trace/Trace_Call__Print_Lines.py

@@ -0,0 +1,85 @@
+from osbot_utils.utils.Lists import list_sorted
+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.helpers.trace.Trace_Call__Config       import Trace_Call__Config
+from osbot_utils.helpers.trace.Trace_Call__Print_Traces import text_grey, text_bold_green, text_olive, text_light_grey
+
+
+class Trace_Call__Print_Lines(Kwargs_To_Self):
+
+    config     : Trace_Call__Config
+    view_model : list
+
+    def lines(self):
+        lines = []
+        for trace in self.view_model:
+            items          = trace.get('lines')
+            leading_spaces = 0
+            if items:
+                line = items[0].get('line')
+                leading_spaces = len(line) - len(line.lstrip())
+
+            for line_data in items:
+                depth_padding = '  ' + ' ' * (line_data.get('stack_size') - 2) * 6                      # this helps to align the code with the current depth (i.e. column alignment of code)
+                line_data['line'] = depth_padding + line_data.get('line')[leading_spaces:]
+                lines.append(line_data)
+        return list_sorted(lines, 'index')
+
+    def max_fields_length(self, items, *fields):
+        max_length = 0
+        for item in items:
+            method_sig = '.'.join(str(item.get(field, '')) for field in fields)
+            if len(method_sig) > max_length:
+                max_length = len(method_sig)
+        return max_length
+
+    def max_fields_value(self, items, *fields):
+        max_value = 0
+        for item in items:
+            values = [int(item.get(field, 0)) for field in fields if field in item and isinstance(item.get(field), int)]        # This will create a list of integers for the given fields in the line
+            line_max = max(values) if values else 0                                                                             # Now find the max value from these integers
+            if line_max > max_value:
+                max_value = line_max
+        return max_value
+
+    def print_lines(self, ):
+        lines = self.lines()
+        print("--------- CALL TRACER (Lines)----------")
+        print(f"Here are the {len(lines)} lines captured\n")
+
+        max_length__sig  = self.max_fields_length(lines, 'module', 'func_name') + 2
+        max_length__line = self.max_fields_length(lines, 'line'        ) + self.max_fields_value (lines, 'stack_size'  ) + 5                  # this +  5 helps with the alignment of the larger line (so that it doesn't overflow the table)
+        max_length__self = self.max_fields_length(lines, 'self_local'  )
+        print( '┌─────┬──────┬─' + '─' * max_length__line       +'──┬─' + '─' * max_length__sig                + '─┬─' + '─' * max_length__self      + '─┬───────┐   ')
+        print(f"│ #   │ Line │ {'Source code':<{max_length__line}}  │ {'Method Class and Name':<{max_length__sig}} │ {'Self object':<{max_length__self}} │ Depth │   ")
+        print( '├─────┼──────┼─' + '─' * max_length__line       +'──┼─' + '─'* max_length__sig                 + '─┼─'  + '─' * max_length__self     + '─┼───────┤   ')
+        for line_data in lines:
+            index       = line_data.get('index')
+            func_name   = line_data.get('func_name')
+            line_number = line_data.get('line_number')
+            module      = line_data.get('module')
+            event       = line_data.get('event')
+            line        = line_data.get('line')
+            self_local  = line_data.get('self_local') or ''
+            method_sig  = f"{module}.{func_name}"
+            stack_size  = line_data.get('stack_size') -1
+
+            text_depth         = f'{stack_size:5}'
+            text_depth_padding = ' ' * ((stack_size-1)  * 2)
+            text_index         = f'{text_grey(index):12}'
+            text_line_no       = f'{line_number:4}'
+            text_method_sig    = f'{method_sig:{max_length__sig}}'
+
+            if event == 'call':
+                text_line = f'{text_bold_green(line)}'
+            else:
+                text_line = f'{text_light_grey(line)}'
+
+            text_line_padding  =  ' ' * (max_length__line - ansi_text_visible_length(text_line) - len(text_depth_padding))
+            text_source_code   = f'{text_depth_padding}{text_line} {text_line_padding}'
+
+            print(f"│ {text_index} │ {text_line_no} │ {text_source_code} │ {text_method_sig} │ {self_local:<{max_length__self}} │ {text_depth} │")
+
+        print('└─────┴──────┴──' + '─' * max_length__line + '─┴─' + '─' * max_length__sig + '─┴──'  + '─' * max_length__self + '┴───────┘')
+
+

osbot_utils/helpers/trace/Trace_Call__Print_Traces.py

@@ -0,0 +1,170 @@
+from osbot_utils.base_classes.Kwargs_To_Self        import Kwargs_To_Self
+from osbot_utils.utils.Dev                          import pformat
+from osbot_utils.helpers.trace.Trace_Call__Config   import Trace_Call__Config
+
+# ANSI escape codes     #todo: refactor this color support to separate colors class
+dark_mode = False
+
+if dark_mode:
+    BOLD       = "\033[1m\033[48;2;30;31;34m\033[38;2;255;255;255m"        # dark mode
+    BLUE       = "\033[48;2;30;31;34m\033[94m"
+    GREEN      = "\033[48;2;30;31;34m\033[92m"
+    LIGHT_GREY = "\033[48;2;30;31;34m\033[38;2;130;130;130m"
+    OLIVE      = "\033[48;2;30;31;34m\033[38;2;118;138;118m"
+    GREY       = "\033[48;2;30;31;34m\033[90m"
+
+else:
+    BOLD  = "\033[1m"
+    BLUE  = "\033[94m"
+    GREEN = "\033[92m"
+    LIGHT_GREY = "\033[38;2;120;120;120m"
+    OLIVE = "\033[38;2;138;148;138m" #"\033[38;2;118;138;118m"
+    GREY  = "\033[90m"
+
+RED     = "\033[91m"
+WHITE   = "\033[97m"
+RESET   = "\033[0m"
+
+text_blue       = lambda text: f"{BLUE}{text}{RESET}"
+text_bold       = lambda text: f"{BOLD}{text}{RESET}"
+text_bold_red   = lambda text: f"{BOLD}{RED}{text}{RESET}"
+text_bold_green = lambda text: f"{BOLD}{GREEN}{text}{RESET}"
+text_bold_blue  = lambda text: f"{BOLD}{BLUE}{text}{RESET}"
+text_green      = lambda text: f"{GREEN}{text}{RESET}"
+text_grey       = lambda text: f"{GREY}{text}{RESET}"
+text_light_grey = lambda text: f"{BOLD}{LIGHT_GREY}{text}{RESET}"
+text_olive      = lambda text: f"{OLIVE}{text}{RESET}"
+text_red        = lambda text: f"{RED}{text}{RESET}"
+text_white      = lambda text: f"{WHITE}{text}{RESET}"
+text_none       = lambda text: f"{text}"
+text_color      = lambda text, color: f"{color}{text}{RESET}"
+
+
+
+class Trace_Call__Print_Traces(Kwargs_To_Self):
+
+    config: Trace_Call__Config
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def formatted_local_data(self, local_data, formatted_line, emoji = '🔖'):
+        if local_data:
+            formatted_data = {}
+            max_key_length = 0  # Variable to store the length of the longest key
+
+            # First pass to format data and find the length of the longest key
+            for key, value in local_data.items():
+                if key.startswith('_'):                                                 # don't show internal methods
+                    continue
+                # Convert objects to their type name
+                if isinstance(value, dict):
+                    value = pformat(value)                                                  # convert dicts to string (so that they are impacted by self.self.print_max_string_length)
+                if not isinstance(value, (int, float, bool, str, dict)):
+                    formatted_data[key] = (type(value).__name__, BLUE)
+                elif isinstance(value, str) and len(value) > self.config.print_max_string_length:
+                    formatted_data[key] = (value[:self.config.print_max_string_length] + "...", GREEN)    # Trim large strings
+                else:
+                    formatted_data[key] = (value, GREEN)
+
+                # Update the maximum key length
+                if len(key) > max_key_length:
+                    max_key_length = len(key)
+
+            def format_multiline(value, left_padding):
+                lines = str(value).split('\n')
+                indented_lines = [lines[0]] + [" " * (left_padding +1) + line for line in lines[1:]]
+                return '\n│'.join(indented_lines)
+
+            padding = " " * len(formatted_line)
+            for key, (value, color) in formatted_data.items():
+                # Calculate the number of spaces needed for alignment
+                spaces = " " * (max_key_length - len(key))
+                var_name = f"{padding}       {emoji} {text_light_grey(key)}{spaces} = "
+                value = format_multiline(value, len(var_name)- len(text_light_grey('')))  # this logic makes sure that the local's values are column aligned
+                print(f'│{var_name}{color}{value}{RESET}')
+
+    def print_lines(self, lines, formatted_line):
+        if lines:
+            padding = " " * len(formatted_line)
+            for line in lines:
+                index       = line.get('index')
+                #func_name   = line.get('func_name')
+                #module      = line.get('module')
+                event       = line.get('event')
+                line        = line.get('line')
+                if event == 'call':
+                    print(f"{padding}       {text_grey(index):12} {text_bold_green(line)}")
+                else:
+                    print(f"{padding}       {text_grey(index):12} {text_olive(line)}")
+
+    def print_traces(self, view_model):
+        print()
+        print("--------- CALL TRACER ----------")
+        print(f"Here are the {len(view_model)} traces captured\n")
+        for idx, item in enumerate(view_model):
+            emoji                = item.get('emoji'             , '' )
+            extra_data           = item.get('extra_data'        , {} )
+            locals               = item.get('locals'            , {} )
+            method_name          = item.get('method_name'       , '' )
+            method_parent        = item.get('method_parent'     , '' )
+            parent_info          = item.get('parent_info'       , '' )
+            prefix               = item.get('prefix'            , '' )
+            tree_branch          = item.get('tree_branch'       , '' )
+            source_code          = item.get('source_code'       , '' )
+            source_code_caller   = item.get('source_code_caller', '' )
+            #source_code_location = item.get('source_code_location') or ''
+
+            if self.config.show_method_class:
+                if self.config.show_parent_info:
+                    method_name = f'{text_olive(parent_info)}.{text_bold(method_name)}'
+                else:
+                    method_name = f'{text_olive(method_parent)}.{text_bold(method_name)}'
+
+
+            node_text          = source_code or method_name
+            formatted_line     = f"{prefix}{tree_branch}{emoji} {node_text}"
+            if self.config.print_duration:
+                duration         = item.get('duration',0) * 1000                    # todo: see if this can be optimised with the similar call below
+                duration_rounded = round(duration, 3)
+                padding_duration = self.config.print_padding_duration - len(formatted_line)
+                duration_text    = "{:>{},.3f}ms".format(duration_rounded, padding_duration)
+                formatted_line += f' {text_grey(duration_text)} '
+
+            if self.config.with_duration_bigger_than:
+                duration = item.get('duration', 0)
+                if duration < self.config.with_duration_bigger_than:
+                    continue
+
+            if False and self.config.trace_capture_source_code:       # todo: fix show caller funcionality
+
+                if self.config.show_caller:
+                    print(f"{prefix}{tree_branch}🔼️{text_bold(source_code_caller)}")
+                    print(f"{prefix}{tree_branch}➡️{emoji} {text_grey(node_text)}")
+                else:
+                    print(f"{prefix}{tree_branch}➡️{emoji} {text_bold(node_text)}")
+
+                # if self.config.show_source_code_path:
+                #
+                #     raise Exception("to implement path_source_code_root")
+                    # path_source_code_root = ...
+                    #
+                    # print(f" " * len(prefix), end="         ")
+                    # fixed_source_code_location = source_code_location.replace(path_source_code_root, '')
+                    # print(fixed_source_code_location)
+            else:
+                if idx == 0 or (self.config.show_parent_info is False or self.config.show_method_class is True):                            # Handle the first line and conditional parent info differently
+                    print(f"{text_bold(formatted_line)}")                                                  # Don't add "|" to the first line
+                else:
+                    padding = " " * (self.config.print_padding_parent_info - len(formatted_line))
+
+                    print(f"{text_bold(formatted_line)} {padding}         {parent_info}")
+
+            if self.config.trace_capture_lines:
+                self.print_lines(item.get('lines'), f'{prefix}{tree_branch}')
+
+            if self.config.print_locals:
+                self.formatted_local_data(locals, f'{prefix}{tree_branch}')
+
+            if self.config.capture_extra_data:
+                self.formatted_local_data(extra_data, f'{prefix}{tree_branch}', emoji='✨')

osbot_utils/helpers/trace/Trace_Call__Stack.py

@@ -0,0 +1,166 @@
+import linecache
+import time
+from copy                                               import deepcopy
+from osbot_utils.base_classes.Kwargs_To_Self            import Kwargs_To_Self
+from osbot_utils.helpers.trace.Trace_Call__Config       import Trace_Call__Config
+from osbot_utils.helpers.trace.Trace_Call__Stack_Node   import Trace_Call__Stack_Node
+
+
+class Trace_Call__Stack(Kwargs_To_Self):
+    call_index : int
+    stack_data : list
+    config     : Trace_Call__Config
+    root_node  : Trace_Call__Stack_Node
+    line_index : int
+
+    def __eq__(self, target):
+        if self is target:
+            return True
+        return self.stack_data == target
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def __iter__(self):
+        return iter(self.stack_data)
+
+    def __getitem__(self, index):
+        if -len(self.stack_data) <= index < len(self.stack_data):
+            return self.stack_data[index]
+
+    def __len__(self):
+        return self.size()
+
+    def add_frame(self, frame):
+        if frame and frame.__class__.__name__=='frame':
+            self.call_index += 1  # Increment the call index
+            code        = frame.f_code                                                      # Get code object from frame
+            func_name   = code.co_name                                                      # Get function name
+            module      = frame.f_globals.get("__name__", "")                               # Get module name
+
+            source_code = self.map_source_code(frame)
+            full_name   = self.map_full_name(frame, module, func_name)
+            new_node    = self.create_stack_node(frame, full_name, source_code, self.call_index)
+            if self.add_stack_node(new_node, frame):
+                return new_node
+
+
+    def add_node(self, title: str):
+        new_node = self.new_stack_node(title)
+        if self.config.capture_duration:
+            new_node.call_start = time.perf_counter()
+        if self.add_stack_node(new_node):
+            return new_node
+
+    def add_stack_node(self, stack_node : Trace_Call__Stack_Node, frame=None):
+        if type(stack_node) is Trace_Call__Stack_Node:
+            if self.stack_data:                                             # if there are items in the stack
+                self.top().children.append(stack_node)                      # add an xref to the new node to the children of the top node
+            else:
+                self.root_node = stack_node                                 # if not this is the first node and capture it as a root node
+            self.stack_data.append(stack_node)                              # append the new node to the stack
+            return True
+        return False
+
+    def bottom(self):
+        if self.stack_data:
+            return self.stack_data[0]
+
+    def create_stack_node(self, frame, full_name, source_code, call_index):
+        new_node = Trace_Call__Stack_Node(call_index=call_index, name=full_name)
+        if frame:
+            code      = frame.f_code
+            new_node.func_name = code.co_name                           # Get function name
+            new_node.module    = frame.f_globals.get("__name__", "")    # Get module name
+            if source_code:
+                 new_node.source_code           = source_code.get('source_code'          )
+                 new_node.source_code_caller    = source_code.get('source_code_caller'   )
+                 new_node.source_code_location  = source_code.get('source_code_location' )
+
+            if self.config.capture_frame:
+                new_node.frame = frame
+            if self.config.capture_locals:
+                if self.config.deep_copy_locals:
+                    try:
+                        new_node.locals = deepcopy(frame.f_locals)
+                    except Exception as error:
+                        new_node.locals = {'error': f'error in deepcopy: {error}'}
+                else:
+                    new_node.locals = frame.f_locals
+
+            if self.config.capture_duration:
+                new_node.call_start = time.perf_counter()
+        return new_node
+
+    def empty_stack(self):              # use to make sure the stack is empty (usally called at the end of a trace sessions)
+        for node in reversed(list(self.stack_data)):
+            self.pop(node)
+        return self
+
+    def map_source_code(self, frame):
+        if self.config.trace_capture_source_code:
+            filename             = frame.f_code.co_filename
+            lineno               = frame.f_lineno
+            source_code          = linecache.getline(filename, lineno).strip()
+
+            caller_filename      = frame.f_back.f_code.co_filename
+            caller_lineno        = frame.f_back.f_lineno
+            source_code_caller   = linecache.getline(caller_filename, caller_lineno).strip()
+            source_code_location = f'{filename}:{lineno}'
+        else:
+            source_code          = ''
+            source_code_caller   = ''
+            source_code_location = ''
+
+        return dict(source_code          = source_code          ,
+                    source_code_caller   = source_code_caller   ,
+                    source_code_location = source_code_location )
+
+    def map_full_name(self, frame, module, func_name):
+        if frame and module and func_name:
+            instance = frame.f_locals.get("self", None)                                                           # Get instance if available
+            try:
+                class_name = instance.__class__.__name__ if instance else ""
+            except Exception:                                                               # note: this will trigger this exception: ansi_text_visible_length("some text")
+                class_name = "<unavailable>"
+            if class_name:
+                full_name = f"{module}.{class_name}.{func_name}"
+            else:
+                full_name = f"{module}.{func_name}"
+            return full_name
+
+    def new_stack_node(self, name):
+        return Trace_Call__Stack_Node(call_index=self.call_index, name=name)
+
+    def nodes(self):
+        return self.stack_data
+
+    def remove_from_top(self, top_node, extra_data: dict):
+        if self.config.capture_duration:
+            top_node.call_end     = time.perf_counter()
+            top_node.call_duration = top_node.call_end - top_node.call_start
+        if type(extra_data) is dict:
+            top_node.extra_data.update(extra_data)
+        self.stack_data.pop()
+        return True
+
+    def pop(self, target, extra_data: dict = None):
+        top_node = self.top()
+        if target and top_node :
+            if type(target) is Trace_Call__Stack_Node:                  # handle the case when target is Trace_Call__Stack_Node
+                if target == top_node:                                  # if they match, pop the stack (since we are only capturing a subset of the stack)
+                    return self.remove_from_top(top_node, extra_data)
+            elif target is top_node.frame:                              # if not assume target is a frame
+                return self.remove_from_top(top_node, extra_data)       # if they match, pop the stack (since we are only capturing a subset of the stack)
+        return False
+
+    def push(self, frame):
+        return self.add_frame(frame)
+
+
+    def top(self):
+        if self.stack_data:
+            return self.stack_data[-1]
+
+    def size(self):
+        return self.stack_data.__len__()

osbot_utils/helpers/trace/Trace_Call__Stack_Node.py

@@ -0,0 +1,59 @@
+from osbot_utils.utils.Misc import random_id
+
+from osbot_utils.utils.Dev import pprint
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+EXTRA_DATA__RETURN_VALUE = '(return_value)'
+
+class Trace_Call__Stack_Node(Kwargs_To_Self):
+    call_duration       : float
+    call_end            : float
+    call_index          : int
+    call_start          : float
+    children            : list
+    extra_data          : dict
+    locals              : dict
+    frame               : None
+    func_name           : str
+    lines               : list
+    key                 : str
+    module              : str
+    name                : str
+    source_code         : str
+    source_code_caller  : str
+    source_code_location: str
+
+    # def __init__(self, **kwargs):
+    #     super().__init__(**kwargs)
+    #     #self.key = random_id()
+
+    def __eq__(self, other):
+        if not isinstance(other, Trace_Call__Stack_Node):
+            return False
+        if self is other:
+            return True
+        return self.data() == other.data()
+
+    def __repr__(self):
+        return f'Trace_Call__Stack_Node (call_index={self.call_index})'
+
+    def all_children(self):
+        all_children = self.children.copy()                     # Initialize the list with the current node's children
+        for child in self.children:                             # Recursively add the children of each child node
+            all_children.extend(child.all_children())
+        return all_children
+
+    def info(self):
+        return f'Stack_Node: call_index:{self.call_index} | name: {self.name} | children: {len(self.children)} | source_code: {self.source_code is not None}'
+
+    def data(self):
+        return self.__locals__()
+
+    def print(self):
+        pprint(self.data())
+
+    def print_info(self):
+        pprint(self.info())
+
+

osbot_utils/helpers/trace/Trace_Call__Stats.py

@@ -0,0 +1,71 @@
+from collections import defaultdict, Counter
+from copy import copy
+
+from osbot_utils.utils.Dev import pprint
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+
+class Trace_Call__Stats(Kwargs_To_Self):
+
+    calls          : int
+    calls_skipped  : int
+    exceptions     : int
+    lines          : int
+    returns        : int
+    unknowns       : int            # to use for extra events that are not being captured
+    raw_call_stats : list
+
+    def __repr__(self):
+        return str(self.stats())
+
+    def __eq__(self, target):
+        if self is target:
+            return True
+        return self.stats() == target
+
+    def log_frame(self, frame):
+        code        = frame.f_code
+        func_name   = code.co_name
+        module      = frame.f_globals.get("__name__", "")
+        self.raw_call_stats.append((module, func_name))
+        return self
+
+    def frames_stats__build_tree(self, d, path, function_name):
+        parts = path.split('.')
+        current_level = d
+        for part in parts[:-1]:  # Go up to the second-to-last element
+            if part not in current_level:
+                current_level[part] = {}
+            current_level = current_level[part]
+        if parts[-1] not in current_level:
+            current_level[parts[-1]] = Counter()
+        current_level[parts[-1]][function_name] += 1
+
+    def frames_stats(self):
+        processed_frame_stats = self.frames_stats__process_raw_data()
+        return self.to_standard_dict(processed_frame_stats)
+
+    def frames_stats__process_raw_data(self):
+        tree = defaultdict(dict)
+        for module, function_name in self.raw_call_stats:
+            self.frames_stats__build_tree(tree, module, function_name)
+        return tree
+
+
+    def to_standard_dict(self, d):
+        if isinstance(d, defaultdict):
+            d = {k: self.to_standard_dict(v) for k, v in d.items()}
+        if isinstance(d, Counter):
+            d = dict(d)
+        if isinstance(d, dict):
+            return {k: self.to_standard_dict(v) for k, v in d.items()}
+        return d
+
+    def stats(self):
+        stats = copy(self.__locals__())
+        del stats['raw_call_stats']
+        return stats
+
+    def print(self):
+        pprint(self.stats())

osbot_utils/helpers/trace/Trace_Call__View_Model.py

@@ -0,0 +1,75 @@
+from osbot_utils.utils.Dev import pprint
+
+
+class Trace_Call__View_Model:
+
+    def __init__(self):
+        self.view_model = []
+
+    def create(self, stack):
+        root_node = stack.root_node
+        if root_node:
+            target = [root_node]
+            self.view_model = self.create_view_model(target)
+            self.fix_view_mode()                                        # Fix the view mode for the last node
+        return self.view_model
+
+    # todo: rename view_model so that it is not confused with self.view_model
+    def create_view_model(self, json_list, level=0, prefix="", view_model=None):
+        if view_model is None:
+            view_model = []                                                                 # Initialize view model if None
+        for idx, node in enumerate(json_list):                                              # Iterate over each node in the JSON list to populate the view model
+            components           = node.name.split('.')
+            duration             = node.call_duration
+            extra_data           = node.extra_data
+            frame_locals         = node.locals
+            lines                = node.lines
+            source_code          = node.source_code
+            source_code_caller   = node.source_code_caller
+            source_code_location = node.source_code_location
+            method_name          = components[-1]
+            if len(components) > 1:
+                method_parent  = f"{components[-2]}"
+            else:
+                method_parent  = ""
+            if method_name == "__init__":                                                   # Adjust the method_name based on special method names like __init__ and __call__
+                method_name = f"{method_parent}.{method_name}"
+            elif method_name == "__call__":
+                method_name = f"{method_parent}.{method_name}"
+            elif method_name == "<module>":
+                method_name = f"{method_parent}.{method_name}"
+
+            pruned_parents = [comp for comp in components]
+            parent_info = '.'.join(pruned_parents[:-1])
+
+            if level == 0:                                                                  # Handle tree representation at level 0
+                emoji = "📦 "
+                tree_branch = ""
+            else:
+                is_last_sibling = (idx == len(json_list) - 1)                               # Check if the node is the last sibling
+                tree_branch = "└── " if is_last_sibling else "├── "
+                emoji = "🧩️" if not node.children else "🔗️"
+
+            view_model.append({ 'duration'            : duration             ,
+                                'emoji'               : emoji                ,
+                                'extra_data'          : extra_data           ,
+                                'method_name'         : method_name          ,
+                                'method_parent'       : method_parent        ,
+                                'lines'               : lines                ,
+                                'locals'              : frame_locals         ,  # todo finish refactoring use of locals to frame_locals
+                                'parent_info'         : parent_info          ,
+                                'prefix'              : prefix               ,
+                                'source_code'         : source_code          ,
+                                'source_code_caller'  : source_code_caller   ,
+                                'source_code_location': source_code_location ,
+                                'tree_branch'         : tree_branch          ,})
+            next_prefix = prefix + ("    " if tree_branch == "└── " else "│   ")            # Calculate the prefix for the next level
+            self.create_view_model(node.children, level + 1, prefix=next_prefix, view_model=view_model)
+
+        return view_model
+
+    def fix_view_mode(self):
+        if len(self.view_model) > 0:                                                        # these changes will provide a nice end of tree, for example replacing "│       ├──" with "└────────── "
+            last_node = self.view_model[-1]                                                 # Get the last node in the view model
+            last_node['prefix'] = last_node['prefix'].replace(' ', '─').replace('│', '└')   # Update the prefix for the last node
+            last_node['tree_branch'] = '─── '

osbot_utils/helpers/trace/Trace_Files.py

@@ -0,0 +1,33 @@
+from osbot_utils.helpers.trace.Trace_Call import Trace_Call
+
+
+class Trace_Files(Trace_Call):
+
+    files: list
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    # def trace_calls(self, frame, event, arg):
+    #     if event == 'call':
+    #         self.files.append(frame.f_code.co_filename)
+    #
+    #     # if event != 'call':
+    #     #     return
+    #     #
+    #     #
+    #     #     # Get the function object being called
+    #     # func = frame.f_globals.get(frame.f_code.co_name, None)
+    #     #
+    #     # # Retrieve the source code if the function object is available
+    #     # if func:
+    #     #     try:
+    #     #         source_code = inspect.getsource(func)
+    #     #         print(f"Source code of {func.__name__}:\n{source_code}\n")
+    #     #     except TypeError:
+    #     #         pass  # Handle cases where source code can't be retrieved
+    #     #
+    #
+    #     return super().trace_calls(frame, event, arg)
+
+