feat: Support strongly typed functions signature

[kappratiksha]

Add a new signature in functions framework that will support strongly typed objects. This signature will take a strong type T as an input and can return a strong type T, built in types supported by flask or None as an output.

Sample declarations:

@functions_framework.typed(T1)
def my_function(x:T1) -> T2:

@functions_framework.typed
def my_function(x:T1) -> T2:

@functions_framework.typed
def my_function(x:T1) -> None:

@functions_framework.typed
def my_function(x:T1) -> string:

The new signature will only support types abiding by the below contract to convert a python object to and from json:

• Implement from_dict() method. This method converts a dict to the strongly typed python object.
• Implement to_dict() method. This method converts the python object to a dict.

Here is sample python object:

class MyMessage:
    message: str
    retry_limit: int

    def __init__(self, message: str, retry_limit: int) -> None:
        self.message = message
        self.retry_limit = retry_limit

    @staticmethod
    def from_dict(obj: dict) -> 'MyMessage':
        assert isinstance(obj, dict)
        message = from_str(obj.get("message"))
        retry_limit = from_int(obj.get("retryLimit"))
        return MyMessage(message, retry_limit)

    def to_dict(self) -> dict:
        result: dict = {}
        result["message"] = from_str(self.message)
        result["retryLimit"] = from_int(self.retry_limit)
        return result

[anniefu]

Could you add a description to the PR explaining the new feature and a code snippet sample of how to use it? I would define the typed class with the to_dict and from_dict functions in the code snippet to for illustrative purposes.

[anniefu]

Whew, pretty big one! Nice work getting this done!

I think I reviewed everything except tests. But gonna get these comments out for now.

[anniefu]

Oh btw, for the lint check, you can copy the commands executed here to reproduce locally: https://github.com/GoogleCloudPlatform/functions-framework-python/blob/master/.github/workflows/lint.yml

[anniefu]

Just nits and a existential-ish question

[anniefu]

Hmm I've been pondering for a while whether there's a way for us to provide typing here where like someone could hover over the definition of @typed and see that it's supposed to just take one, optional input type parameter instead of this kind of ambiguous *args situation.

I'm not sure it's possible though unless we enforce a named parameter like @typed(input_type=MyType)...

Can you think of anything?

[kappratiksha]

I believe that is the only way to get type hints for a function. Also, it's not very useful for generics also.

if I do something like this-def typed(input_type=T) , the type hints are input_type: Any
We can leave it as is right now, I added documentation for this decorator so it should be a little better.

[haizaar]

Good day,
Is this functionality ready for use? (Couldn't find any docs on that)

Does it supersede functions_framework.http?
I.e. does

@functions_framework.typed
def get(m: MyModel):
  ...

essentially replace

@functions_framework.http
def get(request: flask.Request):
  m = MyModel.from_dict(request.get_json)
  ...

?

Will it work on Google Cloud Functions?

[haizaar]

Answering to myself:

1. It work
2. On Google Cloud Functions too
3. Example:

from __future__ import annotations
from pydantic import BaseModel

class HelloRequest(BaseModel):
    name: str

    @classmethod
    def from_dict(cls, d: dict[str, Any]) -> HelloRequest:
        return cls(**d)

    def to_dict(self) -> dict[str, Any]:
        return self.model_dump()

@functions_framework.typed
def hello(hr: HelloRequest):
    return f"Hello, {hr.name}"

Well done guys!

[HKWinterhalter]

@haizaar Thanks for trying it out and sharing an example! As you may have found, 'typed' is in additional feature and does not deprecate 'http'.