5

I am trying to determine the owning class of a calling function in python. For example, I have two classes, ClassA and ClassB. I want to know when classb_instance.call_class_a_method() is the caller of class_a.class_a_method() such that:

class ClassA(object):
    def class_a_method(self):
        # Some unknown process would occur here to
        # define caller. 
        if caller.__class__ == ClassB:
            print 'ClassB is calling.'
        else:
            print 'ClassB is not calling.'

class ClassB(object):
    def __init__(self):
        self.class_a_instance = ClassA()
    def call_class_a_method(self):
        self.class_a_instance.class_a_method()

classa_instance = ClassA()
classa_instance.class_a_method()
classb_instance = ClassB()
classb_instance.call_class_a_method()

the output would be:

'ClassB is not calling.'
'ClassB is calling.'

It seems as though inspect should be able to do this, but I cant puzzle out how.

Improve this question
6
  • Why not pass the class as a variable? Commented Aug 1, 2010 at 19:29
  • 9
    I strongly suspect that you are doing something wrong if you feel that you need this solution. Commented Aug 1, 2010 at 19:31
  • what's the use case? this is weird.. why aren't you using inheritance? why do u need to know who's calling? you could inspect the stack trace, but it isn't pretty. Commented Aug 1, 2010 at 19:33
  • 2
    +1 for Jesse Dhillon and I'd add 'very very' between "something wrong" Commented Aug 1, 2010 at 19:42
  • 1
    I can see another use case: adding class information to stack frames in stack traces. That's something I've always wanted. Commented Nov 20, 2012 at 0:29

4 Answers 4

Reset to default
7

Well, if you want to traverse call stack and find which class (if any) did call it, its trivial:

def class_a_method(self):
    stack = inspect.stack()
    frame = stack[1][0]
    caller = frame.f_locals.get('self', None)

If you want to check whether caller is of type ClassB, you should use isinstance(caller, ClassB) rather than comparsion on __class__. However this is generally un-pythonic, since python is duck-typed.

As others stated, most likely your app needs redesign to avoid using inspect.stack. Its CPython implementation feature, and is not guaranteed to be present in other Python implementations. Besides, its just Wrong Thing To Do.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

I recently found out inspect.stack can be very slow - one should rather use inspect.currentframe(n) instead of inspect.stack()[n][0] - (of course, if one is doing this at all - the previous considerations against it in production are mostly valid - except that it is consistent enough in cPython)
4

A function does not "have" a class -- one or more classes may (but need not) refer to a given function object, e.g.:

def f(self): return g()

class One(object): bah = f

class Two(object): blup = f

def g(): ...

One.bah and Two.blup are both set as references to the same function object f (and turn into unbound or bound method objects when accessed on the classes or their instances, but that leaves no trace in the stack). So, the stack upon

One().f()

vs

Two().f()

as seen from the g() that's called in either case, is pretty hard indeed to distinguish -- as would be that resulting from, e.g.,

f('blah bloh blup')

with no "classes" involved at all (though the type of the string being used as f's self argument would be;-).

I recommend not relying on introspection -- especially the wild and wooly kind, with lots of heuristics, that would be needed to get any semi-useful info here -- for any production code requirements: rearchitect to avoid that need.

For purely debugging purposes, in this case, you could walk the stack until you find a calling function with a first argument named self and introspect the type of the value bound to that argument name -- but as I mentioned that's entirely heuristical, since nothing forces your callers to name their first argument self if and only if their functions are meant to be methods in some class.

Such heuristic introspection would produce type objects One, Two, and str, in the three examples of code I just gave -- as you see, definitely not good for much else than debugging;-).

If you clarify better exactly what you're trying to accomplish through this attempted introspection, we might of course be able to help you better.

Improve this answer

1 Comment

Wow, I've got a ton left to learn. What I'm trying to achieve is for an object to treat itself as a child of another object based on whether it is being called by that object or not. Reading over comments here I am realizing just how silly this approach is, as the child shouldn't care whether or not it is owned by any other object. Using the parent as the mediator removes this whole issue of introspection from the table and simplifies the problem infinitely. sigh
0 
class ClassA( object ):
    def class_a_method( self ):
        if any( "call_class_a_method" in tup for tup in inspect.stack( ) ):
            print( 'ClassB is calling.' )
        else:
            print( 'ClassB is not calling.' )
# ClassB is not calling.
# ClassB is calling.

Why do you actually need this? It's a nasty hack because it's not something you should have to do.

Improve this answer

Comments

0

Usually the caller knows and should use the proper parameters, not to do magic in called class.

Do you need maybe factory class/function which record the Class or to write decorator for that?

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.