utils.py

#!/usr/bin/env python

import argparse
import ast
import boto3
import calendar
import colorama
import csv
import datetime
import inspect
import json
import lorem
import math
import operator
import os
import platform
import random
import socket
import sys
import textwrap
import typing
import tomllib
import uuid
import yaml

from colorama import init as colorama_init
from colorama import Fore
from colorama import Style
from datetime import date, datetime, timezone, timedelta
from inspect import getframeinfo, stack
from io import StringIO
from rich.console import Console
from typing import Any, List, TypeVar, Tuple, get_type_hints
from yaml.loader import SafeLoader, FullLoader, Loader, BaseLoader


# Initilize
console = Console()

colorama_init()
if platform.system() == 'Windows':
    from colorama import just_fix_windows_console
    just_fix_windows_console()


# Config
def get_config_file():
    """Returns content of ./cocnfig.toml file if exist"""
    if 'CFG_UTILS' in globals():
        return globals()['CFG_UTILS']

    res = {}
    path = cur_dir()['Path']

    # look for cfg in possible paths
    cfg_paths = [
        '',        # current path
        '..',      # one path above
        '../cfg',
        '../..'
        '../../cfg'
    ]

    for cfg_path in cfg_paths:
        config = f'{path}/{cfg_path}/config.toml'
        if os.path.isfile(config):
            with open(config, "rb") as f:
                res = tomllib.load(f)
                globals()['CFG_UTILS'] = res

    return res


def get_config(string: str | None = None):
    """Returns config file or config key

    Args:
        key (str): config key, default None

    Retunrs:
        if key is None returns config map dict of {key: value, ...}
        if key is not None return in below order:
            1. global varibale
            2. value of key in env vars
            3. value of key in config file
            4. default as defined in cMap[key]
    """
    CFG_UTILS = get_config_file()

    cMap = {
        'CACHE_PATH': None,
        'LOG_CALLER': None,
        'LOG_DT': None,
        'LOG_DT_FMT': '%d-%b-%Y %H:%M:%S',
        'LOGLEVEL': 'WARNING',
        'LOG_META_COLOR': 'iGray',
        'UTC': None,
        'COLORED': True,
        'INDENT': 4,
        'IND_SPC': ' ' * 4,
        'LEAD': 3,
        'REP': '=',
        'WIDTH': 90,
        'UNITTEST': None,
    }

    globals_var = globals()

    res = {}
    # config order is global, env var, config file & default or None
    for key in cMap.keys():
        # ex: 'INDENT': os.environ.get('INDENT', CFG_UTILS.get('INDENT', 4),
        res[key] = os.environ.get(key, CFG_UTILS.get(key, cMap[key]))

        # env var should be converted to int
        if isinstance(cMap[key], int):
            res[key] = int(res[key])

        if key in globals_var:
            res[key] = globals_var[key]

    res['IND_SPC'] = ' ' * res['INDENT']  # depends on ['INDENT']

    return res if string is None else res.get(string, '')


# Log Management
def cur_log():
    """Returns current log level"""
    CFG_UTILS = get_config_file()
    if 'LOGLEVEL' in globals():
        return globals()['LOGLEVEL']
    else:
        return os.environ.get('LOGLEVEL', CFG_UTILS.get('LOGLEVEL', 'WARNING')).upper()


def isLog(level: str) -> bool | None:
    """Returns True, Flase or None (invalid level) for given level"""
    LOGLEVEL = cur_log()
    level = level.lower()

    levels = {
        'trace':    LOGLEVEL in [ 'TRACE' ],
        'debug':    LOGLEVEL in [ 'TRACE', 'DEBUG' ],
        'info':     LOGLEVEL in [ 'TRACE', 'DEBUG', 'INFO' ],
        'success':  LOGLEVEL in [ 'TRACE', 'DEBUG', 'INFO', 'SUCCESS', ],
        'warning':  LOGLEVEL in [ 'TRACE', 'DEBUG', 'INFO', 'SUCCESS', 'WARN', 'WARNING' ],
        'error':    LOGLEVEL in [ 'TRACE', 'DEBUG', 'INFO', 'SUCCESS', 'WARN', 'WARNING', 'ERROR' ],
        'critical': LOGLEVEL in [ 'TRACE', 'DEBUG', 'INFO', 'SUCCESS', 'WARN', 'WARNING', 'ERROR', 'CRITICAL' ],
    }
    return levels.get(level)


def log_levels():
    """Returns list of log levels"""
    return [
        'TRACE',
        'DEBUG',
        'INFO',
        'WARNING',
        'ERROR',
        'CRITICAL',
    ]


def log_functions():
    """Returns list of log logging functions"""
    return [
        'trace',
        'debug',
        'info',
        'success',
        'warning',
        'error',
        'abort',
        'sysExit',
    ]


def log_fmt(caller: object):
    """Returns string from caller object of <class 'inspect.Traceback'>

    Args:
        caller (object): should be getframeinfo(stack()[1][0])

    Returns (str):
        [datetime :: ] [File caller.filename :: ] L#{caller.lineno} :: 
    """
    res = ''
    if get_config('LOG_DT'):
        res += f' {get_dt_log()} :: '

    if get_config('LOG_CALLER'):
        res += f'File {caller.filename} :: ' # type: ignore

    res += f'L#{caller.lineno} ::' # type: ignore

    if get_config('LOG_META_COLOR'):
        res = iColor(res, get_config('LOG_META_COLOR'))

    return res


def print_stderr(*args, **kwargs):
    """Prints to sys.stderr. Use it like print()"""
    print(*args, file=sys.stderr, **kwargs)


