osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/helpers/sqlite/tables/Sqlite__Table__Config.py

@@ -0,0 +1,63 @@
+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.sqlite.Sqlite__Table   import Sqlite__Table
+from osbot_utils.utils.Objects                  import pickle_save_to_bytes, pickle_load_from_bytes
+
+SQLITE__TABLE_NAME__CONFIG = 'config'
+
+class Schema__Table__Config(Kwargs_To_Self):
+    key  : str
+    value: bytes
+
+class Sqlite__Table__Config(Sqlite__Table):
+    def __init__(self, **kwargs):
+        self.table_name = SQLITE__TABLE_NAME__CONFIG
+        self.row_schema  = Schema__Table__Config
+        super().__init__(**kwargs)
+
+    def config_data(self):
+        config_data = {}
+        for row in self.rows():
+            key, value = self.deserialize_row(row)
+            config_data[key] = value
+        return config_data
+
+    @cache_on_self
+    def data(self):
+        return self.config_data()
+
+    def deserialize_row(self, row):
+        if row:
+            key           = row.get('key')
+            pickled_value = row.get('value')
+            value         = pickle_load_from_bytes(pickled_value)
+            return key, value
+        return None, None
+
+    def set_config_data(self, config_data: dict):
+        self.clear()
+        for key,value in config_data.items():
+            self.set_value(key=key, value=value)
+        self.commit()
+
+    def set_value(self, key, value):
+        if self.not_contains(key=key):
+            pickled_value = pickle_save_to_bytes(value)
+            return self.add_row_and_commit(key=key, value=pickled_value)
+        return self.update_value(key,value)
+
+    def update_value(self, key, value):
+        pickled_value = pickle_save_to_bytes(value)
+        self.row_update(dict(key=key, value=pickled_value), dict(key=key))
+
+    def setup(self):
+        if self.exists() is False:
+            self.create()
+            self.index_create('key')
+        return self
+
+    def value(self, key):
+        row = self.where_one(key=key)
+        key, value = self.deserialize_row(row)
+        return value
+

osbot_utils/helpers/sqlite/tables/Sqlite__Table__Edges.py

@@ -0,0 +1,46 @@
+from osbot_utils.decorators.lists.index_by import index_by
+from osbot_utils.helpers.sqlite.Sqlite__Table   import Sqlite__Table
+from osbot_utils.base_classes.Kwargs_To_Self    import Kwargs_To_Self
+from osbot_utils.utils.Misc import timestamp_utc_now
+
+SQLITE__TABLE_NAME__EDGES = 'edges'
+
+class Schema__Table__Edges(Kwargs_To_Self):
+    source_key : str
+    target_key : str
+    value      : bytes
+    properties : bytes
+    timestamp  : int
+
+class Sqlite__Table__Edges(Sqlite__Table):
+    auto_pickle_blob    : bool = True
+    set_timestamp       : bool = True
+
+    def __init__(self, **kwargs):
+        self.table_name = SQLITE__TABLE_NAME__EDGES
+        self.row_schema  = Schema__Table__Edges
+        super().__init__(**kwargs)
+
+
+    def add_edge(self, source_key, target_key, value=None, properties=None):
+        row_data = self.create_node_data(source_key, target_key,value, properties)
+        return self.add_row_and_commit(**row_data)
+
+    def create_node_data(self, source_key, target_key, value=None, properties=None):
+        node_data =  {'source_key' : source_key              ,
+                      'target_key' : target_key              ,
+                      'value'      : value                   ,
+                      'properties' : properties              }
+        if self.set_timestamp:
+            node_data['timestamp'] = timestamp_utc_now()
+        return node_data
+
+    def edges(self):
+        return self.rows()
+
+    def setup(self):
+        if self.exists() is False:
+            self.create()
+            self.index_create('source_key')
+            self.index_create('target_key')
+        return self

osbot_utils/helpers/sqlite/tables/Sqlite__Table__Files.py

