What Is Pydantic? – DZone Web Dev

by:

Web Development

Pydantic is a Python library for data modeling/parsing that has efficient error handling and a custom validation mechanism. As of today, Pydantic is used mostly in the FastAPI framework for parsing requests and responses because Pydantic has built-in support for JSON encoding and decoding. 

This article covers the following topics:

  • Understanding BaseModel class 
  • Optional in Pydantic
  • Validation in Pydantic
  • Custom validation 
  • Email validation using Pydantic optional email-validator module 

BaseModel

For data modeling in Pydantic, we need to define a class that inherits from the BaseModel class and fields. Custom validation logic sits in the same model class.  Let’s understand by the simple example of JSON parsing. Consider a JSON representing user data.

Input

data = "id":20, "name":"John", "age":42, "dept":"IT"

For parsing, first, we need to import BaseModel and declare a class User, which inherits from the BaseModel.

from pydantic import BaseModel
from pprint import print

data = "id":20, "name":"John", "age":42, "dept":"IT"

class User(BaseModel):

    id: int

    name: str

    age: int

    dept: str

Next, need to instantiate an object from the User class:

user = User(**data)
pprint(user)

Output  

User(id=20, name="John", age=42, dept="IT") 

Optional in Pydantic

Attributes in the User class can be declared of type Optional. If we are not sure whether any JSON field will be present or not, we can declare that specific type as Optional and if the field is missing, by default, Optional returns None if the attribute is not initialized with a default value. In the example, let’s remove the dept field completely:

from pydantic import BaseModel
from typing import Optional
from pprint import pprint

data = "id":20, "name":"John", "age":42

class User(BaseModel):
id: int
name: str
age: int
dept: Optional[str]

user = User(**data)
 pprint(user)

Output

The dept field value is None, as it’s missing in the input data.

User(id=20, name="John", age=42, dept=None)

Validation in Pydantic

In Pydantic, to get finer error details, developers need to use try/except block. The error will be of type pydantic.error_wrappers.ValidationError.

In our JSON data, modify the id field to string, and import ValidationError.

Input Data

data = "id":"default", "name":"John", "age":42

Program

from pydantic import BaseModel, ValidationError

from typing import Optional

from pprint import pprint

data = "id":"default", "name":"John", "age":42

class User(BaseModel):

    id: int

    name: str

    age: int

    dept: Optional[str]

try:

    user = User(**data)

    pprint(user)

except ValidationError as error:

    pprint(error)

Error

ValidationError(model="User", errors=['loc': ('id',), 'msg': 'value is not a valid integer', 'type': 'type_error.integer'])

The error can be represented as JSON for better readability:

try:

    user = User(**data)

    pprint(user)

except ValidationError as error:

    print(error.json())

This returns JSON:

[

  

    "loc": [

      "id"

    ],

    "msg": "value is not a valid integer",

    "type": "type_error.integer"

  

]

Custom Validation 

Pydantic has useful decorators for custom validation of attributes. Developers need to import the Pydantic validator decorator and write our custom validation logic; for example, raise an error if the length of the name field is less than 3 characters. 

Input Data

data = "id":10, "name":"ab", "age":42

Program

from pydantic import BaseModel, ValidationError, validator
from typing import Optional
from pprint import pprint

data = "id":10, "name":"ab", "age":42


class User(BaseModel):
id: int
name: str
age: int
dept: Optional[str]

@validator('name')
def validate_name(cls, name):
print('Length of Name:', len(name))
if len (name) < 3:
raise ValueError('Name length must be > 3')
return name

try:
user = User(**data)
print(user)
except ValidationError as e:
 print(e.json())

Error

[

  

    "loc": [

      "name"

    ],

    "msg": "Name length must be > 3",

    "type": "value_error"

  

]

Email Validation

The reason for covering email validation is that one can utilize the Pydantic custom optional email-validator library. You will need to import validate_email from the email_validator module. Using the @validator decorator, all we need to do is invoke validate_email with the data. 

Input Data

data = "id":20, "name":"Sameer", "age":42, "email":"sameer@abc.com"

Program

from pydantic import BaseModel, ValidationError, validator, Required

from typing import Optional

from pprint import pprint

from email_validator import validate_email



class User(BaseModel):

    id: int

    name: str

    age: int

    dept: Optional[str]

    email: str



    @validator('name')

    def validateName(cls, name):

        print('Length of Name:', len(name))

        if (len(name) < 3):

            raise ValueError('Name length must be > 3')

        return name



    @validator('email')

    def validateEmail(cls, email):

        valid_email = validate_email(email)

        return valid_email.email

try:

    user = User(**data)

    pprint(user)

except ValidationError as e:

    print(e.json())

Output

User(id=20, name="Sameer", age=42, dept=None, email="sameer@abc.com")

Let’s change the value of email to incorrect email-id:

data = "id":20, "name":"Sameer", "age":42, "email":"sameer"

Error

[

  

    "loc": [

      "email"

    ],

    "msg": "The email address is not valid. It must have exactly one @-sign.",

    "type": "value_error.emailsyntax"

  

]

It clearly indicates that the @ sign is missing. After providing the correct email-id, it returns everything in order. 

Conclusion

Pydantic can be used with any Python-based framework and it supports native JSON encoding and decoding as well. As we have seen throughout the article, adopting Pydantic is simple, and it has various built-in classes and decorators which help in efficient data modeling, validation, and error handling.

Leave a Reply

Your email address will not be published.