Bug: get_field_info_and_type_annotation doesn't respect tuple return types

[philiptzou]

Expected Behaviour

The get_field_info_and_type_annotation function should respect tuple response types since it is supported since 2.7.0. See #1845 and #1853.

Current Behaviour

Validation error (HTTP 422) happens when the endpoint function returning type annotation is a tuple, if we had enable_validation=True for OpenAPI validation.

Code snippet

from pydantic import BaseModel
from aws_lambda_powertools.event_handler import ALBResolver

app = ALBResolver(enable_validation=True)

class Result(BaseModel):
    payload: str

@app.post('/foobar')
def foobar() -> tuple[Result, int]:
    return Result(payload='foobar'), 201

def test_foobar():
    response = app.resolve({
        'path': '/foobar',
        'httpMethod': 'POST',
        'queryStringParameters': {},
        'headers': {}
    })
    assert response['statusCode'] == 201

Instead of 201 Created, the endpoint currently returns 422 error with following body:

{"statusCode":422,"detail":[{"loc":["response"],"type":"tuple_type"}]}

Possible Solution

Update here to support tuple type for a response. In addition, distinguishing is_response_param is necessary for avoiding changing behaviors for other types of annotations.

powertools-lambda-python/aws_lambda_powertools/event_handler/openapi/params.py

Lines 969 to 987 in 8251bb0

	def get_field_info_and_type_annotation(annotation, value, is_path_param: bool) -> Tuple[Optional[FieldInfo], Any]:
	"""
	Get the FieldInfo and type annotation from an annotation and value.
	"""
	field_info: Optional[FieldInfo] = None
	type_annotation: Any = Any
	if annotation is not inspect.Signature.empty:
	# If the annotation is an Annotated type, we need to extract the type annotation and the FieldInfo
	if get_origin(annotation) is Annotated:
	field_info, type_annotation = get_field_info_annotated_type(annotation, value, is_path_param)
	# If the annotation is a Response type, we recursively call this function with the inner type
	elif get_origin(annotation) is Response:
	field_info, type_annotation = get_field_info_response_type(annotation, value)
	# If the annotation is not an Annotated type, we use it as the type annotation
	else:
	type_annotation = annotation
	return field_info, type_annotation

Steps to Reproduce

Please see above code snippet.

Powertools for AWS Lambda (Python) version

latest

AWS Lambda function runtime

3.11

Packaging format used

PyPi

Debugging logs

No response

[boring-cyborg]

Thanks for opening your first issue here! We'll come back to you as soon as we can.
In the meantime, check out the #python channel on our Powertools for AWS Lambda Discord: Invite link

[leandrodamascena]

Hey @philiptzou! Thanks for opening this discussion because I see room to improve our documentation.

Actually this is not a bug, this is an expected behavior but I agree that it's not very clear in our documentation. Before agreeing with next steps, let me explain why this is working as expected.

Prior to PR #1853, customers who wanted to set a specific response code for methods must respond to a method using the Response object or a dict like {"statusCode": 201...}. In PR #1853, we introduced a concept used in other frameworks like Flask, where you can simply use return body, status_code, and we transform it into a Response object. So, based on that, your function will always returns a JSON and that's why data validation is complaining that you are setting the return type to tuple.

Your code should be something like this:

@app.get('/foobar')
def foobar() -> dict:
    return Result(payload='foobar'), 201

While I don't consider this a bug, I do see that we need to improve our documentation to make this clearer and prevent customers from interpreting it as an error.

I'll add the documentation label to this issue and think about a solution. In the meantime, please test it with the code above and see if it works.

[leandrodamascena]

Hey @philiptzou! Please reopen if you have any additional questions.

Thanks