Background UploadFile is just a wrapper around SpooledTemporaryFile, which can be accessed as UploadFile.file. SpooledTemporaryFile() […] function operates exactly as TemporaryFile() does And documentation about TemporaryFile says: Return a file-like object that can be used as a temporary storage area. [..] It will be destroyed as soon as it is closed (including an implicit close … Read more
I found a solution that can help us to use Pydantic with FastAPI forms 🙂 My code: class AnyForm(BaseModel): any_param: str any_other_param: int = 1 @classmethod def as_form( cls, any_param: str = Form(…), any_other_param: int = Form(1) ) -> AnyForm: return cls(any_param=any_param, any_other_param=any_other_param) @router.post(”) async def any_view(form_data: AnyForm = Depends(AnyForm.as_form)): … It’s shown in the … Read more
request.client should work, unless you’re running behind a proxy (e.g. nginx) in that case use uvicorn’s –proxy-headers flag to accept these incoming headers and make sure the proxy forwards them.
How can I add any decorators to FastAPI endpoints? As you said, you need to use @functools.wraps(…)–(PyDoc) decorator as, from functools import wraps from fastapi import FastAPI from pydantic import BaseModel class SampleModel(BaseModel): name: str age: int app = FastAPI() def auth_required(func): @wraps(func) async def wrapper(*args, **kwargs): return await func(*args, **kwargs) return wrapper @app.post(“https://stackoverflow.com/”) @auth_required … Read more
This is because your application isn’t trusting the reverse proxy’s headers overriding the scheme (the X-Forwarded-Proto header that’s passed when it handles a TLS request). There’s a few ways we can fix that: If you’re running the application straight from uvicorn server, try using the flag –forwarded-allow-ips ‘*’. If you’re running gunicorn you can set … Read more
First, as per FastAPI documentation, you need to install python-multipart—if you haven’t already—as uploaded files are sent as “form data”. For instance: pip install python-multipart The below examples use the .file attribute of the UploadFile object to get the actual Python file (i.e., SpooledTemporaryFile), which allows you to call SpooledTemporaryFile‘s methods, such as .read() and … Read more
Your task is defined as async, which means fastapi (or rather starlette) will run it in the asyncio event loop. And because somelongcomputation is synchronous (i.e. not waiting on some IO, but doing computation) it will block the event loop as long as it is running. I see a few ways of solving this: Use … Read more
async def endpoint You could use loop.run_in_executor with ProcessPoolExecutor to start function at a separate process. @app.post(“/async-endpoint”) async def test_endpoint(): loop = asyncio.get_event_loop() with concurrent.futures.ProcessPoolExecutor() as pool: result = await loop.run_in_executor(pool, cpu_bound_func) # wait result def endpoint Since def endpoints are run implicitly in a separate thread, you can use the full power of modules … Read more
You need to enable validate_assignment option in model config: from typing import Optional from pydantic import BaseModel, validator class User(BaseModel): name: Optional[str] = ” password: Optional[str] = ” class Config: validate_assignment = True @validator(‘name’) def set_name(cls, name): return name or ‘foo’ user = User(name=None, password=’some_password’, ) print(“Name is “, user.name) user.name = None print(“Name is … Read more
Since FastAPI is based on Starlette, you can use what they call “converters” with your route parameters, using type path in this case, which “returns the rest of the path, including any additional / characers.” See https://www.starlette.io/routing/#path-parameters for reference. If your react (or vue or …) app is using a base path, you can do … Read more