In Pydantic 2, you can use MyModel.model_validate(my_dict) to generate a model from a dictionary. According to the documentation –

this is very similar to the __init__ method of the model, except it takes a dict rather than keyword arguments.

If you're Pydantic 1, the method is parse_obj instead.

It's not entirely clear what you are trying to achieve, so here's my best guess:

Pydantic's create_model() is meant to be used when

the shape of a model is not known until runtime.

From your code it's not clear whether or not this is really necessary.

Here's how I would approach this.

(The code below is using Python 3.9 and above type hints. If you're using an earlier version, you might have to replace list with typing.List and dict with typing.Dict.)

Using a "Static" Model

from pydantic import BaseModel, create_model
from typing import Optional

class Data(BaseModel):
    type: str
    daytime: dict[str, int] # <- explicit types in the dict, values will be coerced

class System(BaseModel):
    data: Optional[Data]

system = {
    "data": {
        "type": "solar",
        "daytime": {
            "sunrise": 1,
            "sunset": 10
        }
    }
}

p = System.parse_obj(system)
print(repr(p))
# System(data=Data(type='solar', daytime={'sunrise': 1, 'sunset': 10}))

This will accept integers in daytime but not other types, like strings.

That means, something like this:

system = {
    "data": {
        "type": "solar",
        "daytime": {
            "sunrise": "some string",
            "sunset": 10
        }
    }
}

p = System.parse_obj(system)

will fail with:

pydantic.error_wrappers.ValidationError: 1 validation error for System
data -> daytime -> sunrise
  value is not a valid integer (type=type_error.integer)

If you want more control over how "daytime" is being parsed, you could create an additional model for it, e.g.:

class Daytime(BaseModel):
    sunrise: int
    sunset: int

class Data(BaseModel):
    type: str
    daytime: Daytime

class System(BaseModel):
    data: Optional[Data]

This will work as above however, only the parameters sunrise and sunset will be parsed and everything else that might be inside "daytime" will be ignored (by default).

Using a "Dynamic" Model

If you really need to create the model dynamically, you can use a similar approach:

class System(BaseModel):
    data: Optional[
        create_model(
            "Data",
            type=(str, ...),
            daytime=(dict[str, int], ...), # <- explicit types in dict
        )
    ] = None

system = {
    "data": {
        "type": "solar",
        "daytime": {
            "sunrise": 1,
            "sunset": 10
        }
    }
}

p = System.parse_obj(system)
print(repr(p))

will work, while

system = {
    "data": {
        "type": "solar",
        "daytime": {
            "sunrise": "abc",
            "sunset": 10
        }
    }
}

p = System.parse_obj(system)

will fail with

pydantic.error_wrappers.ValidationError: 1 validation error for System
data -> daytime -> sunrise
  value is not a valid integer (type=type_error.integer)

Sure datamodel-code-generator is what you looking for https://docs.pydantic.dev/latest/integrations/datamodel_code_generator/.

Or you could write something that converted JSON Schema to pydantic core schema directly.

We won't be adding this functionality directly to pydantic.