No call_method_full in Class Node

[CuriousCrook]

Is there any reason, why there is no call_method_full() used in class Node?
call_method() is used there...

The funktions call_method() and call_method_full() are defined in ./common/methods.py.
The class Node is defined in ./common/node.py.

I occasionally use call_method_full(). Are there any reasons not to include it in the Node class?

[oroulet]

call_method_full was a hack to solve an issue without changing the API.
I just looked at it now and it is not very nice. the name full tend to say if exposes more arguments, in reality it changes the parsing of the result. to something hybrid, not returning clean python objects and not returning the real Ua objects either.

if you want something better maybe you could add a named argument to call_method like return_raw=False that really returns the UA result without any modification of it.

[CuriousCrook]

I need the results of the input arguments, which are contained in the call_method_full() function. This is why I use (and like) it.
For me a optional argument like with_input_argument_results=False will meet my requirements.

But I think optional argument should not change the structure of the return value.
IMHO it would be unpleasant if one has to evaluate the OutputArguments differently, in case one also wants the InputArgumentResults.

Example:
ret = call_method(..., with_input_argument_results=False)
> ret = [1, 2, 3]

or
ret = call_method(..., with_input_argument_results=True)
> ret = CallMethodResults(InputArgumentResults=[...], OutputArguments=[1, 2, 3])

That is why I personally would prefer another method like method_call_with_input_results().

I'd be happy to take this over. How would you like it?

[oroulet]

Good point, changing the output is a bad idea. so you proposition is better. But if we first return more details I would prefer to return the raw result so satisfy everyone- For example call it method_call_with_raw_result() and really return everything

[CuriousCrook]

You say that the result is "something hybrid" that does not return clean Python objects and also not the real Ua objects. Would you like to have the "old" output of the method_call_full() method under the new name method_call_with_raw_result()?
Or do you have any wishes what the return value should look like?

[oroulet]

The code in call method_full is:

result = await _call_method(parent.server, parent.nodeid, methodid, to_variant(*args))
    if result.OutputArguments is None:
        result.OutputArguments = []
    result.OutputArguments = [var.Value for var in result.OutputArguments]
    return result

that does not make any sense. OutputArguments is a defined, typed, structure and we overwrite one member of it with another type than the original one.
Either we return a pythonic output (as in call_method()) or we should simply return the result which is CallMethodResult, without modifying it (as we should do in "call_method_raw_result()" for example.)

[oroulet]

also it would be nice with a bit of typing so it is clear whant these methods return. (And you will fnd out it is impossibe to type that methd "call_method_full", it returns something that does not exist