@@ -0,0 +1,45 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.sqlite.Sqlite__Table import Sqlite__Table
+from osbot_utils.utils.Misc import timestamp_utc_now
+
+SQLITE__TABLE_NAME__FILES = 'files'
+
+class Schema__Table__Files(Kwargs_To_Self):
+    path     : str
+    contents : bytes
+    metadata : bytes
+    timestamp: int
+
+
+class Sqlite__Table__Files(Sqlite__Table):
+    auto_pickle_blob    : bool = True
+    set_timestamp       : bool = True
+
+    def __init__(self, **kwargs):
+        self.table_name = SQLITE__TABLE_NAME__FILES
+        self.row_schema  = Schema__Table__Files
+        super().__init__(**kwargs)
+
+    def add_file(self, path, contents=None, metadata= None):
+        if self.contains(path=path):                                     # don't allow multiple entries for the same file path (until we add versioning support)
+            return None
+        row_data = self.create_node_data(path, contents, metadata)
+        return self.add_row_and_commit(**row_data)
+
+    def create_node_data(self, path, contents=None, metadata= None):
+        node_data = {'path'    : path     ,
+                     'contents': contents ,
+                     'metadata': metadata }
+        if self.set_timestamp:
+            node_data['timestamp'] = timestamp_utc_now()
+        return node_data
+
+
+    def files(self):
+        return self.rows()
+
+    def setup(self):
+        if self.exists() is False:
+            self.create()
+            self.index_create('path')
+        return self

osbot_utils/helpers/sqlite/tables/Sqlite__Table__Nodes.py

@@ -0,0 +1,52 @@
+from osbot_utils.decorators.lists.index_by import index_by
+from osbot_utils.helpers.sqlite.Sqlite__Table import Sqlite__Table
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.utils.Lists import unique
+from osbot_utils.utils.Misc import timestamp_utc_now
+
+SQLITE__TABLE_NAME__NODES = 'nodes'
+
+class Schema__Table__Nodes(Kwargs_To_Self):
+    key       : str
+    value     : bytes
+    properties: bytes
+    timestamp : int
+
+class Sqlite__Table__Nodes(Sqlite__Table):
+    allow_duplicate_keys: bool = False
+    auto_pickle_blob    : bool = True
+    set_timestamp       : bool = True
+
+    def __init__(self, **kwargs):
+        self.table_name = SQLITE__TABLE_NAME__NODES
+        self.row_schema  = Schema__Table__Nodes
+        super().__init__(**kwargs)
+
+    def add_node(self, key, value=None, properties=None):
+        if self.allow_duplicate_keys is False:
+            if self.contains(key=key):
+                return None
+        row_data = self.create_node_data(key,value, properties)
+        return self.add_row_and_commit(**row_data)
+
+    def create_node_data(self, key, value=None, properties=None):
+        node_data =  {'key'        : key                     ,
+                      'value'      : value                   ,
+                      'properties' : properties              }
+        if self.set_timestamp:
+            node_data['timestamp'] = timestamp_utc_now()
+        return node_data
+
+    @index_by
+    def nodes(self):
+        return self.rows()
+
+    def keys(self):
+        return unique(self.select_field_values('key'))
+
+    def setup(self):
+        if self.exists() is False:
+            self.create()
+            self.index_create('key')
+        return self

osbot_utils/helpers/trace/Trace_Call.py

