How to let a nested class implicitly know about the attributes of an outer class instance that created it?

Question

I am trying to create a client class that is able to be instantiated with connection information and other attributes about how the client is connecting and interacting with a service. The client class would have inner classes that represent objects in the service. These objects could be instantiated in a couple of different ways:

1. The outer, client class has a factory method that creates the inner class, like client.make_someobject() - this would pass an instance of itself to the new object, so the object would know about and can use the connection information without the caller explicitly passing the connection in.
2. An existing object in the service can be pulled in by writing client.SomeObject(some_id)

My question is mostly related to the second scenario. When creating an instance of an inner class directly, without a factory method that can just pass in self, how could I ensure that the new instance of the inner class knows about the attributes of the outer, client class?

Illustrative example:

class Client():
    def __init__(self, client_attr):
        self.client_attr = client_attr

    def make_serviceobject(self):
        return ServiceObject._make_serviceobject(self)

    class ServiceObject():
        def __init__(self, id,client=None):
            self.id = id
            if client:
                self.client = client
            # ...

        @classmethod
        def _make_serviceobject(cls, client):
            id = 'some_id'
            return cls(id, client=client)

my_client = Client(some_attr)
# now, how can this new ServiceObject know about the my_client attributes and methods?
my_existing_resource = my_client.ServiceObject(some_id) 
# I am trying to avoid this: 
my_existing_resource = my_client.ServiceObject(some_id, client=my_client) 

Answer 1

You're pretty close, but there are a few issues here:

1. Class methods (where you expect a class instance to be passed as the first parameter, conventionally named cls, rather than an object instance conventionally named self) need to be decorated with @classmethod. However, there isn't really a reason to set up a hidden class method within the inner class; since it's logic that only gets used by the outer class, and is accessible (via the Client.make_serviceobject interface) from the outer class, it logically belongs in the outer class. (There also isn't a reason to use classmethod anyway - as opposed to staticmethod - because there is no hope of this working polymorphically - the inner class is specific to this outer class.)

2. my_client.ServiceObject (that is, the class name of the inner class, looked up via an outer class instance) just gets you that class itself, rather than anything associated with or bound to the outer class instance.

3. It makes no sense to offer a default None for the inner class' client (i.e., containing instance), because a) there will never be a None value (we only intend to create the instance from the outer class) and b) the outer class instance is presumably necessary for the inner class' functionality (otherwise, why do any of this setup work at all rather than just having two separate classes?)

4. You apparently want to supply the ID from the calling code, so the internal code can't just make one up.

To fix these problems, we simply:

1. Make the outer class' interface do the work needed to create an instance of the inner class, and have it accept a parameter for the ID.

2. Have it do so directly, via the constructor.

3. Have calling code use that interface.

I would also mark the inner class' name to indicate that it isn't intended to be dealt with directly.

It looks like:

class Client():
    def __init__(self, client_attr):
        self.client_attr = client_attr

    def make_serviceobject(self, id):
        # any logic necessary to compute the ID goes here.
        return _ServiceObject(id, self)

    class _ServiceObject():
        def __init__(self, id, client):
            self.id = id
            self.client = client
            # ...

my_client = Client(some_attr)
my_existing_resource = my_client.make_serviceobject('some_id') 
# assert my_existing_resource.client == my_client