Type Annotations in Function interfaces

[effigies]

Python 3 has added annotations, which are accessible via the inspect.getfullargspec function or the inspect.Signature API.

Using these could permit us to add type-checking to Function interfaces whose callables have type/trait annotations for their arguments and return values, and drastically reduce boilerplate for simple interfaces.

For example, suppose we want to have a function:

def split(in_list: list, index: int) -> {'out_left': list, 'out_right': list}:
    return in_list[:index], in_list[index:]

splitter = Function(split)

This would be equivalent to the current approach:

class SplitInputSpec(BaseInterfaceSpec):
    in_list = traits.List(mandatory=True)
    index = traits.Int(mandatory=True)

class SplitOutputSpec(TraitedSpec):
    out_left = traits.List()
    out_right = traits.List()

class Split(SimpleInterface):
    input_spec = SplitInputSpec
    output_spec = SplitOutputSpec

    def _run_interface(self, runtime):
        self._results['out_left'] = self.inputs.in_list[:self.inputs.index]
        self._results['out_right'] = self.inputs.in_list[self.inputs.index:]
        return runtime

splitter = Split()

For more complicated options, annotations could be fully-fledged traits:

def split(in_list: list,
          index: traits.Either('middle', traits.Int, usedefault=True)
          ) -> {'out_left': list, 'out_right': list}:
    if index == 'half':
        index = len(in_list) // 2
    return in_list[:index], in_list[index:]

The goal wouldn't be to replace the current approach for defining interfaces (although perhaps we could make spec-writing much simpler using similar approaches), and promiscuously typed Function interfaces should still be doable, but this could narrow the gap between full interfaces and Function interfaces substantially.

Conversation started in #2520.

Related: #2081 #2083 #2220

[satra]

just a note that full support i believe is only Py 3.6+, but i'm all for reducing boilerplate. we can even introduce an interface decorator that one simply has to attach to the function.

@interface
def split(in_list: list, index: int) -> {'out_left': list, 'out_right': list}:
    return in_list[:index], in_list[index:]

where

def interface(some_function):
    def wrapper():
        ...
        return Function(some_function, ...)
    return wrapper

[effigies]

This is in Pydra.