Disable async functions as a app_factory

[inyutin]

Look at this code:

async def make_server_app() -> FastAPI:
    return FastAPI()


async def main() -> None:
    server_app = make_servep_app()
    config = uvicorn.Config(server_app, port=settings.APP_PORT)
    server = uvicorn.Server(config)
    await server.serve()


if __name__ == "__main__":
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    loop.run_until_complete(main())

This is a simplified version of a program I'm working on. If you will try to run it - you will not encountered any errors:

^^/C/t/Contigo-Integration >>> PYTHONPATH=. poetry run python main/server.py         (*master) 21:35:59
INFO:     Started server process [1755017]
INFO:     Waiting for application startup.
INFO:     ASGI 'lifespan' protocol appears unsupported.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

But (!) any request to this API will fail:

ERROR:    Exception in ASGI application
Traceback (most recent call last):
  File "/home/dmitry/.cache/pypoetry/virtualenvs/contigo-integration-r0O_5Ty1-py3.9/lib/python3.9/site-p
ackages/uvicorn/protocols/http/httptools_impl.py", line 401, in run_asgi
    result = await app(self.scope, self.receive, self.send)
  File "/home/dmitry/.cache/pypoetry/virtualenvs/contigo-integration-r0O_5Ty1-py3.9/lib/python3.9/site-p
ackages/uvicorn/middleware/proxy_headers.py", line 78, in __call__
    return await self.app(scope, receive, send)
TypeError: 'coroutine' object is not callable
INFO:     127.0.0.1:44782 - "GET /docs HTTP/1.1" 500 Internal Server Error

I probably spend half an hour trying to find what's wrong here. There is no warnings from Uvicorn, there is no mypy errors.
The problem is that make_server_app is async function. Let's check Uvicorn code.

1. There is a type definition for appin uvicorn.Config.__init__(...):

app: Union["ASGIApplication", Callable, str],

So app receives any Callable, which is obviously incorrect. My first proposal is to set here type Callable[Any, "ASGIApplication"] instead of plain Callable. By doing this mypy will raise an error and modern code editors will give a hint of an error too.

2. Let's check how app variable is used further on:

        try:
            self.loaded_app = import_from_string(self.app)
        except ImportFromStringError as exc:
            logger.error("Error loading ASGI app. %s" % exc)
            sys.exit(1)

        try:
            self.loaded_app = self.loaded_app()
        except TypeError as exc:
            if self.factory:
                logger.error("Error loading ASGI app factory: %s", exc)
                sys.exit(1)
        else:
            if not self.factory:
                logger.warning(
                    "ASGI app factory detected. Using it, "
                    "but please consider setting the --factory flag explicitly."
                )

        if self.interface == "auto":
            if inspect.isclass(self.loaded_app):
                use_asgi_3 = hasattr(self.loaded_app, "__await__")
            elif inspect.isfunction(self.loaded_app):
                use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
            else:
                call = getattr(self.loaded_app, "__call__", None)
                use_asgi_3 = asyncio.iscoroutinefunction(call)
            self.interface = "asgi3" if use_asgi_3 else "asgi2"

        if self.interface == "wsgi":
            self.loaded_app = WSGIMiddleware(self.loaded_app)
            self.ws_protocol_class = None
        elif self.interface == "asgi2":
            self.loaded_app = ASGI2Middleware(self.loaded_app)

        if self.debug:
            self.loaded_app = DebugMiddleware(self.loaded_app)
        if logger.level <= TRACE_LOG_LEVEL:
            self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
        if self.proxy_headers:
            self.loaded_app = ProxyHeadersMiddleware(
                self.loaded_app, trusted_hosts=self.forwarded_allow_ips
            )

        self.loaded = True

There you can see why it behaves as I described above. Instead of ASGIApplication my factory ASGIApplication returned an awaitable object. So, loaded_app is "Awaitable" and that's why "asgi2" selected. But this thing is sync, so while serving requests an error raised, as I showed you above. My second proposal is to raise here an error, like "you can't use async factory app.__name___.

What do you think about those proposals ? I hope you will agree with me and in this case I will raise an issue and send a PR

[Kludex]

PR welcome to improve type annotation.

[inyutin]

@Kludex what about second suggestion ?