@@ -0,0 +1,120 @@
+import linecache
+import sys
+from functools import wraps
+
+from osbot_utils.base_classes.Kwargs_To_Self                import Kwargs_To_Self
+from osbot_utils.helpers.trace.Trace_Call__Config           import Trace_Call__Config, PRINT_MAX_STRING_LENGTH
+from osbot_utils.helpers.trace.Trace_Call__Handler          import Trace_Call__Handler
+from osbot_utils.helpers.trace.Trace_Call__Print_Lines      import Trace_Call__Print_Lines
+from osbot_utils.helpers.trace.Trace_Call__Print_Traces     import Trace_Call__Print_Traces
+from osbot_utils.helpers.trace.Trace_Call__View_Model       import Trace_Call__View_Model
+
+
+def trace_calls(title         = None , print_traces = True , show_locals    = False, source_code          = False ,
+                ignore        = None , include      = None , show_path      = False, duration_bigger_than = 0     ,
+                max_string    = None , show_types   = False, show_duration  = False ,# show_caller    = False     ,         # todo: add back when show_caller is working again
+                show_class    = False, contains     = None , show_internals = False, enabled              = True  ,
+                extra_data    = False, show_lines   = False, print_lines    = False, show_types_padding   = None  , duration_padding=None):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            config_kwargs = dict(title=title, print_traces_on_exit=print_traces, print_locals=show_locals,
+                                 capture_locals = show_locals,
+                                 trace_capture_source_code=source_code, ignore_start_with=ignore,
+                                 trace_capture_start_with=include, print_max_string_length=max_string,
+                                 show_parent_info=show_types, show_method_class=show_class,
+                                 show_source_code_path=show_path,
+                                 capture_duration=show_duration, print_duration= show_duration,
+                                 with_duration_bigger_than=duration_bigger_than,
+                                 trace_capture_contains=contains, trace_show_internals=show_internals,
+                                 capture_extra_data=extra_data,
+                                 print_padding_parent_info= show_types_padding, print_padding_duration=duration_padding,
+                                 print_lines_on_exit=print_lines, trace_enabled=enabled,
+                                 trace_capture_lines=show_lines or print_lines)
+
+            config = (Trace_Call__Config().update_from_kwargs (**config_kwargs))
+
+            with Trace_Call(config=config):
+                result = func(*args, **kwargs)
+                return result
+        return wrapper
+    return decorator
+
+class Trace_Call(Kwargs_To_Self):
+
+    config             : Trace_Call__Config
+    started            : bool
+    prev_trace_function: None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.trace_call_handler                                 = Trace_Call__Handler     (config=self.config)
+        self.trace_call_print_traces                            = Trace_Call__Print_Traces(config=self.config)
+        self.trace_call_view_model                              = Trace_Call__View_Model  ()
+        self.config.print_traces_on_exit                        = self.config.print_traces_on_exit
+        #self.config.trace_capture_start_with                    = self.config.capture_start_with       or []          # todo add a better way to set these to [] when then value is null
+        self.config.trace_ignore_start_with                     = self.config.ignore_start_with        or []          #      probablty better done inside Kwargs_To_Self since it doesn't make sense for lists or dicts to have None value
+        self.config.trace_capture_contains                      = self.config.trace_capture_contains   or []          #      and None will be quite common since we can use [] on method's params
+        self.config.print_max_string_length                     = self.config.print_max_string_length  or PRINT_MAX_STRING_LENGTH
+        self.stack                                              = self.trace_call_handler.stack
+        #self.prev_trace_function                                = None                                                # Stores the previous trace function
+
+
+    def __enter__(self):
+        return self.on_enter()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self.on_exit()
+
+    def on_enter(self):
+        if self.config.trace_enabled:
+            self.start()  # Start the tracing
+        return self
+
+    def on_exit(self):
+        if self.config.trace_enabled:
+            self.stop()  # Stop the tracing
+            if self.config.print_traces_on_exit:
+                self.print()
+            if self.config.print_lines_on_exit:
+                self.print_lines()
+
+    def capture_all(self):
+        self.config.trace_capture_all = True
+        return self
+
+    def view_data(self):
+        return self.trace_call_view_model.create(self.stack)
+
+    def print(self):
+        view_model = self.view_data()
+        self.trace_call_print_traces.print_traces(view_model)
+        #self.print_lines()
+        return view_model
+
+    def print_lines(self):
+        print()
+        view_model = self.view_data()
+        print_lines = Trace_Call__Print_Lines(config=self.config, view_model=view_model)
+        print_lines.print_lines()
+
+    def start(self):
+        self.trace_call_handler.stack.add_node(title=self.trace_call_handler.config.title)
+        self.prev_trace_function = sys.gettrace()
+        self.started             = True                                                         # set this here so that it does show in the trace
+        sys.settrace(self.trace_call_handler.trace_calls)                                       # Set the new trace function
+
+
+    def stop(self):
+        if self.started:
+            sys.settrace(self.prev_trace_function)                                              # Restore the previous trace function
+            self.stack.empty_stack()
+            self.started = False
+
+    def stats(self):
+        return self.trace_call_handler.stats
+
+    def stats_data(self):
+        return self.trace_call_handler.stats.raw_call_stats
+

osbot_utils/helpers/trace/Trace_Call__Config.py

