From 3fa5d10aeb34f994bd8950c1dbaaf70dc8b435f5 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Mon, 10 Feb 2025 15:09:17 +0000 Subject: [PATCH] remove `schema=` --- tests/benchmarks/test_micro_benchmarks.py | 172 +++++++++--------- tests/serializers/test_any.py | 2 +- tests/serializers/test_dataclasses.py | 2 +- tests/serializers/test_model.py | 6 +- tests/serializers/test_other.py | 4 +- tests/serializers/test_serialize_as_any.py | 16 +- tests/serializers/test_url.py | 8 +- tests/test_build.py | 10 +- tests/test_config.py | 22 +-- tests/test_errors.py | 68 +++---- tests/test_garbage_collection.py | 2 +- tests/test_hypothesis.py | 10 +- tests/test_isinstance.py | 8 +- tests/test_json.py | 46 ++--- tests/test_misc.py | 10 +- tests/test_prebuilt.py | 4 +- tests/test_schema_functions.py | 8 +- tests/test_tzinfo.py | 2 +- tests/test_validate_strings.py | 12 +- tests/test_validation_context.py | 2 +- tests/validators/test_allow_partial.py | 26 ++- tests/validators/test_arguments.py | 8 +- tests/validators/test_bool.py | 8 +- tests/validators/test_bytes.py | 10 +- tests/validators/test_call.py | 16 +- tests/validators/test_callable.py | 6 +- tests/validators/test_chain.py | 12 +- tests/validators/test_complex.py | 16 +- tests/validators/test_dataclasses.py | 76 ++++---- tests/validators/test_date.py | 20 +- tests/validators/test_datetime.py | 54 +++--- tests/validators/test_decimal.py | 36 ++-- tests/validators/test_definitions.py | 18 +- .../validators/test_definitions_recursive.py | 50 ++--- tests/validators/test_dict.py | 32 ++-- tests/validators/test_enums.py | 56 +++--- tests/validators/test_float.py | 20 +- tests/validators/test_frozenset.py | 24 +-- tests/validators/test_function.py | 96 +++++----- tests/validators/test_generator.py | 4 +- tests/validators/test_int.py | 40 ++-- tests/validators/test_is_instance.py | 28 +-- tests/validators/test_is_subclass.py | 12 +- tests/validators/test_json.py | 10 +- tests/validators/test_json_or_python.py | 2 +- tests/validators/test_lax_or_strict.py | 4 +- tests/validators/test_list.py | 40 ++-- tests/validators/test_literal.py | 26 ++- tests/validators/test_model.py | 72 ++++---- tests/validators/test_model_fields.py | 94 +++++----- tests/validators/test_model_init.py | 28 +-- tests/validators/test_model_root.py | 20 +- tests/validators/test_none.py | 4 +- tests/validators/test_nullable.py | 6 +- tests/validators/test_pickling.py | 6 +- tests/validators/test_set.py | 22 +-- tests/validators/test_string.py | 52 +++--- tests/validators/test_tagged_union.py | 12 +- tests/validators/test_time.py | 26 +-- tests/validators/test_timedelta.py | 30 ++- tests/validators/test_tuple.py | 40 ++-- tests/validators/test_typed_dict.py | 50 ++--- tests/validators/test_union.py | 96 +++++----- tests/validators/test_url.py | 36 ++-- tests/validators/test_uuid.py | 12 +- tests/validators/test_with_default.py | 92 ++++------ 66 files changed, 889 insertions(+), 973 deletions(-) diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py index 0c9757efa..3435174a5 100644 --- a/tests/benchmarks/test_micro_benchmarks.py +++ b/tests/benchmarks/test_micro_benchmarks.py @@ -123,7 +123,7 @@ def test_core_json_fs(self, core_model_validator, benchmark): @pytest.mark.benchmark(group='bool') def test_bool_core(benchmark): - schema_validator = SchemaValidator(schema=core_schema.bool_schema()) + schema_validator = SchemaValidator(core_schema.bool_schema()) @benchmark def t(): @@ -143,7 +143,7 @@ def test_small_class_core_dict(benchmark): 'age': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, }, } - dict_schema_validator = SchemaValidator(schema=model_schema) + dict_schema_validator = SchemaValidator(model_schema) benchmark(dict_schema_validator.validate_python, small_class_data) @@ -157,7 +157,7 @@ class MyCoreModel: age: int model_schema_validator = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyCoreModel, schema=core_schema.model_fields_schema( fields={ @@ -172,7 +172,7 @@ class MyCoreModel: @pytest.mark.benchmark(group='string') def test_core_string_lax(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema()) + validator = SchemaValidator(core_schema.str_schema()) input_str = 'Hello ' * 20 assert validator.validate_python(input_str) == input_str @@ -182,7 +182,7 @@ def test_core_string_lax(benchmark): @pytest.mark.benchmark(group='string') def test_core_string_lax_wrong(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema()) + validator = SchemaValidator(core_schema.str_schema()) with pytest.raises(ValidationError, match='Input should be a valid string'): validator.validate_python(123) @@ -197,7 +197,7 @@ def t(): @pytest.mark.benchmark(group='string') def test_core_string_strict(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) + validator = SchemaValidator(core_schema.str_schema(strict=True)) input_str = 'Hello ' * 20 assert validator.validate_python(input_str) == input_str @@ -207,7 +207,7 @@ def test_core_string_strict(benchmark): @pytest.mark.benchmark(group='string') def test_core_string_strict_wrong(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) + validator = SchemaValidator(core_schema.str_schema(strict=True)) with pytest.raises(ValidationError, match='Input should be a valid string'): validator.validate_python(123) @@ -222,7 +222,7 @@ def t(): @pytest.mark.benchmark(group='string') def test_core_string_strict_wrong_str_e(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) + validator = SchemaValidator(core_schema.str_schema(strict=True)) with pytest.raises(ValidationError, match='Input should be a valid string'): validator.validate_python(123) @@ -237,7 +237,7 @@ def t(): @pytest.mark.benchmark(group='isinstance-string') def test_isinstance_string_lax_true(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema()) + validator = SchemaValidator(core_schema.str_schema()) input_str = 'Hello ' * 20 assert validator.isinstance_python(input_str) is True @@ -247,7 +247,7 @@ def test_isinstance_string_lax_true(benchmark): @pytest.mark.benchmark(group='isinstance-string') def test_isinstance_string_lax_false(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema()) + validator = SchemaValidator(core_schema.str_schema()) assert validator.isinstance_python(123) is False @@ -256,7 +256,7 @@ def test_isinstance_string_lax_false(benchmark): @pytest.mark.benchmark(group='isinstance-string') def test_isinstance_string_strict_true(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) + validator = SchemaValidator(core_schema.str_schema(strict=True)) input_str = 'Hello ' * 20 assert validator.isinstance_python(input_str) is True @@ -266,7 +266,7 @@ def test_isinstance_string_strict_true(benchmark): @pytest.mark.benchmark(group='isinstance-string') def test_isinstance_string_strict_false(benchmark): - validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) + validator = SchemaValidator(core_schema.str_schema(strict=True)) assert validator.isinstance_python(123) is False @@ -293,7 +293,7 @@ class CoreBranch: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema(schema_ref='Branch'), [ core_schema.model_schema( @@ -322,7 +322,7 @@ class CoreBranch: @pytest.mark.benchmark(group='list[TypedDict]') def test_list_of_dict_models_core(benchmark): v = SchemaValidator( - schema=core_schema.list_schema( + core_schema.list_schema( items_schema=core_schema.typed_dict_schema( fields={'width': core_schema.typed_dict_field(schema=core_schema.int_schema())} ) @@ -338,7 +338,7 @@ def test_list_of_dict_models_core(benchmark): @pytest.mark.benchmark(group='list[int]') def test_list_of_ints_core_py(benchmark): - v = SchemaValidator(schema=core_schema.list_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema())) @benchmark def t(): @@ -348,7 +348,7 @@ def t(): @pytest.mark.benchmark(group='list[int] JSON') def test_list_of_ints_core_json(benchmark): - v = SchemaValidator(schema=core_schema.list_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema())) json_data = [json.dumps(d) for d in list_of_ints_data] @@ -363,14 +363,14 @@ def t(): @pytest.mark.benchmark(group='list[str]') def test_list_of_strs_py_cached(benchmark): - v = SchemaValidator(schema=core_schema.list_schema(core_schema.str_schema())) + v = SchemaValidator(core_schema.list_schema(core_schema.str_schema())) benchmark(v.validate_python, list_of_strs_data) @pytest.mark.benchmark(group='list[str]') def test_list_of_strs_json_cached(benchmark): - v = SchemaValidator(schema=core_schema.list_schema(core_schema.str_schema())) + v = SchemaValidator(core_schema.list_schema(core_schema.str_schema())) json_data = json.dumps(list_of_strs_data) benchmark(v.validate_json, json_data) @@ -378,9 +378,7 @@ def test_list_of_strs_json_cached(benchmark): @pytest.mark.benchmark(group='list[str]') def test_list_of_strs_json_uncached(benchmark): - v = SchemaValidator( - schema=core_schema.list_schema(core_schema.str_schema()), config=CoreConfig(cache_strings=False) - ) + v = SchemaValidator(core_schema.list_schema(core_schema.str_schema()), config=CoreConfig(cache_strings=False)) json_data = json.dumps(list_of_strs_data) benchmark(v.validate_json, json_data) @@ -388,7 +386,7 @@ def test_list_of_strs_json_uncached(benchmark): @pytest.mark.benchmark(group='list[Any]') def test_list_of_any_core_py(benchmark): - v = SchemaValidator(schema=core_schema.list_schema()) + v = SchemaValidator(core_schema.list_schema()) @benchmark def t(): @@ -402,7 +400,7 @@ def t(): @pytest.mark.benchmark(group='Set[int]') def test_set_of_ints_core(benchmark): - v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema())) @benchmark def t(): @@ -412,7 +410,7 @@ def t(): @pytest.mark.benchmark(group='Set[int]') def test_set_of_ints_core_duplicates(benchmark): - v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema())) @benchmark def t(): @@ -422,7 +420,7 @@ def t(): @pytest.mark.benchmark(group='Set[int]') def test_set_of_ints_core_length(benchmark): - v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema(), max_length=2000)) + v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema(), max_length=2000)) @benchmark def t(): @@ -432,7 +430,7 @@ def t(): @pytest.mark.benchmark(group='Set[int] JSON') def test_set_of_ints_core_json(benchmark): - v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema())) json_data = [json.dumps(list(d)) for d in set_of_ints_data] @@ -444,7 +442,7 @@ def t(): @pytest.mark.benchmark(group='Set[int] JSON') def test_set_of_ints_core_json_duplicates(benchmark): - v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema())) json_data = [json.dumps(list(d)) for d in set_of_ints_duplicates] @@ -460,14 +458,14 @@ def t(): @pytest.mark.benchmark(group='FrozenSet[int]') def test_frozenset_of_ints_core(benchmark): - v = SchemaValidator(schema=core_schema.frozenset_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.frozenset_schema(items_schema=core_schema.int_schema())) benchmark(v.validate_python, frozenset_of_ints) @pytest.mark.benchmark(group='FrozenSet[int]') def test_frozenset_of_ints_duplicates_core(benchmark): - v = SchemaValidator(schema=core_schema.frozenset_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.frozenset_schema(items_schema=core_schema.int_schema())) benchmark(v.validate_python, frozenset_of_ints_duplicates) @@ -478,7 +476,7 @@ def test_frozenset_of_ints_duplicates_core(benchmark): @pytest.mark.benchmark(group='dict[str, int]') def test_dict_of_ints_core(benchmark): v = SchemaValidator( - schema=core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()) + core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()) ) @benchmark @@ -489,7 +487,7 @@ def t(): @pytest.mark.benchmark(group='dict[any, any]') def test_dict_of_any_core(benchmark): - v = SchemaValidator(schema=core_schema.dict_schema()) + v = SchemaValidator(core_schema.dict_schema()) @benchmark def t(): @@ -500,7 +498,7 @@ def t(): @pytest.mark.benchmark(group='dict[str, int] JSON') def test_dict_of_ints_core_json(benchmark): v = SchemaValidator( - schema=core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()) + core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()) ) json_data = [json.dumps(d) for d in dict_of_ints_data] @@ -523,7 +521,7 @@ def test_many_models_core_dict(benchmark): 'fields': {'age': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}}, }, } - v = SchemaValidator(schema=model_schema) + v = SchemaValidator(model_schema) benchmark(v.validate_python, many_models_data) @@ -533,7 +531,7 @@ class MyCoreModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - schema=core_schema.list_schema( + core_schema.list_schema( items_schema=core_schema.model_schema( cls=MyCoreModel, schema=core_schema.model_fields_schema( @@ -551,7 +549,7 @@ class MyCoreModel: @pytest.mark.benchmark(group='list[Nullable[int]]') def test_list_of_nullable_core(benchmark): v = SchemaValidator( - schema=core_schema.list_schema(items_schema=core_schema.nullable_schema(schema=core_schema.int_schema())) + core_schema.list_schema(items_schema=core_schema.nullable_schema(schema=core_schema.int_schema())) ) benchmark(v.validate_python, list_of_nullable_data) @@ -562,7 +560,7 @@ def test_list_of_nullable_core(benchmark): @pytest.mark.benchmark(group='bytes') def test_bytes_core(benchmark): - v = SchemaValidator(schema=core_schema.bytes_schema()) + v = SchemaValidator(core_schema.bytes_schema()) benchmark(v.validate_python, some_bytes) @@ -608,25 +606,25 @@ def test_model_core_json(self, core_validator, benchmark, json_dict_data): @pytest.mark.benchmark(group='datetime datetime') def test_core_raw(self, benchmark, datetime_raw): - v = SchemaValidator(schema=core_schema.datetime_schema()) + v = SchemaValidator(core_schema.datetime_schema()) benchmark(v.validate_python, datetime_raw) @pytest.mark.benchmark(group='datetime str') def test_core_str(self, benchmark, datetime_str): - v = SchemaValidator(schema=core_schema.datetime_schema()) + v = SchemaValidator(core_schema.datetime_schema()) benchmark(v.validate_python, datetime_str) @pytest.mark.benchmark(group='datetime future') def test_core_future(self, benchmark, datetime_raw): - v = SchemaValidator(schema=core_schema.datetime_schema(gt=datetime.now())) + v = SchemaValidator(core_schema.datetime_schema(gt=datetime.now())) benchmark(v.validate_python, datetime_raw) @pytest.mark.benchmark(group='datetime future') def test_core_future_str(self, benchmark, datetime_str): - v = SchemaValidator(schema=core_schema.datetime_schema(gt=datetime.now())) + v = SchemaValidator(core_schema.datetime_schema(gt=datetime.now())) benchmark(v.validate_python, datetime_str) @@ -634,7 +632,7 @@ def test_core_future_str(self, benchmark, datetime_str): class TestBenchmarkDateX: @pytest.fixture(scope='class') def validator(self): - return SchemaValidator(schema=core_schema.date_schema()) + return SchemaValidator(core_schema.date_schema()) @pytest.mark.benchmark(group='date from date') def test_date_from_date(self, benchmark, validator): @@ -654,13 +652,13 @@ def test_date_from_datetime_str(self, benchmark, validator): @pytest.mark.benchmark(group='date future') def test_core_future(self, benchmark): - v = SchemaValidator(schema=core_schema.date_schema(gt=date.today())) + v = SchemaValidator(core_schema.date_schema(gt=date.today())) benchmark(v.validate_python, date(2932, 1, 1)) @pytest.mark.benchmark(group='date future') def test_core_future_str(self, benchmark): - v = SchemaValidator(schema=core_schema.date_schema(gt=date.today())) + v = SchemaValidator(core_schema.date_schema(gt=date.today())) benchmark(v.validate_python, str(date(2932, 1, 1))) @@ -727,7 +725,7 @@ class CoreModel: @pytest.fixture(scope='class') def validator(self): - return SchemaValidator(schema=core_schema.uuid_schema()) + return SchemaValidator(core_schema.uuid_schema()) @pytest.fixture(scope='class') def pydantic_validator(self): @@ -761,7 +759,7 @@ def to_UUID(v: Any) -> UUID: serialization=core_schema.to_string_ser_schema(when_used='json'), ) - return SchemaValidator(schema=schema) + return SchemaValidator(schema) @pytest.mark.benchmark(group='uuid from str') def test_uuid_from_string_core(self, benchmark, validator): @@ -805,13 +803,13 @@ def test_model_core_json(self, core_validator, benchmark, json_dict_data): @pytest.mark.benchmark(group='uuid uuid') def test_core_raw(self, benchmark, uuid_raw): - v = SchemaValidator(schema=core_schema.uuid_schema()) + v = SchemaValidator(core_schema.uuid_schema()) benchmark(v.validate_python, uuid_raw) @pytest.mark.benchmark(group='uuid str') def test_core_str(self, benchmark, uuid_str): - v = SchemaValidator(schema=core_schema.uuid_schema()) + v = SchemaValidator(core_schema.uuid_schema()) benchmark(v.validate_python, uuid_str) @@ -821,7 +819,7 @@ def test_dont_raise_error(benchmark): def f(input_value, info): return input_value - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) @benchmark def t(): @@ -833,7 +831,7 @@ def test_dont_raise_error_no_info(benchmark): def f(input_value): return input_value - v = SchemaValidator(schema=core_schema.no_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.no_info_plain_validator_function(f)) @benchmark def t(): @@ -845,7 +843,7 @@ def test_raise_error_value_error(benchmark): def f(input_value, info): raise ValueError('this is a custom error') - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) @benchmark def t(): @@ -862,7 +860,7 @@ def test_raise_error_custom(benchmark): def f(input_value, info): raise PydanticCustomError('my_error', 'this is a custom error {foo}', {'foo': 'FOOBAR'}) - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) @benchmark def t(): @@ -877,7 +875,7 @@ def t(): @pytest.mark.benchmark(group='tuple') def test_positional_tuple(benchmark): v = SchemaValidator( - schema=core_schema.tuple_schema( + core_schema.tuple_schema( items_schema=[ core_schema.int_schema(), core_schema.int_schema(), @@ -894,7 +892,7 @@ def test_positional_tuple(benchmark): @pytest.mark.benchmark(group='tuple') def test_variable_tuple(benchmark): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) assert v.validate_python((1, 2, 3, '4', 5)) == (1, 2, 3, 4, 5) benchmark(v.validate_python, (1, 2, 3, '4', 5)) @@ -902,7 +900,7 @@ def test_variable_tuple(benchmark): @pytest.mark.benchmark(group='tuple-many') def test_tuple_many_variable(benchmark): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) assert v.validate_python(list(range(10))) == tuple(range(10)) benchmark(v.validate_python, list(range(10))) @@ -910,7 +908,7 @@ def test_tuple_many_variable(benchmark): @pytest.mark.benchmark(group='tuple-many') def test_tuple_many_positional(benchmark): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) assert v.validate_python(list(range(10))) == tuple(range(10)) benchmark(v.validate_python, list(range(10))) @@ -919,7 +917,7 @@ def test_tuple_many_positional(benchmark): @pytest.mark.benchmark(group='arguments') def test_arguments(benchmark): v = SchemaValidator( - schema=core_schema.arguments_schema( + core_schema.arguments_schema( arguments=[ {'name': 'args1', 'mode': 'positional_only', 'schema': core_schema.int_schema()}, {'name': 'args2', 'mode': 'positional_only', 'schema': core_schema.str_schema()}, @@ -937,7 +935,7 @@ def test_arguments(benchmark): @pytest.mark.benchmark(group='defaults') def test_with_default(benchmark): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'name': core_schema.typed_dict_field( schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='John') @@ -957,7 +955,7 @@ def t(): @pytest.mark.benchmark(group='chain') def test_chain_list(benchmark): validator = SchemaValidator( - schema=core_schema.chain_schema( + core_schema.chain_schema( steps=[core_schema.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))] ) ) @@ -969,7 +967,7 @@ def test_chain_list(benchmark): @pytest.mark.benchmark(group='chain') def test_chain_function(benchmark): validator = SchemaValidator( - schema={ + { 'type': 'function-after', 'schema': core_schema.str_schema(), 'function': {'type': 'with-info', 'function': lambda v, info: Decimal(v)}, @@ -983,7 +981,7 @@ def test_chain_function(benchmark): @pytest.mark.benchmark(group='chain-functions') def test_chain_two_functions(benchmark): validator = SchemaValidator( - schema=core_schema.chain_schema( + core_schema.chain_schema( steps=[ core_schema.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v)), @@ -999,7 +997,7 @@ def test_chain_two_functions(benchmark): @pytest.mark.benchmark(group='chain-functions') def test_chain_nested_functions(benchmark): validator = SchemaValidator( - schema={ + { 'type': 'function-after', 'schema': { 'type': 'function-after', @@ -1030,7 +1028,7 @@ def generator_gen_python(v, validator, info): @pytest.mark.benchmark(group='generator') def test_generator_python(benchmark): schema = core_schema.with_info_wrap_validator_function(generator_gen_python, {'type': 'int'}) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) input_value = tuple(range(100)) assert sum(v.validate_python(input_value)) == 4950 @@ -1049,7 +1047,7 @@ def generator_gen_rust(v, *, validator, **_kwargs): @pytest.mark.benchmark(group='generator') def test_generator_rust(benchmark): schema = {'type': 'generator', 'items_schema': {'type': 'int'}} - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) input_value = tuple(range(100)) assert sum(v.validate_python(input_value)) == 4950 @@ -1059,9 +1057,7 @@ def test_generator_rust(benchmark): @pytest.mark.benchmark(group='isinstance-json') def test_isinstance_json(benchmark): - validator = SchemaValidator( - schema=core_schema.json_or_python_schema(core_schema.str_schema(), core_schema.int_schema()) - ) + validator = SchemaValidator(core_schema.json_or_python_schema(core_schema.str_schema(), core_schema.int_schema())) assert validator.validate_json('"foo"') == 'foo' with pytest.raises(ValidationError): validator.validate_json('123') @@ -1073,7 +1069,7 @@ def t(): @pytest.mark.benchmark(group='error') def test_int_error(benchmark): - validator = SchemaValidator(schema=core_schema.int_schema()) + validator = SchemaValidator(core_schema.int_schema()) try: validator.validate_python('bar') except ValidationError as e: @@ -1100,7 +1096,7 @@ def t(): @pytest.mark.benchmark(group='definition') def test_definition_in_tree(benchmark): - validator = SchemaValidator(schema=core_schema.list_schema(core_schema.int_schema())) + validator = SchemaValidator(core_schema.list_schema(core_schema.int_schema())) values = [1, 2, 3.0, '4', '5', '6'] * 1000 benchmark(validator.validate_python, values) @@ -1108,7 +1104,7 @@ def test_definition_in_tree(benchmark): @pytest.mark.benchmark(group='definition') def test_definition_out_of_tree(benchmark): validator = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.list_schema(core_schema.definition_reference_schema('foobar')), [core_schema.int_schema(ref='foobar')], ) @@ -1128,7 +1124,7 @@ def __init__(self, **d): self.__pydantic_fields_set__ = set(d) validator = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1169,7 +1165,7 @@ class MyModel(BaseModel): pass validator = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1228,7 +1224,7 @@ class SomeStrEnum(str, Enum): def test_validate_literal( benchmark: Any, allowed_values: list[Any], input: Any, expected_val_res: Any, py_or_json: str ) -> None: - validator = SchemaValidator(schema=core_schema.literal_schema(expected=allowed_values)) + validator = SchemaValidator(core_schema.literal_schema(expected=allowed_values)) if py_or_json == 'python': res = validator.validate_python(input) @@ -1250,7 +1246,7 @@ class MyModel: root: list[int] v = SchemaValidator( - schema=core_schema.model_schema(MyModel, core_schema.list_schema(core_schema.int_schema()), root_model=True) + core_schema.model_schema(MyModel, core_schema.list_schema(core_schema.int_schema()), root_model=True) ) assert v.validate_python([1, 2, '3']).root == [1, 2, 3] input_data = list(range(100)) @@ -1259,14 +1255,14 @@ class MyModel: @pytest.mark.benchmark(group='strict_int') def test_strict_int(benchmark): - v = SchemaValidator(schema=core_schema.int_schema(strict=True)) + v = SchemaValidator(core_schema.int_schema(strict=True)) benchmark(v.validate_python, 42) @pytest.mark.benchmark(group='strict_int') def test_strict_int_fails(benchmark): - v = SchemaValidator(schema=core_schema.int_schema(strict=True)) + v = SchemaValidator(core_schema.int_schema(strict=True)) @benchmark def t(): @@ -1278,7 +1274,7 @@ def t(): @pytest.mark.benchmark(group='int_range') def test_int_range(benchmark): - v = SchemaValidator(schema=core_schema.int_schema(gt=0, lt=100)) + v = SchemaValidator(core_schema.int_schema(gt=0, lt=100)) assert v.validate_python(42) == 42 with pytest.raises(ValidationError, match='Input should be greater than 0'): @@ -1289,7 +1285,7 @@ def test_int_range(benchmark): @pytest.mark.benchmark(group='int_range') def test_int_range_json(benchmark): - v = SchemaValidator(schema=core_schema.int_schema(gt=0, lt=100)) + v = SchemaValidator(core_schema.int_schema(gt=0, lt=100)) assert v.validate_json('42') == 42 with pytest.raises(ValidationError, match='Input should be greater than 0'): @@ -1306,9 +1302,7 @@ def test_tagged_union_int_keys_python(benchmark): 'y': core_schema.typed_dict_field(core_schema.int_schema()), } ) - v = SchemaValidator( - schema=core_schema.tagged_union_schema({x: inner_schema for x in range(1000)}, discriminator='x') - ) + v = SchemaValidator(core_schema.tagged_union_schema({x: inner_schema for x in range(1000)}, discriminator='x')) payload = {'x': 999, 'y': '1'} assert v.validate_python(payload) == {'x': 999, 'y': 1} @@ -1328,9 +1322,7 @@ def test_tagged_union_int_keys_json(benchmark): 'y': core_schema.typed_dict_field(core_schema.int_schema()), } ) - v = SchemaValidator( - schema=core_schema.tagged_union_schema({x: inner_schema for x in range(1000)}, discriminator='x') - ) + v = SchemaValidator(core_schema.tagged_union_schema({x: inner_schema for x in range(1000)}, discriminator='x')) payload = '{"x": 999, "y": "1"}' assert v.validate_json(payload) == {'x': 999, 'y': 1} @@ -1358,7 +1350,7 @@ def f(v: int, info: core_schema.ValidationInfo) -> int: schema = core_schema.typed_dict_schema({'x': core_schema.typed_dict_field(schema)}) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) payload = {'x': 0} assert v.validate_python(payload) == {'x': limit} @@ -1368,7 +1360,7 @@ def f(v: int, info: core_schema.ValidationInfo) -> int: class TestBenchmarkDecimal: @pytest.fixture(scope='class') def validator(self): - return SchemaValidator(schema=core_schema.decimal_schema()) + return SchemaValidator(core_schema.decimal_schema()) @pytest.fixture(scope='class') def pydantic_validator(self): @@ -1408,7 +1400,7 @@ def check_finite(value: decimal.Decimal) -> decimal.Decimal: schema = core_schema.no_info_after_validator_function(check_finite, schema) - return SchemaValidator(schema=schema) + return SchemaValidator(schema) @pytest.mark.benchmark(group='decimal from str') def test_decimal_from_string_core(self, benchmark, validator): @@ -1437,7 +1429,7 @@ def to_enum(input_value: Any, /) -> Enum: except ValueError: raise PydanticCustomError('enum', 'Input should be {expected}', {'expected': '1, 2 or 3'}) - v = SchemaValidator(schema=core_schema.no_info_after_validator_function(to_enum, core_schema.int_schema())) + v = SchemaValidator(core_schema.no_info_after_validator_function(to_enum, core_schema.int_schema())) assert v.validate_python(1) is FooInt.a @@ -1446,7 +1438,7 @@ def to_enum(input_value: Any, /) -> Enum: @pytest.mark.benchmark(group='enum int') def test_enum_int_core(benchmark): - v = SchemaValidator(schema=core_schema.enum_schema(FooInt, list(FooInt.__members__.values()), sub_type='int')) + v = SchemaValidator(core_schema.enum_schema(FooInt, list(FooInt.__members__.values()), sub_type='int')) assert v.validate_python(1) is FooInt.a @@ -1467,7 +1459,7 @@ def to_enum(input_value: Any, /) -> Enum: except ValueError: raise PydanticCustomError('enum', 'Input should be {expected}', {'expected': 'apple, banana or carrot'}) - v = SchemaValidator(schema=core_schema.no_info_after_validator_function(to_enum, core_schema.str_schema())) + v = SchemaValidator(core_schema.no_info_after_validator_function(to_enum, core_schema.str_schema())) assert v.validate_python('apple') is FooStr.a @@ -1476,7 +1468,7 @@ def to_enum(input_value: Any, /) -> Enum: @pytest.mark.benchmark(group='enum str') def test_enum_str_core(benchmark): - v = SchemaValidator(schema=core_schema.enum_schema(FooStr, list(FooStr.__members__.values()), sub_type='str')) + v = SchemaValidator(core_schema.enum_schema(FooStr, list(FooStr.__members__.values()), sub_type='str')) assert v.validate_python('apple') is FooStr.a diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py index 8db8cda63..c3b3e2f8f 100644 --- a/tests/serializers/test_any.py +++ b/tests/serializers/test_any.py @@ -497,7 +497,7 @@ class Foo: ), ['a'], ) - Foo.__pydantic_validator__ = SchemaValidator(schema=schema) + Foo.__pydantic_validator__ = SchemaValidator(schema) Foo.__pydantic_serializer__ = SchemaSerializer(schema) s = SchemaSerializer(core_schema.any_schema()) diff --git a/tests/serializers/test_dataclasses.py b/tests/serializers/test_dataclasses.py index 5365202cb..d7fbcffaf 100644 --- a/tests/serializers/test_dataclasses.py +++ b/tests/serializers/test_dataclasses.py @@ -187,7 +187,7 @@ class Model: [], ) s = SchemaSerializer(schema) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) m = v.validate_python({'extra': 'extra'}) diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py index 503d9520e..cb0298622 100644 --- a/tests/serializers/test_model.py +++ b/tests/serializers/test_model.py @@ -102,7 +102,7 @@ def test_dataclass(): ), ) # just check validation works as expected - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) dc = v.validate_python({'foo': 1, 'bar': 'bar-str', 'spam': 'bite', 'frog': 123}) assert dc == DataClass(foo=1, bar='bar-str', spam=b'bite', frog=123) dc.class_var = 2 @@ -426,7 +426,7 @@ def test_advanced_exclude_nested_lists(exclude, expected): BasicModel, core_schema.model_fields_schema(dict(subs=core_schema.model_field(core_schema.list_schema(sub_model_schema)))), ) - v = SchemaValidator(schema=model_schema) + v = SchemaValidator(model_schema) data = v.validate_python( dict(subs=[dict(k=1, subsubs=[dict(i=1, j=1), dict(i=2, j=2)]), dict(k=2, subsubs=[dict(i=3, j=3)])]) @@ -974,7 +974,7 @@ class MyModel: ), extra_behavior='allow', ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) m = v.validate_python({'field_a': b'test', 'field_b': 12, 'field_c': 'extra'}) assert isinstance(m, MyModel) assert m.__dict__ == {'field_a': b'test', 'field_b': 12} diff --git a/tests/serializers/test_other.py b/tests/serializers/test_other.py index fe9d558bf..13877d096 100644 --- a/tests/serializers/test_other.py +++ b/tests/serializers/test_other.py @@ -80,7 +80,7 @@ class Other(Parent): ), config=core_schema.CoreConfig(extra_fields_behavior='allow'), ) - Parent.__pydantic_validator__ = SchemaValidator(schema=Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__) Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__) Other.__pydantic_core_schema__ = core_schema.model_schema( @@ -93,7 +93,7 @@ class Other(Parent): ), config=core_schema.CoreConfig(extra_fields_behavior='forbid'), ) - Other.__pydantic_validator__ = SchemaValidator(schema=Other.__pydantic_core_schema__) + Other.__pydantic_validator__ = SchemaValidator(Other.__pydantic_core_schema__) Other.__pydantic_serializer__ = SchemaSerializer(Other.__pydantic_core_schema__) other = Other.__pydantic_validator__.validate_python({'x': 1, 'y': 'some string'}) diff --git a/tests/serializers/test_serialize_as_any.py b/tests/serializers/test_serialize_as_any.py index 6fdc7eb31..1d1be238b 100644 --- a/tests/serializers/test_serialize_as_any.py +++ b/tests/serializers/test_serialize_as_any.py @@ -20,7 +20,7 @@ class Child(Parent): } ), ) - Parent.__pydantic_validator__ = SchemaValidator(schema=Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__) Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__) Child.__pydantic_core_schema__ = core_schema.model_schema( @@ -32,7 +32,7 @@ class Child(Parent): } ), ) - Child.__pydantic_validator__ = SchemaValidator(schema=Child.__pydantic_core_schema__) + Child.__pydantic_validator__ = SchemaValidator(Child.__pydantic_core_schema__) Child.__pydantic_serializer__ = SchemaSerializer(Child.__pydantic_core_schema__) child = Child.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'}) @@ -61,7 +61,7 @@ class Child(Parent): ), ['x'], ) - Parent.__pydantic_validator__ = SchemaValidator(schema=Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__) Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__) Child.__pydantic_core_schema__ = core_schema.dataclass_schema( @@ -75,7 +75,7 @@ class Child(Parent): ), ['x', 'y'], ) - Child.__pydantic_validator__ = SchemaValidator(schema=Child.__pydantic_core_schema__) + Child.__pydantic_validator__ = SchemaValidator(Child.__pydantic_core_schema__) Child.__pydantic_serializer__ = SchemaSerializer(Child.__pydantic_core_schema__) child = Child.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'}) @@ -98,7 +98,7 @@ class Child(Parent): 'x': core_schema.typed_dict_field(core_schema.int_schema()), } ) - Parent.__pydantic_validator__ = SchemaValidator(schema=Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__) Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__) Child.__pydantic_core_schema__ = core_schema.typed_dict_schema( @@ -107,7 +107,7 @@ class Child(Parent): 'y': core_schema.typed_dict_field(core_schema.str_schema()), } ) - Child.__pydantic_validator__ = SchemaValidator(schema=Child.__pydantic_core_schema__) + Child.__pydantic_validator__ = SchemaValidator(Child.__pydantic_core_schema__) Child.__pydantic_serializer__ = SchemaSerializer(Child.__pydantic_core_schema__) child = Child.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'}) @@ -133,7 +133,7 @@ class Other: } ), ) - Parent.__pydantic_validator__ = SchemaValidator(schema=Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__) Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__) Other.__pydantic_core_schema__ = core_schema.model_schema( @@ -145,7 +145,7 @@ class Other: ), config=core_schema.CoreConfig(extra_fields_behavior='allow'), ) - Other.__pydantic_validator__ = SchemaValidator(schema=Other.__pydantic_core_schema__) + Other.__pydantic_validator__ = SchemaValidator(Other.__pydantic_core_schema__) Other.__pydantic_serializer__ = SchemaSerializer(Other.__pydantic_core_schema__) other = Other.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'}) diff --git a/tests/serializers/test_url.py b/tests/serializers/test_url.py index 385fa9a8e..be906c75b 100644 --- a/tests/serializers/test_url.py +++ b/tests/serializers/test_url.py @@ -6,7 +6,7 @@ def test_url(): - v = SchemaValidator(schema=core_schema.url_schema()) + v = SchemaValidator(core_schema.url_schema()) s = SchemaSerializer(core_schema.url_schema()) url = v.validate_python('https://example.com') @@ -26,7 +26,7 @@ def test_url(): def test_multi_host_url(): - v = SchemaValidator(schema=core_schema.multi_host_url_schema()) + v = SchemaValidator(core_schema.multi_host_url_schema()) s = SchemaSerializer(core_schema.multi_host_url_schema()) url = v.validate_python('https://example.com,example.org/path') @@ -46,7 +46,7 @@ def test_multi_host_url(): def test_url_dict_keys(): - v = SchemaValidator(schema=core_schema.url_schema()) + v = SchemaValidator(core_schema.url_schema()) s = SchemaSerializer(core_schema.dict_schema(core_schema.url_schema())) url = v.validate_python('https://example.com') @@ -56,7 +56,7 @@ def test_url_dict_keys(): def test_multi_host_url_dict_keys(): - v = SchemaValidator(schema=core_schema.multi_host_url_schema()) + v = SchemaValidator(core_schema.multi_host_url_schema()) s = SchemaSerializer(core_schema.dict_schema(core_schema.multi_host_url_schema())) url = v.validate_python('https://example.com,example.org/path') diff --git a/tests/test_build.py b/tests/test_build.py index f177cd0ea..b20a58530 100644 --- a/tests/test_build.py +++ b/tests/test_build.py @@ -28,7 +28,7 @@ def test_build_error_deep(): def test_schema_as_string(): - v = SchemaValidator(schema=cs.bool_schema()) + v = SchemaValidator(cs.bool_schema()) assert v.validate_python('tRuE') is True @@ -53,7 +53,7 @@ def test_schema_wrong_type(pydantic_version): @pytest.mark.parametrize('pickle_protocol', range(1, pickle.HIGHEST_PROTOCOL + 1)) def test_pickle(pickle_protocol: int) -> None: - v1 = SchemaValidator(schema=cs.bool_schema()) + v1 = SchemaValidator(cs.bool_schema()) assert v1.validate_python('tRuE') is True p = pickle.dumps(v1, protocol=pickle_protocol) v2 = pickle.loads(p) @@ -77,7 +77,7 @@ def test_not_schema_definition_error(): for i in range(101) }, } - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) assert repr(v).count('TypedDictField') == 101 @@ -98,7 +98,7 @@ def test_function_no_mode(): def test_try_self_schema_discriminator(): """Trying to use self-schema when it shouldn't be used""" - v = SchemaValidator(schema=cs.tagged_union_schema(choices={'int': cs.int_schema()}, discriminator='self-schema')) + v = SchemaValidator(cs.tagged_union_schema(choices={'int': cs.int_schema()}, discriminator='self-schema')) assert 'discriminator: LookupKey' in repr(v) @@ -138,4 +138,4 @@ def test_build_recursive_schema_from_defs() -> None: ], ) - SchemaValidator(schema=s) + SchemaValidator(s) diff --git a/tests/test_config.py b/tests/test_config.py index 47027ad35..6fff90878 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -11,7 +11,7 @@ def test_on_field(): - v = SchemaValidator(schema=cs.str_schema(min_length=2, max_length=5)) + v = SchemaValidator(cs.str_schema(min_length=2, max_length=5)) r = plain_repr(v) assert 'min_length:Some(2)' in r assert 'max_length:Some(5)' in r @@ -20,14 +20,14 @@ def test_on_field(): def test_on_config(): - v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(str_max_length=5)) + v = SchemaValidator(cs.str_schema(), config=CoreConfig(str_max_length=5)) assert 'max_length:Some(5)' in plain_repr(v) assert v.isinstance_python('test') is True assert v.isinstance_python('test long') is False def test_field_priority_arg(): - v = SchemaValidator(schema=cs.str_schema(max_length=5), config=CoreConfig(str_max_length=10)) + v = SchemaValidator(cs.str_schema(max_length=5), config=CoreConfig(str_max_length=10)) assert 'max_length:Some(5)' in plain_repr(v) assert v.isinstance_python('test') is True assert v.isinstance_python('test long') is False @@ -40,7 +40,7 @@ class MyModel: def test_on_model_class(): v = SchemaValidator( - schema=cs.model_schema( + cs.model_schema( cls=MyModel, config=CoreConfig(str_max_length=5), schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())}), @@ -53,7 +53,7 @@ def test_on_model_class(): def test_field_priority_model(): v = SchemaValidator( - schema=cs.model_schema( + cs.model_schema( cls=MyModel, config=CoreConfig(str_max_length=10), schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema(max_length=5))}), @@ -103,7 +103,7 @@ def test_field_priority_model(): ) def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expected): v = SchemaValidator( - schema=cs.model_schema( + cs.model_schema( cls=MyModel, schema=cs.model_fields_schema(fields={'x': cs.model_field(schema=float_field_schema)}), config=config, @@ -127,7 +127,7 @@ def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expe ) def test_hide_input_in_errors(config, input_str): v = SchemaValidator( - schema=cs.model_schema( + cs.model_schema( cls=MyModel, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())}) ), config=config, @@ -138,14 +138,14 @@ def test_hide_input_in_errors(config, input_str): def test_cache_strings(): - v = SchemaValidator(schema=cs.str_schema()) + v = SchemaValidator(cs.str_schema()) assert 'cache_strings=True' in plain_repr(v) - v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=True)) + v = SchemaValidator(cs.str_schema(), config=CoreConfig(cache_strings=True)) assert 'cache_strings=True' in plain_repr(v) - v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=False)) + v = SchemaValidator(cs.str_schema(), config=CoreConfig(cache_strings=False)) assert 'cache_strings=False' in plain_repr(v) - v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings='keys')) + v = SchemaValidator(cs.str_schema(), config=CoreConfig(cache_strings='keys')) assert "cache_strings='keys'" in plain_repr(v) diff --git a/tests/test_errors.py b/tests/test_errors.py index a16af954d..ad18a41c8 100644 --- a/tests/test_errors.py +++ b/tests/test_errors.py @@ -67,7 +67,7 @@ def test_pydantic_value_error_usage(): def f(input_value, info): raise PydanticCustomError('my_error', 'this is a custom error {foo} {bar}', {'foo': 'FOOBAR', 'bar': 42}) - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) with pytest.raises(ValidationError) as exc_info: v.validate_python(42) @@ -87,7 +87,7 @@ def test_pydantic_value_error_invalid_dict(): def my_function(input_value, info): raise PydanticCustomError('my_error', 'this is a custom error {foo}', {(): 'foobar'}) - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(my_function)) + v = SchemaValidator(core_schema.with_info_plain_validator_function(my_function)) with pytest.raises(ValidationError) as exc_info: v.validate_python(42) @@ -105,7 +105,7 @@ def test_pydantic_value_error_invalid_type(): def f(input_value, info): raise PydanticCustomError('my_error', 'this is a custom error {foo}', [('foo', 123)]) - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) with pytest.raises(TypeError, match="argument 'context': 'list' object cannot be converted to 'PyDict'"): v.validate_python(42) @@ -121,7 +121,7 @@ def validate(self, input_value, info): return f'{input_value} {self.foo} {self.bar}' c = CustomValidator() - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(c.validate, metadata={'instance': c})) + v = SchemaValidator(core_schema.with_info_plain_validator_function(c.validate, metadata={'instance': c})) c.foo += 1 assert v.validate_python('input value') == 'input value 43 before' @@ -140,9 +140,7 @@ def validate(self, input_value, info): c = CustomValidator() v = SchemaValidator( - schema=core_schema.with_info_after_validator_function( - c.validate, core_schema.str_schema(), metadata={'instance': c} - ) + core_schema.with_info_after_validator_function(c.validate, core_schema.str_schema(), metadata={'instance': c}) ) c.foo += 1 @@ -173,7 +171,7 @@ def test_pydantic_error_type_raise_no_ctx(): def f(input_value, info): raise PydanticKnownError('finite_number') - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(4) @@ -192,7 +190,7 @@ def test_pydantic_error_type_raise_ctx(extra: dict): def f(input_value, info): raise PydanticKnownError('greater_than', ctx) - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(4) @@ -207,7 +205,7 @@ def test_pydantic_error_type_raise_custom_no_ctx(ctx: Optional[dict]): def f(input_value, info): raise PydanticKnownError('int_type', ctx) - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) expect_ctx = {'ctx': {}} if ctx is not None else {} @@ -228,7 +226,7 @@ def test_pydantic_custom_error_type_raise_custom_ctx(extra: dict): def f(input_value, info): raise PydanticCustomError('my_error', 'my message with {val}', ctx) - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(4) @@ -243,7 +241,7 @@ def test_pydantic_custom_error_type_raise_custom_no_ctx(ctx: Optional[dict]): def f(input_value, info): raise PydanticCustomError('my_error', 'my message', ctx) - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) expect_ctx = {'ctx': {}} if ctx is not None else {} @@ -549,9 +547,7 @@ def multi_raise_py_error(v: Any) -> Any: except AssertionError as e: raise ValueError('Oh no!') from e - s2 = SchemaValidator( - schema=core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config - ) + s2 = SchemaValidator(core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config) with pytest.raises(ValidationError) as exc_info: s2.validate_python('anything') @@ -577,9 +573,7 @@ def outer_raise_py_error(v: Any) -> Any: except ValidationError as e: raise ValueError('Sub val failure') from e - s3 = SchemaValidator( - schema=core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config - ) + s3 = SchemaValidator(core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config) with pytest.raises(ValidationError) as exc_info: s3.validate_python('anything') @@ -619,9 +613,7 @@ def multi_raise_py_error(v: Any) -> Any: except AssertionError as e: raise ValueError('Oh no!') from e - s2 = SchemaValidator( - schema=core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config - ) + s2 = SchemaValidator(core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config) with pytest.raises(ValidationError) as exc_info: s2.validate_python('anything') @@ -649,9 +641,7 @@ def outer_raise_py_error(v: Any) -> Any: except ValidationError as e: raise ValueError('Sub val failure') from e - s3 = SchemaValidator( - schema=core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config - ) + s3 = SchemaValidator(core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config) with pytest.raises(ValidationError) as exc_info: s3.validate_python('anything') @@ -707,7 +697,7 @@ def test_validation_error_cause_config_variants(desc: str, config: CoreConfig, e def singular_raise_py_error(v: Any) -> Any: raise ValueError('Oh no!') - s = SchemaValidator(schema=core_schema.no_info_plain_validator_function(singular_raise_py_error), config=config) + s = SchemaValidator(core_schema.no_info_plain_validator_function(singular_raise_py_error), config=config) if expected_result is CauseResult.IMPORT_ERROR: # Confirm error message contains "requires the exceptiongroup module" in the middle of the string: @@ -736,9 +726,7 @@ def test_validation_error_cause_traceback_preserved(): def singular_raise_py_error(v: Any) -> Any: raise ValueError('Oh no!') - s1 = SchemaValidator( - schema=core_schema.no_info_plain_validator_function(singular_raise_py_error), config=enabled_config - ) + s1 = SchemaValidator(core_schema.no_info_plain_validator_function(singular_raise_py_error), config=enabled_config) with pytest.raises(ValidationError) as exc_info: s1.validate_python('anything') @@ -761,7 +749,7 @@ def __repr__(self): def test_error_on_repr(pydantic_version): - s = SchemaValidator(schema=core_schema.int_schema()) + s = SchemaValidator(core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python(BadRepr()) @@ -787,7 +775,7 @@ def test_error_on_repr(pydantic_version): def test_error_json(pydantic_version): - s = SchemaValidator(schema=core_schema.str_schema(min_length=3)) + s = SchemaValidator(core_schema.str_schema(min_length=3)) with pytest.raises(ValidationError) as exc_info: s.validate_python('12') @@ -827,7 +815,7 @@ def raise_py_error(v: Any) -> Any: except AssertionError as e: raise ValueError('Oh no!') from e - s = SchemaValidator(schema=core_schema.no_info_plain_validator_function(raise_py_error)) + s = SchemaValidator(core_schema.no_info_plain_validator_function(raise_py_error)) with pytest.raises(ValidationError) as exc_info: s.validate_python('anything') @@ -865,7 +853,7 @@ def raise_py_error(v: Any) -> Any: def test_error_json_cycle(): - s = SchemaValidator(schema=core_schema.str_schema(min_length=3)) + s = SchemaValidator(core_schema.str_schema(min_length=3)) cycle = [] cycle.append(cycle) msg = '[type=string_type, input_value=[[...]], input_type=list]' @@ -887,7 +875,7 @@ def __str__(self): def test_error_json_unknown(): - s = SchemaValidator(schema=core_schema.str_schema()) + s = SchemaValidator(core_schema.str_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python(Foobar()) @@ -921,7 +909,7 @@ def test_error_json_unknown(): def test_error_json_loc(): s = SchemaValidator( - schema=core_schema.dict_schema(core_schema.str_schema(), core_schema.list_schema(core_schema.int_schema())) + core_schema.dict_schema(core_schema.str_schema(), core_schema.list_schema(core_schema.int_schema())) ) with pytest.raises(ValidationError) as exc_info: s.validate_python({'a': [0, 1, 'x'], 'b': [0, 'y']}) @@ -1069,7 +1057,7 @@ def test_raise_validation_error_custom_class_ctx(): def test_loc_with_dots(pydantic_version): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field( core_schema.tuple_positional_schema([core_schema.int_schema(), core_schema.int_schema()]), @@ -1101,7 +1089,7 @@ def test_loc_with_dots(pydantic_version): def test_hide_input_in_error() -> None: - s = SchemaValidator(schema=core_schema.int_schema()) + s = SchemaValidator(core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python('definitely not an int') @@ -1110,7 +1098,7 @@ def test_hide_input_in_error() -> None: def test_hide_input_in_json() -> None: - s = SchemaValidator(schema=core_schema.int_schema()) + s = SchemaValidator(core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python('definitely not an int') @@ -1123,7 +1111,7 @@ def test_hide_input_in_json() -> None: reason='PyPy before 3.9 cannot pickle this correctly', ) def test_validation_error_pickle() -> None: - s = SchemaValidator(schema=core_schema.int_schema()) + s = SchemaValidator(core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python('definitely not an int') @@ -1134,7 +1122,7 @@ def test_validation_error_pickle() -> None: @pytest.mark.skipif('PYDANTIC_ERRORS_INCLUDE_URL' in os.environ, reason="can't test when envvar is set") def test_errors_include_url() -> None: - s = SchemaValidator(schema=core_schema.int_schema()) + s = SchemaValidator(core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python('definitely not an int') assert 'https://errors.pydantic.dev' in repr(exc_info.value) @@ -1161,7 +1149,7 @@ def test_errors_include_url_envvar(env_var, env_var_value, expected_to_have_url) Since it can only be set before `ValidationError.__repr__()` is first called, we need to spawn a subprocess to test it. """ - code = "import pydantic_core; from pydantic_core import core_schema; pydantic_core.SchemaValidator(schema=core_schema.int_schema()).validate_python('ooo')" + code = "import pydantic_core; from pydantic_core import core_schema; pydantic_core.SchemaValidator(core_schema.int_schema()).validate_python('ooo')" env = os.environ.copy() env.pop('PYDANTIC_ERRORS_OMIT_URL', None) # in case the ambient environment has it set if env_var_value is not None: diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py index f89ab8e30..2213f7cfb 100644 --- a/tests/test_garbage_collection.py +++ b/tests/test_garbage_collection.py @@ -84,7 +84,7 @@ class MyModel: iter: Iterable[int] v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( {'iter': core_schema.model_field(core_schema.generator_schema(core_schema.int_schema()))} diff --git a/tests/test_hypothesis.py b/tests/test_hypothesis.py index 75b275c35..5a24d6808 100644 --- a/tests/test_hypothesis.py +++ b/tests/test_hypothesis.py @@ -15,7 +15,7 @@ @pytest.fixture(scope='module') def datetime_schema(): - return SchemaValidator(schema=cs.datetime_schema()) + return SchemaValidator(cs.datetime_schema()) @given(strategies.datetimes()) @@ -62,7 +62,7 @@ def test_datetime_binary(datetime_schema, data): @pytest.fixture(scope='module') def definition_schema(): return SchemaValidator( - schema=cs.definitions_schema( + cs.definitions_schema( cs.definition_reference_schema('Branch'), [ cs.typed_dict_schema( @@ -137,7 +137,7 @@ def test_definition_broken(definition_schema): @given(strategies.timedeltas()) @pytest.mark.thread_unsafe # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20 def test_pytimedelta_as_timedelta(dt): - v = SchemaValidator(schema=cs.timedelta_schema(gt=dt)) + v = SchemaValidator(cs.timedelta_schema(gt=dt)) # simplest way to check `pytimedelta_as_timedelta` is correct is to extract duration from repr of the validator m = re.search(r'Duration ?\{\s+positive: ?(\w+),\s+day: ?(\d+),\s+second: ?(\d+),\s+microsecond: ?(\d+)', repr(v)) pos, day, sec, micro = m.groups() @@ -148,7 +148,7 @@ def test_pytimedelta_as_timedelta(dt): @pytest.fixture(scope='module') def url_validator(): - return SchemaValidator(schema=cs.url_schema()) + return SchemaValidator(cs.url_schema()) # Parsing errors which hypothesis is likely to hit @@ -169,7 +169,7 @@ def test_urls_text(url_validator, text): @pytest.fixture(scope='module') def multi_host_url_validator(): - return SchemaValidator(schema=cs.multi_host_url_schema()) + return SchemaValidator(cs.multi_host_url_schema()) @given(strategies.text()) diff --git a/tests/test_isinstance.py b/tests/test_isinstance.py index d4f4320a6..8368e36e8 100644 --- a/tests/test_isinstance.py +++ b/tests/test_isinstance.py @@ -7,7 +7,7 @@ def test_isinstance(): - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) assert v.validate_python(123) == 123 assert v.isinstance_python(123) is True assert v.validate_python('123') == 123 @@ -20,7 +20,7 @@ def test_isinstance(): def test_isinstance_strict(): - v = SchemaValidator(schema=cs.int_schema(strict=True)) + v = SchemaValidator(cs.int_schema(strict=True)) assert v.validate_python(123) == 123 assert v.isinstance_python(123) is True @@ -32,9 +32,7 @@ def test_isinstance_strict(): def test_internal_error(): v = SchemaValidator( - schema=cs.model_schema( - cls=int, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.int_schema())}) - ) + cs.model_schema(cls=int, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.int_schema())})) ) with pytest.raises(AttributeError, match="'int' object has no attribute '__dict__'"): v.validate_python({'f': 123}) diff --git a/tests/test_json.py b/tests/test_json.py index aa0c18acc..6b365a4cb 100644 --- a/tests/test_json.py +++ b/tests/test_json.py @@ -26,28 +26,28 @@ [('false', False), ('true', True), ('0', False), ('1', True), ('"yes"', True), ('"no"', False)], ) def test_bool(input_value, output_value): - v = SchemaValidator(schema=core_schema.bool_schema()) + v = SchemaValidator(core_schema.bool_schema()) assert v.validate_json(input_value) == output_value @pytest.mark.parametrize('input_value', ['[1, 2, 3]', b'[1, 2, 3]', bytearray(b'[1, 2, 3]')]) def test_input_types(input_value): - v = SchemaValidator(schema=core_schema.list_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema())) assert v.validate_json(input_value) == [1, 2, 3] def test_input_type_invalid(): - v = SchemaValidator(schema=core_schema.list_schema(items_schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema())) with pytest.raises(ValidationError, match=r'JSON input should be string, bytes or bytearray \[type=json_type,'): v.validate_json([]) def test_null(): - assert SchemaValidator(schema=core_schema.none_schema()).validate_json('null') is None + assert SchemaValidator(core_schema.none_schema()).validate_json('null') is None def test_str(): - s = SchemaValidator(schema=core_schema.str_schema()) + s = SchemaValidator(core_schema.str_schema()) assert s.validate_json('"foobar"') == 'foobar' with pytest.raises(ValidationError, match=r'Input should be a valid string \[type=string_type,'): s.validate_json('false') @@ -56,7 +56,7 @@ def test_str(): def test_bytes(): - s = SchemaValidator(schema=core_schema.bytes_schema()) + s = SchemaValidator(core_schema.bytes_schema()) assert s.validate_json('"foobar"') == b'foobar' with pytest.raises(ValidationError, match=r'Input should be a valid bytes \[type=bytes_type,'): s.validate_json('false') @@ -82,7 +82,7 @@ def test_bytes(): ], ) def test_int(input_value, expected): - v = SchemaValidator(schema=core_schema.int_schema()) + v = SchemaValidator(core_schema.int_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value) @@ -103,7 +103,7 @@ def test_int(input_value, expected): ], ) def test_float(input_value, expected): - v = SchemaValidator(schema=core_schema.float_schema()) + v = SchemaValidator(core_schema.float_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value) @@ -113,7 +113,7 @@ def test_float(input_value, expected): def test_typed_dict(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()), @@ -131,13 +131,13 @@ def test_typed_dict(): def test_float_no_remainder(): - v = SchemaValidator(schema=core_schema.int_schema()) + v = SchemaValidator(core_schema.int_schema()) assert v.validate_json('123.0') == 123 def test_error_loc(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field( schema=core_schema.list_schema(items_schema=core_schema.int_schema()) @@ -164,7 +164,7 @@ def test_error_loc(): def test_dict(): v = SchemaValidator( - schema=core_schema.dict_schema(keys_schema=core_schema.int_schema(), values_schema=core_schema.int_schema()) + core_schema.dict_schema(keys_schema=core_schema.int_schema(), values_schema=core_schema.int_schema()) ) assert v.validate_json('{"1": 2, "3": 4}') == {1: 2, 3: 4} @@ -174,12 +174,12 @@ def test_dict(): def test_dict_any_value(): - v = SchemaValidator(schema=core_schema.dict_schema(keys_schema=core_schema.str_schema())) + v = SchemaValidator(core_schema.dict_schema(keys_schema=core_schema.str_schema())) assert v.validate_json('{"1": 1, "2": "a", "3": null}') == {'1': 1, '2': 'a', '3': None} def test_json_invalid(): - v = SchemaValidator(schema=core_schema.bool_schema()) + v = SchemaValidator(core_schema.bool_schema()) with pytest.raises(ValidationError) as exc_info: v.validate_json('"foobar') @@ -275,7 +275,7 @@ def __init__(self, my_foo: int, my_inners: list['Foobar']): ) ], ) - v = SchemaValidator(schema=c) + v = SchemaValidator(c) s = SchemaSerializer(c) Foobar.__pydantic_validator__ = v @@ -364,7 +364,7 @@ def test_bad_repr(): def test_inf_nan_allow(): - v = SchemaValidator(schema=core_schema.float_schema(allow_inf_nan=True)) + v = SchemaValidator(core_schema.float_schema(allow_inf_nan=True)) assert v.validate_json('Infinity') == float('inf') assert v.validate_json('-Infinity') == float('-inf') assert v.validate_json('NaN') == IsFloatNan() @@ -386,7 +386,7 @@ def test_json_bytes_base64_round_trip(): encoded_url = b'"2AfBVHgkkUYl8_NJythADO7Dq_9_083N-cIQ5KGwMWU="' assert to_json(data, bytes_mode='base64') == encoded_url - v = SchemaValidator(schema=core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64')) + v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64')) assert v.validate_json(encoded_url) == data assert v.validate_json(encoded_std) == data @@ -397,20 +397,20 @@ def test_json_bytes_base64_round_trip(): assert to_json({'key': data}, bytes_mode='base64') == b'{"key":' + encoded_url + b'}' v = SchemaValidator( - schema=core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.bytes_schema()), + core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.bytes_schema()), config=CoreConfig(val_json_bytes='base64'), ) assert v.validate_json(b'{"key":' + encoded_url + b'}') == {'key': data} def test_json_bytes_base64_no_padding(): - v = SchemaValidator(schema=core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64')) + v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64')) base_64_without_padding = 'bm8tcGFkZGluZw' assert v.validate_json(json.dumps(base_64_without_padding)) == b'no-padding' def test_json_bytes_base64_invalid(): - v = SchemaValidator(schema=core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64')) + v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64')) wrong_input = 'wrong!' with pytest.raises(ValidationError) as exc_info: v.validate_json(json.dumps(wrong_input)) @@ -429,19 +429,19 @@ def test_json_bytes_hex_round_trip(): encoded = b'"68656c6c6f"' assert to_json(data, bytes_mode='hex') == encoded - v = SchemaValidator(schema=core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='hex')) + v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='hex')) assert v.validate_json(encoded) == data assert to_json({'key': data}, bytes_mode='hex') == b'{"key":"68656c6c6f"}' v = SchemaValidator( - schema=core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.bytes_schema()), + core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.bytes_schema()), config=CoreConfig(val_json_bytes='hex'), ) assert v.validate_json('{"key":"68656c6c6f"}') == {'key': data} def test_json_bytes_hex_invalid(): - v = SchemaValidator(schema=core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='hex')) + v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='hex')) wrong_input = 'a' with pytest.raises(ValidationError) as exc_info: diff --git a/tests/test_misc.py b/tests/test_misc.py index 30b183e00..6dbdda829 100644 --- a/tests/test_misc.py +++ b/tests/test_misc.py @@ -42,7 +42,7 @@ def test_schema_error(): def test_validation_error(pydantic_version): - v = SchemaValidator(schema=core_schema.int_schema()) + v = SchemaValidator(core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: v.validate_python(1.5) @@ -73,7 +73,7 @@ def test_validation_error(pydantic_version): def test_validation_error_include_context(): - v = SchemaValidator(schema=core_schema.list_schema(max_length=2)) + v = SchemaValidator(core_schema.list_schema(max_length=2)) with pytest.raises(ValidationError) as exc_info: v.validate_python([1, 2, 3]) @@ -101,7 +101,7 @@ def test_validation_error_include_context(): def test_custom_title(): - v = SchemaValidator(schema=core_schema.int_schema(), config=CoreConfig(title='MyInt')) + v = SchemaValidator(core_schema.int_schema(), config=CoreConfig(title='MyInt')) with pytest.raises(ValidationError) as exc_info: v.validate_python(1.5) @@ -116,7 +116,7 @@ class MyModel: field_b: int v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={ @@ -193,7 +193,7 @@ def test_unicode_error_input_repr() -> None: schema = core_schema.int_schema() - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) danger_str = 'ÿ' * 1000 expected = "1 validation error for int\n Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='ÿÿÿÿÿÿÿÿÿÿÿÿ...ÿÿÿÿÿÿÿÿÿÿÿ', input_type=str]" diff --git a/tests/test_prebuilt.py b/tests/test_prebuilt.py index 4cf1e8eca..9cd5aa325 100644 --- a/tests/test_prebuilt.py +++ b/tests/test_prebuilt.py @@ -12,7 +12,7 @@ class InnerModel: ), ) - inner_schema_validator = SchemaValidator(schema=inner_schema) + inner_schema_validator = SchemaValidator(inner_schema) inner_schema_serializer = SchemaSerializer(inner_schema) InnerModel.__pydantic_complete__ = True # pyright: ignore[reportAttributeAccessIssue] InnerModel.__pydantic_validator__ = inner_schema_validator # pyright: ignore[reportAttributeAccessIssue] @@ -40,7 +40,7 @@ class OuterModel: ), ) - outer_validator = SchemaValidator(schema=outer_schema) + outer_validator = SchemaValidator(outer_schema) outer_serializer = SchemaSerializer(outer_schema) result = outer_validator.validate_python({'inner': {'x': 1}}) diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py index cb74775d9..a15adfca5 100644 --- a/tests/test_schema_functions.py +++ b/tests/test_schema_functions.py @@ -303,7 +303,7 @@ def test_schema_functions(function, args_kwargs, expected_schema): if schema.get('type') in {None, 'definition-ref', 'typed-dict-field', 'model-field', 'invalid'}: return - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) try: v.validate_python('foobar') except ValidationError: @@ -330,7 +330,7 @@ def test_all_schema_functions_used(): def test_invalid_custom_error(): s = core_schema.union_schema([{'type': 'int'}, {'type': 'str'}], custom_error_type='foobar') with pytest.raises(SchemaError, match=r"KeyError: 'custom_error_message'"): - SchemaValidator(schema=s) + SchemaValidator(s) def test_invalid_custom_error_type(): @@ -339,7 +339,7 @@ def test_invalid_custom_error_type(): ) msg = "custom_error.message should not be provided if 'custom_error_type' matches a known error" with pytest.raises(SchemaError, match=msg): - SchemaValidator(schema=s) + SchemaValidator(s) def repr_function(value, _info): @@ -359,4 +359,4 @@ def test_expected_serialization_types(return_schema): def test_err_on_invalid() -> None: with pytest.raises(SchemaError, match='Cannot construct schema with `InvalidSchema` member.'): - SchemaValidator(schema=core_schema.invalid_schema()) + SchemaValidator(core_schema.invalid_schema()) diff --git a/tests/test_tzinfo.py b/tests/test_tzinfo.py index 7085d08e4..4d4279d22 100644 --- a/tests/test_tzinfo.py +++ b/tests/test_tzinfo.py @@ -219,7 +219,7 @@ class Model: value: datetime v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema({'value': core_schema.model_field(core_schema.datetime_schema())}) ) ) diff --git a/tests/test_validate_strings.py b/tests/test_validate_strings.py index d140ddd67..0e0350d0b 100644 --- a/tests/test_validate_strings.py +++ b/tests/test_validate_strings.py @@ -10,7 +10,7 @@ def test_bool(): - v = SchemaValidator(schema=core_schema.bool_schema()) + v = SchemaValidator(core_schema.bool_schema()) assert v.validate_strings('true') is True assert v.validate_strings('true', strict=True) is True @@ -39,7 +39,7 @@ def test_bool(): ids=repr, ) def test_validate_strings(schema, input_value, expected, strict): - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_strings(input_value, strict=strict) @@ -48,7 +48,7 @@ def test_validate_strings(schema, input_value, expected, strict): def test_dict(): - v = SchemaValidator(schema=core_schema.dict_schema(core_schema.int_schema(), core_schema.date_schema())) + v = SchemaValidator(core_schema.dict_schema(core_schema.int_schema(), core_schema.date_schema())) assert v.validate_strings({'1': '2017-01-01', '2': '2017-01-02'}) == {1: date(2017, 1, 1), 2: date(2017, 1, 2)} assert v.validate_strings({'1': '2017-01-01', '2': '2017-01-02'}, strict=True) == { @@ -65,7 +65,7 @@ class MyModel: field_b: date v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -88,7 +88,7 @@ class MyDataClass: field_b: date v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( MyDataClass, core_schema.dataclass_args_schema( 'MyDataClass', @@ -108,7 +108,7 @@ class MyDataClass: def test_typed_dict(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'field_a': core_schema.typed_dict_field(core_schema.int_schema()), 'field_b': core_schema.typed_dict_field(core_schema.date_schema()), diff --git a/tests/test_validation_context.py b/tests/test_validation_context.py index f1ca1924d..5d71f5b55 100644 --- a/tests/test_validation_context.py +++ b/tests/test_validation_context.py @@ -100,7 +100,7 @@ def f2(input_value, info): return input_value + f'| context: {info.context}' v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( { 'f1': core_schema.model_field(core_schema.with_info_plain_validator_function(f1)), 'f2': core_schema.model_field(core_schema.with_info_plain_validator_function(f2)), diff --git a/tests/validators/test_allow_partial.py b/tests/validators/test_allow_partial.py index c2bc99795..297727572 100644 --- a/tests/validators/test_allow_partial.py +++ b/tests/validators/test_allow_partial.py @@ -9,7 +9,7 @@ def test_list(): v = SchemaValidator( - schema=core_schema.list_schema( + core_schema.list_schema( core_schema.tuple_positional_schema([core_schema.int_schema(), core_schema.int_schema()]), ) ) @@ -42,7 +42,7 @@ def test_list(): @pytest.mark.parametrize('collection_type', [core_schema.set_schema, core_schema.frozenset_schema]) def test_set_frozenset(collection_type): v = SchemaValidator( - schema=collection_type( + collection_type( core_schema.tuple_positional_schema([core_schema.int_schema(), core_schema.int_schema()]), ) ) @@ -86,7 +86,7 @@ def __len__(self): def test_dict(): - v = SchemaValidator(schema=core_schema.dict_schema(core_schema.int_schema(), core_schema.int_schema())) + v = SchemaValidator(core_schema.dict_schema(core_schema.int_schema(), core_schema.int_schema())) assert v.validate_python({'1': 2, 3: '4'}) == snapshot({1: 2, 3: 4}) assert v.validate_python({'1': 2, 3: '4'}, allow_partial=True) == snapshot({1: 2, 3: 4}) assert v.validate_python(MyMapping({'1': 2, 3: '4'}), allow_partial=True) == snapshot({1: 2, 3: 4}) @@ -115,7 +115,7 @@ def test_dict(): def test_dict_list(): v = SchemaValidator( - schema=core_schema.dict_schema(core_schema.int_schema(), core_schema.list_schema(core_schema.int_schema(ge=10))) + core_schema.dict_schema(core_schema.int_schema(), core_schema.list_schema(core_schema.int_schema(ge=10))) ) assert v.validate_python({'1': [20, 30], 3: [40, '50']}, allow_partial=True) == snapshot({1: [20, 30], 3: [40, 50]}) assert v.validate_python({'1': [20, 30], 3: [40, 5]}, allow_partial=True) == snapshot({1: [20, 30], 3: [40]}) @@ -126,7 +126,7 @@ def test_dict_list(): def test_partial_typed_dict(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field(core_schema.int_schema(gt=10)), 'b': core_schema.typed_dict_field(core_schema.int_schema(gt=10)), @@ -195,7 +195,7 @@ def test_partial_typed_dict(): def test_non_partial_typed_dict(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field(core_schema.int_schema(gt=10)), 'b': core_schema.typed_dict_field(core_schema.int_schema(gt=10), required=True), @@ -217,7 +217,7 @@ def test_non_partial_typed_dict(): def test_double_nested(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field(core_schema.int_schema(gt=10)), 'b': core_schema.typed_dict_field( @@ -261,7 +261,7 @@ def test_double_nested(): def test_tuple_list(): """Tuples don't support partial, so behaviour should be disabled.""" v = SchemaValidator( - schema=core_schema.tuple_positional_schema( + core_schema.tuple_positional_schema( [core_schema.list_schema(core_schema.int_schema()), core_schema.int_schema()] ) ) @@ -284,7 +284,7 @@ def test_dataclass(): ), ], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) assert v.validate_python({'a': 'x', 'b': ['ab', 'cd']}) == snapshot(({'a': 'x', 'b': ['ab', 'cd']}, None)) assert v.validate_python({'a': 'x', 'b': ['ab', 'cd']}, allow_partial=True) == snapshot( ({'a': 'x', 'b': ['ab', 'cd']}, None) @@ -294,9 +294,7 @@ def test_dataclass(): def test_nullable(): - v = SchemaValidator( - schema=core_schema.nullable_schema(core_schema.list_schema(core_schema.str_schema(min_length=2))) - ) + v = SchemaValidator(core_schema.nullable_schema(core_schema.list_schema(core_schema.str_schema(min_length=2)))) assert v.validate_python(None, allow_partial=True) is None assert v.validate_python(['ab', 'cd'], allow_partial=True) == ['ab', 'cd'] @@ -312,7 +310,7 @@ def test_nullable(): 'json_nested_type', [None, core_schema.dict_schema(core_schema.str_schema(), core_schema.int_schema())] ) def test_json(json_nested_type): - v = SchemaValidator(schema=core_schema.list_schema(core_schema.json_schema(json_nested_type))) + v = SchemaValidator(core_schema.list_schema(core_schema.json_schema(json_nested_type))) assert v.validate_python(['{"a": 1}', '{"b": 2}']) == snapshot([{'a': 1}, {'b': 2}]) assert v.validate_python(['{"a": 1}', '{"b": 2}'], allow_partial=True) == snapshot([{'a': 1}, {'b': 2}]) @@ -327,7 +325,7 @@ def test_json(json_nested_type): def test_json_trailing_strings(): - v = SchemaValidator(schema=core_schema.list_schema(core_schema.json_schema())) + v = SchemaValidator(core_schema.list_schema(core_schema.json_schema())) assert v.validate_python(['{"a": 1}', '{"b": "x'], allow_partial=True) == snapshot([{'a': 1}, {}]) assert v.validate_python(['{"a": 1}', '{"b": "x'], allow_partial='trailing-strings') == snapshot( [{'a': 1}, {'b': 'x'}] diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py index 9f9b63155..496363a1f 100644 --- a/tests/validators/test_arguments.py +++ b/tests/validators/test_arguments.py @@ -738,7 +738,7 @@ def test_default_factory(py_and_json: PyAndJson, input_value, expected): def test_repr(): v = SchemaValidator( - schema=cs.arguments_schema( + cs.arguments_schema( arguments=[ {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}, { @@ -772,7 +772,7 @@ def test_build_missing_var_kwargs(): with pytest.raises( SchemaError, match="`var_kwargs_schema` must be specified when `var_kwargs_mode` is `'unpacked-typed-dict'`" ): - SchemaValidator(schema=cs.arguments_schema(arguments=[], var_kwargs_mode='unpacked-typed-dict')) + SchemaValidator(cs.arguments_schema(arguments=[], var_kwargs_mode='unpacked-typed-dict')) @pytest.mark.parametrize( @@ -936,7 +936,7 @@ def decorator(function): assert p.kind == Parameter.VAR_KEYWORD, p.kind schema['var_kwargs_schema'] = arg_schema - validator = SchemaValidator(schema=schema, config=config) + validator = SchemaValidator(schema, config=config) @wraps(function) def wrapper(*args, **kwargs): @@ -1111,7 +1111,7 @@ def test_invalid_schema(): def test_error_display(pydantic_version): v = SchemaValidator( - schema=core_schema.arguments_schema( + core_schema.arguments_schema( [ core_schema.arguments_parameter('a', core_schema.int_schema()), core_schema.arguments_parameter('b', core_schema.int_schema()), diff --git a/tests/validators/test_bool.py b/tests/validators/test_bool.py index ee0132fb8..e151b8e85 100644 --- a/tests/validators/test_bool.py +++ b/tests/validators/test_bool.py @@ -55,7 +55,7 @@ def test_bool_strict(py_and_json: PyAndJson): def test_bool_error(pydantic_version): - v = SchemaValidator(schema=cs.bool_schema()) + v = SchemaValidator(cs.bool_schema()) with pytest.raises(ValidationError) as exc_info: v.validate_python('wrong') @@ -77,12 +77,12 @@ def test_bool_error(pydantic_version): def test_bool_repr(): - v = SchemaValidator(schema=cs.bool_schema()) + v = SchemaValidator(cs.bool_schema()) assert ( plain_repr(v) == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:false}),definitions=[],cache_strings=True)' ) - v = SchemaValidator(schema=cs.bool_schema(strict=True)) + v = SchemaValidator(cs.bool_schema(strict=True)) assert ( plain_repr(v) == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:true}),definitions=[],cache_strings=True)' @@ -105,6 +105,6 @@ def test_validate_assignment_not_supported() -> None: same for all validators (it's the default impl on the Validator trait). But we need to test this somewhere, so it is going in the bool tests for now. """ - v = SchemaValidator(schema=core_schema.bool_schema()) + v = SchemaValidator(core_schema.bool_schema()) with pytest.raises(TypeError, match='validate_assignment is not supported for bool'): v.validate_assignment(False, 'foo', True) diff --git a/tests/validators/test_bytes.py b/tests/validators/test_bytes.py index 71bba1348..1110a34d3 100644 --- a/tests/validators/test_bytes.py +++ b/tests/validators/test_bytes.py @@ -10,7 +10,7 @@ def test_strict_bytes_validator(): - v = SchemaValidator(schema=cs.bytes_schema(strict=True)) + v = SchemaValidator(cs.bytes_schema(strict=True)) assert v.validate_python(b'foo') == b'foo' assert v.validate_json('"foo"') == b'foo' @@ -22,7 +22,7 @@ def test_strict_bytes_validator(): def test_lax_bytes_validator(): - v = SchemaValidator(schema=cs.bytes_schema()) + v = SchemaValidator(cs.bytes_schema()) assert v.validate_python(b'foo') == b'foo' assert v.validate_python('foo') == b'foo' @@ -57,7 +57,7 @@ def test_lax_bytes_validator(): ], ) def test_constrained_bytes_python_bytes(opts: dict[str, Any], input, expected): - v = SchemaValidator(schema=cs.bytes_schema(**opts)) + v = SchemaValidator(cs.bytes_schema(**opts)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input) @@ -91,13 +91,13 @@ def test_constrained_bytes(py_and_json: PyAndJson, opts: dict[str, Any], input, def test_union(): - v = SchemaValidator(schema=cs.union_schema(choices=[cs.str_schema(), cs.bytes_schema()], strict=True)) + v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.bytes_schema()], strict=True)) assert v.validate_python('oh, a string') == 'oh, a string' assert v.validate_python(b'oh, bytes') == b'oh, bytes' def test_length_ctx(): - v = SchemaValidator(schema=cs.bytes_schema(min_length=2, max_length=3)) + v = SchemaValidator(cs.bytes_schema(min_length=2, max_length=3)) with pytest.raises(ValidationError) as exc_info: v.validate_python(b'1') assert exc_info.value.errors(include_url=False) == [ diff --git a/tests/validators/test_call.py b/tests/validators/test_call.py index fadc7bb5e..eb25f1325 100644 --- a/tests/validators/test_call.py +++ b/tests/validators/test_call.py @@ -69,9 +69,7 @@ def test_function_args_any(input_value, expected): def my_function(a, b, c): return a + b + c - v = SchemaValidator( - schema=cs.call_schema(function=my_function, arguments=cs.any_schema(), return_schema=cs.int_schema()) - ) + v = SchemaValidator(cs.call_schema(function=my_function, arguments=cs.any_schema(), return_schema=cs.int_schema())) if isinstance(expected, Exception): with pytest.raises(type(expected), match=re.escape(str(expected))): @@ -85,7 +83,7 @@ def test_function_return_any(input_value, expected): def my_function(a): return a - v = SchemaValidator(schema=cs.call_schema(function=my_function, arguments=cs.any_schema())) + v = SchemaValidator(cs.call_schema(function=my_function, arguments=cs.any_schema())) assert 'name:"call[my_function]"' in plain_repr(v) assert v.validate_python(input_value) == expected @@ -96,7 +94,7 @@ def my_function(a): return a v = SchemaValidator( - schema=cs.union_schema( + cs.union_schema( choices=[ cs.call_schema( function=my_function, @@ -129,7 +127,7 @@ class my_dataclass: b: str v = SchemaValidator( - schema=cs.call_schema( + cs.call_schema( function=my_dataclass, arguments=cs.arguments_schema( arguments=[ @@ -154,7 +152,7 @@ def test_named_tuple(): Point = namedtuple('Point', ['x', 'y']) v = SchemaValidator( - schema=cs.call_schema( + cs.call_schema( function=Point, arguments=cs.arguments_schema( arguments=[ @@ -180,7 +178,7 @@ def my_function(a, b, c): return a + b + c v = SchemaValidator( - schema=cs.call_schema( + cs.call_schema( function=partial(my_function, c=3), arguments=cs.arguments_schema( arguments=[ @@ -200,7 +198,7 @@ def my_function(a): return a v = SchemaValidator( - schema=cs.call_schema( + cs.call_schema( function=my_function, function_name='foobar', arguments=cs.arguments_schema( diff --git a/tests/validators/test_callable.py b/tests/validators/test_callable.py index 209c289b3..f8ef8bcaf 100644 --- a/tests/validators/test_callable.py +++ b/tests/validators/test_callable.py @@ -18,7 +18,7 @@ def __call__(self, *args, **kwargs): def test_callable(): - v = SchemaValidator(schema=cs.callable_schema()) + v = SchemaValidator(cs.callable_schema()) assert v.validate_python(func) == func assert v.isinstance_python(func) is True @@ -48,12 +48,12 @@ def test_callable(): ], ) def test_callable_cases(input_value, expected): - v = SchemaValidator(schema=cs.callable_schema()) + v = SchemaValidator(cs.callable_schema()) assert v.isinstance_python(input_value) == expected def test_repr(): - v = SchemaValidator(schema=cs.union_schema(choices=[cs.int_schema(), cs.callable_schema()])) + v = SchemaValidator(cs.union_schema(choices=[cs.int_schema(), cs.callable_schema()])) assert v.isinstance_python(4) is True assert v.isinstance_python(func) is True assert v.isinstance_python('foo') is False diff --git a/tests/validators/test_chain.py b/tests/validators/test_chain.py index f032cfbf3..cae3c170d 100644 --- a/tests/validators/test_chain.py +++ b/tests/validators/test_chain.py @@ -10,7 +10,7 @@ def test_chain(): validator = SchemaValidator( - schema=cs.chain_schema( + cs.chain_schema( steps=[cs.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))] ) ) @@ -21,7 +21,7 @@ def test_chain(): def test_chain_many(): validator = SchemaValidator( - schema=cs.chain_schema( + cs.chain_schema( steps=[ core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1'), core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-2'), @@ -35,7 +35,7 @@ def test_chain_many(): def test_chain_error(): - validator = SchemaValidator(schema=cs.chain_schema(steps=[cs.str_schema(), cs.int_schema()])) + validator = SchemaValidator(cs.chain_schema(steps=[cs.str_schema(), cs.int_schema()])) assert validator.validate_python('123') == 123 assert validator.validate_python(b'123') == 123 @@ -73,7 +73,7 @@ def test_json(py_and_json: PyAndJson, input_value, expected): def test_flatten(): validator = SchemaValidator( - schema=cs.chain_schema( + cs.chain_schema( steps=[ core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1'), cs.chain_schema( @@ -98,12 +98,12 @@ def test_flatten(): def test_chain_empty(): with pytest.raises(SchemaError, match='One or more steps are required for a chain validator'): - SchemaValidator(schema=cs.chain_schema(steps=[])) + SchemaValidator(cs.chain_schema(steps=[])) def test_chain_one(): validator = SchemaValidator( - schema=cs.chain_schema(steps=[core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1')]) + cs.chain_schema(steps=[core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1')]) ) assert validator.validate_python('input') == 'input-1' assert validator.title == 'function-plain[()]' diff --git a/tests/validators/test_complex.py b/tests/validators/test_complex.py index af653406d..c3a1076c7 100644 --- a/tests/validators/test_complex.py +++ b/tests/validators/test_complex.py @@ -46,7 +46,7 @@ ids=repr, ) def test_complex_cases(input_value, expected): - v = SchemaValidator(schema=cs.complex_schema()) + v = SchemaValidator(cs.complex_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -77,7 +77,7 @@ def test_complex_cases(input_value, expected): ids=repr, ) def test_complex_strict(input_value, expected): - v = SchemaValidator(schema=cs.complex_schema(strict=True)) + v = SchemaValidator(cs.complex_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -90,12 +90,12 @@ def test_complex_strict(input_value, expected): reason='PyPy cannot process this string due to a bug, even if this string is considered valid in python', ) def test_valid_complex_string_with_space(): - v = SchemaValidator(schema=cs.complex_schema()) + v = SchemaValidator(cs.complex_schema()) assert v.validate_python('\t( -1.23+4.5J )\n') == complex(-1.23, 4.5) def test_nan_inf_complex(): - v = SchemaValidator(schema=cs.complex_schema()) + v = SchemaValidator(cs.complex_schema()) c = v.validate_python('NaN+Infinityj') # c != complex(float('nan'), float('inf')) as nan != nan, # so we need to examine the values individually @@ -106,7 +106,7 @@ def test_nan_inf_complex(): def test_overflow_complex(): # Python simply converts too large float values to inf, so these strings # are still valid, even if the numbers are out of range - v = SchemaValidator(schema=cs.complex_schema()) + v = SchemaValidator(cs.complex_schema()) c = v.validate_python('5e600j') assert math.isinf(c.imag) @@ -116,7 +116,7 @@ def test_overflow_complex(): def test_json_complex(): - v = SchemaValidator(schema=cs.complex_schema()) + v = SchemaValidator(cs.complex_schema()) assert v.validate_json('"-1.23e+4+5.67e-8J"') == complex(-1.23e4, 5.67e-8) assert v.validate_json('1') == complex(1, 0) assert v.validate_json('1.0') == complex(1, 0) @@ -136,7 +136,7 @@ def test_json_complex(): def test_json_complex_strict(): - v = SchemaValidator(schema=cs.complex_schema(strict=True)) + v = SchemaValidator(cs.complex_schema(strict=True)) assert v.validate_json('"-1.23e+4+5.67e-8J"') == complex(-1.23e4, 5.67e-8) # "1" is a valid complex string assert v.validate_json('"1"') == complex(1, 0) @@ -150,7 +150,7 @@ def test_json_complex_strict(): def test_string_complex(): - v = SchemaValidator(schema=cs.complex_schema()) + v = SchemaValidator(cs.complex_schema()) assert v.validate_strings('+1.23e-4-5.67e+8J') == complex(1.23e-4, -5.67e8) with pytest.raises(ValidationError, match=re.escape(EXPECTED_PARSE_ERROR_MESSAGE)): v.validate_strings("{'real': 1, 'imag': 0}") diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py index 444059eb2..c5eeebf02 100644 --- a/tests/validators/test_dataclasses.py +++ b/tests/validators/test_dataclasses.py @@ -207,7 +207,7 @@ def test_dataclass(): ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 'hello', 'b': True}) assert dataclasses.is_dataclass(foo) assert foo.a == 'hello' @@ -289,7 +289,7 @@ def test_dataclass_subclass(revalidate_instances, input_value, expected): ['a', 'b'], revalidate_instances=revalidate_instances, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) if isinstance(expected, Err): with pytest.raises(ValidationError, match=expected.message) as exc_info: @@ -306,7 +306,7 @@ def test_dataclass_subclass(revalidate_instances, input_value, expected): def test_dataclass_subclass_strict_never_revalidate(): v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( FooDataclass, core_schema.dataclass_args_schema( 'FooDataclass', @@ -333,7 +333,7 @@ def test_dataclass_subclass_strict_never_revalidate(): def test_dataclass_subclass_subclass_revalidate(): v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( FooDataclass, core_schema.dataclass_args_schema( 'FooDataclass', @@ -379,7 +379,7 @@ def __post_init__(self): post_init=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 'hello', 'b': True}) assert foo.a == 'HELLO' assert foo.b is True @@ -413,7 +413,7 @@ def __post_init__(self, c: int): post_init=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': b'hello', 'b': 'true', 'c': '42'}) assert foo.a == 'hello' assert foo.b is True @@ -449,7 +449,7 @@ def __post_init__(self, *args): post_init=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': b'hello', 'b': 'true', 'c': '42'}) assert dataclasses.asdict(foo) == {'a': 'hello'} assert dc_args == (True, 42) @@ -480,7 +480,7 @@ def test_dataclass_exact_validation(revalidate_instances, input_value, expected) revalidate_instances=revalidate_instances, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python(input_value) assert dataclasses.asdict(foo) == expected @@ -515,7 +515,7 @@ def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str: ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 1, 'b': b'hello'}) assert dataclasses.asdict(foo) == {'a': 1, 'b': 'hello world!'} @@ -547,7 +547,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> str: ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 1, 'b': b'hello'}) assert dataclasses.asdict(foo) == {'a': 1, 'b': 'hello world!'} @@ -582,7 +582,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes: ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 1, 'b': b'hello'}) assert dataclasses.asdict(foo) == {'a': 1, 'b': 'hello world!'} @@ -621,7 +621,7 @@ def validate_b( ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 1, 'b': b'hello'}) assert dataclasses.asdict(foo) == {'a': 1, 'b': 'hello world!'} @@ -658,7 +658,7 @@ def validate_b( ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 1, 'b': b'hello'}) assert dataclasses.asdict(foo) == {'a': 1, 'b': 'hello world!'} @@ -683,7 +683,7 @@ def __init__(self, *args, **kwargs): ), ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = Foo(b'hello', 'True') assert dataclasses.is_dataclass(foo) @@ -707,7 +707,7 @@ class Foo: ), ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) def __init__(self, *args, **kwargs): v.validate_python(ArgsKwargs(args, kwargs), self_instance=self) @@ -750,7 +750,7 @@ class Foo: ['a', 'b'], config={'loc_by_alias': False}, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) def __init__(self, *args, **kwargs): v.validate_python(ArgsKwargs(args, kwargs), self_instance=self) @@ -804,7 +804,7 @@ def __post_init__(self, c): ['a', 'b', 'c'], post_init=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = Foo(b'hello', 'True', c='123') assert dataclasses.is_dataclass(foo) @@ -824,7 +824,7 @@ def test_dataclass_validate_assignment(): ), ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 'hello', 'b': 'True'}) assert dataclasses.asdict(foo) == {'a': 'hello', 'b': True} @@ -870,7 +870,7 @@ def func(x, info): return x * 2 v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( MyDataclass, core_schema.dataclass_args_schema( 'MyDataclass', @@ -910,7 +910,7 @@ class MyModel: f: str v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( MyModel, core_schema.dataclass_args_schema('MyModel', [core_schema.dataclass_field('f', core_schema.str_schema())]), ['f'], @@ -936,7 +936,7 @@ class MyModel: f: str v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( MyModel, core_schema.dataclass_args_schema( 'MyModel', [core_schema.dataclass_field('f', core_schema.str_schema(), frozen=True)] @@ -973,7 +973,7 @@ class MyModel: f: str v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( MyModel, core_schema.dataclass_args_schema( 'MyModel', [core_schema.dataclass_field('f', core_schema.str_schema())], **schema_extra_behavior_kw @@ -1021,7 +1021,7 @@ class MyModel: f: str v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( MyModel, core_schema.dataclass_args_schema( 'MyModel', [core_schema.dataclass_field('f', core_schema.str_schema())], **schema_extra_behavior_kw @@ -1067,7 +1067,7 @@ class MyModel: f: str v = SchemaValidator( - schema=core_schema.dataclass_schema( + core_schema.dataclass_schema( MyModel, core_schema.dataclass_args_schema( 'MyModel', [core_schema.dataclass_field('f', core_schema.str_schema())], **schema_extra_behavior_kw @@ -1110,7 +1110,7 @@ class Model: ['number'], ) - v = SchemaValidator(schema=cs) + v = SchemaValidator(cs) instance: Model = v.validate_python({'number': 1}) assert instance.number == 1 @@ -1142,7 +1142,7 @@ class Model: ['number'], ) - v = SchemaValidator(schema=cs) + v = SchemaValidator(cs) instance: Model = v.validate_python({'number': 1}) assert instance.number == 1 @@ -1177,7 +1177,7 @@ class Model: ['number'], ) - v = SchemaValidator(schema=cs) + v = SchemaValidator(cs) instance: Model = v.validate_python({'number': 1}) assert instance.number == 1 @@ -1227,7 +1227,7 @@ def test_custom_dataclass_names(): ['foo'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) with pytest.raises(ValidationError) as exc_info: v.validate_python({'foo': 123}) assert exc_info.value.errors(include_url=False) == [ @@ -1257,7 +1257,7 @@ class Model: slots=True, ) - val = SchemaValidator(schema=schema) + val = SchemaValidator(schema) m: Model m = val.validate_python({'x': 123}) @@ -1305,7 +1305,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes: slots=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 1, 'b': b'hello'}) assert dataclasses.asdict(foo) == {'a': 1, 'b': 'hello world!'} @@ -1342,7 +1342,7 @@ def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str: slots=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) foo = v.validate_python({'a': 1, 'b': b'hello'}) assert dataclasses.asdict(foo) == {'a': 1, 'b': 'hello world!'} @@ -1430,7 +1430,7 @@ def test_slots_dataclass_subclass(revalidate_instances, input_value, expected): revalidate_instances=revalidate_instances, slots=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) if isinstance(expected, Err): with pytest.raises(ValidationError, match=expected.message) as exc_info: @@ -1473,7 +1473,7 @@ class SubModel(Model): ['x'], slots=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) dc = v.validate_python({'x': 1, 'y': 'a', 'x2': 2, 'y2': 'b'}) assert dc.x == 1 assert dc.x2 == 2 @@ -1492,7 +1492,7 @@ def test_dataclass_json(): ), ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) assert v.validate_json('{"a": "hello", "b": true}') == FooDataclass(a='hello', b=True) with pytest.raises(ValidationError) as exc_info: @@ -1525,7 +1525,7 @@ def test_dataclass_wrap_json(): ['a', 'b'], ), ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) assert v.validate_json('{"a": "hello", "b": true}') == FooDataclass(a='hello', b=True) assert v.validate_json('{"a": "hello", "b": true}', strict=True) == FooDataclass(a='hello', b=True) @@ -1576,7 +1576,7 @@ def _wrap_validator(cls, v, validator, info): # If any of the Rust validators don't implement traversal properly, # there will be an undetectable cycle created by this assignment # which will keep Dataclass alive - Dataclass.__pydantic_validator__ = SchemaValidator(schema=dataclass_schema) + Dataclass.__pydantic_validator__ = SchemaValidator(dataclass_schema) return Dataclass @@ -1652,7 +1652,7 @@ def __post_init__(self): post_init=True, ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: @@ -1698,7 +1698,7 @@ class Foo: ['a', 'b'], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py index 0bbe9a92b..90cb1d797 100644 --- a/tests/validators/test_date.py +++ b/tests/validators/test_date.py @@ -74,7 +74,7 @@ ], ) def test_date(input_value, expected): - v = SchemaValidator(schema=cs.date_schema()) + v = SchemaValidator(cs.date_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): result = v.validate_python(input_value) @@ -137,7 +137,7 @@ def test_date_json(py_and_json: PyAndJson, input_value, expected): ids=repr, ) def test_date_strict(input_value, expected, strict_mode_type): - v = SchemaValidator(schema=cs.date_schema(strict=strict_mode_type.schema)) + v = SchemaValidator(cs.date_schema(strict=strict_mode_type.schema)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value, **strict_mode_type.validator_args) @@ -158,7 +158,7 @@ def test_date_strict(input_value, expected, strict_mode_type): ], ) def test_date_strict_json(input_value, expected, strict_mode_type): - v = SchemaValidator(schema=cs.date_schema(strict=strict_mode_type.schema)) + v = SchemaValidator(cs.date_schema(strict=strict_mode_type.schema)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value, **strict_mode_type.validator_args) @@ -168,7 +168,7 @@ def test_date_strict_json(input_value, expected, strict_mode_type): def test_date_strict_json_ctx(): - v = SchemaValidator(schema=cs.date_schema(strict=True)) + v = SchemaValidator(cs.date_schema(strict=True)) with pytest.raises(ValidationError) as exc_info: v.validate_json('"foobar"') assert exc_info.value.errors(include_url=False) == [ @@ -205,7 +205,7 @@ def test_date_strict_json_ctx(): ], ) def test_date_kwargs(kwargs: dict[str, Any], input_value: date, expected: Err | date): - v = SchemaValidator(schema=cs.date_schema(**kwargs)) # type: ignore + v = SchemaValidator(cs.date_schema(**kwargs)) # type: ignore if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -220,7 +220,7 @@ def test_invalid_constraint(): def test_dict_py(): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.date_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.date_schema(), values_schema=cs.int_schema())) assert v.validate_python({date(2000, 1, 1): 2, date(2000, 1, 2): 4}) == {date(2000, 1, 1): 2, date(2000, 1, 2): 4} @@ -230,11 +230,11 @@ def test_dict(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator(schema=cs.union_schema(choices=[cs.str_schema(), cs.date_schema()])) + v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.date_schema()])) assert v.validate_python('2022-01-02') == '2022-01-02' assert v.validate_python(date(2022, 1, 2)) == date(2022, 1, 2) - v = SchemaValidator(schema=cs.union_schema(choices=[cs.date_schema(), cs.str_schema()])) + v = SchemaValidator(cs.union_schema(choices=[cs.date_schema(), cs.str_schema()])) assert v.validate_python('2022-01-02') == '2022-01-02' assert v.validate_python(date(2022, 1, 2)) == date(2022, 1, 2) @@ -283,13 +283,13 @@ def test_date_future(py_and_json: PyAndJson, input_value, expected): def test_date_past_future_today(): - v = SchemaValidator(schema=core_schema.date_schema(now_op='past', now_utc_offset=0)) + v = SchemaValidator(core_schema.date_schema(now_op='past', now_utc_offset=0)) today = datetime.now(timezone.utc).date() assert v.isinstance_python(today) is False assert v.isinstance_python(today - timedelta(days=1)) is True assert v.isinstance_python(today + timedelta(days=1)) is False - v = SchemaValidator(schema=core_schema.date_schema(now_op='future', now_utc_offset=0)) + v = SchemaValidator(core_schema.date_schema(now_op='future', now_utc_offset=0)) assert v.isinstance_python(today) is False assert v.isinstance_python(today - timedelta(days=1)) is False assert v.isinstance_python(today + timedelta(days=1)) is True diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py index adeadffd7..f9ee69bf4 100644 --- a/tests/validators/test_datetime.py +++ b/tests/validators/test_datetime.py @@ -59,7 +59,7 @@ ], ) def test_datetime(input_value, expected): - v = SchemaValidator(schema=cs.datetime_schema()) + v = SchemaValidator(cs.datetime_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): result = v.validate_python(input_value) @@ -82,7 +82,7 @@ def test_datetime(input_value, expected): ], ) def test_datetime_strict(input_value, expected): - v = SchemaValidator(schema=cs.datetime_schema(strict=True)) + v = SchemaValidator(cs.datetime_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -94,7 +94,7 @@ def test_datetime_strict(input_value, expected): def test_keep_tz(): tz = zoneinfo.ZoneInfo('Europe/London') dt = datetime(2022, 6, 14, 12, 13, 14, tzinfo=tz) - v = SchemaValidator(schema=cs.datetime_schema()) + v = SchemaValidator(cs.datetime_schema()) output = v.validate_python(dt) assert output == dt @@ -107,7 +107,7 @@ def test_keep_tz(): def test_keep_tz_bound(): tz = zoneinfo.ZoneInfo('Europe/London') dt = datetime(2022, 6, 14, 12, 13, 14, tzinfo=tz) - v = SchemaValidator(schema=cs.datetime_schema(gt=datetime(2022, 1, 1))) + v = SchemaValidator(cs.datetime_schema(gt=datetime(2022, 1, 1))) output = v.validate_python(dt) assert output == dt @@ -167,7 +167,7 @@ def test_datetime_json(py_and_json: PyAndJson, input_value, expected): ], ) def test_datetime_strict_json(input_value, expected): - v = SchemaValidator(schema=cs.datetime_schema(strict=True)) + v = SchemaValidator(cs.datetime_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(json.dumps(input_value)) @@ -177,7 +177,7 @@ def test_datetime_strict_json(input_value, expected): def test_custom_timezone_repr(): - output = SchemaValidator(schema=cs.datetime_schema()).validate_python('2022-06-08T12:13:14-12:15') + output = SchemaValidator(cs.datetime_schema()).validate_python('2022-06-08T12:13:14-12:15') assert output == datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone(timedelta(hours=-12, minutes=-15))) assert output.tzinfo.utcoffset(output) == timedelta(hours=-12, minutes=-15) assert output.tzinfo.dst(output) is None @@ -187,7 +187,7 @@ def test_custom_timezone_repr(): def test_custom_timezone_utc_repr(): - output = SchemaValidator(schema=cs.datetime_schema()).validate_python('2022-06-08T12:13:14Z') + output = SchemaValidator(cs.datetime_schema()).validate_python('2022-06-08T12:13:14Z') assert output == datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone(timedelta(0))) assert output.tzinfo.utcoffset(output) == timedelta(0) assert output.tzinfo.dst(output) is None @@ -201,19 +201,19 @@ def test_tz_comparison(): uk_3pm = datetime(2022, 1, 1, 15, 0, 0, tzinfo=tz) # two times are the same instant, therefore le and ge are both ok - v = SchemaValidator(schema=cs.datetime_schema(le=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00') + v = SchemaValidator(cs.datetime_schema(le=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00') assert v == datetime(2022, 1, 1, 16, 0, 0, tzinfo=timezone(timedelta(hours=1))) - v = SchemaValidator(schema=cs.datetime_schema(ge=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00') + v = SchemaValidator(cs.datetime_schema(ge=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00') assert v == datetime(2022, 1, 1, 16, 0, 0, tzinfo=timezone(timedelta(hours=1))) # but not gt with pytest.raises(ValidationError, match=r'Input should be greater than 2022-01-01T15:00:00Z \[type=greater_than'): - SchemaValidator(schema=cs.datetime_schema(gt=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00') + SchemaValidator(cs.datetime_schema(gt=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00') def test_tz_info_deepcopy(): - output = SchemaValidator(schema=cs.datetime_schema()).validate_python('2023-02-15T16:23:44.037Z') + output = SchemaValidator(cs.datetime_schema()).validate_python('2023-02-15T16:23:44.037Z') c = copy.deepcopy(output) assert repr(output.tzinfo) == 'TzInfo(UTC)' assert repr(c.tzinfo) == 'TzInfo(UTC)' @@ -221,7 +221,7 @@ def test_tz_info_deepcopy(): def test_tz_info_copy(): - output = SchemaValidator(schema=cs.datetime_schema()).validate_python('2023-02-15T16:23:44.037Z') + output = SchemaValidator(cs.datetime_schema()).validate_python('2023-02-15T16:23:44.037Z') c = copy.copy(output) assert repr(output.tzinfo) == 'TzInfo(UTC)' assert repr(c.tzinfo) == 'TzInfo(UTC)' @@ -239,7 +239,7 @@ def dst(self, _dt): def tzname(self, _dt): return 'CustomTZ' - schema = SchemaValidator(schema=cs.datetime_schema(gt=datetime(2022, 1, 1, 15, 0, 0))) + schema = SchemaValidator(cs.datetime_schema(gt=datetime(2022, 1, 1, 15, 0, 0))) dt = datetime(2022, 1, 1, 16, 0, 0, tzinfo=CustomTz()) outcome = schema.validate_python(dt) @@ -253,7 +253,7 @@ class CustomTz(tzinfo): def tzname(self, _dt): return 'CustomTZ' - schema = SchemaValidator(schema=cs.datetime_schema(gt=datetime(2022, 1, 1, 15, 0, 0))) + schema = SchemaValidator(cs.datetime_schema(gt=datetime(2022, 1, 1, 15, 0, 0))) dt = datetime(2022, 1, 1, 16, 0, 0, tzinfo=CustomTz()) # perhaps this should be a ValidationError? but we don't catch other errors @@ -278,7 +278,7 @@ def tzname(self, _dt): def test_dict_py(): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.datetime_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.datetime_schema(), values_schema=cs.int_schema())) assert v.validate_python({datetime(2000, 1, 1): 2, datetime(2000, 1, 2): 4}) == { datetime(2000, 1, 1): 2, datetime(2000, 1, 2): 4, @@ -294,11 +294,11 @@ def test_dict(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator(schema=cs.union_schema(choices=[cs.str_schema(), cs.datetime_schema()])) + v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.datetime_schema()])) assert v.validate_python('2022-01-02T00:00') == '2022-01-02T00:00' assert v.validate_python(datetime(2022, 1, 2)) == datetime(2022, 1, 2) - v = SchemaValidator(schema=cs.union_schema(choices=[cs.datetime_schema(), cs.str_schema()])) + v = SchemaValidator(cs.union_schema(choices=[cs.datetime_schema(), cs.str_schema()])) assert v.validate_python('2022-01-02T00:00') == '2022-01-02T00:00' assert v.validate_python(datetime(2022, 1, 2)) == datetime(2022, 1, 2) @@ -329,7 +329,7 @@ def test_datetime_past(py_and_json: PyAndJson, input_value, expected): def test_datetime_past_timezone(): - v = SchemaValidator(schema=core_schema.datetime_schema(now_utc_offset=0, now_op='past')) + v = SchemaValidator(core_schema.datetime_schema(now_utc_offset=0, now_op='past')) now_utc = datetime.now(timezone.utc) - timedelta(seconds=1) assert v.isinstance_python(now_utc) # "later" in the day @@ -372,7 +372,7 @@ def test_datetime_future(py_and_json: PyAndJson, input_value, expected): def test_datetime_future_timezone(): - v = SchemaValidator(schema=core_schema.datetime_schema(now_utc_offset=0, now_op='future')) + v = SchemaValidator(core_schema.datetime_schema(now_utc_offset=0, now_op='future')) now_utc = datetime.now(timezone.utc) soon_utc = now_utc + timedelta(minutes=1) @@ -398,7 +398,7 @@ def test_mock_utc_offset_8_hours(mocker): time.localtime() will return `{'tm_gmtoff': 8 * 60 * 60}` for the rest of the session. """ mocker.patch('time.localtime', return_value=type('time.struct_time', (), {'tm_gmtoff': 8 * 60 * 60})) - v = SchemaValidator(schema=core_schema.datetime_schema(now_op='future')) + v = SchemaValidator(core_schema.datetime_schema(now_op='future')) future = datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(hours=8, minutes=1) assert v.isinstance_python(future) @@ -420,7 +420,7 @@ def test_raises_schema_error_for_unknown_constraint_kind(): def test_aware(): - v = SchemaValidator(schema=core_schema.datetime_schema(tz_constraint='aware')) + v = SchemaValidator(core_schema.datetime_schema(tz_constraint='aware')) value = datetime.now(tz=timezone.utc) assert value is v.validate_python(value) assert v.validate_python('2022-06-08T12:13:14Z') == datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone.utc) @@ -434,7 +434,7 @@ def test_aware(): def test_naive(): - v = SchemaValidator(schema=core_schema.datetime_schema(tz_constraint='naive')) + v = SchemaValidator(core_schema.datetime_schema(tz_constraint='naive')) value = datetime.now() assert value is v.validate_python(value) assert v.validate_python('2022-06-08T12:13:14') == datetime(2022, 6, 8, 12, 13, 14) @@ -448,7 +448,7 @@ def test_naive(): def test_aware_specific(): - v = SchemaValidator(schema=core_schema.datetime_schema(tz_constraint=0)) + v = SchemaValidator(core_schema.datetime_schema(tz_constraint=0)) value = datetime.now(tz=timezone.utc) assert value is v.validate_python(value) assert v.validate_python('2022-06-08T12:13:14Z') == datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone.utc) @@ -476,7 +476,7 @@ def test_aware_specific(): def test_neg_7200(): - v = SchemaValidator(schema=core_schema.datetime_schema(tz_constraint=-7200)) + v = SchemaValidator(core_schema.datetime_schema(tz_constraint=-7200)) value = datetime.now(tz=timezone(timedelta(hours=-2))) assert value is v.validate_python(value) @@ -493,7 +493,7 @@ def test_neg_7200(): def test_tz_constraint_too_high(): with pytest.raises(SchemaError, match='OverflowError: Python int too large to convert to C long'): - SchemaValidator(schema=core_schema.datetime_schema(tz_constraint=2**64)) + SchemaValidator(core_schema.datetime_schema(tz_constraint=2**64)) def test_tz_constraint_wrong(): @@ -502,7 +502,7 @@ def test_tz_constraint_wrong(): def test_tz_hash() -> None: - v = SchemaValidator(schema=core_schema.datetime_schema()) + v = SchemaValidator(core_schema.datetime_schema()) lookup: dict[datetime, str] = {} for day in range(1, 10): input_str = f'2022-06-{day:02}T12:13:14-12:15' @@ -517,7 +517,7 @@ def test_tz_hash() -> None: def test_tz_cmp() -> None: - v = SchemaValidator(schema=core_schema.datetime_schema()) + v = SchemaValidator(core_schema.datetime_schema()) validated1 = v.validate_python('2022-06-08T12:13:14-12:15') validated2 = v.validate_python('2022-06-08T12:13:14-12:14') diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py index 129d578b9..074425b5f 100644 --- a/tests/validators/test_decimal.py +++ b/tests/validators/test_decimal.py @@ -91,7 +91,7 @@ def test_decimal(py_and_json: PyAndJson, input_value, expected): ids=repr, ) def test_decimal_strict_py(input_value, expected): - v = SchemaValidator(schema=cs.decimal_schema(strict=True)) + v = SchemaValidator(cs.decimal_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -121,7 +121,7 @@ def test_decimal_strict_py(input_value, expected): ids=repr, ) def test_decimal_strict_json(input_value, expected): - v = SchemaValidator(schema=cs.decimal_schema(strict=True)) + v = SchemaValidator(cs.decimal_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(json.dumps(input_value)) @@ -225,9 +225,7 @@ def test_decimal_multiple_of(py_and_json: PyAndJson, multiple_of: float, input_v def test_union_decimal_py(): - v = SchemaValidator( - schema=cs.union_schema(choices=[cs.decimal_schema(strict=True), cs.decimal_schema(multiple_of=7)]) - ) + v = SchemaValidator(cs.union_schema(choices=[cs.decimal_schema(strict=True), cs.decimal_schema(multiple_of=7)])) assert v.validate_python('14') == 14 assert v.validate_python(Decimal(5)) == 5 with pytest.raises(ValidationError) as exc_info: @@ -251,9 +249,7 @@ def test_union_decimal_py(): def test_union_decimal_json(): - v = SchemaValidator( - schema=cs.union_schema(choices=[cs.decimal_schema(strict=True), cs.decimal_schema(multiple_of=7)]) - ) + v = SchemaValidator(cs.union_schema(choices=[cs.decimal_schema(strict=True), cs.decimal_schema(multiple_of=7)])) assert v.validate_json(json.dumps('14')) == 14 assert v.validate_json(json.dumps('5')) == 5 @@ -276,21 +272,21 @@ def test_union_decimal_simple(py_and_json: PyAndJson): def test_decimal_repr(): - v = SchemaValidator(schema=cs.decimal_schema()) + v = SchemaValidator(cs.decimal_schema()) assert plain_repr(v).startswith( 'SchemaValidator(title="decimal",validator=Decimal(DecimalValidator{strict:false,allow_inf_nan:false' ) - v = SchemaValidator(schema=cs.decimal_schema(strict=True)) + v = SchemaValidator(cs.decimal_schema(strict=True)) assert plain_repr(v).startswith( 'SchemaValidator(title="decimal",validator=Decimal(DecimalValidator{strict:true,allow_inf_nan:false' ) - v = SchemaValidator(schema=cs.decimal_schema(multiple_of=7)) + v = SchemaValidator(cs.decimal_schema(multiple_of=7)) assert plain_repr(v).startswith('SchemaValidator(title="decimal",validator=Decimal(') @pytest.mark.parametrize('input_value,expected', [(Decimal('1.23'), Decimal('1.23')), (Decimal('1'), Decimal('1.0'))]) def test_decimal_not_json(input_value, expected): - v = SchemaValidator(schema=cs.decimal_schema()) + v = SchemaValidator(cs.decimal_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -384,7 +380,7 @@ def test_non_finite_json_values(py_and_json: PyAndJson, input_value, allow_inf_n ], ) def test_non_finite_decimal_values(strict, input_value, allow_inf_nan, expected): - v = SchemaValidator(schema=cs.decimal_schema(allow_inf_nan=allow_inf_nan, strict=strict)) + v = SchemaValidator(cs.decimal_schema(allow_inf_nan=allow_inf_nan, strict=strict)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -420,7 +416,7 @@ def test_non_finite_decimal_values(strict, input_value, allow_inf_nan, expected) ], ) def test_non_finite_constrained_decimal_values(input_value, allow_inf_nan, expected): - v = SchemaValidator(schema=cs.decimal_schema(allow_inf_nan=allow_inf_nan, gt=0)) + v = SchemaValidator(cs.decimal_schema(allow_inf_nan=allow_inf_nan, gt=0)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -458,12 +454,12 @@ def test_non_finite_constrained_decimal_values(input_value, allow_inf_nan, expec ], ) def test_validate_scientific_notation_from_json(input_value, expected): - v = SchemaValidator(schema=cs.decimal_schema()) + v = SchemaValidator(cs.decimal_schema()) assert v.validate_json(input_value) == expected def test_validate_max_digits_and_decimal_places() -> None: - v = SchemaValidator(schema=cs.decimal_schema(max_digits=5, decimal_places=2)) + v = SchemaValidator(cs.decimal_schema(max_digits=5, decimal_places=2)) # valid inputs assert v.validate_json('1.23') == Decimal('1.23') @@ -482,7 +478,7 @@ def test_validate_max_digits_and_decimal_places() -> None: def test_validate_max_digits_and_decimal_places_edge_case() -> None: - v = SchemaValidator(schema=cs.decimal_schema(max_digits=34, decimal_places=18)) + v = SchemaValidator(cs.decimal_schema(max_digits=34, decimal_places=18)) # valid inputs assert v.validate_python(Decimal('9999999999999999.999999999999999999')) == Decimal( @@ -491,20 +487,20 @@ def test_validate_max_digits_and_decimal_places_edge_case() -> None: def test_str_validation_w_strict() -> None: - s = SchemaValidator(schema=core_schema.decimal_schema(strict=True)) + s = SchemaValidator(core_schema.decimal_schema(strict=True)) with pytest.raises(ValidationError): assert s.validate_python('1.23') def test_str_validation_w_lax() -> None: - s = SchemaValidator(schema=core_schema.decimal_schema(strict=False)) + s = SchemaValidator(core_schema.decimal_schema(strict=False)) assert s.validate_python('1.23') == Decimal('1.23') def test_union_with_str_prefers_str() -> None: - s = SchemaValidator(schema=core_schema.union_schema([core_schema.decimal_schema(), core_schema.str_schema()])) + s = SchemaValidator(core_schema.union_schema([core_schema.decimal_schema(), core_schema.str_schema()])) assert s.validate_python('1.23') == '1.23' assert s.validate_python(1.23) == Decimal('1.23') diff --git a/tests/validators/test_definitions.py b/tests/validators/test_definitions.py index 55412f401..1c730ee6f 100644 --- a/tests/validators/test_definitions.py +++ b/tests/validators/test_definitions.py @@ -7,7 +7,7 @@ def test_list_with_def(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.list_schema(core_schema.definition_reference_schema('foobar')), [core_schema.int_schema(ref='foobar')], ) @@ -20,7 +20,7 @@ def test_list_with_def(): def test_ignored_def(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.list_schema(core_schema.int_schema()), [core_schema.int_schema(ref='foobar')] ) ) @@ -30,14 +30,14 @@ def test_ignored_def(): def test_extract_used_refs_ignores_metadata(): - v = SchemaValidator(schema=core_schema.any_schema(metadata={'type': 'definition-ref'})) + v = SchemaValidator(core_schema.any_schema(metadata={'type': 'definition-ref'})) assert v.validate_python([1, 2, 3]) == [1, 2, 3] assert plain_repr(v).endswith('definitions=[],cache_strings=True)') def test_check_ref_used_ignores_metadata(): v = SchemaValidator( - schema=core_schema.list_schema( + core_schema.list_schema( core_schema.int_schema(metadata={'type': 'definition-ref', 'schema_ref': 'foobar'}), ref='foobar' ) ) @@ -61,7 +61,7 @@ def test_def_error(): def test_dict_repeat(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.dict_schema( core_schema.definition_reference_schema('foobar'), core_schema.definition_reference_schema('foobar') ), @@ -108,7 +108,7 @@ def test_repeat_after(): def test_deep(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field(core_schema.int_schema()), 'b': core_schema.typed_dict_field( @@ -130,7 +130,7 @@ def test_deep(): def test_use_after(): v = SchemaValidator( - schema=core_schema.tuple_positional_schema( + core_schema.tuple_positional_schema( [ core_schema.definitions_schema( core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')] @@ -144,7 +144,7 @@ def test_use_after(): def test_definition_chain(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('foo'), [core_schema.definition_reference_schema(ref='foo', schema_ref='bar'), core_schema.int_schema(ref='bar')], ) @@ -154,7 +154,7 @@ def test_definition_chain(): def test_forwards_get_default_value(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('foo'), [core_schema.with_default_schema(core_schema.int_schema(), default=1, ref='foo')], ) diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py index 46eefe15c..77368c61a 100644 --- a/tests/validators/test_definitions_recursive.py +++ b/tests/validators/test_definitions_recursive.py @@ -16,7 +16,7 @@ def test_branch_nullable(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( {'type': 'definition-ref', 'schema_ref': 'Branch'}, [ { @@ -54,7 +54,7 @@ def test_branch_nullable(): def test_unused_ref(): v = SchemaValidator( - schema=cs.typed_dict_schema( + cs.typed_dict_schema( fields={ 'name': cs.typed_dict_field(schema=cs.str_schema()), 'other': cs.typed_dict_field(schema=cs.int_schema()), @@ -67,7 +67,7 @@ def test_unused_ref(): def test_nullable_error(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.typed_dict_schema( @@ -110,7 +110,7 @@ def test_nullable_error(): def test_list(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('BranchList'), [ core_schema.typed_dict_schema( @@ -151,7 +151,7 @@ class Bar: """ v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('Foo'), [ core_schema.typed_dict_schema( @@ -204,7 +204,7 @@ class Branch: branch: Optional['Branch'] v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.model_schema( @@ -263,7 +263,7 @@ def test_invalid_schema(): def test_outside_parent(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.typed_dict_schema( { 'tuple1': core_schema.typed_dict_field(core_schema.definition_reference_schema('tuple-iis')), @@ -286,7 +286,7 @@ def test_outside_parent(): def test_recursion_branch(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.typed_dict_schema( @@ -330,7 +330,7 @@ def test_recursion_branch(): def test_recursion_branch_from_attributes(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.model_fields_schema( @@ -379,7 +379,7 @@ def test_recursion_branch_from_attributes(): def test_definition_list(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('the-list'), [core_schema.list_schema(core_schema.definition_reference_schema('the-list'), ref='the-list')], ) @@ -406,7 +406,7 @@ def test_definition_list(): @pytest.fixture(scope='module') def multiple_tuple_schema() -> SchemaValidator: return SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.typed_dict_schema( { 'f1': core_schema.typed_dict_field(core_schema.definition_reference_schema('t')), @@ -509,7 +509,7 @@ def wrap_func(input_value, validator, info): return validator(input_value) + (42,) v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('wrapper'), [ core_schema.with_info_wrap_validator_function( @@ -543,7 +543,7 @@ def wrap_func(input_value, validator, info): def test_union_ref_strictness(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field(core_schema.definition_reference_schema('int-type')), @@ -571,7 +571,7 @@ def test_union_ref_strictness(): def test_union_container_strictness(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.typed_dict_schema( { 'b': core_schema.typed_dict_field( @@ -600,7 +600,7 @@ def test_union_container_strictness(): @pytest.mark.parametrize('strict', [True, False], ids=lambda s: f'strict={s}') def test_union_cycle(strict: bool): s = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('root-schema'), [ core_schema.union_schema( @@ -641,7 +641,7 @@ def f(input_value, info): return input_value + ' Changed' v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('root-schema'), [ core_schema.union_schema( @@ -689,7 +689,7 @@ def f(input_value, info): return f'f-{int(count) + 1}' v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('root-schema'), [ core_schema.union_schema( @@ -722,7 +722,7 @@ def f(input_value, info): def test_many_uses_of_ref(): # check we can safely exceed RECURSION_GUARD_LIMIT without upsetting the recursion guard v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.typed_dict_schema( @@ -798,7 +798,7 @@ def test_recursive_definitions_schema(pydantic_version) -> None: ], ) - v = SchemaValidator(schema=s) + v = SchemaValidator(s) assert v.validate_python({'b': [{'a': []}]}) == {'b': [{'a': []}]} @@ -827,7 +827,7 @@ def test_unsorted_definitions_schema() -> None: ], ) - v = SchemaValidator(schema=s) + v = SchemaValidator(s) assert v.validate_python({'x': 123}) == {'x': 123} @@ -862,7 +862,7 @@ class Model: ], ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) data = [Model(x=[Model(x=[])])] instance = Model(x=[]) @@ -910,7 +910,7 @@ def test_cyclic_data() -> None: ], ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) with pytest.raises(ValidationError) as exc_info: validator.validate_python(cyclic_data) @@ -960,7 +960,7 @@ def test_cyclic_data_threeway() -> None: ], ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) with pytest.raises(ValidationError) as exc_info: validator.validate_python(cyclic_data) @@ -998,7 +998,7 @@ def test_complex_recursive_type() -> None: ], ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) with pytest.raises(ValidationError) as exc_info: validator.validate_python({'a': datetime.date(year=1992, month=12, day=11)}) @@ -1089,4 +1089,4 @@ def test_no_exponential_blowup(): ], ) - SchemaValidator(schema=schema) + SchemaValidator(schema) diff --git a/tests/validators/test_dict.py b/tests/validators/test_dict.py index d9c4d2f7c..bff6cf5a3 100644 --- a/tests/validators/test_dict.py +++ b/tests/validators/test_dict.py @@ -39,7 +39,7 @@ def test_dict(py_and_json: PyAndJson): ids=repr, ) def test_dict_cases(input_value, expected): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.str_schema(), values_schema=cs.str_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema(), values_schema=cs.str_schema())) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -63,7 +63,7 @@ def test_dict_value_error(py_and_json: PyAndJson): def test_dict_error_key_int(): - v = SchemaValidator(schema=cs.dict_schema(values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(values_schema=cs.int_schema())) with pytest.raises(ValidationError, match='Input should be a valid integer') as exc_info: v.validate_python({1: 2, 3: 'wrong', -4: 'wrong2'}) # insert_assert(exc_info.value.errors(include_url=False)) @@ -84,7 +84,7 @@ def test_dict_error_key_int(): def test_dict_error_key_other(): - v = SchemaValidator(schema=cs.dict_schema(values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(values_schema=cs.int_schema())) with pytest.raises(ValidationError, match='Input should be a valid integer') as exc_info: v.validate_python({1: 2, (1, 2): 'wrong'}) assert exc_info.value.errors(include_url=False) == [ @@ -98,8 +98,8 @@ def test_dict_error_key_other(): def test_dict_any_value(): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.str_schema())) - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.str_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema())) assert v.validate_python({'1': 1, '2': 'a', '3': None}) == {'1': 1, '2': 'a', '3': None} @@ -117,15 +117,15 @@ def __iter__(self): def __len__(self): return len(self._d) - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) assert v.validate_python(MyMapping({'1': 2, 3: '4'})) == {1: 2, 3: 4} - v = SchemaValidator(schema=cs.dict_schema(strict=True, keys_schema=cs.int_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(strict=True, keys_schema=cs.int_schema(), values_schema=cs.int_schema())) with pytest.raises(ValidationError, match='Input should be a valid dictionary'): v.validate_python(MyMapping({'1': 2, 3: '4'})) def test_key_error(): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) assert v.validate_python({'1': True}) == {1: 1} with pytest.raises(ValidationError, match=re.escape('x.[key]\n Input should be a valid integer')) as exc_info: v.validate_python({'x': 1}) @@ -150,7 +150,7 @@ def __iter__(self): def __len__(self): return 1 - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(BadMapping()) @@ -180,7 +180,7 @@ def __getitem__(self, key): def __len__(self): return 1 - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(BadMapping()) @@ -218,7 +218,7 @@ def __len__(self): ], ) def test_dict_length_constraints(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator(schema=cs.dict_schema(**kwargs)) + v = SchemaValidator(cs.dict_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -227,7 +227,7 @@ def test_dict_length_constraints(kwargs: dict[str, Any], input_value, expected): def test_json_dict(): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) assert v.validate_json('{"1": 2, "3": 4}') == {1: 2, 3: 4} with pytest.raises(ValidationError) as exc_info: v.validate_json('1') @@ -237,14 +237,12 @@ def test_json_dict(): def test_dict_complex_key(): - v = SchemaValidator( - schema=cs.dict_schema(keys_schema=cs.complex_schema(strict=True), values_schema=cs.str_schema()) - ) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.complex_schema(strict=True), values_schema=cs.str_schema())) assert v.validate_python({complex(1, 2): '1'}) == {complex(1, 2): '1'} with pytest.raises(ValidationError, match='Input should be an instance of complex'): assert v.validate_python({'1+2j': b'1'}) == {complex(1, 2): '1'} - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.complex_schema(), values_schema=cs.str_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.complex_schema(), values_schema=cs.str_schema())) with pytest.raises( ValidationError, match='Input should be a valid python complex object, a number, or a valid complex string' ): @@ -252,7 +250,7 @@ def test_dict_complex_key(): def test_json_dict_complex_key(): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.complex_schema(), values_schema=cs.int_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.complex_schema(), values_schema=cs.int_schema())) assert v.validate_json('{"1+2j": 2, "-3": 4}') == {complex(1, 2): 2, complex(-3, 0): 4} assert v.validate_json('{"1+2j": 2, "infj": 4}') == {complex(1, 2): 2, complex(0, float('inf')): 4} with pytest.raises(ValidationError, match='Input should be a valid complex string'): diff --git a/tests/validators/test_enums.py b/tests/validators/test_enums.py index 94df99eef..83e286417 100644 --- a/tests/validators/test_enums.py +++ b/tests/validators/test_enums.py @@ -13,7 +13,7 @@ class MyEnum(Enum): a = 1 b = 2 - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -43,13 +43,13 @@ class MyEnum(Enum): with pytest.raises(ValidationError, match='type=enum'): v.validate_json('"1"', strict=True) - v_strict = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True)) + v_strict = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True)) assert v_strict.validate_python(MyEnum.a) is MyEnum.a with pytest.raises(ValidationError, match=re.escape(e)): v_strict.validate_python(1, strict=True) - v_strict_f = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True)) + v_strict_f = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True)) assert v_strict_f.validate_python(MyEnum.a) is MyEnum.a with pytest.raises(ValidationError, match=re.escape(e)): @@ -61,7 +61,7 @@ class MyEnum(int, Enum): a = 1 b = 2 - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='int')) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='int')) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -95,7 +95,7 @@ class MyEnum(str, Enum): a = 'x' b = 'y' - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='str')) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='str')) # debug(v) assert v.validate_python('x') is MyEnum.a @@ -126,7 +126,7 @@ class MyEnum(float, Enum): b = 2.5 c = 3.0 - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='float')) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='float')) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -169,9 +169,7 @@ def _missing_(cls, v): assert MyEnum(2) is MyEnum.b assert MyEnum(3) is MyEnum.b - v = SchemaValidator( - schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_) - ) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_)) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -197,9 +195,7 @@ def _missing_(cls, v): with pytest.raises(ValueError, match='3 is not a valid'): MyEnum(3) - v = SchemaValidator( - schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_) - ) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_)) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -231,9 +227,7 @@ def _missing_(cls, v): with pytest.raises(TypeError, match=e): MyEnum(3) - v = SchemaValidator( - schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_) - ) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_)) with pytest.raises(TypeError, match=e): v.validate_python(3) @@ -244,7 +238,7 @@ class MyEnum(int, Enum): b = 2 v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( [ core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_), core_schema.int_schema(), @@ -262,7 +256,7 @@ class MyEnum(Enum): b = [2] assert MyEnum([1]) is MyEnum.a - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) assert v.validate_python(MyEnum.a) is MyEnum.a assert v.validate_python([1]) is MyEnum.a assert v.validate_python([2]) is MyEnum.b @@ -273,7 +267,7 @@ class MyEnum(Enum): pass with pytest.raises(SchemaError, match='`members` should have length > 0'): - SchemaValidator(schema=core_schema.enum_schema(MyEnum, [])) + SchemaValidator(core_schema.enum_schema(MyEnum, [])) def test_enum_with_str_subclass() -> None: @@ -281,7 +275,7 @@ class MyEnum(Enum): a = 'a' b = 'b' - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) assert v.validate_python(MyEnum.a) is MyEnum.a assert v.validate_python('a') is MyEnum.a @@ -299,7 +293,7 @@ class MyEnum(Enum): a = 1 b = 2 - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) assert v.validate_python(MyEnum.a) is MyEnum.a assert v.validate_python(1) is MyEnum.a @@ -317,7 +311,7 @@ class MyEnum(int, Enum): a = 1 b = 2 - v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) assert v.validate_python(1.0) is MyEnum.a @@ -328,7 +322,7 @@ class MyFlags(IntFlag): ON = 1 v = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.enum_schema(MyFlags, list(MyFlags.__members__.values())), default=MyFlags.OFF ) ) @@ -346,9 +340,7 @@ class ColorEnum(IntEnum): BLUE = 1 << 64 v = SchemaValidator( - schema=core_schema.with_default_schema( - schema=core_schema.enum_schema(ColorEnum, list(ColorEnum.__members__.values())) - ) + core_schema.with_default_schema(schema=core_schema.enum_schema(ColorEnum, list(ColorEnum.__members__.values()))) ) assert v.validate_python(ColorEnum.GREEN) is ColorEnum.GREEN @@ -367,14 +359,14 @@ class MyIntEnum(IntEnum): VALUE = value v = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) ) v_int = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.enum_schema(MyIntEnum, list(MyIntEnum.__members__.values())), default=MyIntEnum.VALUE, ) @@ -404,7 +396,7 @@ class MyEnum(Enum): THIRD_VALUE = 'Py03' v = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -420,7 +412,7 @@ class MyEnum(Enum): VALUE = '1' v = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -435,7 +427,7 @@ class MyEnum(Enum): VALUE = 1 v = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -460,7 +452,7 @@ def __init__(self, value): self.value = value v = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -490,7 +482,7 @@ def __new__(cls, species: str, sound: str): return obj - v = SchemaValidator(schema=core_schema.enum_schema(Animal, list(Animal.__members__.values()))) + v = SchemaValidator(core_schema.enum_schema(Animal, list(Animal.__members__.values()))) assert v.validate_python('cat') is Animal.CAT assert v.validate_python('meow') is Animal.CAT assert v.validate_python('dog') is Animal.DOG diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py index 7ee68fa43..8a0235ed5 100644 --- a/tests/validators/test_float.py +++ b/tests/validators/test_float.py @@ -201,23 +201,23 @@ def test_union_float_simple(py_and_json: PyAndJson): def test_float_repr(): - v = SchemaValidator(schema=cs.float_schema()) + v = SchemaValidator(cs.float_schema()) assert ( plain_repr(v) == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:false,allow_inf_nan:true}),definitions=[],cache_strings=True)' ) - v = SchemaValidator(schema=cs.float_schema(strict=True)) + v = SchemaValidator(cs.float_schema(strict=True)) assert ( plain_repr(v) == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:true,allow_inf_nan:true}),definitions=[],cache_strings=True)' ) - v = SchemaValidator(schema=cs.float_schema(multiple_of=7)) + v = SchemaValidator(cs.float_schema(multiple_of=7)) assert plain_repr(v).startswith('SchemaValidator(title="constrained-float",validator=ConstrainedFloat(') @pytest.mark.parametrize('input_value,expected', [(Decimal('1.23'), 1.23), (Decimal('1'), 1.0)]) def test_float_not_json(input_value, expected): - v = SchemaValidator(schema=cs.float_schema()) + v = SchemaValidator(cs.float_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -316,7 +316,7 @@ def test_non_finite_json_values(py_and_json: PyAndJson, input_value, allow_inf_n ], ) def test_non_finite_float_values(strict, input_value, allow_inf_nan, expected): - v = SchemaValidator(schema=cs.float_schema(allow_inf_nan=allow_inf_nan, strict=strict)) + v = SchemaValidator(cs.float_schema(allow_inf_nan=allow_inf_nan, strict=strict)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -346,7 +346,7 @@ def test_non_finite_float_values(strict, input_value, allow_inf_nan, expected): ], ) def test_non_finite_constrained_float_values(input_value, allow_inf_nan, expected): - v = SchemaValidator(schema=cs.float_schema(allow_inf_nan=allow_inf_nan, gt=0)) + v = SchemaValidator(cs.float_schema(allow_inf_nan=allow_inf_nan, gt=0)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -384,12 +384,12 @@ def test_non_finite_constrained_float_values(input_value, allow_inf_nan, expecte ], ) def test_validate_scientific_notation_from_json(input_value, expected): - v = SchemaValidator(schema=cs.float_schema()) + v = SchemaValidator(cs.float_schema()) assert v.validate_json(input_value) == expected def test_string_with_underscores() -> None: - v = SchemaValidator(schema=cs.float_schema()) + v = SchemaValidator(cs.float_schema()) assert v.validate_python('1_000_000.0') == 1_000_000.0 assert v.validate_json('"1_000_000.0"') == 1_000_000.0 @@ -401,7 +401,7 @@ def test_string_with_underscores() -> None: def test_allow_inf_nan_true_json() -> None: - v = SchemaValidator(schema=core_schema.float_schema()) + v = SchemaValidator(core_schema.float_schema()) assert v.validate_json('123') == 123 assert v.validate_json('NaN') == IsFloatNan() @@ -414,7 +414,7 @@ def test_allow_inf_nan_true_json() -> None: def test_allow_inf_nan_false_json() -> None: - v = SchemaValidator(schema=core_schema.float_schema(), config=core_schema.CoreConfig(allow_inf_nan=False)) + v = SchemaValidator(core_schema.float_schema(), config=core_schema.CoreConfig(allow_inf_nan=False)) assert v.validate_json('123') == 123 with pytest.raises(ValidationError) as exc_info1: diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py index 27bef1330..e2fe20fc7 100644 --- a/tests/validators/test_frozenset.py +++ b/tests/validators/test_frozenset.py @@ -26,14 +26,14 @@ def test_frozenset_ints_both(py_and_json: PyAndJson, input_value, expected): [([], frozenset()), ([1, '2', b'3'], {1, '2', b'3'}), (frozenset([1, '2', b'3']), {1, '2', b'3'})], ) def test_frozenset_any(input_value, expected): - v = SchemaValidator(schema=cs.frozenset_schema()) + v = SchemaValidator(cs.frozenset_schema()) output = v.validate_python(input_value) assert output == expected assert isinstance(output, frozenset) def test_no_copy(): - v = SchemaValidator(schema=cs.frozenset_schema()) + v = SchemaValidator(cs.frozenset_schema()) input_value = frozenset([1, 2, 3]) output = v.validate_python(input_value) assert output == input_value @@ -85,7 +85,7 @@ def test_frozenset_no_validators_both(py_and_json: PyAndJson, input_value, expec ) @pytest.mark.thread_unsafe # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14 def test_frozenset_ints_python(input_value, expected): - v = SchemaValidator(schema=cs.frozenset_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema())) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -100,14 +100,14 @@ def test_frozenset_ints_python(input_value, expected): [(frozenset([1, 2.5, '3']), {1, 2.5, '3'}), ([1, 2.5, '3'], {1, 2.5, '3'}), ([(1, 2), (3, 4)], {(1, 2), (3, 4)})], ) def test_frozenset_no_validators_python(input_value, expected): - v = SchemaValidator(schema=cs.frozenset_schema()) + v = SchemaValidator(cs.frozenset_schema()) output = v.validate_python(input_value) assert output == expected assert isinstance(output, frozenset) def test_frozenset_multiple_errors(): - v = SchemaValidator(schema=cs.frozenset_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(['a', (1, 2), []]) assert exc_info.value.errors(include_url=False) == [ @@ -169,7 +169,7 @@ def generate_repeats(): ) @pytest.mark.thread_unsafe # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14 def test_frozenset_kwargs_python(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator(schema=cs.frozenset_schema(**kwargs)) + v = SchemaValidator(cs.frozenset_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -181,7 +181,7 @@ def test_frozenset_kwargs_python(kwargs: dict[str, Any], input_value, expected): @pytest.mark.parametrize('input_value,expected', [({1, 2, 3}, {1, 2, 3}), ([1, 2, 3], [1, 2, 3])]) def test_union_frozenset_list(input_value, expected): - v = SchemaValidator(schema=cs.union_schema(choices=[cs.frozenset_schema(), cs.list_schema()])) + v = SchemaValidator(cs.union_schema(choices=[cs.frozenset_schema(), cs.list_schema()])) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -219,7 +219,7 @@ def test_union_frozenset_list(input_value, expected): ) def test_union_frozenset_int_frozenset_str(input_value, expected): v = SchemaValidator( - schema=cs.union_schema( + cs.union_schema( choices=[ cs.frozenset_schema(items_schema=cs.int_schema(strict=True)), cs.frozenset_schema(items_schema=cs.str_schema(strict=True)), @@ -244,7 +244,7 @@ def test_frozenset_as_dict_keys(py_and_json: PyAndJson): def test_repr(): - v = SchemaValidator(schema=cs.frozenset_schema(strict=True, min_length=42)) + v = SchemaValidator(cs.frozenset_schema(strict=True, min_length=42)) assert plain_repr(v) == ( 'SchemaValidator(' 'title="frozenset[any]",' @@ -266,7 +266,7 @@ def gen(error: bool): raise RuntimeError('my error') yield 3 - v = SchemaValidator(schema=cs.frozenset_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema())) r = v.validate_python(gen(False)) assert r == {1, 2, 3} assert isinstance(r, frozenset) @@ -295,7 +295,7 @@ def gen(error: bool): ], ) def test_frozenset_from_dict_items(input_value, items_schema, expected): - v = SchemaValidator(schema=cs.frozenset_schema(items_schema=items_schema)) + v = SchemaValidator(cs.frozenset_schema(items_schema=items_schema)) output = v.validate_python(input_value) assert isinstance(output, frozenset) assert output == expected @@ -337,7 +337,7 @@ def test_frozenset_from_dict_items(input_value, items_schema, expected): ], ) def test_frozenset_fail_fast(fail_fast, expected): - v = SchemaValidator(schema=cs.frozenset_schema(items_schema=cs.int_schema(), fail_fast=fail_fast)) + v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema(), fail_fast=fail_fast)) with pytest.raises(ValidationError) as exc_info: v.validate_python([1, 'not-num', 'again']) diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py index 5d204847e..562687268 100644 --- a/tests/validators/test_function.py +++ b/tests/validators/test_function.py @@ -26,7 +26,7 @@ def test_function_before(): def f(input_value, _info): return input_value + ' Changed' - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -35,7 +35,7 @@ def test_function_before_no_info(): def f(input_value): return input_value + ' Changed' - v = SchemaValidator(schema=core_schema.no_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.no_info_before_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -44,7 +44,7 @@ def test_function_before_raise(): def f(input_value, info): raise ValueError('foobar') - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(ValidationError) as exc_info: assert v.validate_python('input value') == 'input value Changed' @@ -65,7 +65,7 @@ def my_function(input_value, info): return input_value + 'x' v = SchemaValidator( - schema={ + { 'type': 'function-before', 'function': {'type': 'with-info', 'function': my_function}, 'schema': cs.str_schema(max_length=5), @@ -100,7 +100,7 @@ def my_function(input_value, info): return input_value + 'x' v = SchemaValidator( - schema={ + { 'type': 'function-before', 'function': {'type': 'with-info', 'function': my_function}, 'schema': cs.str_schema(max_length=5), @@ -119,7 +119,7 @@ def f(input_value, info): return input_value v = SchemaValidator( - schema={ + { 'type': 'function-before', 'function': {'type': 'with-info', 'function': f}, 'schema': cs.typed_dict_schema( @@ -161,9 +161,7 @@ def f(input_value, info: core_schema.ValidationInfo): assert str(info) == expected_repr return input_value - v = SchemaValidator( - schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema()), config=config - ) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()), config=config) assert v.validate_python('input value', **kwargs) == 'input value' @@ -172,7 +170,7 @@ def test_function_wrap(): def f(input_value, validator, info): return validator(input_value=input_value) + ' Changed' - v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -181,7 +179,7 @@ def test_function_wrap_no_info(): def f(input_value, validator): return validator(input_value=input_value) + ' Changed' - v = SchemaValidator(schema=core_schema.no_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.no_info_wrap_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -191,7 +189,7 @@ def f(input_value, validator, info): assert repr(validator) == str(validator) return plain_repr(validator) - v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) assert ( v.validate_python('input value') @@ -203,7 +201,7 @@ def test_function_wrap_str(): def f(input_value, validator, info): return plain_repr(validator) - v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) assert ( v.validate_python('input value') @@ -228,7 +226,7 @@ def f(input_value, validator, info): assert str(e).startswith('1 validation error for ValidatorCallable\n') raise e - v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) assert v.validate_python('42') == 84 with pytest.raises(ValidationError) as exc_info: @@ -260,9 +258,7 @@ def f(input_value, validator, info): assert str(e).startswith('1 validation error for ValidatorCallable\n') raise e - v = SchemaValidator( - schema=core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()), config=config - ) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()), config=config) with pytest.raises( ValidationError, @@ -275,7 +271,7 @@ def test_function_wrap_location(): def f(input_value, validator, info): return validator(input_value, outer_location='foo') + 2 - v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) assert v.validate_python(4) == 6 with pytest.raises(ValidationError) as exc_info: @@ -295,7 +291,7 @@ def test_function_wrap_invalid_location(): def f(input_value, validator, info): return validator(input_value, ('4',)) + 2 - v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) assert v.validate_python(4) == 6 @@ -316,7 +312,7 @@ def test_function_after(): def f(input_value, _info): return input_value + ' Changed' - v = SchemaValidator(schema=core_schema.with_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -325,7 +321,7 @@ def test_function_no_info(): def f(input_value): return input_value + ' Changed' - v = SchemaValidator(schema=core_schema.no_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.no_info_after_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -334,7 +330,7 @@ def test_function_after_raise(): def f(input_value, info): raise ValueError('foobar') - v = SchemaValidator(schema=core_schema.with_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema())) with pytest.raises(ValidationError) as exc_info: assert v.validate_python('input value') == 'input value Changed' @@ -362,9 +358,7 @@ def test_function_after_error_hide_input(config, input_str): def f(input_value, info): raise ValueError('foobar') - v = SchemaValidator( - schema=core_schema.with_info_after_validator_function(f, core_schema.str_schema()), config=config - ) + v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()), config=config) with pytest.raises(ValidationError, match=re.escape(f'Value error, foobar [{input_str}]')): v.validate_python('input value') @@ -379,7 +373,7 @@ def f(input_value, info): return input_value + ' Changed' v = SchemaValidator( - schema=cs.typed_dict_schema( + cs.typed_dict_schema( fields={ 'test_field': cs.typed_dict_field( schema={ @@ -405,7 +399,7 @@ def f(input_value, info: core_schema.ValidationInfo): f_kwargs = deepcopy_info(info) return input_value + ' Changed' - v = SchemaValidator(schema=core_schema.with_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema())) assert v.validate_python(b'abc') == 'abc Changed' assert f_kwargs == {'data': None, 'config': None, 'context': None, 'field_name': None} @@ -415,7 +409,7 @@ def test_function_plain(): def f(input_value, _info): return input_value * 2 - v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) assert v.validate_python(1) == 2 assert v.validate_python('x') == 'xx' @@ -425,7 +419,7 @@ def test_function_plain_no_info(): def f(input_value): return input_value * 2 - v = SchemaValidator(schema=core_schema.no_info_plain_validator_function(f)) + v = SchemaValidator(core_schema.no_info_plain_validator_function(f)) assert v.validate_python(1) == 2 assert v.validate_python('x') == 'xx' @@ -455,7 +449,7 @@ def __init__(self): self.__pydantic_extra__ = None # this attribute must be present for validate_assignment v = SchemaValidator( - schema=core_schema.no_info_after_validator_function( + core_schema.no_info_after_validator_function( f, core_schema.model_schema( Model, core_schema.model_fields_schema({'field_a': core_schema.model_field(core_schema.str_schema())}) @@ -480,7 +474,7 @@ def test_function_wrong_sig(): def f(input_value): return input_value + ' Changed' - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) # exception messages differ between python and pypy if platform.python_implementation() == 'PyPy': @@ -504,7 +498,7 @@ def __validate__(cls, input_value, info): return Foobar(input_value * 2) v = SchemaValidator( - schema={ + { 'type': 'function-after', 'function': {'type': 'with-info', 'function': Foobar.__validate__}, 'schema': cs.str_schema(), @@ -531,7 +525,7 @@ def test_raise_assertion_error(): def f(input_value, info): raise AssertionError('foobar') - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python('input value') @@ -551,7 +545,7 @@ def test_raise_assertion_error_plain(): def f(input_value, info): raise AssertionError - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python('input value') @@ -576,7 +570,7 @@ def __str__(self): def f(input_value, info): raise MyError() - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(RuntimeError, match='internal error'): v.validate_python('input value') @@ -586,7 +580,7 @@ def test_raise_type_error(): def f(input_value, info): raise TypeError('foobar') - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(TypeError, match='^foobar$'): v.validate_python('input value') @@ -605,7 +599,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -631,7 +625,7 @@ def f(input_value: str, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -657,7 +651,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f, field_name='x'))} @@ -679,7 +673,7 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor return f'input: {val(input_value)}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -709,7 +703,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -733,7 +727,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -758,7 +752,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f))} @@ -779,7 +773,7 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor return f'input: {val(input_value)}' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -804,7 +798,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value}' v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field(core_schema.int_schema()), 'b': core_schema.typed_dict_field(core_schema.int_schema()), @@ -861,7 +855,7 @@ def f(input_value: Any, *args: Any) -> Any: return input_value v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, { 'type': f'function-{mode}', @@ -893,7 +887,7 @@ def f(v: Any, info: core_schema.ValidationInfo) -> Any: calls.append(info.mode) return v - v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) assert v.validate_python(1) == 1 assert calls == ['python'] calls.clear() @@ -901,7 +895,7 @@ def f(v: Any, info: core_schema.ValidationInfo) -> Any: assert calls == ['json'] calls.clear() - v = SchemaValidator(schema=core_schema.with_info_after_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.int_schema())) assert v.validate_python(1) == 1 assert calls == ['python'] calls.clear() @@ -913,7 +907,7 @@ def f_w(v: Any, handler: core_schema.ValidatorFunctionWrapHandler, info: core_sc calls.append(info.mode) return handler(v) - v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f_w, core_schema.int_schema())) + v = SchemaValidator(core_schema.with_info_wrap_validator_function(f_w, core_schema.int_schema())) assert v.validate_python(1) == 1 assert calls == ['python'] calls.clear() @@ -930,7 +924,7 @@ def sample_repr(v: Any, info: core_schema.ValidationInfo) -> Any: return v v = SchemaValidator( - schema=core_schema.chain_schema( + core_schema.chain_schema( [ core_schema.with_info_plain_validator_function(sample_repr), core_schema.with_info_plain_validator_function(sample_repr, field_name='x'), @@ -959,7 +953,7 @@ def identity(v): return v schema = core_schema.no_info_after_validator_function(identity, core_schema.date_schema(strict=True)) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) # this input should be valid JSON input, but isn't valid Python input, so # the following tests will pass if the after_validator is not diff --git a/tests/validators/test_generator.py b/tests/validators/test_generator.py index 84d156235..411b2202e 100644 --- a/tests/validators/test_generator.py +++ b/tests/validators/test_generator.py @@ -151,7 +151,7 @@ def gen(): def test_generator_too_long(): - v = SchemaValidator(schema=cs.generator_schema(items_schema=cs.int_schema(), max_length=2)) + v = SchemaValidator(cs.generator_schema(items_schema=cs.int_schema(), max_length=2)) validating_iterator = v.validate_python(gen()) @@ -175,7 +175,7 @@ def test_generator_too_long(): def test_generator_too_short(): - v = SchemaValidator(schema=cs.generator_schema(items_schema=cs.int_schema(), min_length=4)) + v = SchemaValidator(cs.generator_schema(items_schema=cs.int_schema(), min_length=4)) validating_iterator = v.validate_python(gen()) diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py index b5327fd2e..ffd8a85c6 100644 --- a/tests/validators/test_int.py +++ b/tests/validators/test_int.py @@ -142,7 +142,7 @@ def test_int_py_and_json(py_and_json: PyAndJson, input_value, expected): ids=repr, ) def test_int(input_value, expected): - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -188,7 +188,7 @@ def test_int(input_value, expected): ], ) def test_positive_int(input_value, expected): - v = SchemaValidator(schema=cs.int_schema(gt=0)) + v = SchemaValidator(cs.int_schema(gt=0)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -209,7 +209,7 @@ def test_positive_int(input_value, expected): ], ) def test_negative_int(input_value, expected): - v = SchemaValidator(schema=cs.int_schema(lt=0)) + v = SchemaValidator(cs.int_schema(lt=0)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -237,7 +237,7 @@ def test_negative_int(input_value, expected): ], ) def test_positive_json(input_value, expected): - v = SchemaValidator(schema=cs.int_schema(gt=0)) + v = SchemaValidator(cs.int_schema(gt=0)) json_input = json.dumps(input_value) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -259,7 +259,7 @@ def test_positive_json(input_value, expected): ], ) def test_negative_json(input_value, expected): - v = SchemaValidator(schema=cs.int_schema(lt=0)) + v = SchemaValidator(cs.int_schema(lt=0)) json_input = json.dumps(input_value) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -384,22 +384,22 @@ def test_union_int_simple(py_and_json: PyAndJson): def test_int_repr(): - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) assert ( plain_repr(v) == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:false}),definitions=[],cache_strings=True)' ) - v = SchemaValidator(schema=cs.int_schema(strict=True)) + v = SchemaValidator(cs.int_schema(strict=True)) assert ( plain_repr(v) == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:true}),definitions=[],cache_strings=True)' ) - v = SchemaValidator(schema=cs.int_schema(multiple_of=7)) + v = SchemaValidator(cs.int_schema(multiple_of=7)) assert plain_repr(v).startswith('SchemaValidator(title="constrained-int",validator=ConstrainedInt(') def test_too_long(pydantic_version): - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) with pytest.raises(ValidationError) as exc_info: v.validate_python('1' * 4301) @@ -422,7 +422,7 @@ def test_too_long(pydantic_version): def test_long_python(): - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) s = v.validate_python('1' * 4_300) assert s == int('1' * 4_300) @@ -435,7 +435,7 @@ def test_long_python(): def test_long_python_inequality(): - v = SchemaValidator(schema=cs.int_schema(gt=0, lt=int('1' * 4_300) - 5)) + v = SchemaValidator(cs.int_schema(gt=0, lt=int('1' * 4_300) - 5)) s = str(int('1' * 4_300) - 6) s = v.validate_python(s) @@ -447,7 +447,7 @@ def test_long_python_inequality(): def test_long_json(): - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) assert v.validate_json('-' + '1' * 400) == int('-' + '1' * 400) @@ -464,7 +464,7 @@ def test_int_key(py_and_json: PyAndJson): def test_string_as_int_with_underscores() -> None: - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) assert v.validate_python('1_000_000') == 1_000_000 assert v.validate_json('"1_000_000"') == 1_000_000 @@ -480,7 +480,7 @@ class IntSubclass(int): def test_int_subclass() -> None: - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) v_lax = v.validate_python(IntSubclass(1)) assert v_lax == 1 assert type(v_lax) == int @@ -495,7 +495,7 @@ def test_int_subclass() -> None: def test_int_subclass_constraint() -> None: - v = SchemaValidator(schema=cs.int_schema(gt=0)) + v = SchemaValidator(cs.int_schema(gt=0)) v_lax = v.validate_python(IntSubclass(1)) assert v_lax == 1 assert type(v_lax) == int @@ -512,14 +512,14 @@ class FloatSubclass(float): def test_float_subclass() -> None: - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) v_lax = v.validate_python(FloatSubclass(1)) assert v_lax == 1 assert type(v_lax) == int def test_int_subclass_plain_enum() -> None: - v = SchemaValidator(schema=cs.int_schema()) + v = SchemaValidator(cs.int_schema()) from enum import Enum @@ -532,7 +532,7 @@ class PlainEnum(Enum): def test_allow_inf_nan_true_json() -> None: - v = SchemaValidator(schema=core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=True)) + v = SchemaValidator(core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=True)) assert v.validate_json('123') == 123 with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'): @@ -544,7 +544,7 @@ def test_allow_inf_nan_true_json() -> None: def test_allow_inf_nan_false_json() -> None: - v = SchemaValidator(schema=core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=False)) + v = SchemaValidator(core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=False)) assert v.validate_json('123') == 123 with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'): @@ -556,7 +556,7 @@ def test_allow_inf_nan_false_json() -> None: def test_json_big_int_key(): - v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.str_schema())) + v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.str_schema())) big_integer = 1433352099889938534014333520998899385340 assert v.validate_python({big_integer: 'x'}) == {big_integer: 'x'} assert v.validate_json('{"' + str(big_integer) + '": "x"}') == {big_integer: 'x'} diff --git a/tests/validators/test_is_instance.py b/tests/validators/test_is_instance.py index b1778e093..a62406b04 100644 --- a/tests/validators/test_is_instance.py +++ b/tests/validators/test_is_instance.py @@ -19,14 +19,14 @@ class Spam: def test_validate_json() -> None: - v = SchemaValidator(schema=cs.is_instance_schema(cls=Foo)) + v = SchemaValidator(cs.is_instance_schema(cls=Foo)) with pytest.raises(ValidationError) as exc_info: v.validate_json('"foo"') assert exc_info.value.errors()[0]['type'] == 'needs_python_object' def test_is_instance(): - v = SchemaValidator(schema=cs.is_instance_schema(cls=Foo)) + v = SchemaValidator(cs.is_instance_schema(cls=Foo)) foo = Foo() assert v.validate_python(foo) == foo assert v.isinstance_python(foo) is True @@ -66,14 +66,14 @@ def test_is_instance(): ], ) def test_is_instance_cases(schema_class, input_val, value): - v = SchemaValidator(schema=cs.is_instance_schema(cls=schema_class)) + v = SchemaValidator(cs.is_instance_schema(cls=schema_class)) assert v.isinstance_python(input_val) == value @pytest.mark.parametrize('input_cls', [123, 'foo', Foo(), [], {1: 2}]) def test_is_instance_invalid(input_cls): with pytest.raises(SchemaError, match="SchemaError: 'cls' must be valid as the first argument to 'isinstance'"): - SchemaValidator(schema=cs.is_instance_schema(cls=input_cls)) + SchemaValidator(cs.is_instance_schema(cls=input_cls)) class HasIsInstanceMeta(type): @@ -89,7 +89,7 @@ class HasIsInstance(metaclass=HasIsInstanceMeta): def test_instancecheck(): - v = SchemaValidator(schema=cs.is_instance_schema(cls=HasIsInstance)) + v = SchemaValidator(cs.is_instance_schema(cls=HasIsInstance)) assert v.validate_python('true') == 'true' with pytest.raises(ValidationError, match='type=is_instance_of'): @@ -100,7 +100,7 @@ def test_instancecheck(): def test_repr(): - v = SchemaValidator(schema=cs.union_schema(choices=[cs.int_schema(), cs.is_instance_schema(cls=Foo)])) + v = SchemaValidator(cs.union_schema(choices=[cs.int_schema(), cs.is_instance_schema(cls=Foo)])) assert v.isinstance_python(4) is True assert v.isinstance_python(Bar()) is True assert v.isinstance_python('foo') is False @@ -123,13 +123,13 @@ def test_repr(): ], ) def test_is_type(input_val, value): - v = SchemaValidator(schema=cs.is_instance_schema(cls=type)) + v = SchemaValidator(cs.is_instance_schema(cls=type)) assert v.isinstance_python(input_val) == value def test_is_instance_dict(): v = SchemaValidator( - schema=core_schema.dict_schema( + core_schema.dict_schema( keys_schema=core_schema.is_instance_schema(str), values_schema=core_schema.is_instance_schema(int) ) ) @@ -138,13 +138,13 @@ def test_is_instance_dict(): def test_is_instance_dict_not_str(): - v = SchemaValidator(schema=core_schema.dict_schema(keys_schema=core_schema.is_instance_schema(int))) + v = SchemaValidator(core_schema.dict_schema(keys_schema=core_schema.is_instance_schema(int))) assert v.isinstance_python({1: 1}) is True assert v.isinstance_python({'foo': 1}) is False def test_is_instance_sequence(): - v = SchemaValidator(schema=core_schema.is_instance_schema(typing.Sequence)) + v = SchemaValidator(core_schema.is_instance_schema(typing.Sequence)) assert v.isinstance_python(1) is False assert v.isinstance_python([1]) is True @@ -153,7 +153,7 @@ def test_is_instance_sequence(): def test_is_instance_tuple(): - v = SchemaValidator(schema=core_schema.is_instance_schema((int, str))) + v = SchemaValidator(core_schema.is_instance_schema((int, str))) assert v.isinstance_python(1) is True assert v.isinstance_python('foobar') is True assert v.isinstance_python([1]) is False @@ -162,7 +162,7 @@ def test_is_instance_tuple(): def test_class_repr(): - v = SchemaValidator(schema=core_schema.is_instance_schema(int, cls_repr='Foobar')) + v = SchemaValidator(core_schema.is_instance_schema(int, cls_repr='Foobar')) assert v.validate_python(1) == 1 with pytest.raises(ValidationError, match=r'Input should be an instance of Foobar \[type=is_instance_of,'): v.validate_python('1') @@ -175,7 +175,7 @@ def test_is_instance_json_type_before_validator(): # such as type to have a valid input from JSON. schema = core_schema.is_instance_schema(type) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) with pytest.raises(ValidationError) as exc_info: v.validate_json('null') @@ -186,6 +186,6 @@ def set_type_to_int(input: None) -> type: return int schema = core_schema.no_info_before_validator_function(set_type_to_int, schema) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) assert v.validate_json('null') == int diff --git a/tests/validators/test_is_subclass.py b/tests/validators/test_is_subclass.py index 38264cc62..43e65b6b1 100644 --- a/tests/validators/test_is_subclass.py +++ b/tests/validators/test_is_subclass.py @@ -16,7 +16,7 @@ class Bar: def test_is_subclass_basic(): - v = SchemaValidator(schema=core_schema.is_subclass_schema(Foo)) + v = SchemaValidator(core_schema.is_subclass_schema(Foo)) assert v.validate_python(Foo) == Foo with pytest.raises(ValidationError) as exc_info: v.validate_python(Bar) @@ -47,23 +47,23 @@ def test_is_subclass_basic(): ], ) def test_is_subclass(input_value, valid): - v = SchemaValidator(schema=core_schema.is_subclass_schema(Foo)) + v = SchemaValidator(core_schema.is_subclass_schema(Foo)) assert v.isinstance_python(input_value) == valid def test_not_parent(): - v = SchemaValidator(schema=core_schema.is_subclass_schema(Foobar)) + v = SchemaValidator(core_schema.is_subclass_schema(Foobar)) assert v.isinstance_python(Foobar) assert not v.isinstance_python(Foo) def test_invalid_type(): with pytest.raises(SchemaError, match="TypeError: 'Foo' object cannot be converted to 'PyType"): - SchemaValidator(schema=core_schema.is_subclass_schema(Foo())) + SchemaValidator(core_schema.is_subclass_schema(Foo())) def test_custom_repr(): - v = SchemaValidator(schema=core_schema.is_subclass_schema(Foo, cls_repr='Spam')) + v = SchemaValidator(core_schema.is_subclass_schema(Foo, cls_repr='Spam')) assert v.validate_python(Foo) == Foo with pytest.raises(ValidationError) as exc_info: v.validate_python(Bar) @@ -80,7 +80,7 @@ def test_custom_repr(): def test_is_subclass_json() -> None: - v = SchemaValidator(schema=core_schema.is_subclass_schema(Foo)) + v = SchemaValidator(core_schema.is_subclass_schema(Foo)) with pytest.raises(ValidationError) as exc_info: v.validate_json("'Foo'") assert exc_info.value.errors()[0]['type'] == 'needs_python_object' diff --git a/tests/validators/test_json.py b/tests/validators/test_json.py index ed90eb911..5d60d58f3 100644 --- a/tests/validators/test_json.py +++ b/tests/validators/test_json.py @@ -86,7 +86,7 @@ def test_any(py_and_json: PyAndJson, input_value, expected): ], ) def test_any_python(input_value, expected): - v = SchemaValidator(schema=core_schema.json_schema()) + v = SchemaValidator(core_schema.json_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -162,7 +162,7 @@ class MyEnum(Enum): core_schema.is_instance_schema(MyEnum), ) v = core_schema.json_schema(enum_schema) - v = SchemaValidator(schema=v) + v = SchemaValidator(v) assert v.validate_python('"a"') == MyEnum.a assert v.validate_python('"b"') == MyEnum.b with pytest.raises(ValidationError): @@ -170,9 +170,9 @@ class MyEnum(Enum): def test_any_schema_no_schema(): - v = SchemaValidator(schema=core_schema.json_schema()) + v = SchemaValidator(core_schema.json_schema()) assert 'validator:None' in plain_repr(v) - v = SchemaValidator(schema=core_schema.json_schema(core_schema.any_schema())) + v = SchemaValidator(core_schema.json_schema(core_schema.any_schema())) assert 'validator:None' in plain_repr(v) - v = SchemaValidator(schema=core_schema.json_schema(core_schema.int_schema())) + v = SchemaValidator(core_schema.json_schema(core_schema.int_schema())) assert 'validator:Some(' in plain_repr(v) diff --git a/tests/validators/test_json_or_python.py b/tests/validators/test_json_or_python.py index 2430afa93..6cd57b1c3 100644 --- a/tests/validators/test_json_or_python.py +++ b/tests/validators/test_json_or_python.py @@ -14,7 +14,7 @@ def __eq__(self, o: object) -> bool: s = cs.json_or_python_schema( json_schema=cs.no_info_after_validator_function(Foo, cs.str_schema()), python_schema=cs.is_instance_schema(Foo) ) - v = SchemaValidator(schema=s) + v = SchemaValidator(s) assert v.validate_python(Foo('abc')) == Foo('abc') with pytest.raises(ValidationError) as exc_info: diff --git a/tests/validators/test_lax_or_strict.py b/tests/validators/test_lax_or_strict.py index 830ebe72d..4c3a457d5 100644 --- a/tests/validators/test_lax_or_strict.py +++ b/tests/validators/test_lax_or_strict.py @@ -4,7 +4,7 @@ def test_lax_or_strict(): - v = SchemaValidator(schema=core_schema.lax_or_strict_schema(core_schema.str_schema(), core_schema.int_schema())) + v = SchemaValidator(core_schema.lax_or_strict_schema(core_schema.str_schema(), core_schema.int_schema())) # validator is default - lax so with no runtime arg, we're in lax mode, and we use the string validator assert v.validate_python('aaa') == 'aaa' # the strict validator is itself lax @@ -23,7 +23,7 @@ def test_lax_or_strict(): def test_lax_or_strict_default_strict(): v = SchemaValidator( - schema=core_schema.lax_or_strict_schema(core_schema.str_schema(), core_schema.int_schema(), strict=True) + core_schema.lax_or_strict_schema(core_schema.str_schema(), core_schema.int_schema(), strict=True) ) assert v.validate_python('aaa', strict=False) == 'aaa' assert v.validate_python(b'aaa', strict=False) == 'aaa' diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py index c6a70e561..124f7062f 100644 --- a/tests/validators/test_list.py +++ b/tests/validators/test_list.py @@ -34,7 +34,7 @@ def test_list_py_or_json(py_and_json: PyAndJson, input_value, expected): def test_list_strict(): - v = SchemaValidator(schema=cs.list_schema(items_schema=cs.int_schema(), strict=True)) + v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema(), strict=True)) assert v.validate_python([1, 2, '33']) == [1, 2, 33] with pytest.raises(ValidationError) as exc_info: v.validate_python((1, 2, '33')) @@ -44,7 +44,7 @@ def test_list_strict(): def test_list_no_copy(): - v = SchemaValidator(schema=cs.list_schema()) + v = SchemaValidator(cs.list_schema()) assert v.validate_python([1, 2, 3]) is not [1, 2, 3] # noqa: F632 @@ -74,7 +74,7 @@ def gen_ints(): ) @pytest.mark.thread_unsafe # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14 def test_list_int(input_value, expected): - v = SchemaValidator(schema=cs.list_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema())) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -83,7 +83,7 @@ def test_list_int(input_value, expected): def test_list_json(): - v = SchemaValidator(schema=cs.list_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema())) assert v.validate_json('[1, "2", 3]') == [1, 2, 3] with pytest.raises(ValidationError) as exc_info: @@ -108,7 +108,7 @@ def test_list_json(): ], ) def test_list_any(input_value, expected): - v = SchemaValidator(schema=cs.list_schema()) + v = SchemaValidator(cs.list_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -128,7 +128,7 @@ def test_list_any(input_value, expected): ], ) def test_list_error(input_value, index): - v = SchemaValidator(schema=cs.list_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(input_value) assert exc_info.value.errors(include_url=False) == [ @@ -174,7 +174,7 @@ def test_list_error(input_value, index): ) @pytest.mark.thread_unsafe # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14 def test_list_length_constraints(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator(schema=cs.list_schema(**kwargs)) + v = SchemaValidator(cs.list_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -192,9 +192,7 @@ def test_list_length_constraints(kwargs: dict[str, Any], input_value, expected): ) def test_list_length_constraints_omit(input_value, expected): v = SchemaValidator( - schema=cs.list_schema( - items_schema=cs.with_default_schema(schema=cs.int_schema(), on_error='omit'), max_length=4 - ) + cs.list_schema(items_schema=cs.with_default_schema(schema=cs.int_schema(), on_error='omit'), max_length=4) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -204,7 +202,7 @@ def test_list_length_constraints_omit(input_value, expected): def test_length_ctx(): - v = SchemaValidator(schema=cs.list_schema(min_length=2, max_length=3)) + v = SchemaValidator(cs.list_schema(min_length=2, max_length=3)) with pytest.raises(ValidationError) as exc_info: v.validate_python([1]) # insert_assert(exc_info.value.errors(include_url=False)) @@ -237,7 +235,7 @@ def test_list_function(): def f(input_value, info): return input_value * 2 - v = SchemaValidator(schema=cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f))) + v = SchemaValidator(cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f))) assert v.validate_python([1, 2, 3]) == [2, 4, 6] @@ -246,7 +244,7 @@ def test_list_function_val_error(): def f(input_value, info): raise ValueError(f'error {input_value}') - v = SchemaValidator(schema=cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f))) + v = SchemaValidator(cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f))) with pytest.raises(ValidationError) as exc_info: v.validate_python([1, 2]) @@ -272,7 +270,7 @@ def test_list_function_internal_error(): def f(input_value, info): raise RuntimeError(f'error {input_value}') - v = SchemaValidator(schema=cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f))) + v = SchemaValidator(cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f))) with pytest.raises(RuntimeError, match='^error 1$') as exc_info: v.validate_python([1, 2]) @@ -287,7 +285,7 @@ def gen(error: bool): raise RuntimeError('error') yield 3 - v = SchemaValidator(schema=cs.list_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema())) assert v.validate_python(gen(False)) == [1, 2, 3] with pytest.raises(ValidationError) as exc_info: v.validate_python(gen(True)) @@ -321,7 +319,7 @@ def gen(error: bool): ], ) def test_list_from_dict_items(input_value, items_schema, expected): - v = SchemaValidator(schema=cs.list_schema(items_schema=items_schema)) + v = SchemaValidator(cs.list_schema(items_schema=items_schema)) output = v.validate_python(input_value) assert isinstance(output, list) assert output == expected @@ -349,7 +347,7 @@ def __next__(self): else: raise RuntimeError('broken') - v = SchemaValidator(schema=cs.list_schema(items_schema={'type': items_schema})) + v = SchemaValidator(cs.list_schema(items_schema={'type': items_schema})) assert v.validate_python(BadIter(True)) == [1] with pytest.raises(ValidationError) as exc_info: v.validate_python(BadIter(False)) @@ -379,7 +377,7 @@ def f(v: int) -> int: core_schema.no_info_after_validator_function(f, core_schema.int_schema()), max_length=10 ) - v = SchemaValidator(schema=s) + v = SchemaValidator(s) data = list(range(15)) @@ -436,7 +434,7 @@ def f(v: int) -> int: ) def test_list_fail_fast(fail_fast, expected): s = core_schema.list_schema(core_schema.int_schema(), fail_fast=fail_fast) - v = SchemaValidator(schema=s) + v = SchemaValidator(s) with pytest.raises(ValidationError) as exc_info: v.validate_python([1, 'not-num', 'again']) @@ -514,7 +512,7 @@ class ListInputTestCase: ) @pytest.mark.thread_unsafe # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14 def test_list_allowed_inputs_python(testcase: ListInputTestCase): - v = SchemaValidator(schema=core_schema.list_schema(core_schema.int_schema(), strict=testcase.strict)) + v = SchemaValidator(core_schema.list_schema(core_schema.int_schema(), strict=testcase.strict)) if isinstance(testcase.output, Err): with pytest.raises(ValidationError, match=re.escape(testcase.output.message)): v.validate_python(testcase.input) @@ -538,7 +536,7 @@ def test_list_allowed_inputs_python(testcase: ListInputTestCase): ) def test_list_dict_items_input(testcase: ListInputTestCase) -> None: v = SchemaValidator( - schema=core_schema.list_schema( + core_schema.list_schema( core_schema.tuple_positional_schema([core_schema.int_schema(), core_schema.int_schema()]), strict=testcase.strict, ) diff --git a/tests/validators/test_literal.py b/tests/validators/test_literal.py index f1b05339f..70b1ba0b0 100644 --- a/tests/validators/test_literal.py +++ b/tests/validators/test_literal.py @@ -148,7 +148,7 @@ def test_literal_py_and_json(py_and_json: PyAndJson, kwarg_expected, input_value ], ) def test_literal_not_json(kwarg_expected, input_value, expected): - v = SchemaValidator(schema=cs.literal_schema(expected=kwarg_expected)) + v = SchemaValidator(cs.literal_schema(expected=kwarg_expected)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: v.validate_python(input_value) @@ -161,11 +161,11 @@ def test_literal_not_json(kwarg_expected, input_value, expected): def test_build_error(): with pytest.raises(SchemaError, match='SchemaError: `expected` should have length > 0'): - SchemaValidator(schema=cs.literal_schema(expected=[])) + SchemaValidator(cs.literal_schema(expected=[])) def test_literal_none(): - v = SchemaValidator(schema=core_schema.literal_schema([None])) + v = SchemaValidator(core_schema.literal_schema([None])) assert v.isinstance_python(None) is True assert v.isinstance_python(0) is False expected_repr_start = 'SchemaValidator(title="literal[None]"' @@ -173,9 +173,7 @@ def test_literal_none(): def test_union(): - v = SchemaValidator( - schema=core_schema.union_schema([core_schema.literal_schema(['a', 'b']), core_schema.int_schema()]) - ) + v = SchemaValidator(core_schema.union_schema([core_schema.literal_schema(['a', 'b']), core_schema.int_schema()])) assert v.validate_python('a') == 'a' assert v.validate_python(4) == 4 with pytest.raises(ValidationError) as exc_info: @@ -203,7 +201,7 @@ class FooEnum(Enum): foo = 'foo_value' bar = 'bar_value' - v = SchemaValidator(schema=core_schema.literal_schema([FooEnum.foo])) + v = SchemaValidator(core_schema.literal_schema([FooEnum.foo])) assert v.validate_python(FooEnum.foo) == FooEnum.foo with pytest.raises(ValidationError) as exc_info: v.validate_python('foo_value') @@ -248,7 +246,7 @@ class Foo(str, Enum): foo = 'foo_value' bar = 'bar_value' - v = SchemaValidator(schema=core_schema.literal_schema([Foo.foo])) + v = SchemaValidator(core_schema.literal_schema([Foo.foo])) assert v.validate_python(Foo.foo) == Foo.foo assert v.validate_python('foo_value') == Foo.foo @@ -272,7 +270,7 @@ class Foo(int, Enum): foo = 2 bar = 3 - v = SchemaValidator(schema=core_schema.literal_schema([Foo.foo])) + v = SchemaValidator(core_schema.literal_schema([Foo.foo])) assert v.validate_python(Foo.foo) == Foo.foo assert v.validate_python(2) == Foo.foo @@ -324,7 +322,7 @@ def test_mix_int_enum_with_int(reverse: Callable[[list[Any]], list[Any]], err: A class Foo(int, Enum): foo = 1 - v = SchemaValidator(schema=core_schema.literal_schema(reverse([1, Foo.foo]))) + v = SchemaValidator(core_schema.literal_schema(reverse([1, Foo.foo]))) assert v.validate_python(Foo.foo) is Foo.foo val = v.validate_python(1) @@ -370,7 +368,7 @@ def test_mix_str_enum_with_str(reverse: Callable[[list[Any]], list[Any]], err: A class Foo(str, Enum): foo = 'foo_val' - v = SchemaValidator(schema=core_schema.literal_schema(reverse(['foo_val', Foo.foo]))) + v = SchemaValidator(core_schema.literal_schema(reverse(['foo_val', Foo.foo]))) assert v.validate_python(Foo.foo) is Foo.foo val = v.validate_python('foo_val') @@ -386,7 +384,7 @@ class Foo(str, Enum): def test_big_int(): big_int = 2**64 + 1 massive_int = 2**128 + 1 - v = SchemaValidator(schema=core_schema.literal_schema([big_int, massive_int])) + v = SchemaValidator(core_schema.literal_schema([big_int, massive_int])) assert v.validate_python(big_int) == big_int assert v.validate_python(massive_int) == massive_int m = r'Input should be 18446744073709551617 or 340282366920938463463374607431768211457 \[type=literal_error' @@ -398,8 +396,8 @@ def test_enum_for_str() -> None: class S(str, Enum): a = 'a' - val_enum = SchemaValidator(schema=core_schema.literal_schema([S.a])) - val_str = SchemaValidator(schema=core_schema.literal_schema(['a'])) + val_enum = SchemaValidator(core_schema.literal_schema([S.a])) + val_str = SchemaValidator(core_schema.literal_schema(['a'])) for val in [val_enum, val_str]: assert val.validate_python('a') == 'a' diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py index 57ad33da7..2ce2c0a56 100644 --- a/tests/validators/test_model.py +++ b/tests/validators/test_model.py @@ -18,7 +18,7 @@ class MyModel: field_b: int v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -54,7 +54,7 @@ class MyModel: field_b: int v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -95,7 +95,7 @@ def __getattr__(self, key): return getattr(self._inner, key) v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -142,7 +142,7 @@ def __init__(self, **values): self.__dict__.update(values) v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -184,7 +184,7 @@ def __setattr__(self, key, value): setattr_calls.clear() v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} @@ -219,7 +219,7 @@ def f( ), ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) m = v.validate_python({'field_a': 123}) assert m.field_a == 123 @@ -253,7 +253,7 @@ def f(input_value: dict[str, Any], info: core_schema.ValidationInfo): ), ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) m = v.validate_python({'field_a': 123}) assert m.field_a == 123 @@ -288,7 +288,7 @@ def f(input_value_and_fields_set: tuple[dict[str, Any], set[str]]): ), ) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) m = v.validate_python({'field_a': 123}) assert m.field_a == 123 @@ -315,7 +315,7 @@ def f(input_value, info): return input_value SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema={ 'type': f'function-{mode}', @@ -335,9 +335,7 @@ class MyModel: def f(input_value): return input_value, {1: 2}, {'field_a'} - v = SchemaValidator( - schema=core_schema.model_schema(cls=MyModel, schema=core_schema.no_info_plain_validator_function(f)) - ) + v = SchemaValidator(core_schema.model_schema(cls=MyModel, schema=core_schema.no_info_plain_validator_function(f))) m = v.validate_python({'field_a': 'test'}) assert isinstance(m, MyModel) assert m.__dict__ == {'field_a': 'test'} @@ -350,7 +348,7 @@ class MyModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.union_schema( choices=[ @@ -379,7 +377,7 @@ class MyModel: pass v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.tagged_union_schema( discriminator='foo', @@ -428,7 +426,7 @@ def test_bad_sub_schema(): class MyModel: pass - v = SchemaValidator(schema=core_schema.model_schema(cls=MyModel, schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.model_schema(cls=MyModel, schema=core_schema.int_schema())) with pytest.raises(TypeError): v.validate_python(123) @@ -442,7 +440,7 @@ def f(input_value, info): return input_value v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema={ 'type': 'function-after', @@ -480,7 +478,7 @@ def __init__(self): self.field_a = 'init' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} @@ -519,7 +517,7 @@ def __init__(self): self.field_b = 'init_b' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} @@ -566,7 +564,7 @@ def __init__(self): self.field_b = 'init_b' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} @@ -604,7 +602,7 @@ def __init__(self): self.field_b = 'init_b' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( strict=True, cls=MyModel, schema=core_schema.model_fields_schema( @@ -649,7 +647,7 @@ class MyModel: field_c: int v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( strict=True, cls=MyModel, schema=core_schema.model_fields_schema( @@ -673,7 +671,7 @@ class MyModel: def test_internal_error(): v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=int, schema=core_schema.model_fields_schema( fields={'f': core_schema.model_field(schema=core_schema.int_schema())} @@ -696,7 +694,7 @@ def __init__(self, a, b, fields_set): self.__pydantic_fields_set__ = fields_set v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, revalidate_instances='always', schema=core_schema.model_fields_schema( @@ -752,7 +750,7 @@ def __init__(self): self.field_c = 'init_c' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, revalidate_instances='subclass-instances', schema=core_schema.model_fields_schema( @@ -793,7 +791,7 @@ def __init__(self, **kwargs): self.__dict__.update(kwargs) v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( extra_behavior='allow', @@ -842,7 +840,7 @@ def call_me_maybe(self, *args): assert self.__pydantic_fields_set__ == {'field_a', 'field_b'} v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, post_init='call_me_maybe', schema=core_schema.model_fields_schema( @@ -870,7 +868,7 @@ def call_me_maybe(self, context): assert context is None v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, post_init='call_me_maybe', schema=core_schema.model_fields_schema( @@ -914,7 +912,7 @@ def call_me_maybe(self, context, **kwargs): raise ValueError(f'this is broken: {self.field_a}') v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, post_init='call_me_maybe', schema=core_schema.model_fields_schema( @@ -948,7 +946,7 @@ def wrong_signature(self): pass v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, post_init='wrong_signature', schema=core_schema.model_fields_schema( @@ -971,7 +969,7 @@ def call_me_maybe(self, context, **kwargs): self.__pydantic_fields_set__ = {'field_a'} v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, post_init='call_me_maybe', schema=core_schema.model_fields_schema( @@ -1001,7 +999,7 @@ def __init__(self): self.__pydantic_extra__ = None v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1050,7 +1048,7 @@ def func(x, info): return x * 2 v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1090,7 +1088,7 @@ def __init__(self): self.__pydantic_extra__ = None v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={ @@ -1122,7 +1120,7 @@ class MyModel: __slots__ = {'__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'} v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema({'f': core_schema.model_field(core_schema.str_schema())}), frozen=True, @@ -1191,7 +1189,7 @@ def f(values_or_values_and_fields_set: Any, *args: Any) -> Any: return values_or_values_and_fields_set v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, function_schema( f, @@ -1228,7 +1226,7 @@ class MyModel: field_b: int v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1316,7 +1314,7 @@ class MyModel: # WHEN v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( MyModel, core_schema.model_fields_schema( { diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py index 08b42e074..e156eaa6b 100644 --- a/tests/validators/test_model_fields.py +++ b/tests/validators/test_model_fields.py @@ -42,7 +42,7 @@ def __repr__(self): def test_simple(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field(schema=core_schema.str_schema()), 'field_b': core_schema.model_field(schema=core_schema.int_schema()), @@ -85,7 +85,7 @@ def test_strict(): def test_with_default(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field(schema=core_schema.str_schema()), 'field_b': core_schema.model_field( @@ -105,7 +105,7 @@ def test_with_default(): def test_missing_error(pydantic_version): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field(schema=core_schema.str_schema()), 'field_b': core_schema.model_field(schema=core_schema.int_schema()), @@ -154,7 +154,7 @@ def test_missing_error(pydantic_version): ) def test_config(config: CoreConfig, input_value, expected): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'a': core_schema.model_field(schema=core_schema.int_schema()), 'b': core_schema.model_field( @@ -175,7 +175,7 @@ def test_config(config: CoreConfig, input_value, expected): def test_ignore_extra(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field(schema=core_schema.str_schema()), 'field_b': core_schema.model_field(schema=core_schema.int_schema()), @@ -192,7 +192,7 @@ def test_ignore_extra(): def test_forbid_extra(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}, extra_behavior='forbid' ) ) @@ -223,9 +223,7 @@ def test_allow_extra_wrong(): def test_str_config(): v = SchemaValidator( - schema=core_schema.model_fields_schema( - fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} - ), + core_schema.model_fields_schema(fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}), config=CoreConfig(str_max_length=5), ) assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'}) @@ -236,9 +234,7 @@ def test_str_config(): def test_validate_assignment(): v = SchemaValidator( - schema=core_schema.model_fields_schema( - fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} - ) + core_schema.model_fields_schema(fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}) ) assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'}) @@ -250,7 +246,7 @@ def test_validate_assignment(): def test_validate_assignment_strict_field(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema(strict=True))} ) ) @@ -276,7 +272,7 @@ def func_b(input_value, info): return input_value / 2 v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field( schema={ @@ -315,9 +311,7 @@ def func_b(input_value, info): def test_validate_assignment_ignore_extra(): v = SchemaValidator( - schema=core_schema.model_fields_schema( - fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} - ) + core_schema.model_fields_schema(fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}) ) assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'}) @@ -339,7 +333,7 @@ def test_validate_assignment_ignore_extra(): def test_validate_assignment_allow_extra(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}, extra_behavior='allow' ) ) @@ -355,7 +349,7 @@ def test_validate_assignment_allow_extra(): def test_validate_assignment_allow_extra_validate(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}, extras_schema=core_schema.int_schema(), extra_behavior='allow', @@ -382,7 +376,7 @@ def test_validate_assignment_allow_extra_validate(): def test_validate_assignment_with_strict(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'x': core_schema.model_field(schema=core_schema.str_schema()), 'y': core_schema.model_field(schema=core_schema.int_schema()), @@ -408,7 +402,7 @@ def test_validate_assignment_with_strict(): def test_json_error(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field( schema=core_schema.list_schema(items_schema=core_schema.int_schema()) @@ -437,7 +431,7 @@ def test_missing_schema_key(): def test_fields_required_by_default(): """By default all fields should be required""" v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'x': core_schema.model_field(schema=core_schema.str_schema()), 'y': core_schema.model_field(schema=core_schema.str_schema()), @@ -457,7 +451,7 @@ def test_fields_required_by_default(): def test_fields_required_by_default_with_default(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'x': core_schema.model_field(schema=core_schema.str_schema()), 'y': core_schema.model_field( @@ -608,7 +602,7 @@ def test_aliases_path_multiple(py_and_json: PyAndJson, input_value, expected): ) def test_aliases_path_negative(input_value, expected): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(validation_alias=['foo', -2], schema=core_schema.int_schema())} ), config=CoreConfig(loc_by_alias=False), @@ -649,7 +643,7 @@ def test_aliases_path_negative_json(py_and_json: PyAndJson, input_value, expecte def test_aliases_debug(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field( validation_alias=[['foo', 'bar', 'bat'], ['foo', 3]], schema=core_schema.int_schema() @@ -664,7 +658,7 @@ def test_aliases_debug(): def get_int_key(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field( validation_alias=[['foo', 3], ['spam']], schema=core_schema.int_schema() @@ -683,7 +677,7 @@ def __getitem__(self, v): def get_custom_getitem(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'field_a': core_schema.model_field(validation_alias=['foo'], schema=core_schema.int_schema())} ) ) @@ -827,7 +821,7 @@ def test_alias_error_loc_field_names(py_and_json: PyAndJson): def test_empty_model(): - v = SchemaValidator(schema=core_schema.model_fields_schema(fields={})) + v = SchemaValidator(core_schema.model_fields_schema(fields={})) assert v.validate_python({}) == ({}, None, set()) with pytest.raises( ValidationError, match=re.escape('Input should be a valid dictionary or instance of Model [type=model_type,') @@ -837,7 +831,7 @@ def test_empty_model(): def test_model_fields_deep(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'field_a': core_schema.model_field(schema=core_schema.str_schema()), 'field_b': core_schema.model_field( @@ -927,7 +921,7 @@ class MyDataclass: @pytest.mark.parametrize('from_attributes_mode', ['schema', 'validation']) def test_from_attributes(input_value, expected, from_attributes_mode): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'a': core_schema.model_field(schema=core_schema.int_schema()), 'b': core_schema.model_field(schema=core_schema.int_schema()), @@ -950,7 +944,7 @@ def test_from_attributes(input_value, expected, from_attributes_mode): def test_from_attributes_type_error(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'a': core_schema.model_field(schema=core_schema.int_schema()), 'b': core_schema.model_field(schema=core_schema.int_schema()), @@ -988,7 +982,7 @@ def test_from_attributes_type_error(): def test_from_attributes_by_name(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'a': core_schema.model_field(schema=core_schema.int_schema(), validation_alias='a_alias')}, from_attributes=True, populate_by_name=True, @@ -1000,7 +994,7 @@ def test_from_attributes_by_name(): def test_from_attributes_override_true(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=False ) ) @@ -1014,7 +1008,7 @@ def test_from_attributes_override_true(): def test_from_attributes_override_false(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True ) ) @@ -1033,7 +1027,7 @@ def __init__(self): self.b = 2 v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'a': core_schema.model_field(schema=core_schema.int_schema()), 'b': core_schema.model_field(schema=core_schema.int_schema()), @@ -1066,7 +1060,7 @@ def b(self): raise RuntimeError('intentional error') v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'a': core_schema.model_field(schema=core_schema.int_schema()), 'b': core_schema.model_field(schema=core_schema.int_schema()), @@ -1133,7 +1127,7 @@ class MyDataclass: _d: int = 4 v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True, extra_behavior='allow', @@ -1149,7 +1143,7 @@ class MyDataclass: def test_from_attributes_extra_ignore_no_attributes_accessed() -> None: v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True, extra_behavior='ignore', @@ -1176,7 +1170,7 @@ class Source: b = 2 v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True, extra_behavior='forbid', @@ -1203,7 +1197,7 @@ def foobar(): ) def test_from_attributes_function(input_value, expected): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'a': core_schema.model_field(schema=core_schema.any_schema())}, from_attributes=True ) ) @@ -1225,7 +1219,7 @@ def x(self): raise BadError('intentional error') v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={'x': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True ) ) @@ -1282,7 +1276,7 @@ def x(self): ) def test_from_attributes_path(input_value, expected): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'my_field': core_schema.model_field( validation_alias=[['foo', 'bar', 'bat'], ['foo', 3], ['spam']], schema=core_schema.int_schema() @@ -1310,7 +1304,7 @@ def foo(self): raise RuntimeError('intentional error') v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'my_field': core_schema.model_field( validation_alias=[['foo', 'bar', 'bat'], ['foo', 3], ['spam']], schema=core_schema.int_schema() @@ -1367,7 +1361,7 @@ def test_alias_extra(py_and_json: PyAndJson): def test_alias_extra_from_attributes(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( extra_behavior='allow', from_attributes=True, fields={ @@ -1412,7 +1406,7 @@ def test_alias_extra_forbid(py_and_json: PyAndJson): def test_with_default_factory(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'x': core_schema.model_field( schema=core_schema.with_default_schema( @@ -1436,7 +1430,7 @@ def test_with_default_factory(): ) def test_bad_default_factory(default_factory, error_message): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'x': core_schema.model_field( schema=core_schema.with_default_schema( @@ -1582,7 +1576,7 @@ def wrap_function(input_value, validator, info): def test_frozen_field(): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( fields={ 'name': core_schema.model_field(schema=core_schema.str_schema()), 'age': core_schema.model_field(schema=core_schema.int_schema()), @@ -1627,7 +1621,7 @@ def test_extra_behavior_allow( expected_extra_value: Any, ): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw, **extras_schema_kw ), config=config, @@ -1659,7 +1653,7 @@ def test_extra_behavior_allow( ) def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw ), config=config, @@ -1706,7 +1700,7 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche ) def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): v = SchemaValidator( - schema=core_schema.model_fields_schema( + core_schema.model_fields_schema( {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw ), config=config, diff --git a/tests/validators/test_model_init.py b/tests/validators/test_model_init.py index a6240e42a..08f13ac54 100644 --- a/tests/validators/test_model_init.py +++ b/tests/validators/test_model_init.py @@ -18,7 +18,7 @@ class MyModel: def test_model_init(): v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={ @@ -48,7 +48,7 @@ class MyModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.model_fields_schema( fields={ @@ -92,7 +92,7 @@ def f(input_value, _info): return input_value v = SchemaValidator( - schema={ + { 'type': 'function-before', 'function': {'type': 'with-info', 'function': f}, 'schema': core_schema.model_schema( @@ -126,7 +126,7 @@ def f(input_value, _info): return input_value v = SchemaValidator( - schema={ + { 'type': 'function-after', 'function': {'type': 'with-info', 'function': f}, 'schema': core_schema.model_schema( @@ -162,7 +162,7 @@ def f(input_value, handler, _info): return v v = SchemaValidator( - schema={ + { 'type': 'function-wrap', 'function': {'type': 'with-info', 'function': f}, 'schema': core_schema.model_schema( @@ -189,7 +189,7 @@ def f(input_value, handler, _info): def test_simple(): - v = SchemaValidator(schema=core_schema.str_schema()) + v = SchemaValidator(core_schema.str_schema()) assert v.validate_python(b'abc') == 'abc' assert v.isinstance_python(b'abc') is True @@ -213,7 +213,7 @@ def __init__(self, **kwargs): self.c = self.a + 2 v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -270,7 +270,7 @@ def __init__(self, **data): ), custom_init=True, ) - ModelInner.__pydantic_validator__ = SchemaValidator(schema=inner_schema) + ModelInner.__pydantic_validator__ = SchemaValidator(inner_schema) class ModelOuter: __slots__ = '__dict__', '__pydantic_fields_set__' @@ -282,7 +282,7 @@ def __init__(self, **data): self.__pydantic_validator__.validate_python(data, self_instance=self) ModelOuter.__pydantic_validator__ = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( ModelOuter, core_schema.model_fields_schema( { @@ -330,7 +330,7 @@ def __init__(self, **data): config=CoreConfig(extra_fields_behavior='allow'), custom_init=True, ) - ModelInner.__pydantic_validator__ = SchemaValidator(schema=inner_schema) + ModelInner.__pydantic_validator__ = SchemaValidator(inner_schema) class ModelOuter: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' @@ -346,7 +346,7 @@ def __init__(self, **data): calls.append(('outer', self.__dict__, self.__pydantic_fields_set__, self.__pydantic_extra__)) ModelOuter.__pydantic_validator__ = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( ModelOuter, core_schema.model_fields_schema( { @@ -387,7 +387,7 @@ def __init__(self, **kwargs): self.__pydantic_extra__ = None v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema({'a': core_schema.model_field(core_schema.int_schema())}), custom_init=True, @@ -452,7 +452,7 @@ def _wrap_validator(cls, v, validator, info): # If any of the Rust validators don't implement traversal properly, # there will be an undetectable cycle created by this assignment # which will keep Model alive - Model.__pydantic_validator__ = SchemaValidator(schema=model_schema) + Model.__pydantic_validator__ = SchemaValidator(model_schema) return Model @@ -504,7 +504,7 @@ def __init__(self, **kwargs): ], } - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert validator.validate_python({'a': False}).a is False assert validator.validate_python({'b': True}).b is True diff --git a/tests/validators/test_model_root.py b/tests/validators/test_model_root.py index 5098a31d2..4e0a55048 100644 --- a/tests/validators/test_model_root.py +++ b/tests/validators/test_model_root.py @@ -9,7 +9,7 @@ class RootModel: root: list[int] v = SchemaValidator( - schema=core_schema.model_schema(RootModel, core_schema.list_schema(core_schema.int_schema()), root_model=True) + core_schema.model_schema(RootModel, core_schema.list_schema(core_schema.int_schema()), root_model=True) ) assert repr(v).startswith('SchemaValidator(title="RootModel", validator=Model(\n') @@ -37,7 +37,7 @@ class RootModel: root: list[int] v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( RootModel, core_schema.list_schema(core_schema.int_schema()), root_model=True, revalidate_instances='always' ) ) @@ -60,7 +60,7 @@ class RootModel: root: int = 42 v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( RootModel, core_schema.with_default_schema(core_schema.int_schema(), default=42), root_model=True, @@ -86,9 +86,7 @@ class RootModel: root: str v = SchemaValidator( - schema=core_schema.model_schema( - RootModel, core_schema.str_schema(), root_model=True, revalidate_instances='always' - ) + core_schema.model_schema(RootModel, core_schema.str_schema(), root_model=True, revalidate_instances='always') ) m = RootModel() @@ -102,7 +100,7 @@ class RootModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' root: str - v = SchemaValidator(schema=core_schema.model_schema(RootModel, core_schema.str_schema(), root_model=True)) + v = SchemaValidator(core_schema.model_schema(RootModel, core_schema.str_schema(), root_model=True)) m = v.validate_python('foobar') assert m.root == 'foobar' @@ -138,7 +136,7 @@ def f(input_value: str, info): return input_value + ' validated' v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( RootModel, core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='root'), root_model=True, @@ -163,7 +161,7 @@ class RootModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' root: int - v = SchemaValidator(schema=core_schema.model_schema(RootModel, core_schema.int_schema(), root_model=True)) + v = SchemaValidator(core_schema.model_schema(RootModel, core_schema.int_schema(), root_model=True)) m = v.validate_python(1) @@ -179,7 +177,7 @@ class RootModel: root: int = 42 v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( RootModel, core_schema.with_default_schema(core_schema.int_schema(), default=42), root_model=True ) ) @@ -204,7 +202,7 @@ class Model: value: RootModel = 42 v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( { diff --git a/tests/validators/test_none.py b/tests/validators/test_none.py index 088db58c6..7b12f6884 100644 --- a/tests/validators/test_none.py +++ b/tests/validators/test_none.py @@ -5,7 +5,7 @@ def test_python_none(): - v = SchemaValidator(schema=cs.none_schema()) + v = SchemaValidator(cs.none_schema()) assert v.validate_python(None) is None with pytest.raises(ValidationError) as exc_info: v.validate_python(1) @@ -15,7 +15,7 @@ def test_python_none(): def test_json_none(): - v = SchemaValidator(schema=cs.none_schema()) + v = SchemaValidator(cs.none_schema()) assert v.validate_json('null') is None with pytest.raises(ValidationError) as exc_info: v.validate_json('1') diff --git a/tests/validators/test_nullable.py b/tests/validators/test_nullable.py index b78abd9ba..779b2507d 100644 --- a/tests/validators/test_nullable.py +++ b/tests/validators/test_nullable.py @@ -9,7 +9,7 @@ def test_nullable(): - v = SchemaValidator(schema=core_schema.nullable_schema(schema=core_schema.int_schema())) + v = SchemaValidator(core_schema.nullable_schema(schema=core_schema.int_schema())) assert v.validate_python(None) is None assert v.validate_python(1) == 1 assert v.validate_python('123') == 123 @@ -27,7 +27,7 @@ def test_nullable(): def test_union_nullable_bool_int(): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[ core_schema.nullable_schema(schema=core_schema.bool_schema()), core_schema.nullable_schema(schema=core_schema.int_schema()), @@ -53,7 +53,7 @@ def validate(v, info): # If any of the Rust validators don't implement traversal properly, # there will be an undetectable cycle created by this assignment # which will keep Defaulted alive - validate.__pydantic_validator__ = SchemaValidator(schema=schema) + validate.__pydantic_validator__ = SchemaValidator(schema) return validate diff --git a/tests/validators/test_pickling.py b/tests/validators/test_pickling.py index 362f911df..2037ab8c9 100644 --- a/tests/validators/test_pickling.py +++ b/tests/validators/test_pickling.py @@ -10,7 +10,7 @@ def test_basic_schema_validator(): v = SchemaValidator( - schema=validate_core_schema( + validate_core_schema( {'type': 'dict', 'strict': True, 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}} ) ) @@ -26,7 +26,7 @@ def test_schema_validator_containing_config(): Verify that the config object is not lost during (de)serialization. """ v = SchemaValidator( - schema=core_schema.model_fields_schema({'f': core_schema.model_field(core_schema.str_schema())}), + core_schema.model_fields_schema({'f': core_schema.model_field(core_schema.str_schema())}), config=core_schema.CoreConfig(extra_fields_behavior='allow'), ) v = pickle.loads(pickle.dumps(v)) @@ -46,7 +46,7 @@ def test_schema_validator_tz_pickle() -> None: """ https://github.com/pydantic/pydantic-core/issues/589 """ - v = SchemaValidator(schema=core_schema.datetime_schema()) + v = SchemaValidator(core_schema.datetime_schema()) original = datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone(timedelta(hours=-12, minutes=-15))) validated = v.validate_python('2022-06-08T12:13:14-12:15') assert validated == original diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py index 998ed793a..6eafe8abb 100644 --- a/tests/validators/test_set.py +++ b/tests/validators/test_set.py @@ -76,7 +76,7 @@ def test_frozenset_no_validators_both(py_and_json: PyAndJson, input_value, expec ) @pytest.mark.thread_unsafe # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14 def test_set_ints_python(input_value, expected): - v = SchemaValidator(schema=cs.set_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema())) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -86,12 +86,12 @@ def test_set_ints_python(input_value, expected): @pytest.mark.parametrize('input_value,expected', [([1, 2.5, '3'], {1, 2.5, '3'}), ([(1, 2), (3, 4)], {(1, 2), (3, 4)})]) def test_set_no_validators_python(input_value, expected): - v = SchemaValidator(schema=cs.set_schema()) + v = SchemaValidator(cs.set_schema()) assert v.validate_python(input_value) == expected def test_set_multiple_errors(): - v = SchemaValidator(schema=cs.set_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(['a', (1, 2), []]) assert exc_info.value.errors(include_url=False) == [ @@ -107,7 +107,7 @@ def test_set_multiple_errors(): def test_list_with_unhashable_items(): - v = SchemaValidator(schema=cs.set_schema()) + v = SchemaValidator(cs.set_schema()) class Unhashable: __hash__ = None @@ -166,7 +166,7 @@ def generate_repeats(): ) @pytest.mark.thread_unsafe # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14 def test_set_kwargs(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator(schema=cs.set_schema(**kwargs)) + v = SchemaValidator(cs.set_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): r = v.validate_python(input_value) @@ -177,7 +177,7 @@ def test_set_kwargs(kwargs: dict[str, Any], input_value, expected): @pytest.mark.parametrize('input_value,expected', [({1, 2, 3}, {1, 2, 3}), ([1, 2, 3], [1, 2, 3])]) def test_union_set_list(input_value, expected): - v = SchemaValidator(schema=cs.union_schema(choices=[cs.set_schema(), cs.list_schema()])) + v = SchemaValidator(cs.union_schema(choices=[cs.set_schema(), cs.list_schema()])) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -215,7 +215,7 @@ def test_union_set_list(input_value, expected): ) def test_union_set_int_set_str(input_value, expected): v = SchemaValidator( - schema=cs.union_schema( + cs.union_schema( choices=[ cs.set_schema(items_schema=cs.int_schema(strict=True)), cs.set_schema(items_schema=cs.str_schema(strict=True)), @@ -245,7 +245,7 @@ def gen(error: bool): raise RuntimeError('my error') yield 3 - v = SchemaValidator(schema=cs.set_schema(items_schema=cs.int_schema())) + v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema())) r = v.validate_python(gen(False)) assert r == {1, 2, 3} assert isinstance(r, set) @@ -274,7 +274,7 @@ def gen(error: bool): ], ) def test_set_from_dict_items(input_value, items_schema, expected): - v = SchemaValidator(schema=cs.set_schema(items_schema=items_schema)) + v = SchemaValidator(cs.set_schema(items_schema=items_schema)) output = v.validate_python(input_value) assert isinstance(output, set) assert output == expected @@ -291,7 +291,7 @@ def test_set_from_dict_items(input_value, items_schema, expected): ], ) def test_set_any(input_value, expected): - v = SchemaValidator(schema=cs.set_schema()) + v = SchemaValidator(cs.set_schema()) output = v.validate_python(input_value) assert output == expected assert isinstance(output, set) @@ -333,7 +333,7 @@ def test_set_any(input_value, expected): ], ) def test_set_fail_fast(fail_fast, expected): - v = SchemaValidator(schema=cs.set_schema(items_schema=cs.int_schema(), fail_fast=fail_fast)) + v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema(), fail_fast=fail_fast)) with pytest.raises(ValidationError) as exc_info: v.validate_python([1, 'not-num', 'again']) diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py index 9c86f0a8a..4f295056b 100644 --- a/tests/validators/test_string.py +++ b/tests/validators/test_string.py @@ -56,7 +56,7 @@ def test_str(py_and_json: PyAndJson, input_value, expected): ], ) def test_str_not_json(input_value, expected): - v = SchemaValidator(schema=core_schema.str_schema()) + v = SchemaValidator(core_schema.str_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -112,7 +112,7 @@ def test_constrained_str(py_and_json: PyAndJson, kwargs: dict[str, Any], input_v ], ) def test_constrained_str_py_only(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator(schema=core_schema.str_schema(**kwargs)) + v = SchemaValidator(core_schema.str_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -123,7 +123,7 @@ def test_constrained_str_py_only(kwargs: dict[str, Any], input_value, expected): def test_unicode_error(): # `.to_str()` Returns a `UnicodeEncodeError` if the input is not valid unicode (containing unpaired surrogates). # https://github.com/PyO3/pyo3/blob/6503128442b8f3e767c663a6a8d96376d7fb603d/src/types/string.rs#L477 - v = SchemaValidator(schema=core_schema.str_schema(min_length=1)) + v = SchemaValidator(core_schema.str_schema(min_length=1)) assert v.validate_python('🐈 Hello') == '🐈 Hello' with pytest.raises(ValidationError) as exc_info: @@ -154,7 +154,7 @@ def test_unicode_error(): ], ) def test_str_constrained(data: str, max_length: int, error: Union[re.Pattern, None]): - v = SchemaValidator(schema=core_schema.str_schema(max_length=max_length)) + v = SchemaValidator(core_schema.str_schema(max_length=max_length)) if error is None: assert v.validate_python(data) == data else: @@ -163,7 +163,7 @@ def test_str_constrained(data: str, max_length: int, error: Union[re.Pattern, No def test_str_constrained_config(): - v = SchemaValidator(schema=core_schema.str_schema(), config=CoreConfig(str_max_length=5)) + v = SchemaValidator(core_schema.str_schema(), config=CoreConfig(str_max_length=5)) assert v.validate_python('test') == 'test' with pytest.raises(ValidationError, match='String should have at most 5 characters'): @@ -179,7 +179,7 @@ def test_invalid_regex(engine): # 'Error building "str" validator:\n TypeError: \'int\' object cannot be converted to \'PyString\'' # ) with pytest.raises(SchemaError) as exc_info: - SchemaValidator(schema=core_schema.str_schema(pattern='(abc', regex_engine=engine)) + SchemaValidator(core_schema.str_schema(pattern='(abc', regex_engine=engine)) if engine is None or engine == 'rust-regex': assert exc_info.value.args[0] == ( @@ -194,7 +194,7 @@ def test_invalid_regex(engine): @pytest.mark.parametrize('engine', [None, 'rust-regex', 'python-re']) def test_regex_error(engine): - v = SchemaValidator(schema=core_schema.str_schema(pattern='11', regex_engine=engine)) + v = SchemaValidator(core_schema.str_schema(pattern='11', regex_engine=engine)) with pytest.raises(ValidationError) as exc_info: v.validate_python('12') assert exc_info.value.errors(include_url=False) == [ @@ -210,7 +210,7 @@ def test_regex_error(engine): def test_default_validator(): v = SchemaValidator( - schema=core_schema.str_schema(strict=True, to_lower=False), config=CoreConfig(str_strip_whitespace=False) + core_schema.str_schema(strict=True, to_lower=False), config=CoreConfig(str_strip_whitespace=False) ) assert ( plain_repr(v) @@ -231,7 +231,7 @@ class FruitEnum(str, Enum): @pytest.mark.parametrize('to_lower', [False, True], ids=repr) def test_strict_subclass(to_lower: bool): - v = SchemaValidator(schema=core_schema.str_schema(strict=True, to_lower=to_lower)) + v = SchemaValidator(core_schema.str_schema(strict=True, to_lower=to_lower)) class StrSubclass(str): pass @@ -242,7 +242,7 @@ class StrSubclass(str): @pytest.mark.parametrize('kwargs', [{}, {'to_lower': True}], ids=repr) def test_lax_subclass(FruitEnum, kwargs): - v = SchemaValidator(schema=core_schema.str_schema(**kwargs)) + v = SchemaValidator(core_schema.str_schema(**kwargs)) assert v.validate_python('foobar') == 'foobar' assert v.validate_python(b'foobar') == 'foobar' p = v.validate_python(FruitEnum.pear) @@ -253,7 +253,7 @@ def test_lax_subclass(FruitEnum, kwargs): @pytest.mark.parametrize('kwargs', [{}, {'to_lower': True}], ids=repr) def test_lax_subclass_plain_enum(kwargs): - v = SchemaValidator(schema=core_schema.str_schema(**kwargs)) + v = SchemaValidator(core_schema.str_schema(**kwargs)) from enum import Enum @@ -270,7 +270,7 @@ def test_subclass_preserved() -> None: class StrSubclass(str): pass - v = SchemaValidator(schema=core_schema.str_schema()) + v = SchemaValidator(core_schema.str_schema()) assert not isinstance(v.validate_python(StrSubclass('')), StrSubclass) assert not isinstance(v.validate_python(StrSubclass(''), strict=True), StrSubclass) @@ -278,7 +278,7 @@ class StrSubclass(str): # unions do a first pass in strict mode # so verify that they don't match the str schema in strict mode # and preserve the type - v = SchemaValidator(schema=core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()])) + v = SchemaValidator(core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()])) assert not isinstance(v.validate_python(StrSubclass('')), StrSubclass) assert not isinstance(v.validate_python(StrSubclass(''), strict=True), StrSubclass) @@ -288,14 +288,14 @@ class StrSubclass(str): def test_coerce_numbers_to_str_with_invalid_unicode_character(string) -> None: config = core_schema.CoreConfig(coerce_numbers_to_str=True) - v = SchemaValidator(schema=core_schema.str_schema(strict=string), config=config) + v = SchemaValidator(core_schema.str_schema(strict=string), config=config) assert v.validate_python('\ud835') == '\ud835' def test_coerce_numbers_to_str_disabled_in_strict_mode() -> None: config = core_schema.CoreConfig(coerce_numbers_to_str=True) - v = SchemaValidator(schema=core_schema.str_schema(strict=True), config=config) + v = SchemaValidator(core_schema.str_schema(strict=True), config=config) with pytest.raises(ValidationError): v.validate_python(42) with pytest.raises(ValidationError): @@ -305,7 +305,7 @@ def test_coerce_numbers_to_str_disabled_in_strict_mode() -> None: def test_coerce_numbers_to_str_raises_for_bool() -> None: config = core_schema.CoreConfig(coerce_numbers_to_str=True) - v = SchemaValidator(schema=core_schema.str_schema(), config=config) + v = SchemaValidator(core_schema.str_schema(), config=config) with pytest.raises(ValidationError): v.validate_python(True) with pytest.raises(ValidationError): @@ -323,7 +323,7 @@ def test_coerce_numbers_to_str_raises_for_bool() -> None: def test_coerce_numbers_to_str(number: Number, expected_str: str) -> None: config = core_schema.CoreConfig(coerce_numbers_to_str=True) - v = SchemaValidator(schema=core_schema.str_schema(), config=config) + v = SchemaValidator(core_schema.str_schema(), config=config) assert v.validate_python(number) == expected_str @@ -338,7 +338,7 @@ def test_coerce_numbers_to_str(number: Number, expected_str: str) -> None: def test_coerce_numbers_to_str_from_json(number: str, expected_str: str) -> None: config = core_schema.CoreConfig(coerce_numbers_to_str=True) - v = SchemaValidator(schema=core_schema.str_schema(), config=config) + v = SchemaValidator(core_schema.str_schema(), config=config) assert v.validate_json(number) == expected_str @@ -349,9 +349,9 @@ def test_backtracking_regex_rust_unsupported(mode) -> None: with pytest.raises(SchemaError) as exc_info: if mode is None: # rust-regex is the default - SchemaValidator(schema=core_schema.str_schema(pattern=pattern)) + SchemaValidator(core_schema.str_schema(pattern=pattern)) elif mode == 'schema': - SchemaValidator(schema=core_schema.str_schema(pattern=pattern, regex_engine='rust-regex')) + SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='rust-regex')) elif mode == 'config': SchemaValidator( schema=core_schema.str_schema(pattern=pattern), config=core_schema.CoreConfig(regex_engine='rust-regex') @@ -371,7 +371,7 @@ def test_backtracking_regex_python(mode) -> None: pattern = r'r(#*)".*?"\1' if mode == 'schema': - v = SchemaValidator(schema=core_schema.str_schema(pattern=pattern, regex_engine='python-re')) + v = SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='python-re')) elif mode == 'config': v = SchemaValidator( schema=core_schema.str_schema(pattern=pattern), config=core_schema.CoreConfig(regex_engine='python-re') @@ -385,7 +385,7 @@ def test_backtracking_regex_python(mode) -> None: @pytest.mark.parametrize('number', (42, 443, 10242)) def test_coerce_numbers_to_str_schema(number: int): - v = SchemaValidator(schema=core_schema.str_schema(coerce_numbers_to_str=True)) + v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=True)) assert v.validate_python(number) == str(number) assert v.validate_json(str(number)) == str(number) @@ -393,12 +393,12 @@ def test_coerce_numbers_to_str_schema(number: int): @pytest.mark.parametrize('number', (42, 443, 10242)) def test_coerce_numbers_to_str_schema_precedence(number: int): config = core_schema.CoreConfig(coerce_numbers_to_str=False) - v = SchemaValidator(schema=core_schema.str_schema(coerce_numbers_to_str=True), config=config) + v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=True), config=config) assert v.validate_python(number) == str(number) assert v.validate_json(str(number)) == str(number) config = core_schema.CoreConfig(coerce_numbers_to_str=True) - v = SchemaValidator(schema=core_schema.str_schema(coerce_numbers_to_str=False), config=config) + v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=False), config=config) with pytest.raises(ValidationError): v.validate_python(number) with pytest.raises(ValidationError): @@ -407,7 +407,7 @@ def test_coerce_numbers_to_str_schema_precedence(number: int): @pytest.mark.parametrize('number', (42, 443, 10242)) def test_coerce_numbers_to_str_schema_with_strict_mode(number: int): - v = SchemaValidator(schema=core_schema.str_schema(coerce_numbers_to_str=True, strict=True)) + v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=True, strict=True)) with pytest.raises(ValidationError): v.validate_python(number) with pytest.raises(ValidationError): @@ -416,6 +416,6 @@ def test_coerce_numbers_to_str_schema_with_strict_mode(number: int): @pytest.mark.parametrize('engine', [None, 'rust-regex', 'python-re']) def test_compiled_regex(engine) -> None: - v = SchemaValidator(schema=core_schema.str_schema(pattern=re.compile('abc', re.IGNORECASE), regex_engine=engine)) + v = SchemaValidator(core_schema.str_schema(pattern=re.compile('abc', re.IGNORECASE), regex_engine=engine)) assert v.validate_python('abc') == 'abc' assert v.validate_python('ABC') == 'ABC' diff --git a/tests/validators/test_tagged_union.py b/tests/validators/test_tagged_union.py index 3950f3560..1dba17cee 100644 --- a/tests/validators/test_tagged_union.py +++ b/tests/validators/test_tagged_union.py @@ -209,7 +209,7 @@ class PlainEnum(Enum): TWO = 'two' v = SchemaValidator( - schema=core_schema.tagged_union_schema( + core_schema.tagged_union_schema( discriminator='foo', choices={ BarEnum.ONE: core_schema.typed_dict_schema( @@ -452,7 +452,7 @@ def discriminator_function(obj): def test_from_attributes(): v = SchemaValidator( - schema=core_schema.tagged_union_schema( + core_schema.tagged_union_schema( discriminator='foobar', choices={ 'apple': core_schema.model_fields_schema( @@ -487,7 +487,7 @@ def test_from_attributes(): def test_use_ref(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.tagged_union_schema( discriminator='foobar', choices={ @@ -509,7 +509,7 @@ def test_use_ref(): def test_downcast_error(): v = SchemaValidator( - schema=core_schema.tagged_union_schema(discriminator=lambda x: 123, choices={'str': core_schema.str_schema()}) + core_schema.tagged_union_schema(discriminator=lambda x: 123, choices={'str': core_schema.str_schema()}) ) with pytest.raises(ValidationError) as exc_info: v.validate_python('x') @@ -525,7 +525,7 @@ def test_downcast_error(): def test_custom_error(): v = SchemaValidator( - schema=core_schema.tagged_union_schema( + core_schema.tagged_union_schema( discriminator='foo', custom_error_type='snap', custom_error_message='Input should be a foo or bar', @@ -563,7 +563,7 @@ def test_custom_error(): def test_custom_error_type(): v = SchemaValidator( - schema=core_schema.tagged_union_schema( + core_schema.tagged_union_schema( discriminator='foo', custom_error_type='finite_number', choices={ diff --git a/tests/validators/test_time.py b/tests/validators/test_time.py index 5ee84d94b..069e359ad 100644 --- a/tests/validators/test_time.py +++ b/tests/validators/test_time.py @@ -33,7 +33,7 @@ ], ) def test_time(input_value, expected): - v = SchemaValidator(schema=core_schema.time_schema()) + v = SchemaValidator(core_schema.time_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -114,7 +114,7 @@ def test_time_error_microseconds_overflow(py_and_json: PyAndJson) -> None: ], ) def test_time_strict(input_value, expected): - v = SchemaValidator(schema=core_schema.time_schema(strict=True)) + v = SchemaValidator(core_schema.time_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -132,7 +132,7 @@ def test_time_strict(input_value, expected): ], ) def test_time_strict_json(input_value, expected): - v = SchemaValidator(schema=core_schema.time_schema(strict=True)) + v = SchemaValidator(core_schema.time_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value) @@ -159,7 +159,7 @@ def test_time_strict_json(input_value, expected): ], ) def test_time_kwargs(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator(schema=core_schema.time_schema(**kwargs)) + v = SchemaValidator(core_schema.time_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: v.validate_python(input_value) @@ -174,7 +174,7 @@ def test_time_kwargs(kwargs: dict[str, Any], input_value, expected): def test_time_bound_ctx(): - v = SchemaValidator(schema=core_schema.time_schema(gt=time(12, 13, 14, 123_456))) + v = SchemaValidator(core_schema.time_schema(gt=time(12, 13, 14, 123_456))) with pytest.raises(ValidationError) as exc_info: v.validate_python('12:13') @@ -196,7 +196,7 @@ def test_invalid_constraint(): def test_dict_py(): v = SchemaValidator( - schema=core_schema.dict_schema(keys_schema=core_schema.time_schema(), values_schema=core_schema.int_schema()) + core_schema.dict_schema(keys_schema=core_schema.time_schema(), values_schema=core_schema.int_schema()) ) assert v.validate_python({time(12, 1, 1): 2, time(12, 1, 2): 4}) == {time(12, 1, 1): 2, time(12, 1, 2): 4} @@ -207,17 +207,17 @@ def test_dict(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator(schema=core_schema.union_schema(choices=[core_schema.str_schema(), core_schema.time_schema()])) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.str_schema(), core_schema.time_schema()])) assert v.validate_python('12:01:02') == '12:01:02' assert v.validate_python(time(12, 1, 2)) == time(12, 1, 2) - v = SchemaValidator(schema=core_schema.union_schema(choices=[core_schema.time_schema(), core_schema.str_schema()])) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.time_schema(), core_schema.str_schema()])) assert v.validate_python('12:01:02') == '12:01:02' assert v.validate_python(time(12, 1, 2)) == time(12, 1, 2) def test_aware(): - v = SchemaValidator(schema=core_schema.time_schema(tz_constraint='aware')) + v = SchemaValidator(core_schema.time_schema(tz_constraint='aware')) value = time(12, 13, 15, tzinfo=timezone.utc) assert value is v.validate_python(value) assert v.validate_python('12:13:14Z') == time(12, 13, 14, tzinfo=timezone.utc) @@ -231,7 +231,7 @@ def test_aware(): def test_naive(): - v = SchemaValidator(schema=core_schema.time_schema(tz_constraint='naive')) + v = SchemaValidator(core_schema.time_schema(tz_constraint='naive')) value = time(12, 13, 15) assert value is v.validate_python(value) assert v.validate_python('12:13:14') == time(12, 13, 14) @@ -245,7 +245,7 @@ def test_naive(): def test_aware_specific(): - v = SchemaValidator(schema=core_schema.time_schema(tz_constraint=0)) + v = SchemaValidator(core_schema.time_schema(tz_constraint=0)) value = time(12, 13, 15, tzinfo=timezone.utc) assert value is v.validate_python(value) assert v.validate_python('12:13:14Z') == time(12, 13, 14, tzinfo=timezone.utc) @@ -273,7 +273,7 @@ def test_aware_specific(): def test_neg_7200(): - v = SchemaValidator(schema=core_schema.time_schema(tz_constraint=-7200)) + v = SchemaValidator(core_schema.time_schema(tz_constraint=-7200)) value = time(12, 13, 15, tzinfo=timezone(timedelta(hours=-2))) assert value is v.validate_python(value) @@ -290,7 +290,7 @@ def test_neg_7200(): def test_tz_constraint_too_high(): with pytest.raises(SchemaError, match='OverflowError: Python int too large to convert to C long'): - SchemaValidator(schema=core_schema.time_schema(tz_constraint=2**64)) + SchemaValidator(core_schema.time_schema(tz_constraint=2**64)) def test_tz_constraint_wrong(): diff --git a/tests/validators/test_timedelta.py b/tests/validators/test_timedelta.py index 2b4889870..e9b885481 100644 --- a/tests/validators/test_timedelta.py +++ b/tests/validators/test_timedelta.py @@ -57,7 +57,7 @@ ids=repr, ) def test_timedelta(input_value, expected): - v = SchemaValidator(schema=core_schema.timedelta_schema()) + v = SchemaValidator(core_schema.timedelta_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -82,7 +82,7 @@ def test_timedelta(input_value, expected): ids=repr, ) def test_timedelta_json(input_value, expected): - v = SchemaValidator(schema=core_schema.timedelta_schema()) + v = SchemaValidator(core_schema.timedelta_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value) @@ -103,7 +103,7 @@ def test_timedelta_json(input_value, expected): ], ) def test_timedelta_strict(input_value, expected): - v = SchemaValidator(schema=core_schema.timedelta_schema(strict=True)) + v = SchemaValidator(core_schema.timedelta_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -121,7 +121,7 @@ def test_timedelta_strict(input_value, expected): ], ) def test_timedelta_strict_json(input_value, expected): - v = SchemaValidator(schema=core_schema.timedelta_schema(strict=True)) + v = SchemaValidator(core_schema.timedelta_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value) @@ -179,7 +179,7 @@ def test_timedelta_strict_json(input_value, expected): ids=repr, ) def test_timedelta_kwargs(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator(schema=core_schema.timedelta_schema(**kwargs)) + v = SchemaValidator(core_schema.timedelta_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -189,7 +189,7 @@ def test_timedelta_kwargs(kwargs: dict[str, Any], input_value, expected): def test_timedelta_kwargs_strict(): - v = SchemaValidator(schema=core_schema.timedelta_schema(strict=True, le=timedelta(days=3))) + v = SchemaValidator(core_schema.timedelta_schema(strict=True, le=timedelta(days=3))) output = v.validate_python(timedelta(days=2, hours=1)) assert output == timedelta(days=2, hours=1) @@ -210,9 +210,7 @@ def test_invalid_constraint(): def test_dict_py(): v = SchemaValidator( - schema=core_schema.dict_schema( - keys_schema=core_schema.timedelta_schema(), values_schema=core_schema.int_schema() - ) + core_schema.dict_schema(keys_schema=core_schema.timedelta_schema(), values_schema=core_schema.int_schema()) ) assert v.validate_python({timedelta(days=2, hours=1): 2, timedelta(days=2, hours=2): 4}) == { timedelta(days=2, hours=1): 2, @@ -237,15 +235,11 @@ def test_dict_value(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator( - schema=core_schema.union_schema(choices=[core_schema.str_schema(), core_schema.timedelta_schema()]) - ) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.str_schema(), core_schema.timedelta_schema()])) assert v.validate_python('P2DT1H') == 'P2DT1H' assert v.validate_python(timedelta(days=2, hours=1)) == timedelta(days=2, hours=1) - v = SchemaValidator( - schema=core_schema.union_schema(choices=[core_schema.timedelta_schema(), core_schema.str_schema()]) - ) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.timedelta_schema(), core_schema.str_schema()])) assert v.validate_python('P2DT1H') == 'P2DT1H' assert v.validate_python(timedelta(days=2, hours=1)) == timedelta(days=2, hours=1) @@ -273,7 +267,7 @@ def test_union(): ids=repr, ) def test_pytimedelta_as_timedelta(constraint, expected_duration): - v = SchemaValidator(schema=core_schema.timedelta_schema(gt=constraint)) + v = SchemaValidator(core_schema.timedelta_schema(gt=constraint)) # simplest way to check `pytimedelta_as_timedelta` is correct is to extract duration from repr of the validator m = re.search(r'Duration ?\{\s+positive: ?(\w+),\s+day: ?(\d+),\s+second: ?(\d+),\s+microsecond: ?(\d+)', repr(v)) pos, day, sec, micro = m.groups() @@ -282,7 +276,7 @@ def test_pytimedelta_as_timedelta(constraint, expected_duration): def test_large_value(): - v = SchemaValidator(schema=core_schema.timedelta_schema()) + v = SchemaValidator(core_schema.timedelta_schema()) assert v.validate_python('123days, 12:34') == timedelta(days=123, hours=12, minutes=34) assert v.validate_python(f'{999_999_999}days, 12:34') == timedelta(days=999_999_999, hours=12, minutes=34) with pytest.raises(ValidationError, match='should be a valid timedelta, durations may not exceed 999,999,999 days'): @@ -291,7 +285,7 @@ def test_large_value(): @pytest.mark.skipif(not pandas, reason='pandas not installed') def test_pandas(): - v = SchemaValidator(schema=core_schema.timedelta_schema(ge=timedelta(hours=2))) + v = SchemaValidator(core_schema.timedelta_schema(ge=timedelta(hours=2))) two_hours = pandas.Timestamp('2023-01-01T02:00:00Z') - pandas.Timestamp('2023-01-01T00:00:00Z') assert v.validate_python(two_hours) == two_hours diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py index 816d32dac..286b327d7 100644 --- a/tests/validators/test_tuple.py +++ b/tests/validators/test_tuple.py @@ -35,7 +35,7 @@ def test_tuple_json(py_and_json: PyAndJson, variadic_item_index, items, input_va def test_any_no_copy(): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0)) input_value = (1, '2', b'3') output = v.validate_python(input_value) assert output == input_value @@ -53,14 +53,14 @@ def test_any_no_copy(): ) def test_tuple_strict_passes_with_tuple(variadic_item_index, items, input_value, expected): v = SchemaValidator( - schema=core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index, strict=True) + core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index, strict=True) ) assert v.validate_python(input_value) == expected @pytest.mark.parametrize('fail_fast', [True, False]) def test_empty_positional_tuple(fail_fast): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[], fail_fast=fail_fast)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[], fail_fast=fail_fast)) assert v.validate_python(()) == () assert v.validate_python([]) == () with pytest.raises(ValidationError) as exc_info: @@ -84,7 +84,7 @@ def test_empty_positional_tuple(fail_fast): @pytest.mark.parametrize('wrong_coll_type', [list, set, frozenset]) def test_tuple_strict_fails_without_tuple(wrong_coll_type: type[Any], variadic_item_index, items): v = SchemaValidator( - schema=core_schema.tuple_schema(variadic_item_index=variadic_item_index, items_schema=items, strict=True) + core_schema.tuple_schema(variadic_item_index=variadic_item_index, items_schema=items, strict=True) ) with pytest.raises(ValidationError) as exc_info: v.validate_python(wrong_coll_type([1, 2, '33'])) @@ -125,7 +125,7 @@ def test_tuple_strict_fails_without_tuple(wrong_coll_type: type[Any], variadic_i ) def test_tuple_var_len_kwargs(kwargs: dict[str, Any], input_value, expected): v = SchemaValidator( - schema=core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0, **kwargs) + core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0, **kwargs) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -152,7 +152,7 @@ def test_tuple_var_len_kwargs(kwargs: dict[str, Any], input_value, expected): ids=repr, ) def test_tuple_validate(input_value, expected, variadic_item_index, items): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -167,7 +167,7 @@ def test_tuple_validate(input_value, expected, variadic_item_index, items): 'variadic_item_index,items', [(0, [{'type': 'int'}]), (None, [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])] ) def test_tuple_validate_iterator(variadic_item_index, items): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index)) assert v.validate_python(x for x in [1, 2, '3']) == (1, 2, 3) @@ -182,7 +182,7 @@ def test_tuple_validate_iterator(variadic_item_index, items): ], ) def test_tuple_var_len_errors(input_value, index): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) with pytest.raises(ValidationError) as exc_info: assert v.validate_python(input_value) assert exc_info.value.errors(include_url=False) == [ @@ -210,7 +210,7 @@ def test_tuple_var_len_errors(input_value, index): ], ) def test_tuple_fix_len_errors(input_value, items, index): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=items)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=items)) with pytest.raises(ValidationError) as exc_info: assert v.validate_python(input_value) assert exc_info.value.errors(include_url=False) == [ @@ -278,7 +278,7 @@ def test_positional_empty_extra(py_and_json: PyAndJson): @pytest.mark.parametrize('input_value,expected', [((1, 2, 3), (1, 2, 3)), ([1, 2, 3], [1, 2, 3])]) def test_union_tuple_list(input_value, expected): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[ core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0), core_schema.list_schema(), @@ -321,7 +321,7 @@ def test_union_tuple_list(input_value, expected): ) def test_union_tuple_var_len(input_value, expected): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[ core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0, strict=True), core_schema.tuple_schema(items_schema=[core_schema.str_schema()], variadic_item_index=0, strict=True), @@ -367,7 +367,7 @@ def test_union_tuple_var_len(input_value, expected): ) def test_union_tuple_fix_len(input_value, expected): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[ core_schema.tuple_schema( items_schema=[core_schema.int_schema(), core_schema.int_schema(), core_schema.int_schema()], @@ -390,9 +390,7 @@ def test_union_tuple_fix_len(input_value, expected): def test_tuple_fix_error(): - v = SchemaValidator( - schema=core_schema.tuple_schema(items_schema=[core_schema.int_schema(), core_schema.str_schema()]) - ) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema(), core_schema.str_schema()])) with pytest.raises(ValidationError) as exc_info: v.validate_python([1]) @@ -414,7 +412,7 @@ def test_tuple_fix_error(): ) def test_tuple_fix_extra(input_value, expected): v = SchemaValidator( - schema=core_schema.tuple_schema( + core_schema.tuple_schema( items_schema=[core_schema.int_schema(), core_schema.str_schema(), core_schema.str_schema()], variadic_item_index=2, ) @@ -430,7 +428,7 @@ def test_tuple_fix_extra(input_value, expected): def test_tuple_fix_extra_any(): v = SchemaValidator( - schema=core_schema.tuple_schema( + core_schema.tuple_schema( items_schema=[core_schema.str_schema(), core_schema.any_schema()], variadic_item_index=1 ) ) @@ -453,7 +451,7 @@ def gen(error: bool): raise RuntimeError('error') yield 3 - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0)) assert v.validate_python(gen(False)) == (1, 2, 3) msg = r'Error iterating over object, error: RuntimeError: error \[type=iteration_error,' @@ -480,7 +478,7 @@ def gen(error: bool): ], ) def test_frozenset_from_dict_items(input_value, items_schema, expected): - v = SchemaValidator(schema=core_schema.tuple_schema(items_schema=[items_schema], variadic_item_index=0)) + v = SchemaValidator(core_schema.tuple_schema(items_schema=[items_schema], variadic_item_index=0)) output = v.validate_python(input_value) assert isinstance(output, tuple) assert output == expected @@ -496,7 +494,7 @@ def test_frozenset_from_dict_items(input_value, items_schema, expected): ) def test_length_constraints_omit(input_value, expected): v = SchemaValidator( - schema=core_schema.tuple_schema( + core_schema.tuple_schema( items_schema=[core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit')], variadic_item_index=0, max_length=4, @@ -554,7 +552,7 @@ def test_tuple_fail_fast(fail_fast, expected): variadic_item_index=None, fail_fast=fail_fast, ) - v = SchemaValidator(schema=s) + v = SchemaValidator(s) with pytest.raises(ValidationError) as exc_info: v.validate_python(['str', 'not-num', 'again']) diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py index 4d11c9e0a..cbbd21846 100644 --- a/tests/validators/test_typed_dict.py +++ b/tests/validators/test_typed_dict.py @@ -41,7 +41,7 @@ def __repr__(self): def test_simple(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()), @@ -76,7 +76,7 @@ def test_strict(): def test_with_default(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'field_b': core_schema.typed_dict_field( @@ -92,7 +92,7 @@ def test_with_default(): def test_missing_error(pydantic_version): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()), @@ -136,7 +136,7 @@ def test_missing_error(pydantic_version): ) def test_config(config: CoreConfig, input_value, expected): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'a': core_schema.typed_dict_field(schema=core_schema.int_schema()), 'b': core_schema.typed_dict_field(schema=core_schema.float_schema(), required=False), @@ -155,7 +155,7 @@ def test_config(config: CoreConfig, input_value, expected): def test_ignore_extra(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()), @@ -168,7 +168,7 @@ def test_ignore_extra(): def test_forbid_extra(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema())}, extra_behavior='forbid' ) ) @@ -197,7 +197,7 @@ def test_allow_extra_wrong(): def test_str_config(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema())}, config=CoreConfig(str_max_length=5), ) @@ -210,7 +210,7 @@ def test_str_config(): def test_json_error(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field( schema=core_schema.list_schema(items_schema=core_schema.int_schema()) @@ -239,7 +239,7 @@ def test_missing_schema_key(): def test_fields_required_by_default(): """By default all fields should be required""" v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'y': core_schema.typed_dict_field(schema=core_schema.str_schema()), @@ -259,7 +259,7 @@ def test_fields_required_by_default(): def test_fields_required_by_default_with_optional(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'y': core_schema.typed_dict_field(schema=core_schema.str_schema(), required=False), @@ -273,7 +273,7 @@ def test_fields_required_by_default_with_optional(): def test_fields_required_by_default_with_default(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'y': core_schema.typed_dict_field( @@ -290,7 +290,7 @@ def test_fields_required_by_default_with_default(): def test_all_optional_fields(): """By default all fields should be optional if `total` is set to `False`""" v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( total=False, fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema(strict=True)), @@ -313,7 +313,7 @@ def test_all_optional_fields(): def test_all_optional_fields_with_required_fields(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( total=False, fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema(strict=True), required=True), @@ -491,7 +491,7 @@ def test_aliases_path_multiple(py_and_json: PyAndJson, input_value, expected): ) def test_aliases_path_negative(input_value, expected): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field(validation_alias=['foo', -2], schema=core_schema.int_schema()) }, @@ -536,7 +536,7 @@ def test_aliases_path_negative_json(py_and_json: PyAndJson, input_value, expecte def test_aliases_debug(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field( validation_alias=[['foo', 'bar', 'bat'], ['foo', 3]], schema=core_schema.int_schema() @@ -551,7 +551,7 @@ def test_aliases_debug(): def get_int_key(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field( validation_alias=[['foo', 3], ['spam']], schema=core_schema.int_schema() @@ -570,7 +570,7 @@ def __getitem__(self, v): def get_custom_getitem(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={'field_a': core_schema.typed_dict_field(validation_alias=['foo'], schema=core_schema.int_schema())} ) ) @@ -714,7 +714,7 @@ def test_alias_error_loc_field_names(py_and_json: PyAndJson): def test_empty_model(): - v = SchemaValidator(schema=core_schema.typed_dict_schema(fields={})) + v = SchemaValidator(core_schema.typed_dict_schema(fields={})) assert v.validate_python({}) == {} with pytest.raises(ValidationError, match=re.escape('Input should be a valid dictionary [type=dict_type,')): v.validate_python('x') @@ -722,7 +722,7 @@ def test_empty_model(): def test_model_deep(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'field_b': core_schema.typed_dict_field( @@ -820,7 +820,7 @@ def test_alias_extra_forbid(py_and_json: PyAndJson): def test_with_default_factory(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field( schema=core_schema.with_default_schema( @@ -861,7 +861,7 @@ def test_field_required_and_default_factory(): ) def test_bad_default_factory(default_factory, error_message): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field( schema=core_schema.with_default_schema( @@ -1075,7 +1075,7 @@ def test_extra_behavior_allow( expected_extra_value: Any, ): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw, **extras_schema_kw, @@ -1099,7 +1099,7 @@ def test_extra_behavior_allow( ) def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw, config=config ) ) @@ -1128,7 +1128,7 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche ) def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw ), config=config, @@ -1154,7 +1154,7 @@ def validate(v, info): # If any of the Rust validators don't implement traversal properly, # there will be an undetectable cycle created by this assignment # which will keep Defaulted alive - validate.__pydantic_validator__ = SchemaValidator(schema=schema) + validate.__pydantic_validator__ = SchemaValidator(schema) return validate diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py index 993cb643f..70acd6cfd 100644 --- a/tests/validators/test_union.py +++ b/tests/validators/test_union.py @@ -29,7 +29,7 @@ ], ) def test_union_bool_int(input_value, expected_value): - v = SchemaValidator(schema=core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.int_schema()])) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.int_schema()])) assert v.validate_python(input_value) == expected_value @@ -49,7 +49,7 @@ def test_union_bool_int(input_value, expected_value): ], ) def test_union_int_bool(input_value, expected_value): - v = SchemaValidator(schema=core_schema.union_schema(choices=[core_schema.int_schema(), core_schema.bool_schema()])) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.int_schema(), core_schema.bool_schema()])) assert v.validate_python(input_value) == expected_value @@ -185,7 +185,7 @@ def test_model_b_not_ignored(self, schema_validator: SchemaValidator): def test_nullable_via_union(): - v = SchemaValidator(schema=core_schema.union_schema(choices=[core_schema.none_schema(), core_schema.int_schema()])) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.none_schema(), core_schema.int_schema()])) assert v.validate_python(None) is None assert v.validate_python(1) == 1 with pytest.raises(ValidationError) as exc_info: @@ -203,7 +203,7 @@ def test_nullable_via_union(): def test_union_list_bool_int(): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[ core_schema.list_schema(items_schema=core_schema.bool_schema()), core_schema.list_schema(items_schema=core_schema.int_schema()), @@ -250,11 +250,11 @@ def test_no_choices(pydantic_version): def test_empty_choices(): msg = r'Error building "union" validator:\s+SchemaError: One or more union choices required' with pytest.raises(SchemaError, match=msg): - SchemaValidator(schema=core_schema.union_schema(choices=[])) + SchemaValidator(core_schema.union_schema(choices=[])) def test_one_choice(): - v = SchemaValidator(schema=core_schema.union_schema(choices=[core_schema.str_schema()])) + v = SchemaValidator(core_schema.union_schema(choices=[core_schema.str_schema()])) assert ( plain_repr(v) == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:false,coerce_numbers_to_str:false}),definitions=[],cache_strings=True)' @@ -264,7 +264,7 @@ def test_one_choice(): def test_strict_union(): v = SchemaValidator( - schema=core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema()]) + core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema()]) ) assert v.validate_python(1) == 1 assert v.validate_python(123) == 123 @@ -280,7 +280,7 @@ def test_strict_union(): def test_custom_error(): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[core_schema.str_schema(), core_schema.bytes_schema()], custom_error_type='my_error', custom_error_message='Input should be a string or bytes', @@ -298,7 +298,7 @@ def test_custom_error(): def test_custom_error_type(): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[core_schema.str_schema(), core_schema.bytes_schema()], custom_error_type='string_type' ) ) @@ -314,7 +314,7 @@ def test_custom_error_type(): def test_custom_error_type_context(): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[core_schema.str_schema(), core_schema.bytes_schema()], custom_error_type='less_than', custom_error_context={'lt': 42}, @@ -342,13 +342,13 @@ def test_dirty_behaviour(): def test_int_float(): - v = SchemaValidator(schema=core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()])) + v = SchemaValidator(core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()])) assert v.validate_python(1) == IsInt(approx=1, delta=0) assert v.validate_json('1') == IsInt(approx=1, delta=0) assert v.validate_python(1.0) == IsFloat(approx=1, delta=0) assert v.validate_json('1.0') == IsFloat(approx=1, delta=0) - v = SchemaValidator(schema=core_schema.union_schema([core_schema.float_schema(), core_schema.int_schema()])) + v = SchemaValidator(core_schema.union_schema([core_schema.float_schema(), core_schema.int_schema()])) assert v.validate_python(1) == IsInt(approx=1, delta=0) assert v.validate_json('1') == IsInt(approx=1, delta=0) assert v.validate_python(1.0) == IsFloat(approx=1, delta=0) @@ -356,7 +356,7 @@ def test_int_float(): def test_str_float(): - v = SchemaValidator(schema=core_schema.union_schema([core_schema.str_schema(), core_schema.float_schema()])) + v = SchemaValidator(core_schema.union_schema([core_schema.str_schema(), core_schema.float_schema()])) assert v.validate_python(1) == IsFloat(approx=1, delta=0) assert v.validate_json('1') == IsFloat(approx=1, delta=0) @@ -368,7 +368,7 @@ def test_str_float(): assert v.validate_json('"1.0"') == '1.0' assert v.validate_json('"1"') == '1' - v = SchemaValidator(schema=core_schema.union_schema([core_schema.float_schema(), core_schema.str_schema()])) + v = SchemaValidator(core_schema.union_schema([core_schema.float_schema(), core_schema.str_schema()])) assert v.validate_python(1) == IsFloat(approx=1, delta=0) assert v.validate_json('1') == IsFloat(approx=1, delta=0) assert v.validate_python(1.0) == IsFloat(approx=1, delta=0) @@ -381,16 +381,14 @@ def test_str_float(): def test_no_strict_check(): - v = SchemaValidator( - schema=core_schema.union_schema([core_schema.is_instance_schema(int), core_schema.json_schema()]) - ) + v = SchemaValidator(core_schema.union_schema([core_schema.is_instance_schema(int), core_schema.json_schema()])) assert v.validate_python(123) == 123 assert v.validate_python('[1, 2, 3]') == [1, 2, 3] def test_strict_reference(): v = SchemaValidator( - schema=core_schema.definitions_schema( + core_schema.definitions_schema( core_schema.definition_reference_schema(schema_ref='tuple-ref'), [ core_schema.tuple_positional_schema( @@ -412,7 +410,7 @@ def test_strict_reference(): def test_case_labels(): v = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[core_schema.none_schema(), ({'type': 'int'}, 'my_label'), core_schema.str_schema()] ) ) @@ -434,7 +432,7 @@ def test_case_labels(): def test_left_to_right_doesnt_care_about_strict_check(): v = SchemaValidator( - schema=core_schema.union_schema([core_schema.int_schema(), core_schema.json_schema()], mode='left_to_right') + core_schema.union_schema([core_schema.int_schema(), core_schema.json_schema()], mode='left_to_right') ) assert 'strict_required' not in plain_repr(v) assert 'ultra_strict_required' not in plain_repr(v) @@ -444,13 +442,13 @@ def test_left_to_right_union(): choices = [core_schema.int_schema(), core_schema.float_schema()] # smart union prefers float - v = SchemaValidator(schema=core_schema.union_schema(choices, mode='smart')) + v = SchemaValidator(core_schema.union_schema(choices, mode='smart')) out = v.validate_python(1.0) assert out == 1.0 assert isinstance(out, float) # left_to_right union will select int - v = SchemaValidator(schema=core_schema.union_schema(choices, mode='left_to_right')) + v = SchemaValidator(core_schema.union_schema(choices, mode='left_to_right')) out = v.validate_python(1) assert out == 1 assert isinstance(out, int) @@ -460,7 +458,7 @@ def test_left_to_right_union(): assert isinstance(out, int) # reversing them will select float - v = SchemaValidator(schema=core_schema.union_schema(list(reversed(choices)), mode='left_to_right')) + v = SchemaValidator(core_schema.union_schema(list(reversed(choices)), mode='left_to_right')) out = v.validate_python(1.0) assert out == 1.0 assert isinstance(out, float) @@ -474,7 +472,7 @@ def test_left_to_right_union_strict(): choices = [core_schema.int_schema(), core_schema.float_schema()] # left_to_right union will select not cast if int first (strict int will not accept float) - v = SchemaValidator(schema=core_schema.union_schema(choices, mode='left_to_right', strict=True)) + v = SchemaValidator(core_schema.union_schema(choices, mode='left_to_right', strict=True)) out = v.validate_python(1) assert out == 1 assert isinstance(out, int) @@ -484,7 +482,7 @@ def test_left_to_right_union_strict(): assert isinstance(out, float) # reversing union will select float always (as strict float will accept int) - v = SchemaValidator(schema=core_schema.union_schema(list(reversed(choices)), mode='left_to_right', strict=True)) + v = SchemaValidator(core_schema.union_schema(list(reversed(choices)), mode='left_to_right', strict=True)) out = v.validate_python(1.0) assert out == 1.0 assert isinstance(out, float) @@ -515,7 +513,7 @@ def remove_prefix(v: str): prefixed_uuid_schema = core_schema.no_info_before_validator_function(remove_prefix, core_schema.uuid_schema()) - v = SchemaValidator(schema=core_schema.union_schema([special_values_schema, prefixed_uuid_schema])) + v = SchemaValidator(core_schema.union_schema([special_values_schema, prefixed_uuid_schema])) assert v.validate_python('uuid::12345678-1234-5678-1234-567812345678') == UUID( '12345678-1234-5678-1234-567812345678' @@ -544,7 +542,7 @@ def test_smart_union_json_string_types(schema: core_schema.CoreSchema, input_val # when parsing in JSON mode these types are preferred # TODO: in V3 we will make str win in all these cases. - validator = SchemaValidator(schema=core_schema.union_schema([schema, core_schema.str_schema()])) + validator = SchemaValidator(core_schema.union_schema([schema, core_schema.str_schema()])) assert validator.validate_json(f'"{input_value}"') == expected_value # in Python mode the string will be preferred assert validator.validate_python(input_value) == input_value @@ -567,7 +565,7 @@ def test_smart_union_json_string_types(schema: core_schema.CoreSchema, input_val ) def test_smart_union_json_string_types_str_first(schema: core_schema.CoreSchema, input_value: str): # As above, but reversed order; str should always win - validator = SchemaValidator(schema=core_schema.union_schema([core_schema.str_schema(), schema])) + validator = SchemaValidator(core_schema.union_schema([core_schema.str_schema(), schema])) assert validator.validate_json(f'"{input_value}"') == input_value assert validator.validate_python(input_value) == input_value @@ -601,7 +599,7 @@ class ModelB: ] ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) result = validator.validate_python({'x': 1}) assert isinstance(result, ModelA) @@ -631,7 +629,7 @@ class ModelB: ] ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) result = validator.validate_python({'x': 1}) assert isinstance(result, ModelA) @@ -670,7 +668,7 @@ class ModelB: ] ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) result = validator.validate_python({'x': 1}) assert isinstance(result, ModelA) @@ -686,12 +684,12 @@ def test_smart_union_with_any(): # str not coerced to int schema = core_schema.union_schema([core_schema.int_schema(), core_schema.any_schema()]) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert validator.validate_python('1') == '1' # int *is* coerced to float, this is a strict validation schema = core_schema.union_schema([core_schema.float_schema(), core_schema.any_schema()]) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert repr(validator.validate_python(1)) == '1.0' @@ -700,7 +698,7 @@ def test_smart_union_validator_function(): inner_schema = core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()]) - validator = SchemaValidator(schema=inner_schema) + validator = SchemaValidator(inner_schema) assert repr(validator.validate_python(1)) == '1' assert repr(validator.validate_python(1.0)) == '1.0' @@ -708,7 +706,7 @@ def test_smart_union_validator_function(): [core_schema.no_info_after_validator_function(lambda v: v * 2, inner_schema), core_schema.str_schema()] ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '2.0' assert validator.validate_python('1') == '1' @@ -720,7 +718,7 @@ def test_smart_union_validator_function(): ] ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '2.0' assert validator.validate_python('1') == '1' @@ -736,7 +734,7 @@ def test_smart_union_validator_function_one_arm(): ] ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '1.0' @@ -747,7 +745,7 @@ def test_smart_union_validator_function_one_arm(): ] ) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '1.0' @@ -764,7 +762,7 @@ class BinaryEnum(IntEnum): schema = core_schema.union_schema([enum_schema, core_schema.int_schema()]) - validator = SchemaValidator(schema=schema) + validator = SchemaValidator(schema) assert validator.validate_python(0) is not BinaryEnum.ZERO assert validator.validate_python(1) is not BinaryEnum.ONE @@ -778,7 +776,7 @@ class ModelA: pass validator = SchemaValidator( - schema=core_schema.union_schema( + core_schema.union_schema( choices=[ core_schema.model_schema( cls=ModelA, @@ -825,7 +823,7 @@ class ModelB(ModelA): @pytest.mark.parametrize('choices', permute_choices([model_a_schema, model_b_schema])) def test_more_specific_data_matches_subclass(self, choices) -> None: - validator = SchemaValidator(schema=core_schema.union_schema(choices)) + validator = SchemaValidator(core_schema.union_schema(choices)) assert isinstance(validator.validate_python({'a': 1}), self.ModelA) assert isinstance(validator.validate_python({'a': 1, 'b': 2}), self.ModelB) @@ -860,7 +858,7 @@ class ModelB: @pytest.mark.parametrize('choices', permute_choices([model_a_schema, model_b_schema])) def test_fields_set_ensures_best_match(self, choices) -> None: - validator = SchemaValidator(schema=core_schema.union_schema(choices)) + validator = SchemaValidator(core_schema.union_schema(choices)) assert isinstance(validator.validate_python({'a': 1}), self.ModelA) assert isinstance(validator.validate_python({'b': 1}), self.ModelB) @@ -921,7 +919,7 @@ class ModelB(ModelA): ) for choices in permute_choices([dc_a_schema, dc_b_schema]): - validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) + validator = SchemaValidator(core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'x': 1}), ModelA) assert isinstance(validator.validate_python({'x': '1'}), ModelA) @@ -968,7 +966,7 @@ class ModelB: ) for choices in permute_choices([dc_a_schema, dc_b_schema]): - validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) + validator = SchemaValidator(core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'a': 1}), ModelA) assert isinstance(validator.validate_python({'b': 1}), ModelB) @@ -987,7 +985,7 @@ def test_td_smart_union_by_fields_set() -> None: ) for choices in permute_choices([td_a_schema, td_b_schema]): - validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) + validator = SchemaValidator(core_schema.union_schema(choices=choices)) assert set(validator.validate_python({'x': 1}).keys()) == {'x'} assert set(validator.validate_python({'x': '1'}).keys()) == {'x'} @@ -1052,7 +1050,7 @@ class ModelB: ) for choices in permute_choices([model_a_schema, model_b_schema]): - validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) + validator = SchemaValidator(core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'sub': {'x': 1}}), ModelA) assert isinstance(validator.validate_python({'sub': {'y': 3}}), ModelB) @@ -1135,7 +1133,7 @@ class ModelB: ) for choices in permute_choices([dc_a_schema, dc_b_schema]): - validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) + validator = SchemaValidator(core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'sub': {'x': 1}}), ModelA) assert isinstance(validator.validate_python({'sub': {'y': 3}}), ModelB) @@ -1162,7 +1160,7 @@ def test_smart_union_does_nested_typed_dict_field_counting() -> None: ) for choices in permute_choices([td_a_schema, td_b_schema]): - validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) + validator = SchemaValidator(core_schema.union_schema(choices=choices)) assert set(validator.validate_python({'sub': {'x': 1}})['sub'].keys()) == {'x'} assert set(validator.validate_python({'sub': {'y': 2}})['sub'].keys()) == {'y'} @@ -1285,7 +1283,7 @@ class Model: x: Union[Foo, Bar] validator = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( Model, core_schema.model_fields_schema( fields={ diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py index 8d721ea36..c2f3f2e14 100644 --- a/tests/validators/test_url.py +++ b/tests/validators/test_url.py @@ -51,7 +51,7 @@ def test_url_from_constructor_ok(): @pytest.fixture(scope='module', name='url_validator') def url_validator_fixture(): - return SchemaValidator(schema=core_schema.url_schema()) + return SchemaValidator(core_schema.url_schema()) SCHEMA_VALIDATOR_MODE = 'SCHEMA_VALIDATOR' @@ -283,12 +283,12 @@ def test_url_cases(url_validator, url, expected, mode): ], ) def test_url_defaults_single_url(validator_kwargs, url, expected): - s = SchemaValidator(schema=core_schema.url_schema(**validator_kwargs)) + s = SchemaValidator(core_schema.url_schema(**validator_kwargs)) url_test_case_helper(url, expected, SCHEMA_VALIDATOR_MODE, s) def test_url_host_required(): - s = SchemaValidator(schema=core_schema.url_schema(host_required=True)) + s = SchemaValidator(core_schema.url_schema(host_required=True)) url_test_case_helper('test:', Err('empty host'), SCHEMA_VALIDATOR_MODE, s) url_test_case_helper('sftp://', Err('empty host'), SCHEMA_VALIDATOR_MODE, s) @@ -328,7 +328,7 @@ def test_url_host_required(): ], ) def test_url_defaults_multi_host_url(validator_kwargs, url, expected): - s = SchemaValidator(schema=core_schema.multi_host_url_schema(**validator_kwargs)) + s = SchemaValidator(core_schema.multi_host_url_schema(**validator_kwargs)) url_test_case_helper(url, expected, SCHEMA_VALIDATOR_MODE, s) @@ -362,12 +362,12 @@ def test_multi_host_url(url, expected): def test_multi_host_default_host_no_comma(): with pytest.raises(SchemaError, match='default_host cannot contain a comma, see pydantic-core#326'): - SchemaValidator(schema=core_schema.multi_host_url_schema(default_host='foo,bar')) + SchemaValidator(core_schema.multi_host_url_schema(default_host='foo,bar')) @pytest.fixture(scope='module', name='strict_url_validator') def strict_url_validator_fixture(): - return SchemaValidator(schema=core_schema.url_schema(), config=CoreConfig(strict=True)) + return SchemaValidator(core_schema.url_schema(), config=CoreConfig(strict=True)) @pytest.mark.parametrize( @@ -430,7 +430,7 @@ def test_no_host(url_validator): def test_max_length(): - v = SchemaValidator(schema=core_schema.url_schema(max_length=25)) + v = SchemaValidator(core_schema.url_schema(max_length=25)) assert str(v.validate_python('https://example.com')) == 'https://example.com/' with pytest.raises(ValidationError) as exc_info: v.validate_python('https://example.com/foo/bar') @@ -447,7 +447,7 @@ def test_max_length(): def test_allowed_schemes_ok(): - v = SchemaValidator(schema=core_schema.url_schema(allowed_schemes=['http', 'https'])) + v = SchemaValidator(core_schema.url_schema(allowed_schemes=['http', 'https'])) url = v.validate_python(' https://example.com ') assert url.host == 'example.com' assert url.scheme == 'https' @@ -456,7 +456,7 @@ def test_allowed_schemes_ok(): def test_allowed_schemes_error(): - v = SchemaValidator(schema=core_schema.url_schema(allowed_schemes=['http', 'https'])) + v = SchemaValidator(core_schema.url_schema(allowed_schemes=['http', 'https'])) with pytest.raises(ValidationError) as exc_info: v.validate_python('unix:/run/foo.socket') # insert_assert(exc_info.value.errors(include_url=False)) @@ -472,7 +472,7 @@ def test_allowed_schemes_error(): def test_allowed_schemes_errors(): - v = SchemaValidator(schema=core_schema.url_schema(allowed_schemes=['a', 'b', 'c'])) + v = SchemaValidator(core_schema.url_schema(allowed_schemes=['a', 'b', 'c'])) with pytest.raises(ValidationError) as exc_info: v.validate_python('unix:/run/foo.socket') # insert_assert(exc_info.value.errors(include_url=False)) @@ -520,11 +520,11 @@ def test_url_to_url(url_validator, multi_host_url_validator): def test_url_to_constraint(): - v1 = SchemaValidator(schema=core_schema.url_schema()) + v1 = SchemaValidator(core_schema.url_schema()) url: Url = v1.validate_python('http://example.com/foobar/bar') assert str(url) == 'http://example.com/foobar/bar' - v2 = SchemaValidator(schema=core_schema.url_schema(max_length=25)) + v2 = SchemaValidator(core_schema.url_schema(max_length=25)) with pytest.raises(ValidationError) as exc_info: v2.validate_python(url) @@ -539,7 +539,7 @@ def test_url_to_constraint(): } ] - v3 = SchemaValidator(schema=core_schema.url_schema(allowed_schemes=['https'])) + v3 = SchemaValidator(core_schema.url_schema(allowed_schemes=['https'])) with pytest.raises(ValidationError) as exc_info: v3.validate_python(url) @@ -651,7 +651,7 @@ def test_multi_host_url_ok_2(py_and_json: PyAndJson): @pytest.fixture(scope='module', name='multi_host_url_validator') def multi_host_url_validator_fixture(): - return SchemaValidator(schema=core_schema.multi_host_url_schema()) + return SchemaValidator(core_schema.multi_host_url_schema()) @pytest.mark.parametrize( @@ -922,7 +922,7 @@ def test_multi_url_cases(multi_host_url_validator, url, expected): @pytest.fixture(scope='module', name='strict_multi_host_url_validator') def strict_multi_host_url_validator_fixture(): - return SchemaValidator(schema=core_schema.multi_host_url_schema(strict=True)) + return SchemaValidator(core_schema.multi_host_url_schema(strict=True)) @pytest.mark.parametrize( @@ -998,7 +998,7 @@ def test_multi_wrong_type(multi_host_url_validator): def test_multi_allowed_schemas(): - v = SchemaValidator(schema=core_schema.multi_host_url_schema(allowed_schemes=['http', 'foo'])) + v = SchemaValidator(core_schema.multi_host_url_schema(allowed_schemes=['http', 'foo'])) assert str(v.validate_python('http://example.com')) == 'http://example.com/' assert str(v.validate_python('foo://example.com')) == 'foo://example.com' with pytest.raises(ValidationError, match=r"URL scheme should be 'http' or 'foo' \[type=url_scheme,"): @@ -1006,7 +1006,7 @@ def test_multi_allowed_schemas(): def test_multi_max_length(url_validator): - v = SchemaValidator(schema=core_schema.multi_host_url_schema(max_length=25)) + v = SchemaValidator(core_schema.multi_host_url_schema(max_length=25)) assert str(v.validate_python('http://example.com')) == 'http://example.com/' with pytest.raises(ValidationError, match=r'URL should have at most 25 characters \[type=url_too_long,'): v.validate_python('https://example.com/this-is-too-long') @@ -1025,7 +1025,7 @@ def test_multi_max_length(url_validator): def test_zero_schemas(): with pytest.raises(SchemaError, match='`allowed_schemes` should have length > 0'): - SchemaValidator(schema=core_schema.multi_host_url_schema(allowed_schemes=[])) + SchemaValidator(core_schema.multi_host_url_schema(allowed_schemes=[])) @pytest.mark.parametrize( diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py index 92dad04e6..c8a609482 100644 --- a/tests/validators/test_uuid.py +++ b/tests/validators/test_uuid.py @@ -81,7 +81,7 @@ class MyStr(str): ... ], ) def test_uuid(input_value, expected): - v = SchemaValidator(schema=core_schema.uuid_schema()) + v = SchemaValidator(core_schema.uuid_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): result = v.validate_python(input_value) @@ -102,7 +102,7 @@ def test_uuid(input_value, expected): ], ) def test_uuid_strict(input_value, expected): - v = SchemaValidator(schema=core_schema.uuid_schema(strict=True)) + v = SchemaValidator(core_schema.uuid_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -154,7 +154,7 @@ def test_uuid_version(input_value, version, expected): if version is not None: schema['version'] = version - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -193,7 +193,7 @@ def test_uuid_json(py_and_json: PyAndJson, input_value, expected): def test_uuid_deepcopy(): - output = SchemaValidator(schema=core_schema.uuid_schema()).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c') + output = SchemaValidator(core_schema.uuid_schema()).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c') c = copy.deepcopy(output) assert repr(output) == "UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c')" assert c == output @@ -201,7 +201,7 @@ def test_uuid_deepcopy(): def test_uuid_copy(): - output = SchemaValidator(schema=core_schema.uuid_schema()).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c') + output = SchemaValidator(core_schema.uuid_schema()).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c') c = copy.copy(output) assert repr(output) == "UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c')" assert c == output @@ -211,7 +211,7 @@ def test_uuid_copy(): def test_uuid_wrap_json(): # https://github.com/pydantic/pydantic/issues/8147 schema = core_schema.no_info_wrap_validator_function(lambda v, handler: handler(v), core_schema.uuid_schema()) - v = SchemaValidator(schema=schema) + v = SchemaValidator(schema) assert v.validate_python(UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c'), strict=True) == UUID( 'a6cc5730-2261-11ee-9c43-2eb5a363657c' diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py index d7bc671fb..2b092d066 100644 --- a/tests/validators/test_with_default.py +++ b/tests/validators/test_with_default.py @@ -21,7 +21,7 @@ def test_typed_dict_default(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'y': core_schema.typed_dict_field( @@ -36,7 +36,7 @@ def test_typed_dict_default(): def test_typed_dict_omit(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'y': core_schema.typed_dict_field( @@ -53,7 +53,7 @@ def test_typed_dict_omit(): def test_arguments(): v = SchemaValidator( - schema=core_schema.arguments_schema( + core_schema.arguments_schema( arguments=[ { 'name': 'a', @@ -111,7 +111,7 @@ def test_list_json(py_and_json: PyAndJson, input_value, expected): ) def test_list(input_value, expected): v = SchemaValidator( - schema=core_schema.list_schema( + core_schema.list_schema( items_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit') ) ) @@ -130,7 +130,7 @@ def test_list(input_value, expected): ) def test_set(input_value, expected): v = SchemaValidator( - schema=core_schema.set_schema( + core_schema.set_schema( items_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit') ) ) @@ -152,7 +152,7 @@ def test_dict_values(py_and_json: PyAndJson): def test_dict_keys(): v = SchemaValidator( - schema=core_schema.dict_schema( + core_schema.dict_schema( keys_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit'), values_schema=core_schema.str_schema(), ) @@ -177,7 +177,7 @@ def test_tuple_variable(py_and_json: PyAndJson): def test_tuple_positional(): v = SchemaValidator( - schema=core_schema.tuple_schema( + core_schema.tuple_schema( items_schema=[ core_schema.int_schema(), core_schema.with_default_schema(schema=core_schema.int_schema(), default=42), @@ -192,7 +192,7 @@ def test_tuple_positional(): def test_tuple_positional_omit(): v = SchemaValidator( - schema=core_schema.tuple_schema( + core_schema.tuple_schema( items_schema=[ core_schema.int_schema(), core_schema.int_schema(), @@ -209,9 +209,7 @@ def test_tuple_positional_omit(): def test_on_error_default(): - v = SchemaValidator( - schema=core_schema.with_default_schema(schema=core_schema.int_schema(), default=2, on_error='default') - ) + v = SchemaValidator(core_schema.with_default_schema(schema=core_schema.int_schema(), default=2, on_error='default')) assert v.validate_python(42) == 42 assert v.validate_python('42') == 42 assert v.validate_python('wrong') == 2 @@ -222,9 +220,7 @@ def broken(): raise RuntimeError('this is broken') v = SchemaValidator( - schema=core_schema.with_default_schema( - schema=core_schema.int_schema(), on_error='default', default_factory=broken - ) + core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='default', default_factory=broken) ) assert v.validate_python(42) == 42 assert v.validate_python('42') == 42 @@ -237,7 +233,7 @@ def broken(x): return 7 v = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( schema=core_schema.int_schema(), on_error='default', default_factory=broken, @@ -252,7 +248,7 @@ def broken(x): def test_typed_dict_error(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( fields={ 'x': core_schema.typed_dict_field(schema=core_schema.str_schema()), 'y': core_schema.typed_dict_field( @@ -270,7 +266,7 @@ def test_typed_dict_error(): def test_on_error_default_not_int(): v = SchemaValidator( - schema=core_schema.with_default_schema(schema=core_schema.int_schema(), default=[1, 2, 3], on_error='default') + core_schema.with_default_schema(schema=core_schema.int_schema(), default=[1, 2, 3], on_error='default') ) assert v.validate_python(42) == 42 assert v.validate_python('42') == 42 @@ -279,9 +275,7 @@ def test_on_error_default_not_int(): def test_on_error_default_factory(): v = SchemaValidator( - schema=core_schema.with_default_schema( - schema=core_schema.int_schema(), default_factory=lambda: 17, on_error='default' - ) + core_schema.with_default_schema(schema=core_schema.int_schema(), default_factory=lambda: 17, on_error='default') ) assert v.validate_python(42) == 42 assert v.validate_python('42') == 42 @@ -289,7 +283,7 @@ def test_on_error_default_factory(): def test_on_error_omit(): - v = SchemaValidator(schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit')) + v = SchemaValidator(core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit')) assert v.validate_python(42) == 42 with pytest.raises(SchemaError, match='Uncaught Omit error, please check your usage of `default` validators.'): v.validate_python('wrong') @@ -297,7 +291,7 @@ def test_on_error_omit(): def test_on_error_wrong(): with pytest.raises(SchemaError, match="'on_error = default' requires a `default` or `default_factory`"): - SchemaValidator(schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='default')) + SchemaValidator(core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='default')) def test_build_default_and_default_factory(): @@ -316,7 +310,7 @@ class MyModel: field_b: int v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=MyModel, schema=core_schema.with_default_schema( schema=core_schema.model_fields_schema( @@ -364,7 +358,7 @@ def test_validate_default( else: config = None v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'x': core_schema.typed_dict_field( core_schema.with_default_schema( @@ -386,7 +380,7 @@ def test_validate_default( def test_validate_default_factory(): v = SchemaValidator( - schema=core_schema.tuple_positional_schema( + core_schema.tuple_positional_schema( [core_schema.with_default_schema(core_schema.int_schema(), default_factory=lambda: '42')] ), config=dict(validate_default=True), @@ -397,7 +391,7 @@ def test_validate_default_factory(): def test_validate_default_error_tuple(): v = SchemaValidator( - schema=core_schema.tuple_positional_schema( + core_schema.tuple_positional_schema( [core_schema.with_default_schema(core_schema.int_schema(), default='wrong', validate_default=True)] ) ) @@ -418,7 +412,7 @@ def test_validate_default_error_tuple(): def test_validate_default_error_typed_dict(): v = SchemaValidator( - schema=core_schema.typed_dict_schema( + core_schema.typed_dict_schema( { 'x': core_schema.typed_dict_field( core_schema.with_default_schema(core_schema.int_schema(), default='xx', validate_default=True) @@ -450,7 +444,7 @@ class Model: str_dict_with_default: dict[str, str] = stored_empty_dict v = SchemaValidator( - schema=core_schema.model_schema( + core_schema.model_schema( cls=Model, schema=core_schema.model_fields_schema( fields={ @@ -496,7 +490,7 @@ class Model: def test_default_value() -> None: s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=[1, 2, 3]) - v = SchemaValidator(schema=s) + v = SchemaValidator(s) r = v.get_default_value() assert r is not None @@ -506,7 +500,7 @@ def test_default_value() -> None: def test_default_value_validate_default() -> None: s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=['1', '2', '3']) - v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True)) r = v.get_default_value() assert r is not None @@ -516,7 +510,7 @@ def test_default_value_validate_default() -> None: def test_default_value_validate_default_fail() -> None: s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=['a']) - v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True)) with pytest.raises(ValidationError) as exc_info: v.get_default_value() @@ -533,7 +527,7 @@ def test_default_value_validate_default_fail() -> None: def test_default_value_validate_default_strict_pass() -> None: s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=[1, 2, 3]) - v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True)) r = v.get_default_value(strict=True) assert r is not None @@ -543,7 +537,7 @@ def test_default_value_validate_default_strict_pass() -> None: def test_default_value_validate_default_strict_fail() -> None: s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=['1']) - v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True)) with pytest.raises(ValidationError) as exc_info: v.get_default_value(strict=True) @@ -555,7 +549,7 @@ def test_default_value_validate_default_strict_fail() -> None: @pytest.mark.parametrize('validate_default', [True, False]) def test_no_default_value(validate_default: bool) -> None: s = core_schema.list_schema(core_schema.int_schema()) - v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=validate_default)) + v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=validate_default)) assert v.get_default_value() is None @@ -564,7 +558,7 @@ def test_no_default_value(validate_default: bool) -> None: def test_some(validate_default: bool) -> None: def get_default() -> Union[Some[int], None]: s = core_schema.with_default_schema(core_schema.int_schema(), default=42) - return SchemaValidator(schema=s).get_default_value() + return SchemaValidator(s).get_default_value() res = get_default() assert res is not None @@ -593,19 +587,13 @@ def f(v: Union[Some[Any], None]) -> str: exec(code, globals(), local_vars) f = cast(Callable[[Union[Some[Any], None]], str], local_vars['f']) - res = f( - SchemaValidator(schema=core_schema.with_default_schema(core_schema.int_schema(), default=1)).get_default_value() - ) + res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default=1)).get_default_value()) assert res == 'case1' - res = f( - SchemaValidator(schema=core_schema.with_default_schema(core_schema.int_schema(), default=2)).get_default_value() - ) + res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default=2)).get_default_value()) assert res == 'case2' - res = f( - SchemaValidator(schema=core_schema.with_default_schema(core_schema.int_schema(), default=3)).get_default_value() - ) + res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default=3)).get_default_value()) assert res == 'case3: 3' res = f( @@ -615,7 +603,7 @@ def f(v: Union[Some[Any], None]) -> str: ) assert res == 'case4: str(4)' - res = f(SchemaValidator(schema=core_schema.int_schema()).get_default_value()) + res = f(SchemaValidator(core_schema.int_schema()).get_default_value()) assert res == 'case5' @@ -626,7 +614,7 @@ def val_func(v: Any, handler: core_schema.ValidatorFunctionWrapHandler) -> Any: return handler(v) validator = SchemaValidator( - schema=core_schema.with_default_schema( + core_schema.with_default_schema( core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema()), default=10 ) ) @@ -637,15 +625,13 @@ def val_func(v: Any, handler: core_schema.ValidatorFunctionWrapHandler) -> Any: # without a default value the error bubbles up # the error message is the same as the error message produced by PydanticOmit validator = SchemaValidator( - schema=core_schema.with_default_schema( - core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema()) - ) + core_schema.with_default_schema(core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema())) ) with pytest.raises(SchemaError, match='Uncaught UseDefault error, please check your usage of `default` validators'): validator.validate_python('') # same if there is no WithDefault validator - validator = SchemaValidator(schema=core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema())) + validator = SchemaValidator(core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema())) with pytest.raises(SchemaError, match='Uncaught UseDefault error, please check your usage of `default` validators'): validator.validate_python('') @@ -666,7 +652,7 @@ def _validator(cls, v, info): # If any of the Rust validators don't implement traversal properly, # there will be an undetectable cycle created by this assignment # which will keep Defaulted alive - Defaulted.__pydantic_validator__ = SchemaValidator(schema=schema) + Defaulted.__pydantic_validator__ = SchemaValidator(schema) return Defaulted @@ -785,7 +771,7 @@ def _raise(ex: Exception) -> None: ) v = SchemaValidator( - schema=core_schema_constructor( + core_schema_constructor( { 'x': field_constructor( core_schema.with_default_schema(inner_schema, default=None, validate_default=True) @@ -820,7 +806,7 @@ def _raise(ex: Exception) -> None: ) z = core_schema.dataclass_field(name='z', schema=core_schema.str_schema()) - v = SchemaValidator(schema=core_schema.dataclass_args_schema('XYZ', [x, y, z])) + v = SchemaValidator(core_schema.dataclass_args_schema('XYZ', [x, y, z])) with pytest.raises(ValidationError) as exc_info: v.validate_python(input_value)