Making all attributes and methods available for a socket server in Python

Question

I use a Raspberry Pi to collect sensor data and set digital outputs, to make it easy for other applications to set and get values I'm using a socket server. But I am having some problems finding an elegant way of making all the data available on the socket server without having to write a function for each data type.

Some examples of values and methods I have that I would like to make available on the socket server:

do[2].set_low()    # set digital output 2 low
do[2].value=0      # set digital output 2 low
do[2].toggle()     # toggle digital output 2
di[0].value        # read value for digital input 0
ai[0].value        # read value for analog input 0
ai[0].average      # get the average calculated value for analog input 0
ao[4].value=255    # set analog output 4 to byte value 255
ao[4].percent=100  # set analog output 4 to 100%

I've tried eval() and exec():

self.request.sendall(str.encode(str(eval('item.' + recv_string)) + '\n'))

eval() works unless I am using equal sign (=), but I'm not to happy about the solution because of dangers involved. exec() does the work but does not return any value, also dangerous.

I've also tried getattr():

recv_string = bytes.decode(self.data).lower().split(';')
values = getattr(item, recv_string[0])
self.request.sendall(str.encode(str(values[int(recv_string[1])].value) + '\n'))
                                                                ^^^^^

This works for getting my attributes, and the above example works for getting the value of the attribute I am getting with getattr(). But I can not figure out how to use getattr() on the value attribute as well.

The semi-colon (;) is used to split the incoming command, I've experimented with multiple ways of formatting the commands:

# unit means that I want to talk to a I/O interface module,
# and the name specified which one

unit;unit_name;get;do;1
unit;unit_name;get;do[1]
unit;unit_name;do[1].value

I am free to choose the format since I am also writing the software that uses these commands. I have not yet found a good format which covers all my needs.

Any suggestions how I can write an elegant way of accessing and returning the data above? Preferably with having to add new methods to the socket server every time a new value type or method is added to my I/O ports.

Edit: This is not public, it's only available on my LAN.

Answer 1

Suggestions

Make your API all methods so that eval can always be used:

def value_m(self, newValue=None):
    if newValue is not None:
        self.value = newValue
    return self.value

Then you can always do

result = str(eval(message))
self.request.sendall(str.encode(result + '\n'))

For your message, I would suggest that your messages are formatted to include the exact syntax of the command exactly so that it can be evaled as-is, e.g.

message = 'do[1].value_m()'  # read a value, alternatively...
message = 'do[1].value_m(None)' 

or to write

message = 'do[1].value_m(0)'  # write a value

This will make it easy to keep your messages up-to-date with your API, because they must match exactly, you won't have a second DSL to deal with. You really don't want to have to maintain a second API, on top of your IO one.

This is a very simple scheme, suitable for a home project. I would suggest some error handling in evaluation, like so:

import traceback

try:
    result = str(eval(message))
except Exception:
    result = traceback.format_exc()
self.request.sendall(str.encode(result + '\n'))

This way your caller will receive a printout of the exception traceback in the returned message. This will make it much, much easier to debug bad calls.

NOTE If this is public-facing, you cannot do this. All input must be sanitised. You will have to parse each instruction and compare it to the list of available (and desirable) commands, and verify input validity and validity ranges for everything. For such a scenario you are better off simply using one of the input validation systems used for web services, where this problem receives a great deal of attention.