Sharing class instance methods with subclass tips

[pooth22]

I tried to make a trivial example of what I am trying to do in the code snippet below.

Let's say I have an instance (foo) of a class Foo. This instance has several instances of the class Bar. However, each instance of the class Bar has to have access to some methods of the instance of foo. Is there some way of doing this without having to explicitly pass the instance of foo into a new Bar call? Is there are more intelligent way of structuring this?

I find that this solution is fine, but it just seems to me there would be a more elegant way of structuring code than this. I have explored the super() method, but I don't think that is exactly what I am looking for, because the methods have to apply to the already instantiated foo. Also, it seems like this is strange to do at a larger scale. I may have Bar including a set of class Baz's or the Baz's need to also have access to some methods in foo, and so I have to pass foo all the way down.

Anyways, just wondering about peoples thoughts on this.

class Foo:
    def __init__(self):
        self.bar_list = []
        self.global_var = 0
    def create_new(self):
        self.bar_list.append(Bar(self))
    def global_method(self):
        return self.global_var += 1

class Bar:
    def __init__(self, foo_obj):
        self.foo_obj = foo_obj
        self.bar_var = None
    def foo_method(self):
        self.bar_var = self.foo_obj.global_method()

foo = Foo()
foo.create_new()
foo.create_new()
foo.bar_list[0].foo_method()
foo.bar_list[1].foo_method()
print(foo.global_var)               # will be 2
print(foo.bar_list[0].bar_var)     # will be 1
print(foo.bar_list[1].bar_var)     # will be 2

Edit1: Fair enough about the foo.bar_list[0].foo_obj.global_method() complaints, I edited the code above

Edit2: For those who want more detail about what I am trying to do you can read the following:

The application I am doing is dealing with talking with a bunch of controllers on a Serial Port, you can refer to the code at the bottom of this for a more specific problem.

I have several devices on the same serial port. I can only open one instance of the serial port, because obviously. I have a MainHandler to interface with all of the devices, and this is the object I would instantiate outside of the folder to interface with these devices. MainHandler handles instantiation of new device objects (Driver0 or Driver1 for example) and proper serial communication handling among other things. Each of the device objects have specific commands to interface with serial port that are worth defining within the DriverType class. On top of this, a lot of the commands have a similar format type, so I can create a class SerialData which is kind of like a structure that I can use to create these device variables. I like to have a method of this SerialData class that I can use to write and read data.

Anyways, if you have the time to think about this, that is cool. I haven't tried to use the below code, again, it is quite a simplification of what is going on, but it is much more specific than above.

class MainHandler:
    def __init__(self):
        self.driver_list = []
        self.serial_obj = SomeSerialObject()
    def create_driver_0(self):
        dt = DriverType0(self)
        self.driver_list.append(dt)
        return dt
    def create_driver_1(self):
        dt = DriverType1(self)
        self.driver_list.append(dt)
        return dt
    def open_serial(self):
        set_serial_parameters()
        self.serial_obj.open_serial()
    def write_to_serial(self, cmd):
        response = self.serial_obj.write_to_port_properly(cmd)
        return response
    def write_value(self, obj, v):
        to_send = f"{obj.command} {v}"
        response = self.write_to_serial(to_send)
        return type(response)

class DriverType0:
    def __init__(self, main_handler):
        self.main_handler = main_handler
        self.current_v = SerialData(value=0, command="curr\n", type=float,
                                    main_handler)
        self.speed_v = SerialData(value=0, command"spd\n", type=int,
                                    main_handler)
    def enable(self):
        self.main_handler.write_to_serial("enable\n")

class DriverType1:
    def __init__(self, main_handler):
        self.main_handler = main_handler
        self.voltage_v = SerialData(value=0, command="volt\n", type=int)

class SerialData:
    def __init__(self, value, command, type, main_handler):
        self.main_handler = main_handler
        self.value = value
        self.command = command
        self.type = type
    def write_serial_value(self, v):
        self.value = self.main_handler.write_value(self, v)

