Inner Classes: How can I get the outer-class object at construction time?

Question

Consider the following Python (runs in 2.x or 3.x):

class Outer(object):
  pass

  class Inner(object):
    def __init__(self):
      print("Inner.self", self)

o = Outer()
i = o.Inner()

I want to get my hands on o while inside Inner.__init__(). But:

• I don't want o to be an explicit parameter to Inner.
• I want O.Inner and o.Inner to be a class object, not something weird like a closure.

Can you suggest how I might achieve this?

Right now my best idea is to use thread local storage. In my use case, whenever I construct an o.Inner(), I'm already inside a method on o somewhere, and it wouldn't be a big deal to add

threading.local()["my o object"] = o

to my code.

This gives you an idea of the level of depravity I'm willing to consider.

Answer 1

You should redesign your code not to use inner classes and to explicitly pass the instance of Outer to Inner when you make it, or not to require it.

Answer 2

You can't (in any portable, reliable or efficient way.) Nested classes have no relation to the nesting class. They have no added value, either. Instead of using nested classes, use containment of instances -- define Outer and Inner separately, and create an instance of Inner in Outer.__init__, possibly passing Outer or the Outer instance if you need it. You can make Inner a class attribute of Outer if you insist, but it will have no special access to Outer.

Answer 3

Can't be done. But with a bit of redesign:

class Outer(object):
  pass

  class _Inner(object):
    def __init__(self, outobj):
      self.outobj = outobj

  def Inner(self):
    return self._Inner(self)

o = Outer()
i = o.Inner()

print o, i.outobj

Answer 4

In Python 2.6, a class decorator that's also a custom descripton matches the specs you give:

class InnerClassDescriptor(object):
  def __init__(self, cls):
    self.cls = cls
  def __get__(self, instance, outerclass):
    class Wrapper(self.cls):
      outer = instance
    Wrapper.__name__ = self.cls.__name__
    return Wrapper

class Outer(object):
  @InnerClassDescriptor
  class Inner(object):
    def __init__(self):
      print self.outer

o = Outer()
i = o.Inner()
print 'Outer is a', type(Outer)
print 'Inner is a', type(o.Inner)

This emits:

<__main__.Outer object at 0x82f90>
Outer is a <type 'type'>
Inner is a <type 'type'>

just to confirm that

o.Inner [[is]] a class object, not something weird like a closure

as per your peculiar specs. Of course it needs to be a different class each time for reentrancy -- even in a single-threaded world, the following:

o1 = Outer()
o2 = Outer()
i1 = o1.Inner
i2 = o2.Inner
print i1(), i2(), i1(), i2()

should work cleanly, and stashing o1 vs o2 anywhere else than in the classes returned by o1.Inner vs o2.Inner (e.g., in TLS) would mean horrible results for this use.

But then you didn't specify "o.Inner has to be exactly the same class object for every possible o that's an instance of Outer", so this code fully meets the specs you did give;-).

I think it's also the first occasion I've had to make a single class that's both a custom descriptor and a class decorator, so I'm happy to propose it to celebrate National Engineers Week (here in the US;-).

Answer 5

You can use a metaclass to implement a _get_ descriptor that binds the inner class to the outer one. And since you seem to be interested in only binding to a class, consider modifying the inner class in-place, unlike a function which is wrapped into a method.

>>> class Outer(object):
    class Inner(object):
        class __metaclass__(type):
            def __get__(self, instance, owner):
                self.owner = owner
                return self


>>> Outer.Inner is Outer().Inner
True
>>> Outer.Inner.owner is Outer
True

If you'd rather wrap the inner class via a subclass then replace the _get_ body with:

return type(self.__name__, (self,), {'owner': owner})