如何避免python中的循环引用-类成员创建另一个类的对象并将self作为参数传递？

Question

I need some help in terms of 'pythonic' way of handling a specific scenario.

I'm writing an Ssh class (wraps paramiko) that provides the capability to connect to and executes commands on a device under test (DUT) over ssh.

class Ssh:
    def connect(some_params):
        # establishes connection
    def execute_command(command):
        # executes command and returns response
    def disconnect(some_params):
        # closes connection

Next, I'd like to create a Dut class that represents my device under test. It has other things, besides capability to execute commands on the device over ssh. It exposes a wrapper for command execution that internally invokes the Ssh's execute_command. The Ssh may change to something else in future - hence the wrapper.

def Dut:
    def __init__(some params):
        self.ssh = Ssh(blah blah)

    def execute_command(command)
        return self.ssh.execute_command(command)

Next, the device supports a custom command line interface for device under test. So, a class that accepts a DUT object as an input and exposes a method to execute the customised command.

def CustomCli:
    def __init__(dut_object):
        self.dut = dut_object
    def _customize(command):
        # return customised command
    def execute_custom_command(command):
        return self.dut.execute_command(_customize(command))

Each of the classes can be used independently (CustomCli would need a Dut object though).

Now, to simplify things for user, I'd like to expose a wrapper for CustomCli in the Dut class. This'll allow the creator of the Dut class to exeute a simple or custom command. So, I modify the Dut class as below:

def Dut:
    def __init__(some params):
        self.ssh = Ssh(blah blah)
        self.custom_cli = Custom_cli(self) ;# how to avoid this circular reference in a pythonic way?

    def execute_command(command)
        return self.ssh.execute_command(command)

    def execute_custom_command(command)
        return self.custom_cli.execute_custom_command(command)

This will work, I suppose. But, in the process I've created a circular reference - Dut is pointing to CustomCli and CustomCli has a reference to it's creator Dut instance. This doesn't seem to be the correct design. What's the best/pythonic way to deal with this?

Any help would be appreciated!

Regards

Sharad

Answer 1

In general, circular references aren't a bad thing. Many programs will have them, and people just don't notice because there's another instance in-between like A->B->C->A . Python's garbage collector will properly take care of such constructs.

You can make circular references a bit easier on your conscience by using weak references. See the weakref module. This won't work in your case, however.

If you want to get rid of the circular reference, there are two way:

1. Have CustomCLI inherit from Dut , so you end up with just one instance. You might want to read up on Mixins.

    class CLIMerger(Dut): def execute_custom_command(command): return self.execute_command(_customize(command)) # use self^ instead of self.dut class CLIMixin(object): # inherit from object, won't work on its own def execute_custom_command(command): return self.execute_command(_customize(command)) # use self^ instead of self.dut class CLIDut(Dut, CLIMixin): # now the mixin "works", but still could enhance other Duts the same way pass

   The Mixin is advantageous if you need several cases of merging a CLI and Dut.

2. Have an explicit interface class that combines CustomCli and Dut .

    class DutCLI(object): def __init__(self, *bla, **blah): self.dut = Dut(*bla, **blah) self.cli = CustomCLI(self.dut)

   This requires you to write boilerplate or magic to forward every call from DutCLI to either dut or cli .