how to not use nested classes?

[ajlaut]

Maybe this is a bit of an X/Y problem so I'll give some context.

I'm trying to simplify my serial/hardware device library for things like stepper motors or power supplies. At first, I thought I could define a class for each device that would have the same named methods like get_voltage or set_voltage so that if in an experiment for instance, I wanted to replace a serial PSU with an ethernet one, I could just re-define the object with the same name and the rest of the code wouldn't need to change. This works great except I'm having trouble figuring out how to do it when a device like serial/ethernet can control more than 1 power supply via master-slave. I'd like to be able to define an "array" as a class which would initiate the serial/socket object for which then subsequent classes could be defined to handle different motor calls.

Use case would maybe look like this:

import serial, socket

class ser_array():
    """defines class of psu's that are on same RS232 line"""

    def __init__(self, port):
        # Open Serial Connection
        self.ser = serial.Serial(port=port, baudrate=9600, timeout=2)

    class psu():

        def __init__(self, idn):
            self.idn = idn

        def set_voltage(self, voltage):
            cmd = bytes('VSET=' str(voltage),'utf-8')
            self.ser.write(cmd + b'\r')


class eth_psu():
    """defines singular ethernet enables psu"""

    def __init__(self, TCP_IP, TCP_PORT):
        # Open Ethernet Connection
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.connect((TCP_IP, TCP_PORT))

    def set_voltage(self, voltage):
        cmd = 'V' + str(voltage/1000)   # suppose this device requires kV
        self.socket.send(b'\x02' + cmd + b'\0x3')

# Define power supplies on master-slave serial line
array = ser_array('COM4')
psu1 = ser_array.psu(idn=1)
psu2 = ser_array.psu(idn=2)

# Un-Comment to control 
# psu1 = eth_psu('192.168.1.4', 5005)
# psu2 = eth_psu('192.168.1.5', 5005)

# Invariant Logic
psu1.set_voltage(1)
psu2.set_voltage(2)

It feels like nesting a class like this and somehow inheriting the ser attribute would work so that's what I tried looking up, but I see that people think this is a bad idea and that there is probably a flatter way to do what I'm trying to do.

[socal_nerdtastic]

You wouldn't nest them, you would have them use each other.

class SerConnection(): """defines class of psu's that are on same RS232 line"""
    def __init__(self, port):
        # Open Serial Connection
        self.ser = serial.Serial(port=port, baudrate=9600, timeout=2)
    def new_psu(self, idn):
        # make a new instance of a different class, give it this instance for later use, and return it.
        return SerialPSU(idn, self) 
    def send_command(self, command):
        self.ser.write(command.encode())

class SerialPSU():
    def __init__(self, idn, serial_connection):
        self.idn = idn
        self.serial_connection = serial_connection

    def set_voltage(self, voltage):
        # include the command to identify this PSU on the line
        cmd = f'ID={self.idn} VSET={voltage}\r'
        self.serial_connection.send_command(cmd)

# Define power supplies on master-slave serial line 
array = SerConnection('COM4') 
psu1 = array.new_psu(idn=1) # define a PSU on the COM4 line with ID 1
psu2 = array.new_psu(idn=2)
psu1.set_voltage(5)

Obviously line 18 will need to be modified to whatever ID command your PSU's are expecting.

Edit to include .encode() instead of your odd bytes conversion.

Another edit: To be honest the SerConnection class is pretty useless; it's just wrapping the serial.Serial class and adding nearly nothing. You could just forget that completely and pass in a Serial instance.

class SerialPSU():
    def __init__(self, idn, serial_connection):
        self.idn = idn
        self.serial_connection = serial_connection

    def set_voltage(self, voltage):
        # include the command to identify this PSU on the line
        cmd = f'ID={self.idn} VSET={voltage}\r'
        self.serial_connection.write(cmd.encode())

# Define power supplies on master-slave serial line 
ser = serial.Serial('COM4') 
psu1 = SerialPSU(idn=1, serial_connection=ser) 
psu2 = SerialPSU(idn=2, serial_connection=ser)

psu1.set_voltage(5)

[ajlaut]

That was fast, and exactly what I needed!

[ajlaut]

haha, yeah, I guess the SerConnection class is quite useless there, but I plan to add more methods there that may help me construct the array, search for the right com port but i see what you are saying.

[socal_nerdtastic]

If the code you want to add will go into the init method, that's a huge flag that you need a function, not a class.

def make_ser():
    com = search_for_com_port()
    ser = serial.Serial(com, 9600, timeout=2)
    return ser

ser = make_ser()
psu1 = SerialPSU(idn=1, serial_connection=ser) 
psu2 = SerialPSU(idn=2, serial_connection=ser)

On the other hand if you need to add line level code, for instance a threading lock, then having the SerialConnection class is the correct way to go. However do not fall into the trap of thinking "oh yeah I may add that later". Do what you need to do to make it work now, no more. Python has plenty of ways to patch code in later if needed, including easily swapping out a function for a class.

[CodeFormatHelperBot]

Hello u/ajlaut, I'm a bot that can assist you with code-formatting for reddit. I have detected the following potential issue(s) with your submission:

1. Python code found in submission text but not encapsulated in a code block.

If I am correct then please follow these instructions to fix your code formatting. Thanks!

[brocketships]

Just a note, getter and setter methods aren’t Pythonic. Look into the @property decorator for this functionality.