如何在 python 中使用 Pydantic model 验证 2 个嵌套的 json？

Question

test1 = {
  "abx": [
    {
      "name": "toyota",
      "colors": "abc",
      "demo": [
        {
          "name1": "pqr",
          "surname": "abc",
          "columns": [
            {
              "name2": "demo",
              "nameid": "1"
            }
          ]
        }
      ]
    },
    {
      "name": "suzuki",
      "colors": "deq",
      "demo": [
        {
          "name1": "abc",
          "surname": "asd",
          "columns": [
            {
              "name2": "demo1",
              "nameid": "2"
            }
          ]
        }
      ]
    }
  ]
}

I have 2 nested JSON and both responses have shuffle values. I wanted to match using Pydantic models for testing in Python.

Is there any way to compare, validate both responses?

Answer 1

A nested JSON can simply be represented by nested Pydantic models . Each object can be mapped to a model, and that model can have attributes that are other Pydantic models or a list of Pydantic models.

You start with the innermost objects:

{
    "name2": "demo1",
    "nameid": "2",
}

which can be represented as:

from pydantic import BaseModel, constr

class Column(BaseModel):
    name2: str
    nameid: constr(regex="[0-9]+")  # See: https://pydantic-docs.helpmanual.io/usage/types/#arguments-to-constr

In [2]: raw = {"name2": "demo1", "nameid": "2"}
In [3]: col = Column(**raw)
In [4]: col.name2
Out[4]: 'demo1'
In [5]: col.nameid
Out[5]: '2'

If one of the values is wrong, Pydantic would raise a validation error:

In [6]: raw = {"name2": 1, "nameid": True}
In [7]: col = Column(**raw)
...
ValidationError: 1 validation error for Column
nameid
  string does not match regex "[0-9]+" (type=value_error.str.regex; pattern=[0-9]+)

Then you move up to each Column 's parent object:

{
    "name1": "abc",
    "surname": "asd",
    "columns": [
        {"name2": "demo1", "nameid": "2"},
    ],
}

which can then be represented as:

from pydantic import BaseModel, conlist

class Demo(BaseModel):
    name1: str
    surname: str
    columns: conlist(Column, min_items=1)  # See: https://pydantic-docs.helpmanual.io/usage/types/#arguments-to-conlist

where we reuse the previous Column class definition, to say that the columns attribute is a list of Column 's. Pydantic can instantiate and validate each attribute of Column under Demo :

In [8]: raw
Out[8]: {'name1': 'abc', 'surname': 'asd', 'columns': [{'name2': 'demo1', 'nameid': '2'}]}
In [9]: demo = Demo(**raw)
In [11]: demo.name1
Out[11]: 'abc'
In [13]: demo.surname
Out[13]: 'asd'
In [14]: demo.columns
Out[14]: [Column(name2='demo1', nameid='2')]
In [15]: demo.columns[0].name2
Out[15]: 'demo1'
In [16]: demo.columns[0].nameid
Out[16]: '2'

Again, if any of the values are wrong (whether from the outer attributes or from the innermost attributes), Pydantic will raise a validation error:

In [20]: raw
Out[20]: {'name1': 'abc', 'surname': None, 'columns': [{'name2': 'demo1', 'nameid': '2'}]}
In [21]: demo = Demo(**raw)
...
ValidationError: 1 validation error for Demo
surname
  none is not an allowed value (type=type_error.none.not_allowed)

In [27]: raw
Out[27]: {'name1': 'abc', 'surname': 'asd', 'columns': [{'name2': None, 'nameid': '2'}]}
In [28]: demo = Demo(**raw)
...
ValidationError: 1 validation error for Demo
columns -> 0 -> name2
  none is not an allowed value (type=type_error.none.not_allowed)

Then after that, you move up again to each Demo 's parent object

{
    "name": "suzuki",
    "colors": "deq",
    "demo": [
        {
            "name1": "abc",
            "surname": "asd",
            "columns": [
                {"name2": "demo1", "nameid": "2"},
            ],
        }
    ],
}

which can be represented as

from pydantic import BaseModel, conlist

class Car(BaseModel):
    name: str
    colors: str
    demo: conlist(Demo, min_items=1)

where, same as what we did for Column , we have a demo attribute that is modeled as a list of Demo objects. Pydantic can handle nested initialization and validation of demo which includes its inner Column class.

Finally, you'll reach the uppermost object:

test1 = {
    "abx": [
        {...},
        {...},
    ]
}

which has an abx attribute that's a list of Car objects

from pydantic import BaseModel, conlist

class Test(BaseModel):
    abx: conlist(Car, min_items=1)

In [3]: obj = Test(**test1)
In [4]: obj
Out[4]: Test(abx=[Car(name='toyota', colors='abc', demo=[Demo(name1='pqr', surname='abc', columns=[Column(name2='demo', nameid='1')])]), Car(name='suzuki', colors='deq', demo=[Demo(name1='abc', surname='asd', columns=[Column(name2='demo1', nameid='2')])])])

In [5]: obj.abx[1]
Out[5]: Car(name='suzuki', colors='deq', demo=[Demo(name1='abc', surname='asd', columns=[Column(name2='demo1', nameid='2')])])

In [6]: obj.abx[1].demo[0]
Out[6]: Demo(name1='abc', surname='asd', columns=[Column(name2='demo1', nameid='2')])

You can also stop modeling anywhere, for example, stop at modeling a Car and validate from the raw abx object:

In [15]: car1 = Car(**test1['abx'][0])
In [16]: car1
Out[16]: Car(name='toyota', colors='abc', demo=[Demo(name1='pqr', surname='abc', columns=[Column(name2='demo', nameid='1')])])

In [17]: car2 = Car(**test1['abx'][1])
In [18]: car2
Out[18]: Car(name='suzuki', colors='deq', demo=[Demo(name1='abc', surname='asd', columns=[Column(name2='demo1', nameid='2')])])

Again, if you have an error, even somewhere in the inner Column model, you'll get a validation error.

The good thing about this is that you can test and validate each object in turn, from the innermost ones up to the outermost one. For more details about the usage of constr and conlist , check Pydantic docs for Constrained Types as well as the other Field Types and Validators for more complex validations.