Upload 8 files

mew_log/__init__.py

@@ -0,0 +1,22 @@
+from .ansi_utils import AnsiCodeHelper, ansi_color_str, ansi_format_str, ansi_link_str, ansi_rainbow_str, print_to_ansi_alt_screen_buffer
+from .attr_utils import get_caller_info, get_class_attributes, get_class_name, get_method_args, get_method_info, get_partial_argspec, get_prev_caller_info, get_prev_frame, get_prev_frame_from_frame, get_signature, get_source_info, get_thread_info, get_type_name, get_var_value, get_variable_info, is_bytes_like_type, is_complex_type, is_of_type, list_class_attributes
+from .extended_symbols import ExtendedSymbols, draw_arrow, draw_box, format_arrow
+from .log_utils import LogSpinner, allow_curly_braces, ensure_directory_exists, ensure_file_exists, format_arg, format_args, format_duration, format_kwarg, format_path, format_traceback, get_timestamp, init_log, log_error, log_file, log_function, log_info, log_text_input, log_warning, make_formatted_msg, parse_duration, run_unit_test, stringf, trace_error
+from .mem_utils import bytes_to_kb, bytes_to_mb, format_mem_size_value, format_size_bytes, get_mem_size, get_mem_size_breakdown, save_obj_graph_img, take_mem_growth_snapshot
+from .profile_utils import ProfileSection, allow_curly_braces, create_or_get_profile, format_profile_registry, get_profile_registry, get_profile_reports, log_profile_registry, make_time_str, profile_function, profile_start, profile_stop
+from .table_utils import format_data_as_table, format_dict_as_table, format_list_as_table, format_obj_as_table, format_property, format_square_layout, format_table, print_as_square, print_square_layout, print_table, transpose_dict
+
+__all__ = [
+    'AnsiCodeHelper', 'ansi_color_str', 'ansi_format_str', 'ansi_link_str', 'ansi_rainbow_str', 'print_to_ansi_alt_screen_buffer',
+    'get_caller_info', 'get_class_attributes', 'get_class_name', 'get_method_args', 'get_method_info', 'get_partial_argspec', 'get_prev_caller_info', 'get_prev_frame', 'get_prev_frame_from_frame', 'get_signature',
+    'get_source_info', 'get_thread_info', 'get_type_name', 'get_var_value', 'get_variable_info', 'is_bytes_like_type', 'is_complex_type', 'is_of_type', 'list_class_attributes',
+    'ExtendedSymbols', 'draw_arrow', 'draw_box', 'format_arrow',
+    'LogSpinner', 'allow_curly_braces', 'ensure_directory_exists', 'ensure_file_exists', 'format_arg', 'format_args', 'format_duration', 'format_kwarg', 'format_path', 'format_traceback',
+    'get_timestamp', 'init_log', 'log_error', 'log_file', 'log_function', 'log_info', 'log_text_input', 'log_warning', 'make_formatted_msg', 'parse_duration',
+    'run_unit_test', 'stringf', 'trace_error',
+    'bytes_to_kb', 'bytes_to_mb', 'format_mem_size_value', 'format_size_bytes', 'get_mem_size', 'get_mem_size_breakdown', 'save_obj_graph_img', 'take_mem_growth_snapshot',
+    'ProfileSection', 'allow_curly_braces', 'create_or_get_profile', 'format_profile_registry', 'get_profile_registry', 'get_profile_reports', 'log_profile_registry', 'make_time_str', 'profile_function', 'profile_start',
+    'profile_stop',
+    'format_data_as_table', 'format_dict_as_table', 'format_list_as_table', 'format_obj_as_table', 'format_property', 'format_square_layout', 'format_table', 'print_as_square', 'print_square_layout', 'print_table',
+    'transpose_dict',
+]

mew_log/ansi_utils.py

@@ -0,0 +1,148 @@
+import sys
+import time
+
+# from colorama import Fore, Back, Style
+# from colorama import just_fix_windows_console, init
+
+# init(autoreset=True)
+# # use Colorama to make Termcolor work on Windows too
+# just_fix_windows_console()
+
+
+class AnsiCodeHelper:
+    ansi_codes = {
+        'fg_colors': {
+            'black': '\033[30m',
+            'red': '\033[31m',
+            'green': '\033[32m',
+            'yellow': '\033[33m',
+            'blue': '\033[34m',
+            'magenta': '\033[35m',
+            'cyan': '\033[36m',
+            'white': '\033[37m',
+            'bright_black': '\033[1;30m',
+            'bright_red': '\033[1;31m',
+            'bright_green': '\033[1;32m',
+            'bright_yellow': '\033[1;33m',
+            'bright_blue': '\033[1;34m',
+            'bright_magenta': '\033[1;35m',
+            'bright_cyan': '\033[1;36m',
+            'bright_white': '\033[1;37m',
+            'reset_color': '\033[39m',
+        },
+        'bg_colors': {
+            'black': '\033[40m',
+            'red': '\033[41m',
+            'green': '\033[42m',
+            'yellow': '\033[43m',
+            'blue': '\033[44m',
+            'magenta': '\033[45m',
+            'cyan': '\033[46m',
+            'white': '\033[47m',
+            'reset_background': '\033[49m',
+        },
+        'text_format': {
+            'bold': '\033[1m',
+            'underline': '\033[4m',
+            'italic': '\033[3m',
+            'inverse': '\033[7m',
+            'blink': '\033[5m',
+            'hidden': '\033[8m',
+            'strike_through': '\033[9m',
+            'frame': '\033[51m',
+            'encircled': '\033[52m',
+            'overlined': '\033[53m',
+            'reset_format': '\033[0m',
+        },
+        'link': {
+            'url_start': '\033]8;;',
+            'url_end': '\033]8;;\033\\',
+        },
+        'utility': {
+            'escape_sequence_start': '\033]',
+            'escape_sequence_end': '\033\\',
+            'enable_alternate_screen_buffer': '\033[?1049h',
+            'disable_alternate_screen_buffer': '\033[?1049l',
+        }
+    }
+
+    @staticmethod
+    def get_ansi_code(category, name):
+        return AnsiCodeHelper.ansi_codes.get(category, {}).get(name, '')
+
+
+def ansi_link_str(url, link_text="", link_color='bright_green'):
+    # Get the ANSI escape sequence for the default color
+    # Check if link text is empty
+    if link_text == '':
+        link_text = url
+
+    # Check if stdout is a terminal
+    if sys.stdout.isatty():
+        # get ansi codes
+        # default_color_code = AnsiCodeHelper.get_ansi_code('fg_colors', link_color)
+        # format_reset_code = AnsiCodeHelper.get_ansi_code('text_format', 'reset_format')
+        start_sequence = AnsiCodeHelper.get_ansi_code('utility', 'escape_sequence_start')
+        end_sequence = AnsiCodeHelper.get_ansi_code('utility', 'escape_sequence_end')
+        # create url link sequence
+        url_start = AnsiCodeHelper.get_ansi_code('link', 'url_start')
+        url_end = AnsiCodeHelper.get_ansi_code('link', 'url_end')
+        link_color_code = AnsiCodeHelper.get_ansi_code('fg_colors', link_color)
+        reset_format_code = AnsiCodeHelper.get_ansi_code('text_format', 'reset_format')
+
+        formatted_link_text = f"{url_start}{url}{end_sequence}{link_color_code}{link_text}{reset_format_code}{url_end}"
+
+        # log_info(f'formatted_link_text={formatted_link_text}\n\n')
+
+        return formatted_link_text
+    else:
+        # If stdout is not a terminal, return the default formatted link text
+        return link_text
+
+
+def ansi_color_str(s, fg='white', bg=None):
+    if bg is None:
+        color_type = 'fg_colors'
+        color_code = AnsiCodeHelper.get_ansi_code(color_type, fg)
+        reset_color_code = AnsiCodeHelper.get_ansi_code(color_type, 'reset_color')
+        return f"{color_code}{s}{reset_color_code}"
+    else:
+        fg_color_code = AnsiCodeHelper.get_ansi_code('fg_colors', fg)
+        bg_color_code = AnsiCodeHelper.get_ansi_code('bg_colors', bg)
+        reset_bg_color_code = AnsiCodeHelper.get_ansi_code('bg_colors', 'reset_background')
+        reset_fg_color_code = AnsiCodeHelper.get_ansi_code('fg_colors', 'reset_color')
+        return f"{bg_color_code}{fg_color_code}{s}{reset_fg_color_code}{reset_bg_color_code}"
+
+
+def ansi_format_str(s, format_name):
+    format_code = AnsiCodeHelper.get_ansi_code('text_format', format_name)
+    reset_format_code = AnsiCodeHelper.get_ansi_code('text_format', 'reset_format')
+    return f"{format_code}{s}{reset_format_code}"
+
+
+def ansi_rainbow_str(message, delay=0.1, iterations=10):
+    # init_thread(ansi_rainbow_anim, message, delay)
+    rainbow_colors = ['red', 'yellow', 'green', 'blue', 'magenta', 'cyan']
+    for _ in range(iterations):
+        for color in rainbow_colors:
+            color_code = AnsiCodeHelper.get_ansi_code('fg_colors', color)
+            reset_color_code = AnsiCodeHelper.get_ansi_code('fg_colors', 'reset_color')
+            rainbow_str = ansi_color_str(message, color)
+            log_info(rainbow_str, end='\r', flush=True)
+            time.sleep(delay)
+    log_info('\n')
+
+
+def print_to_ansi_alt_screen_buffer(info):
+    # Enable alternate screen buffer
+    sys.stdout.write(
+        f"{AnsiCodeHelper.get_ansi_code('utility', 'escape_sequence_start')}{AnsiCodeHelper.get_ansi_code('utility', 'enable_alternate_screen_buffer')}")
+
+    # Display additional information on the alternate screen buffer
+    log_info(info)
+
+    # Disable alternate screen buffer
+    sys.stdout.write(
+        f"{AnsiCodeHelper.get_ansi_code('utility', 'escape_sequence_start')}{AnsiCodeHelper.get_ansi_code('utility', 'disable_alternate_screen_buffer')}")
+
+

