Knowing the context/scope at instantiation time

Question

Is there any way to know the context in which an object is instantiated? So far I've been searching and tried inspect module (currentcontext) with poor results.

For example

class Item:
    pass

class BagOfItems:
    def __init__(self):
        item_1 = Item()
        item_2 = Item()
item_3 = Item()

I'd want to raise an exception in the instantiation of item_3 (because its outside a BagOfItems), while not doing so in item_1 and item_2. I dont know if a metaclass could be a solution to this, since the problem occurs at instantiation not at declaration.

The holder class (BagOfItems) can't implement the check because when Item intantiation happens outside it there would be no check.

Answer 1

When you instantiate an object with something like Item(), you are basically doing type(Item).__call__(), which will call Item.__new__() and Item.__init__() at some point in the calling sequence. That means that if you browse up the sequence of calls that led to Item.__init__(), you will eventually find code that does not live in Item or in type(Item). Your requirement is that the first such "context" up the stack belong to BagOfItem somehow.

In the general case, you can not determine the class that contains the method responsible for a stack frame¹. However, if you make your requirement that you can only instantiate in a class method, you are no longer working with the "general case". The first argument to a method is always an instance of the class. We can therefore move up the stack trace until we find a method call whose first argument is neither an instance of Item nor a subclass of type(Item). If the frame has arguments (i.e., it is not a module or class body), and the first argument is an instance of BagOfItems, proceed. Otherwise, raise an error.

Keep in mind that the non-obvious calls like type(Item).__call__() may not appear in the stack trace at all. I just want to be prepared for them.

The check can be written something like this:

import inspect

def check_context(base, restriction):
    it = iter(inspect.stack())
    next(it)  # Skip this function, jump to caller
    for f in it:
        args = inspect.getargvalues(f.frame)
        self = args.locals[args.args[0]] if args.args else None
        # Skip the instantiating calling stack
        if self is not None and isinstance(self, (base, type(base))):
            continue
        if self is None or not isinstance(self, restriction):
            raise ValueError('Attempting to instantiate {} outside of {}'.format(base.__name__, restriction.__name__))
        break

You can then embed it in Item.__init__:

class Item:
    def __init__(self):
        check_context(Item, BagOfItems)
        print('Made an item')

class BagOfItems:
    def __init__(self):
        self.items = [Item(), Item()]

boi = BagOfItems()
i = Item()

The result will be:

Made an item
Made an item
Traceback (most recent call last):
    ...
ValueError: Attempting to instantiate Item outside of BagOfItems

Caveats

All this prevents you from calling methods of one class outside the methods of another class. It will not work properly in a staticmethod or classmethod, or in the module scope. You could probably work around that if you had the motivation. I have already learned more about introspection and stack tracing than I wanted to, so I will call it a day. This should be enough to get you started, or better yet, show you why you should not continue down this path.

The functions used here might be CPython-specific. I really don't know enough about inspection to be able to tell for sure. I did try to stay away from the CPython-specific features as much as I could based on the docs.

References

<sub>1. Python: How to retrieve class information from a 'frame' object?
2. How to get value of arguments passed to functions on the stack?
3. Check if a function is a method of some object
4. Get class that defined method
5. Python docs: inspect.getargvalues
6. Python docs: inspect.stack</sub>