Autocompletion of function parameters in (I)Python for XMLRPC-Client

Question

I am using xmlrpclib to interactively remote control some lab equipment with IPython. I love IPython's autocompletion features and I would also like to have it via xmlrpclib. So far I managed to accomplish method name completion and method help with the following approach.

A little test server simulating a motorized stage (this is only useful, if you want to test my client code):

import time  # needed for StageSimulation
from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler

class StageSimulation:
    """ A very simple simulation of a motorized linear stage """
    v = 5 # mm/s -- speed of stage
    goalPos = 0 # mm -- goal Position in mm
    goalTime = 0 # sec -- time when goal position should be reached


    def getPos(self):
        """ Return actual Position of stage """
        delta_t = self.goalTime - time.time()  # remaining moving time
        if delta_t <= 0 :  # stage is not moving
            return self.goalPos
        else:  # stage is moving
            return self.goalPos - self.v*delta_t

    def move(self, goalPos, v=5):
        """ Move stage to position ``goalPos`` with speed ``v`` """
        p0 = self.getPos()
        delta_p = goalPos - p0

        if v*delta_p < 0: # sign of v wrong
            v *= -1
        self.goalTime = time.time() + delta_p/v
        self.goalPos, self.v = goalPos, v


# Restrict to a particular path (see python Docs)
class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2',)


if __name__=='__main__':
    """ Instaniate Server """   
    host, hport = "localhost", 8787
    LogXMLRPCRequests = False
    server = SimpleXMLRPCServer((host, hport), allow_none=True,
                                requestHandler=RequestHandler)
    server.register_introspection_functions()

    StS = StageSimulation()
    server.register_instance(StS)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("Terminated server.")

My client instantiates an object in which all known methods are registered:

import xmlrpclib


class XMLRPCClientObject(object):
    """XMLRPC Client which allows Tab completion on server instances

    This is achieved by reading all methods names from the server and 
    using them to generate local wrappers to them.
    """

    def __init__(self, url):
        """ Connect to server with ``url`` and generate methods """
        self.SP = xmlrpclib.ServerProxy(url)
        self.generateMethods()


    def generateMethods(self):
       """ Read names of server methods and use them for local wrappers """
       SP = self.SP
       for n in SP.system.listMethods():
           f = getattr(SP, n)
           f.__doc__  = SP.system.methodHelp(n)  # add doc string
           f.__name__ = n  # needed to make help() work
           setattr(self, n, f)  # register as local method 

if __name__ == "__main__":
    """ main function connects to Test Server """
    S = XMLRPCClientObject("http://localhost:8787")

In addition to the method name completion, I would also like to have parameter name completion as in S.move(goal<TAB>. An approach would be to utilize xmlrpc.ServerProxy.system.methodSignature(), but system_methodSignature() is not supported by SimpleXMLRPCServer. Does anybody have an idea how to retrieve the signatures of the server methods?

Answer 1

I tend to think that python inspect module can help, it provides the basics you can use for your desired features