mew_log/attr_utils.py

@@ -0,0 +1,260 @@
+from ..mew_log.ansi_utils import ansi_link_str, ansi_color_str
+
+
+def get_type_name(attr):
+    return type(attr).__name__
+
+def is_complex_type(obj):
+    return is_of_type(variable, (list, set, dict)) or hasattr(variable, '__dict__')
+
+
+def is_bytes_like_type(obj, bytes_like_types=(memoryview, bytes, bytearray), raise_err=False):
+    try:
+        return is_of_type(obj, bytes_like_types)
+    except TypeError as e:
+        if raise_err:
+            raise TypeError(f"Provided object does not match the provided types: {bytes_like_types}")
+        return False
+
+def is_of_type(obj, types, raise_err=False):
+    if isinstance(obj, (types)):
+        return True
+    elif raise_err:
+        raise TypeError(f"Provided object does not match the provided types: {tuple(types)}")
+    return False
+
+
+def get_partial_argspec(method):
+    if not callable(method):
+        return None  # Not a callable object
+    try:
+        full_argspec = inspect.getfullargspec(method)
+        return full_argspec
+    except TypeError:
+        # Fallback to using inspect.signature
+        signature = get_signature(method)
+        if signature:
+            parameters = signature.parameters
+            args = [param for param in parameters if parameters[param].default == parameters[param].empty]
+            varargs = signature.varargs
+            varkw = signature.varkw
+            defaults = [parameters[param].default for param in args]
+            return inspect.FullArgSpec(args, varargs, varkw, defaults)
+
+def get_signature(method):
+    try:
+        signature = inspect.signature(method)
+        return signature
+    except (TypeError, ValueError):
+        return None
+
+def get_method_args(method):
+
+    full_arg_spec = get_partial_argspec(method)
+    if full_arg_spec:
+        args = [arg for arg in full_arg_spec.args if
+                getattr(method, arg, None) is not None and getattr(method, arg, "") != ""]
+        kwargs = {key: getattr(method, key, None) for key in full_arg_spec.kwonlyargs}
+        kwargs_defaults = {key: value for key, value in
+                           zip(full_arg_spec.kwonlyargs, full_arg_spec.kwonlydefaults or ())}
+        args.extend(f"{key}={value}" for key, value in kwargs.items() if value is not None and value != "")
+        return args
+    return None
+
+
+def get_source_info(attr):
+    try:
+        source_lines, line_number = inspect.getsourcelines(attr)
+        source_file_path = inspect.getsourcefile(attr)
+        source_file = os.path.relpath(source_file_path)
+        return f"/{source_file}::{line_number}"
+    except Exception as e:
+        return "Source info not available!"
+
+
+def get_method_info(method):
+    args = get_method_args(method)
+    args_str = ", ".join(args) if args else ''
+    signature = get_signature(method)
+    return_str = f' -> {signature.return_annotation}' if signature and signature.return_annotation is not inspect.Signature.empty else ''
+
+    try:
+        source_info = get_source_info(method)
+    except Exception as e:
+        raise Exception("Source info not available!", e)
+
+    # Construct the file:// URL with line number for the method if available
+    method_file_url = f"file://{inspect.getsourcefile(method)}#L{inspect.getsourcelines(method)[1]}"
+    method_link = ansi_link_str(method_file_url, "Source")
+
+    # Include the link in the method signature string
+    method_signature = f"{signature}{return_str}: {method_link}\n-->{source_info}"
+
+    return method_signature
+def get_var_value(variable):
+        return f'{str(variable)}' if not is_of_type(variable, (list, set, dict)) or hasattr(variable, '__dict__') else '...'
+
+def get_variable_info(variable):
+    return f"<{ get_type_name(variable) }>: { get_var_value(variable) }"
+
+def list_class_attributes(cls, verbose=True, use_color=False):
+    def format_str(s, fg=None):
+        return ansi_color_str(s, fg=fg) if use_color else s
+
+    # Determine whether cls is a class or an instance of a class
+    if inspect.isclass(cls):
+        class_name = cls.__name__
+    else:
+        class_name = cls.__class__.__name__
+
+    variables = [
+        f'{attribute}{get_variable_info(getattr(cls, attribute))}' if verbose else f'{attribute}<{get_type_name(getattr(cls, attribute))}>'
+        for attribute in dir(cls) if not attribute.startswith('__') and not callable(getattr(cls, attribute))]
+    methods = [f'{attribute}{get_method_info(getattr(cls, attribute))}' if verbose else f'{attribute}<method>' for
+               attribute in dir(cls) if not attribute.startswith('__') and callable(getattr(cls, attribute))]
+
+    variables_str = '\n'.join([f' - {format_str(var, fg="green")}' for var in variables])
+    methods_str = '\n'.join([f' - {format_str(method, fg="blue")}' for method in methods])
+
+    cls_name = format_str(class_name, fg="cyan") if use_color else class_name
+    return f'===list_class_attributes of: {cls_name}:\n===<variables>===\n{variables_str}\n===<methods>===\n{methods_str}'
+    
+def get_class_attributes(cls, verbose=True, use_color=True):
+    def format_str(s, fg=None):
+        return ansi_color_str(s, fg=fg) if use_color else s
+
+    attributes_dict = {'variables': {}, 'methods': {}}
+
+    for attribute_v in vars(cls):
+        if not attribute_v.startswith('__') and 'stat' not in attribute_v:
+            attr = getattr(cls, attribute_v)
+            if not callable(attr):
+                attr_info = get_variable_info(attr) if verbose else ''
+                formatted_key = format_str(attribute_v, fg="green")
+                formatted_value = format_str(attr_info, fg="cyan") if verbose else ''
+                attributes_dict['variables'][attribute_v] = f'\n ~ {formatted_key}{formatted_value}'
+
+    for attribute in dir(cls):
+        if not attribute.startswith('__'):
+            attr = getattr(cls, attribute)
+            if callable(attr):
+                method_info = get_method_info(attr) if verbose else ''
+                formatted_key = format_str(attribute, fg="blue")
+                formatted_value = format_str(method_info, fg="cyan") if verbose else ''
+                attributes_dict['methods'][attribute] = f'\n ~ {formatted_key}{formatted_value}'
+
+    return attributes_dict
+
+
+import threading
+
+
+def get_thread_info(message='', use_color=True):
+    current_thread = threading.current_thread()
+    current_thread_name = current_thread.name
+    current_thread_id = current_thread.ident
+    current_thread_alive = current_thread.is_alive()
+
+    # Construct the colored thread info
+    thread_info = f'thread:{current_thread_name}::{current_thread_id}::{current_thread_alive}'
+    if use_color:
+        thread_info = ansi_color_str(thread_info,fg='yellow', bg='bright_yellow')
+
+    formatted_message = f'{thread_info}:{message}'
+
+    return formatted_message
+
+
+import inspect
+import os
+
+ # Get the current frame
+def get_prev_frame(steps=1):
+    curr_frame = inspect.currentframe()
+    
+    # Traverse back the specified number of steps in the call stack
+    for _ in range(steps):
+        if curr_frame is not None:
+            curr_frame = curr_frame.f_back
+    
+    if curr_frame is None:
+        return None
+
+    return curr_frame
+
+
+def get_prev_frame_from_frame(frame, steps=1):
+    curr_frame = frame
+    
+    # Traverse back the specified number of steps in the call stack
+    for _ in range(steps):
+        if frame is not None:
+            curr_frame = curr_frame.f_back
+    
+    if curr_frame is None:
+        return None
+
+    return curr_frame
+
+def get_prev_caller_info(message='', use_color=True, steps=99):
+    # Get the current frame
+    curr_frame = inspect.currentframe()
+    caller_frame = curr_frame.f_back
+
+    while not caller_frame.f_back is None:
+        caller_frame = caller_frame.f_back
+        steps -=1
+        if steps <= 0:
+            break
+
+    previous_frame = caller_frame
+
+    # Retrieve the information about the previous frame
+    frame_info = inspect.getframeinfo(previous_frame)
+    # Get the file name where the function was called
+    filename_with_path = frame_info.filename
+    # Extract only the file name
+    filename = os.path.basename(filename_with_path)
+    # Get the line number in the file where the function was called
+    linenumber = frame_info.lineno
+    # Get the function name
+    function = frame_info.function
+    # Format the string to include the passed message
+    caller_link = ansi_link_str(f"file:///{filename_with_path}", f"{filename}::{linenumber}::{function}") if use_color else f"{filename}::{linenumber}::{function}"
+    info_str = f"{caller_link}: {message}"
+    # Clean up to prevent reference cycles
+    del curr_frame
+    del caller_frame
+    del previous_frame
+    return info_str
+
+
+def get_caller_info(message='', use_color=True):
+    # Get the current frame
+    curr_frame = inspect.currentframe()
+    # Get the caller's frame
+    caller_frame = curr_frame.f_back
+    # Retrieve the information about the caller's frame
+    frame_info = inspect.getframeinfo(caller_frame)
+    # Get the file name where the function was called
+    filename_with_path = frame_info.filename
+    # Extract only the file name
+    filename = os.path.basename(filename_with_path)
+    # Get the line number in the file where the function was called
+    linenumber = frame_info.lineno
+    # get the function name
+    function = frame_info.function
+    # Format the string to include the passed message
+    #caller_link = f"file:///{filename_with_path}", f"{filename}::{linenumber}::{function}"
+    caller_link =  ansi_link_str(f"file:///{filename_with_path}", f"{filename}::{linenumber}::{function}") if use_color else f"{filename}::{linenumber}::{function}"
+    #caller_link = f"{filename}::{linenumber}::{function}"
+
+    info_str = f"{caller_link}: {message}"  # file://
+    # Clean up to prevent reference cycles
+    del curr_frame
+    del caller_frame
+    return info_str
+
+
+def get_class_name(obj):
+    return obj.__class__.__name__

