Add json schema tests, add section mapping existing validators

pydantic · sydney-runkle · Jun 6, 2024 · May 20, 2024 · May 20, 2024 · May 20, 2024
commit 8742e9e26daf054472b251accf3f265883e29e52
diff --git a/docs/concepts/types.md b/docs/concepts/types.md
@@ -165,6 +165,23 @@ class User(BaseModel):
 7. For recursive types you can use `parse_defer` to reference the type itself before it's defined.
 8. You can call `parse()` before or after other steps to do pre or post processing.
 
+##### Mapping from `BeforeValidator`, `AfterValidator` and `WrapValidator`
+
+The `parse` method is a more type-safe way to define `BeforeValidator`, `AfterValidator` and `WrapValidator`:
+
+```python
+# BeforeValidator
+Annotated[int, parse(str).str.strip().parse()]  # (1)!
+# AfterValidator
+Annotated[int, parse().transform(lambda x: x * 2)]  # (2)!
+# WrapValidator
+Annotated[int, parse(str).str.strip().parse().transform(lambda x: x * 2)]  # (3)!
+```
+
+1. Strip whitespace from a string before parsing it as an integer.
+2. Multiply an integer by 2 after parsing it.
+3. Strip whitespace from a string, parse it as an integer, then multiply it by 2.
+
 #### Adding validation and serialization
 
 You can add or override validation, serialization, and JSON schemas to an arbitrary type using the markers that

diff --git a/pydantic/_internal/_generate_schema.py b/pydantic/_internal/_generate_schema.py
@@ -1805,7 +1805,7 @@ def _apply_annotations(
         pydantic_js_annotation_functions: list[GetJsonSchemaFunction] = []
 
         def inner_handler(obj: Any) -> CoreSchema:
-            from_property = self._generate_schema_from_property(obj, obj)
+            from_property = self._generate_schema_from_property(obj, source_type)
             if from_property is None:
                 schema = self._generate_schema_inner(obj)
             else:

diff --git a/pydantic/transform_experimental.py b/pydantic/transform_experimental.py
@@ -398,20 +398,44 @@ def check_gt(v: Any) -> bool:
             s = _check_func(check_gt, f'> {gt}', s)
     elif isinstance(constraint, annotated_types.Ge):
         ge = constraint.ge
+        if s and s['type'] in ('int', 'float', 'decimal'):
+            s = s.copy()
+            if s['type'] == 'int' and isinstance(ge, int):
+                s['ge'] = ge
+            elif s['type'] == 'float' and isinstance(ge, float):
+                s['ge'] = ge
+            elif s['type'] == 'decimal' and isinstance(ge, Decimal):
+                s['ge'] = ge
 
         def check_ge(v: Any) -> bool:
             return v >= ge
 
         s = _check_func(check_ge, f'>= {ge}', s)
     elif isinstance(constraint, annotated_types.Lt):
         lt = constraint.lt
+        if s and s['type'] in ('int', 'float', 'decimal'):
+            s = s.copy()
+            if s['type'] == 'int' and isinstance(lt, int):
+                s['lt'] = lt
+            elif s['type'] == 'float' and isinstance(lt, float):
+                s['lt'] = lt
+            elif s['type'] == 'decimal' and isinstance(lt, Decimal):
+                s['lt'] = lt
 
         def check_lt(v: Any) -> bool:
             return v < lt
 
         s = _check_func(check_lt, f'< {lt}', s)
     elif isinstance(constraint, annotated_types.Le):
         le = constraint.le
+        if s and s['type'] in ('int', 'float', 'decimal'):
+            s = s.copy()
+            if s['type'] == 'int' and isinstance(le, int):
+                s['le'] = le
+            elif s['type'] == 'float' and isinstance(le, float):
+                s['le'] = le
+            elif s['type'] == 'decimal' and isinstance(le, Decimal):
+                s['le'] = le
 
         def check_le(v: Any) -> bool:
             return v <= le
@@ -421,6 +445,21 @@ def check_le(v: Any) -> bool:
         min_len = constraint.min_length
         max_len = constraint.max_length
 
+        if s and s['type'] in ('str', 'list', 'tuple', 'set', 'frozenset', 'dict'):
+            assert (
+                s['type'] == 'str'
+                or s['type'] == 'list'
+                or s['type'] == 'tuple'
+                or s['type'] == 'set'
+                or s['type'] == 'dict'
+                or s['type'] == 'frozenset'
+            )
+            s = s.copy()
+            if min_len != 0:
+                s['min_length'] = min_len
+            if max_len is not None:
+                s['max_length'] = max_len
+
         def check_len(v: Any) -> bool:
             if max_len is not None:
                 return (min_len <= len(v)) and (len(v) <= max_len)
@@ -429,6 +468,14 @@ def check_len(v: Any) -> bool:
         s = _check_func(check_len, f'length >= {min_len} and length <= {max_len}', s)
     elif isinstance(constraint, annotated_types.MultipleOf):
         multiple_of = constraint.multiple_of
+        if s and s['type'] in ('int', 'float', 'decimal'):
+            s = s.copy()
+            if s['type'] == 'int' and isinstance(multiple_of, int):
+                s['multiple_of'] = multiple_of
+            elif s['type'] == 'float' and isinstance(multiple_of, float):
+                s['multiple_of'] = multiple_of
+            elif s['type'] == 'decimal' and isinstance(multiple_of, Decimal):
+                s['multiple_of'] = multiple_of
 
         def check_multiple_of(v: Any) -> bool:
             return v % multiple_of == 0

diff --git a/tests/test_transform.py b/tests/test_transform.py
@@ -1,6 +1,7 @@
 """Tests for the experimental transform module."""
+from __future__ import annotations
 
-from typing import Optional
+from typing import Any
 
 import pytest
 from typing_extensions import Annotated
@@ -38,7 +39,7 @@ def test_parse_str_with_pattern() -> None:
         ('ends_with', 'ato', 'potato', 'potato'),
     ],
 )
