Validate type annotation separately for input and output bindings

Input and output bindings have different requirements for the type
annotation.  Input bindings are usually passed as a specific
`azure.functions` type, whereas the output type may vary.

This corrects converters that implement both In and Out interfaces.

Author: elprans

azure/worker/bindings/__init__.py

@@ -1,5 +1,6 @@
 from .context import Context
-from .meta import check_type_annotation
+from .meta import check_input_type_annotation
+from .meta import check_output_type_annotation
 from .meta import is_binding, is_trigger_binding
 from .meta import from_incoming_proto, to_outgoing_proto
 from .out import Out
@@ -15,6 +16,6 @@
 __all__ = (
     'Out', 'Context',
     'is_binding', 'is_trigger_binding',
-    'check_type_annotation',
+    'check_input_type_annotation', 'check_output_type_annotation',
     'from_incoming_proto', 'to_outgoing_proto',
 )

azure/worker/bindings/blob.py

@@ -47,7 +47,11 @@ class BlobConverter(meta.InConverter,
                     binding='blob'):
 
     @classmethod
-    def check_python_type(cls, pytype: type) -> bool:
+    def check_input_type_annotation(cls, pytype: type) -> bool:
+        return issubclass(pytype, azf_abc.InputStream)
+
+    @classmethod
+    def check_output_type_annotation(cls, pytype: type) -> bool:
         return (issubclass(pytype, (str, bytes, bytearray,
                                     azf_abc.InputStream) or
                 callable(getattr(pytype, 'read', None))))

azure/worker/bindings/http.py

@@ -68,7 +68,7 @@ def get_json(self) -> typing.Any:
 class HttpResponseConverter(meta.OutConverter, binding='http'):
 
     @classmethod
-    def check_python_type(cls, pytype: type) -> bool:
+    def check_output_type_annotation(cls, pytype: type) -> bool:
         return issubclass(pytype, (azf_abc.HttpResponse, str))
 
     @classmethod
@@ -107,7 +107,7 @@ class HttpRequestConverter(meta.InConverter,
                            binding='httpTrigger', trigger=True):
 
     @classmethod
-    def check_python_type(cls, pytype: type) -> bool:
+    def check_input_type_annotation(cls, pytype: type) -> bool:
         return issubclass(pytype, azf_abc.HttpRequest)
 
     @classmethod

azure/worker/bindings/meta.py

@@ -19,7 +19,8 @@ class TypedDataKind(enum.Enum):
 
 class _ConverterMeta(abc.ABCMeta):
 
-    _check_py_type: typing.Mapping[str, typing.Callable[[type], bool]] = {}
+    _check_in_typeann: typing.Mapping[str, typing.Callable[[type], bool]] = {}
+    _check_out_typeann: typing.Mapping[str, typing.Callable[[type], bool]] = {}
     _from_proto: typing.Mapping[str, typing.Callable] = {}
     _to_proto: typing.Mapping[str, typing.Callable] = {}
     _binding_types: typing.Mapping[str, bool] = {}
@@ -37,11 +38,23 @@ def __new__(mcls, name, bases, dct, *,
                 f'registered')
         mcls._binding_types[binding] = trigger
 
-        if binding in mcls._check_py_type:
-            raise RuntimeError(
-                f'cannot register a second check_python_type implementation '
-                f'for {binding!r} binding')
-        mcls._check_py_type[binding] = getattr(cls, 'check_python_type')
+        check_in_typesig = getattr(cls, 'check_input_type_annotation', None)
+        if (check_in_typesig is not None and
+                not getattr(check_in_typesig, '__isabstractmethod__', False)):
+            if binding in mcls._check_in_typeann:
+                raise RuntimeError(
+                    f'cannot register a second check_input_type_annotation '
+                    f'implementation for {binding!r} binding')
+            mcls._check_in_typeann[binding] = check_in_typesig
+
+        check_out_typesig = getattr(cls, 'check_output_type_annotation', None)
+        if (check_out_typesig is not None and
+                not getattr(check_out_typesig, '__isabstractmethod__', False)):
+            if binding in mcls._check_out_typeann:
+                raise RuntimeError(
+                    f'cannot register a second check_output_type_annotation '
+                    f'implementation for {binding!r} binding')
+            mcls._check_out_typeann[binding] = check_out_typesig
 
         if issubclass(cls, InConverter):
             if binding in mcls._from_proto:
