remove pydantic V1 comparisons from benchmark suite (#748)

Author: davidhewitt

.github/workflows/ci.yml

@@ -103,7 +103,6 @@ jobs:
 
       - run: pytest
         env:
-          BENCHMARK_VS_PYDANTIC: 1
           HYPOTHESIS_PROFILE: slow
 
   test-os:

tests/benchmarks/README.md

@@ -209,91 +209,6 @@ def wrap_function(input_value, validator, info):
     }
 
 
-def pydantic_model():
-    from datetime import date, datetime, time
-    from typing import Any, Literal, Union
-
-    try:
-        from pydantic import BaseModel, conbytes, confloat, confrozenset, conint, conlist, conset, constr, validator
-    except ImportError:
-        return None
-
-    class UnionModel1(BaseModel):
-        field_str: str
-        field_int: int
-        field_float: float
-
-    class UnionModel2(BaseModel):
-        field_float: float
-        field_bytes: bytes
-        field_date: date
-
-    class FunctionModel(BaseModel):
-        field_before: str
-        field_after: str
-        field_wrap: str
-        field_plain: Any
-
-        @validator('field_before', pre=True, allow_reuse=True)
-        def append_before(cls, v):
-            return f'{v} Changed'
-
-        @validator('field_after', 'field_wrap', 'field_plain', allow_reuse=True)  # best attempts at wrap and plain
-        def append_after(cls, v):
-            return f'{v} Changed'
-
-        @validator('field_wrap', pre=True, allow_reuse=True)  # other part of wrap
-        def wrap_before(cls, v):
-            return f'Input {v}'
-
-    class BranchModel(BaseModel):
-        name: str
-        sub_branch: 'BranchModel' = None
-
-    class Model(BaseModel):
-        field_str: str
-        field_str_con: constr(min_length=3, max_length=5, regex='^[a-z]+$')
-        field_int: int
-        field_int_con: conint(gt=1, lt=10, multiple_of=2)
-        field_float: float
-        field_float_con: confloat(ge=1.0, le=10.0, multiple_of=0.5)
-        field_bool: bool
-        field_bytes: bytes
-        field_bytes_con: conbytes(min_length=6, max_length=1000)
-        field_date: date
-        field_date_con: date  # todo ge='2020-01-01', lt='2020-01-02'
-        field_time: time
-        field_time_con: time  # todo ge='06:00:00', lt='12:13:14'
-        field_datetime: datetime
-        field_datetime_con: datetime  # todo ge='2000-01-01T06:00:00', lt='2020-01-02T12:13:14'
-        field_list_any: list
-        field_list_str: list[str]
-        field_list_str_con: conlist(str, min_items=3, max_items=42)
-        field_set_any: set
-        field_set_int: set[int]
-        field_set_int_con: conset(int, min_items=3, max_items=42)
-        field_frozenset_any: frozenset
-        field_frozenset_bytes: frozenset[bytes]
-        field_frozenset_bytes_con: confrozenset(bytes, min_items=3, max_items=42)
-        field_tuple_var_len_any: tuple[Any, ...]
-        field_tuple_var_len_float: tuple[float, ...]
-        field_tuple_var_len_float_con: tuple[float, ...]  # todo min_items=3, max_items=42
-        field_tuple_fix_len: tuple[str, int, float, bool]
-        field_dict_any: dict
-        field_dict_str_float: dict[str, float]
-        field_literal_1_int: Literal[1]
-        field_literal_1_str: Literal['foobar']
-        field_literal_mult_int: Literal[1, 2, 3]
-        field_literal_mult_str: Literal['foo', 'bar', 'baz']
-        field_literal_assorted: Literal[1, 'foo', True]
-        field_list_nullable_int: list[int | None]
-        field_union: Union[str, UnionModel1, UnionModel2]
-        field_functions_model: FunctionModel
-        field_recursive: BranchModel
-
-    return Model
-
-
 def input_data_lax():
     return {
         'field_str': 'fo',

tests/benchmarks/complete_schema.py

@@ -2,17 +2,13 @@
 General benchmarks that attempt to cover all field types, through by no means all uses of all field types.
 """
 import json
-import sys
 from datetime import date, datetime, time
 
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError
 
-from .complete_schema import input_data_lax, input_data_strict, input_data_wrong, pydantic_model, schema
-from .test_micro_benchmarks import skip_pydantic
-
-pytestmark = pytest.mark.skipif(sys.version_info < (3, 10), reason='requires python3.10 or higher')
+from .complete_schema import input_data_lax, input_data_strict, input_data_wrong, schema
 
 
 def test_complete_valid():
@@ -77,14 +73,6 @@ def test_complete_valid():
     output2 = strict_validator.validate_python(input_data_strict())
     assert output_dict == output2.__dict__
 
-    model = pydantic_model()
-    if model is None:
-        print('pydantic is not installed, skipping pydantic tests')
-        return
-
-    output_pydantic = model.parse_obj(input_data_lax())
-    assert output_pydantic.dict() == output_dict
-
 
 def test_complete_invalid():
     lax_schema = schema()
@@ -93,17 +81,6 @@ def test_complete_invalid():
         lax_validator.validate_python(input_data_wrong())
     assert len(exc_info.value.errors(include_url=False)) == 738
 
-    model = pydantic_model()
-    if model is None:
-        print('pydantic is not installed, skipping pydantic tests')
-        return
-
-    from pydantic import ValidationError as PydanticValidationError
-
-    with pytest.raises(PydanticValidationError) as exc_info:
-        model.parse_obj(input_data_wrong())
-    assert len(exc_info.value.errors()) == 530
-
 
 @pytest.mark.benchmark(group='complete')
 def test_complete_core_lax(benchmark):
@@ -117,14 +94,6 @@ def test_complete_core_strict(benchmark):
     benchmark(v.validate_python, input_data_strict())
 
 
-@skip_pydantic
-@pytest.mark.benchmark(group='complete')
-def test_complete_pyd(benchmark):
-    model = pydantic_model()
-    assert model is not None
-    benchmark(model.parse_obj, input_data_lax())
-
-
 @pytest.mark.benchmark(group='complete-wrong')
 def test_complete_core_error(benchmark):
     v = SchemaValidator(schema())
@@ -151,23 +120,6 @@ def f():
         v.isinstance_python(data)
 
 
-@skip_pydantic
-@pytest.mark.benchmark(group='complete-wrong')
-def test_complete_pyd_error(benchmark):
-    model = pydantic_model()
-    assert model is not None
-    data = input_data_wrong()
-
-    @benchmark
-    def f():
-        try:
-            model.parse_obj(data)
-        except ValueError:
-            pass
-        else:
-            raise RuntimeError('expected ValueError')
-
-
 def default_json_encoder(obj):
     if isinstance(obj, bytes):
         return obj.decode('utf-8')
@@ -184,18 +136,6 @@ def test_complete_core_json(benchmark):
     benchmark(v.validate_json, json_data)
 
 
-@skip_pydantic
-@pytest.mark.benchmark(group='complete-json')
-def test_complete_pyd_json(benchmark):
-    model = pydantic_model()
-    assert model is not None
-    json_data = json.dumps(input_data_lax(), default=default_json_encoder)
-
-    @benchmark
-    def t():
-        model.parse_raw(json_data, content_type='application/json')
-
-
 @pytest.mark.benchmark(group='build')
 def test_build_schema(benchmark):
     lax_schema = schema()