question: If my API already has a base64-encoded PNG, how ought it return it?

[jrobbins-LiveData]

One API endpoint I have receives a base64-encoded PNG. Can I return the data via mangum with content-type image/png without having to first base64-decode it?

[jordaneremieff]

@jrobbins-LiveData I can provide some general information, but would need more details to say much more. The decoding is done by the maybe_encode_body function based on the value of isBase64Encoded from the event for a handler like this. If I'm not misunderstanding, then sounds like you may want to use a custom handler subclass to override this, but just taking my best guess atm.

[jrobbins-LiveData]

Here's a more concrete version of my question.

First, here's where the base64 feature works perfectly. Using pypdf, for example, I can merge some PDF files, in memory, and simply return a FastAPI Response of the bytes, and the ALB adapter of Mangum does exactly what I want.

    # some FastAPI route that receives a JSON body giving instructions about what PDF files to merge
    ...
    output_io = io.BytesIO()
    merger = PdfMerger()
    for pdf_io in pdf_ios:
        merger.append(pdf_io)
    merger.write(output_io)
    merger.close()
    return Response(output_io.getvalue(), media_type='application/pdf')

In a different route, I need to return a screenshot from a Selenium embedded browser using this api. If I get the screenshot as bytes, then the code is equivalent to the PDF example:

    ...
    browser.get(url)
    screenshot = browser.get_screenshot_as_png()
    return Response(content=screenshot, media_type='image/png')

But, suppose for performance reasons, I need to call get_screenshot_as_base64 instead of get_screenshot_as_png?

    ...
    browser.get(url)
    screenshot = browser.get_screenshot_as_base64()
    # NOTE this currently does not work because `maybe_encode_body` base64-encodes the already encoded string
    return Response(content=screenshot, media_type='image/png')

The ALB body @Property uses the incoming request event as its flag, but, since a REST API taking JSON as its input might need to return a base64-encoded response, it would be nice to somehow be able to flag this without reference to the incoming event.

    @property
    def body(self) -> bytes:
        return maybe_encode_body(
            self.event.get("body", b""),
            is_base64=self.event.get("isBase64Encoded", False),
        )

How would I use the handler subclass technique you referred to in order to solve this?

[pkit]

It's impossible to handle right now, as Response expects bytes and is irreversibly mangled by handle_base64_response_body function.