Bump Pydantic ♻️

Bump Pydantic is a tool to help you migrate your code from Pydantic V1 to V2.

[!NOTE]\ If you find bugs, please report them on the issue tracker.

Table of contents

• Bump Pydantic ♻️

  • Table of contents

  • Installation

  • Usage

  • Check diff before applying changes

  • Apply changes

  • Rules

  • BP001: Add default None to Optional[T], Union[T, None] and Any fields

  • BP002: Replace Config class by model_config attribute

  • BP003: Replace Field old parameters to new ones

  • BP004: Replace imports

  • BP005: Replace GenericModel by BaseModel

  • BP006: Replace __root__ by RootModel

  • BP007: Replace decorators

  • BP008: Replace con* functions by Annotated versions

  • BP009: Mark pydantic "protocol" functions in custom types with proper TODOs

  • License

Installation

The installation is as simple as:

pip install bump-pydantic

Usage

bump-pydantic is a CLI tool, hence you can use it from your terminal.

It's easy to use. If your project structure is:

repository/
└── my_package/
    └── <python source files>

Then you'll want to do:

cd /path/to/repository
bump-pydantic my_package

Check diff before applying changes

To check the diff before applying the changes, you can run:

bump-pydantic --diff <path>

Apply changes

To apply the changes, you can run:

bump-pydantic <path>

Rules

You can find below the list of rules that are applied by bump-pydantic.

It's also possible to disable rules by using the --disable option.

BP001: Add default None to Optional[T], Union[T, None] and Any fields

• ✅ Add default None to Optional[T] fields.

The following code will be transformed:

class User(BaseModel):
    name: Optional[str]

Into:

class User(BaseModel):
    name: Optional[str] = None

BP002: Replace Config class by model_config attribute

• ✅ Replace Config class by model_config = ConfigDict().
• ✅ Rename old Config attributes to new model_config attributes.
• ✅ Add a TODO comment in case the transformation can't be done automatically.
• ✅ Replace Extra enum by string values.

The following code will be transformed:

from pydantic import BaseModel, Extra

class User(BaseModel):
    name: str

    class Config:
        extra = Extra.forbid

Into:

from pydantic import ConfigDict, BaseModel

class User(BaseModel):
    name: str

    model_config = ConfigDict(extra="forbid")

BP003: Replace Field old parameters to new ones

• ✅ Replace Field old parameters to new ones.
• ✅ Replace field: Enum = Field(Enum.VALUE, const=True) by field: Literal[Enum.VALUE] = Enum.VALUE.

The following code will be transformed:

from typing import List

from pydantic import BaseModel, Field

class User(BaseModel):
    name: List[str] = Field(..., min_items=1)

Into:

from typing import List

from pydantic import BaseModel, Field

class User(BaseModel):
    name: List[str] = Field(..., min_length=1)

BP004: Replace imports

• ✅ Replace BaseSettings from pydantic to pydantic_settings.
• ✅ Replace Color and PaymentCardNumber from pydantic to pydantic_extra_types.

BP005: Replace GenericModel by BaseModel

• ✅ Replace GenericModel by BaseModel.

The following code will be transformed:

from typing import Generic, TypeVar
from pydantic.generics import GenericModel

T = TypeVar('T')

class User(GenericModel, Generic[T]):
    name: str

Into:

from typing import Generic, TypeVar
from pydantic import BaseModel

T = TypeVar('T')

class User(BaseModel, Generic[T]):
    name: str

BP006: Replace __root__ by RootModel

• ✅ Replace __root__ by RootModel.

The following code will be transformed:

from typing import List

from pydantic import BaseModel

class User(BaseModel):
    age: int
    name: str

class Users(BaseModel):
    __root__ = List[User]

Into:

from typing import List

from pydantic import RootModel, BaseModel

class User(BaseModel):
    age: int
    name: str

class Users(RootModel[List[User]]):
    pass

BP007: Replace decorators

• ✅ Replace @validator by @field_validator.
• ✅ Replace @root_validator by @model_validator.

The following code will be transformed:

from pydantic import BaseModel, validator, root_validator

class User(BaseModel):
    name: str

    @validator('name', pre=True)
    def validate_name(cls, v):
        return v

    @root_validator(pre=True)
    def validate_root(cls, values):
        return values

Into:

from pydantic import BaseModel, field_validator, model_validator

class User(BaseModel):
    name: str

    @field_validator('name', mode='before')
    def validate_name(cls, v):
        return v

    @model_validator(mode='before')
    def validate_root(cls, values):
        return values

BP008: Replace con* functions by Annotated versions

• ✅ Replace constr(*args) by Annotated[str, StringConstraints(*args)].
• ✅ Replace conint(*args) by Annotated[int, Field(*args)].
• ✅ Replace confloat(*args) by Annotated[float, Field(*args)].
• ✅ Replace conbytes(*args) by Annotated[bytes, Field(*args)].
• ✅ Replace condecimal(*args) by Annotated[Decimal, Field(*args)].
• ✅ Replace conset(T, *args) by Annotated[Set[T], Field(*args)].
• ✅ Replace confrozenset(T, *args) by Annotated[Set[T], Field(*args)].
• ✅ Replace conlist(T, *args) by Annotated[List[T], Field(*args)].

The following code will be transformed:

from pydantic import BaseModel, constr

class User(BaseModel):
    name: constr(min_length=1)

Into:

from pydantic import BaseModel, StringConstraints
from typing_extensions import Annotated

class User(BaseModel):
    name: Annotated[str, StringConstraints(min_length=1)]

BP009: Mark Pydantic "protocol" functions in custom types with proper TODOs

• ✅ Mark __get_validators__ as to be replaced by __get_pydantic_core_schema__.
• ✅ Mark __modify_schema__ as to be replaced by __get_pydantic_json_schema__.

The following code will be transformed:

class SomeThing:
    @classmethod
    def __get_validators__(cls):
        yield from []

    @classmethod
    def __modify_schema__(cls, field_schema, field):
        if field:
            field_schema['example'] = "Weird example"

Into:

class SomeThing:
    @classmethod
    # TODO[pydantic]: We couldn't refactor `__get_validators__`, please create the `__get_pydantic_core_schema__` manually.
    # Check https://docs.pydantic.dev/latest/migration/#defining-custom-types for more information.
    def __get_validators__(cls):
        yield from []

    @classmethod
    # TODO[pydantic]: We couldn't refactor `__modify_schema__`, please create the `__get_pydantic_json_schema__` manually.
    # Check https://docs.pydantic.dev/latest/migration/#defining-custom-types for more information.
    def __modify_schema__(cls, field_schema, field):
        if field:
            field_schema['example'] = "Weird example"

BP010: Add type annotations or TODO comments to fields without them

• ✅ Add type annotations based on the default value for a few types that can be inferred, like bool, str, int, float.
• ✅ Add # TODO[pydantic]: add type annotation comments to fields that can't be inferred.

The following code will be transformed:

from pydantic import BaseModel, Field

class Potato(BaseModel):
    name: str
    is_sale = True
    tags = ["tag1", "tag2"]
    price = 10.5
    description = "Some item"
    active = Field(default=True)
    ready = Field(True)
    age = Field(10, title="Age")

Into:

from pydantic import BaseModel, Field

class Potato(BaseModel):
    name: str
    is_sale: bool = True
    # TODO[pydantic]: add type annotation
    tags = ["tag1", "tag2"]
    price: float = 10.5
    description: str = "Some item"
    active: bool = Field(default=True)
    ready: bool = Field(True)
    age: int = Field(10, title="Age")

License

This project is licensed under the terms of the MIT license.