Pass Python type to type converters.

This allows to implement custom type encoding/decoding logic
depending on parameter annotatition type.

Closes issue #67.

Author: 1st1

azure/worker/bindings/blob.py

@@ -35,7 +35,8 @@ def check_python_type(cls, pytype: type) -> bool:
                 callable(getattr(pytype, 'read', None))))
 
     @classmethod
-    def to_proto(cls, obj: typing.Any) -> protos.TypedData:
+    def to_proto(cls, obj: typing.Any, *,
+                 pytype: typing.Optional[type]) -> protos.TypedData:
         if callable(getattr(obj, 'read', None)):
             # file-like object
             obj = obj.read()
@@ -50,7 +51,8 @@ def to_proto(cls, obj: typing.Any) -> protos.TypedData:
             raise NotImplementedError
 
     @classmethod
-    def from_proto(cls, data: protos.TypedData,
+    def from_proto(cls, data: protos.TypedData, *,
+                   pytype: typing.Optional[type],
                    trigger_metadata) -> typing.Any:
         data_type = data.WhichOneof('data')
         if data_type == 'string':

azure/worker/bindings/http.py

@@ -72,7 +72,8 @@ def check_python_type(cls, pytype: type) -> bool:
         return issubclass(pytype, (azf_abc.HttpResponse, str))
 
     @classmethod
-    def to_proto(cls, obj: typing.Any) -> protos.TypedData:
+    def to_proto(cls, obj: typing.Any, *,
+                 pytype: typing.Optional[type]) -> protos.TypedData:
         if isinstance(obj, str):
             return protos.TypedData(string=obj)
 
@@ -110,7 +111,8 @@ def check_python_type(cls, pytype: type) -> bool:
         return issubclass(pytype, azf_abc.HttpRequest)
 
     @classmethod
-    def from_proto(cls, data: protos.TypedData,
+    def from_proto(cls, data: protos.TypedData, *,
+                   pytype: typing.Optional[type],
                    trigger_metadata) -> typing.Any:
         if data.WhichOneof('data') != 'http':
             raise NotImplementedError

azure/worker/bindings/meta.py

@@ -129,15 +129,17 @@ def _decode_trigger_metadata_field(
 class InConverter(_BaseConverter, binding=None):
 
     @abc.abstractclassmethod
-    def from_proto(cls, data: protos.TypedData,
+    def from_proto(cls, data: protos.TypedData, *,
+                   pytype: typing.Optional[type],
                    trigger_metadata) -> typing.Any:
         pass
 
 
 class OutConverter(_BaseConverter, binding=None):
 
     @abc.abstractclassmethod
-    def to_proto(cls, obj: typing.Any) -> protos.TypedData:
+    def to_proto(cls, obj: typing.Any, *,
+                 pytype: typing.Optional[type]) -> protos.TypedData:
         pass
 
 
@@ -164,7 +166,8 @@ def check_type_annotation(binding: str, pytype: type) -> bool:
 
 
 def from_incoming_proto(
-        binding: str, val: protos.TypedData,
+        binding: str, val: protos.TypedData, *,
+        pytype: typing.Optional[type],
         trigger_metadata: typing.Optional[typing.Dict[str, protos.TypedData]])\
         -> typing.Any:
     converter = _ConverterMeta._from_proto.get(binding)
@@ -175,7 +178,8 @@ def from_incoming_proto(
         except KeyError:
             raise NotImplementedError
         else:
-            return converter(val, trigger_metadata)
+            return converter(val, pytype=pytype,
+                             trigger_metadata=trigger_metadata)
     except NotImplementedError:
         # Either there's no converter or a converter has failed.
         dt = val.WhichOneof('data')
@@ -186,7 +190,8 @@ def from_incoming_proto(
             f'and expected binding type {binding}')
 
 
-def to_outgoing_proto(binding: str, obj: typing.Any) -> protos.TypedData:
+def to_outgoing_proto(binding: str, obj: typing.Any, *,
+                      pytype: typing.Optional[type]) -> protos.TypedData:
     converter = _ConverterMeta._to_proto.get(binding)
 
     try:
@@ -195,7 +200,7 @@ def to_outgoing_proto(binding: str, obj: typing.Any) -> protos.TypedData:
         except KeyError:
             raise NotImplementedError
         else:
-            return converter(obj)
+            return converter(obj, pytype=pytype)
     except NotImplementedError:
         # Either there's no converter or a converter has failed.
         raise TypeError(

azure/worker/bindings/queue.py

@@ -59,8 +59,9 @@ def check_python_type(cls, pytype: type) -> bool:
         return issubclass(pytype, azf_abc.QueueMessage)
 
     @classmethod
-    def from_proto(cls, data: protos.TypedData,
-                   trigger_metadata) -> azf_abc.QueueMessage:
+    def from_proto(cls, data: protos.TypedData, *,
+                   pytype: typing.Optional[type],
+                   trigger_metadata) -> typing.Any:
         data_type = data.WhichOneof('data')
 
         if data_type == 'string':
@@ -117,7 +118,8 @@ def check_python_type(cls, pytype: type) -> bool:
         return issubclass(pytype, (azf_abc.QueueMessage, str, bytes))
 
     @classmethod
-    def to_proto(cls, obj: typing.Any) -> protos.TypedData:
+    def to_proto(cls, obj: typing.Any, *,
+                 pytype: typing.Optional[type]) -> protos.TypedData:
         if isinstance(obj, str):
             return protos.TypedData(string=obj)
 

azure/worker/bindings/timer.py

@@ -25,7 +25,8 @@ def check_python_type(cls, pytype: type) -> bool:
         return issubclass(pytype, azf_abc.TimerRequest)
 
     @classmethod
-    def from_proto(cls, data: protos.TypedData,
+    def from_proto(cls, data: protos.TypedData, *,
+                   pytype: typing.Optional[type],
                    trigger_metadata) -> typing.Any:
         if data.WhichOneof('data') != 'json':
             raise NotImplementedError

azure/worker/dispatcher.py

@@ -235,20 +235,22 @@ async def _handle__invocation_request(self, req):
 
             args = {}
             for pb in invoc_request.input_data:
-                pb_type = fi.input_binding_types[pb.name]
-                if bindings.is_trigger_binding(pb_type):
+                pb_type_info = fi.input_types[pb.name]
+                if bindings.is_trigger_binding(pb_type_info.binding_name):
                     trigger_metadata = invoc_request.trigger_metadata
                 else:
                     trigger_metadata = None
                 args[pb.name] = bindings.from_incoming_proto(
-                    pb_type, pb.data, trigger_metadata)
+                    pb_type_info.binding_name, pb.data,
+                    trigger_metadata=trigger_metadata,
+                    pytype=pb_type_info.pytype)
 
             if fi.requires_context:
                 args['context'] = bindings.Context(
                     fi.name, fi.directory, invocation_id)
 
-            if fi.output_binding_types:
-                for name in fi.output_binding_types:
+            if fi.output_types:
+                for name in fi.output_types:
                     args[name] = bindings.Out()
 
             if fi.is_async:
@@ -259,15 +261,17 @@ async def _handle__invocation_request(self, req):
                     self.__run_sync_func, invocation_id, fi.func, args)
 
             output_data = []
-            if fi.output_binding_types:
-                for out_name, out_type in fi.output_binding_types.items():
+            if fi.output_types:
+                for out_name, out_type_info in fi.output_types.items():
                     val = args[name].get()
                     if val is None:
                         # TODO: is the "Out" parameter optional?
                         # Can "None" be marshaled into protos.TypedData?
                         continue
 
-                    rpc_val = bindings.to_outgoing_proto(out_type, val)
+                    rpc_val = bindings.to_outgoing_proto(
+                        out_type_info.binding_name, val,
+                        pytype=out_type_info.pytype)
                     assert rpc_val is not None
 
                     output_data.append(
@@ -276,9 +280,10 @@ async def _handle__invocation_request(self, req):
                             data=rpc_val))
 
             return_value = None
-            if fi.return_binding_type is not None:
+            if fi.return_type is not None:
                 return_value = bindings.to_outgoing_proto(
-                    fi.return_binding_type, call_result)
+                    fi.return_type.binding_name, call_result,
+                    pytype=fi.return_type.pytype)
 
             return protos.StreamingMessage(
                 request_id=self.request_id,

azure/worker/functions.py

@@ -7,6 +7,12 @@
 from . import protos
 
 
+class ParamTypeInfo(typing.NamedTuple):
+
+    binding_name: str
+    pytype: typing.Optional[type]
+
+
 class FunctionInfo(typing.NamedTuple):
 
     func: typing.Callable
@@ -16,9 +22,9 @@ class FunctionInfo(typing.NamedTuple):
     requires_context: bool
     is_async: bool
 
-    input_binding_types: typing.Mapping[str, str]
-    output_binding_types: typing.Mapping[str, str]
-    return_binding_type: typing.Optional[str]
+    input_types: typing.Mapping[str, ParamTypeInfo]
+    output_types: typing.Mapping[str, ParamTypeInfo]
+    return_type: typing.Optional[ParamTypeInfo]
 
 
 class FunctionLoadError(RuntimeError):
@@ -49,9 +55,10 @@ def add_function(self, function_id: str,
         sig = inspect.signature(func)
         params = dict(sig.parameters)
 
-        input_types = {}
-        output_types = {}
-        return_type = None
+        input_types: typing.Dict[str, ParamTypeInfo] = {}
+        output_types: typing.Dict[str, ParamTypeInfo] = {}
+        return_binding_name: typing.Optional[str] = None
+        return_pytype: typing.Optional[type] = None
 
         requires_context = False
 
@@ -68,8 +75,10 @@ def add_function(self, function_id: str,
                         func_name,
                         f'"$return" binding must have direction set to "out"')
 
-                return_type = desc.type
-                if not bindings.is_binding(return_type):
+                return_binding_name = desc.type
+                assert return_binding_name is not None
+
+                if not bindings.is_binding(return_binding_name):
                     raise FunctionLoadError(
                         func_name,
                         f'unknown type for $return binding: "{desc.type}"')
@@ -134,11 +143,7 @@ def add_function(self, function_id: str,
                     func_name,
                     f'unknown type for {param.name} binding: "{desc.type}"')
 
-            if is_binding_out:
-                output_types[param.name] = param_bind_type
-            else:
-                input_types[param.name] = param_bind_type
-
+            param_py_type = None
             if param_has_anno:
                 if is_param_out:
                     assert issubclass(param.annotation, azf.Out)
@@ -156,31 +161,44 @@ def add_function(self, function_id: str,
                             f'"{param_bind_type}" does not match its Python '
                             f'annotation "{param_py_type.__name__}"')
 
-        if return_type is not None and sig.return_annotation is not sig.empty:
-            ra = sig.return_annotation
-            if not isinstance(ra, type):
+            param_type_info = ParamTypeInfo(param_bind_type, param_py_type)
+            if is_binding_out:
+                output_types[param.name] = param_type_info
+            else:
+                input_types[param.name] = param_type_info
+
+        return_pytype = None
+        if (return_binding_name is not None and
+                sig.return_annotation is not sig.empty):
+            return_pytype = sig.return_annotation
+            if not isinstance(return_pytype, type):
                 raise FunctionLoadError(
                     func_name,
-                    f'has invalid non-type return annotation {ra!r}')
+                    f'has invalid non-type return '
+                    f'annotation {return_pytype!r}')
 
-            if issubclass(ra, azf.Out):
+            if issubclass(return_pytype, azf.Out):
                 raise FunctionLoadError(
                     func_name,
                     f'return annotation should not be azure.functions.Out')
 
             if not bindings.check_type_annotation(
-                    return_type, ra):
+                    return_binding_name, return_pytype):
                 raise FunctionLoadError(
                     func_name,
-                    f'Python return annotation "{ra.__name__}" does not match '
-                    f'binding type "{return_type}"')
+                    f'Python return annotation "{return_pytype.__name__}" '
+                    f'does not match binding type "{return_binding_name}"')
+
+        return_type = None
+        if return_binding_name is not None:
+            return_type = ParamTypeInfo(return_binding_name, return_pytype)
 
         self._functions[function_id] = FunctionInfo(
             func=func,
             name=func_name,
             directory=metadata.directory,
             requires_context=requires_context,
             is_async=inspect.iscoroutinefunction(func),
-            input_binding_types=input_types,
-            output_binding_types=output_types,
-            return_binding_type=return_type)
+            input_types=input_types,
+            output_types=output_types,
+            return_type=return_type)