@@ -62,10 +75,6 @@ def __new__(mcls, name, bases, dct, *,
 
 class _BaseConverter(metaclass=_ConverterMeta, binding=None):
 
-    @abc.abstractclassmethod
-    def check_python_type(cls, pytype: type) -> bool:
-        pass
-
     @classmethod
     def _decode_typed_data(
             cls, data: typing.Optional[protos.TypedData], *,
@@ -125,6 +134,10 @@ def _decode_trigger_metadata_field(
 
 class InConverter(_BaseConverter, binding=None):
 
+    @abc.abstractclassmethod
+    def check_input_type_annotation(cls, pytype: type) -> bool:
+        pass
+
     @abc.abstractclassmethod
     def from_proto(cls, data: protos.TypedData, *,
                    pytype: typing.Optional[type],
@@ -134,6 +147,10 @@ def from_proto(cls, data: protos.TypedData, *,
 
 class OutConverter(_BaseConverter, binding=None):
 
+    @abc.abstractclassmethod
+    def check_output_type_annotation(cls, pytype: type) -> bool:
+        pass
+
     @abc.abstractclassmethod
     def to_proto(cls, obj: typing.Any, *,
                  pytype: typing.Optional[type]) -> protos.TypedData:
@@ -151,12 +168,23 @@ def is_trigger_binding(bind_name: str) -> bool:
         raise ValueError(f'unsupported binding type {bind_name!r}')
 
 
-def check_type_annotation(binding: str, pytype: type) -> bool:
+def check_input_type_annotation(binding: str, pytype: type) -> bool:
+    try:
+        checker = _ConverterMeta._check_in_typeann[binding]
+    except KeyError:
+        raise TypeError(
+            f'{binding!r} input binding does not have '
+            f'a corresponding Python type') from None
+
+    return checker(pytype)
+
+
+def check_output_type_annotation(binding: str, pytype: type) -> bool:
     try:
-        checker = _ConverterMeta._check_py_type[binding]
+        checker = _ConverterMeta._check_out_typeann[binding]
     except KeyError:
         raise TypeError(
-            f'bind type {binding!r} does not have '
+            f'{binding!r} output binding does not have '
             f'a corresponding Python type') from None
 
     return checker(pytype)

azure/worker/bindings/queue.py

@@ -55,7 +55,7 @@ class QueueMessageInConverter(meta.InConverter,
                               binding='queueTrigger', trigger=True):
 
     @classmethod
-    def check_python_type(cls, pytype: type) -> bool:
+    def check_input_type_annotation(cls, pytype: type) -> bool:
         return issubclass(pytype, azf_abc.QueueMessage)
 
     @classmethod
@@ -114,7 +114,7 @@ def _parse_datetime_metadata(
 class QueueMessageOutConverter(meta.OutConverter, binding='queue'):
 
     @classmethod
-    def check_python_type(cls, pytype: type) -> bool:
+    def check_output_type_annotation(cls, pytype: type) -> bool:
         return issubclass(pytype, (azf_abc.QueueMessage, str, bytes))
 
     @classmethod

azure/worker/bindings/timer.py

@@ -21,7 +21,7 @@ class TimerRequestConverter(meta.InConverter,
                             binding='timerTrigger', trigger=True):
 
     @classmethod
-    def check_python_type(cls, pytype: type) -> bool:
+    def check_input_type_annotation(cls, pytype: type) -> bool:
         return issubclass(pytype, azf_abc.TimerRequest)
 
     @classmethod

azure/worker/functions.py

@@ -157,8 +157,12 @@ def add_function(self, function_id: str,
                 else:
                     param_py_type = param.annotation
                 if param_py_type:
-                    if not bindings.check_type_annotation(
-                            param_bind_type, param_py_type):
+                    if is_param_out:
+                        checker = bindings.check_output_type_annotation
+                    else:
+                        checker = bindings.check_input_type_annotation
+
+                    if not checker(param_bind_type, param_py_type):
                         raise FunctionLoadError(
                             func_name,
                             f'type of {param.name} binding in function.json '
@@ -186,7 +190,7 @@ def add_function(self, function_id: str,
                     func_name,
                     f'return annotation should not be azure.functions.Out')
 
-            if not bindings.check_type_annotation(
+            if not bindings.check_output_type_annotation(
                     return_binding_name, return_pytype):
                 raise FunctionLoadError(
                     func_name,