@@ -0,0 +1,94 @@
+from osbot_utils.utils.Dev import pprint
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+PRINT_MAX_STRING_LENGTH    = 100
+PRINT_PADDING__DURATION    = 100
+PRINT_PADDING_PARENT_INFO  = 60
+
+class Trace_Call__Config(Kwargs_To_Self):
+    title                      : str
+    capture_locals             : bool = False
+    capture_duration           : bool
+    capture_extra_data         : bool
+    capture_frame              : bool = True
+    capture_frame_stats        : bool
+    deep_copy_locals           : bool
+    trace_capture_lines        : bool
+    ignore_start_with          : list
+    print_padding_duration     : int = PRINT_PADDING__DURATION
+    print_padding_parent_info  : int = PRINT_PADDING_PARENT_INFO
+    print_duration             : bool
+    print_max_string_length    : int  = PRINT_MAX_STRING_LENGTH
+    print_locals               : bool
+    print_traces_on_exit       : bool
+    print_lines_on_exit        : bool
+    show_parent_info           : bool = False
+    show_caller                : bool
+    show_method_class          : bool = True
+    show_source_code_path      : bool
+    trace_capture_all          : bool
+    trace_capture_source_code  : bool
+    trace_capture_start_with   : list
+    trace_capture_contains     : list
+    trace_enabled              : bool = True
+    trace_ignore_start_with    : list
+    trace_show_internals       : bool
+    trace_up_to_depth          : int
+    with_duration_bigger_than  : float
+
+    def __init__(self, **wargs):
+        super().__init__(**wargs)
+        #self.locked()
+
+    def all(self, up_to_depth=0, print_traces=True):
+        self.trace_capture_all    = True
+        self.print_traces_on_exit = print_traces
+        self.trace_up_to_depth    = up_to_depth
+        return self
+
+    def capture(self, starts_with=None, contains=None, ignore=None):
+        if starts_with:
+            if type(starts_with) is str:
+                starts_with = [starts_with]
+            self.trace_capture_start_with = starts_with
+        if contains:
+            if type(contains) is str:
+                contains = [contains]
+            self.trace_capture_contains = contains
+        if ignore:
+            if type(ignore) is str:
+                ignore = [ignore]
+            self.ignore_start_with = ignore
+        self.print_traces_on_exit = True
+        return self
+
+    def duration(self, bigger_than=0, padding=PRINT_PADDING__DURATION):
+        self.capture_duration          = True
+        self.print_duration            = True
+        self.print_padding_duration          = padding
+        self.with_duration_bigger_than = bigger_than
+        return self
+
+    def locals(self):
+        self.capture_locals = True
+        self.print_locals   = True
+        return self
+
+    def lines(self, print_traces=True, print_lines=True):
+        self.trace_capture_lines  = True
+        self.print_traces_on_exit = print_traces
+        self.print_lines_on_exit  = print_lines
+        return self
+
+    def print_config(self):
+        pprint(self.__locals__())
+        return self
+
+    def print_on_exit(self, value=True):
+        self.print_traces_on_exit = value
+        return self
+
+    def up_to_depth(self, depth):
+        self.trace_up_to_depth = depth
+        return self

osbot_utils/helpers/trace/Trace_Call__Graph.py

@@ -0,0 +1,26 @@
+from osbot_utils.graphs.mermaid.Mermaid__Graph import Mermaid__Graph
+from osbot_utils.utils.Dev import pprint
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.trace.Trace_Call import Trace_Call
+
+# todo: reimplement this class when Mermaid__Graph has been updated to new version
+class Trace_Call__Graph(Trace_Call):
+
+    def create(self):
+        mermaid_graph = Mermaid__Graph()
+        self.trace_call_handler.stack.root_node.func_name = 'trace_root'
+        for trace in self.trace_call_handler.traces():
+            node_key   = trace.func_name
+            class_name = trace.module.split('.')[-1]
+            node_label = f'`**{trace.func_name}**\n*{class_name}*`'
+            mermaid_graph.add_node(key=node_key, label=node_label)
+
+        nodes__by_key = mermaid_graph.data().nodes__by_key()
+
+        for trace in self.trace_call_handler.traces():
+            from_node = nodes__by_key[trace.func_name]
+            for child in trace.children:
+                to_node = nodes__by_key[child.func_name]
+                mermaid_graph.add_edge(from_node=from_node, to_node=to_node)
+        return mermaid_graph

osbot_utils/helpers/trace/Trace_Call__Handler.py

