Kludex/fastapi-tips
Kludex/fastapi-tips là dự án mã nguồn mở trên GitHub, với 3.6k sao. FastAPI Tips by The FastAPI Expert!
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Snapshot
Cộng tác viên hàng đầu
Xem cộng tác viên hàng đầu
101 FastAPI Tips by The FastAPI Expert
This repository contains tips and tricks for FastAPI. If you have any tip that you believe is useful, feel free to open an issue or a pull request.
Consider sponsoring me on GitHub to support my work. With your support, I will be able to create more content like this.
[!TIP] Remember to watch this repository to receive notifications about new tips.
1. Install uvloop and httptools
By default, Uvicorn doesn't come with uvloop and httptools which are faster than the default
asyncio event loop and HTTP parser. You can install them using the following command:
pip install uvloop httptools
Uvicorn will automatically use them if they are installed in your environment.
[!WARNING]
uvloopcan't be installed on Windows. If you use Windows locally, but Linux on production, you can use an environment marker to not installuvloopon Windows e.g.uvloop; sys_platform != 'win32'.
2. Be careful with non-async functions
There's a performance penalty when you use non-async functions in FastAPI. So, always prefer to use async functions.
The penalty comes from the fact that FastAPI will call run_in_threadpool, which will run the
function using a thread pool.
[!NOTE] Internally,
run_in_threadpoolwill useanyio.to_thread.run_syncto run the function in a thread pool.
[!TIP] There are only 40 threads available in the thread pool. If you use all of them, your application will be blocked.
To change the number of threads available, you can use the following code:
import anyio
from contextlib import asynccontextmanager
from typing import Iterator
from fastapi import FastAPI
@asynccontextmanager
async def lifespan(app: FastAPI) -> Iterator[None]:
limiter = anyio.to_thread.current_default_thread_limiter()
limiter.total_tokens = 100
yield
app = FastAPI(lifespan=lifespan)
You can read more about it on AnyIO's documentation.
3. Use async for instead of while True on WebSocket
Most of the examples you will find on the internet use while True to read messages from the WebSocket.
I believe the uglier notation is used mainly because the Starlette documentation didn't show the async for notation for a long time.
Instead of using the while True:
from fastapi import FastAPI
from starlette.websockets import WebSocket
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket) -> None:
await websocket.accept()
while True:
data = await websocket.receive_text()
await websocket.send_text(f"Message text was: {data}")
You can use the async for notation:
from fastapi import FastAPI
from starlette.websockets import WebSocket
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket) -> None:
await websocket.accept()
async for data in websocket.iter_text():
await websocket.send_text(f"Message text was: {data}")
You can read more about it on the Starlette documentation.
4. Ignore the WebSocketDisconnect exception
If you are using the while True notation, you will need to catch the WebSocketDisconnect.
The async for notation will catch it for you.
from fastapi import FastAPI
from starlette.websockets import WebSocket, WebSocketDisconnect
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket) -> None:
await websocket.accept()
try:
while True:
data = await websocket.receive_text()
await websocket.send_text(f"Message text was: {data}")
except WebSocketDisconnect:
pass
If you need to release resources when the WebSocket is disconnected, you can use that exception to do it.
If you are using an older FastAPI version, only the receive methods will raise the WebSocketDisconnect exception.
The send methods will not raise it. In the latest versions, all methods will raise it.
In that case, you'll need to add the send methods inside the try block.
5. Use HTTPX's AsyncClient instead of TestClient
Since you are using async functions in your application, it will be easier to use HTTPX's AsyncClient
instead of Starlette's TestClient.
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"Hello": "World"}
# Using TestClient
from starlette.testclient import TestClient
client = TestClient(app)
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"Hello": "World"}
# Using AsyncClient
import anyio
from httpx import AsyncClient, ASGITransport
async def main():
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
response = await client.get("/")
assert response.status_code == 200
assert response.json() == {"Hello": "World"}
anyio.run(main)
If you are using lifespan events (on_startup, on_shutdown or the lifespan parameter), you can use the
asgi-lifespan package to run those events.
from contextlib import asynccontextmanager
from typing import AsyncIterator
import anyio
from asgi_lifespan import LifespanManager
from httpx import AsyncClient, ASGITransport
from fastapi import FastAPI
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
print("Starting app")
yield
print("Stopping app")
app = FastAPI(lifespan=lifespan)
@app.get("/")
async def read_root():
return {"Hello": "World"}
async def main():
async with LifespanManager(app) as manager:
async with AsyncClient(transport=ASGITransport(app=manager.app)) as client:
response = await client.get("/")
assert response.status_code == 200
assert response.json() == {"Hello": "World"}
anyio.run(main)
[!NOTE] Consider supporting the creator of
asgi-lifespanFlorimond Manca via GitHub Sponsors.
6. Use Lifespan State instead of app.state
Since not long ago, FastAPI supports the lifespan state, which defines a standard way to manage objects that need to be created at startup, and need to be used in the request-response cycle.
The app.state is not recommended to be used anymore. You should use the lifespan state instead.
Using the app.state, you'd do something like this:
from contextlib import asynccontextmanager
from typing import AsyncIterator
from fastapi import FastAPI, Request
from httpx import AsyncClient
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
async with AsyncClient(app=app) as client:
app.state.client = client
yield
app = FastAPI(lifespan=lifespan)
@app.get("/")
async def read_root(request: Request):
client = request.app.state.client
response = await client.get("/")
return response.json()
Using the lifespan state, you'd do something like this:
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from typing import Any, TypedDict, cast
from fastapi import FastAPI, Request
from httpx import AsyncClient
class State(TypedDict):
client: AsyncClient
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[State]:
async with AsyncClient(app=app) as client:
yield {"client": client}
app = FastAPI(lifespan=lifespan)
@app.get("/")
async def read_root(request: Request) -> dict[str, Any]:
client = cast(AsyncClient, request.state.client)
response = await client.get("/")
return response.json()
7. Enable AsyncIO debug mode
If you want to find the endpoints that are blocking the event loop, you can enable the AsyncIO debug mode.
When you enable it, Python will print a warning message when a task takes more than 100ms to execute.
Run the following code with PYTHONASYNCIODEBUG=1 python main.py:
import os
import time
import uvicorn
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
time.sleep(1) # Blocking call
return {"Hello": "World"}
if __name__ == "__main__":
uvicorn.run(app, loop="uvloop")
If you call the endpoint, you will see the following message:
INFO: Started server process [19319]
INFO: Waiting for application startup.
INFO: Application startup complete.
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: 127.0.0.1:50036 - "GET / HTTP/1.1" 200 OK
Executing <Task finished name='Task-3' coro=<RequestResponseCycle.run_asgi() done, defined at /uvicorn/uvicorn/protocols/http/httptools_impl.py:408> result=None created at /uvicorn/uvicorn/protocols/http/httptools_impl.py:291> took 1.009 seconds
You can read more about it on the official documentation.
8. Implement a Pure ASGI Middleware instead of BaseHTTPMiddleware
The BaseHTTPMiddleware is the simplest way to create a middleware in FastAPI.
[!NOTE] The
@app.middleware("http")decorator is a wrapper around theBaseHTTPMiddleware.
There were some issues with the BaseHTTPMiddleware, but most of the issues were fixed in the latest versions.
That said, there's still a performance penalty when using it.
To avoid the performance penalty, you can implement a Pure ASGI middleware. The downside is that it's more complex to implement.
Check the Starlette's documentation to learn how to implement a Pure ASGI middleware.
9. Your dependencies may be running on threads
If the function is non-async and you use it as a dependency, it will run in a thread.
In the following example, the http_client function will run in a thread:
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from httpx import AsyncClient
from fastapi import FastAPI, Request, Depends
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[dict[str, AsyncClient]]:
async with AsyncClient() as client:
yield {"client": client}
app = FastAPI(lifespan=lifespan)
def http_client(request: Request) -> AsyncClient:
return request.state.client
@app.get("/")
async def read_root(client: AsyncClient = Depends(http_client)):
return await client.get("/")
To run in the event loop, you need to make the function async:
# ...
async def http_client(request: Request) -> AsyncClient:
return request.state.client
# ...
As an exercise for the reader, let's learn a bit more about how to check the running threads.
You can run the following with python main.py:
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
import anyio
from anyio.to_thread import current_default_thread_limiter
from httpx import AsyncClient
from fastapi import FastAPI, Request, Depends
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[dict[str, AsyncClient]]:
async with AsyncClient() as client:
yield {"client": client}
app = FastAPI(lifespan=lifespan)
# Change this function to be async, and rerun this application.
def http_client(request: Request) -> AsyncClient:
return request.state.client
@app.get("/")
async def read_root(client: AsyncClient = Depends(http_client)): ...
async def monitor_thread_limiter():
limiter = current_default_thread_limiter()
threads_in_use = limiter.borrowed_tokens
while True:
if threads_in_use != limiter.borrowed_tokens:
print(f"Threads in use: {limiter.borrowed_tokens}")
threads_in_use = limiter.borrowed_tokens
await anyio.sleep(0)
if __name__ == "__main__":
import uvicorn
config = uvicorn.Config(app="main:app")
server = uvicorn.Server(config)
async def main():
async with anyio.create_task_group() as tg:
tg.start_soon(monitor_thread_limiter)
await server.serve()
anyio.run(main)
If you call the endpoint, you will see the following message:
❯ python main.py
INFO: Started server process [23966]
INFO: Waiting for application startup.
INFO: Application startup complete.
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
Threads in use: 1
INFO: 127.0.0.1:57848 - "GET / HTTP/1.1" 200 OK
Threads in use: 0
Replace the def http_client with async def http_client and rerun the application.
You will not see the message Threads in use: 1, because the function is running in the event loop.
[!TIP] You can use the FastAPI Dependency package that I've built to make it explicit when a dependency should run in a thread.
10. Use pytest.mark.anyio instead of pytest.mark.asyncio
You already have anyio installed, since it's a dependency of Starlette.
Which means, you can use pytest.mark.anyio instead of pytest.mark.asyncio.
import pytest
@pytest.mark.anyio
async def test_async_function(): ...
By default, anyio runs every test that has the marker twice, once with trio and another time with asyncio.
You probably want to restrict that by using either one or the other, in case you are testing an application,
and not a package:
import pytest
@pytest.fixture
def anyio_backend():
return "asyncio" # or "trio"
You can read more about it on the
anyio documentation.
Repo liên quan
Master programming by recreating your favorite technologies from scratch.
A curated meta-list of curated lists organized by technology domain. The repository acts as a directory pointing to hundreds of specialized awesome lists covering programming languages, platforms, frameworks, and tooling. All content is community-contributed under the CC0 public domain dedication.
Public APIs is a community-curated GitHub repository listing free, publicly accessible APIs across a wide range of categories, with auth type, HTTPS, and CORS noted for each entry. It's a browsable reference, not a library to install.
freeCodeCamp is a free, self-paced curriculum for learning to code, published as open source at freeCodeCamp/freeCodeCamp. It's a 501(c)(3) nonprofit funded by donor support, structured around six certifications in its Full-Stack Developer Curriculum, each gated by required projects instead of open-book quizzes. The repository also carries beta language certifications for developers, interview-prep resources, and the code that runs the live freecodecamp.org platform.
Trả lời nhanh
Đọc thêm về Kludex/fastapi-tips ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/Kludex/fastapi-tips là nguồn chính thức.
Kludex/fastapi-tips có bao nhiêu sao?
Kludex/fastapi-tips có 3.6k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/Kludex/fastapi-tips. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
Kludex/fastapi-tips có phải mã nguồn mở không?
TopGit chưa ghi nhận license cho Kludex/fastapi-tips. Phần lớn repo public trên GitHub là mã nguồn mở, nhưng điều khoản khác nhau từng repo — mở file LICENSE để xác nhận.
Kludex/fastapi-tips có tag gì không?
Bản đồng bộ chưa ghi nhận topic GitHub nào cho Kludex/fastapi-tips. GitHub topics hiển thị ở thanh bên phải trang repo — đó là nơi đáng kiểm tra nhất.
Kludex/fastapi-tips có website riêng không?
TopGit chưa ghi nhận URL trang chủ cho Kludex/fastapi-tips. Phần README ở tab phía trên thường có link demo, hoặc xem mô tả GitHub của repo.
Kludex/fastapi-tips còn đang phát triển không?
Commit gần nhất trên Kludex/fastapi-tips là 10 tháng trước (theo timestamp GitHub). Repo có 147 fork — một chỉ báo về mức độ quan tâm của cộng đồng.
Đọc đầy đủ README ở tab phía trên.
Vẫn đang phân vân về fastapi-tips?
Một cú bấm sẽ gửi câu hỏi kèm trang này cho AI — xem AI nói gì về fastapi-tips.