debug.py

import re
from inspect import stack

#whether debug may be turned on eventually. Less efficient
mayDebug = False

#Whether right debuging is on
shouldDebug = False
def startDebug():
    global shouldDebug
    shouldDebug = True
    print("Debug started")
def endDebug():
    global shouldDebug
    shouldDebug = False
    print("Debug ended")

indentation = 0
def debug(text, indentToAdd=0, force = False, level =1):
    if not shouldDebug and not force:
        return
    global indentation
    glob = stack()[level].frame.f_globals
    loc = stack()[level].frame.f_locals
    text = eval(f"""f"{text}" """,glob,loc)
    indentToPrint = indentation
    t = " "*indentToPrint
    if indentToAdd>0:
        t+= "{<"
    space = " "
    newline = "\n"
    t+= re.sub(newline,newline+space,text)
    print (t)
    indentation +=indentToAdd
    if indentToAdd<0:
        indentToPrint +=indentToAdd
        print((" "*indentToPrint)+">}")

nbInsideThis = 0
def debugInsideThisMethod(fun):
    if not mayDebug:
        return fun
    def aux_debugInsideThisMethod(*args, **kwargs):
        global nbInsideThis
        startDebug()
        nbInsideThis+=1
        ret = fun(*args, **kwargs)
        nbInsideThis -=1
        if nbInsideThis ==0:
            endDebug()
        return ret
    return aux_debugInsideThisMethod

def debugOnlyThisMethod(fun):
    return debugFun(fun, (lambda text,indentToAdd = 0: debug(text, indentToAdd, force = True, level=2)))

def assertEqual(left, right):
    if left == right:
        return True
    print(f"""\n\nReceived\n\"\"\"{left}\"\"\"\nwhich is distinct from expected\n\"\"\"{right}\"\"\"\n""")
    if hasattr(left,"firstDifference"):
        if hasattr(right,"firstDifference"):
            pair = left.firstDifference(right)
            if isinstance(pair,tuple):
                left_dif,right_dif=pair
                print(f"""\n\nThe first difference is\n\"\"\"{left_dif}\"\"\"\nand\n\"\"\"{right_dif}\"\"\"\n""")
            elif isinstance(pair,None):
                print("Strangely, firstDifference find no difference")
            else:
                assert False
        else:
            print("Only the first is a Gen")
    elif hasattr(right,"firstDifference"):
        print("Only the second is a Gen")
    return False

# def assertEqualString(left, right):
#     glob = stack()[1].frame.f_globals
#     loc = stack()[1].frame.f_locals
#     # try:
#     leftEval = eval(left, glob, loc)
#     # except NameError as n:
#     #     print(f"""glob is {glob}""")
#     #     raise
#     rightEval = eval(right,glob,loc)
#     if leftEval == rightEval:
#         return True
#     print(f"""\n\n{left} evaluates as \n"{leftEval}".\n"{rightEval}"\n is the value of {right}, they are distinct.""")
#     return False

def assertType(element,types):
    if not isinstance(types,list):
        types = [types]
    for typ in types:
        if isinstance(element,typ):
            return True
    print(f""" "{element}"'s type is {type(element)}, which is not a subtype of {types}""")
    return False


def debugFun(fun, debug=debug):
    if not mayDebug:
        return fun
    def aux_debugFun(*args, **kwargs):
        nonlocal debug
        t = f"{fun.__qualname__}("
        first = False
        def comma(text):
            nonlocal first, t
            if not first:
                first = True
            else:
                t+=", "
            t+=text
        for arg in args:
            comma(f"{arg}")
        for kw in kwargs:
            comma(f"{kw}={kwargs[kw]}")
        t+=")"
        debug("{t}",1)
        ret = fun(*args, **kwargs)
        debug("returns {ret}",-1)
        return ret
    aux_debugFun.__name__ = f"debug_{fun.__name__}"
    aux_debugFun.__qualname__ = f"debug_{fun.__qualname__}"
    return aux_debugFun


def debugInit(fun, debug=debug):
    if not mayDebug:
        return fun
    def aux_debugInit(self, *args, **kwargs):
        t = f"{fun.__name__}("
        needSeparator = False
        def comma(text):
            nonlocal needSeparator, t
            if not needSeparator:
                needSeparator = True
            else:
                t+=", "
            t+=text
        isSelf = True
        for arg in args:
            if isSelf:
                isSelf = False
                continue
            comma(f"{arg}")
        for kw in kwargs:
            comma(f"{kw}={kwargs[kw]}")
        t+=")"
        debug("{t}",1)
        fun(self, *args, **kwargs)
        debug("returns {self}",-1)
    aux_debugInit.__name__ = f"debug_{fun.__name__}"
    aux_debugInit.__qualname__ = f"debug_{fun.__qualname__}"
    return aux_debugInit

def debugOnlyThisInit(fun):
    return debugInit(fun, (lambda text,indentToAdd = 0: debug(text, indentToAdd, force = True, level=2)))


class ExceptionInverse(Exception):
    def  __init__(self,text):
        self.text = "\n".join(reversed((str(text)+"\n").split("\n")))

    def __str__(self):
        return f"Exception: {self.text}"