How to require predefined string values in python pydantic basemodels?

Question

Is there any in-built way in pydantic to specify options? For example, let's say I want a string value that must either have the value "foo" or "bar".

I know I can use regex validation to do this, but since I use pydantic with FastAPI, the users will only see the required input as a string, but when they enter something, it will give a validation error. All in-built validations of pydantic are displayed in the api interface, so would be great if there was something like

class Input(BaseModel):
     option: "foo" || "bar"

Addison · Accepted Answer · 2024-11-26 01:54:41Z

138

Yes, you can either use an enum:

class Choices(Enum):
    foo = 'foo'
    bar = 'bar'

class Input(BaseModel):
     option: Choices

see here

Or you can use Literal:

from typing import Literal

class Input(BaseModel):
     option: Literal['foo', 'bar']

see here

edited Nov 26, 2024 at 1:54

Addison

8,6755 gold badges44 silver badges65 bronze badges

answered Apr 16, 2020 at 10:57

Samuel Colvin

13.5k7 gold badges64 silver badges78 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Gabriel Petersson Over a year ago

Thanks this worked. I also want to add that in python 3.8+ its from typing import Literal, while <3.8 you need to use from typing_extensions import Literal

Samuel Colvin Over a year ago

Or for simplicity you can use from pydantic.typing import Literal which will work on both.

Aravind Over a year ago

How to include list of predefined values for a given field?

selle Over a year ago

@SamuelColvin Not anymore though. It's Literal from typing nowadays: docs.pydantic.dev/latest/api/standard_library_types/…

Samuel Colvin Jan 6 at 21:32

sorry, I think that was just a typo from me!

Yaakov Bressler · Accepted Answer · 2025-02-05 16:51:07Z

Easiest: Use `typing.Literal`

Literal is a good option when you can hardcode your values:

class Input(BaseModel):
    option: Literal["foo", "bar"]

To use a dynamic list, wrap your list with a tuple:

allowed_values = ["foo", "bar"]

class Input(BaseModel):
    option: Literal[tuple(allowed_values)]

Alt: Use Validator

Assuming it is not possible to transcode into regex (say you have objects, not only strings), you would then want to use a field validator:

allowed_values = ["foo", "bar"]

class Input(BaseModel):
    option: str

    @field_validator("option")
    def validate_option(cls, v):
        assert v in allowed_values
        return v

Best: Reusable Field

Let's say this field is going to be reused in your codebase. A better approach would be to create a "custom field type" as such:

from typing import Annotated, Literal


allowed_values = ["foo", "bar"]
custom_option = Annotated[Literal[tuple(allowed_values)]]

class Input(BaseModel):
    option: custom_option

Reusable field with Annotated Validator

Previously, I had this as the answer. Will keep for posterity. You can add validators1 to reusable fields, which are neat:

from typing import Annotated
from pydantic import BaseModel, AfterValidator


allowed_values = ["foo", "bar"]

def option_in_allowed_values(v):
    """Ensures option is allowed"""
    assert v in allowed_values
    return v

custom_option = Annotated[str, AfterValidator(option_in_allowed_values)]


class Input(BaseModel):
    option: custom_option

Steven Staley · Accepted Answer · 2023-03-23 21:46:32Z

5

Wanted to add another option here. You could also use a Regex. Worked better for me since Literal isn't available until python 3.8 (which is unfortunately not an easy upgrade for me) and since I'm only expecting a single string for each, enum didn't really fit.

class YourClass(pydantic.BaseModel):
  your_attribute: pydantic.constr(regex="^yourvalwith\.escapes\/abcd$")

answered Mar 23, 2023 at 21:46

Steven Staley

3371 gold badge3 silver badges11 bronze badges

Comments

Shaun · Accepted Answer · 2024-01-18 13:52:05Z

3

I'd like to expand on Yaakov's answer. You can use functools.partial to bake in your values list

from functools import partial
from typing import Annotated
from pydantic import BaseModel, AfterValidator


def allowed_values(v, values):
    assert v in values
    return v

class Input(BaseModel):
    option: Annotated[str, AfterValidator(partial(allowed_values, values=["a", "b"]))]

answered Jan 18, 2024 at 13:52

Shaun

3,8934 gold badges27 silver badges46 bronze badges

2 Comments

Konstantin Smolyanin Over a year ago

+1 This is the best solution here because you have a function that is not coupled with a list of values. So you can pass any list later.

Yaakov Bressler Dec 26, 2024 at 4:36

This is neat :)

Collectives™ on Stack Overflow

How to require predefined string values in python pydantic basemodels?

4 Answers 4

5 Comments

Easiest: Use `typing.Literal`

Alt: Use Validator

Best: Reusable Field

Reusable field with Annotated Validator

Comments

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

5 Comments

Easiest: Use typing.Literal

Alt: Use Validator

Best: Reusable Field

Reusable field with Annotated Validator

Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related

Easiest: Use `typing.Literal`