Best practice to structure multiple module

[yihuang]

When I sperate apis into multiple module, I find it hard to structure the code, currently I approach like this:

# app.py
from fastapi import FastAPI
app = FastAPI()

# api1.py
from app import app

@app.get('/test1')
...

# api2.py
from app import app

@app.get('/test2')
...

# main.py
from app import app
import api1
import api2

$ uvicorn main:app --lifespan on
...

Any suggestions?

[dmontagu]

From the FastAPI project-generator codebase:

# app/api/api_v1/endpoints/items.py
...

from fastapi import APIRouter, Depends, HTTPException

...

router = APIRouter()


@router.get("/", response_model=List[Item])
...

# app/api/api_v1/api.py
from fastapi import APIRouter

from app.api.api_v1.endpoints import items, login, users, utils

api_router = APIRouter()
api_router.include_router(login.router, tags=["login"])
api_router.include_router(users.router, prefix="/users", tags=["users"])
api_router.include_router(utils.router, prefix="/utils", tags=["utils"])
api_router.include_router(items.router, prefix="/items", tags=["items"])

# app/main.py
from fastapi import FastAPI

...

from app.api.api_v1.api import api_router

...

app = FastAPI(title=config.PROJECT_NAME, openapi_url="/api/v1/openapi.json")

...

app.include_router(api_router, prefix=config.API_V1_STR)

...

[yihuang]

Great, thanks!

[tiangolo]

Thanks @dmontagu! : 🍰

@yihuang the docs about that are here: https://fastapi.tiangolo.com/tutorial/bigger-applications/

[markqiu]

Hi, guys, I think this is great, thanks. But when using this strategy, It's easy to get 302, why?

For example:
test_client.get("/api/v1/items") # 302
test_client.get("/api/v1/items/") # OK

[dmontagu]

@markqiu it’s because you are creating an endpoint with path "/" mounted at ".../items". So the full endpoint path is ".../items/". The 302 is because the system realizes that /items isn’t a valid endpoint, and you probably meant ".../items/", so it redirects.

If you don’t want your paths to end in a / (eg if you are using a client library that likes to remove trailing slashes... been there...), make sure you never have paths ending in / in the endpoint decorators (this includes just a single slash).

[markqiu]

@dmontagu But If a path includes just a single slash, you can't define the endpoint decorators like this:
@router.get("", response_model=List[Item])

[dmontagu]

Right, you'd have to give it a name (e.g. @router.get("/items", response_model=List[Item])).

You can mount multiple routers with the same prefix if, for example, you want to have multiple distinct resources with the same prefix and different non-slash-ending endpoints:

from fastapi import FastAPI, APIRouter

app = FastAPI()

router1 = APIRouter()
router2 = APIRouter()


@router1.get("/items")
async def read_items():
    return []


@router2.get("/things")
async def read_things():
    return []


app.include_router(router1, prefix="")
app.include_router(router2, prefix="")

if __name__ == '__main__':
    import uvicorn

    uvicorn.run(app, host='0.0.0.0', port=8000)

[markqiu]

ok, thanks.

[jgunstone]

hi there,
I have a large-ish application (app-1) that I structure in the way described in the bigger-applications tutorial.
I'm working on another application (app-2) that is for the most part standalone, but app-1 will require some data from app-2.

I'm considering how the structure the project.
I'd like app-2 to have its own git repo and be standalone for testing etc. as this will simplify development.
My starting point is to just make and deploy 2no separate standalone APIs and make app-1 query the app-2 api as required....

... but now I'm wondering if I could deploy the 2no packages as a single API.
issues I can see are:

1. need 2no models.py files to have the same Base. Could define Base in a parent file that is imported into the models.py file in app-1 and app-2.

from sqlalchemy import create_engine, MetaData
from sqlalchemy.orm import relationship, configure_mappers, validates
from sqlalchemy.orm import declarative_base

Base = declarative_base()

2. similarly need 2no app.py files that use a common FastAPI app. So this too would need to be defined in some parent and imported in with each package adding its own routers.

app = FastAPI(
    # openapi_tags=tags_metadata,
    title="document-issue",
    description=description,
    version="0.3.0",
    contact={
        "name": "John Gunstone",
        "email": "j.gunstone@maxfordham.com",
    },
)

ideally there would be some logic within each package that says something like "if app defined and available then use it, else instantiate it here", thus allowing it to run in standalone mode for testing.

is this a good / bad idea?
any thoughts welcome

[alv2017]

@jgunstone

I would recommend you to create a separate discussion topic.
(Did you think about using microservices architecture? Did you think about Django supported architecture?)