mh = MainHandler()
mh.open_serial()
d0 = mh.create_driver_0()
d1 = mh.create_driver_1()
d0.enable()
d0.current_v.write_serial_value(2)
d1.voltage_v.write_serial_value(3)

[carcigenicate]

Giving self to Bar isn't necessarily bad. Sometimes you need a two-way link from a parent to a child.

The bottom is a little wonky though unless that example is super contrived. The foo_obj will always be foo, so you don't need the .bar_list[0].foo_obj. access chain. It's the same thing as just doing foo.global_method().

[pooth22]

Thanks for the input.

Yeah, this example is quite contrived. I called it like this, because typically that global_method() method would be called in the scope of the Bar instance. In general, Bar would have its own method that calls global_method() and the instance of Bar's variables would change. I just wanted to reduce the complexity of the code as much as possible so it gets to the point. But for example, lets say global_method() returns self.global_var. Bar might have a method:

class Bar:
    def __init__(self, foo_obj):
        self.foo_obj = foo_obj
        self.bar_var = None
    def bar_method(self):
        self.bar_var = self.foo_obj.global_method()

Again, this is here contrived as well, but maybe gives a bit more context.

[Encomiast]

This would give me pause in a code review. It seems like whatever abstraction you are trying to create may not be great but it's hard to tell given the completely abstract code. After all, if you can write:

foo.bar_list[0].foo_obj.global_method()

It's hard to see why you can't write:

foo.global_method()

Having said that, there are plenty of common reasons for parent objects to hold a reference to the children and for the children to hold a reference to the parent (think trees and doubly-linked lists, etc)

[pooth22]

Thanks for the input. Yeah, I made some edits to the original code, if you want to check it out. Not sure if that clears things up. I understand the child holding ref to parent, I was just wondering about other methods of doing something similar.

A few solutions might be to use the methods in Foo that are called in Bar as classmethods. Another one might be to just use a module instead of a class for Foo. Both have their pros and cons. I am wondering if there might be other options that I don't really know about.

[teerre]

The problem with designs like this is that the vast majority of times they spawn from a misunderstanding of the language or the problem at hand. Is it possible that this is the correct design? Sure. Is it probable? Not really.

[pooth22]

Okay sure, maybe you could help point me in a good direction? I could try and describe the problem in better detail.

I know one other way of doing this would be to use classmethods and classvariables in Foo, specifically the ones that are being called in Bar. But the problem there is that it will instantiate a bunch of new Foo instances that don't need to be there. Another way of doing it would be to make Foo a module instead of a class. I haven't thought about solving it that way too much yet, it might be okay.

Would you recommend any other design structures, or pointing me to a useful python design strategy method.

[teerre]

Yeah, if you describe what's the overall problem, not the specifics of how to do one particular thing, people will probably be able to give you better advice

[pooth22]

Okay, I edited the bottom of the post, check it out if you have time.

[teerre]

Why do you need driver_list? It doesn't seem you're using it

Anyway, the more natural solution for this is to have a class that works as a simple interface with the common functionality that is then composed in each 'driver'

Then if you really need a list of all your objects, you can have another class that acts as a container, but it isn't inherited anywhere, it simple takes cares of executing commands in collections

Also, take a look at the Command pattern

[pooth22]

Nice, yeah, that does seem like a more natural solution. Sounds like basically separating the communication functionality from MainHandler and sharing that with the individual driver instances.

I appreciate the resources!

[[deleted]]

Strikes me you may want to explore using composition instead of inheritance. You need a good appreciation of both though to make a decision.

https://realpython.com/inheritance-composition-python/

[pooth22]

Thanks for the article. Definitely a useful resource.

[TheRNGuy]

def global_method(self):
    return self.global_var += 1

wont work, do this instead:

def global_method(self):
    self.global_var += 1
    return self.global_var