Fixups

Author: Viicos

benches/main.rs

@@ -8,15 +8,14 @@ use test::{black_box, Bencher};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
-use _pydantic_core::{validate_core_schema, SchemaValidator};
+use _pydantic_core::SchemaValidator;
 
 fn build_schema_validator_with_globals(
     py: Python,
     code: &CStr,
     globals: Option<&Bound<'_, PyDict>>,
 ) -> SchemaValidator {
     let mut schema = py.eval(code, globals, None).unwrap().extract().unwrap();
-    schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
     SchemaValidator::py_new(py, &schema, None).unwrap()
 }
 
@@ -511,7 +510,6 @@ fn complete_model(bench: &mut Bencher) {
 
         let complete_schema = py.import("complete_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema").unwrap();
-        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_lax").unwrap();
@@ -535,7 +533,6 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
 
         let complete_schema = py.import("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema_using_defs").unwrap();
-        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_valid").unwrap();
@@ -563,7 +560,6 @@ fn nested_model_inlined(bench: &mut Bencher) {
 
         let complete_schema = py.import("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("inlined_schema").unwrap();
-        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_valid").unwrap();

python/pydantic_core/__init__.py

@@ -25,7 +25,6 @@
     from_json,
     to_json,
     to_jsonable_python,
-    validate_core_schema,
 )
 from .core_schema import CoreConfig, CoreSchema, CoreSchemaType, ErrorType
 
@@ -66,7 +65,6 @@
     'to_json',
     'from_json',
     'to_jsonable_python',
-    'validate_core_schema',
 ]
 
 

python/pydantic_core/_pydantic_core.pyi

@@ -34,7 +34,6 @@ __all__ = [
     'to_jsonable_python',
     'list_all_errors',
     'TzInfo',
-    'validate_core_schema',
 ]
 __version__: str
 build_profile: str

src/lib.rs

@@ -39,7 +39,7 @@ pub use serializers::{
     to_json, to_jsonable_python, PydanticSerializationError, PydanticSerializationUnexpectedValue, SchemaSerializer,
     WarningsArg,
 };
-pub use validators::{validate_core_schema, PySome, SchemaValidator};
+pub use validators::{PySome, SchemaValidator};
 
 use crate::input::Input;
 
@@ -113,8 +113,8 @@ mod _pydantic_core {
 
     #[pymodule_export]
     use crate::{
-        from_json, list_all_errors, to_json, to_jsonable_python, validate_core_schema, ArgsKwargs, PyMultiHostUrl,
-        PySome, PyUrl, PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticSerializationError,
+        from_json, list_all_errors, to_json, to_jsonable_python, ArgsKwargs, PyMultiHostUrl, PySome, PyUrl,
+        PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticSerializationError,
         PydanticSerializationUnexpectedValue, PydanticUndefinedType, PydanticUseDefault, SchemaError, SchemaSerializer,
         SchemaValidator, TzInfo, ValidationError,
     };

tests/benchmarks/complete_schema.py

@@ -1,7 +1,9 @@
 from decimal import Decimal
 
+from pydantic_core import CoreSchema
 
-def schema(*, strict: bool = False) -> dict:
+
+def schema(*, strict: bool = False) -> CoreSchema:
     class MyModel:
         # __slots__ is not required, but it avoids __pydantic_fields_set__ falling into __dict__
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
@@ -12,7 +14,7 @@ def append_func(input_value, info):
     def wrap_function(input_value, validator, info):
         return f'Input {validator(input_value)} Changed'
 
-    return {
+    return {  # type: ignore
         'type': 'model',
         'cls': MyModel,
         'config': {'strict': strict},
@@ -342,7 +344,7 @@ def input_data_wrong():
     }
 
 
-def wrap_schema_in_root_model(schema: dict) -> dict:
+def wrap_schema_in_root_model(schema: CoreSchema) -> CoreSchema:
     class MyRootModel:
         # __slots__ is not required, but it avoids __pydantic_fields_set__ falling into __dict__
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'

tests/benchmarks/test_complete_benchmark.py

@@ -9,15 +9,15 @@
 
 import pytest
 
-from pydantic_core import SchemaSerializer, SchemaValidator, ValidationError, validate_core_schema
+from pydantic_core import SchemaSerializer, SchemaValidator, ValidationError
 
 from .complete_schema import input_data_lax, input_data_strict, input_data_wrong, schema, wrap_schema_in_root_model
 
 
 def test_complete_valid():
     lax_schema = schema()
     cls = lax_schema['cls']
-    lax_validator = SchemaValidator(validate_core_schema(lax_schema))
+    lax_validator = SchemaValidator(lax_schema)
     output = lax_validator.validate_python(input_data_lax())
     assert isinstance(output, cls)
     assert len(output.__pydantic_fields_set__) == 41
@@ -74,40 +74,40 @@ def test_complete_valid():
         },
     }
 
-    strict_validator = SchemaValidator(validate_core_schema(schema(strict=True)))
+    strict_validator = SchemaValidator(schema(strict=True))
     output2 = strict_validator.validate_python(input_data_strict())
     assert output_dict == output2.__dict__
 
 
 def test_complete_invalid():
     lax_schema = schema()
-    lax_validator = SchemaValidator(validate_core_schema(lax_schema))
+    lax_validator = SchemaValidator(lax_schema)
     with pytest.raises(ValidationError) as exc_info:
         lax_validator.validate_python(input_data_wrong())
     assert len(exc_info.value.errors(include_url=False)) == 739
 
 
 @pytest.mark.benchmark(group='complete')
 def test_complete_core_lax(benchmark):
-    v = SchemaValidator(validate_core_schema(schema()))
+    v = SchemaValidator(schema())
     benchmark(v.validate_python, input_data_lax())
 
 
 @pytest.mark.benchmark(group='complete')
 def test_complete_core_strict(benchmark):
-    v = SchemaValidator(validate_core_schema(schema(strict=True)))
+    v = SchemaValidator(schema(strict=True))
     benchmark(v.validate_python, input_data_strict())
 
 
 @pytest.mark.benchmark(group='complete')
 def test_complete_core_root(benchmark):
-    v = SchemaValidator(validate_core_schema(wrap_schema_in_root_model(schema())))
+    v = SchemaValidator(wrap_schema_in_root_model(schema()))
     benchmark(v.validate_python, {'root': input_data_lax()})
 
 
 @pytest.mark.benchmark(group='complete-to-python')
 def test_complete_core_serializer_to_python(benchmark):
-    core_schema = validate_core_schema(schema())
+    core_schema = schema()
     v = SchemaValidator(core_schema)
     model = v.validate_python(input_data_lax())
     serializer = SchemaSerializer(core_schema)
@@ -117,7 +117,7 @@ def test_complete_core_serializer_to_python(benchmark):
 
 @pytest.mark.benchmark(group='complete-to-json')
 def test_complete_core_serializer_to_json(benchmark):
-    core_schema = validate_core_schema(schema())
+    core_schema = schema()
     v = SchemaValidator(core_schema)
     model = v.validate_python(input_data_lax())
     serializer = SchemaSerializer(core_schema)
@@ -126,7 +126,7 @@ def test_complete_core_serializer_to_json(benchmark):
 
 @pytest.mark.benchmark(group='complete-wrong')
 def test_complete_core_error(benchmark):
-    v = SchemaValidator(validate_core_schema(schema()))
+    v = SchemaValidator(schema())
     data = input_data_wrong()
 
     @benchmark
@@ -141,7 +141,7 @@ def f():
 
 @pytest.mark.benchmark(group='complete-wrong')
 def test_complete_core_isinstance(benchmark):
-    v = SchemaValidator(validate_core_schema(schema()))
+    v = SchemaValidator(schema())
     data = input_data_wrong()
     assert v.isinstance_python(data) is False
 
@@ -161,19 +161,19 @@ def default_json_encoder(obj):
 
 @pytest.mark.benchmark(group='complete-json')
 def test_complete_core_json(benchmark):
-    v = SchemaValidator(validate_core_schema(schema()))
+    v = SchemaValidator(schema())
     json_data = json.dumps(input_data_lax(), default=default_json_encoder)
     benchmark(v.validate_json, json_data)
 
 
 @pytest.mark.benchmark(group='complete-json')
 def test_complete_core_root_json(benchmark):
-    v = SchemaValidator(validate_core_schema(wrap_schema_in_root_model(schema())))
+    v = SchemaValidator(wrap_schema_in_root_model(schema()))
     json_data = json.dumps({'root': input_data_lax()}, default=default_json_encoder)
     benchmark(v.validate_json, json_data)
 
 
 @pytest.mark.benchmark(group='build')
 def test_build_schema(benchmark):
     lax_schema = schema()
-    benchmark(lambda s: SchemaValidator(validate_core_schema(s)), lax_schema)
+    benchmark(SchemaValidator, lax_schema)

tests/conftest.py

@@ -15,7 +15,7 @@
 import hypothesis
 import pytest
 
-from pydantic_core import ArgsKwargs, CoreSchema, SchemaValidator, ValidationError, validate_core_schema
+from pydantic_core import ArgsKwargs, CoreSchema, SchemaValidator, ValidationError
 from pydantic_core.core_schema import CoreConfig
 
 __all__ = 'Err', 'PyAndJson', 'assert_gc', 'is_free_threaded', 'plain_repr', 'infinite_generator'
@@ -64,7 +64,7 @@ def __init__(
         *,
         validator_type: Literal['json', 'python'] | None = None,
     ):
-        self.validator = SchemaValidator(validate_core_schema(schema), config)
+        self.validator = SchemaValidator(schema, config)
         self.validator_type = validator_type
 
     def validate_python(self, py_input, strict: bool | None = None, context: Any = None):

tests/serializers/test_definitions.py

@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema, validate_core_schema
+from pydantic_core import SchemaError, SchemaSerializer, core_schema
 
 
 def test_custom_ser():
@@ -23,20 +23,6 @@ def test_ignored_def():
     assert s.to_python([1, 2, 3]) == [1, 2, 3]
 
 
-def test_def_error():
-    with pytest.raises(SchemaError) as exc_info:
-        validate_core_schema(
-            core_schema.definitions_schema(
-                core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
-                [core_schema.int_schema(ref='foobar'), {'type': 'wrong'}],
-            )
-        )
-
-    assert str(exc_info.value).startswith(
-        "Invalid Schema:\ndefinitions.definitions.1\n  Input tag 'wrong' found using 'type'"
-    )
-
-
 def test_repeated_ref():
     with pytest.raises(SchemaError, match='SchemaError: Duplicate ref: `foobar`'):
         SchemaSerializer(

tests/serializers/test_dict.py

@@ -3,7 +3,7 @@
 import pytest
 from dirty_equals import IsStrictDict
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema, validate_core_schema
+from pydantic_core import SchemaSerializer, core_schema
 
 
 def test_dict_str_int():
@@ -143,18 +143,3 @@ def test_filter_runtime_int():
         core_schema.dict_schema(core_schema.any_schema(), serialization=core_schema.filter_dict_schema(exclude={0, 1}))
     )
     assert s.to_python({0: 0, 1: 1, 2: 2, 3: 3}, include={1, 2}) == {1: 1, 2: 2}
-
-
-@pytest.mark.parametrize(
-    'include_value,error_msg',
-    [
-        ('foobar', 'Input should be a valid set'),
-        ({'a': 'dict'}, 'Input should be a valid set'),
-        ({4.2}, 'Input should be a valid integer, got a number with a fractional part'),
-    ],
-)
-def test_include_error(include_value, error_msg):
-    with pytest.raises(SchemaError, match=error_msg):
-        validate_core_schema(
-            core_schema.dict_schema(serialization=core_schema.filter_dict_schema(include=include_value))
-        )

tests/serializers/test_list_tuple.py

@@ -5,10 +5,8 @@
 
 from pydantic_core import (
     PydanticSerializationError,
-    SchemaError,
     SchemaSerializer,
     core_schema,
-    validate_core_schema,
 )
 
 
@@ -162,13 +160,10 @@ def test_exclude(schema_func, seq_f):
     assert v.to_json(seq_f('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'), exclude={-1, -2}) == b'["a","c","e"]'
 
 
-@pytest.mark.parametrize('include,exclude', [({1, 3, 5}, {5, 6}), ([1, 3, 5], [5, 6])])
-def test_filter(include, exclude):
+def test_filter():
     v = SchemaSerializer(
-        validate_core_schema(
-            core_schema.list_schema(
-                core_schema.any_schema(), serialization=core_schema.filter_seq_schema(include=include, exclude=exclude)
-            )
+        core_schema.list_schema(
+            core_schema.any_schema(), serialization=core_schema.filter_seq_schema(include={1, 3, 5}, exclude={5, 6})
         )
     )
     assert v.to_python([0, 1, 2, 3, 4, 5, 6, 7]) == [1, 3]
@@ -197,23 +192,6 @@ class RemovedContains(ImplicitContains):
     __contains__ = None  # This might be done to explicitly force the `x in RemovedContains()` check to not be allowed
 
 
-@pytest.mark.parametrize(
-    'include_value,error_msg',
-    [
-        ('foobar', 'Input should be a valid set'),
-        ({'a': 'dict'}, 'Input should be a valid set'),
-        ({4.2}, 'Input should be a valid integer, got a number with a fractional part'),
-        ({'a'}, 'Input should be a valid integer, unable to parse string as an integer'),
-    ],
-)
-@pytest.mark.parametrize('schema_func', [core_schema.list_schema, core_schema.tuple_variable_schema])
-def test_include_error(schema_func, include_value, error_msg):
-    with pytest.raises(SchemaError, match=error_msg):
-        validate_core_schema(
-            schema_func(core_schema.any_schema(), serialization=core_schema.filter_seq_schema(include=include_value))
-        )
-
-
 @pytest.mark.parametrize(
     'include,exclude,expected',
     [

tests/serializers/test_misc.py

@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
 
 from ..conftest import PyAndJson
 
@@ -31,11 +31,6 @@ def test_custom_error_type(py_and_json: PyAndJson):
     ]
 
 
-def test_custom_error_error():
-    with pytest.raises(SchemaError, match=r'custom_error_type\s+Field required \[type=missing'):
-        validate_core_schema({'type': 'custom-error', 'schema': {'type': 'int'}})
-
-
 def test_custom_error_invalid():
     msg = "custom_error_message should not be provided if 'custom_error_type' matches a known error"
     with pytest.raises(SchemaError, match=msg):