mew_log/extended_symbols.py

@@ -0,0 +1,127 @@
+import enum
+
+class ExtendedSymbols:
+    class Symbol(enum.Enum):
+        # Correctly differentiating between single and double line symbols
+        TOP_RIGHT_L = '\u2510'        # ┐ Single line top right corner
+        BOTTOM_RIGHT_L = '\u2518'     # ┘ Single line bottom right corner
+        TOP_LEFT_L = '\u250C'         # ┌ Single line top left corner
+        BOTTOM_LEFT_L = '\u2514'      # └ Single line bottom left corner
+        RIGHT_T = '\u2524'            # ┤ Single line right T
+        LEFT_T = '\u251C'             # ├ Single line left T
+        TOP_T = '\u252C'              # ┬ Single line top T
+        BOTTOM_T = '\u2534'           # ┴ Single line bottom T
+        CROSS = '\u253C'              # ┼ Single line cross
+        SINGLE_HORIZONTAL = '\u2500'  # ─ Single horizontal line
+        SINGLE_VERTICAL = '\u2502'    # │ Single vertical line
+        
+        # Double line versions
+        DOUBLE_TOP_RIGHT_L = '\u2557'  # ╗ Double line top right corner
+        DOUBLE_BOTTOM_RIGHT_L = '\u255D'  # ╝ Double line bottom right corner
+        DOUBLE_TOP_LEFT_L = '\u2554'   # ╔ Double line top left corner
+        DOUBLE_BOTTOM_LEFT_L = '\u255A'  # ╚ Double line bottom left corner
+        DOUBLE_RIGHT_T = '\u2563'      # ╣ Double line right T
+        DOUBLE_LEFT_T = '\u2560'       # ╠ Double line left T
+        DOUBLE_TOP_T = '\u2566'        # ╦ Double line top T
+        DOUBLE_BOTTOM_T = '\u2569'     # ╩ Double line bottom T
+        DOUBLE_CROSS = '\u256C'        # ╬ Double line cross
+        DOUBLE_HORIZONTAL = '\u2550'   # ═ Double horizontal line
+        DOUBLE_VERTICAL = '\u2551'     # ║ Double vertical line
+
+        SOLID_BLOCK = '\u2588'         # █ Solid block
+        TOP_HALF_BLOCK = '\u2580'      # ▀ Top half block
+        BOTTOM_HALF_BLOCK = '\u2584'   # ▄ Bottom half block
+        SHADED_BLOCK = '\u2592'        # ▒ Shaded block
+
+    def __getattr__(self, name):
+        try:
+            return self.Symbol[name].value
+        except KeyError:
+            raise AttributeError(f"No such symbol: {name}")
+
+# Make ExtendedSymbols an instance so it can be used directly
+ExtendedSymbols = ExtendedSymbols()
+
+
+
+
+def draw_box(msg=None, width=None, height=None, title=None, line_type='single'):
+    # Use extended symbols correctly with Unicode
+    line_char = ExtendedSymbols.SINGLE_HORIZONTAL if line_type == 'single' else ExtendedSymbols.DOUBLE_HORIZONTAL
+    corner_tl = ExtendedSymbols.TOP_LEFT_L if line_type == 'single' else ExtendedSymbols.DOUBLE_TOP_LEFT_L
+    corner_tr = ExtendedSymbols.TOP_RIGHT_L if line_type == 'single' else ExtendedSymbols.DOUBLE_TOP_RIGHT_L
+    corner_bl = ExtendedSymbols.BOTTOM_LEFT_L if line_type == 'single' else ExtendedSymbols.DOUBLE_BOTTOM_LEFT_L
+    corner_br = ExtendedSymbols.BOTTOM_RIGHT_L if line_type == 'single' else ExtendedSymbols.DOUBLE_BOTTOM_RIGHT_L
+    vertical_line = ExtendedSymbols.SINGLE_VERTICAL if line_type == 'single' else ExtendedSymbols.DOUBLE_VERTICAL
+
+    # Determine width based on message length if not specified
+    if msg and (width is None or height is None):
+        width = max(len(msg), width if width else 0) + 2  # Add padding
+        height = 3  # Minimum box height with top, middle, and bottom
+
+    # Use default dimensions if none provided
+    if width is None:
+        width = 10  # Default width
+    if height is None:
+        height = 3  # Default minimum height
+
+    # Draw top border
+    top_border = f"{corner_tl}{line_char * width}{corner_tr}"
+    if title:
+        title_str = f" {title} "
+        title_length = len(title_str)
+        pre_title_length = (width - title_length) // 2
+        post_title_length = width - title_length - pre_title_length
+        top_border = f"{corner_tl}{line_char * pre_title_length}{title_str}{line_char * post_title_length}{corner_tr}"
+
+    # Prepare message line or blank lines
+    if msg:
+        message_line = f"{vertical_line} {msg} {vertical_line}"
+        if len(msg) < width - 2:
+            msg = msg + ' ' * (width - 2 - len(msg))
+        message_line = f"{vertical_line}{msg}{vertical_line}"
+    else:
+        message_line = f"{vertical_line}{' ' * (width)}{vertical_line}"
+
+    # Draw middle lines
+    middle_lines = (f"{vertical_line}{' ' * width}{vertical_line}\n") * (height - 2)
+    middle_lines = middle_lines[:-1]  # Remove the last newline for proper formatting
+
+    # Draw bottom border
+    bottom_border = f"{corner_bl}{line_char * width}{corner_br}"
+
+    # Combine all parts
+    box = f"{top_border}\n{message_line}\n{middle_lines}\n{bottom_border}"
+    print(box)
+
+def format_arrow(root_symbol=None, line_type='single', length=10):
+    """
+    Draw an arrow with a specified root symbol, line type, and length.
+    """
+    symbol_map = {
+        'L': {
+            'single': ExtendedSymbols.BOTTOM_LEFT_L,
+            'double': ExtendedSymbols.DOUBLE_BOTTOM_LEFT_L,
+        },
+        'T': {
+            'single': ExtendedSymbols.LEFT_T,
+            'double': ExtendedSymbols.DOUBLE_LEFT_T
+        },
+        '+': {
+            'single': ExtendedSymbols.CROSS,
+            'double': ExtendedSymbols.DOUBLE_CROSS 
+        }
+    }
+
+    # Default to a single horizontal line if undefined symbol or line type
+    chosen_symbol = symbol_map.get(root_symbol, {}).get(line_type, '')
+    line_char = ExtendedSymbols.DOUBLE_HORIZONTAL if line_type == 'double' else ExtendedSymbols.SINGLE_HORIZONTAL
+
+    # Construct the arrow string
+    return chosen_symbol + line_char * length + ">"
+
+
+def draw_arrow(root_symbol=None, line_type='single', length=10):
+    format_arrow_str = format_arrow(root_symbol, line_type, length)
+    print(format_arrow_str)
+