@@ -0,0 +1,215 @@
+import inspect
+import linecache
+from osbot_utils.utils.Objects                          import class_full_name
+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        import Trace_Call__Stack
+from osbot_utils.helpers.trace.Trace_Call__Stack_Node   import Trace_Call__Stack_Node, EXTRA_DATA__RETURN_VALUE
+from osbot_utils.helpers.trace.Trace_Call__Stats        import Trace_Call__Stats
+
+DEFAULT_ROOT_NODE_NODE_TITLE = 'Trace Session'
+GLOBAL_FUNCTIONS_TO_IGNORE   = ['value_type_matches_obj_annotation_for_attr'       ,            # these are type safety functions which introduce quite a lot of noise in the traces (and unless one is debugging type safety, they will not be needed)
+                                'value_type_matches_obj_annotation_for_union_attr' ,            # todo: map out and document why exactly these methods are ignore (and what is the side effect)
+                                'are_types_compatible_for_assigment'               ,
+                                'obj_attribute_annotation'                         ,
+                                'get_origin'                                       ,
+                                'getmro'                                           ,
+                                'default_value'                                    ,
+                                'raise_exception_on_obj_type_annotation_mismatch'  ,
+                                '__cls_kwargs__'        ,
+                                '__default__value__'    ,
+                                '__setattr__'           ,
+                                '<module>']
+GLOBAL_MODULES_TO_IGNORE     = ['osbot_utils.helpers.trace.Trace_Call'             ,            # todo: map out and document why exactly these modules are ignore (and what is the side effect)
+                                'osbot_utils.helpers.CPrint'                       ,            #       also see if this should be done here or at the print/view stage
+                                'osbot_utils.helpers.Print_Table'      ,
+                                'osbot_utils.decorators.methods.cache_on_self'     ,
+                                'codecs']
+
+class Trace_Call__Handler(Kwargs_To_Self):
+    config : Trace_Call__Config
+    stack  : Trace_Call__Stack
+    stats  : Trace_Call__Stats
+
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.config.title  = self.config.title or DEFAULT_ROOT_NODE_NODE_TITLE                           # Title for the trace root node
+        self.stack.config  = self.config
+
+    def add_default_root_node(self):
+        return self.stack.add_node(title=self.config.title)
+
+    def add_line(self, frame):
+        if self.config.trace_capture_lines:
+            if frame:
+                target_node = self.stack.top()  # lines captured are added to the current top of the stack
+                #obj_info(target_node)
+                if self.stack.top():
+                    target_node__func_name = target_node.func_name
+                    target_node__module    = target_node.module
+                    frame_func_name        = frame.f_code.co_name
+                    frame_module           = frame.f_globals.get("__name__", "")
+                    if frame_func_name == target_node__func_name:
+                        if frame_module == target_node__module:
+                            return self.add_line_to_node(frame, target_node, 'line')
+        return False
+
+    def add_line_to_node(self, frame, target_node, event):
+        def source_code_for_frame(function_name):
+            try:
+                return inspect.getsource(frame.f_code)
+            except Exception as error:
+                return ''
+                #print(self.stack.line_index, f'def {function_name}() : error]  {error}' )
+                #return f'def {function_name}() : [error]  {error}'
+
+        if frame and target_node:
+            func_name  = frame.f_code.co_name
+            module     = frame.f_globals.get("__name__", "")
+            self_local = class_full_name(frame.f_locals.get('self'))
+            stack_size = len(self.stack)
+            line =''
+            line_number=0
+            if event == 'call':                                                     # if this is a call we need to do the code below to get the actual method signature (and decorators)
+                function_name       = frame.f_code.co_name
+                filename            = frame.f_code.co_filename                             # Get the filename where the function is defined
+                start_line_number   = frame.f_code.co_firstlineno                 # Get the starting line number
+                source_lines        = source_code_for_frame(function_name).split('\n')
+                if source_lines:
+                    def_line_number     = start_line_number                         # Try to find the actual 'def' line
+                    for line in source_lines:
+                        if line.strip().startswith('def ' + function_name):
+                            break
+                        def_line_number += 1
+                    else:
+                        def_line_number = start_line_number                      # If the 'def' line wasn't found, default to the starting line
+                    line_number = def_line_number
+                    line = linecache.getline(filename, line_number).rstrip()            # todo: refactor this to not capture this info here, and to use the Ast_* utils to get a better source code mapping
+            else:
+                filename    = frame.f_code.co_filename  # get the filename
+                line_number = frame.f_lineno                          # get the current line number
+                line        = linecache.getline(filename, line_number)         # get the line
+
+            if line:
+                self.stack.line_index += 1
+                line_data = dict(event=event, index = self.stack.line_index, func_name=func_name,
+                                 line = line.rstrip(), line_number=line_number,
+                                 module=module,  self_local=self_local,
+                                 stack_size=stack_size)
+                target_node.lines.append(line_data)
+                return True
+            # else:
+            #     print(f'no line for : {self.stack.line_index}, {module}.{func_name}')
+        return False
+
+    def add_frame(self, frame):
+        return self.handle_event__call(frame)
+
+    def add_trace_ignore(self, value):
+        self.config.trace_ignore_start_with.append(value)
+        return
+
+    def handle_event__call(self, frame):
+        if frame:
+            if self.config.capture_frame_stats:
+                self.stats.log_frame(frame)
+            if self.should_capture(frame):
+                new_node = self.stack.add_frame(frame)
+                if self.config.trace_capture_lines:
+                    self.add_line_to_node(frame, new_node,'call')
+                return  new_node
+            else:
+                self.stats.calls_skipped += 1
+
+    def handle_event__line(self, frame):
+        return self.add_line(frame)
+
+
+    def handle_event__return(self, frame, return_value=None):
+        if return_value and self.config.capture_extra_data:
+            extra_data = { EXTRA_DATA__RETURN_VALUE : return_value}
+        else:
+            extra_data = {}
+        return self.stack.pop(target=frame, extra_data = extra_data)
+
+    def should_capture(self, frame):                                                    # todo: see if we can optimise these 3 lines (starting with frame.f_code) which are repeated in a number of places here
+        if self.config.trace_up_to_depth:
+            if len(self.stack) > self.config.trace_up_to_depth:
+                return False
+
+        capture = False
+        if frame:
+            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
+
+            if module in GLOBAL_MODULES_TO_IGNORE:                                         # check if we should skip this module
+                return False
+
+            if func_name in GLOBAL_FUNCTIONS_TO_IGNORE:                                     # check if we should skip this function
+                return False
+
+            if module and func_name:
+                if self.config.trace_capture_all:
+                    capture = True
+                else:
+                    for item in self.config.trace_capture_start_with:                                  # capture if the module starts with
+                        if item:                                                                       # prevent empty queries  (which will always be true)
+                            if module.startswith(item) or item =='*':
+                                capture = True
+                                break
+                    for item in self.config.trace_capture_contains:                                    # capture if module of func_name contains
+                        if item:                                                                       # prevent empty queries  (which will always be true)
+                            if item in module or item in func_name:
+                                capture = True
+                                break
+                if self.config.trace_show_internals is False and func_name.startswith('_'):                   # Skip private functions
+                    capture = False
+
+                for item in self.config.trace_ignore_start_with:                                       # Check if the module should be ignored
+                    if module.startswith(item):
+                        capture = False
+                        break
+        return capture
+
+    def stack_json__parse_node(self, stack_node: Trace_Call__Stack_Node):
+        node         = stack_node.data()
+        new_children = []
+        for child in node.get('children'):
+            new_children.append(self.stack_json__parse_node(child))
+        node['children'] = new_children
+        return node
+
+    def stack_top(self):
+        if self.stack:
+            return self.stack[-1]
+
+    def trace_calls(self, frame, event, arg):
+        if event == 'call':
+            self.stats.calls +=1
+            self.handle_event__call(frame)                  # todo: handle bug with locals which need to be serialised, since it's value will change
+        elif event == 'return':
+            self.stats.returns += 1
+            self.handle_event__return(frame, arg)
+        elif event == 'exception':
+            self.stats.exceptions +=1                  # for now don't handle exception events
+        elif event == 'line':
+            self.handle_event__line(frame)
+            self.stats.lines +=1
+        else:
+            self.stats.unknowns += 1
+
+        return self.trace_calls
+
+
+
+    def traces(self):
+        def map_traces(node, all_traces):
+            if node:
+                all_traces.append(node)
+                for child in node.children:
+                    map_traces(child, all_traces)
+        result = []
+        map_traces(self.stack.root_node, result)
+        return result