Python pydantic.create_model() Examples
The following are 19
code examples of pydantic.create_model().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
pydantic
, or try the search function
.
![](https://www.programcreek.com/common/static/images/search.png)
Example #1
Source File: test_create_model.py From pydantic with MIT License | 6 votes |
def test_repeat_base_usage(): class Model(BaseModel): a: str assert Model.__fields__.keys() == {'a'} model = create_model('FooModel', b=1, __base__=Model) assert Model.__fields__.keys() == {'a'} assert model.__fields__.keys() == {'a', 'b'} model2 = create_model('Foo2Model', c=1, __base__=Model) assert Model.__fields__.keys() == {'a'} assert model.__fields__.keys() == {'a', 'b'} assert model2.__fields__.keys() == {'a', 'c'} model3 = create_model('Foo2Model', d=1, __base__=model) assert Model.__fields__.keys() == {'a'} assert model.__fields__.keys() == {'a', 'b'} assert model2.__fields__.keys() == {'a', 'c'} assert model3.__fields__.keys() == {'a', 'b', 'd'}
Example #2
Source File: schemas.py From CTFd with Apache License 2.0 | 6 votes |
def sqlalchemy_to_pydantic( db_model: Type, *, exclude: Container[str] = [] ) -> Type[BaseModel]: """ Mostly copied from https://github.com/tiangolo/pydantic-sqlalchemy """ mapper = inspect(db_model) fields = {} for attr in mapper.attrs: if isinstance(attr, ColumnProperty): if attr.columns: column = attr.columns[0] python_type = column.type.python_type name = attr.key if name in exclude: continue default = None if column.default is None and not column.nullable: default = ... fields[name] = (python_type, default) pydantic_model = create_model( db_model.__name__, **fields # type: ignore ) return pydantic_model
Example #3
Source File: test_jsonable_encoder.py From fastapi with MIT License | 6 votes |
def fixture_model_with_path(request): class Config: arbitrary_types_allowed = True ModelWithPath = create_model( "ModelWithPath", path=(request.param, ...), __config__=Config ) return ModelWithPath(path=request.param("/foo", "bar"))
Example #4
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_invalid_name(): with pytest.warns(RuntimeWarning): model = create_model('FooModel', _foo=(str, ...)) assert len(model.__fields__) == 0
Example #5
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_funky_name(): model = create_model('FooModel', **{'this-is-funky': (int, ...)}) m = model(**{'this-is-funky': '123'}) assert m.dict() == {'this-is-funky': 123} with pytest.raises(ValidationError) as exc_info: model() assert exc_info.value.errors() == [ {'loc': ('this-is-funky',), 'msg': 'field required', 'type': 'value_error.missing'} ]
Example #6
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_inheritance_validators_all(): class BarModel(BaseModel): @validator('*') def check_all(cls, v): return v * 2 model = create_model('FooModel', a=(int, ...), b=(int, ...), __base__=BarModel) assert model(a=2, b=6).dict() == {'a': 4, 'b': 12}
Example #7
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_inheritance_validators(): class BarModel(BaseModel): @validator('a', check_fields=False) def check_a(cls, v): if 'foobar' not in v: raise ValueError('"foobar" not found in a') return v model = create_model('FooModel', a='cake', __base__=BarModel) assert model().a == 'cake' assert model(a='this is foobar good').a == 'this is foobar good' with pytest.raises(ValidationError): model(a='something else')
Example #8
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_custom_config_extras(): class Config(BaseModel.Config): extra = Extra.forbid model = create_model('FooModel', foo=(int, ...), __config__=Config) assert model(foo=654) with pytest.raises(ValidationError): model(bar=654)
Example #9
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_custom_config_inherits(): class Config(BaseModel.Config): fields = {'foo': 'api-foo-field'} model = create_model('FooModel', foo=(int, ...), __config__=Config) assert model(**{'api-foo-field': '987'}).foo == 987 assert issubclass(model.__config__, BaseModel.Config) with pytest.raises(ValidationError): model(foo=654)
Example #10
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_custom_config(): class Config: fields = {'foo': 'api-foo-field'} model = create_model('FooModel', foo=(int, ...), __config__=Config) assert model(**{'api-foo-field': '987'}).foo == 987 assert issubclass(model.__config__, BaseModel.Config) with pytest.raises(ValidationError): model(foo=654)
Example #11
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_inheritance(): class BarModel(BaseModel): x = 1 y = 2 model = create_model('FooModel', foo=(str, ...), bar=(int, 123), __base__=BarModel) assert model.__fields__.keys() == {'foo', 'bar', 'x', 'y'} m = model(foo='a', x=4) assert m.dict() == {'bar': 123, 'foo': 'a', 'x': 4, 'y': 2}
Example #12
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_field_wrong_tuple(): with pytest.raises(errors.ConfigError): create_model('FooModel', foo=(1, 2, 3))
Example #13
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_create_model_usage(): model = create_model('FooModel', foo=(str, ...), bar=123) m = model(foo='hello') assert m.foo == 'hello' assert m.bar == 123 with pytest.raises(ValidationError): model() with pytest.raises(ValidationError): model(foo='hello', bar='xxx')
Example #14
Source File: test_create_model.py From pydantic with MIT License | 5 votes |
def test_create_model(): model = create_model('FooModel', foo=(str, ...), bar=123) assert issubclass(model, BaseModel) assert issubclass(model.__config__, BaseModel.Config) assert model.__name__ == 'FooModel' assert model.__fields__.keys() == {'foo', 'bar'} assert model.__validators__ == {} assert model.__config__.__name__ == 'Config'
Example #15
Source File: test_model_signature.py From pydantic with MIT License | 5 votes |
def test_invalid_identifiers_signature(): model = create_model( 'Model', **{'123 invalid identifier!': Field(123, alias='valid_identifier'), '!': Field(0, alias='yeah')} ) assert _equals(str(signature(model)), '(*, valid_identifier: int = 123, yeah: int = 0) -> None') model = create_model('Model', **{'123 invalid identifier!': 123, '!': Field(0, alias='yeah')}) assert _equals(str(signature(model)), '(*, yeah: int = 0, **extra_data: Any) -> None')
Example #16
Source File: request.py From CTFd with Apache License 2.0 | 5 votes |
def validate_args(spec, location): """ A rough implementation of webargs using pydantic schemas. You can pass a pydantic schema as spec or create it on the fly as follows: @validate_args({"name": (str, None), "id": (int, None)}, location="query") """ if isinstance(spec, dict): spec = create_model("", **spec) schema = spec.schema() props = schema.get("properties", {}) required = schema.get("required", []) for k in props: if k in required: props[k]["required"] = True props[k]["in"] = location def decorator(func): # Inject parameters information into the Flask-Restx apidoc attribute. # Not really a good solution. See https://github.com/CTFd/CTFd/issues/1504 apidoc = getattr(func, "__apidoc__", {"params": {}}) apidoc["params"].update(props) func.__apidoc__ = apidoc @wraps(func) def wrapper(*args, **kwargs): data = ARG_LOCATIONS[location]() loaded = spec(**data).dict(exclude_unset=True) return func(*args, loaded, **kwargs) return wrapper return decorator
Example #17
Source File: utils.py From bitcart with MIT License | 4 votes |
def get_pagination_model(display_model): return create_pydantic_model( f"PaginationResponse_{display_model.__name__}", count=(int, ...), next=(Optional[str], None), previous=(Optional[str], None), result=(List[display_model], ...), __base__=BaseModel, )
Example #18
Source File: utils.py From fastapi with MIT License | 4 votes |
def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]: flat_dependant = get_flat_dependant(dependant) if not flat_dependant.body_params: return None first_param = flat_dependant.body_params[0] field_info = get_field_info(first_param) embed = getattr(field_info, "embed", None) body_param_names_set = set([param.name for param in flat_dependant.body_params]) if len(body_param_names_set) == 1 and not embed: return get_schema_compatible_field(field=first_param) # If one field requires to embed, all have to be embedded # in case a sub-dependency is evaluated with a single unique body field # That is combined (embedded) with other body fields for param in flat_dependant.body_params: setattr(get_field_info(param), "embed", True) model_name = "Body_" + name BodyModel = create_model(model_name) for f in flat_dependant.body_params: BodyModel.__fields__[f.name] = get_schema_compatible_field(field=f) required = any(True for f in flat_dependant.body_params if f.required) BodyFieldInfo_kwargs: Dict[str, Any] = dict(default=None) if any( isinstance(get_field_info(f), params.File) for f in flat_dependant.body_params ): BodyFieldInfo: Type[params.Body] = params.File elif any( isinstance(get_field_info(f), params.Form) for f in flat_dependant.body_params ): BodyFieldInfo = params.Form else: BodyFieldInfo = params.Body body_param_media_types = [ getattr(get_field_info(f), "media_type") for f in flat_dependant.body_params if isinstance(get_field_info(f), params.Body) ] if len(set(body_param_media_types)) == 1: BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0] return create_response_field( name="body", type_=BodyModel, required=required, alias="body", field_info=BodyFieldInfo(**BodyFieldInfo_kwargs), )
Example #19
Source File: utils.py From fastapi with MIT License | 4 votes |
def create_cloned_field( field: ModelField, *, cloned_types: Dict[Type[BaseModel], Type[BaseModel]] = None, ) -> ModelField: # _cloned_types has already cloned types, to support recursive models if cloned_types is None: cloned_types = dict() original_type = field.type_ if is_dataclass(original_type) and hasattr(original_type, "__pydantic_model__"): original_type = original_type.__pydantic_model__ # type: ignore use_type = original_type if lenient_issubclass(original_type, BaseModel): original_type = cast(Type[BaseModel], original_type) use_type = cloned_types.get(original_type) if use_type is None: use_type = create_model(original_type.__name__, __base__=original_type) cloned_types[original_type] = use_type for f in original_type.__fields__.values(): use_type.__fields__[f.name] = create_cloned_field( f, cloned_types=cloned_types ) new_field = create_response_field(name=field.name, type_=use_type) new_field.has_alias = field.has_alias new_field.alias = field.alias new_field.class_validators = field.class_validators new_field.default = field.default new_field.required = field.required new_field.model_config = field.model_config if PYDANTIC_1: new_field.field_info = field.field_info else: # pragma: nocover new_field.schema = field.schema # type: ignore new_field.allow_none = field.allow_none new_field.validate_always = field.validate_always if field.sub_fields: new_field.sub_fields = [ create_cloned_field(sub_field, cloned_types=cloned_types) for sub_field in field.sub_fields ] if field.key_field: new_field.key_field = create_cloned_field( field.key_field, cloned_types=cloned_types ) new_field.validators = field.validators if PYDANTIC_1: new_field.pre_validators = field.pre_validators new_field.post_validators = field.post_validators else: # pragma: nocover new_field.whole_pre_validators = field.whole_pre_validators # type: ignore new_field.whole_post_validators = field.whole_post_validators # type: ignore new_field.parse_json = field.parse_json new_field.shape = field.shape try: new_field.populate_validators() except AttributeError: # pragma: nocover # TODO: remove when removing support for Pydantic < 1.0.0 new_field._populate_validators() # type: ignore return new_field