def trace(*args, **kwargs):
    """Prints csv TRACE log to sys.stderr. Use it like print()"""
    if not isTrace():
        return
    caller = getframeinfo(stack()[1][0])
    if isLog('trace'):
        print(iColor('TRACE:'.ljust(maxlen(log_functions()) + 1), 'iBlack'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)


def debug(*args, **kwargs):
    """Prints csv DEBUG log to sys.stderr. Use it like print()"""
    if not isDebug():
        return
    caller = getframeinfo(stack()[1][0])
    if isLog('debug'):
        print(iColor('DEBUG:'.ljust(maxlen(log_functions()) + 1), 'iYellow'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)


def info(*args, **kwargs):
    """Prints csv INFO log to sys.stderr. Use it like print()"""
    caller = getframeinfo(stack()[1][0])
    if isLog('info'):
        print(iColor('INFO:'.ljust(maxlen(log_functions()) + 1), 'iGreen'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)


def success(*args, **kwargs):
    """Prints csv SUCCESS log to sys.stderr. Use it like print()"""
    caller = getframeinfo(stack()[1][0])
    if isLog('success'):
        print(iColor('SUCCESS:'.ljust(maxlen(log_functions()) + 1), 'iGreen'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)


def warning(*args, **kwargs):
    """Prints csv WARNING log to sys.stderr. Use it like print()"""
    caller = getframeinfo(stack()[1][0])
    if isLog('warning'):
        print(iColor('WARNING:'.ljust(maxlen(log_functions()) + 1), 'iRed'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)


def error(*args, **kwargs):
    """Prints csv ERROR log to sys.stderr. Use it like print()"""
    caller = getframeinfo(stack()[1][0])
    if isLog('error'):
        print(iColor('ERROR:'.ljust(maxlen(log_functions()) + 1), 'iRed'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)


def abort(*args, **kwargs):
    """Prints csv ABORT log to sys.stderr. Use it like print()"""
    caller = getframeinfo(stack()[1][0])
    if isLog('critical'):
        print(iColor('ABORT:'.ljust(maxlen(log_functions()) + 1), 'iRed'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)
    if get_config('UNITTEST'):
        return
    sys.exit(1)


def sysExit(*args, **kwargs):
    """Prints csv EXIT log to sys.stderr. Use it like print()"""
    caller = getframeinfo(stack()[1][0])
    if isLog('critical'):
        print(iColor('EXIT:'.ljust(maxlen(log_functions()) + 1), 'iGreen'),
              log_fmt(caller),
              *args, file=sys.stderr, **kwargs)
    if get_config('UNITTEST'):
        return
    sys.exit(0)


def get_caller_lineno():
    """Returns caller line number"""
    frame, _, lineno, _, _, _ = inspect.stack()[1]
    return lineno


def isDebug():
    """Returns True is log level is DEBUG"""
    return isLog('debug')


def isTrace():
    """Returns True is log level is TRACE"""
    return isLog('trace')


def isFile(file):
    """Returns True if 'file' is file"""
    return os.path.isfile(file)


def isFolder(path):
    """Returns True if 'path' exist"""
    return os.path.exists(path)


def whichLog():
    """Returns current log"""
    return cur_log()


def whichPlatform():
    """Returns system platform"""
    return platform.system()


# API
def api_req(statusCode: int = 200, message=None, data=None):
    """Returns api request object of data

    Args:
        statusCode (int): any valid http status code {2xx, 3xx, 4xx, 5xx}
        message (any): will add to body.Message
        data (any): will be added to body.Data

    """
    api_data = {
        'Message': message,
        'Data': data
    }

    return {
        "statusCode": statusCode,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": json.dumps(api_data, default=str)
    }


def api_res(data, full=False):
    """Returns json object of api response"""
    res = {}

    for key in data.keys():
        try:
            res[key] = json.loads(data[key])
        except Exception as err:
            res[key] = data[key]

    if not full and 'body' in res and 'Data' in res['body']:
        return res['body']['Data']

    return res


def isVenv():
    """Returns True if VIRTUAL_ENV is an env var"""
    return 'VIRTUAL_ENV' in os.environ


def isLocal(): return 'bamdad' in cur_dir()['Path']


def get_host_data():
    """Returns dict of FQDN, Host IP & Host Name"""
    return {
            'fqdn': socket.getfqdn(),
            'hostip': socket.gethostbyname(socket.gethostname()),
            'hostname': socket.gethostname(),
        }


# Folder Management
def cur_dir():
    """Returns dict of current directory & runing file info

    Return:
        {
            CWD (str): Current working directory
            Path (str): Current Path
            File (str): Current file who called function
            FileName (str): Current filename
            Name (str): Current filename name - without ext
            Platform (str): Current platform
        }
    """
    caller_frame = inspect.stack()[1]
    file = caller_frame.filename
    fullPath = os.path.realpath(file)
    path, filename = os.path.split(fullPath)
    res = {
        'CWD': os.getcwd(),
        'Path': path,
        'File': file,
        'FileName': filename,
        'Name': os.path.splitext(filename)[0],
        'Platform': platform.system(),
    }
    for k in res.keys():
        res[k] = uni_path(res[k])
    return res


def cur_file(path=None, prefix=None):
    """Returns current file with given 'path' & 'prefix'"""
    path = f'{path}/' if path else ''
    prefix = f'{prefix}-' if prefix else ''
    caller_frame = inspect.stack()[1]
    file = caller_frame.filename
    fullPath = os.path.realpath(file)
    iPath, filename = os.path.split(fullPath)
    res = os.path.splitext(filename)[0]

    return f'{path}{prefix}{res}'


def dot_path(path):
    """Returns linux path"""
    return path.replace('\\', '/').replace('/./', '/').replace('/', '.')


def mk_folder(path):
    """Make folder if not exists"""
    if not os.path.exists(path):
        os.makedirs(path)


def rm_empty_folder(path):
    """Remove folder if exists"""
    if not os.path.exists(path):
        return
    folders = list(os.walk(path))
    for folder in folders:
        # print ('all folder ->', folder)
        if not folder[2]:
            os.rmdir(folder[0])


def uni_path(path=''):
    """Returns linux path as universal path for any of OSX, Linux & Windows OS"""
    return path.replace('\\', '/').replace('/./', '/')


def clean_path(path):
    """Returns removed '../' from given absolute path"""
    path = uni_path(path)
    paths = path.split('/')

    while '..' in paths:
        if paths[0] == '..':
            break
        for i, path in enumerate(paths):
            trace(f'{i} : {path}')
            if path == '..':
                trace(f'{i} : {path} in path! pop({paths[i]})')
                trace(f'{i} : {path} in path! pop({paths[i-1]})')

                paths.pop(i)
                paths.pop(i - 1)

                trace(f"new path: {'/'.join(paths)}")

    res = '/'.join(paths)

    return res


# Print util
def fmt_aws_acc(accoount_id):
    """Returns nnnn-nnnn-nnnn format"""
    acc = f'{accoount_id:012}'
    return f'{acc[0:4]}-{acc[4:8]}-{acc[8:12]}'


def terminal_size():
    """Returns dict of terminal columns & lines size

    {
        'columns': int,
        'lines': int
    }
    """
    ts = os.get_terminal_size()
    return {
        'columns': ts.columns,
        'lines': ts.lines
    }


def blue_green(lstr, rstr, sep=' ', lcol='Blue', rcol='Green'):
    """Returns blue lstr + sep + green rstr """
    return iColor(str(lstr), lcol) + sep + iColor(str(rstr), rcol)


def blue_green_dict_print(data: dict, sep=' ', lcol='Blue', rcol='Green'):
    """Prints dict items in two colors"""
    width = maxlen(data.keys())
    for key in data.keys():
        print(blue_green(key.ljust(width),
              data[key], sep=sep, lcol=lcol, rcol=rcol))


def round_down(number: float, decimals: int = 0) -> float:
    """Rounds a number down to the given number of decimals."""
    factor = 10 ** decimals
    return math.floor(number * factor) / factor


def round_up(number: float, decimals: int = 0) -> float:
    """Rounds a number up to the given number of decimals."""
    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


def justc(string: int | str, width: int = 3, trunk: bool = False) -> str:
    """Centers or truncates a string to a given width."""
    string = str(string)

    if len(string) <= width:
        return string.center(width)

    if trunk:
        return textwrap.shorten(string, width - 3) + "..."

    return string


def justl(string: int | str, width: int = 3, trunk: bool = False) -> str:
    """Left aligns or truncates a string to a given width."""
    string = str(string)

    if len(string) <= width:
        return string

    if trunk:
        return textwrap.shorten(string, width - 3) + "..."

    padding = width - len(string)
    return string + " " * padding


def justr(string: int | str, width: int = 3, trunk: bool = False) -> str:
    """Right aligns or truncates a string to a given width."""
    string = str(string)

    if len(string) <= width:
        return string + " " * (width - len(string))

    if trunk:
        return textwrap.shorten(string, width - 3) + "..."

    padding = width - len(string)
    return " " * padding + string


def maxlen(iVars=[]):
    """Returns maximum length of list elements"""
    res = 0
    for var in iVars:
        res = max([len(var), res])
    return res


def ndigits(string, width=3):
    """Returns zero leading string or num"""
    return '0' * (width - len(str(string))) + str(string) if len(str(string)) < width else str(string)


def progress_print(counter=8, indent=8, limit=88, char='.'):
    if counter == indent:
        sys.stdout.write(' ' * indent)
    counter += 1
    if counter > limit:
        print()
        counter = indent
    else:
        sys.stdout.write('.')
    sys.stdout.flush()
    return counter


def ppwide(string, rep: str | None = None, lead: int | None = None, width: int | None = None):
    """Prints ~~~ Title ~~~~~ to desired 'width' 

    Args:
        string (str | int): input string. If is single character then output is its replication.
        rep (str | None): character to replicate to the desired width, default '#'
        lead (int | None): leading character length with value of rep, default 3 
        width (int | None): desired width, default 90

    Returns:
        Returns string followed by a space and desired replication character to desired space
    """

    if string is None:
        string = get_config('REP')
    if rep is None:
        rep = get_config('REP')
    if lead is None:
        lead = get_config('LEAD')
    if lead > 0 and len(string) > 0:
        string = f'{rep*lead} {string}'
    if width is None:
        width = get_config('WIDTH')

    print(to_len(string, rep=rep, width=width))


def to_space(string, width=3):
    """Returns left spaced string to given width"""
    return ' ' * (width - len(str(string))) + str(string) if len(str(string)) < width else str(string)


def to_len(string: str, **kwargs) -> str:
    """Returns string followed by a space and dashed to desired space

    Args:
        string (str | int): input string. If is single character then output is its replication.

    **kwargs:
        rep (str): character to replicate to the desired width. Default '-'.
        width (int): desired width. Default 90.

    Returns:
        Returns string followed by a space and desired replication character to desired space
    """
    string = str(string)
    rep = kwargs.get('rep', get_config('REP'))
    width = kwargs.get('width', get_config('WIDTH'))
    spc = ' '

    if len(str(string)) == 1:
        rep = spc = string

    return f"{str(string)}{spc}{rep*(width-len(str(string))-1)}" if len(string) < width else string


def wline(rep='-', width: int | None = None):
    """Prints wide line filled with 'rep' to given 'width'"""
    if width is None:
        width = get_config('WIDTH')
    ppwide(string=rep, rep=rep, lead=0, width=width)

# Colors


def colors():
    """Returns list of colors"""
    return [
        'Black',    # Black
        'Gray',     # Gray
        'Red',      # Red
        'Green',    # Green
        'Yellow',   # Yellow
        'Blue',     # Blue
        'Magenta',  # Magenta
        'Cyan',     # Cyan
        'White',    # White

        'iBlack',   # Light Black
        'iGray',    # Light Gray
        'iRed',     # Light Red
        'iGreen',   # Light Green
        'iYellow',  # Light Yellow
        'iBlue',    # Light Blue
        'iMagenta',  # Light Magenta
        'iCyan',    # Light Cyan
        'iWhite',   # Light White
    ]


def iColors():
    """Returns list of extended colors"""
    return [
        'LIGHTBLACK_EX',
        'LIGHTRED_EX',
        'LIGHTGREEN_EX',
        'LIGHTYELLOW_EX',
        'LIGHTBLUE_EX',
        'LIGHTMAGENTA_EX',
        'LIGHTCYAN_EX',
        'LIGHTWHITE_EX',
    ]


def cStyles():
    """Returns list of styles"""
    return [
        'DIM',
        'NORMAL',
        'BRIGHT',
    ]


def iColor(string, color, cStyle: str = 'Normal', trace=False):
    """Returns color formated string to use in print()

    Args:
        string (str | int): input string
        color (str): one of 'Black' 'Gray' 'Red' 'Green' 'Yellow' 'Blue' 'Magenta' 'Cyan' 'White'
             'iBlack' 'iGray' 'iRed' 'iGreen' 'iYellow' 'iBlue' 'iMagenta' 'iCyan' 'iWhite'
        cStyle (str): one of 'DIM' 'NORMAL' 'BRIGHT'. Default 'NORMAL'

    Caution:
        Do not use log like trace or error here since it causes infinite loop
    """
    if not get_config('COLORED'):
        return string

    iLocals = locals()
    ln = get_caller_lineno() - 14  # go back to the function name
    string = str(string)

    cTitle = color.title()
    if cTitle[0:1] == 'I':
        cTitle = color[0:1].lower() + color[1:].title()
    cTitle = cTitle.replace('Gray', 'Black')
    cTitle = cTitle.replace('iGray', 'iBlack')

    sColor = None
    paint = None
    nc = getattr(Style, 'RESET_ALL')
    if cTitle[0:1] == 'i':
        sColor = f'LIGHT{cTitle[1:].upper()}_EX'
        if sColor in iColors():
            paint = getattr(Fore, sColor)
    elif cTitle in colors():
        paint = getattr(Fore, cTitle.upper())

    styles = ['DIM', 'NORMAL', 'BRIGHT']
    if cStyle.upper() in styles:
        sString = cStyle.title()
    else:
        sString = 'NORMAL'  # set to default for invalid entry
    cStyle = getattr(Style, cStyle.upper())

    tab = ' ' * 6
    if trace is True:
        caller = getframeinfo(stack()[1][0])
        this = inspect.stack()[0][3]
        if caller.function not in log_functions():
            iStyle = getattr(Style, 'NORMAL')
            iPaint = getattr(Fore, 'YELLOW')
            trace_log = {
                'Color': color,
                'cTitle': cTitle,
                'sColor': sColor,
                'cStyle': sString,
                'paint': paint,
                'string': string,
                'nc': nc,
            }
            print(f'{iPaint}{iStyle}TRACE:{nc} File {caller.filename}, line {caller.lineno}', file=sys.stderr)
            print(tab, f'1. Calling line {ln}: {this}({iLocals})', file=sys.stderr)
            print(tab, f'2. Process: {trace_log}', file=sys.stderr)
            print(tab, f'3. Returns: {paint}{cStyle}{string}{nc}', file=sys.stderr)

    if paint:
        return f"{paint}{cStyle}{string}{nc}"

    return string


def incolor(string, color, cStyle='Normal'):
    """Identical to iColor() for backward compatiblity"""
    return incolor(string, color, cStyle='Normal')


def triStateColor(string, cond=None):
    """Returns in Green, Red or Yellow for True, False or else cond"""
    if cond is True:
        return iColor(string, 'iGreen')
    if cond is False:
        return iColor(string, 'iRed')

    return iColor(string, 'iYellow')


def rStyles():
    """Returns rich styles dict"""
    return {
        '': 'normal',
        'b': 'bold',
        'i': 'italic',
        'l': 'blink',
        'u': 'underline',
    }


def rColors():
    """Returns list of rich colors abbrivations"""
    res = []

    colors = [
        'Black',           # Black
        'Red',             # Red
        'Green',           # Green
        'Yellow',          # Yellow
        'Blue',            # Blue
        'Magenta',         # Magenta
        'Cyan',            # Cyan
        'White',           # White

        'Bright_Black',    # Bright Black
        'Bright_Red',      # Bright Red
        'Bright_Green',    # Bright Green
        'Bright_Yellow',   # Bright Yellow
        'Bright_Blue',     # Bright Blue
        'Bright_Magenta',  # Bright Magenta
        'Bright_Cyan',     # Bright Cyan
        'Bright_White',    # Bright White
    ]

    bright = ''
    for key in rStyles().keys():
        for color in colors:
            res.append(f'{key}{color}')

    return res


def rColor(string, color):
    """Returns rich color only usable with console.print() or rprint

    Arguments:
        string (any): string to paint with color
        color (str): any valid rich color in format of [b|i|l|u]['Bright_']Color

    ---
    #### Valid rich Color is one of:
    Black, Red, Green, Yellow, Blue, Magenta, Cyan, White

    ---
    #### Valid rich Prefix for Color is one of:
    '': 'normal', 'b': 'bold', 'i': 'italic', 'l': 'blink', 'u': 'underline', 
    """
    if not get_config('COLORED'):
        return string

    # styles = ['blink', 'bold', 'italic', 'underline']
    style = ''
    for key, val in rStyles().items():
        if color[0] == key:
            style = val

    if color[0] == color[0].lower():
        color = color[1:]

    if 'Gray' in color:
        color.replace('Gray', 'Black')
    if 'Blue' in color:
        color = 'Dodger_Blue1'
    if 'Yellow' in color:
        color = f'color({11})'
    if 'Magenta' in color:
        color = f'color({13})'

    # if color[0] == 'i':
    #     color = 'Bright_'+color[1:]

    color = color.strip()
    string = f'[{color.lower()} {style}]{string}'

    return string


def rprint(string, color: None | str = None):
    if color is None:
        print(string)
        return

    color = rColor(color)
    console.print(string, color)

# File Management


def rm_file(file):
    """Remove file is exists"""
    if os.path.isfile(file):
        os.remove(file)
    return os.path.isfile(file)


def file_read_lines(file) -> list:
    """Returns list of lines for given file"""
    try:
        with open(file) as f:
            rs = f.readlines()
            res = []
            for r in rs:
                r = r.replace('\r\n', '').replace('\n', '').strip()
                res.append(r)
            return res
    except Exception as err:
        error('utils.file_read_lines, file:', file, err)
    return []


def get_dir(path: str | None):
    """Returns dict of Dirs & Files for path of [start][*][.ext]

    Args:
        path (str): path to search or [start][*][.ext]
    """
    res = {'Path': '', 'Dirs': [], 'Files': [], 'Paths': []}

    if not path:
        path = cur_dir()['Path']

    full_path = clean_path(path)
    paths = full_path.split('/')

    filter = paths[-1]
    paths.pop(-1)
    path = '/'.join(paths)
    res['Path'] = path

    files = os.listdir(path)

    files = [f for f in files if os.path.isfile(path + '/' + f)]
    res['Dirs'] = [d for d in files if os.path.isdir(path + '/' + d)]

    start = end = None
    if filter.startswith('.'):
        debug('.')
        end = filter

    if filter.startswith('*'):
        debug('*')
        filter = filter[1:]
        end = filter

    if '*' in filter[1:]:
        debug('start * end')
        filters = filter.split('*')
        start = filters[0]
        end = filter[-1]

    # filtered files
    for file in files:
        if start and end:
            if file.startswith(start) and file.endswith(end):
                debug('start & end', file)
                res['Files'].append(file)

        elif start:
            if file.startswith(start):
                debug('start', file)
                res['Files'].append(file)

        elif end:
            if file.endswith(end):
                debug('end', file)
                res['Files'].append(file)

    # filtered paths
    for file in res['Files']:
        res['Paths'].append(path + '/' + file)

    return res


def file_append_line(file, line):
    """Append a line to given file"""
    try:
        with open(file, 'a') as f:
            f.write(str(line) + '\n')
            return True
    except Exception as err:
        error('utils.file_append_line, file:',
              file, 'line:', line, 'error:', err)
        return False


def get_file(file):
    """Returns file content"""
    try:
        with open(file, 'r') as f:
            res = f.read()
            return res
    except Exception as err:
        error('utils.get_file, file:', file, 'error:', err)
        return False  # type: ignore


def put_file(file, data):
    """Create or rewite a file with given 'data'"""
    try:
        with open(file, 'w') as f:
            f.write(str(data) + '\n')
            return True
    except Exception as err:
        error('utils.put_file, file:', file, 'data:', data, 'error:', err)
        return False


def get_csv(file):
    """Returns list of lines for given csv file"""
    res = []
    warning('utils.get_csv::file', file)
    try:
        with open(file, newline='') as f:
            rs = csv.reader(f, quoting=csv.QUOTE_ALL)
            for r in rs:
                res.append(r)
            return res
    except Exception as err:
        error('utils.get_csv, file:', file, 'error:', err)
        return []


def put_csv(file, data):
    """Write csv file & fills all missing fields of given list of dicts

    Args:
        file (str):
            csv_file.csv
        data: [
            {key: val, key1: val1, ...}, # each row items
            {key: val, key2: val2, ...}, # each row items
        ]

    Returns True or False
    """
    # Generate All columns list
    columns = []
    for rs in data:
        for key in rs.keys():
            if key not in columns:
                columns.append(key)
    debug('columns', columns)

    try:
        with open(file, 'w', newline='') as f:
            writer = csv.writer(f)
            i = 0
            for rs in data:
                if i == 0:
                    # all columns
                    writer.writerow(columns)
                    trace(rs.keys())
                i += 1
                # Fill missing columns
                rsAll = {}
                for key in columns:
                    rsAll[key] = rs.get(key, '')
                    trace(rsAll.values())
                writer.writerow(rsAll.values())
        return True
    except Exception as err:
        error('utils.put_csv, file:', file, 'error:', err)
        return False


def get_json(file: str):
    """Returns content of of given json file or empty dict if file not exists"""
    try:
        with open(file, 'r') as f:
            res = json.load(f)
        return res
    except Exception as err:
        error('utils.get_json, file:', file, 'error:', err)
        return {}


def put_json(file, data, minify=False):
    """Write json file with & return True if Success"""
    indent = 0 if minify else 4
    try:
        with open(file, 'w') as f:
            json.dump(data, f, indent=indent, default=str, sort_keys=False)
        return True
    except Exception as err:
        error('utils.put_json, file:', file, 'error:', err)
        return False


def get_yaml(file: str):
    """Returns content of yaml file or empty string for failure"""
    try:
        with open(file, 'r') as f:
            res = yaml.safe_load(f)
        return res
    except Exception as err:
        error('utils.get_yaml, file:', file, 'error:', err)
        return ''


class NoAliasDumper(yaml.SafeDumper):
    """Yaml Safe dupmer class"""

    def ignore_aliases(self, data):
        """Ignore aliases"""
        return True


def put_yaml(file, data):
    """Write yaml file with given data"""
    try:
        with open(file, 'w') as f:
            res = yaml.dump(data, f, Dumper=NoAliasDumper)
        return True
    except Exception as err:
        error('utils.put_yaml, file:', file, 'error:', err)
        return False


def pjson(data, indent: int | None = None) -> str:
    """Retuens json dump string of input"""
    if indent is None:
        indent = get_config('INDENT')
    if not data:
        error("'pjson' data is null:", data)
    return json.dumps(data, indent=indent, default=str)


def pyaml(data, indent: int | None = None, sort_keys=False) -> str:
    """Returns yaml dump string of given 'data'"""
    if indent is None:
        indent = get_config('INDENT')
    if not data:
        error("'pyaml' data is null:", data)
    return yaml.dump(data, indent=indent, Dumper=NoAliasDumper, sort_keys=sort_keys)


def ppjson(data):
    """Prints json.dumps of givent jason 'data"""
    if not data:
        warning("'ppjson' data is null:", data)
    print(pjson(data))


def ppyaml(data, indent=4):
    """Prints yaml.dump of givent yaml 'data"""
    if not data:
        warning("'ppyaml' data is null:", data)
    print(pyaml(data, indent=indent))


def printl(char: str, **kwargs) -> None:
    """Prints given input to desired len - see to_len function"""
    print(to_len(char, **kwargs))


def printll(char: str, **kwargs) -> None:
    """Prints empty line & given input to desired len - see to_len function"""
    print()
    printl(char, **kwargs)


# Data Management
def get_uuid():
    """Returns unique uuid4"""
    return uuid.uuid4()


def csv_json(data):
    """Retuen list of given csv data in jason object format - python list format"""
    res = []
    keys = []
    i = 0
    for i, rs in enumerate(data):
        if i == 0:
            keys = rs
            trace(f'keys: {keys}')
        else:
            row = {}
            for key, val in enumerate(rs):
                warning(f'{keys[key]}: {val}')
                row[keys[key]] = val
            res.append(row)
            trace('row:', row)
    return res


def find_between(char, left='(', right=')'):
    """Returns first match between given 'left' and 'right'

    Arguments:
        char (str | list | dict | tuple): input which will be converted to str
        left (str): left match, default '('
        right (str): right match, default ')'

    """
    res = str(char)
    try:
        lIndex = res.index(left) + len(left)
        rIndex = res.index(right, lIndex)
        # Return if exist
        return res[lIndex:rIndex]
    except Exception as err:
        return None


def typeof(obj, check_type: typing.Type[typing.Any] = None):
    """Returns type of given object"""
    obj_type = type(obj).__name__

    if check_type is None:
        return obj_type

    return obj_type == check_type.__name__


def isfloat(string):
    """Returns True if given 'string' is float"""
    try:
        float(string)
        return True
    except Exception as err:
        return False


def isint(string):
    """Returns True if given 'string' is int"""
    try:
        int(string)
        return True
    except Exception as err:
        return False


def uappend(arr, val, sort=False):
    """Returns unique appended 'val' to 'arr'"""
    if val not in arr:
        arr.append(val)

    return arr.sorted() if sort else arr


def sort_dict(myDict: dict = {}):
    """Returns key sorted given dict"""
    myKeys = list(myDict.keys())
    myKeys.sort()
    res = {i: myDict[i] for i in myKeys}
    return res


# Date, Time, Cache & Session
def get_dt() -> str:
    """Returns isoformat datetime in default system timezone"""
    return datetime.now(datetime.now().astimezone().tzinfo).isoformat()


def dt2ts(dt):
    """Returns epoc time isoformat datetime"""
    ts = datetime.fromisoformat(dt)
    info(ts)
    ts = datetime.timestamp(ts)
    ts = int(ts)
    return ts


def get_dt_log() -> str:
    """Returns formated local or utc datetime respctive to config"""
    if get_config('UTC'):
        dt = datetime.now(datetime.now().astimezone().tzinfo)
    else:
        dt = datetime.now(timezone.utc)

    if get_config('LOG_DT_FMT'):
        dt = dt.strftime(get_config('LOG_DT_FMT'))

    return dt


def get_dtutc() -> str:
    """Returns UTC ISO 8601 datetime"""
    return datetime.now(timezone.utc).isoformat()


def get_cur_cal(echo=False):
    """Returns current month calendar or print if 'echo'"""
    res = {}
    dt = get_dt()

    trace(f'{dt}')
    y = dt[0:4]
    m = dt[5:7]
    dd = dt[8:10]
    d = dd[1:] if dd.startswith('0') else dd
    trace(f'{dt} : {y}-{m}-{d}')

    y = int(y)
    m = int(m)
    d = int(d)

    wds = ['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su']
    wdn = datetime.fromisoformat(dt).weekday()
    wd = wds[wdn]
    trace(f'{wdn} : {wd}')

    my_cal = calendar.month(y, m)
    res = {
        'dt': dt,
        'y': y,
        'm': m,
        'd': d,
        'wd': wd,
        'cal': my_cal,
        'cal_fmt': '',
        'dt_short': ''
    }
    my_cal = my_cal.replace('\n', ' \n ')

    iTitle = my_cal.split('\n')[0].strip()
    my_cal = my_cal.replace(iTitle, iColor(iTitle, 'Blue', 'BRIGHT'))
    my_cal = my_cal.replace('Sa Su', iColor('Sa Su', 'Green', 'BRIGHT'))
    trace(repr(my_cal))
    trace(my_cal)

    my_color = 'Blue' if wd not in ['Sa', 'Su'] else 'Green'

    my_cal = my_cal.replace(f' {d} ', iColor(f' {d} ', my_color, 'BRIGHT'))
    my_cal = my_cal.replace(f' {wd} ', iColor(f' {wd} ', my_color, 'BRIGHT'))
    trace(repr(my_cal))
    # https://www.geeksforgeeks.org/how-to-format-date-using-strftime-in-python/
    dt_short = datetime.now(datetime.now().astimezone().tzinfo).strftime(
        '%a %d-%b-%Y %H:%M:%S %Z')

    res['cal_fmt'] = my_cal
    res['dt_short'] = dt_short

    if echo is True:
        print(my_cal)
        print(dt_short)

    return res


def iso8601Time() -> str:
    """Returns UTC ISO 8601 datetime"""
    return datetime.now(timezone.utc).isoformat()


def get_excel_date(date_str: None | str = None):
    """Returns days since 1900-1-1 +2 days to fix excel bug

    Args:
        date_str (None | str): Today if None or format as yyyy-mm-dd
    """
    res = ''
    offset = 2

    today = date.today()
    if date_str:
        date_arr = date_str.split('-')
        year = int(date_arr[0])
        if year == 1900:
            offset = 1

        month = int(date_arr[1])
        day = int(date_arr[2])
        today = date(year, month, day)

    trace('today :', today)

    delta = date(1900, 1, 1)
    trace('delta :', delta)

    # Excel considers 1900 as a leap year because of lotus 1-2-3 bug also 1900-1-1 is day 1 not zero
    res = (today - delta).days + offset  # excel date is days from 1900-1-1 with +2 days or +1 day for 1900

    return res


def get_today():
    """Returns today in yyyy-mm-dd format"""
    return date.today()


def get_tdelta(now_date, **kwargs: dict[str, int]) -> str:
    """Returns timedelta of now_date

    Args:
        days         (int): optional
        seconds      (int): optional
        microseconds (int): optional
        milliseconds (int): optional
        minutes      (int): optional
        hours        (int): optional
        weeks        (int): optional

    Example:
        day=2, hours=6
        hours=-24
    """
    days = kwargs.get('days', 0)
    seconds = kwargs.get('seconds', 0)
    microseconds = kwargs.get('microseconds', 0)
    milliseconds = kwargs.get('milliseconds', 0)
    minutes = kwargs.get('minutes', 0)
    hours = kwargs.get('hours', 0)
    weeks = kwargs.get('weeks', 0)

    try:
        new_date = datetime.fromisoformat(now_date) + timedelta(
            days=days,  # type: ignore
            seconds=seconds,  # type: ignore
            microseconds=microseconds,  # type: ignore
            milliseconds=milliseconds,  # type: ignore
            minutes=minutes,  # type: ignore
            hours=hours,  # type: ignore
            weeks=weeks  # type: ignore
        )
        return new_date.isoformat()
    except Exception as err:
        error('utils.get_tdelta', err)
        return now_date


def safe_sess_name(name, size=20):
    """Returns session safe name for AWS STS session name"""
    res = name
    size -= 1
    chars_filter = ' :~`!#$%^&*()_;:"\\|][}{<>?}' + "'"
    unsafe_chars = [*chars_filter]
    unsafe_chars.append('---')
    unsafe_chars.append('--')

    for c in unsafe_chars:
        res = res.replace(c, '-')
        trace(f'{justr(name, 50)} :: sess: {res[0:size]}')
    return res[0:size]


def file_mtime(file):
    """Returns file modified time or None if file not exists"""
    if os.path.isfile(file):
        return os.path.getmtime(file)
    warning('utils.file_mtime invalid path:', file)
    return None


def file_mtime_after(file, ts):
    """Returns True if file modified timestamp is after 'ts'"""
    if os.path.isfile(file):
        fts = os.path.getmtime(file)
        if fts > float(ts):
            return True
        if fts < float(ts):
            return False
    warning('utils.file_mtime_after invalid path:', file)
    return False


def file_mtime_before(file, ts):
    """Returns True if file modified timestamp is before 'ts'"""
    if os.path.isfile(file):
        fts = os.path.getmtime(file)
        if fts < float(ts):
            return True
        if fts > float(ts):
            return False
    warning('utils.file_mtime_before invalid path:', file)
    return False


def get_ts():
    """Returns datetime timestamp with 6 deciaml points"""
    return float(format(datetime.timestamp(datetime.now()), '.6f'))


def fmt_ts(ts, digits=6):
    """Returns formated timestamp with 'digits' deciaml points"""
    return float(format(ts, f'.{digits}f'))


def rand(start=1, stop=1, step=1):
    """Returns random number

    Arguuments:
        start(int): start number, default 1
        end(int): end number, default 1
        step(int): step number to increment start to <= end, default 1

    Usage: 
        rand(start)
        rand((start, stop)
        rand((start, stop, step)
    """
    if stop == 1 and start != 1:
        stop = start
    return random.randrange(start=start, stop=stop, step=step)


def took_ts(ts):
    """Returns diff of current timestamp and given 'ts' with 6 decimal points"""
    return float(format(get_ts() - ts, '.6f'))


def took_ts_ms(ts):
    """Returns diff of current timestamp and given 'ts' with 3 decimal points"""
    return float(format((get_ts() - ts) * 1000, '.3f'))


def took_ts_hms(ts):
    """Returns HH:MM:SS.6f format timedelata of current timestamp & given 'ts'"""
    return str(timedelta(seconds=get_ts() - ts))


def cache_file(cName):
    """Returns cache file name for given name which should be filename safe"""
    cPath = get_config('CACHE_PATH') if get_config('CACHE_PATH') else '__cache__'
    cPath = cur_dir()['Path'] + '/' + cPath
    trace('utils.cache_file::cPath', cPath)

    mk_folder(cPath)

    cFile = f'{cPath}/__cache__{cName}.json'
    trace('utils.cache_file::cFile', cFile)

    return cFile


def delete_cache(cName):
    """Deletes cache file by its name if exists"""
    cFile = cache_file(cName)

    if os.path.isfile(cFile):
        os.remove(cFile)

    return os.path.isfile(cFile)


def delete_expired_cache():
    """Deletes expired cache files"""
    rss = list_cache()

    for rs in rss:
        if rs['Expired']:
            delete_cache(rs['Name'])


def get_cache(cName, fullData: bool = False):
    """Returns cache data for given cache name, Flase if expired, None if not exists 

    Arguments:
        cName (str): cache name
        fullData (bool): returns cache object if True else cache data - or None if expired
    """
    cFile = cache_file(cName)
    trace('utils.get_cache::isFile(cFile)', isFile(cFile))

    try:
        cData = get_json(cFile)

        if get_ts() > float(cData['Expiration']):
            warning('cache expired!')
            return False

        trace(f'urtils.get_cache success. name: {cName}')
        return cData if fullData else cData['Data']
    except Exception as err:
        error(f'utils.get_cache failed. name: {cName}, error:', err)
        return None


def list_cache(prefix: str | None = None, icnludes: list = [], excludes: list = []):
    """Returns list of cache metadata and their expiration status

    Arguments:
        prefix (str | None): filter cache starts with given prefix, default None
        includes (list): include cache that contain one string in this list 
        excludes (list): exclude cache that contain one string in this list

    Process Order: prefix, include and exclude
    """
    cKey = '__cache__'
    cPath = get_config('CACHE_PATH') if get_config('CACHE_PATH') else cKey
    cPath = cur_dir()['Path'] + '/' + cPath

    rss = get_dir(cPath + '/*.json')

    res = []
    for cFile in rss['Files']:
        add = False
        if not prefix or (prefix and cFile.startswith(cKey + prefix)):
            add = True

        if add:
            for key in icnludes:
                if key in cFile:
                    add = True

            for key in excludes:
                if key in cFile:
                    add = False

        if add:
            # append only cache metadata plus calculated Expired
            cName = cFile[len(cKey):-5]  # -5 is len('.json')
            cFile = cache_file(cName)
            cData = get_json(cFile)
            cData['Expired'] = True if get_ts() > float(cData['Expiration']) else False
            cData.pop('Data', None)
            res.append(cData)

    return res


def set_cache(cName, cData, ttl: int = 86400):
    """Returns True if cache data stored successfully or None

    Arguments:
        cName (str): cache name
        cData (any): cache data
        ttl (int): time to leave is seconds
    """
    cFile = cache_file(cName)

    cExpire = get_ts() + ttl
    jData = {
        'Name': cName,
        'Created': datetime.now(),
        'Expires': datetime.now() + timedelta(seconds=int(ttl)),
        'Expiration': cExpire,
        'TTL': ttl,
        'Data': cData,
    }

    try:
        put_json(cFile, jData)
        trace(f'urtils.set_cache success. name: {cName}')
        return True
    except Exception as err:
        error(f'urtils.set_cache failed. name: {cName}, error:', err)
        return None


def get_session(profile='default'):
    """Returns boto3 session by 'profile' name or default"""
    try:
        session = boto3.Session(profile_name=profile)
        return session
    except Exception as err:
        pass
    return


def get_globals(sortit=True):
    """Returns dict of gloabal variables"""
    iVars = globals()
    if sortit:
        iVars = sort_dict(iVars)
    return iVars


def types_report(iVars=[], sortit=True, echo=True):
    """Returns & prints 'iVars' info list from globals()"""
    res = []

    if sortit:
        iVars.sort()

    for i, var in enumerate(iVars):
        i += 1
        row = get_config('IND_SPC') + justr(i, 5) + '.'

        if echo:
            print(
                row,
                iColor('Global', 'iCyan') + ':',
                iColor(var, 'iYellow') + ':',
                iColor(type(globals()[var]), 'iGreen'),
                '=',
                iColor(globals()[var], 'iCyan'),
            )

        res.append({
            'Name': var,
            'Type': type(globals()[var]),
            'TypeString': find_between(type(globals()[var]), left="'", right="'"),
        })

    return res


# Classes
class MyIndex:
    """Auto index based on defined index level starting from zero"""

    def __init__(self, levels=3, space=0, tab=0) -> None:
        """Preset 'levels', 'space' & 'tab' size

        Arguments:
            levels (int): levels count, default 3 for three levels
            space (int): spaces before all lines - left indent
            tab (int): tab for each level tab indent 
        """
        self.levels_count = levels  # levels count
        self.space = space          # space size for all
        self.tab = tab              # tab size in space
        self.levels = []            # levels array
        trace(f'MyIndex.__init__({levels})')
        trace(f'{levels} levels Index')
        for i in range(levels):
            self.levels.append(0)
            trace('i:', i, 'has', len(self.levels), 'levels')

    def demo(self):
        """Prints demo"""
        for i in [0, 2]:
            mi = MyIndex(3, tab=i)  # initialize 3 levels array [0, 0, 0] with tab = i
            mi.set(0)       # returns 1
            mi.set(1)       # returns 1.1
            mi.set(1)       # returns 1.2
            mi.set(2)       # returns 1.2.1
            mi.set(2)       # returns 1.2.2
            mi.set(1)       # returns 1.3
            mi.set(2)       # returns 1.3.1
            mi.set(0)       # returns 2
            mi.set(1)       # returns 2.1

            mi.get()        # returns [1, 3, 1] # return levels array

    def get(self):
        """Returns current levels array"""
        return self.levels

    def set(self, i=0):
        """Returns incremented levels[i] item starting from 0

        Usage:
            MyIndex.set(0) Returns {n0+1}
            MyIndex.set(1) Returns {n0}.{n1+1}
            MyIndex.set(2) Returns {n0}.{n1}.{n2+1}
        """
        sTrace = True
        caller = getframeinfo(stack()[1][0])

        if caller.function not in log_functions():
            sTrace = False

        trace(f'MyIndex.set({i})')

        # Init
        old = []
        for d in range(self.levels_count):
            old.append(self.levels[d])

        if i <= self.levels_count:
            self.levels[i] += 1

        new = []
        for d in range(self.levels_count):
            new.append(self.levels[d])

        if isTrace() and sTrace:
            trace(f'MyIndex.set({i}) Old', old)
            trace(f'MyIndex.set({i}) New', new)

        # If there is gigits after self.levels[i-1] reset it to zero
        # example MyIndex.set(2) then MyIndex.set(1) then MyIndex.set(2) should be zero
        for d in reversed(range(self.levels_count)):
            if new[d] == old[d] and old[d] > 0 and d >= i:
                trace('Reset Index', d, 'New', new[d], 'Old', old[d])
                new[d] = 0
                self.levels[d] = 0

                if isTrace() and sTrace:
                    trace('New', self.levels, 'Old', old, 'Reset')

        res = ''
        for d in range(self.levels_count):
            if isTrace() and sTrace:
                trace(f'MyIndex.set({i})', f'levels[{d}]:', self.levels[d], 'res', f"'{res}'")

            if self.levels[d] > 0:
                res = f'{res}.{self.levels[d]}' if res != '' else f'{self.levels[d]}'

                if isTrace() and sTrace:
                    trace(f'MyIndex.set({i})', f'levels[{d}]:', self.levels[d], 'res', f"'{res}'", 'outcome')

        if self.space > 0:
            res = ' ' * self.space + res

        return res if self.tab == 0 else ' ' * self.tab * (i + 1) + res


class Timer:
    """Timer class to register excution duration & print summary

    Usage:
        t = Timer()                 # Initialize Timer
        t.set('Start Script A')     # Register time since init
        t.set('Start Script B')     # Register time since last register

        t.print_table()             # Print Timer data table
        took = t.took()             # Get Total Timer time
    """

    def __init__(self):
        """Preset class"""
        self.ts = 0
        self.events = []
        self.header = ['#', 'Event', 'Took', 'Total']
        self.table = []
        self.total = 0

    def get_ts(self):
        """Returns current unaware timestamp"""
        ts = datetime.timestamp(datetime.now())  # type: ignore
        if not self.ts:
            self.ts = ts
        return ts

    def iso8601Time(self) -> str:
        """Returns UTC ISO 8601 timestamp string"""
        return datetime.now(timezone.utc).isoformat()  # type: ignore

    def localTime(self) -> str:
        """Returns local ISO 8601  timestamp string"""
        return datetime.now().astimezone(tz=None).isoformat()  # type: ignore

    def set(self, char: str = ''):
        """Set a timer entry with given string of 'char'"""
        ts = self.get_ts()
        utc = self.iso8601Time()
        local = self.localTime()
        row = len(self.events) + 1

        if len(self.events) == 0:
            took = total = 0
        else:
            took = ts - self.events[-1]['TimeStamp']
            total = ts - self.events[0]['TimeStamp']

        iTotal = total
        iTook = took

        if took > total:
            iTook = total
            iTotal = took

        self.events.append({
            '#': row,
            'Event': char,
            'TimeStamp': ts,
            'Local': local,
            'UTC': utc,
            'Took': iTook,
            'Total': iTotal
        })

        self.total = total
        self.table.append([row, char, took, total])

    def get_events(self):
        """REturn list of stored events"""
        return self.events

    def get_table(self):
        """Returns events table data"""
        return {
            'Header': self.header,
            'Table': self.table
        }

    def _justl(self, string, width=3):
        """Returns left justified 'string' to given 'width'"""
        return str(string) + ' ' * (width - len(str(string))) if len(str(string)) < width else str(string)

    def _justr(self, string, width=3):
        """Returns right justified 'string' to given 'width'"""
        return ' ' * (width - len(str(string))) + str(string) if len(str(string)) < width else str(string)

    def _ndigits(self, string, width=3):
        """Returns leading zeros given 'str | int' to given 'width'"""
        return '0' * (width - len(str(string))) + str(string) if len(str(string)) < width else str(string)

    def _fmt_ts(self, ts, digits=6):
        """Returns formated timestamp with 'digits' decimal points"""
        return float(format(ts, f'.{digits}f'))

    def event_process(self, levels=3):
        """Process events to calulate 'Took' percentage of total time"""
        for i, event in enumerate(self.events):
            tPercent = event['Took'] / self.total if self.total > 0 else 0
            self.events[i]['Percent'] = self._fmt_ts(tPercent * 100, 2)

    def print_table(self, order: None = None, decimal: int = 3, out: bool = True):
        """Times are in ms, order= asc|desc

        Args:
            order (None | str): None for chronological, 'asc' for ascending & 'desc' for descending took order 
            out (bool): True to print output and False to log timing
            decimal (int): decimal points

        Print timer table if out is True or just logs the timing
        """
        if not out:
            # Prevent output print
            buffer = StringIO()
            sys.stdout = buffer

        # Get max len of Events
        maxEvent = 0
        for e in self.events:
            maxEvent = max(len(e['Event']), maxEvent)
        maxEvent += 3

        # Get len Events Count
        lenCount = len(str(len(self.events)))
        lenCount += 2

        # Print Header
        tWidth = lenCount + 12 + 12 + 8
        if tWidth + maxEvent < 90:
            maxEvent = 80 - tWidth
        print(self._justr('#', lenCount), end=' ')
        print(self._justl('Event', maxEvent), end=' ')
        print(self._justr('Took in ms', 12), end=' ')  # len: 12+1+2 = 15
        print(self._justr('Total in ms', 12), end=' ')  # len: 12+1+2 = 15
        print(self._justr('Took%', 8))
        hLine = lenCount + maxEvent + 3 + 15 + 15 + 9
        tLine = hLine - 15 - 9 - 2 - 2
        print('-' * hLine)

        # calculate total
        tMap = [rs['Total'] for rs in self.events]
        self.total = max(tMap)

        # Process Events
        self.event_process()

        # Chronological order
        if not order:
            self.events.sort(key=operator.itemgetter('#'), reverse=False)

        if order and order.lower() == 'asc':
            self.events.sort(key=operator.itemgetter('Took'), reverse=True)

        if order and order.lower() == 'desc':
            self.events.sort(key=operator.itemgetter('Took'), reverse=False)

        # Print Events
        for i, event in enumerate(self.events):
            print(self._justr(event['#'], lenCount), end=' ')
            # Convert to ms
            iTook = self._fmt_ts(event['Took'] * 1000, decimal)
            iTotal = self._fmt_ts(event['Total'] * 1000, decimal)
            print(self._justl(event['Event'], maxEvent), end=' ')
            print(self._justr('{:.3f}'.format(iTook), 12), end=' ')
            print(self._justr('{:.3f}'.format(iTotal), 12), end=' ')
            print(self._justr('{:.2f}'.format(event['Percent']), 9) + '%')

        # Print Total
        print('-' * hLine)
        total = self._fmt_ts(self.total * 1000, decimal)
        print(self._justr('Total in ms', tLine), self._justr(total, 12))

        if not out:
            # Restore output print
            sys.stdout = sys.__stdout__

    def took(self):
        """Returns total time with 3 decimal points"""
        return '%.3f' % self.total


class AST:
    """Abstract Syntax Tree
    Generates functions, classes, methods and their arguments for a given python filename

    Args:
        filename (str): Python filename, cur_dir()['File'] for other files
        func_color (str): function & methods color, default 'Yellow'
        args_color (str): args & kwargs color, default 'Cyan'
        class_color (str): class color, default 'Green'
        docs_color (str): docstring color, default 'Green'
        full_docstring (bool): show full docsting or brief, default False for brief

    Examples:
        ast = AST(filename=cur_dir()['File']);
        ast.print_info()

    Returns:
        None
    """

    def __init__(self,
                 filename=os.path.basename(__file__),
                 func_color='Yellow',
                 args_color='Cyan',
                 class_color='Green',
                 docs_color='Green',
                 full_docstring=True
                 ):

        self.filename = filename
        self.func_color = func_color
        self.args_color = args_color
        self.class_color = class_color
        self.docs_color = docs_color
        self.full_docstring = full_docstring

        self.node = None

        self.data = {
            'Functions': [],
            'Classes': []
        }

        try:
            with open(filename) as file:
                self.node = ast.parse(file.read())  # type: ignore

            self.functions = [n for n in self.node.body if isinstance(n, ast.FunctionDef)]  # type: ignore
            self.classes = [n for n in self.node.body if isinstance(n, ast.ClassDef)]  # type: ignore

            for function in self.functions:
                self._info(function)

            for class_ in self.classes:
                methods_info = []
                methods = [n for n in class_.body if isinstance(n, ast.FunctionDef)]  # type: ignore

                for method in methods:
                    methods_info.append(self._info(method, isClass=True))

                docstring = self.get_docstring(node=class_)

                self.data['Classes'].append({'Class': class_.name, 'Methods': methods_info, 'Docstring': docstring})  # type: ignore
        except FileNotFoundError as err:
            print(f'FileNotFoundError: {err}')
        except Exception as err:
            print(f'UnexpectedError: {err}')

    def _info(self, node, isClass=False):
        """Returns dict of {function: args}"""
        args = ([arg.arg for arg in node.args.args])

        # Args & kwargs
        if isDebug() and node.name in ['trace', 'isDebug', 'iColor']:
            try:
                tmp = ast.dump(ast.parse(node), indent=4)
                print(tmp)

                print(node.args.args)
                print(node.args.vararg.arg)
                print(node.args.kwarg.arg)
            except Exception as err:
                warning(err)

        try:
            args.append(node.args.vararg.arg)
        except Exception as err:
            pass

        try:
            args.append(node.args.kwarg.arg)
        except Exception as err:
            pass

        args_str = ' ' + ', '.join(args) + ' ' if args else ''

        docs = self.get_docstring(node)
        trace(f"{iColor(node.name, self.func_color)}({iColor(args_str, self.args_color)}) {iColor(docs, self.docs_color)}")

        if not isClass:
            self.data['Functions'].append({
                    'Func': node.name,
                    'Args': args,
                    'Docs': docs
                })

        return {
                'Func': node.name,
                'Args': args,
                'Docs': docs
            }

    def get_docstring(self, node):
        """Returns docstring of given node"""
        res = ast.get_docstring(node)

        # if not full docstring only return the first line
        if res and not self.full_docstring:
            return res.split('\n')[0]

        return res

    def _print_docstring(self, docstring='', isClass=False, isClassDoc=False):
        """Prints docstring"""
        num = 1 if isClassDoc or not isClass else 2
        docs = docstring.split('\n') if docstring else []

        if not docs:
            return

        # print single line docstring in the same line
        if len(docs) == 1 and not isClassDoc:
            print(iColor(docs[0], self.docs_color))
            return

        # print multi-line docstring from new line
        print() if not isClassDoc else ''
        for doc in docs:
            print(get_config('IND_SPC') * (num + 2), iColor(doc, self.docs_color))
        print()if not isClassDoc else ''

    def _print_func(self, data, isClass=False):
        """Prints output of Function, Args, Docstring"""
        num = 2 if isClass else 1
        for i, rs in enumerate(data):
            trace('rs:', rs)
            iStr = justr(i + 1, 3)
            args_str = ' ' + ', '.join(rs['Args']) + ' ' if rs['Args'] else ''
            docs = rs['Docs'].split('\n') if rs['Docs'] else []

            print(f"{get_config('IND_SPC')*num}{iStr}. {iColor(rs['Func'], self.func_color)}({iColor(args_str, self.args_color)})", end=' ')

            self._print_docstring(rs['Docs'], isClass=isClass) if rs['Docs'] else print()

        return

    def get_info(self):
        """Returns data"""
        return self.data

    def print_info(self):
        """Prints AST info"""
        # remove path from filename
        path = cur_dir()['Path']
        filename = self.filename.replace(path, '')

        ast_dir = cur_dir()
        ast_dir['File'] = f'{path}/{filename}'
        ast_dir['FileName'] = filename.replace('/', '')
        ast_dir['Name'] = os.path.splitext(filename)[0].replace('/', '')
        ast_dir['LOGLEVEL'] = cur_log()
        blue_green_dict_print(ast_dir, ' : ')

        fCount = len(self.data['Functions'])
        cCount = len(self.data['Classes'])

        print()
        ppwide(f'{filename} / AST / Functions ({fCount})')
        self._print_func(self.data['Functions'])

        print()
        ppwide(f'{filename} / AST / Classes ({cCount})')
        for i, class_ in enumerate(self.data['Classes']):
            if i > 0:
                print()

            iStr = justr(i + 1, 3)
            print(f"{get_config('IND_SPC')}{iStr}. Class {iColor(class_['Class'], self.class_color)}")
            self._print_docstring(class_['Docstring'], isClass=True, isClassDoc=True)
            self._print_func(class_['Methods'], isClass=True)


class DictErr:
    def __init__(self, aa, silent=True):
        """Dict error handler"""
        if silent:
            printll('Dictionary Error Swallowing Anti-Pattern')
            printl('No error message at all')
        else:
            printll('Dictionary Error Hiding Anti-Pattern')
            printl('Error message but hides the location that caused the error')

        print('See: https://en.wikipedia.org/wiki/Error_hiding')
        print(f'dict          : {aa}')
        print(f'dict.keys()   : {aa.keys()}')
        print(f'dict.values() : {aa.values()}')
        print(f'dict.items()  : {aa.items()}')

        try:
            aa.dict = []
        except Exception as err:
            if not silent:
                print(f'1. {type(err).__name__}: {err}')  # type: ignore

        try:
            aa.dict = {}
        except Exception as err:
            if not silent:
                print(f'2. {type(err).__name__}: {err}')  # type: ignore

        tags = {'Tags': []}
        printll('Key/Value')
        for key, val in aa.items():
            dict = {'Name': key, 'Value': val}
            tags['Tags'].append(dict)
            print(f"{get_config('IND_SPC')}{dict}")

        printll('Tags - Json')
        print(pjson(tags))

        printll('Tags - Yaml')
        print(pyaml(tags))


class ProgPrint:
    counter = 0
    indent = 0
    limit = 120
    hideFail = True
    passChar = '.'
    failChar = '!'
    total = 0

    def __init__(self, counter=0, indent=7, limit=120, hideFail=True, passChar='.', failChar='!') -> None:
        """Prints progress"""
        self.counter = counter
        self.indent = indent
        self.limit = limit
        self.hideFail = hideFail
        self.passChar = passChar
        self.failChar = failChar
        self.total = 0

    def set(self, passed=True) -> None:
        """Set progress then wirte & flush to stdout"""
        if self.counter < self.indent:
            self.counter = self.indent
            sys.stdout.write(' ' * self.indent)

        if passed is True:  # Count passed
            self.counter += 1
            self.total += 1
        elif self.hideFail is False:    # Count failed if not hideFail
            self.counter += 1
            self.total += 1

        if self.counter > self.limit + 1:
            print()
            self.conter = 0
        else:
            if passed is True:
                sys.stdout.write(iColor(self.passChar, 'Green'))
            elif self.hideFail is False:    # Print failed if not hideFail
                sys.stdout.write(iColor(self.failChar, 'Red'))

        sys.stdout.flush()

    def get(self) -> dict:
        """Get Progress"""
        return {
            'Counter': self.counter,
            'Indent': self.indent,
            'Limit': self.limit,
            'HideFail': self.hideFail,
            'PassChar': self.passChar,
            'FailChar': self.failChar,
            'Total': self.total,
        }

    def reset(self):
        """Reset proress"""
        self.counter = 0
        self.total = 0


# Demo Functions
def demo_alignment():
    """Prints demo of alignment functions"""
    aCount = MyIndex(2)
    aWidth = 50
    aMsgs = [
        'Sed etincidunt neque quaerat adipisci neque velit dolore.',
        'Neque ipsum non quisquam ipsum sed.',
    ]
    aRange = 5
    for i in range(aRange):
        aMsg = aMsgs[i] if i < len(aMsgs) else lorem.sentence()
        aStat = triStateColor(f'{len(aMsg)}/{aWidth}', len(aMsg) <= aWidth)
        print(f" {aCount.set(0)}. Sentence is: '{aMsg}', Width: {aStat}, Max: {aWidth}")
        print(f"    {aCount.set(1)}. justc: '{justc(string=aMsg, width=aWidth, trunk=True)}'")
        print(f"    {aCount.set(1)}. justl: '{justl(string=aMsg, width=aWidth, trunk=True)}'")
        print(f"    {aCount.set(1)}. justr: '{justr(string=aMsg, width=aWidth, trunk=True)}'")


def demo_locals(sortit=True):
    """Prints list of locals() vars"""
    var = row = iVars = None
    i = 0
    iVars = locals()

    if sortit:
        iVars = sort_dict(iVars)

    print(
        'Local Variables of',
        iColor(inspect.stack()[0][3], 'iYellow') + '(',
        iColor('sorted', 'iCyan'),
        '=',
        iColor(sortit, 'iBlue'),
        ')',
    )

    for i, var in enumerate(iVars):
        i += 1
        row = get_config('IND_SPC') + justr(i, 5) + '.'
        print(
            row,
            iColor('Local', 'iBlue') + ':',
            iColor(var, 'iYellow') + ':',
            iColor(type(locals()[var]), 'iGreen'),
            '=',
            iColor(locals()[var], 'iCyan'),
        )


def demo_globals(sortit=True):
    """Prints list of globals() vars"""
    var = row = iVars = None
    i = 0
    iVars = globals()

    if sortit:
        iVars = sort_dict(iVars)

    print(f"Global Variables for Environemt")
    for i, var in enumerate(iVars):
        i += 1
        row = get_config('IND_SPC') + justr(i, 5) + '.'
        print(
            row,
            iColor('Global', 'iCyan') + ':',
            iColor(var, 'iYellow') + ':',
            iColor(type(globals()[var]), 'iGreen'),
            '=',
            iColor(globals()[var], 'iCyan'),
        )


def demo_rich_color():
    """Prints rich color by using console.print from rich"""
    console.rule("Rich color")
    print()

    aligns = ['left', 'center', 'right']
    styles = ['', 'bold', 'italic', 'underline', 'blink']
    for t, style in enumerate(styles):
        t += 1
        if style:
            style = style + ' '
        style_str = style if style else "''"
        console.rule(f"Chapter {t}, Rich color, {style_str}")
        for i, color in enumerate(colors()):
            if color[0:1] == 'i':
                color = 'bright_' + color[1:]

            if 'Gray' in color:
                color = color.replace('Gray', 'Black')
                continue

            i += 1
            color = color.lower().strip()
            # type: ignore
            console.rule(f"[{style}{color}]Part {i} {style} {color.title()}", align='left')
        print()

    console.rule(f"[bold red]Chapter {t+1}, Rich color, 0-255")
    for c in range(0, 255):
        console.print(f"{justr(c,3)}. Lorem", style=f'color({c})', end=' ', width=80)

    console.print()
    print()


def demo_MyIndex(levels=4, space=2, tab=0):
    """Prints hirearchy of sentences by using MyIndex class"""
    mi = MyIndex(levels, space, tab)
    print(f'{mi.set(0)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(2)}. {lorem.sentence()}')
    print(f'{mi.set(2)}. {lorem.sentence()}')
    print(f'{mi.set(0)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(0)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(2)}. {lorem.sentence()}')
    print(f'{mi.set(2)}. {lorem.sentence()}')
    print(f'{mi.set(0)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(1)}. {lorem.sentence()}')
    print(f'{mi.set(2)}. {lorem.sentence()}')
    print(f'{mi.set(3)}. {lorem.sentence()}')
    print(f'{mi.set(3)}. {lorem.sentence()}')

# Get Arguments


def demo_args_parser(show_help=False):
    """Helper function to parse input arguments to execute tests & demo"""
    # https://docs.python.org/3/library/argparse.html
    file = cur_dir()['FileName']

    parser = argparse.ArgumentParser(
        prog='Python Utility',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description=textwrap.dedent("""\
        Utility Functions & Classes
        -------------------------------------------------------------------------------
        Utilty to manage cache, color, date, files, folders, logs, print, and time 
        function with calsses for:
            - AST (Abstract Syntax Tree - List Functions, Classes & Methods)
            - MyIndex (Auto index based on defined index level starting from zero)
            - Timer (Timer class to register excution duration & print summary)
            - NoAliasDumper (Yaml safe dumper class)

        default: skip is default for all options which start with --show
        """),
        epilog=textwrap.dedent("""\
        GitHub: https://github.com/FMI-Test/api
        """))

    """
    parser.add_argument example
        'filename', type=str [, default='']
        'path', type=str, required=True [, default='']
        '-a', '--action', choices=['approve', 'deny', 'grant']
        '-c', '--count' type=int
        '-s', '--skip-vars', action='store_true'
    """

    parser.add_argument('-a', '--all', action='store_true', help='show and run all demos')
    parser.add_argument('-b', '--brief', action='store_true', help='show and run brief demos')
    parser.add_argument('-c', '--color', action='store_true', help='show colors range demo')
    parser.add_argument('-d', '--diff', action='store_true', help='show demo globals vars diff')
    parser.add_argument('-f', '--full-doc', action='store_true', help='show full docstring when used with -s')
    parser.add_argument('-g', '--global', action='store_true', help='show global env vars demo')
    parser.add_argument('-i', '--dir', action='store_true', help='show dir search demo')
    parser.add_argument('-j', '--just', action='store_true', help='show text alignement demo')
    parser.add_argument('-l', '--local', action='store_true', help='show local env vars demo')
    parser.add_argument('-o', '--log', action='store_true', help='show log levels demo')
    parser.add_argument('-p', '--profiler', action='store_true', help='run profiler')
    parser.add_argument('-t', '--timer', action='store_true', help='show Timer Asc & Desc Demo if used with -b or -a')
    parser.add_argument('-s', '--ast', action='store_true', help='show abstract syntax tree')
    parser.add_argument('-v', '--version', action='version', version='%(prog)s 2.0')

    if show_help:
        parser.print_help()

    res = parser.parse_args()

    return vars(res)


if __name__ == '__main__':
    gVarsStart = get_globals()
    args = demo_args_parser()

    if args.get('profiler'):
        import cProfile
        import pstats
        import io
        from pstats import SortKey
        pr = cProfile.Profile()
        pr.enable()

    mi = MyIndex(levels=3)
    summary = []
    timer = Timer()

    # config overwrite
    UNITTEST = True
    REP = '~'
    rName = cur_file().title()
    cur_level = cur_log()
    cur_colored = get_config('COLORED')
    title = f'Utilities Function / {rName}'
    summary.append(f'{mi.set(0)}. {title}')
    ppwide(summary[-1], rep='=')
    timer.set(summary[-1].split('/')[-1].strip())

    COLORED = True

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / cur_dir()')
        ppwide(summary[-1])
        ppjson(cur_dir())
        timer.set(summary[-1].split('/')[-1].strip())

        print()
        summary.append(f'{mi.set(0)}. {title} / get_host_data()')
        ppwide(summary[-1])
        ppjson(get_host_data())
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('log'):
        fMap = [
            '%H:%M:%S',
            '%H:%M:%S.%f',
            '%d-%b-%Y %H:%M:%S',
            '%Y-%m-%d %H:%M:%S.%f',
            '%a %d %b %Y, %I:%M%p',
            '%d-%b-%Y %H:%M:%S %Z',
            '%d-%b-%Y %H:%M:%S.%f',
            '%a %d %b %Y, %I:%M:%S %p',
            '%a %d %b %Y, %I:%M:%S %p %Z',
            '%Y-%m-%d %H:%M:%S.%f%z',
        ]

        summary.append(f'{mi.set(0)}. {title} / Get Current Log {cur_level}')
        timer.set(summary[-1].split('/')[-1].strip())

        LOG_DT_FMT = get_config('LOG_DT_FMT')
        for level in log_levels():
            LOGLEVEL = level
            print()
            summary.append(f'{mi.set(0)}. {title} / Log {level} Demo')
            ppwide(summary[-1])
            uColor = triStateColor('UNITTEST', get_config('UNITTEST'))
            wColor = iColor(whichLog(), 'iYellow')
            dColor = triStateColor(f'isDebug(): {isDebug()}', isDebug())
            tColor = triStateColor(f'isTrace(): {isTrace()}', isTrace())
            print(f"{uColor}, {wColor}, {dColor}, {tColor}, {iColor('LOG_DT_FMT: '+LOG_DT_FMT, 'Blue')}")
            trace(f'Unittest for log level {level}')
            debug(f'Unittest for log level {level}')
            info(f'Unittest for log level {level}')
            success(f'Unittest for log level {level}')
            warning(f'Unittest for log level {level}')
            error(f'Unittest for log level {level}')
            abort(f'Unittest for log level {level}')
            sysExit(f'Unittest for log level {level}')
            timer.set(summary[-1].split('/')[-1].strip())

        LOGLEVEL = cur_level
        UNITTEST = False

        print()
        summary.append(f'{mi.set(0)}. {title} / Set Current Log {cur_level}')
        ppwide(summary[-1])
        uColor = triStateColor('UNITTEST', get_config('UNITTEST'))
        wColor = iColor(whichLog(), 'iYellow')
        dColor = triStateColor(f'isDebug(): {isDebug()}', isDebug())
        tColor = triStateColor(f'isTrace(): {isTrace()}', isTrace())
        print(f"{uColor}, {wColor}, {dColor}, {tColor}, {iColor('LOG_DT_FMT: '+LOG_DT_FMT, 'Blue')}")
        timer.set(summary[-1].split('/')[-1].strip())

        if not args.get('all'):
            print()
            timer.print_table()

            print()
            print('Config')
            ppjson(get_config())

            print()
            sysExit(f'UNITTEST: {UNITTEST}, for log level {LOGLEVEL}')

    if args.get('all') or args.get('color'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Rich Color')
        ppwide(summary[-1])
        demo_rich_color()

        style = ''
        last_style = None
        for color in rColors():
            if color[0] == color[0].lower():
                style = rStyles()[color[0]]

            if style != last_style:
                if not style:
                    style = 'Normal'
                ppwide(f'{style.title()} Style')
                last_style = style

            console.print(justl(color, 16) + ': ' + rColor(f'You can use style with value of many colors like {color}, {style}', color))
        timer.set(summary[-1].split('/')[-1].strip())
        if not args.get('all'):
            UNITTEST = False
            sysExit(summary[-1])

    if args.get('all') or args.get('local'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Local Variables ')
        ppwide(summary[-1])
        demo_locals()
        timer.set(summary[-1].split('/')[-1].strip())
        if not args.get('all'):
            UNITTEST = False
            sysExit(summary[-1])

    if args.get('all') or args.get('global'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Global Variables ({len(globals())})')
        ppwide(summary[-1])
        demo_globals()
        timer.set(summary[-1].split('/')[-1].strip())
        if not args.get('all'):
            UNITTEST = False
            sysExit(summary[-1])

    # Text Alignment Demo
    if args.get('all') or args.get('just'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Text Alignment Demo')
        ppwide(summary[-1])
        demo_alignment()
        timer.set(summary[-1].split('/')[-1].strip())
        if not args.get('all'):
            UNITTEST = False
            sysExit(summary[-1])

    if args.get('all') or args.get('brief'):
        summary.append(f'{mi.set(0)}. {title} / Colors')
        ppwide(summary[-1])
        iVars = iColor("string, color, cStyle='NORMAL'", 'iCyan')
        print(f"Demo of {iColor('iColor', 'iYellow')}( {iVars} )")

        cIndex = MyIndex(levels=3, space=2)
        maxLen = maxlen(colors())
        print(' '.ljust(3 + 1),
              'Color'.ljust(maxLen),
              (f"cStyle='{cStyles()[0]}'").ljust(25),
              (f"cStyle='{cStyles()[1]}'").ljust(25),
              (f"cStyle='{cStyles()[2]}'").ljust(25)
              )
        print('-' * 90)
        for i, color in enumerate(colors()):
            i += 1
            iStr = justr(i, 3)
            print(
                f'{iStr}. {color.ljust(maxLen)}',
                iColor(f'This is {cStyles()[0]} {color}'.ljust(25), color, cStyles()[0]),
                iColor(f'This is {cStyles()[1]} {color}'.ljust(25), color, cStyles()[1]),
                iColor(f'This is {cStyles()[2]} {color}', color, cStyles()[2])
            )
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('ast'):
        print()
        summary.append(f'{mi.set(0)}. {title} / AST - Abstract Syntax Tree')
        ppwide(summary[-1])
        file = cur_dir()['File']
        ast = AST(file, full_docstring=args.get('full_doc', True))
        ast.print_info()
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Date & Time')
        ppwide(summary[-1])
        td = 'days=5 )'
        spc = 30
        dtt = get_dt()
        utc = get_dtutc()
        iso = iso8601Time()
        print(iColor(justl('get_dt()', spc), 'iYellow'), ':', dtt)
        print(iColor(justl('get_dtutc()', spc), 'iYellow'), ':', utc)
        print(iColor(justl('iso8601Time()', spc), 'iYellow'), ':', iso)
        timer.set(summary[-1].split('/')[-1].strip())

        print()
        summary.append(f'{mi.set(0)}. {title} / Excel days since 1900-1-1 date format')
        ppwide(summary[-1])
        dates = ['1900-1-1', '1900-12-31', '1901-1-1', '2023-12-18', '2023-12-19', None]

        for d in dates:
            print(iColor(justl(f'get_excel_date( {d} )', spc), 'iYellow'), ':', get_excel_date(d))
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Time Delta')
        ppwide(summary[-1])
        print('Assume')
        wline()
        spc = 90 - 3 - 32
        dtt = '2023-10-10T10:10:20.000001-07:00'
        utc = '2023-10-10T17:10:20.000001+00:00'
        iso = '2023-10-10T17:10:20.000001+00:00'
        print(iColor(justl('get_dt()', spc), 'iYellow'), ':', dtt)
        print(iColor(justl('get_dtutc()', spc), 'iYellow'), ':', utc)
        print(iColor(justl('iso8601Time()', spc), 'iYellow'), ':', iso)
        wline()

        try:
            print(iColor(justl(f'get_tdelta( dtt, days=5, hours=0, seconds=0 )',
                               spc), 'iYellow'), ':', get_tdelta(dtt, days=5, hours=0, seconds=0))
            print(iColor(justl(f'get_tdelta( dtt, days=5, hours=5, seconds=0 )',
                               spc), 'iYellow'), ':', get_tdelta(dtt, days=5, hours=5, seconds=0))
            print(iColor(justl(f'get_tdelta( dtt, days=5, hours=5, seconds=5 )',
                               spc), 'iYellow'), ':', get_tdelta(dtt, days=5, hours=5, seconds=5))
            print(iColor(justl(f'get_tdelta( iso, days=5, hours=0, seconds=0 )',
                               spc), 'iYellow'), ':', get_tdelta(iso, days=5, hours=0, seconds=0))
            print(iColor(justl(f'get_tdelta( iso, days=5, hours=5, seconds=0 )',
                               spc), 'iYellow'), ':', get_tdelta(iso, days=5, hours=5, seconds=0))
            print(iColor(justl(f'get_tdelta( iso, days=5, hours=5, seconds=5 )',
                               spc), 'iYellow'), ':', get_tdelta(iso, days=5, hours=5, seconds=5))
            print(iColor(justl(f'get_tdelta( utc, days=5, hours=0, seconds=0 )',
                               spc), 'iYellow'), ':', get_tdelta(utc, days=5, hours=0, seconds=0))
            print(iColor(justl(f'get_tdelta( utc, days=5, hours=5, seconds=0 )',
                               spc), 'iYellow'), ':', get_tdelta(utc, days=5, hours=5, seconds=0))
            print(iColor(justl(f'get_tdelta( utc, days=5, hours=5, seconds=5 )',
                               spc), 'iYellow'), ':', get_tdelta(utc, days=5, hours=5, seconds=5))
        except Exception as err:
            print('get_tdelta error:', err)

        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Virtual Environment')
        ppwide(summary[-1])
        print('Is venv activated?   ', isVenv())
        print('Is local environment?', isLocal())
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / MyIndex 4 Levels & Tab 2 Demo')
        ppwide(summary[-1])
        demo_MyIndex(levels=4, space=2, tab=2)
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Terminal size')
        ppwide(summary[-1])
        tSize = os.get_terminal_size()
        print('Terminal Lines:', tSize.lines)
        print('Terminal Width:', tSize.columns)
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        # https://docs.python.org/3/library/textwrap.html
        print()
        summary.append(f'{mi.set(0)}. {title} / TextWrap')
        ppwide(summary[-1])

        pText = 'The textwrap module provides some convenience functions, '
        pText += 'as well as TextWrapper, the class that does all the work. '
        pText += 'If you’re just wrapping or filling one or two text strings, '
        pText += 'the convenience functions should be good enough; otherwise, '
        pText += 'you should use an instance of TextWrapper for efficiency.'
        pWidth = get_config('WIDTH')

        pArr = textwrap.fill(pText, width=pWidth)
        print(pArr)

        print()
        print(textwrap.fill(pText, width=pWidth, subsequent_indent='  '))

        print()
        print(textwrap.shorten(pText, width=pWidth))
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / TextWrap Shorten & Dedent')
        ppwide(summary[-1])
        iText = []
        for i in range(10):
            iText.append(lorem.sentence())

        dLen = 60
        dText = f"""
            This is left indeneted text like help in -h argparser
            {to_len('-', rep = '-', to_len=dLen)}

            This is {rName} Demo for textwrap.shorten
            {to_len('=', rep = '=', to_len=dLen)}
                1. {textwrap.shorten(iText[0], dLen-8)}
                2. {textwrap.shorten(iText[2], dLen-8)}
                3. {textwrap.shorten(iText[3], dLen-8)}
                4. {textwrap.shorten(iText[4], dLen-8)}
                5. {textwrap.shorten(iText[5], dLen-8)}
                6. {textwrap.shorten(iText[6], dLen-8)}
                7. {textwrap.shorten(iText[7], dLen-8)}
                8. {textwrap.shorten(iText[8], dLen-8)}
                9. {textwrap.shorten(iText[9], dLen-8)}"""
        print(textwrap.dedent(dText))
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Toml Config')
        ppwide(summary[-1])
        ppjson(get_config_file())
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Get Config')
        ppwide(summary[-1])
        ppjson(get_config())
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('brief'):
        print()
        summary.append(f'{mi.set(0)}. {title} / Calendar')
        ppwide(summary[-1])
        get_cur_cal(True)
        timer.set(summary[-1].split('/')[-1].strip())

    if args.get('all') or args.get('diff'):
        gDiff = []
        var = ''
        gDiffDetail = []
        gVarsEnd = get_globals()
        print()
        summary.append(f'{mi.set(0)}. {title} / Global Vars Diff {len(gVarsStart)} of {len(gVarsEnd)}')
        ppwide(summary[-1])

        for var in gVarsEnd.keys():
            if var not in gVarsStart and var != 'gVarsStart':
                gDiff.append(var)
        gDiffDetail = types_report(gDiff, sortit=True, echo=True)
        timer.set(summary[-1].split('/')[-1].strip())

    # Log timing
    if args.get('all') or args.get('timer'):
        summary.append(f'{mi.set(0)}. {title} / Timer Demo - Took Descending')
        timer.set(summary[-1].split('/')[-1].strip())
        timer.print_table('desc', out=False)

        summary.append(f'{mi.set(0)}. {title} / Timer Demo - Took Ascending')
        timer.set(summary[-1].split('/')[-1].strip())
        timer.print_table('asc', out=False)
        if not args.get('all'):
            UNITTEST = False
            sysExit(summary[-1])

    summary.append(f'{mi.set(0)}. {title} / Timer Demo - Chronological')
    timer.set(summary[-1].split('/')[-1].strip())
    timer.print_table(out=False)

    if args.get('all') or args.get('brief'):
        # Demo Summary
        print()
        ppwide(f'{title} / Demo Summary')
        for i, s in enumerate(summary):
            s = s.split('/')[-1].strip()
            print(f'{justr(i + 1, 4)}. {s}')

    # Print timing
    if args.get('all') or args.get('timer'):
        # Print descending order timing
        print()
        ppwide(summary[-3])
        timer.print_table('desc')

        # Print ascending order timing
        print()
        ppwide(summary[-2])
        timer.print_table('asc')

    if args.get('all') or args.get('brief'):
        # Print chronological order timing
        print()
        ppwide(summary[-1])
        timer.print_table()

    if args.get('dir') or args.get('brief'):
        path = cur_dir()['Path'] + '/'
        data = [
            path + '_*.py',
            path + '.py',
            path + '../.md',
            path + '../../.md',
        ]

        ppwide(f'Demo get_dir ( {path} )')
        ppjson(get_dir(path))
        print()
        for path in data:
            print(f'Path: {path}')
            print('Res :', get_dir(path)['Res'])
            print()

    print()
    ppwide(f'{title} / Help')
    demo_args_parser(show_help=True)

    if args.get('profiler'):
        pr.disable()
        s = io.StringIO()
        sortby = SortKey.CUMULATIVE
        ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
        ps.print_stats()
        print(s.getvalue())
    '''
    243 gray
    227 yellow
    196 red
• 
❌ cross_mark
❎ cross_mark_button
❗ exclamation
⛔ no_entry
❓ question
✅ white_check_mark
'''