-
|
Is FastAPI
Important: this is only for code that was working before and then after upgrading FastAPI, not for something that is not working for you since previous versions of FastAPI. As FastAPI now supports Pydantic v2, any problems are not about the beta (as it's already released 😅), so let's keep the normal workflow. If you are having problems, please create a new Discussion question following the template! 🙏 https://github.com/tiangolo/fastapi/discussions/new?category=questions |
Beta Was this translation helpful? Give feedback.
Replies: 66 comments 257 replies
-
|
Everything is working fine! 🎉 Add an upvote and thumbs up here if everything is working fine for you. Optionally, add a comment. 😄 |
Beta Was this translation helpful? Give feedback.
-
|
Some fun yezz123/authx#470 |
Beta Was this translation helpful? Give feedback.
-
|
Switched to Pydantic V2 today (64 files changed, 674 insertions(+), 548 deletions(-)). Everything works fine with FastAPI! Big thanks @tiangolo |
Beta Was this translation helpful? Give feedback.
-
|
Awesome @dfroger! 🚀 |
Beta Was this translation helpful? Give feedback.
-
|
I found an incompatibility with def _prepare_source(error: "ErrorDict", content_type: str) -> ApiErrorSource:
location: str | Loc = error.get("loc", "")
if isinstance(location, tuple) and (location[0] == "body"):
if "form" not in content_type:
source = ApiErrorSource(
pointer=_create_pointer(location),
)
else:
source = ApiErrorSource(
pointer=(_create_pointer(location[1:]) if len(location) > 2 else None),
parameter=_create_parameter(location[:2]),
)
else:
# if body does not exist in location it is invalid parameter error
source = ApiErrorSource(parameter=_create_parameter(location))
return source
async def request_validation_handler(
request: Request, exc: RequestValidationError | WebSocketRequestValidationError
) -> JSONResponse:
return ORJSONResponse(
status_code=HTTP_400_BAD_REQUEST,
content=jsonable_encoder(
CustomApiErrorResponse(
errors=[
CustomApiError(
status=str(HTTP_400_BAD_REQUEST),
title="Validation Error",
detail=jsonable_encoder(error.get("msg", "")),
source=_prepare_source(error, request.headers.get("content-type", "")),
)
for error in exc.errors()
]
)
),
)I get an exception when using I investigated this a bit more and realized, I am manually raising a 
Is there a different way I should be doing this? No problem if this is just a not-so-good pattern of mine 😅 I have a few thousand additional API tests across various services and all of those pass with flying colors!! Thanks so much for the care!! |
Beta Was this translation helpful? Give feedback.
-
|
Hi ! I was trying it out the beta as well on one of our projects, and encountered the same kind of issue: having 2 tests failing because ErrorWrapper is not a dict, in our exception handler. raise RequestValidationError(errors=[ErrorWrapper(ValueError("mock"), ("mock", "mock"))])However, our exception handler still works correctly on all "real" tests with no manual raise of Exceptions. raise RequestValidationError(errors, body=body)In current beta: raise ResponseValidationError(errors=_normalize_errors(errors), body=response_content)A quick fix is to simply replace my orginal mocked exception in tests with RequestValidationError(errors=_normalize_errors([ErrorWrapper(ValueError("mock"), ("mock", "mock"))]))However, it doesn't look as a best practice to use a private method here, so here is the final rewrite I did: RequestValidationError(
errors=ValidationError(
errors=[ErrorWrapper(ValueError("mock"), ("mock", "mock"))],
model=RequestErrorModel,
).errors()
)but, maybe there is an even better solution here, what would you recommend here @tiangolo ? |
Beta Was this translation helpful? Give feedback.
-
|
Interesting! I didn't expect you to raise Yes, it changed, before it inherited from Pydantic's If you need something like that, it's probably better to create your own exception and exception handler, so that it's only related to your app and won't have a special meaning for FastAPI. If you still need to create @phillipuniverse in your case, you should probably define that parameter as the enum, not a def upload(
type: Annotated[DocumentType | None, Form()] = DocumentType.OTHER
):
...Then you can remove all the custom validation logic and let FastAPI validate the enum for you. |
Beta Was this translation helpful? Give feedback.
-
|
Thanks for the explanations! |
Beta Was this translation helpful? Give feedback.
-
|
Ah, get it @thentgesMindee, then what I would do is create the object with plain dictionaries containing the mock data you want to test. Or maybe you can even use a normal path operation and send invalid data, and ensure that your response is having the right format from your custom handler. |
Beta Was this translation helpful? Give feedback.
-
|
@tiangolo perfect, thanks for the heads up!
That way, I can test both my exception handler edge cases (by manually raising the exception), and also tests that, when FastAPI raises them internally, it contains the expected attributes. For future references and people stumbling across this discussion, here is how I created my error from plain dicts for the manual raise case: RequestValidationError(
[
{
"loc": ("body", "mock"),
"msg": "mock",
}
]
)Since my exception handler only uses |
Beta Was this translation helpful? Give feedback.
-
|
Hi The order of parameters changes in swagger UI: @app.post("/formtest")
def formtest(
username: Annotated[Optional[str], Form()],
password: Annotated[Optional[str], Form()],
):
return [username, password]
|
Beta Was this translation helpful? Give feedback.
-
|
It is. Thank you @vitalik 👍 |
Beta Was this translation helpful? Give feedback.
-
|
Resolved |
Beta Was this translation helpful? Give feedback.
-
|
Route ordering in general seems pretty messed up. This sorting is much worse than it was before – just alphabetical seems preferable if some other order is not going to be maintained. 
|
Beta Was this translation helpful? Give feedback.
-
|
Do you have an MRE? |
Beta Was this translation helpful? Give feedback.
-
|
@acnebs please create a new discussion, including your Pydantic version, how it was before, how it is now, and a minimal reproducible example. The original question here was about the order of the parameters in a specific path operation, not about all the path operations. So it's better in a new one. And as the version supporting Pydantic v2 is now released, it's better in a new discussion instead of in this same one to avoid the clutter. |
Beta Was this translation helpful? Give feedback.
-
|
SQLModel test suite fails with this kind of differences in the openapi schema, using Pydantic v1. 11 fails under fastapi 0.100.0b1 Otherwise unmodified SQLModel main (same as 0.0.8 release), only changed the fastapi dep version. |
Beta Was this translation helpful? Give feedback.
-
|
Great, thanks! Yep, that would be expected, SQLModel needs some work still, especially in those tests that replicate the tests in FastAPI, I have to update them the same way as here. |
Beta Was this translation helpful? Give feedback.
-
|
Parsing of Literal types seems to be broken with Pydantic v2. Take this example: from typing import Literal
from pydantic import BaseModel
class Health(BaseModel):
status: Literal["ok", "error"]Doing However, if I use it as the return model for a path operation, the schema is broken in the swagger docs. Weirdly the examples do use one of the values.
Here is a pastebin with the generated openapi.json: https://pastebin.com/a95Tujah |
Beta Was this translation helpful? Give feedback.
-
|
Yep I did and it does. I haven't had a chance to open an issue on their repo. But the gist of it is that the JSON schema with V2 is missing the type key for the enum. |
Beta Was this translation helpful? Give feedback.
-
|
Cool, I think this will be solved when I migrate FastAPI to OpenAPI 3.1.0 that uses the new JSON Schema, it will probably solve it. |
Beta Was this translation helpful? Give feedback.
-
|
FastAPI 0.100.0-beta3 is out, this includes OpenAPI 3.1.0, the new JSON Schema, and the new Swagger UI! 🎉 Could you test it out? |
Beta Was this translation helpful? Give feedback.
-
|
I did not get the chance to check this out during the third beta. Although the Pydantic team added the type for simple Literal types. I'll take a look in a couple of hours and get back with any findings |
Beta Was this translation helpful? Give feedback.
-
|
Happy to report it works as expected |
Beta Was this translation helpful? Give feedback.
-
|
I use pydantic HEAD PydanticUndefinedwas changed in pydantic/pydantic@f742ca4 invalid OpenAPI description document when using nested discriminated unionsthe OpenAPI document created fails internal validation it's the result of nested discriminated unions, can be reproduced by using Pet in a fastapi service as body argument: from datetime import timedelta
import uuid
import sys
if sys.version_info >= (3, 9):
from typing import List, Optional, Literal, Union, Annotated
else:
from typing import List, Optional, Union
from typing_extensions import Annotated, Literal
import pydantic
from pydantic import BaseModel, RootModel, Field
from pydantic_core import PydanticUndefined as Undefined
class PetBase(BaseModel):
identifier: Optional[str] = Field(default_factory=lambda: str(uuid.uuid4()))
name: str
tags: Optional[List[str]] # = Field(default_factory=list)
class BlackCat(PetBase):
pet_type: Literal["cat"] = "cat"
color: Literal["black"] = "black"
black_name: str
class WhiteCat(PetBase):
pet_type: Literal["cat"] = "cat"
color: Literal["white"] = "white"
white_name: str
Cat = Annotated[Union[BlackCat, WhiteCat], Field(default=Undefined, discriminator='color')]
class Dog(PetBase):
pet_type: Literal["dog"] = "dog"
name: str
age: timedelta
class Pet(RootModel):
root: Annotated[Union[Cat, Dog], Field(discriminator="pet_type")]
class Pets(RootModel):
root: List[Pet] = Field(..., description="list of pet")fails at Pet:
discriminator:
mapping:
cat:
discriminator:
mapping:
black: '#/components/schemas/BlackCat'
white: '#/components/schemas/WhiteCat'
propertyName: color
oneOf:
- $ref: '#/components/schemas/BlackCat'
- $ref: '#/components/schemas/WhiteCat'
dog: '#/components/schemas/Dog'
propertyName: pet_type
oneOf:
- discriminator:
mapping:
black: '#/components/schemas/BlackCat'
white: '#/components/schemas/WhiteCat'
propertyName: color
oneOf:
- $ref: '#/components/schemas/BlackCat'
- $ref: '#/components/schemas/WhiteCat'
- $ref: '#/components/schemas/Dog'
title: Pet
|
Beta Was this translation helpful? Give feedback.
-
The problem of invalid Discriminators persists for me: import io
from typing import Literal, Union, List
import yaml
from typing_extensions import Annotated
from pydantic import BaseModel, Field, RootModel
class BlackCat(BaseModel):
pet_type: Literal['cat']
color: Literal['black']
black_name: str
class WhiteCat(BaseModel):
pet_type: Literal['cat']
color: Literal['white']
white_name: str
Cat = Annotated[Union[BlackCat, WhiteCat], Field(discriminator='color')]
class Dog(BaseModel):
pet_type: Literal['dog'] = "dog"
name: str
Pet = RootModel[Annotated[Union[Cat, Dog], Field(discriminator='pet_type')]]
Pets = List[Pet]
# patching for fastapi
from pydantic_core import PydanticUndefined
import pydantic._internal._fields
pydantic._internal._fields.Undefined = PydanticUndefined
pydantic._internal._fields._UndefinedType = type(PydanticUndefined)
from fastapi import FastAPI, Response, Body, Path
from fastapi.testclient import TestClient
app = FastAPI()
@app.post(
"/pet",
operation_id="createPet",
)
def createPet(
response: Response,
pet: Annotated[Cat | Dog, Body(..., discriminator="pet_type")]
# pet: Pet
) -> None:
#) -> Annotated[Cat | Dog, Field(discriminator="pet_type")]:
#) -> Pet:
return pet
def test_create():
client = TestClient(app)
r = client.post("/pet", json=Dog(name="doggy").model_dump())
print(r)
def test_dd():
client = TestClient(app)
r = client.get("/openapi.json")
s = io.StringIO()
yaml.safe_dump(r.json(), s)
s.seek(0)
print(s.read())
test_dd()paths:
/pet:
post:
operationId: createPet
requestBody:
content:
application/json:
schema:
discriminator:
mapping:
cat:
discriminator: # <- VALID?
mapping:
black: '#/components/schemas/BlackCat'
white: '#/components/schemas/WhiteCat'
propertyName: color
oneOf:
- $ref: '#/components/schemas/BlackCat'
- $ref: '#/components/schemas/WhiteCat'
dog: '#/components/schemas/Dog' # OK !
propertyName: pet_typeI've added OK & VALID comments Discriminator is defined as As shown previously using RootModel it is even possible to fault fastapis internal validator with something which looks like … I guess the current approach of using Annotated Fields may be a problem when having nested discriminated unions, as the |
Beta Was this translation helpful? Give feedback.
-
|
Thanks for the detailed response @commonism! As the focus of this first release is compatibility with Pydantic v1, is this something you were able to do with Pydantic v1? If that's the case, can you please share a minimal example that reproduces the correct thing using Pydantic v1? That way I can check and see what's missing in Pydantic v2. Otherwise, I think this would work better as a feature request for the next version with Pydantic v2. I was able to run your example, but I didn't check the internal differences and JSON Schema too deeply, but I think it's worth investigating that. Just that first I want to try and make sure the use cases of Pydantic v1 are covered before making the final release, and then add features on top, but get the first thing out. |
Beta Was this translation helpful? Give feedback.
-
|
This has been working fine with v1, it's part of aiopenapi3 unit testing - this is the pydanticv1 version: The schema looks fine when "materializing" Cat & Pet class Cat(RootModel[Annotated[Union[BlackCat, WhiteCat], Field(discriminator='color')]]):
...
class Pet(RootModel[Annotated[Union[Cat, Dog], Field(discriminator='pet_type')]]):
...Currently these can not be used as Body in fastapi? |
Beta Was this translation helpful? Give feedback.
-
|
I'm trying here to make an app/code that can be copy-pasted and run as is to replicate your use case @commonism. I'm trying to reduce it to the minimum replicable example. import io
import json
from pathlib import Path
from typing import List, Literal, Union
import yaml
from fastapi import Body, FastAPI, Response
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field, RootModel, TypeAdapter
from typing_extensions import Annotated
class BlackCat(BaseModel):
pet_type: Literal["cat"]
color: Literal["black"]
black_name: str
class WhiteCat(BaseModel):
pet_type: Literal["cat"]
color: Literal["white"]
white_name: str
Cat = RootModel[Annotated[Union[BlackCat, WhiteCat], Field(discriminator="color")]]
class Dog(BaseModel):
pet_type: Literal["dog"] = "dog"
name: str
Pet = RootModel[Annotated[Union[Cat, Dog], Field(discriminator="pet_type")]]
Pets = List[Pet]
ta = TypeAdapter(Pets)
jsp = Path("pets-json-schema.json")
jsp.write_text(json.dumps(ta.json_schema(), indent=2))
app = FastAPI()
@app.post(
"/pet",
operation_id="createPet",
)
def createPet(
response: Response,
pet: Annotated[Cat | Dog, Body(discriminator="pet_type")]
# pet: Pet
) -> None:
# ) -> Annotated[Cat | Dog, Field(discriminator="pet_type")]:
# ) -> Pet:
return pet
def test_create():
client = TestClient(app)
r = client.post("/pet", json=Dog(name="doggy").model_dump())
print(r)
def test_dd():
client = TestClient(app)
r = client.get("/openapi.json")
s = io.StringIO()
yaml.safe_dump(r.json(), s)
s.seek(0)
print(s.read())
test_dd()What I see is the problem in your code is that as Then it fails to generate the OpenAPI on the FastAPI side and triggers a server error because, indeed, it's invalid OpenAPI. If you put that in a WhereNow, if you think something around this is wrong, this would actually belong to Pydantic, not to FastAPI. It would have to be a bug report/feature request there, as FastAPI just takes the JSON Schema directly and puts it in OpenAPI in the right places. But I think this would probably solve it for you. RootModelThe funny thing about root models is that I have never officially supported them in FastAPI, I don't have docs for them, never saw the need for that, as the main use cases I saw could be declared with plain types in FastAPI. I wasn't really sure they would work, as every time I've been asked I've suggested using plain types. DiscriminatorI actually have never really been a fan of them as I consider they add a lot of unnecessary complexity. 😬 I'm not sure what use cases they improve over an Still not good?If this is still not the solution for your problem, please create a minimal code snippet I can copy paste here that I can run directly without modifications. That will let me know and understand better what you are expecting and will help me/us help you better. |
Beta Was this translation helpful? Give feedback.
-
|
I missed this, the write everywhere without already read indication format is somewhat hard to follow. |
Beta Was this translation helpful? Give feedback.
-
|
I used rootmodels as I was unaware of the limitations.
from typing import Literal, Union
from typing_extensions import Annotated
from pydantic import BaseModel, Field, ValidationError
class BlackCat(BaseModel):
pet_type: Literal['cat']
color: Literal['black']
black_name: str
class WhiteCat(BaseModel):
pet_type: Literal['cat']
color: Literal['white']
white_name: str
Cat = Annotated[Union[BlackCat, WhiteCat], Field(discriminator='color')]
try:
from pydantic._internal._fields import Undefined as Undefined
except:
from pydantic_core import PydanticUndefined
import pydantic._internal._fields
pydantic._internal._fields.Undefined = PydanticUndefined
pydantic._internal._fields._UndefinedType = type(PydanticUndefined)
from fastapi import FastAPI, Response, Body
app = FastAPI()
@app.post(
"/pet",
operation_id="createPet",
response_model=Cat,
responses={201: {"model": Cat}},
)
def createPet(
response: Response,
pet: Cat = Body(..., embed=True),
) -> None:
return pet |
Beta Was this translation helpful? Give feedback.
-
|
@tiangolo anything about this? |
Beta Was this translation helpful? Give feedback.
-
|
Gotcha, it's not even valid pydanticv2, and works when using the RootModel properly. |
Beta Was this translation helpful? Give feedback.
-
|
Will this be a minor release or a major release? I note that this version is 0.100.0 instead of 1.0.0. I'm wondering if I need to disable automatic version updates for FastAPI using Renovate. |
Beta Was this translation helpful? Give feedback.
-
|
Semantic versioning permits breaking changes for minor releases on <1 versions. |
Beta Was this translation helpful? Give feedback.
-
|
0ver isn't a magic bullet for every changes when a project has been around for so long. HashiCorp used that excuse on terraform for years and it was a pain as a user. |
Beta Was this translation helpful? Give feedback.
-
|
Agreed, everyone is working very hard to minimize breaking changes. There is no magic bullet. |
Beta Was this translation helpful? Give feedback.
-
|
Yep, I'll release the first 1.0.0 at some point, but first I want to add and change a few things. And yep, 0ver is no magic bullet, but releasing 1.x.x isn't either, it's just a number, it on itself doesn't change the things that need to be changed, the cadence, etc. And as @adriangb says, we are working very hard to minimize breaking changes. That actually doesn't change with a version number. And I already have looots of stuff for backwards compatibility in the 0.x.x versions of FastAPI, there have been deprecated things with compatibility layers for many versions and I haven't even removed those. But if you prefer, you can consider the numbers shifted to the left, and consider this the version 100.0, and take any steps you would take to migrate from 99.0 to 100.0. There are also a couple of extra details to help you be super safe when handling versions in FastAPI in the docs (including what to pin and what not to pin): https://fastapi.tiangolo.com/deployment/versions/ |
Beta Was this translation helpful? Give feedback.
-
|
Hi both, thanks for the feedback. I totally appreciate the difficulty to cut a 1.0 with the breadth and depth of this project. I was wondering, is there a place where you sort of collate your goals for the future? Migrating to Pydantic v2 is on my todo for instance but it's easier to prioritize when you have a rough idea of how projects you depend on define their own plans. It's okay you keep on 0ver but visibility would help us follow upgrades more gracefully. |
Beta Was this translation helpful? Give feedback.
-
|
Hey @tiangolo What's the goal down the road? To drop Pydantic v1? I'm sorry I couldn't find anything explaining the direction long term. Thanks, |
Beta Was this translation helpful? Give feedback.
-
|
Yep, the plan is to drop Pydantic v1 at some point, but I have no particular hurry. Also, @Kludex is building https://github.com/pydantic/bump-pydantic that will help you migrate Pydantic models in batch. If you have something specific that doesn't work or is complicated, in particular, if it's not covered in the migration guide, we would love to know. |
Beta Was this translation helpful? Give feedback.
-
|
The use of "null" as type requires "3.1.0" as OpenAPI version in the description document. from pydantic import BaseModel
class A(BaseModel):
data: str | None
schema = A.model_json_schema()
assert any(map(lambda x: x["type"] == "null", schema["properties"]["data"]["anyOf"])) |
Beta Was this translation helpful? Give feedback.
-
|
Thanks! I'm gonna upgrade FastAPI to 3.1.0 in these next days, and then release the next beta and it will all work fine. 🤞 |
Beta Was this translation helpful? Give feedback.
-
|
FastAPI 0.100.0-beta3 is out, this includes OpenAPI 3.1.0, the new JSON Schema, and the new Swagger UI! 🎉 Could you test it out? |
Beta Was this translation helpful? Give feedback.
-
|
Using pydantic/pydantic@70a43f7 Can not use discriminated unions as body argumentsfrom typing import Literal, Union, List
from typing_extensions import Annotated
from pydantic import BaseModel, Field
class BlackCat(BaseModel):
pet_type: Literal['cat']
color: Literal['black']
black_name: str
class WhiteCat(BaseModel):
pet_type: Literal['cat']
color: Literal['white']
white_name: str
Cat = Annotated[Union[BlackCat, WhiteCat], Field(discriminator='color')]
class Dog(BaseModel):
pet_type: Literal['dog']
name: str
Pet = Annotated[Union[Cat, Dog], Field(discriminator='pet_type')]
Pets = List[Pet]
# patching for fastapi
from pydantic_core import PydanticUndefined
import pydantic._internal._fields
pydantic._internal._fields.Undefined = PydanticUndefined
pydantic._internal._fields._UndefinedType = type(PydanticUndefined)
from fastapi import FastAPI, Response, Body, Path
app = FastAPI()
@app.post(
"/pet",
operation_id="createPet",
)
def createPet(
response: Response,
pet: Pet = Body(..., embed=True),
# pet: Annotated[Pet, Body(embed=True)]
) -> Pet:
return petInvalid description document to do discrimination target resolving instead of referencingUsing Dog for the Body in the example- "it works" but the description document is invalid due to the same problem as mentioned before - responses:
'200':
content:
application/json:
schema:
discriminator:
mapping:
cat:
discriminator:
mapping:
black: '#/components/schemas/BlackCat'
white: '#/components/schemas/WhiteCat'
propertyName: color
oneOf:
- $ref: '#/components/schemas/BlackCat'
- $ref: '#/components/schemas/WhiteCat'
dog: '#/components/schemas/Dog'
propertyName: pet_type
oneOf:
- discriminator:
mapping:
black: '#/components/schemas/BlackCat'
white: '#/components/schemas/WhiteCat'
propertyName: color
oneOf:
- $ref: '#/components/schemas/BlackCat'
- $ref: '#/components/schemas/WhiteCat'
- $ref: '#/components/schemas/Dog'
title: Response Createpet
description: Successful ResponseI'd expect it to be responses:
'200':
content:
application/json:
schema:
discriminator:
mapping:
cat: '#/components/schemas/Cat'
dog: '#/components/schemas/Dog'
propertyName: pet_type
oneOf:
- $ref: '#/components/schemas/Cat'
- $ref: '#/components/schemas/Dog'
title: Response Createpet
description: Successful Response |
Beta Was this translation helpful? Give feedback.
-
|
Is this the same problem described above? Maybe this solution would help: #9709 (reply in thread) |
Beta Was this translation helpful? Give feedback.
-
|
Yes - same issue. |
Beta Was this translation helpful? Give feedback.
-
|
@tiangolo , can you add new |
Beta Was this translation helpful? Give feedback.
-
|
Yep! Good point. I just did that, it will be available in the next beta (hopefully today). |
Beta Was this translation helpful? Give feedback.
-
|
Sounds great, thanks! |
Beta Was this translation helpful? Give feedback.
-
|
FastAPI 0.100.0-beta3 is out, this includes these extras, OpenAPI 3.1.0, the new JSON Schema, and the new Swagger UI! 🎉 Could you test it out? |
Beta Was this translation helpful? Give feedback.
-
|
I detected when pydantic v2 class has a override model_validate (ex from_orm) the endpoints crash with a ResponseValidationError Full example: requirements: requirements: Run: # main.py
from typing import Any
from sqlalchemy import ForeignKey, Integer, String, create_engine
from sqlalchemy.orm import (
Mapped,
declarative_base,
mapped_column,
relationship,
sessionmaker,
)
# SQLAlchemy
engine = create_engine("sqlite:///test.db")
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True, nullable=False)
email: Mapped[str] = mapped_column(String, nullable=False, unique=True)
posts: Mapped[list["Post"]] = relationship(back_populates="owner")
class Post(Base):
__tablename__ = "posts"
id: Mapped[int] = mapped_column(primary_key=True, nullable=False)
title: Mapped[str] = mapped_column(String(255), nullable=False)
owner_id: Mapped[int] = mapped_column(
Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False
)
owner: Mapped["User"] = relationship(back_populates="posts")
Base.metadata.drop_all(bind=engine)
Base.metadata.create_all(bind=engine)
# Init db
db = next(get_db())
user1 = User(email="[email protected]")
user2 = User(email="[email protected]")
post1_user1 = Post(title="Post 1 by User 1", owner=user1)
post2_user1 = Post(title="Post 2 by User 1", owner=user1)
post1_user2 = Post(title="Post 1 by User 2", owner=user2)
post2_user2 = Post(title="Post 2 by User 2", owner=user2)
user1.posts.extend([post1_user1, post2_user1])
user2.posts.extend([post1_user2, post2_user2])
db.add(user1)
db.add(user2)
db.commit()
# Schema pydantic
from pydantic import BaseModel, Field
class UserOut(BaseModel):
id: int = Field(description="ID")
email: str = Field(description="Email")
first_post_title: str = Field(description="First post title")
class Config:
orm_mode = True
## Pydantic v1 *********************
## With fastapi 0.99.1 and pydantic v1 = OK
@classmethod
def from_orm(cls, obj: Any) -> "UserOut":
if hasattr(obj, "posts"):
obj.first_post_title = obj.posts[0].title
return super().from_orm(obj)
## Pydantic v2 *********************
## With fastapi 0.100.0b2 and pydantic v2 = ResponseValidationError
@classmethod
def model_validate(cls, obj: Any) -> "UserOut":
if hasattr(obj, "posts"):
obj.first_post_title = obj.posts[0].title
return super().model_validate(obj)
# Fastapi
from fastapi import Depends, FastAPI
from sqlalchemy import select
from sqlalchemy.orm import Session
app = FastAPI()
@app.get("/")
async def root(
db: Session = Depends(get_db),
) -> UserOut:
user = db.execute(select(User)).scalars().first()
return user |
Beta Was this translation helpful? Give feedback.
-
|
I updated with a full example to check. |
Beta Was this translation helpful? Give feedback.
-
|
I have the feeling that what you need is the new computed fields: https://docs.pydantic.dev/2.0/usage/computed_fields/ Would that solve it for you? |
Beta Was this translation helpful? Give feedback.
-
|
@tiangolo I tried with computed fields, but this feature cant access to orm obj. With v1 when I override If I manually add the validation in an extra step works fine: ...
user = db.execute(select(User)).scalars().first()
aux = UserOut.model_validate(user) # <- Extra step
return auxI think somewhere is not taking the parameter |
Beta Was this translation helpful? Give feedback.
-
|
Can you try something like this? from typing import Any
from pydantic import BaseModel, model_validator
class ArbitraryOrmObject:
abc = '123'
class Model(BaseModel):
x: int
@model_validator(mode='before')
@classmethod
def intercept_raw_input(cls, v: Any) -> Any:
if isinstance(v, ArbitraryOrmObject):
return {'x': v.abc}
return v
assert Model.model_validate(ArbitraryOrmObject()).x == 123 |
Beta Was this translation helpful? Give feedback.
-
|
Amazing @adriangb Finnally I got the api running, I added the class UserOut(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: int = Field(description="ID")
email: str = Field(description="Email")
first_post_title: str = Field(description="First post title")
@model_validator(mode="before")
@classmethod
def intercept_raw_input(cls, v: Any) -> Any:
if isinstance(v, User):
return {"first_post_title": v.posts[0].title, **v.__dict__}
return v |
Beta Was this translation helpful? Give feedback.
-
|
Not entirely sure if this is already addressed, but after the release of This code produces a valid schema with from typing import Literal
from devtools import debug
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Request(BaseModel):
at: Literal["today", "tomorrow", "yesterday"]
@app.get("/")
def root(data: Request):
return data
debug(app.openapi())The diff is --- out_2.0.txto2023-07-05 12:27:09
+++ out_2.0.1.txt 2023-07-05 12:29:05
@@ -14,7 +14,7 @@
'content': {
'application/json': {
'schema': {
- '$ref': '#/components/schemas/Request',
+ '$ref': '#/components/schemas/__main____RequestInput__1',
},
},
},… and of course |
Beta Was this translation helpful? Give feedback.
-
|
I can confirm the problem, class PostOut(BaseModel):
id: int
@app.get("/test")
def test() -> PostOut:
return PostOut(id=1)procudes wrong $ref too. |
Beta Was this translation helpful? Give feedback.
-
|
Yep, it was fixed last night, released today in Pydantic 2.0.2. And I just released FastAPI 0.100.0-beta3, this includes OpenAPI 3.1.0, the new JSON Schema, and the new Swagger UI! 🎉 Could you test it out? |
Beta Was this translation helpful? Give feedback.
-
|
Awesome! I just tested with |
Beta Was this translation helpful? Give feedback.
-
|
Going through pydantic docs to try to discover the root cause of an issue I am seeing. Previously you could do According to pydantic v2 docs dict -> model_dump and it still supports exclude_none etc. But in fastapi responses I am now seeing the keys with None values appearing, and I can't track down where the disconnect between myself, fastapi and pydantic v2 lies. I've tried overloading every method I can detect that is called during fastapi serialization to see if any of them are called, but it seems to not be hitting any of the pydantic methods. Despite the following code, the endpoint returns as if nothing has gone wrong. Any assistance would be great, looking forward to upgrading our systems to fastapi with pydantic v2, but can't seem to get past this one on my own. Minimum example |
Beta Was this translation helpful? Give feedback.
-
|
Yeah, so, the way it works now is different, each Pydantic model creates an internal dict that has the information for pydantic-core do to its thing in Rust. Then in FastAPI I create a Here's how you can solve it, I wrote the full test so you can run it with pytest. There are two options:
from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel
from typing_extensions import TypedDict
app = FastAPI()
class ModelA(TypedDict, total=False):
data: str | None
class ModelB(BaseModel):
data: str | None = None
@app.get("/a")
async def get_a() -> ModelA:
return ModelA()
@app.get("/b", response_model_exclude_none=True)
async def get_b() -> ModelB:
return ModelB()
client = TestClient(app)
def test_a():
response = client.get("a")
assert response.json() == {}
def test_b():
response = client.get("b")
assert response.json() == {}Funny enough, I don't like these parameters |
Beta Was this translation helpful? Give feedback.
-
|
Annoying to have to do it per path, but this'll work :) If there was a way to define the config on the object somehow that would be lush. |
Beta Was this translation helpful? Give feedback.
-
|
Just checked again, its only on a child sub-object we really want this setting, so object level config would be preferable. |
Beta Was this translation helpful? Give feedback.
-
|
I suppose it could be added to the object level config |
Beta Was this translation helpful? Give feedback.
-
|
Hello ! After migrating to the latest version of FastAPI, a feature related to Multipart Form has stopped working. Previously, when using FastAPI version 0.99.1 and Pydantic 1.10.11, the code below functioned correctly: I was able to send POST requests with Multipart Form data like this, with a string and a list of tags:
However, after migrating to the latest versions of FastAPI and Pydantic (0.100.0 and 2.0.3 respectively), the same request now returns validation errors for both fields:
I have gone through the migration guide, but I was unable to find any relevant information. Could this be an issue with FastAPI or Pydantic? Is there a way to modify the code to make it work? Thank you for your help! |
Beta Was this translation helpful? Give feedback.
-
|
Part of the problem seems to be related to the parsing of the OAS and docs with the code as givenopenapi: 3.1.0
info:
title: FastAPI
version: 0.1.0
paths:
/:
post:
summary: Get Item
operationId: get_item__post
parameters:
- name: name
in: query
required: true
schema:
type: string
title: Name
requestBody:
required: true
content:
application/json:
schema:
type: array
items:
type: string
title: Tags
responses:
'200':
description: Successful Response
content:
application/json:
schema: {}
'422':
description: Validation Error
content:
application/json:
schema:
$ref: '#/components/schemas/HTTPValidationError'
components:
schemas:
HTTPValidationError:
properties:
detail:
items:
$ref: '#/components/schemas/ValidationError'
type: array
title: Detail
type: object
title: HTTPValidationError
ValidationError:
properties:
loc:
items:
anyOf:
- type: string
- type: integer
type: array
title: Location
msg:
type: string
title: Message
type:
type: string
title: Error Type
type: object
required:
- loc
- msg
- type
title: ValidationError
OAS and docs if no parameter is a list typeopenapi: 3.1.0
info:
title: FastAPI
version: 0.1.0
paths:
/:
post:
summary: Get Item
operationId: get_item__post
parameters:
- name: name
in: query
required: true
schema:
type: string
title: Name
- name: tags
in: query
required: true
schema:
type: integer
title: Tags
responses:
'200':
description: Successful Response
content:
application/json:
schema: {}
'422':
description: Validation Error
content:
application/json:
schema:
$ref: '#/components/schemas/HTTPValidationError'
components:
schemas:
HTTPValidationError:
properties:
detail:
items:
$ref: '#/components/schemas/ValidationError'
type: array
title: Detail
type: object
title: HTTPValidationError
ValidationError:
properties:
loc:
items:
anyOf:
- type: string
- type: integer
type: array
title: Location
msg:
type: string
title: Message
type:
type: string
title: Error Type
type: object
required:
- loc
- msg
- type
title: ValidationError
|
Beta Was this translation helpful? Give feedback.
-
|
This was not actually officially supported by FastAPI, it worked by chance. I want to add support for something similar, but it's not there yet. |
Beta Was this translation helpful? Give feedback.
-
|
We are having an error with fastapi 0.100, pydantic 2.0.3. We have a regex with a lookaround, which can't be used anymore in V2. Pydantic have a workaround, but it doesn't seem to work with fastapi. import re
from dataclasses import dataclass
from typing import Any, Annotated
import uvicorn
from fastapi import FastAPI
from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler
from pydantic.json_schema import JsonSchemaValue
from pydantic_core import CoreSchema, PydanticCustomError, core_schema
PERIOD_REGEX = (
# Regex to validate that a string is an ISO-8601 format duration. See
# https://en.wikipedia.org/wiki/ISO_8601#Time_intervals for more information
# on duration only ISO-8601 time intervals.
r"^P(?!$)(\d+(?:\.\d+)?Y)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?W)?(\d+(?:\.\d+)?D)?"
r"(T(?=\d)(\d+(?:\.\d+)?H)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?S)?)?$"
)
# Copied straight from pydantic docs
@dataclass
class Regex:
pattern: str
def __get_pydantic_core_schema__(
self, source_type: Any, handler: GetCoreSchemaHandler
) -> CoreSchema:
regex = re.compile(self.pattern)
def match(v: str) -> str:
if not regex.match(v):
msg = "string_pattern_mismatch"
raise PydanticCustomError(
msg,
"String should match pattern '{pattern}'",
{"pattern": self.pattern},
)
return v
return core_schema.no_info_after_validator_function(
match,
handler(source_type),
)
def __get_pydantic_json_schema__(
self, core_schema: CoreSchema, handler: GetJsonSchemaHandler
) -> JsonSchemaValue:
json_schema = handler(core_schema)
json_schema["pattern"] = self.pattern
return json_schema
# Our custom type
PERIOD_RESOLUTION_TYPE = Annotated[str, Regex(pattern=PERIOD_REGEX)]
app = FastAPI()
@app.get("/test")
def endpoint(period_resolution: PERIOD_RESOLUTION_TYPE):
"""Evaluate string JSON query param."""
return period_resolution
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)The endpoint then takes any string. If someone can advise that would be great. |
Beta Was this translation helpful? Give feedback.
-
|
For durations you could actually use from datetime import timedelta
import uvicorn
from fastapi import FastAPI
app = FastAPI()
@app.get("/test")
def endpoint(period_resolution: timedelta):
"""Evaluate string JSON query param."""
return period_resolution
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000) |
Beta Was this translation helpful? Give feedback.
-
|
I do not really see how the data is meant to be passed in the get request. Either @app.post("/post")
def endpoint(period_resolution: Annotated[timedelta, Body()]) -> timedelta:
return period_resolutionor @app.post("/re")
def endpoint_re(period_resolution: Annotated[PERIOD_RESOLUTION_TYPE, Body()]) -> timedelta:
"""Evaluate string JSON query param."""
return period_resolutionas pytest: import json
from typing import Annotated
import datetime
import random
from datetime import timedelta
import pytest
from pydantic import TypeAdapter
from fastapi import FastAPI, Body
from fastapi.testclient import TestClient
app = FastAPI()
@app.post("/post")
def endpoint(period_resolution: Annotated[timedelta, Body()]) -> timedelta:
return period_resolution
client = TestClient(app)
def test_post():
data = datetime.timedelta(seconds=random.randint(10 * 7, 2 * (10 ** 7)))
t = TypeAdapter(datetime.timedelta)
data = t.dump_json(data)
response = client.post("/post", content=data)
assert response.status_code == 200
assert response.json() == json.loads(data) |
Beta Was this translation helpful? Give feedback.
-
|
Thanks for the help @aradkdj and @commonism 🙇 @ollz272 if those two solutions don't work, check if you can make it work with Pydantic alone, if you can't, then it would be a question for Pydantic. If you can make it work with Pydantic alone, and that doesn't work with FastAPI, then please create a new question discussion following the template, that will help me keep track of it instead of here. I'm about to close this one as it has too many things and several are already resolved. |
Beta Was this translation helpful? Give feedback.
-
|
I'm having a couple issues with the OpenAPI/Swagger docs for More problematic is that any Pydantic Model that I have that extends a Model that uses a Good code: class CamelModel(BaseModel):
model_config = ConfigDict(alias_generator=camelize, populate_by_name=True)
class OpportunityUpdateParamsV2(CamelModel):
model_config = ConfigDict()
name: Optional[str] = NoneIn this case, the documentation loads just fine, but still shows Bad code: class CamelModel(BaseModel):
model_config = ConfigDict(alias_generator=camelize, populate_by_name=True)
class OpportunityUpdateParamsV2(CamelModel):
name: Optional[str] = NoneStack trace from bad code: It appears to be from Pydantic, but I suspect that it's an interplay with how FastAPI is serializing PydanticV2 models for the OpenAPI document. Of course, it could also be user error, so if I'm doing something wrong please do let me know 🙂 Thanks! |
Beta Was this translation helpful? Give feedback.
-
|
Can you share the full MRE, please? |
Beta Was this translation helpful? Give feedback.
-
|
@Kludex I've managed to isolate the
I think I do have a bug, but after this investigation I think it's in my ASGI server. It does seem odd to me that FastAPI would change it's serialization behavior when the ASGI server sending events changes, though. |
Beta Was this translation helpful? Give feedback.
-
|
@crossk3 if you're still having problems, please create a new discussion question so we can continue there. |
Beta Was this translation helpful? Give feedback.
-
|
@tiangolo I kind of stopped trying to replicate the failure after switching to Thanks for all the work you and the team do on FastAPI, I've been using it for years 🙂 |
Beta Was this translation helpful? Give feedback.
-
|
|
Beta Was this translation helpful? Give feedback.
-
|
|
Beta Was this translation helpful? Give feedback.
-
|
Okay I think there's a miracle one-liner that gets FastAPI working. @tiangolo I think we might want to rework how some of the field subclass stuff works for better merging, but there's a tiny tweak I can make that makes all existing FastAPI code work. I'll note that there are some changes to reported error loc's that we'll probably want to improve, but that can come later. |
Beta Was this translation helpful? Give feedback.
-
|
Thank you @dmontagu! I confirm the |
Beta Was this translation helpful? Give feedback.
This comment was marked as spam.
This comment was marked as spam.
-
|
Thanks all! 🚀 |
Beta Was this translation helpful? Give feedback.
-
|
Hi, There is a bug in Pydantic v2.1.1 that impacts FastAPI. Response output is not validated correctly. See the following example where the second test fails. Issue reported in Pydantic here: pydantic/pydantic#6901 Pull Request to FastAPI adding the two tests that are copied below: #9954 |
Beta Was this translation helpful? Give feedback.
-
|
If I remember correctly, model_construct() doesn't validate. And then assignment of fields does not validate either unless you turn on the option to do so in the model_config. Why didn't you construct the model as Model(**{...})? Does the response_model rerun the validation if the object already matches the correct model class? |
Beta Was this translation helpful? Give feedback.
-
|
I think it used to do that because of the secure cloned field thing, but I think that has been removed in the latest fastapi (when used with pydantic v2) so it shouldn't re-run full validation anymore. |
Beta Was this translation helpful? Give feedback.
-
|
Here is a concrete example of why we cannot use |
Beta Was this translation helpful? Give feedback.
-
|
I think this was concluded in the conversation here: #9954 right? If not, or if you still have problems, please create a new discussion question, I'm about to close this one for clean up as there's too much going on here and several things are already resolved. |
Beta Was this translation helpful? Give feedback.
-
|
I have some issues with Decimals in new version. Now all Decimals are casted to strings instead of floats, and my external infrastructure is not yet ready for that: Why it works like that now: |
Beta Was this translation helpful? Give feedback.
-
|
Hi! Any suggestions on how to properly deal with Decimal serialization in new version? @Kludex |
Beta Was this translation helpful? Give feedback.
-
|
Hey there! Please create a new discussion question following the template (including an example, etc) and we can continue from there. I'm about to close this discussion for clean up. |
Beta Was this translation helpful? Give feedback.
-
|
Hi All, I am having a weird issue with using the constr function and how it is displayed in the docs. This are my classes: Nevertheless, when looking at the swagger docs (and redoc) it shows a weird pattern, and not the one defined. this is what I see: 
Any ideas what I am doing wrong? |
Beta Was this translation helpful? Give feedback.
-
|
Please share a snippet that I can copy-paste, and run it. |
Beta Was this translation helpful? Give feedback.
-
|
If you still have problems, please create a new discussion question following the template and we can continue there. |
Beta Was this translation helpful? Give feedback.
-
|
Upgrading to fastapi 0.100 I am seeing what looks like function call references in the View code: @app.get("/query-param-validation")
def get_query_param_validation(object_id: UUID):
return "OK"response with non-UUID object_id: before with fastapi 0.99.1 and pydantic 1.10.10: after with 0.100.0, pydantic 2.0.3: Expected behavior:
|
Beta Was this translation helpful? Give feedback.
-
|
Can you try using Pydantic 2.1.1? |
Beta Was this translation helpful? Give feedback.
-
Much better, thanks! 😁 |
Beta Was this translation helpful? Give feedback.
-
|
Hi, Upgrading to fastapi ==0.100.1, Using Pipenv:
AWS Lambda Python 3.11 x86_64. Error Messsage: Reverting back to 0.99.1 resolves the issues. |
Beta Was this translation helpful? Give feedback.
-
|
See pydantic/pydantic#6557 for more details. |
Beta Was this translation helpful? Give feedback.
-
|
Hi @Kludex, I have raised pydantic/pydantic#6990, as the above details do not solve the issue when the architecture's are the same. |
Beta Was this translation helpful? Give feedback.
-
|
Hello! Not sure if this was covered (I read through quite a few issues): I have an issue with OpenAPI and non required fields. Any idea? The following: #!/usr/bin/env python3
from fastapi import FastAPI, Depends, Query
from pydantic import BaseModel, Field
from typing import Annotated
import uvicorn
import os
app = FastAPI()
class MyInput(BaseModel):
foo: int|None = Field(title="hello world")
foodefault: int|None = Field(default=None,title="hello world")
foorequire: int = Field(title="hello required")
foodefaultnum: int = Field(default=0,title="hello world")
@app.get("/", response_model=MyInput)
async def root(ipt: MyInput = Depends()):
return ipt
if __name__ == "__main__":
uvicorn.run(app, port=int(os.environ.get("PORT", "8000")))
Requirements: And |
Beta Was this translation helpful? Give feedback.
-
|
This might be the same as here: #9709 (comment) What is somehow addressed here pydantic/pydantic#6647, but still waiting for this #9873. |
Beta Was this translation helpful? Give feedback.
-
|
Thank you! |
Beta Was this translation helpful? Give feedback.
-
|
So, the first thing is You can read more about it here: https://fastapi.tiangolo.com/python-types/#using-union-or-optional Now, about having |
Beta Was this translation helpful? Give feedback.
-
|
Looks like classes as dependencies doesn't work anymore when the class is a pydantic model. It used to work before, see this StackOverflow answer.
@router.get(path='/api/endpoints')
async def endpoint(
schema: Annotated[SomeSchema, Depends()],
):
...This gives the following exception: A workaround I found is to explicitly catch the pydantic error and convert it to fastapi's def validate_schema(request: Request) -> SomeSchema:
try:
return SomeSchema.model_validate(request.query_params)
except pydantic.ValidationError as exc:
raise RequestValidationError(exc.errors()) from None
@router.get(path='/api/endpoints')
async def endpoint(
schema: Annotated[SomeSchema, Depends(validate_schema)],
):
... |
Beta Was this translation helpful? Give feedback.
-
|
This was actually never officially supported by FastAPI (nor documented), it was a hack that worked by accident. I want to add support for something similar in the future, but it's not there yet. |
Beta Was this translation helpful? Give feedback.
-
|
I have a problem using Annotated directly as a request param when using MongoDB _id. I updated my ObjectIdType to new pydantic as following: Then I have the route: That gives me an error while starting the app (please note that it says "response field" in the error, instead of "request field", however it is not the main problem):
FastAPI: 0.100.1 |
Beta Was this translation helpful? Give feedback.
-
|
First, I've seen the code above for defining Regardless of that, I'm confused with Seems to me like you would want |
Beta Was this translation helpful? Give feedback.
-
|
Hmm, this is probably not related to the migration between Pydantic v1 and v2, but anyway, please create a new question following the template, including an example I can copy paste and run, etc. I'm about to close this discussion to clean things up and better keep track of everything. |
Beta Was this translation helpful? Give feedback.
-
|
Is it expected that This test only works with fastapi==0.100.1 when removing My expectation is that it still works as you state "This version of FastAPI still supports Pydantic v1.". import pytest
from fastapi import FastAPI
from httpx import AsyncClient
from pydantic.v1 import BaseModel
app = FastAPI()
pytestmark = pytest.mark.anyio
class MyResponse(BaseModel):
...
@pytest.fixture
def anyio_backend():
return 'asyncio'
@app.get("/", response_model=MyResponse)
async def get():
return MyResponse()
async def test():
async with AsyncClient(app=app, base_url="http://local") as client:
res = await client.get("/")
assert res.json() == {} |
Beta Was this translation helpful? Give feedback.
-
|
Discussion here: #9966 |
Beta Was this translation helpful? Give feedback.
-
|
The error message shown by a model validation error is worse in FastAPI 0.100.0 and above. For the following test code, the route will raise a from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class RootSchema(BaseModel):
foo: str
@app.get("/", response_model=RootSchema)
def get_root():
return {}In which is helpful as the error from pydantic is shown and can be used to debug the issue. However, in which doesn't show the error from Pydantic, and makes the error quite a bit harder to debug (in my opinion). |
Beta Was this translation helpful? Give feedback.
-
|
Thanks, could you please create a new discussion question? It will help me keep track of it. I'm about to close this one to clean things up. |
Beta Was this translation helpful? Give feedback.
-
|
Thanks all for the feedback! 🍪 ☕ As FastAPI with support for Pydantic v2 is now released, if you have any problems with it, please create a new discussion question following the template. I'm gonna close this discussion now to clean things up, there are too many conversations here and many are already solved, so it's hard to keep track of what still needs attention. So, let's continue with the normal workflow of creating a new discussion question with a minimal reproducible example, following all the steps, etc. 🤓 |
Beta Was this translation helpful? Give feedback.
and others
Thanks all for the feedback! 🍪 ☕
As FastAPI with support for Pydantic v2 is now released, if you have any problems with it, please create a new discussion question following the template. I'm gonna close this discussion now to clean things up, there are too many conversations here and many are already solved, so it's hard to keep track of what still needs attention. So, let's continue with the normal workflow of creating a new discussion question with a minimal reproducible example, following all the steps, etc. 🤓