Track call depth of a method relative to other methods in a class

call_depth.py

import inspect


def call_depth(instance):
    methods_to_consider = [
        func_name
        for func_name, _ in inspect.getmembers(
            instance, predicate=inspect.ismethod)
    ]
    stack_funcs = [i.function for i in inspect.stack()]
    func_name = stack_funcs[1]

    valid_call_stack = []
    for fn in stack_funcs[::-1]:
        if fn in methods_to_consider:
            valid_call_stack.append(fn)
    return valid_call_stack.index(func_name)


class Foo(object):
    def a(self):
        print((call_depth(self) * '*') + 'a called..')
        self.b()

    def b(self):
        print((call_depth(self) * '*') + 'b called..')
        self.c()

    def d(self):
        print((call_depth(self) * '*') + 'd called..')

    def c(self):
        print((call_depth(self) * '*') + 'c called..')
        self.d()

    def start(self):
        print((call_depth(self) * '*') + '"start" called..')
        self.a()


Foo().start()

Output:

"start" called..
*a called..
**b called..
***c called..
****d called..