Call method of specific parent class

Question

This question is related to this topic.

Context:

class OperationDevice(Device):
    def __init__(self):
        super(OperationDevice, self).__init__()

    def operation_start(self):
        # Do operation specific code
        self.start()

    def operation_stop(self):
        # Do operation specific code
        self.stop()


class SimulationDevice(Device):
    def __init__(self):
        super(SimulationDevice, self).__init__()

    def simulation_start(self):
        # Do simulation specific code
        self.fsm.start()

    def simulation_stop(self):
        # Do simulation specific code
        self.fsm.stop()


class DualModeDevice(OperationDevice, SimulationDevice):
    def __init__(self, mode='simulation'):
        super(DualModeDevice, self).__init__()
        self._mode = mode
        self._start_map = {
            'simulation': self.simulation_start,
            'operation': self.operation_start
        }
        self._stop_map = {
            'simulation': self.simulation_stop,
            'operation': self.operation_stop
        }

    def start(self):
        self._start_map[self._mode]()

    def stop(self):
        self._stop_map[self._mode]()

Here I have to define in OperationDevice and SimulationDevice different method name like simulation_start and operation_start (because of MRO).

• I actually want to define the same method name for both class and be able to call each one from DualModeDevice or subclasses. For example operation_start from OperationDevice and simulation_start from SimulationDevice will become start. Is it possible and how?

• This solution is a way to switch between class OperationDevice and SimulationDevice following value of mode. I am wondering wether is it possible to define automatically all method from SimulationDevice linked with mode = "simulation" (same for OperationDevice with "operation") without having to specify for each method (self._start_map for example) in constructor (init) of DualModeDevice.

Answer 1

You could use composition instead of inheritance:

class OperationDevice(Device):
    def __init__(self):
        super(OperationDevice, self).__init__()

    def start(self):
        # Do operation specific code

    def stop(self):
        # Do operation specific code


class SimulationDevice(Device):
    def __init__(self):
        super(SimulationDevice, self).__init__()

    def start(self):
        # Do simulation specific code
        self.fsm.start()

    def stop(self):
        # Do simulation specific code
        self.fsm.stop()


class DualModeDevice(Device):
    def __init__(self, mode='simulation'):
        super(DualModeDevice, self).__init__()
        self._mode = mode
        self._mode_map = {
            'simulation': SimulationDevice(),
            'operation': OperationDevice()
        }

    def start(self):
        self._mode_map[self._mode].start()

    def stop(self):
        self._mode_map[self._mode].stop()

Answer 2

I am wondering wether is it possible to define automatically all method from SimulationDevice linked with mode = "simulation" (same for OperationDevice with "operation") without having to specify for each method (self._start_map for example) in constructor (init) of DualModeDevice.

You could do this using __getattribute__. Something like:

def __getattribute__(self, name):
    if name in methods_to_map:
        return getattr(self.handler, name)
    return super(...).__getattribute__(name)

You would list the method names that you want to map based on mode in methods_to_map (as strings). Then you would set handler to the class implementing the current mode. E.g. self.mode = 'simulation' -> self.handler = SimulationDevice.

Answer 3

You could map the individual parent to a specific mode in you maps as such:

class DualModeDevice(OperationDevice, SimulationDevice):
    def __init__(self, mode='simulation'):
        super(DualModeDevice, self).__init__()
        self._mode = mode
        self._mode_map = {
            'simulation': SimulationDevice,
            'operation': OperationDevice
        }

Then in your DualModeDevice methods do call those functions, passing in self:

def start(self):
    self._mode_map[self._mode].start(self)