mew_log/log_utils.py

@@ -0,0 +1,502 @@
+# Standard Library Imports
+import datetime
+import threading
+import time
+import traceback
+from pathlib import Path
+
+import enum
+
+# Third-Party Imports
+from loguru import logger
+
+logger.add("./data/log/file_{time}.log", rotation="500 MB")  # Automatically rotate too big log files
+
+
+# Local Imports
+from ..mew_log.ansi_utils import ansi_color_str, ansi_link_str
+from ..mew_log.attr_utils import get_prev_caller_info, get_caller_info, get_thread_info, get_prev_frame, get_prev_frame_from_frame, is_of_type
+from ..mew_log.table_utils import format_property, format_table
+from ..mew_log.extended_symbols import ExtendedSymbols, draw_box, draw_arrow, format_arrow
+#from ..mew_log.mew_context import MewContext, resolve_context
+
+# Constants
+lastLog = None  # Stores the most recent log entry
+debug_log = []  # Stores all log entries
+startTime=time.time()
+#settings vars
+enable_log = True
+enable_log_to_file = False
+log_filename = "log"
+log_file_path = "data/log/log.txt"
+enable_fancy = True
+enable_use_color = True
+
+type_color='yellow'
+value_color='bright_yellow'
+arrow_color = 'bright_white'
+
+def allow_curly_braces(original_string):
+    if "{" in original_string or "}" in original_string:
+        escaped_string = original_string.replace("{", "{{").replace("}", "}}")
+        #print("Escaped String:", escaped_string)  # Debug output
+        return escaped_string
+    return original_string
+
+def format_arg(arg, use_color, fancy):
+    def is_complex_type(obj):
+        return is_of_type(obj, (list, set, dict)) or hasattr(obj, '__dict__')
+
+    type_str = f"<{type(arg).__name__}>"
+    value_str = repr(arg) if not isinstance(arg, str) and not fancy else format_table(arg, use_color=use_color)
+    newline_if_needed = '\n' if is_complex_type(arg) else ""
+    formatted_arg = f"{type_str}:{newline_if_needed}{value_str}"
+    formatted_arg = allow_curly_braces(formatted_arg)
+    return ansi_color_str(formatted_arg, fg=value_color) if use_color else formatted_arg
+
+
+def format_kwarg(kw, arg, use_color, fancy):
+    name_str = ansi_color_str(kw, fg=kw_color) if use_color else kw
+    arg_str = format_arg(arg, use_color, fancy)
+    formatted_arg = f"{name_str}: {arg_str}"
+    return ansi_color_str(formatted_arg, fg=value_color) if use_color else formatted_arg
+
+def format_args(use_color=enable_use_color, fancy=enable_fancy, *args, **kwargs):
+    formatted_args = [ format_arg(arg, use_color, fancy) for arg in args]
+    formatted_kwargs = {k: format_kwarg(k, v, use_color, fancy) for k, v in kwargs.items()}
+    return formatted_args, formatted_kwargs
+
+def make_formatted_msg(msg, *args, **kwargs):
+    #fetch format vars from kwargs
+    fancy = kwargs.pop('fancy', enable_fancy)
+    use_color = kwargs.pop('use_color', enable_use_color)
+    context_depth = kwargs.pop('context_depth', None)
+    context = kwargs.pop('context', None)
+    # print(f"args={args}")
+    # print(f"kwargs={kwargs}")
+
+    formatted_args, formatted_kwargs = format_args(use_color, fancy, *args, **kwargs)
+
+    msgf = stringf(msg, *formatted_args, **formatted_kwargs)
+
+    #context = MewContext.resolve_context(context, depth, steps=5)
+    if fancy:
+        formatted_msg = f"\n ~ | {get_timestamp()} | {get_thread_info(get_prev_caller_info(msgf, use_color=use_color, steps=2))}"
+    else:
+        formatted_msg = f"\n ~ | {get_timestamp()} | {context}:{msgf}"
+
+    return formatted_msg
+
+def stringf(s: str, *args, **kwargs):
+    # s = allow_curly_braces(s)  # Uncomment or modify as needed
+    if not args and not kwargs:
+        #print("Both args and kwargs are empty.")
+        return s
+    else:
+        return s.format(*args, **kwargs)
+    #     if not args:
+    #         print("Args is empty.")
+    #     if not kwargs:
+    #         print("Kwargs is empty.")
+
+    # print(s)
+    # print(f"args: {args}")
+    # print(f"kwargs: {kwargs}")
+    # return s.format(*args, **kwargs)
+
+# No arguments or keyword arguments
+# stringf("Hello, World!")
+
+# # With positional arguments
+# stringf("Hello, {}!", "World")
+
+# # With keyword arguments
+# stringf("Hello, {name}!", name="Alice")
+
+# # With both args and kwargs empty (only prints "Hello, World!")
+# stringf("Hello, World!")
+
+def ensure_directory_exists(directory):
+    path = Path(directory)
+    path.mkdir(parents=True, exist_ok=True)
+
+def ensure_file_exists(file_path):
+    path = Path(file_path)
+    path.touch(exist_ok=True)
+
+#from ..mew_log.mew_log_helper import MewLogHelper
+
+# Logging Configuration
+
+ # Configure Loguru's logger to use a custom format
+import sys
+import io
+
+# Set UTF-8 encoding for stdout and stderr
+#sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8', line_buffering=True)
+#sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8', line_buffering=True)
+
+#logger.add(sys.stdout, format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | {level} | {message}", backtrace=True)
+
+logger.configure(handlers=[
+    {
+        "sink": sys.stdout, 
+        "format": "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | {level} | {message}", # | <cyan>{file}:{line}:{function}</cyan>
+        "level": "INFO"
+    },
+    {
+        "sink": sys.stdout, 
+        "format": "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | {level} | {message}", # | <yellow>{file}:{line}:{function}</yellow> 
+        "level": "WARNING"
+    },
+    {
+        "sink": sys.stderr, 
+        "format": "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | {level} | {message}", #| <red>{file}:{line}:{function}</red> 
+        "level": "ERROR"
+    }
+])
+
+
+# Logging Configuration
+def init_log(log_config):
+    global enable_log_to_file, enable_log, log_filename, log_file_path
+    enable_log_to_file = log_config['log_to_file']
+    clear_file_first = log_config['clear_file_first']
+    enable_log = log_config['enable_log']
+    log_filename = log_config['log_filename']
+    log_dir = 'data/log/'
+    ensure_directory_exists(log_dir)
+    log_file_path = f"data/log/{log_filename}.txt"
+    ensure_file_exists(log_file_path)
+    with open(log_file_path, 'w') as fp:
+        pass
+
+   
+    print(f'init_log: \n ~ enable_log: {enable_log} \n ~ enable_log_to_file: {enable_log_to_file} \n ~ log_file_path: {log_file_path}')
+
+
+def _update_log(formatted_msg_str):
+    global lastLog, debug_log, enable_log_to_file
+    
+    lastLog = formatted_msg_str
+
+    debug_log.append(lastLog)
+
+    if enable_log_to_file:
+        log_file(lastLog)
+
+
+def log_file(msg, file_path = None):
+    global log_file_path
+    if not enable_log:
+        return
+    if file_path is None:
+        file_path = log_file_path
+
+    curTime = time.time()
+    elapsedTime = curTime - startTime
+    with open(log_file_path, 'w') as fp:
+        fp.write(f"\n ~ | time={elapsedTime:.2f}s ~ {msg}")
+    #logger.add(log_file_path, format="time={elapsedTime:.2f}s ~ {msg}")
+
+
+
+def log_info(msg, *args,**kwargs):
+    if not enable_log:
+        return
+
+    formatted_msg_str = make_formatted_msg(msg, *args,**kwargs)
+
+    _update_log(formatted_msg_str)
+
+    formatted_log_str = lastLog
+    print(formatted_log_str)
+    #logger.info(formatted_log_str)
+   
+def log_warning(msg, *args,**kwargs):
+    if not enable_log:
+        return
+
+    formatted_msg_str = make_formatted_msg(msg, *args,**kwargs)
+
+    _update_log(formatted_msg_str)
+
+    formatted_log_str = lastLog
+
+    #print(formatted_log_str)
+
+    logger.warning(formatted_log_str)
+        
+def log_error(msg, e, *args,**kwargs):
+    if not enable_log:
+        return
+
+    formatted_msg_str = f"\n===^_^===\n{make_formatted_msg(msg, *args, **kwargs)}" 
+    formatted_msg_str += f"{trace_error(e)}\n===>_<==="
+
+    _update_log(formatted_msg_str)
+
+    formatted_log_str = lastLog
+
+    #print(formatted_log_str)
+
+    logger.error(formatted_log_str)
+
+
+import functools
+import traceback
+
+def log_function(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        def get_func_args():
+            arg_names = func.__code__.co_varnames[:func.__code__.co_argcount]
+            func_args = dict(zip(arg_names, args))
+            func_args.update(kwargs)
+
+        try:
+            arg_names = func.__code__.co_varnames[:func.__code__.co_argcount]
+            func_args = dict(zip(arg_names, args))
+            func_args.update(kwargs)
+            func_args_str = format_table(func_args, headers=None, tablefmt='simple')
+            #print(get_prev_caller_info(f"({func_args_str} )"))
+            result = func(*args, **kwargs)
+            print(get_thread_info(get_prev_caller_info(f"({func_args} ) -> result: {format_arg(result, use_color=True, fancy=True)}")))
+            return result
+        except Exception as e:
+            arg_names = func.__code__.co_varnames[:func.__code__.co_argcount]
+            func_args = dict(zip(arg_names, args))
+            func_args.update(kwargs)
+            
+            logger.error(f"Exception: {str(e)}")
+            logger.error(f"Format Traceback: {traceback.format_exc()}")
+            raise  # Re-raise the exception after logging
+    return wrapper
+
+# @log_function
+# def dive(a, b):
+#     return a / b
+
+# dive(2,3)
+
+# dive(12,3)
+
+# dive(14,3)
+
+# dive(21,3)
+
+# dive(21,0)
+
+error_color = 'bright_red'
+
+def format_traceback(tb_entry, depth=0, use_color=enable_use_color):
+    arrow_str = format_arrow('T', 'double', 3 + 2 * depth)
+    
+    filename, lineno, funcname, line = tb_entry
+    file_path = f"file:///{filename}"
+    file_link = f"{filename}::{lineno}::{funcname}"
+    trace_link = ansi_link_str(file_path, file_link, link_color="bright_magenta") if use_color else file_link
+    
+    arrow_str2 = format_arrow('L', 'double', 3 + 2 * (depth+1))
+    #(" " * (3 + 2 * depth))+
+    formatted_tb_str = f'\n ~ | {arrow_str}trace({depth}): {trace_link}\n ~ | {arrow_str2} Line: "{line}"'
+    return ansi_color_str(formatted_tb_str, fg=error_color) if use_color else formatted_tb_str
+
+def trace_error(e, use_color=True, fancy=True):
+    exception_str = f"\n ~ | {ExtendedSymbols.DOUBLE_VERTICAL}Exception: {repr(e)}"
+    out_str = ansi_color_str(exception_str, fg=error_color) if use_color else exception_str
+    if isinstance(e, BaseException):
+        arrow_str = format_arrow('T', 'double', 3)
+        traceback_obj = e.__traceback__
+        if traceback_obj:
+            file_path = f"file:///{traceback_obj.tb_frame.f_code.co_filename}"
+            file_link = f"{traceback_obj.tb_frame.f_code.co_filename}::{traceback_obj.tb_lineno}"
+            trace_link = ansi_link_str(file_path, file_link, link_color="bright_magenta") if use_color else file_link
+            formatted_tb_str = f"\n ~ | {arrow_str}trace(0): {trace_link}"
+            out_str += ansi_color_str(formatted_tb_str, fg=error_color) if use_color else formatted_tb_str
+            
+            tb = traceback.extract_tb(traceback_obj)
+            for i, tb_entry in enumerate(tb):
+                out_str += format_traceback(tb_entry, depth=i+1, use_color=use_color)
+
+    return ansi_color_str(out_str, fg=error_color) if use_color else out_str
+
+
+# log_info(' ~ | test log_info: {}', 1)
+# log_warning(' ~ | test log_warning: {}', 2)
+
+
+def log_text_input(key: str):
+    log_info(f'\n ~ | Text Input[{key}]: ')
+    input_text = input()
+    log_info(f'\n ~ | Recv input: "{input_text}"')
+    return input_text
+
+
+def format_duration(seconds):
+    hours, remainder = divmod(seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{int(hours)}h {int(minutes)}m {int(seconds)}s"
+
+def parse_duration(duration_str):
+    parts = duration_str.split()
+    hours = int(parts[0][:-1]) if 'h' in parts[0] else 0
+    minutes = int(parts[1][:-1]) if 'm' in parts[1] else 0
+    seconds = int(parts[2][:-1]) if 's' in parts[2] else 0
+    return hours * 3600 + minutes * 60 + seconds
+
+
+def get_timestamp():
+    return datetime.datetime.now().strftime("%Y-%b-%d %H:%M:%S")
+
+
+def format_path(directory, depth=0, max_depth=3, use_color=True):
+    """Formats the directory structure as a string up to a specified depth, with optional color.
+
+    Args:
+        directory (str or Path): The directory path to format.
+        depth (int): The current depth in the directory structure.
+        max_depth (int): The maximum depth to format.
+        use_color (bool): Whether to apply color to the output.
+
+    Returns:
+        str: The formatted directory structure.
+    """
+    if max_depth is not None and depth > max_depth:
+        return ""
+
+    directory_path = Path(directory)
+    if not directory_path.is_dir():
+        return "The specified path is not a directory.\n"
+
+    # Build the formatted string, applying color if requested
+    line_prefix = "│   " * depth + "├── "
+    directory_name = directory_path.name
+    if use_color:
+        line_prefix = ansi_color_str(line_prefix, fg='cyan')  # Assuming color_str function exists
+        directory_name = ansi_color_str(directory_name, fg='green')  # Adjust colors as needed
+
+    formatted_str = line_prefix + directory_name + "\n"
+    
+    # Sort directory contents for consistent order
+    sorted_items = sorted(directory_path.iterdir(), key=lambda x: (x.is_file(), x.name))
+    
+    for item in sorted_items:
+        if item.is_dir():
+            # Recursive call for directories, increasing the depth
+            formatted_str += format_path(item, depth + 1, max_depth, use_color)
+        else:
+            # Include file name with indentation, applying color if requested
+            file_line = "│   " * (depth + 1) + "├── " + item.name
+            if use_color:
+                file_line = ansi_color_str(file_line, fg='white')  # Example color, adjust as needed
+            formatted_str += file_line + "\n"
+
+    return formatted_str
+
+
+# Spinner Class
+class LogSpinner:
+    def __init__(self, message="", rainbow=True, anim_speed=0.1):
+        self.message = message
+        self.speed = anim_speed
+        self.colors = ['\033[31m', '\033[33m', '\033[32m', '\033[34m', '\033[35m', '\033[36m']
+        self.spinner = ['⠇', '⠋', '⠙', '⠸', '⠼', '⠴', '⠦', '⠧']
+
+        #self.spinner = ['|', '/', '-', '\\']
+        self.rainbow = rainbow
+
+    def __enter__(self):
+        self.stop_spinner = False
+        self.startTime = time.time()
+        # spinner_text = f'^_^ | {self.message} - time: {0.0:.2f}s | Begin!'
+        # print(spinner_text)
+        self.spinner_thread = threading.Thread(target=self.spin)
+        self.spinner_thread.start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.stop_spinner = True
+        self.spinner_thread.join()
+
+        curTime = time.time()
+        spinner_text = f'>_< | {self.message} - time: {format_duration(curTime - self.startTime)} | Done!'
+        print(spinner_text)
+
+    def spin(self):
+        while not self.stop_spinner:
+            #self.update_spinner()
+            if self.rainbow: self.update_color_spinner()
+            else: self.update_spinner()
+
+    def update_spinner(self):
+        for char in self.spinner:
+            curTime = time.time()
+            spinner_text = f'{self.message} - time: {format_duration(curTime - self.startTime)} |'
+            print(f'\r ^_^ | {char} | {spinner_text}', end='\r', flush=True)
+            time.sleep(self.speed)
+
+    def update_color_spinner(self):
+        for color in self.colors:
+            for char in self.spinner:
+                curTime = time.time()
+                spinner_text = f'{self.message} - time: {format_duration(curTime - self.startTime)} |'
+                print(f'^_^ | {color}{char}\033[0m | {spinner_text}', end='\r', flush=True)
+                time.sleep(self.speed)
+
+
+def run_unit_test():
+    # Example usage:
+    class Person:
+        def __init__(self, name, age, city):
+            self.name = name
+            self.age = age
+            self.city = city
+
+    # Create instances of Person
+    person1 = Person('John', 30, 'New York')
+    person2 = Person('Alice', 25, 'Los Angeles')
+    person3 = Person('Bob', 30, 'Hong Kong')
+    person4 = Person('Charlie', 35, 'Shanghai')
+    person5 = Person('David', 40, 'Beijing')
+
+    # Define other data structures
+    data_dict = {'Name': 'John', 'Age': 30, 'City': 'New York'}
+    data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    data_set = {'apple', 'banana', 'orange'}
+    data_dict_of_lists = {'Name': ['John', 'Alice'], 'Age': [30, 25], 'City': ['New York', 'Los Angeles']}
+    data_list_of_dicts = [person1.__dict__, person2.__dict__]
+    data_dict_of_dicts = {'Person1': person1.__dict__, 'Person2': person2.__dict__}
+    list_of_objs = [person3, person4, person5]
+    data_list_of_lists = [['John', 30, 'New York'], ['Alice', 25, 'Los Angeles']]
+    dict_of_objs = {'Alice': person3, 'Bob': person4, 'Charlie': person5}
+    dict_of_list_of_objs = {'Group1': [person3, person4], 'Group2': [person5]}
+
+    # Combine all data into a complex structure
+    complex_data = {
+        'data_dict': data_dict,
+        'data_list': data_list,
+        'data_set': data_set,
+        'data_dict_of_lists': data_dict_of_lists,
+        'data_list_of_dicts': data_list_of_dicts,
+        'data_dict_of_dicts': data_dict_of_dicts,
+        'list_of_objs': list_of_objs,
+        'data_list_of_lists': data_list_of_lists,
+        'dict_of_objs': dict_of_objs,
+        'dict_of_list_of_objs': dict_of_list_of_objs
+    }
+    
+    # Log each unique data structure
+    log_info("Data Dictionary: {}", data_dict)
+    log_info("Data List: {}", data_list)
+    log_info("Data Set: {}", data_set)
+    log_info("Data Dictionary of Lists: {}", data_dict_of_lists)
+    log_info("Data List of Dicts: {}", data_list_of_dicts)
+    log_info("Data Dictionary of Dicts: {}", data_dict_of_dicts)
+    log_info("List of Objects: {}", list_of_objs)
+    log_info("Data List of Lists: {}", data_list_of_lists)
+    log_info("Dictionary of Objects: {}", dict_of_objs)
+    log_info("Dictionary of List of Objects: {}", dict_of_list_of_objs)
+
+
+#run_unit_test()

mew_log/mem_utils.py

@@ -0,0 +1,144 @@
+
+#from ..mew_core import prettify
+from ..mew_log.ansi_utils import ansi_color_str
+from ..mew_log.attr_utils import get_caller_info, get_var_value
+from ..mew_log.table_utils import format_table
+
+import sys
+import types 
+import objgraph
+
+one_mb = 2**20
+
+def bytes_to_mb(size_in_bytes, inv_bytes_in_mb=(1.0 / (1024 * 1024))):
+    """
+    Convert size from bytes to megabytes.
+    """
+    return size_in_bytes * inv_bytes_in_mb
+
+
+def bytes_to_kb(size_in_bytes, inv_bytes_in_kb=(1.0 / (1024))):
+    """
+    Convert size from bytes to kilobytes.
+    """
+    return size_in_bytes * inv_bytes_in_kb
+
+def format_mem_size_value(size_bytes, use_color=True):
+    size_b = size_bytes
+    size_mb = bytes_to_mb(size_b)
+    size_kb = bytes_to_kb(size_b)
+    
+    size_mb_str = f"{size_mb:.4f} MB"
+    size_kb_str = f"{size_kb:.4f} KB"
+    size_b_str = f"{size_b} B"
+
+    # Determine which size to display based on the criteria
+    if size_mb > 0.1:  # More than 0.1 MB
+        display_str = size_mb_str
+    elif size_kb > 0.1:  # More than 0.1 KB but less than 0.1 MB
+        display_str = size_kb_str
+    else:  # Less than 0.1 KB
+        display_str = size_b_str
+
+    # Apply color if use_color is True
+    if use_color:
+        display_str = ansi_color_str(display_str, fg='cyan')
+
+    return f"Mem Size: {display_str}"  # Display the selected size
+
+
+def format_size_bytes(obj, use_color=True):
+    size_b, size_mb = get_mem_size(obj)
+    size_kb = bytes_to_kb(size_b)
+    size_mb_str = f"{size_mb:.4f} MB"
+    size_kb_str = f"{size_kb:.4f} KB"
+    size_b_str = f"{size_b} B"
+
+    # Determine which size to display based on the criteria
+    if size_mb > 0.1:  # More than 0.1 MB
+        display_str = size_mb_str
+    elif size_kb > 0.1:  # More than 0.1 KB but less than 0.1 MB
+        display_str = size_kb_str
+    else:  # Less than 0.1 KB
+        display_str = size_b_str
+
+    # Apply color if use_color is True
+    if use_color:
+        display_str = ansi_color_str(display_str, fg='cyan')
+
+    return f"Mem Size: {display_str}"  # Display the selected size
+
+
+
+def get_mem_size(obj) -> tuple:
+    """
+    Get the size of an object as a tuple ( bytes , megabytes )
+    """
+    def _get_mem_size(obj):
+        size = sys.getsizeof(obj)
+        
+        if isinstance(obj, types.GeneratorType):
+            # Generators don't have __sizeof__, so calculate size recursively
+            size += sum(_get_mem_size(item) for item in obj)
+        elif isinstance(obj, dict):
+            size += sum(_get_mem_size(key) + _get_mem_size(value) for key, value in obj.items())
+        elif hasattr(obj, '__dict__'):
+            # For objects with __dict__, include the size of their attributes
+            size += _get_mem_size(obj.__dict__)
+        
+        return size
+
+    size_b = _get_mem_size(obj)
+    size_mb = bytes_to_mb(size_b)
+    
+    return size_b, size_mb
+
+def get_mem_size_breakdown(obj, do_recursive=False) -> dict:
+    """
+    Get a breakdown of the sizes of the properties of an object.
+    """
+
+    size_b, size_mb = get_mem_size(obj) #'name': obj, 'value': get_variable_value(obj)
+    breakdown = { 'name': obj,'type': type(obj).__name__, 'size (B, MB)': f"{size_b} B | {size_mb:.3f}  MB", 'value': get_var_value(obj), }
+    
+    if do_recursive:
+        if isinstance(obj, types.GeneratorType):
+            for i, item in enumerate(obj):
+                breakdown['generator_'+type(item).__name__][i] = get_mem_size_breakdown(item)
+        elif isinstance(obj, dict):
+            for key, value in obj.items():
+                if key != 'stat':
+                    breakdown[f'[{key}]'] = get_mem_size_breakdown(value)
+        elif hasattr(obj, '__dict__'):
+            breakdown['vars'] = {}
+            for key, value in obj.__dict__.items():
+                if key != 'stat':
+                    breakdown['vars'][f'[{key}]'] = get_mem_size_breakdown(value)
+    return breakdown
+
+def save_obj_graph_img(obj):
+    # Generate and save a graph of objects referencing a specific object
+    graph_filename = f'data/image/obj_graph_{obj.__class__.__name__}.png'
+    objgraph.show_refs([obj], filename=graph_filename)
+    return graph_filename
+
+def take_mem_growth_snapshot():
+    # Take a snapshot of the objects that have grown since the last snapshot
+    growth_info = objgraph.show_growth()
+    if growth_info:
+        # Convert the growth information to a dictionary
+        growth_dict = {}
+        for line in growth_info.split('\n'):
+            if line.strip():  # Skip empty lines
+                parts = line.split()
+                obj_type = parts[0]
+                prev_count = int(parts[1])
+                growth_count = int(parts[2])
+                growth_dict[obj_type] = {'prev_count': prev_count, 'growth_count': growth_count}
+        #print(format_table(growth_dict))
+        return growth_dict
+
+
+
+
+

mew_log/profile_utils.py

@@ -0,0 +1,194 @@
+import time
+
+from ..mew_log.ansi_utils import ansi_color_str
+from ..mew_log.attr_utils import get_prev_caller_info
+from ..mew_log.log_utils import log_info, LogSpinner
+from ..mew_log.table_utils import format_table
+
+
+time_color = ''
+
+# helper funcs
+class ProfileSection:
+    Registry = {}  # Class Variable
+
+    def __init__(self, newMsg=None, enable=True, do_print=False):
+        self.msg = newMsg if newMsg else get_prev_caller_info()
+        self.enable = enable
+        self.startTime = 0.0
+        self.endTime = 0.0
+        self.elapsedTime = 0.0
+        self.totalTime = 0.0
+        self.avgTime = 0.0
+        self.numCalls = 0
+        self.do_print = do_print
+        if self.msg in ProfileSection.Registry:
+            p = ProfileSection.Registry[self.msg]
+            self.__dict__ = p.__dict__
+            self.numCalls += 1
+        else:
+            self.numCalls += 1
+
+        if (self.enable):
+            self.start()
+
+    def __del__(self):
+        if (self.enable):
+            self.stop()
+
+    def __enter__(self):
+        # if self.enable:
+        self.start()
+
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        # if self.enable:
+        self.stop()
+
+    def start(self):
+        self.startTime = time.time()
+        # if self.do_print : log_info(str(self))
+
+    def stop(self):
+        self.endTime = time.time()
+        self.update_stats()
+        stopMsg = str(self)
+
+        p = create_or_get_profile(self.msg)
+        p.__dict__.update(self.__dict__)
+        if self.do_print: log_info(str(p))
+
+        # st.toast(stopMsg)
+        return stopMsg
+
+    def update_stats(self):
+        self.elapsedTime = self.endTime - self.startTime
+        self.totalTime += self.elapsedTime
+        self.avgTime = self.totalTime / float(self.numCalls)
+
+    def __str__(self, use_color=True):
+        msg_str = self.msg #ansi_color_str(self.msg, fg='green')  # Green color for message
+        elapsed_time_str = make_time_str('elapsed', self.elapsedTime)
+        total_time_str = make_time_str('total', self.totalTime)
+        avg_time_str = make_time_str('avg', self.avgTime)
+        calls_str = f'calls={self.numCalls}'
+        if use_color:
+            elapsed_time_str = ansi_color_str(elapsed_time_str, fg='bright_cyan')  # Cyan color for elapsed time
+            total_time_str = ansi_color_str(total_time_str, fg='bright_cyan')  # Cyan color for total time
+            avg_time_str = ansi_color_str(avg_time_str, fg='bright_cyan')  # Cyan color for average time
+            calls_str = ansi_color_str(calls_str, fg='yellow')  # Cyan color for calls information
+
+        return f"{msg_str} ~ Elapsed Time: {elapsed_time_str} | Total Time: {total_time_str} | Avg Time: {avg_time_str} | {calls_str}"
+
+
+from functools import wraps
+from threading import Thread
+from rich.progress import Progress, BarColumn, TextColumn, TimeRemainingColumn, TaskProgressColumn
+from rich.console import Console
+from rich.style import Style
+from rich.panel import Panel
+
+
+def profile_function(func):
+    """
+    Decorator to track the progress of a function with a spinner.
+    The decorated function should not require explicit progress updates.
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        profile_section = ProfileSection(func.__name__, enable=True, do_print=False)
+        console = Console()
+        with LogSpinner(func.__name__):
+            with profile_section:
+                result = func(*args, **kwargs)
+
+        #profile_section.stop()
+        # Display timing information using rich
+        panel = Panel.fit(
+            f"[bold green]{profile_section.msg}[/bold green]\n"
+            f"[cyan]Elapsed Time:[/cyan] {make_time_str('elapsed', profile_section.elapsedTime)}\n"
+            f"[cyan]Total Time:[/cyan] {make_time_str('total', profile_section.totalTime)}\n"
+            f"[cyan]Avg Time:[/cyan] {make_time_str('avg', profile_section.avgTime)}\n"
+            f"[yellow]Calls:[/yellow] {profile_section.numCalls}",
+            title="Profile Report",
+            border_style="bright_blue"
+        )
+        console.print(panel)
+        #print(str(profile_section))
+
+
+        return result
+    return wrapper
+
+
+def make_time_str(msg, value):
+    # do something fancy
+    value, time_unit = (value / 60, 'min') if value >= 60 else (value * 1000, 'ms') if value < 0.01 else (value, 's')
+    return f"{msg}={int(value) if value % 1 == 0 else value:.2f} {time_unit}"
+
+
+def create_or_get_profile(key, enable=False, do_print=False):
+    if key not in ProfileSection.Registry:
+        ProfileSection.Registry[key] = ProfileSection(key, enable, do_print)
+    return ProfileSection.Registry[key]
+
+
+def profile_start(msg, enable=True, do_print=False):
+    p = create_or_get_profile(msg, enable, do_print)
+    if not enable: p.start()
+
+
+def profile_stop(msg):
+    if key in ProfileSection.Registry:
+        create_or_get_profile(msg).stop()
+
+
+def get_profile_registry():
+    return ProfileSection.Registry
+
+from loguru import logger
+
+
+def get_profile_reports():
+    reports = [value for value in ProfileSection.Registry.values()]
+    reports.sort(key=lambda x: (x.totalTime, x.avgTime), reverse=True)
+    return reports
+    
+def log_profile_registry(use_color=True):
+    formatted_output = format_profile_registry(use_color=use_color)
+    print(formatted_output)
+    #logger.info(formatted_output)
+    #return formatted_output
+
+
+
+def allow_curly_braces(original_string):
+    escaped_string = original_string.replace("{", "{{").replace("}", "}}")
+    #print("Escaped String:", escaped_string)  # Debug output
+    return escaped_string
+
+def format_profile_registry(use_color=True):
+    reports = get_profile_reports()
+    out_str = []
+
+    out_str.append('=== Profile Reports ===\n')
+
+    for report in reports:
+        out_str.append(str(report)+'\n')
+
+    out_str.append('===>_<===\n')
+    return ''.join(out_str)
+
+
+# import random
+
+# def do_this(y):
+#     p = ProfileSection("do_this", True) #only way to use the auto destruct method
+#     x = random.randint(0, (y+1)*2)
+#     print(f'do_this: {x} - {y}')
+
+# for index in range(1000):
+#     do_this(index)
+
+# log_profile_registry()

mew_log/table_utils.py

@@ -0,0 +1,174 @@
+from tabulate import tabulate
+
+from ..mew_log.ansi_utils import ansi_color_str
+from ..mew_log.attr_utils import get_class_attributes
+
+
+def transpose_dict(d):
+    return {k: [dic[k] for dic in d.values()] for k in d.keys()}
+
+
+def format_data_as_table(data, headers=None, tablefmt='grid', **kwargs):
+    if kwargs.get('use_color', False):
+        # Apply color to headers if applicable
+        if headers:
+            headers = [ansi_color_str(header, fg="yellow") for header in headers]
+
+
+    return tabulate(data, headers=headers, tablefmt=tablefmt)
+
+def format_property(name, data, headers=None, tablefmt='simple_grid', use_color=False):
+    colored_name = ansi_color_str(f"===[{name}]<{type(data).__name__}>===", fg="yellow") if use_color else f"===[{name}]<{type(data).__name__}>==="
+    return f'{colored_name}\n{format_table(data, headers, tablefmt, use_color=use_color)}'
+
+
+
+# note: pretty sure transpose doesn't work correctly
+def format_table(data, headers=None, tablefmt='simple_grid', **kwargs):
+    if not data:
+        return ""
+    if isinstance(data, dict):
+        return format_dict_as_table(data, headers, tablefmt, **kwargs)
+    elif isinstance(data, (list, set)):
+        # transpose = list(zip(*data))
+        return format_list_as_table(data, headers, tablefmt, **kwargs)
+    elif hasattr(data, '__dict__'):
+        return format_obj_as_table(data, headers, tablefmt, **kwargs)
+    else:
+        use_color = kwargs.get('use_color', False)
+        if use_color:
+            return ansi_color_str(str(data), fg='bright_yellow')
+        else:
+            return str(data)
+            
+
+
+def format_list_as_table(data, headers=None, tablefmt='simple', **kwargs):
+    if not headers:
+        headers = ["Index", "Value"] if kwargs.get('show_indexes', False) else []
+
+    if kwargs.get('show_indexes', False):
+        out_dict = {i: item for i, item in enumerate(data)}
+        return format_table(out_dict, headers, tablefmt, **kwargs)
+    else:
+        formatted_str = ansi_color_str(f" | len={len(data)} | ", fg='bright_cyan') if kwargs.get('use_color', False) else f" | len={len(data)} | "
+        formatted_str += "["
+        for i, item in enumerate(data):
+            formatted_str += format_table(item, [], tablefmt, **kwargs)
+            if i < len(data) - 1: formatted_str += kwargs.get('delimeter', ', ')
+        formatted_str += "]"
+        return formatted_str
+
+
+def format_dict_as_table(data, headers=None, tablefmt='simple_grid', **kwargs):
+    if  kwargs.get('transpose', False):
+        if not headers:
+            headers =list(data.keys())
+        #Transpose the dictionary: each key-value pair becomes a column
+        transposed_data = [list(value) for key, value in zip(list(data.keys()), zip(*data.items()))]
+        #intended for values of the same lenth
+        #transposed_data = [headers] + [list(row) for row in zip(list(data.values()))]
+        return format_data_as_table(transposed_data, headers=headers, tablefmt=tablefmt)
+    else:
+        if not headers:
+            headers = ["Key", "Value"]
+
+        # Convert the dictionary into a list of lists
+        table_data = [[key, format_table(value, [], 'simple',**kwargs)] for key, value in data.items() if value is not None]
+
+        # Format the table
+        return format_data_as_table(table_data, headers=headers, tablefmt=tablefmt)
+
+
+def format_obj_as_table(data, headers=None, tablefmt='fancy_grid', **kwargs):
+    verbose = kwargs.get('verbose', True)
+    fancy = kwargs.get('fancy', True)
+    use_color = kwargs.get('use_color', True)
+    
+    attributes_dict = get_class_attributes(data, verbose=verbose)
+    class_name = data.__class__.__name__
+    variables = [*attributes_dict['variables'].values()]
+    methods = [*attributes_dict['methods'].values()]
+    # Check if headers are provided, if not, construct them
+    if not headers:
+        headers = [class_name]
+        if variables:
+            headers.append('variables')
+        if methods:
+            headers.append('methods')
+
+    # Initialize an empty list to store the formatted table data
+    table_data = []
+
+    # formatted_vars = []
+    # for v in variables:
+    #     format_v = format_arg(v, use_color=use_color, fancy=fancy)
+    #     formatted_vars.append(format_v)
+
+    # Add variables and methods data to the table data
+    table_data.append([format_table(variables, ['variables'], 'simple', **kwargs) if variables else None,
+                       format_table(methods, ['methods'], 'simple', **kwargs) if methods else None])
+
+    table_data = list(zip(*table_data))
+
+    # Return the formatted table
+    return format_data_as_table(table_data, headers, tablefmt, **kwargs)
+
+
+def print_table(msg, data, headers=None, tablefmt='fancy_grid'):
+    print(f'==={msg}==>\n{format_table(data, headers, tablefmt)}')
+
+
+def format_square_layout(data):
+    if isinstance(data, (list, set)):
+        result_count = len(data)
+        rows, columns = calc_best_square(result_count)
+        table_data = [data[i:i + columns] for i in range(0, len(data), columns)]
+        return format_table(table_data)
+    elif isinstance(data, dict):
+        items = [(k, v) for k, v in data.items()]
+        result_count = len(items)
+        rows, columns = calc_best_square(result_count)
+        table_data = [items[i:i + columns] for i in range(0, len(items), columns)]
+        return format_table(table_data)
+    elif hasattr(data, '__dict__'):
+        items = [(k, v) for k, v in data.__dict__.items()]
+        result_count = len(items)
+        rows, columns = calc_best_square(result_count)
+        table_data = [items[i:i + columns] for i in range(0, len(items), columns)]
+        return format_table(table_data)
+    else:
+        return format_table(data)
+
+
+def print_square_layout(msg, data):
+    print(f'==={msg}==>\n{format_square_layout(data)}')
+
+
+def print_as_square(strings):
+    # Calculate the number of strings in the input list
+    result_count = len(strings)
+
+    # Calculate the best square layout dimensions based on the result count
+    rows, columns = calc_best_square(result_count)
+
+    # Create a grid with empty strings filled in for each cell
+    grid = [[' ' for _ in range(columns)] for _ in range(rows)]
+
+    # Iterate over the strings and populate the grid with them
+    for i, string in enumerate(strings):
+        # Calculate the row and column index for the current string
+        row = i // columns
+        col = i % columns
+        # Ensure the row and column indices are within the valid range of the grid dimensions
+        if row < rows and col < columns:
+            # Place the string in the corresponding cell of the grid
+            grid[row][col] = string
+
+    # Determine the maximum width of each column in the grid
+    max_widths = [max(len(cell) for cell in row) for row in grid]
+
+    # Print the grid, ensuring each cell is left-aligned and padded to its maximum width
+    for row in grid:
+        print(' '.join(cell.ljust(width) for cell, width in zip(row, max_widths)))
+