2

I am using Python RPyC to communicate between two machines. Since the link may be prone to errors I would like to have a generic wrapper function which takes a remote function name plus that function's parameters as its input, does some status checking, calls the function with the parameters, does a little more status checking and then returns the result of the function call. The wrapper should have no knowledge of the function, its parameters/parameter types or the number of them, or the return value for that matter, the user has to get that right; it should just pass them transparently through.

I get the getattr(conn.root, function)() pattern to call the function but my Python expertise runs out at populating the parameters. I have read various posts on the use of *arg and **kwarg, in particular this one, which suggests that it is either difficult or impossible to do what I want to do. Is that correct and, if so, might there be a scheme which would work if I, say, ensured that all the function parameters were keyword parameters?

I do own both ends of this interface (the caller and the called) so I could arrange to dictionary-ise all the function parameters but I'd rather not make my API too peculiar if I could possibly avoid it.

Edit: the thing being called, at the remote end of the link, is a class with very ordinary methods, e.g.;

def exposed_a(self)
def exposed_b(self, thing1)
def exposed_c(self, thing1=None)
def exposed_d(self, thing1=DEFAULT_VALUE1, thing2=None)
def exposed_e(self, thing1, thing2, thing3=DEFAULT_VALUE1, thing4=None)
def exposed_f(self, thing1=None, thing2=None)

...where the types of each argument (and the return values) could be string, dict, number or list.

Rob
  • 865
  • 1
  • 8
  • 21
  • No, it isn't difficult or impossible at all, it is trivial... unless you wanted to use variadic arguments and memoization, which is what that linked question is about. – juanpa.arrivillaga Apr 20 '21 at 21:02
  • Well, the number of parameters to the function being passed through will be unknown and whether they are positional or keyword will be unknown: what construction would allow me to pass these through transparently? Embedded C programmer trying to get my head around Python here... – Rob Apr 20 '21 at 21:09
  • 1
    Please add a concrete example to your question. – martineau Apr 20 '21 at 21:10
  • 1
    @Rob you need to add a concrete example. In what form are your arugments? Generaically, you can have a sequence (e.g. list, tuple) of positional arguments, `['foo', 'bar', 42]`, and a mapping (i.e. dict) of named arguments, `{'x':1}`, then just `f(*args, **kwargs)`, note, this should work even if those are empty lists/dicts – juanpa.arrivillaga Apr 20 '21 at 21:11
  • Example function signatures added. – Rob Apr 20 '21 at 21:25
  • @Rob no, the function signatures aren't really relevant. **What is the actual form of the arguments**? You *must* provide a [mcve] – juanpa.arrivillaga Apr 20 '21 at 21:30
  • The argument types, `thingx`, can be string, dictionary, list or a number. – Rob Apr 20 '21 at 21:39
  • Aha, @juanpa.arrivillaga, I think I may see where I was going wrong. I tried the `*args`, `**kargs` construction, but when I called-through the function I left the stars off, so `f(args, kargs)`, which definitely did not work. A quick check suggests that `f(*args, **kargs)` does the trick, exactly as you say. Thank you!!! Syntax is a wonderfuly thing when you get it right. – Rob Apr 20 '21 at 22:02

1 Answers1

0

And it is indeed, trivial, my Goggle fu had simply failed me in finding the answer. In the hope of helping anyone else who is inexperienced in Python and is having a Google bad day:

One simply takes *arg and **kwarg as parameters and passes them directly on, with the asterisks attached. So in my case, to do my RPyC pass-through, where conn is the RPyC connection:

def my_passthru(conn, function_name, *function_args, **function_kwargs):

    # Do a check of something or other here

    return_value = getattr(conn.root, function_name)(*function_args, **function_kwargs)

    # Do another check here

    return return_value

Then, for example, a call to my exposed_e() method above might be:

return_value = my_passthru(conn, e, thing1, thing2, thing3)

(the exposed_ prefix being added automagically by RPyC in this case).

And of course one could put a try: / except ConnectionRefusedError: around the getattr() call in my_passthru() to generically catch the case where the connection has dropped underneath RPyC, which was my main purpose.

Rob
  • 865
  • 1
  • 8
  • 21