Detecting and configuring a FastAPI project for debugging

[brettcannon]

For the Python extension for VS Code we are starting to add support to automatically detect and configure debugging for select web frameworks (you can already configure debugging manually; this is just a nicety). We would like to have support for FastAPI in this situation, but we need to know two things:

1. How best to detect a project is a FastAPI project (preferably w/o running code, i.e. statically)
2. What configuration settings should get set?

If there are any specific guidelines you can provide that would be greatly appreciated!

[acidjunk]

Can you look at requirements/setup.py or project toml files?

Or fastapi imports?

[brettcannon]

It doesn't need to cover all cases, just common cases. You can still configure the debugger manually; this is just a helpful feature to make it easier when possible.

[adriangb]

I assume you're not trying to support multiple web framework setups? In theory you can have Quart mount/wrap a FastAPI app and such. If not, maybe looking for instantiation of the main FastAPI object might work (<var> = FastAPI(...)) sort of thing? There's no real standard structure for FastAPI applications. app.py is pretty common but so are main.py, etc.

I'd encourage you to support Starlette directly if you can since that should cover Starlette, FastAPI and any other web frameworks wrapping Starlette. I can't think of any configurations that would be different for Starlette vs. FastAPI.

[brettcannon]

We are not trying to support multiple frameworks at once with this. You could write your own debug configuration in that instance, but once again we are targeting the common case only here since this is entirely to be nice to users to make the simple case easy.

[adriangb]

What do these debug configurations consist of that would make it so specific to FastAPI? Maybe you know this already but JFYK FastAPI is mostly a thin wrapper around Starlette, my thought was if the debug configuration would be the same why not support Starlette so that you get support for both frameworks for the price of one.

[brettcannon]

What do these debug configurations consist of that would make it so specific to FastAPI?

You tell us (hence question 2). 🙂 We are not presupposing we know what we are doing when it comes to FastAPI, so we are asking here so we do the right thing for FastAPI users.

[tiangolo]

This is awesome!

Here are the heuristics:

File

The main file would be:

• main.py

After that, the next most common options would be:

• app/main.py
• app.py

And other possible but probable quite less common options:

• app/app.py
• api.py
• app/api.py
• api/main.py

Object

Inside of that file, there would normally be an object app. It would be an instance of the class FastAPI(). The instantiation would normally be in that same file.

The symbol/class FastAPI comes from fastapi.FastAPI (exported in the __init__.py of the package), and is defined in fastapi.applications.FastAPI.

Another possible name for that object would be api, but probably not too common.

Config

The JSON object at .vscode/launch.json would have:

        {
            "name": "Python: FastAPI",
            "type": "python",
            "request": "launch",
            "module": "uvicorn",
            "args": [
                "${fileToPythonModule}:${appObject}"
            ],
            "jinja": true
        }

Where fileToPythonModule would point to the file, converting it to a Python module path, so, if it was app/main.py then this would be app.main.

And where appObject would be the object that is an instance of the FastAPI class, normally just the variable app.

You already have a launch debug template, @Kludex implemented it, the main thing I would think could be improved automatically is detecting that file and that variable.

Normally the app object is at the top level, there are not many cases where it needs a factory function, so in most cases, it should be statically analyzable (I would think). Just the object that is an instance of the FastAPI class.

[Kludex]

fwiw <package>/main.py should also be common.