-def test_string_validator_valid(method: str, method_arg: Optional[str], input_string: str, expected_output: str):
+def test_string_validator_valid(method: str, method_arg: str | None, input_string: str, expected_output: str):
     # annotated metadata is equivalent to parse(str).str.method(method_arg)
     # ex: parse(str).str.contains('pot')
     annotated_metadata = getattr(parse(str).str, method)
@@ -95,3 +96,55 @@ def test_predicates() -> None:
     assert ta_str.validate_python('tomato') == 'tomato'
     with pytest.raises(ValidationError):
         ta_str.validate_python('potato')
+
+
+@pytest.mark.parametrize(
+    'model, expected_val_schema, expected_ser_schema',
+    [
+        (
+            Annotated[int | str, parse() | parse(str)],
+            {'anyOf': [{'type': 'integer'}, {'type': 'string'}]},
+            {'anyOf': [{'type': 'integer'}, {'type': 'string'}]},
+        ),
+        (
+            Annotated[int, parse() | parse(str).parse(int)],
+            {'anyOf': [{'type': 'integer'}, {'type': 'string'}]},
+            {'type': 'integer'},
+        ),
+        (
+            Annotated[int, parse() | parse(str).transform(int)],
+            {'anyOf': [{'type': 'integer'}, {'type': 'string'}]},
+            {'anyOf': [{'type': 'integer'}, {'type': 'string'}]},
+        ),
+        (
+            Annotated[int, parse() | parse(str).transform(int).parse(int)],
+            {'anyOf': [{'type': 'integer'}, {'type': 'string'}]},
+            {'type': 'integer'},
+        ),
+        (
+            Annotated[int, parse(int).gt(0).lt(100)],
+            {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100},
+            {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100},
+        ),
+        (
+            Annotated[int, parse(int).gt(0) | parse(int).lt(100)],
+            {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]},
+            {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]},
+        ),
+        (
+            Annotated[list[int], parse().len(0, 100)],
+            {'type': 'array', 'items': {'type': 'integer'}, 'maxItems': 100},
+            {'type': 'array', 'items': {'type': 'integer'}, 'maxItems': 100},
+        ),
+    ],
+)
+def test_json_schema(
+    model: type[Any], expected_val_schema: dict[str, Any], expected_ser_schema: dict[str, Any]
+) -> None:
+    ta = TypeAdapter(model)
+
+    schema = ta.json_schema(mode='validation')
+    assert schema == expected_val_schema
+
+    schema = ta.json_schema(mode='serialization')
+    assert schema == expected_ser_schema