From a03ad51b9756ad7920d30e888fe084b927d02117 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Sun, 9 Feb 2025 13:55:45 +0000 Subject: [PATCH 01/11] add test transformer --- test_transformer/__init__.py | 0 test_transformer/core_schema_gen.py | 170 +++++++++++++++++++++++ test_transformer/schema_collector.py | 171 +++++++++++++++++++++++ test_transformer/transform.py | 81 +++++++++++ tests/test_config_updated.py | 198 +++++++++++++++++++++++++++ 5 files changed, 620 insertions(+) create mode 100644 test_transformer/__init__.py create mode 100644 test_transformer/core_schema_gen.py create mode 100644 test_transformer/schema_collector.py create mode 100644 test_transformer/transform.py create mode 100644 tests/test_config_updated.py diff --git a/test_transformer/__init__.py b/test_transformer/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test_transformer/core_schema_gen.py b/test_transformer/core_schema_gen.py new file mode 100644 index 000000000..c602bc9e7 --- /dev/null +++ b/test_transformer/core_schema_gen.py @@ -0,0 +1,170 @@ +from typing import Any, Dict, Union, Optional +from typing_extensions import TypedDict +from dataclasses import dataclass +from pydantic_core import core_schema as cs + + +@dataclass +class ASTClass: + name: str + + +class CoreConfig(TypedDict, total=False): + """Schema configuration options matching pydantic_core's CoreConfig""" + + title: str + strict: bool + extra_fields_behavior: str # 'allow', 'forbid', 'ignore' + typed_dict_total: bool + from_attributes: bool + loc_by_alias: bool + revalidate_instances: str # 'always', 'never', 'subclass-instances' + validate_default: bool + populate_by_name: bool + str_max_length: int + str_min_length: int + str_strip_whitespace: bool + str_to_lower: bool + str_to_upper: bool + allow_inf_nan: bool + ser_json_timedelta: str # 'iso8601', 'float' + ser_json_bytes: str # 'utf8', 'base64', 'hex' + ser_json_inf_nan: str # 'null', 'constants', 'strings' + val_json_bytes: str # 'utf8', 'base64', 'hex' + hide_input_in_errors: bool + validation_error_cause: bool + coerce_numbers_to_str: bool + regex_engine: str # 'rust-regex', 'python-re' + cache_strings: Union[bool, str] # bool or 'all', 'keys', 'none' + + +SCHEMA_TYPE_TO_FUNCTION = { + 'str': 'str_schema', + 'int': 'int_schema', + 'float': 'float_schema', + 'bool': 'bool_schema', + 'dict': 'dict_schema', + 'list': 'list_schema', + 'set': 'set_schema', + 'tuple': 'tuple_schema', + 'frozenset': 'frozenset_schema', + 'any': 'any_schema', + 'none': 'none_schema', + 'model': 'model_schema', + 'model-field': 'model_field', + 'model-fields': 'model_fields_schema', + 'typed-dict': 'typed_dict_schema', + 'typed-dict-field': 'typed_dict_field', + 'union': 'union_schema', + 'nullable': 'nullable_schema', + 'function-before': 'before_validator_function', + 'function-after': 'after_validator_function', + 'function-wrap': 'wrap_validator_function', + 'function-plain': 'plain_validator_function', +} + +# Parameters that require special handling +SPECIAL_PARAMS = {'ref', 'metadata', 'serialization', 'type'} + + +def format_value(value: Any) -> str: + """Format a value for inclusion in a function call.""" + if isinstance(value, str): + return f"'{value}'" + elif isinstance(value, ASTClass): + return value.name + elif isinstance(value, dict): + return dict_to_schema_call(value) + elif isinstance(value, list): + items = [format_value(item) for item in value] + return f'[{", ".join(items)}]' + elif isinstance(value, bool): + return str(value) + elif value is None: + return 'None' + return str(value) + + +def format_kwarg(key: str, value: Any) -> str: + """Format a keyword argument for a function call.""" + formatted_value = format_value(value) + return f'{key}={formatted_value}' + + +def dict_to_schema_call(schema_dict: Dict[str, Any]) -> str: + """Convert a schema dictionary to a CoreSchema function call.""" + if not isinstance(schema_dict, dict): + return format_value(schema_dict) + + schema_type = schema_dict.get('type') + if not schema_type: + # Handle dict literals that aren't schema definitions + items = [f"'{k}': {format_value(v)}" for k, v in schema_dict.items()] + return f'{{{", ".join(items)}}}' + + function_name = SCHEMA_TYPE_TO_FUNCTION.get(schema_type) + if not function_name: + raise ValueError(f'Unknown schema type: {schema_type}') + + # Collect kwargs + kwargs = [] + for key, value in schema_dict.items(): + if key in SPECIAL_PARAMS: + continue + + # Handle special cases + if key == 'config': + config = schema_dict.get('config', {}) + if isinstance(config, ASTClass) and config.name == 'config': + kwargs.append(f'config={config.name}') + continue + if not config or not isinstance(config, dict): + continue + kwargs.append(f'config={config_to_CoreConfig(config)}') + elif key == 'schema' and isinstance(value, dict): + kwargs.append(f'schema={dict_to_schema_call(value)}') + elif key == 'fields' and isinstance(value, dict): + # Handle fields mapping for typed-dict and model schemas + field_items = [] + for field_name, field_schema in value.items(): + formatted_field = dict_to_schema_call(field_schema) + field_items.append(f"'{field_name}': {formatted_field}") + kwargs.append(f'fields={{{", ".join(field_items)}}}') + else: + kwargs.append(format_kwarg(key, value)) + + # Add reference if present + if 'ref' in schema_dict: + kwargs.append(format_kwarg('ref', schema_dict['ref'])) + + # Add metadata if present + if 'metadata' in schema_dict: + kwargs.append(format_kwarg('metadata', schema_dict['metadata'])) + + # Add serialization if present + if 'serialization' in schema_dict: + kwargs.append(format_kwarg('serialization', schema_dict['serialization'])) + + return f'cs.{function_name}({", ".join(kwargs)})' + + +def config_to_CoreConfig(config: Dict[str, Any] | ASTClass) -> str: + """Convert a config dictionary to a CoreConfig TypedDict instantiation.""" + if isinstance(config, ASTClass): + return config.name + config_items = [] + for key, value in config.items(): + if isinstance(value, str): + config_items.append(f"{key}='{value}'") + else: + config_items.append(f'{key}={value}') + return f'CoreConfig({", ".join(config_items)})' + + +def convert_schema(schema: dict[str, Any]|ASTClass) -> str: + """Convert a schema dictionary to a CoreSchema function call with proper formatting.""" + if isinstance(schema, ASTClass): + return schema.name + result = dict_to_schema_call(schema) + + return result diff --git a/test_transformer/schema_collector.py b/test_transformer/schema_collector.py new file mode 100644 index 000000000..2b5410406 --- /dev/null +++ b/test_transformer/schema_collector.py @@ -0,0 +1,171 @@ +import ast +from dataclasses import dataclass +from typing import Optional, List +import json + + +from pydantic_core import SchemaValidator, CoreConfig +from pydantic_core import core_schema as cs +from test_transformer.core_schema_gen import convert_schema, config_to_CoreConfig, ASTClass + + +@dataclass +class LineRange: + start: int + end: int | None = None + + +@dataclass +class SchemaValidatorCall: + schema: dict | ASTClass + config: dict | ASTClass | None + lines: LineRange + context: str # The function/method name where this was found + assigned_to: str | None # The variable this was assigned to + + +class SchemaValidatorExtractor(ast.NodeVisitor): + def __init__(self): + self.validators = [] + self.current_function = None + self.assigned_to = None + + def visit_FunctionDef(self, node): + old_function = self.current_function + self.current_function = node.name + + # Add decorator handling + for decorator in node.decorator_list: + if isinstance(decorator, ast.Call): + # Check if it's pytest.mark.parametrize + if (isinstance(decorator.func, ast.Attribute) + and decorator.func.attr == 'parametrize' + and isinstance(decorator.func.value, ast.Attribute) + and decorator.func.value.attr == 'mark'): + self._handle_parametrize_decorator(decorator, node) + + self.generic_visit(node) + self.current_function = old_function + + def visit_Assign(self, node): + # Check if the value being assigned is a function + if isinstance(node.value, (ast.Call)): + # node.targets[0] is the variable being assigned to + if isinstance(node.targets[0], ast.Name) and getattr(node.value.func, 'id', None) == 'SchemaValidator': + self.assigned_to = node.targets[0].id + + self.generic_visit(node) + + def visit_Call(self, node): + # Check if this is a SchemaValidator instantiation + if isinstance(node.func, ast.Name) and node.func.id == 'SchemaValidator': + schema_dict = None + config_dict = None + + # Extract schema (first argument) + if len(node.args) > 0: + schema_dict = self._eval_dict_literal(node.args[0]) + + # Extract config (second argument) + if len(node.args) > 1: + config_dict = self._eval_dict_literal(node.args[1]) + + if schema_dict is not None: + self.validators.append( + SchemaValidatorCall( + schema=schema_dict, + config=config_dict, + lines=LineRange(node.lineno, node.end_lineno), + context=self.current_function or '', + assigned_to=self.assigned_to, + ) + ) + + self.generic_visit(node) + + def _handle_parametrize_decorator(self, decorator, func_node): + # Extract parameter names and values + if len(decorator.args) >= 2: + param_names = self._eval_literal(decorator.args[0]) # Could be string or tuple of strings + param_values = self._eval_literal(decorator.args[1]) # List of tuples/values + + if isinstance(param_names, str): + param_names = param_names.split(',') + + # Map parameter names to their indices + param_indices = {name.strip(): idx for idx, name in enumerate(param_names)} + + # Look for 'config' and schema-related parameters + config_idx = param_indices.get('config') + schema_idx = [idx for idx, name in enumerate(param_names) if 'schema' in name] + + # For each test case in param_values, extract config and schema + for test_case in param_values: + if config_idx is not None: + config = test_case[config_idx] + for idx in schema_idx: + schema = test_case[idx] + # Create SchemaValidatorCall for each combination + + def _eval_dict_literal(self, node) -> dict | ASTClass | None: + """Evaluate a dictionary literal AST node to a Python dict.""" + if isinstance(node, ast.Dict): + result = {} + for k, v in zip(node.keys, node.values): + key = self._eval_literal(k) + value = self._eval_literal(v) + if key is not None and value is not None: + result[key] = value + return result + if isinstance(node, ast.Name): + return ASTClass(name=node.id) + return None + + def _eval_literal(self, node): + """Evaluate a literal AST node to its Python value.""" + if isinstance(node, ast.List): + return [self._eval_literal(item) for item in node.elts] + elif isinstance(node, ast.Tuple): + return tuple(self._eval_literal(item) for item in node.elts) + if isinstance(node, ast.Constant): + return node.s + elif isinstance(node, ast.Dict): + return self._eval_dict_literal(node) + elif isinstance(node, ast.Name): + # Handle common constants + if node.id == 'True': + return True + elif node.id == 'False': + return False + elif node.id == 'None': + return None + else: + return ASTClass(name=node.id) + return None + + +def extract_validators_from_file(file_path: str) -> List[SchemaValidatorCall]: + """Extract all SchemaValidator instantiations from a Python file.""" + with open(file_path, 'r') as f: + tree = ast.parse(f.read()) + + extractor = SchemaValidatorExtractor() + extractor.visit(tree) + return extractor.validators + + +def format_validator_call(validator: SchemaValidatorCall) -> str: + """Format a SchemaValidator call into a readable string.""" + parts = [ + f'Lines {validator.lines.start}:{validator.lines.end} in {validator.context}:', + 'SchemaValidator(', + f' schema={json.dumps(validator.schema, indent=4, default=str)}', + ] + + if isinstance(validator.config, dict): + parts.append(f' config={json.dumps(validator.config, indent=4)}') + elif isinstance(validator.config, ASTClass): + parts.append(f' config={validator.config.name}') + + parts.append(')') + return '\n'.join(parts) diff --git a/test_transformer/transform.py b/test_transformer/transform.py new file mode 100644 index 000000000..f6589eafe --- /dev/null +++ b/test_transformer/transform.py @@ -0,0 +1,81 @@ +import ast +from typing import List +from dataclasses import dataclass + +from test_transformer.schema_collector import SchemaValidatorCall, extract_validators_from_file +from test_transformer.core_schema_gen import convert_schema, config_to_CoreConfig, ASTClass + + +def insert_validator_conversions(file_path: str, validators: List[SchemaValidatorCall]) -> str: + """ + Insert converted schema validators into the original file content. + Returns the modified file content as a string. + """ + # Read the original file + with open(file_path, 'r') as f: + content = f.read() + + # Split content into lines for easier manipulation + lines = content.splitlines() + + # Sort validators by line number in reverse order to insert from bottom up + # This prevents line numbers from shifting as we insert + validators = sorted(validators, key=lambda x: x.lines.start, reverse=True) + + # Process each validator + for validator in validators: + # Generate the new schema code + schema = convert_schema(validator.schema) + config = config_to_CoreConfig(validator.config) if validator.config else None + new_schema = ( + f'{validator.assigned_to} = SchemaValidator(schema={schema}, config={config})' + if config + else f'{validator.assigned_to} = SchemaValidator(schema={schema})' + ) + # assertion = f"assert {validator.assigned_to}_n == {validator.assigned_to}" + + # Calculate indentation from the original line + original_line = lines[validator.lines.start - 1] + indentation = len(original_line) - len(original_line.lstrip()) + indent = ' ' * indentation + + # Format the new code with proper indentation + new_code = f'\n{indent}# Converted schema\n{indent}{new_schema}\n' + + # Find the end of the original validator declaration + end_line = validator.lines.end if validator.lines.end else validator.lines.start + + # Insert the new code after the original validator + lines.insert(end_line, new_code) + + # Join lines back together + modified_content = '\n'.join(lines) + + # add import statements + modified_content = 'from pydantic_core import core_schema as cs\n' + modified_content + + return modified_content + + +def update_test_file(input_file: str, output_file: str): + """ + Process a test file and update it with converted schema validators. + If output_file is not specified, will modify the input file in place. + """ + # Extract validators + validators = extract_validators_from_file(input_file) + + # Generate modified content + modified_content = insert_validator_conversions(input_file, validators) + + # Write to output file + output_path = output_file or input_file + with open(output_path, 'w') as f: + f.write(modified_content) + + print(f'Updated {len(validators)} schema validators in {output_path}') + + +if __name__ == '__main__': + # Example usage + update_test_file('tests/test_config.py', 'tests/test_config_updated.py') diff --git a/tests/test_config_updated.py b/tests/test_config_updated.py new file mode 100644 index 000000000..4194531cc --- /dev/null +++ b/tests/test_config_updated.py @@ -0,0 +1,198 @@ +from pydantic_core import core_schema as cs +import math +import re + +import pytest +from dirty_equals import FunctionCheck, HasAttributes, IsInstance + +from pydantic_core import CoreConfig, SchemaValidator, ValidationError + +from .conftest import Err, plain_repr + + +def test_on_field(): + v = SchemaValidator({'type': 'str', 'min_length': 2, 'max_length': 5}) + + # Converted schema + v = SchemaValidator(schema=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 + assert v.isinstance_python('test') is True + assert v.isinstance_python('test long') is False + + +def test_on_config(): + v = SchemaValidator({'type': 'str'}, {'str_max_length': 5}) + + # Converted schema + v = SchemaValidator(schema=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({'type': 'str', 'max_length': 5}, {'str_max_length': 10}) + + # Converted schema + v = SchemaValidator(schema=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 + + +class MyModel: + # this is not required, but it avoids `__pydantic_fields_set__` being included in `__dict__` + __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' + + +def test_on_model_class(): + v = SchemaValidator( + { + 'type': 'model', + 'cls': MyModel, + 'config': {'str_max_length': 5}, + 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}}, + } + ) + + # Converted schema + v = SchemaValidator(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())}))) + + assert 'max_length:Some(5)' in plain_repr(v) + assert v.isinstance_python({'f': 'test'}) is True + assert v.isinstance_python({'f': 'test long'}) is False + + +def test_field_priority_model(): + v = SchemaValidator( + { + 'type': 'model', + 'cls': MyModel, + 'config': {'str_max_length': 10}, + 'schema': { + 'type': 'model-fields', + 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str', 'max_length': 5}}}, + }, + } + ) + + # Converted schema + v = SchemaValidator(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))}))) + + assert 'max_length:Some(5)' in plain_repr(v) + assert v.isinstance_python({'f': 'test'}) is True + assert v.isinstance_python({'f': 'test long'}) is False + + +@pytest.mark.parametrize( + 'config,float_field_schema,input_value,expected', + [ + ({}, {'type': 'float'}, {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan))), + ( + {'allow_inf_nan': True}, + {'type': 'float'}, + {'x': 'nan'}, + IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), + ), + ( + {'allow_inf_nan': False}, + {'type': 'float'}, + {'x': 'nan'}, + Err('Input should be a finite number [type=finite_number,'), + ), + # field `allow_inf_nan` (if set) should have priority over global config + ( + {'allow_inf_nan': True}, + {'type': 'float', 'allow_inf_nan': False}, + {'x': 'nan'}, + Err('Input should be a finite number [type=finite_number,'), + ), + ( + {'allow_inf_nan': False}, + {'type': 'float', 'allow_inf_nan': True}, + {'x': 'nan'}, + IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), + ), + ], + ids=repr, +) +def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expected): + v = SchemaValidator( + { + 'type': 'model', + 'cls': MyModel, + 'schema': {'type': 'model-fields', 'fields': {'x': {'type': 'model-field', 'schema': float_field_schema}}}, + 'config': config, + } + ) + + # Converted schema + v = SchemaValidator(schema=cs.model_schema(cls=MyModel, schema=cs.model_fields_schema(fields={'x': cs.model_field(schema=float_field_schema)}), config=config)) + + if isinstance(expected, Err): + with pytest.raises(ValidationError, match=re.escape(expected.message)): + v.validate_python(input_value) + else: + output_dict = v.validate_python(input_value) + assert output_dict == expected + + +@pytest.mark.parametrize( + 'config,input_str', + ( + ({}, 'type=string_type, input_value=123, input_type=int'), + ({'hide_input_in_errors': False}, 'type=string_type, input_value=123, input_type=int'), + ({'hide_input_in_errors': True}, 'type=string_type'), + ), +) +def test_hide_input_in_errors(config, input_str): + v = SchemaValidator( + { + 'type': 'model', + 'cls': MyModel, + 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}}, + }, + config, + ) + + # Converted schema + v = SchemaValidator(schema=cs.model_schema(cls=MyModel, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())})), config=config) + + + with pytest.raises(ValidationError, match=re.escape(f'Input should be a valid string [{input_str}]')): + assert v.validate_python({'f': 123}) + + +def test_cache_strings(): + v = SchemaValidator({'type': 'str'}) + + # Converted schema + v = SchemaValidator(schema=cs.str_schema()) + + assert 'cache_strings=True' in plain_repr(v) + + v = SchemaValidator({'type': 'str'}, {'cache_strings': True}) + + # Converted schema + v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=True)) + + assert 'cache_strings=True' in plain_repr(v) + + v = SchemaValidator({'type': 'str'}, {'cache_strings': False}) + + # Converted schema + v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=False)) + + assert 'cache_strings=False' in plain_repr(v) + + v = SchemaValidator({'type': 'str'}, {'cache_strings': 'keys'}) + + # Converted schema + v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings='keys')) + + assert "cache_strings='keys'" in plain_repr(v) \ No newline at end of file From 9d9a11fd1e4060ea0f420b451b060da870e6ff73 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Sun, 9 Feb 2025 14:46:30 +0000 Subject: [PATCH 02/11] handle parametersied schem --- test_transformer/schema_collector.py | 54 ++++++++++++-- test_transformer/transform.py | 64 +++++++++-------- tests/test_config_updated.py | 101 ++++----------------------- 3 files changed, 97 insertions(+), 122 deletions(-) diff --git a/test_transformer/schema_collector.py b/test_transformer/schema_collector.py index 2b5410406..e64b793c6 100644 --- a/test_transformer/schema_collector.py +++ b/test_transformer/schema_collector.py @@ -14,21 +14,38 @@ class LineRange: start: int end: int | None = None +@dataclass +class CharRange: + start: int + end: int @dataclass class SchemaValidatorCall: schema: dict | ASTClass config: dict | ASTClass | None lines: LineRange + char_range: CharRange context: str # The function/method name where this was found assigned_to: str | None # The variable this was assigned to +@dataclass +class ParametrizedConfig: + config: dict + lines: LineRange + char_range: CharRange + +@dataclass +class ParametrizedSchema: + schema: dict + lines: LineRange + char_range: CharRange class SchemaValidatorExtractor(ast.NodeVisitor): - def __init__(self): + def __init__(self, source): self.validators = [] self.current_function = None self.assigned_to = None + self.source = source def visit_FunctionDef(self, node): old_function = self.current_function @@ -76,6 +93,7 @@ def visit_Call(self, node): schema=schema_dict, config=config_dict, lines=LineRange(node.lineno, node.end_lineno), + char_range=CharRange(node.col_offset, node.end_col_offset or 0), context=self.current_function or '', assigned_to=self.assigned_to, ) @@ -89,6 +107,9 @@ def _handle_parametrize_decorator(self, decorator, func_node): param_names = self._eval_literal(decorator.args[0]) # Could be string or tuple of strings param_values = self._eval_literal(decorator.args[1]) # List of tuples/values + if not isinstance(param_values, (list, tuple)) or not isinstance(param_names, str): + return + if isinstance(param_names, str): param_names = param_names.split(',') @@ -100,12 +121,34 @@ def _handle_parametrize_decorator(self, decorator, func_node): schema_idx = [idx for idx, name in enumerate(param_names) if 'schema' in name] # For each test case in param_values, extract config and schema - for test_case in param_values: + for i, test_case in enumerate(param_values): + if not isinstance(test_case, tuple): + continue if config_idx is not None: config = test_case[config_idx] + ast_obj = decorator.args[1].elts[i].elts[config_idx] + if isinstance(config, dict): + self.validators.append( + ParametrizedConfig( + config=config, + lines=LineRange(ast_obj.lineno, ast_obj.end_lineno), + char_range=CharRange(ast_obj.col_offset, ast_obj.end_col_offset) + ) + ) for idx in schema_idx: schema = test_case[idx] - # Create SchemaValidatorCall for each combination + if isinstance(schema, dict): + ast_obj = decorator.args[1].elts[i].elts[idx] + self.validators.append( + ParametrizedSchema( + schema=schema, + lines=LineRange(ast_obj.lineno, ast_obj.end_lineno), + char_range=CharRange(ast_obj.col_offset, ast_obj.end_col_offset) + ) + ) + + + def _eval_dict_literal(self, node) -> dict | ASTClass | None: """Evaluate a dictionary literal AST node to a Python dict.""" @@ -147,9 +190,10 @@ def _eval_literal(self, node): def extract_validators_from_file(file_path: str) -> List[SchemaValidatorCall]: """Extract all SchemaValidator instantiations from a Python file.""" with open(file_path, 'r') as f: - tree = ast.parse(f.read()) + source = f.read() + tree = ast.parse(source) - extractor = SchemaValidatorExtractor() + extractor = SchemaValidatorExtractor(source) extractor.visit(tree) return extractor.validators diff --git a/test_transformer/transform.py b/test_transformer/transform.py index f6589eafe..4f012ba05 100644 --- a/test_transformer/transform.py +++ b/test_transformer/transform.py @@ -2,10 +2,19 @@ from typing import List from dataclasses import dataclass -from test_transformer.schema_collector import SchemaValidatorCall, extract_validators_from_file +from test_transformer.schema_collector import SchemaValidatorCall, extract_validators_from_file, ParametrizedConfig, ParametrizedSchema from test_transformer.core_schema_gen import convert_schema, config_to_CoreConfig, ASTClass +def get_replace_target(source:str, lines, char_range): + source_lines = source.splitlines() + replace_target = [] + for i in range(lines.start - 1, lines.end): + replace_target.append(source_lines[i]) + replace_target[-1] = replace_target[-1][:char_range.end] + replace_target[0] = replace_target[0][char_range.start:] + return "\n".join(replace_target) + def insert_validator_conversions(file_path: str, validators: List[SchemaValidatorCall]) -> str: """ Insert converted schema validators into the original file content. @@ -15,8 +24,8 @@ def insert_validator_conversions(file_path: str, validators: List[SchemaValidato with open(file_path, 'r') as f: content = f.read() - # Split content into lines for easier manipulation - lines = content.splitlines() + # Make a copy of the content to modify + modified_content = content # Sort validators by line number in reverse order to insert from bottom up # This prevents line numbers from shifting as we insert @@ -25,36 +34,33 @@ def insert_validator_conversions(file_path: str, validators: List[SchemaValidato # Process each validator for validator in validators: # Generate the new schema code - schema = convert_schema(validator.schema) - config = config_to_CoreConfig(validator.config) if validator.config else None - new_schema = ( - f'{validator.assigned_to} = SchemaValidator(schema={schema}, config={config})' - if config - else f'{validator.assigned_to} = SchemaValidator(schema={schema})' - ) - # assertion = f"assert {validator.assigned_to}_n == {validator.assigned_to}" - - # Calculate indentation from the original line - original_line = lines[validator.lines.start - 1] - indentation = len(original_line) - len(original_line.lstrip()) - indent = ' ' * indentation - - # Format the new code with proper indentation - new_code = f'\n{indent}# Converted schema\n{indent}{new_schema}\n' - - # Find the end of the original validator declaration - end_line = validator.lines.end if validator.lines.end else validator.lines.start - - # Insert the new code after the original validator - lines.insert(end_line, new_code) + if isinstance(validator, ParametrizedConfig): + new_code = config_to_CoreConfig(validator.config) + + elif isinstance(validator, ParametrizedSchema): + new_code = convert_schema(validator.schema) + + elif isinstance(validator, SchemaValidatorCall): + schema = convert_schema(validator.schema) + config = config_to_CoreConfig(validator.config) if validator.config else None + new_code = ( + f'SchemaValidator(schema={schema}, config={config})' + if config + else f'SchemaValidator(schema={schema})' + ) + else: + raise ValueError(f'Unsupported change type: {type(validator)}') + + # Find the code to replace + replace_target = get_replace_target(content, validator.lines, validator.char_range) + + # Replace the code in the modified content + modified_content = modified_content.replace(replace_target, new_code) - # Join lines back together - modified_content = '\n'.join(lines) # add import statements - modified_content = 'from pydantic_core import core_schema as cs\n' + modified_content - return modified_content + return 'from pydantic_core import core_schema as cs\n' + modified_content def update_test_file(input_file: str, output_file: str): diff --git a/tests/test_config_updated.py b/tests/test_config_updated.py index 4194531cc..b8c8b6d3f 100644 --- a/tests/test_config_updated.py +++ b/tests/test_config_updated.py @@ -11,11 +11,7 @@ def test_on_field(): - v = SchemaValidator({'type': 'str', 'min_length': 2, 'max_length': 5}) - - # Converted schema v = SchemaValidator(schema=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 @@ -24,22 +20,14 @@ def test_on_field(): def test_on_config(): - v = SchemaValidator({'type': 'str'}, {'str_max_length': 5}) - - # Converted schema v = SchemaValidator(schema=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({'type': 'str', 'max_length': 5}, {'str_max_length': 10}) - - # Converted schema v = SchemaValidator(schema=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 @@ -51,39 +39,14 @@ class MyModel: def test_on_model_class(): - v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'config': {'str_max_length': 5}, - 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}}, - } - ) - - # Converted schema v = SchemaValidator(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())}))) - assert 'max_length:Some(5)' in plain_repr(v) assert v.isinstance_python({'f': 'test'}) is True assert v.isinstance_python({'f': 'test long'}) is False def test_field_priority_model(): - v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'config': {'str_max_length': 10}, - 'schema': { - 'type': 'model-fields', - 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str', 'max_length': 5}}}, - }, - } - ) - - # Converted schema v = SchemaValidator(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))}))) - assert 'max_length:Some(5)' in plain_repr(v) assert v.isinstance_python({'f': 'test'}) is True assert v.isinstance_python({'f': 'test long'}) is False @@ -92,29 +55,29 @@ def test_field_priority_model(): @pytest.mark.parametrize( 'config,float_field_schema,input_value,expected', [ - ({}, {'type': 'float'}, {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan))), + (CoreConfig(), cs.float_schema(), {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan))), ( - {'allow_inf_nan': True}, - {'type': 'float'}, + CoreConfig(allow_inf_nan=True), + cs.float_schema(), {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), ), ( - {'allow_inf_nan': False}, - {'type': 'float'}, + CoreConfig(allow_inf_nan=False), + cs.float_schema(), {'x': 'nan'}, Err('Input should be a finite number [type=finite_number,'), ), # field `allow_inf_nan` (if set) should have priority over global config ( - {'allow_inf_nan': True}, - {'type': 'float', 'allow_inf_nan': False}, + CoreConfig(allow_inf_nan=True), + cs.float_schema(allow_inf_nan=False), {'x': 'nan'}, Err('Input should be a finite number [type=finite_number,'), ), ( - {'allow_inf_nan': False}, - {'type': 'float', 'allow_inf_nan': True}, + CoreConfig(allow_inf_nan=False), + cs.float_schema(allow_inf_nan=True), {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), ), @@ -122,18 +85,7 @@ def test_field_priority_model(): ids=repr, ) def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expected): - v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': {'type': 'model-fields', 'fields': {'x': {'type': 'model-field', 'schema': float_field_schema}}}, - 'config': config, - } - ) - - # Converted schema v = SchemaValidator(schema=cs.model_schema(cls=MyModel, schema=cs.model_fields_schema(fields={'x': cs.model_field(schema=float_field_schema)}), config=config)) - if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -145,54 +97,27 @@ def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expe @pytest.mark.parametrize( 'config,input_str', ( - ({}, 'type=string_type, input_value=123, input_type=int'), - ({'hide_input_in_errors': False}, 'type=string_type, input_value=123, input_type=int'), - ({'hide_input_in_errors': True}, 'type=string_type'), + (CoreConfig(), 'type=string_type, input_value=123, input_type=int'), + (CoreConfig(hide_input_in_errors=False), 'type=string_type, input_value=123, input_type=int'), + (CoreConfig(hide_input_in_errors=True), 'type=string_type'), ), ) def test_hide_input_in_errors(config, input_str): - v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}}, - }, - config, - ) - - # Converted schema v = SchemaValidator(schema=cs.model_schema(cls=MyModel, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())})), config=config) - with pytest.raises(ValidationError, match=re.escape(f'Input should be a valid string [{input_str}]')): assert v.validate_python({'f': 123}) def test_cache_strings(): - v = SchemaValidator({'type': 'str'}) - - # Converted schema v = SchemaValidator(schema=cs.str_schema()) - assert 'cache_strings=True' in plain_repr(v) - v = SchemaValidator({'type': 'str'}, {'cache_strings': True}) - - # Converted schema v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=True)) - assert 'cache_strings=True' in plain_repr(v) - v = SchemaValidator({'type': 'str'}, {'cache_strings': False}) - - # Converted schema v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=False)) - assert 'cache_strings=False' in plain_repr(v) - v = SchemaValidator({'type': 'str'}, {'cache_strings': 'keys'}) - - # Converted schema v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings='keys')) - - assert "cache_strings='keys'" in plain_repr(v) \ No newline at end of file + assert "cache_strings='keys'" in plain_repr(v) From a81b3c854c4b44b3c8c0e137881f23852329398f Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Mon, 10 Feb 2025 13:55:05 +0000 Subject: [PATCH 03/11] rm script --- test_transformer/__init__.py | 0 test_transformer/core_schema_gen.py | 170 --------------------- test_transformer/schema_collector.py | 215 --------------------------- test_transformer/transform.py | 87 ----------- 4 files changed, 472 deletions(-) delete mode 100644 test_transformer/__init__.py delete mode 100644 test_transformer/core_schema_gen.py delete mode 100644 test_transformer/schema_collector.py delete mode 100644 test_transformer/transform.py diff --git a/test_transformer/__init__.py b/test_transformer/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/test_transformer/core_schema_gen.py b/test_transformer/core_schema_gen.py deleted file mode 100644 index c602bc9e7..000000000 --- a/test_transformer/core_schema_gen.py +++ /dev/null @@ -1,170 +0,0 @@ -from typing import Any, Dict, Union, Optional -from typing_extensions import TypedDict -from dataclasses import dataclass -from pydantic_core import core_schema as cs - - -@dataclass -class ASTClass: - name: str - - -class CoreConfig(TypedDict, total=False): - """Schema configuration options matching pydantic_core's CoreConfig""" - - title: str - strict: bool - extra_fields_behavior: str # 'allow', 'forbid', 'ignore' - typed_dict_total: bool - from_attributes: bool - loc_by_alias: bool - revalidate_instances: str # 'always', 'never', 'subclass-instances' - validate_default: bool - populate_by_name: bool - str_max_length: int - str_min_length: int - str_strip_whitespace: bool - str_to_lower: bool - str_to_upper: bool - allow_inf_nan: bool - ser_json_timedelta: str # 'iso8601', 'float' - ser_json_bytes: str # 'utf8', 'base64', 'hex' - ser_json_inf_nan: str # 'null', 'constants', 'strings' - val_json_bytes: str # 'utf8', 'base64', 'hex' - hide_input_in_errors: bool - validation_error_cause: bool - coerce_numbers_to_str: bool - regex_engine: str # 'rust-regex', 'python-re' - cache_strings: Union[bool, str] # bool or 'all', 'keys', 'none' - - -SCHEMA_TYPE_TO_FUNCTION = { - 'str': 'str_schema', - 'int': 'int_schema', - 'float': 'float_schema', - 'bool': 'bool_schema', - 'dict': 'dict_schema', - 'list': 'list_schema', - 'set': 'set_schema', - 'tuple': 'tuple_schema', - 'frozenset': 'frozenset_schema', - 'any': 'any_schema', - 'none': 'none_schema', - 'model': 'model_schema', - 'model-field': 'model_field', - 'model-fields': 'model_fields_schema', - 'typed-dict': 'typed_dict_schema', - 'typed-dict-field': 'typed_dict_field', - 'union': 'union_schema', - 'nullable': 'nullable_schema', - 'function-before': 'before_validator_function', - 'function-after': 'after_validator_function', - 'function-wrap': 'wrap_validator_function', - 'function-plain': 'plain_validator_function', -} - -# Parameters that require special handling -SPECIAL_PARAMS = {'ref', 'metadata', 'serialization', 'type'} - - -def format_value(value: Any) -> str: - """Format a value for inclusion in a function call.""" - if isinstance(value, str): - return f"'{value}'" - elif isinstance(value, ASTClass): - return value.name - elif isinstance(value, dict): - return dict_to_schema_call(value) - elif isinstance(value, list): - items = [format_value(item) for item in value] - return f'[{", ".join(items)}]' - elif isinstance(value, bool): - return str(value) - elif value is None: - return 'None' - return str(value) - - -def format_kwarg(key: str, value: Any) -> str: - """Format a keyword argument for a function call.""" - formatted_value = format_value(value) - return f'{key}={formatted_value}' - - -def dict_to_schema_call(schema_dict: Dict[str, Any]) -> str: - """Convert a schema dictionary to a CoreSchema function call.""" - if not isinstance(schema_dict, dict): - return format_value(schema_dict) - - schema_type = schema_dict.get('type') - if not schema_type: - # Handle dict literals that aren't schema definitions - items = [f"'{k}': {format_value(v)}" for k, v in schema_dict.items()] - return f'{{{", ".join(items)}}}' - - function_name = SCHEMA_TYPE_TO_FUNCTION.get(schema_type) - if not function_name: - raise ValueError(f'Unknown schema type: {schema_type}') - - # Collect kwargs - kwargs = [] - for key, value in schema_dict.items(): - if key in SPECIAL_PARAMS: - continue - - # Handle special cases - if key == 'config': - config = schema_dict.get('config', {}) - if isinstance(config, ASTClass) and config.name == 'config': - kwargs.append(f'config={config.name}') - continue - if not config or not isinstance(config, dict): - continue - kwargs.append(f'config={config_to_CoreConfig(config)}') - elif key == 'schema' and isinstance(value, dict): - kwargs.append(f'schema={dict_to_schema_call(value)}') - elif key == 'fields' and isinstance(value, dict): - # Handle fields mapping for typed-dict and model schemas - field_items = [] - for field_name, field_schema in value.items(): - formatted_field = dict_to_schema_call(field_schema) - field_items.append(f"'{field_name}': {formatted_field}") - kwargs.append(f'fields={{{", ".join(field_items)}}}') - else: - kwargs.append(format_kwarg(key, value)) - - # Add reference if present - if 'ref' in schema_dict: - kwargs.append(format_kwarg('ref', schema_dict['ref'])) - - # Add metadata if present - if 'metadata' in schema_dict: - kwargs.append(format_kwarg('metadata', schema_dict['metadata'])) - - # Add serialization if present - if 'serialization' in schema_dict: - kwargs.append(format_kwarg('serialization', schema_dict['serialization'])) - - return f'cs.{function_name}({", ".join(kwargs)})' - - -def config_to_CoreConfig(config: Dict[str, Any] | ASTClass) -> str: - """Convert a config dictionary to a CoreConfig TypedDict instantiation.""" - if isinstance(config, ASTClass): - return config.name - config_items = [] - for key, value in config.items(): - if isinstance(value, str): - config_items.append(f"{key}='{value}'") - else: - config_items.append(f'{key}={value}') - return f'CoreConfig({", ".join(config_items)})' - - -def convert_schema(schema: dict[str, Any]|ASTClass) -> str: - """Convert a schema dictionary to a CoreSchema function call with proper formatting.""" - if isinstance(schema, ASTClass): - return schema.name - result = dict_to_schema_call(schema) - - return result diff --git a/test_transformer/schema_collector.py b/test_transformer/schema_collector.py deleted file mode 100644 index e64b793c6..000000000 --- a/test_transformer/schema_collector.py +++ /dev/null @@ -1,215 +0,0 @@ -import ast -from dataclasses import dataclass -from typing import Optional, List -import json - - -from pydantic_core import SchemaValidator, CoreConfig -from pydantic_core import core_schema as cs -from test_transformer.core_schema_gen import convert_schema, config_to_CoreConfig, ASTClass - - -@dataclass -class LineRange: - start: int - end: int | None = None - -@dataclass -class CharRange: - start: int - end: int - -@dataclass -class SchemaValidatorCall: - schema: dict | ASTClass - config: dict | ASTClass | None - lines: LineRange - char_range: CharRange - context: str # The function/method name where this was found - assigned_to: str | None # The variable this was assigned to - -@dataclass -class ParametrizedConfig: - config: dict - lines: LineRange - char_range: CharRange - -@dataclass -class ParametrizedSchema: - schema: dict - lines: LineRange - char_range: CharRange - -class SchemaValidatorExtractor(ast.NodeVisitor): - def __init__(self, source): - self.validators = [] - self.current_function = None - self.assigned_to = None - self.source = source - - def visit_FunctionDef(self, node): - old_function = self.current_function - self.current_function = node.name - - # Add decorator handling - for decorator in node.decorator_list: - if isinstance(decorator, ast.Call): - # Check if it's pytest.mark.parametrize - if (isinstance(decorator.func, ast.Attribute) - and decorator.func.attr == 'parametrize' - and isinstance(decorator.func.value, ast.Attribute) - and decorator.func.value.attr == 'mark'): - self._handle_parametrize_decorator(decorator, node) - - self.generic_visit(node) - self.current_function = old_function - - def visit_Assign(self, node): - # Check if the value being assigned is a function - if isinstance(node.value, (ast.Call)): - # node.targets[0] is the variable being assigned to - if isinstance(node.targets[0], ast.Name) and getattr(node.value.func, 'id', None) == 'SchemaValidator': - self.assigned_to = node.targets[0].id - - self.generic_visit(node) - - def visit_Call(self, node): - # Check if this is a SchemaValidator instantiation - if isinstance(node.func, ast.Name) and node.func.id == 'SchemaValidator': - schema_dict = None - config_dict = None - - # Extract schema (first argument) - if len(node.args) > 0: - schema_dict = self._eval_dict_literal(node.args[0]) - - # Extract config (second argument) - if len(node.args) > 1: - config_dict = self._eval_dict_literal(node.args[1]) - - if schema_dict is not None: - self.validators.append( - SchemaValidatorCall( - schema=schema_dict, - config=config_dict, - lines=LineRange(node.lineno, node.end_lineno), - char_range=CharRange(node.col_offset, node.end_col_offset or 0), - context=self.current_function or '', - assigned_to=self.assigned_to, - ) - ) - - self.generic_visit(node) - - def _handle_parametrize_decorator(self, decorator, func_node): - # Extract parameter names and values - if len(decorator.args) >= 2: - param_names = self._eval_literal(decorator.args[0]) # Could be string or tuple of strings - param_values = self._eval_literal(decorator.args[1]) # List of tuples/values - - if not isinstance(param_values, (list, tuple)) or not isinstance(param_names, str): - return - - if isinstance(param_names, str): - param_names = param_names.split(',') - - # Map parameter names to their indices - param_indices = {name.strip(): idx for idx, name in enumerate(param_names)} - - # Look for 'config' and schema-related parameters - config_idx = param_indices.get('config') - schema_idx = [idx for idx, name in enumerate(param_names) if 'schema' in name] - - # For each test case in param_values, extract config and schema - for i, test_case in enumerate(param_values): - if not isinstance(test_case, tuple): - continue - if config_idx is not None: - config = test_case[config_idx] - ast_obj = decorator.args[1].elts[i].elts[config_idx] - if isinstance(config, dict): - self.validators.append( - ParametrizedConfig( - config=config, - lines=LineRange(ast_obj.lineno, ast_obj.end_lineno), - char_range=CharRange(ast_obj.col_offset, ast_obj.end_col_offset) - ) - ) - for idx in schema_idx: - schema = test_case[idx] - if isinstance(schema, dict): - ast_obj = decorator.args[1].elts[i].elts[idx] - self.validators.append( - ParametrizedSchema( - schema=schema, - lines=LineRange(ast_obj.lineno, ast_obj.end_lineno), - char_range=CharRange(ast_obj.col_offset, ast_obj.end_col_offset) - ) - ) - - - - - def _eval_dict_literal(self, node) -> dict | ASTClass | None: - """Evaluate a dictionary literal AST node to a Python dict.""" - if isinstance(node, ast.Dict): - result = {} - for k, v in zip(node.keys, node.values): - key = self._eval_literal(k) - value = self._eval_literal(v) - if key is not None and value is not None: - result[key] = value - return result - if isinstance(node, ast.Name): - return ASTClass(name=node.id) - return None - - def _eval_literal(self, node): - """Evaluate a literal AST node to its Python value.""" - if isinstance(node, ast.List): - return [self._eval_literal(item) for item in node.elts] - elif isinstance(node, ast.Tuple): - return tuple(self._eval_literal(item) for item in node.elts) - if isinstance(node, ast.Constant): - return node.s - elif isinstance(node, ast.Dict): - return self._eval_dict_literal(node) - elif isinstance(node, ast.Name): - # Handle common constants - if node.id == 'True': - return True - elif node.id == 'False': - return False - elif node.id == 'None': - return None - else: - return ASTClass(name=node.id) - return None - - -def extract_validators_from_file(file_path: str) -> List[SchemaValidatorCall]: - """Extract all SchemaValidator instantiations from a Python file.""" - with open(file_path, 'r') as f: - source = f.read() - tree = ast.parse(source) - - extractor = SchemaValidatorExtractor(source) - extractor.visit(tree) - return extractor.validators - - -def format_validator_call(validator: SchemaValidatorCall) -> str: - """Format a SchemaValidator call into a readable string.""" - parts = [ - f'Lines {validator.lines.start}:{validator.lines.end} in {validator.context}:', - 'SchemaValidator(', - f' schema={json.dumps(validator.schema, indent=4, default=str)}', - ] - - if isinstance(validator.config, dict): - parts.append(f' config={json.dumps(validator.config, indent=4)}') - elif isinstance(validator.config, ASTClass): - parts.append(f' config={validator.config.name}') - - parts.append(')') - return '\n'.join(parts) diff --git a/test_transformer/transform.py b/test_transformer/transform.py deleted file mode 100644 index 4f012ba05..000000000 --- a/test_transformer/transform.py +++ /dev/null @@ -1,87 +0,0 @@ -import ast -from typing import List -from dataclasses import dataclass - -from test_transformer.schema_collector import SchemaValidatorCall, extract_validators_from_file, ParametrizedConfig, ParametrizedSchema -from test_transformer.core_schema_gen import convert_schema, config_to_CoreConfig, ASTClass - - -def get_replace_target(source:str, lines, char_range): - source_lines = source.splitlines() - replace_target = [] - for i in range(lines.start - 1, lines.end): - replace_target.append(source_lines[i]) - replace_target[-1] = replace_target[-1][:char_range.end] - replace_target[0] = replace_target[0][char_range.start:] - return "\n".join(replace_target) - -def insert_validator_conversions(file_path: str, validators: List[SchemaValidatorCall]) -> str: - """ - Insert converted schema validators into the original file content. - Returns the modified file content as a string. - """ - # Read the original file - with open(file_path, 'r') as f: - content = f.read() - - # Make a copy of the content to modify - modified_content = content - - # Sort validators by line number in reverse order to insert from bottom up - # This prevents line numbers from shifting as we insert - validators = sorted(validators, key=lambda x: x.lines.start, reverse=True) - - # Process each validator - for validator in validators: - # Generate the new schema code - if isinstance(validator, ParametrizedConfig): - new_code = config_to_CoreConfig(validator.config) - - elif isinstance(validator, ParametrizedSchema): - new_code = convert_schema(validator.schema) - - elif isinstance(validator, SchemaValidatorCall): - schema = convert_schema(validator.schema) - config = config_to_CoreConfig(validator.config) if validator.config else None - new_code = ( - f'SchemaValidator(schema={schema}, config={config})' - if config - else f'SchemaValidator(schema={schema})' - ) - else: - raise ValueError(f'Unsupported change type: {type(validator)}') - - # Find the code to replace - replace_target = get_replace_target(content, validator.lines, validator.char_range) - - # Replace the code in the modified content - modified_content = modified_content.replace(replace_target, new_code) - - - # add import statements - - return 'from pydantic_core import core_schema as cs\n' + modified_content - - -def update_test_file(input_file: str, output_file: str): - """ - Process a test file and update it with converted schema validators. - If output_file is not specified, will modify the input file in place. - """ - # Extract validators - validators = extract_validators_from_file(input_file) - - # Generate modified content - modified_content = insert_validator_conversions(input_file, validators) - - # Write to output file - output_path = output_file or input_file - with open(output_path, 'w') as f: - f.write(modified_content) - - print(f'Updated {len(validators)} schema validators in {output_path}') - - -if __name__ == '__main__': - # Example usage - update_test_file('tests/test_config.py', 'tests/test_config_updated.py') From 4d177989307d74f55c944b2425a9d4847917664a Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Mon, 10 Feb 2025 14:51:30 +0000 Subject: [PATCH 04/11] update bulk of schema validators to use schema fns --- tests/benchmarks/test_micro_benchmarks.py | 383 +++++------ tests/serializers/test_any.py | 10 +- tests/serializers/test_dataclasses.py | 2 +- tests/serializers/test_list_tuple.py | 8 +- tests/serializers/test_model.py | 6 +- tests/serializers/test_other.py | 4 +- tests/serializers/test_serialize_as_any.py | 16 +- tests/serializers/test_simple.py | 20 +- tests/serializers/test_url.py | 8 +- tests/test_build.py | 10 +- tests/test_config.py | 90 ++- tests/test_config_updated.py | 123 ---- tests/test_errors.py | 78 ++- tests/test_garbage_collection.py | 6 +- tests/test_hypothesis.py | 10 +- tests/test_isinstance.py | 13 +- tests/test_json.py | 77 +-- tests/test_misc.py | 30 +- 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 | 28 +- tests/validators/test_arguments.py | 55 +- tests/validators/test_bool.py | 9 +- tests/validators/test_bytes.py | 11 +- tests/validators/test_call.py | 106 ++- tests/validators/test_callable.py | 7 +- tests/validators/test_chain.py | 41 +- tests/validators/test_complex.py | 17 +- tests/validators/test_custom_error.py | 4 +- tests/validators/test_dataclasses.py | 82 +-- tests/validators/test_date.py | 21 +- tests/validators/test_datetime.py | 55 +- tests/validators/test_decimal.py | 33 +- tests/validators/test_definitions.py | 24 +- .../validators/test_definitions_recursive.py | 128 ++-- tests/validators/test_dict.py | 33 +- tests/validators/test_enums.py | 56 +- tests/validators/test_float.py | 21 +- tests/validators/test_frozenset.py | 36 +- tests/validators/test_function.py | 150 +++-- tests/validators/test_generator.py | 13 +- tests/validators/test_int.py | 41 +- tests/validators/test_is_instance.py | 29 +- 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 | 45 +- tests/validators/test_literal.py | 27 +- tests/validators/test_model.py | 461 ++++++------- tests/validators/test_model_fields.py | 612 ++++++++---------- tests/validators/test_model_init.py | 147 ++--- tests/validators/test_model_root.py | 20 +- tests/validators/test_none.py | 5 +- tests/validators/test_nullable.py | 17 +- tests/validators/test_pickling.py | 6 +- tests/validators/test_set.py | 34 +- tests/validators/test_string.py | 64 +- tests/validators/test_tagged_union.py | 182 +++--- tests/validators/test_time.py | 28 +- tests/validators/test_timedelta.py | 34 +- tests/validators/test_tuple.py | 97 +-- tests/validators/test_typed_dict.py | 413 ++++++------ tests/validators/test_union.py | 263 ++++---- tests/validators/test_url.py | 38 +- tests/validators/test_uuid.py | 12 +- tests/validators/test_with_default.py | 300 +++++---- 70 files changed, 2277 insertions(+), 2478 deletions(-) delete mode 100644 tests/test_config_updated.py diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py index 2caa6fc83..0c9757efa 100644 --- a/tests/benchmarks/test_micro_benchmarks.py +++ b/tests/benchmarks/test_micro_benchmarks.py @@ -18,6 +18,7 @@ import pydantic_core from pydantic_core import ( ArgsKwargs, + CoreConfig, PydanticCustomError, PydanticKnownError, SchemaValidator, @@ -43,26 +44,23 @@ class CoreModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' return SchemaValidator( - { - 'type': 'model', - 'cls': CoreModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'name': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'age': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'friends': {'type': 'model-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}}, - 'settings': { - 'type': 'model-field', - 'schema': { - 'type': 'dict', - 'keys_schema': {'type': 'str'}, - 'values_schema': {'type': 'float'}, - }, - }, - }, - }, - } + schema=core_schema.model_schema( + cls=CoreModel, + 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()), + 'friends': core_schema.model_field( + schema=core_schema.list_schema(items_schema=core_schema.int_schema()) + ), + 'settings': core_schema.model_field( + schema=core_schema.dict_schema( + keys_schema=core_schema.str_schema(), values_schema=core_schema.float_schema() + ) + ), + } + ), + ) ) data = {'name': 'John', 'age': 42, 'friends': list(range(200)), 'settings': {f'v_{i}': i / 2.0 for i in range(50)}} @@ -88,15 +86,13 @@ class CoreModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' return SchemaValidator( - { - 'type': 'model', - 'cls': CoreModel, - 'schema': { - 'type': 'model-fields', - 'extra_behavior': 'allow', - 'fields': {f'field_{i}': {'type': 'model-field', 'schema': {'type': 'int'}} for i in range(100)}, - }, - } + schema=core_schema.model_schema( + cls=CoreModel, + schema=core_schema.model_fields_schema( + extra_behavior='allow', + fields={f'field_{i}': {'type': 'model-field', 'schema': {'type': 'int'}} for i in range(100)}, + ), + ) ) data = {f'field_{99 - i}': i for i in range(100)} @@ -127,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({'type': 'bool'}) + schema_validator = SchemaValidator(schema=core_schema.bool_schema()) @benchmark def t(): @@ -147,7 +143,7 @@ def test_small_class_core_dict(benchmark): 'age': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, }, } - dict_schema_validator = SchemaValidator(model_schema) + dict_schema_validator = SchemaValidator(schema=model_schema) benchmark(dict_schema_validator.validate_python, small_class_data) @@ -161,24 +157,22 @@ class MyCoreModel: age: int model_schema_validator = SchemaValidator( - { - 'type': 'model', - 'cls': MyCoreModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'name': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'age': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + schema=core_schema.model_schema( + cls=MyCoreModel, + 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()), + } + ), + ) ) benchmark(model_schema_validator.validate_python, small_class_data) @pytest.mark.benchmark(group='string') def test_core_string_lax(benchmark): - validator = SchemaValidator(core_schema.str_schema()) + validator = SchemaValidator(schema=core_schema.str_schema()) input_str = 'Hello ' * 20 assert validator.validate_python(input_str) == input_str @@ -188,7 +182,7 @@ def test_core_string_lax(benchmark): @pytest.mark.benchmark(group='string') def test_core_string_lax_wrong(benchmark): - validator = SchemaValidator(core_schema.str_schema()) + validator = SchemaValidator(schema=core_schema.str_schema()) with pytest.raises(ValidationError, match='Input should be a valid string'): validator.validate_python(123) @@ -203,7 +197,7 @@ def t(): @pytest.mark.benchmark(group='string') def test_core_string_strict(benchmark): - validator = SchemaValidator(core_schema.str_schema(strict=True)) + validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) input_str = 'Hello ' * 20 assert validator.validate_python(input_str) == input_str @@ -213,7 +207,7 @@ def test_core_string_strict(benchmark): @pytest.mark.benchmark(group='string') def test_core_string_strict_wrong(benchmark): - validator = SchemaValidator(core_schema.str_schema(strict=True)) + validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) with pytest.raises(ValidationError, match='Input should be a valid string'): validator.validate_python(123) @@ -228,7 +222,7 @@ def t(): @pytest.mark.benchmark(group='string') def test_core_string_strict_wrong_str_e(benchmark): - validator = SchemaValidator(core_schema.str_schema(strict=True)) + validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) with pytest.raises(ValidationError, match='Input should be a valid string'): validator.validate_python(123) @@ -243,7 +237,7 @@ def t(): @pytest.mark.benchmark(group='isinstance-string') def test_isinstance_string_lax_true(benchmark): - validator = SchemaValidator(core_schema.str_schema()) + validator = SchemaValidator(schema=core_schema.str_schema()) input_str = 'Hello ' * 20 assert validator.isinstance_python(input_str) is True @@ -253,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(core_schema.str_schema()) + validator = SchemaValidator(schema=core_schema.str_schema()) assert validator.isinstance_python(123) is False @@ -262,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(core_schema.str_schema(strict=True)) + validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) input_str = 'Hello ' * 20 assert validator.isinstance_python(input_str) is True @@ -272,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(core_schema.str_schema(strict=True)) + validator = SchemaValidator(schema=core_schema.str_schema(strict=True)) assert validator.isinstance_python(123) is False @@ -299,7 +293,7 @@ class CoreBranch: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema(schema_ref='Branch'), [ core_schema.model_schema( @@ -328,13 +322,11 @@ class CoreBranch: @pytest.mark.benchmark(group='list[TypedDict]') def test_list_of_dict_models_core(benchmark): v = SchemaValidator( - { - 'type': 'list', - 'items_schema': { - 'type': 'typed-dict', - 'fields': {'width': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}}, - }, - } + schema=core_schema.list_schema( + items_schema=core_schema.typed_dict_schema( + fields={'width': core_schema.typed_dict_field(schema=core_schema.int_schema())} + ) + ) ) data = [{'width': i} for i in range(100)] @@ -346,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({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.list_schema(items_schema=core_schema.int_schema())) @benchmark def t(): @@ -356,7 +348,7 @@ def t(): @pytest.mark.benchmark(group='list[int] JSON') def test_list_of_ints_core_json(benchmark): - v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.list_schema(items_schema=core_schema.int_schema())) json_data = [json.dumps(d) for d in list_of_ints_data] @@ -371,14 +363,14 @@ def t(): @pytest.mark.benchmark(group='list[str]') def test_list_of_strs_py_cached(benchmark): - v = SchemaValidator(core_schema.list_schema(core_schema.str_schema())) + v = SchemaValidator(schema=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(core_schema.list_schema(core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.list_schema(core_schema.str_schema())) json_data = json.dumps(list_of_strs_data) benchmark(v.validate_json, json_data) @@ -386,7 +378,9 @@ def test_list_of_strs_json_cached(benchmark): @pytest.mark.benchmark(group='list[str]') def test_list_of_strs_json_uncached(benchmark): - v = SchemaValidator(core_schema.list_schema(core_schema.str_schema()), {'cache_strings': False}) + v = SchemaValidator( + schema=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) @@ -394,7 +388,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({'type': 'list'}) + v = SchemaValidator(schema=core_schema.list_schema()) @benchmark def t(): @@ -408,7 +402,7 @@ def t(): @pytest.mark.benchmark(group='Set[int]') def test_set_of_ints_core(benchmark): - v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) @benchmark def t(): @@ -418,7 +412,7 @@ def t(): @pytest.mark.benchmark(group='Set[int]') def test_set_of_ints_core_duplicates(benchmark): - v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) @benchmark def t(): @@ -428,7 +422,7 @@ def t(): @pytest.mark.benchmark(group='Set[int]') def test_set_of_ints_core_length(benchmark): - v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}, 'max_length': 2000}) + v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema(), max_length=2000)) @benchmark def t(): @@ -438,7 +432,7 @@ def t(): @pytest.mark.benchmark(group='Set[int] JSON') def test_set_of_ints_core_json(benchmark): - v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) json_data = [json.dumps(list(d)) for d in set_of_ints_data] @@ -450,7 +444,7 @@ def t(): @pytest.mark.benchmark(group='Set[int] JSON') def test_set_of_ints_core_json_duplicates(benchmark): - v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.set_schema(items_schema=core_schema.int_schema())) json_data = [json.dumps(list(d)) for d in set_of_ints_duplicates] @@ -466,14 +460,14 @@ def t(): @pytest.mark.benchmark(group='FrozenSet[int]') def test_frozenset_of_ints_core(benchmark): - v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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({'type': 'frozenset', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.frozenset_schema(items_schema=core_schema.int_schema())) benchmark(v.validate_python, frozenset_of_ints_duplicates) @@ -483,7 +477,9 @@ def test_frozenset_of_ints_duplicates_core(benchmark): @pytest.mark.benchmark(group='dict[str, int]') def test_dict_of_ints_core(benchmark): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator( + schema=core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()) + ) @benchmark def t(): @@ -493,7 +489,7 @@ def t(): @pytest.mark.benchmark(group='dict[any, any]') def test_dict_of_any_core(benchmark): - v = SchemaValidator({'type': 'dict'}) + v = SchemaValidator(schema=core_schema.dict_schema()) @benchmark def t(): @@ -503,7 +499,9 @@ def t(): @pytest.mark.benchmark(group='dict[str, int] JSON') def test_dict_of_ints_core_json(benchmark): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator( + 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] @@ -525,7 +523,7 @@ def test_many_models_core_dict(benchmark): 'fields': {'age': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}}, }, } - v = SchemaValidator(model_schema) + v = SchemaValidator(schema=model_schema) benchmark(v.validate_python, many_models_data) @@ -535,17 +533,14 @@ class MyCoreModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - { - 'type': 'list', - 'items_schema': { - 'type': 'model', - 'cls': MyCoreModel, - 'schema': { - 'type': 'model-fields', - 'fields': {'age': {'type': 'model-field', 'schema': {'type': 'int'}}}, - }, - }, - } + schema=core_schema.list_schema( + items_schema=core_schema.model_schema( + cls=MyCoreModel, + schema=core_schema.model_fields_schema( + fields={'age': core_schema.model_field(schema=core_schema.int_schema())} + ), + ) + ) ) benchmark(v.validate_python, many_models_data) @@ -555,7 +550,9 @@ class MyCoreModel: @pytest.mark.benchmark(group='list[Nullable[int]]') def test_list_of_nullable_core(benchmark): - v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'nullable', 'schema': {'type': 'int'}}}) + v = SchemaValidator( + schema=core_schema.list_schema(items_schema=core_schema.nullable_schema(schema=core_schema.int_schema())) + ) benchmark(v.validate_python, list_of_nullable_data) @@ -565,7 +562,7 @@ def test_list_of_nullable_core(benchmark): @pytest.mark.benchmark(group='bytes') def test_bytes_core(benchmark): - v = SchemaValidator({'type': 'bytes'}) + v = SchemaValidator(schema=core_schema.bytes_schema()) benchmark(v.validate_python, some_bytes) @@ -577,14 +574,12 @@ class CoreModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' return SchemaValidator( - { - 'type': 'model', - 'cls': CoreModel, - 'schema': { - 'type': 'model-fields', - 'fields': {'dt': {'type': 'model-field', 'schema': {'type': 'datetime'}}}, - }, - } + schema=core_schema.model_schema( + cls=CoreModel, + schema=core_schema.model_fields_schema( + fields={'dt': core_schema.model_field(schema=core_schema.datetime_schema())} + ), + ) ) @pytest.fixture(scope='class') @@ -613,25 +608,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({'type': 'datetime'}) + v = SchemaValidator(schema=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({'type': 'datetime'}) + v = SchemaValidator(schema=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({'type': 'datetime', 'gt': datetime.now()}) + v = SchemaValidator(schema=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({'type': 'datetime', 'gt': datetime.now()}) + v = SchemaValidator(schema=core_schema.datetime_schema(gt=datetime.now())) benchmark(v.validate_python, datetime_str) @@ -639,7 +634,7 @@ def test_core_future_str(self, benchmark, datetime_str): class TestBenchmarkDateX: @pytest.fixture(scope='class') def validator(self): - return SchemaValidator({'type': 'date'}) + return SchemaValidator(schema=core_schema.date_schema()) @pytest.mark.benchmark(group='date from date') def test_date_from_date(self, benchmark, validator): @@ -659,13 +654,13 @@ def test_date_from_datetime_str(self, benchmark, validator): @pytest.mark.benchmark(group='date future') def test_core_future(self, benchmark): - v = SchemaValidator({'type': 'date', 'gt': date.today()}) + v = SchemaValidator(schema=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({'type': 'date', 'gt': date.today()}) + v = SchemaValidator(schema=core_schema.date_schema(gt=date.today())) benchmark(v.validate_python, str(date(2932, 1, 1))) @@ -673,27 +668,37 @@ def test_core_future_str(self, benchmark): class TestBenchmarkUnion: @pytest.mark.benchmark(group='smart-union') def test_smart_union_core(self, benchmark): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'bool'}, {'type': 'int'}, {'type': 'str'}]}) + v = SchemaValidator( + schema=core_schema.union_schema( + choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()] + ) + ) benchmark(v.validate_python, 1) @pytest.mark.benchmark(group='smart-union-coerce') def test_smart_union_coerce_core(self, benchmark): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'bool'}, {'type': 'str'}]}) + v = SchemaValidator( + schema=core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.str_schema()]) + ) benchmark(v.validate_python, 1) # will be True @pytest.mark.benchmark(group='strict-union') def test_strict_union_core(self, benchmark): v = SchemaValidator( - {'type': 'union', 'strict': True, 'choices': [{'type': 'bool'}, {'type': 'int'}, {'type': 'str'}]} + schema=core_schema.union_schema( + strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()] + ) ) benchmark(v.validate_python, 1) @pytest.mark.benchmark(group='strict-union-error') def test_strict_union_error_core(self, benchmark): - v = SchemaValidator({'type': 'union', 'strict': True, 'choices': [{'type': 'bool'}, {'type': 'str'}]}) + v = SchemaValidator( + schema=core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.str_schema()]) + ) def validate_with_expected_error(): try: @@ -712,19 +717,17 @@ class CoreModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' return SchemaValidator( - { - 'type': 'model', - 'cls': CoreModel, - 'schema': { - 'type': 'model-fields', - 'fields': {'u': {'type': 'model-field', 'schema': {'type': 'uuid'}}}, - }, - } + schema=core_schema.model_schema( + cls=CoreModel, + schema=core_schema.model_fields_schema( + fields={'u': core_schema.model_field(schema=core_schema.uuid_schema())} + ), + ) ) @pytest.fixture(scope='class') def validator(self): - return SchemaValidator({'type': 'uuid'}) + return SchemaValidator(schema=core_schema.uuid_schema()) @pytest.fixture(scope='class') def pydantic_validator(self): @@ -758,7 +761,7 @@ def to_UUID(v: Any) -> UUID: serialization=core_schema.to_string_ser_schema(when_used='json'), ) - return SchemaValidator(schema) + return SchemaValidator(schema=schema) @pytest.mark.benchmark(group='uuid from str') def test_uuid_from_string_core(self, benchmark, validator): @@ -802,13 +805,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({'type': 'uuid'}) + v = SchemaValidator(schema=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({'type': 'uuid'}) + v = SchemaValidator(schema=core_schema.uuid_schema()) benchmark(v.validate_python, uuid_str) @@ -818,7 +821,7 @@ def test_dont_raise_error(benchmark): def f(input_value, info): return input_value - v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) @benchmark def t(): @@ -830,7 +833,7 @@ def test_dont_raise_error_no_info(benchmark): def f(input_value): return input_value - v = SchemaValidator(core_schema.no_info_plain_validator_function(f)) + v = SchemaValidator(schema=core_schema.no_info_plain_validator_function(f)) @benchmark def t(): @@ -842,7 +845,7 @@ def test_raise_error_value_error(benchmark): def f(input_value, info): raise ValueError('this is a custom error') - v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) @benchmark def t(): @@ -859,7 +862,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(core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) @benchmark def t(): @@ -874,10 +877,15 @@ def t(): @pytest.mark.benchmark(group='tuple') def test_positional_tuple(benchmark): v = SchemaValidator( - { - 'type': 'tuple', - 'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}], - } + schema=core_schema.tuple_schema( + items_schema=[ + core_schema.int_schema(), + core_schema.int_schema(), + core_schema.int_schema(), + core_schema.int_schema(), + core_schema.int_schema(), + ] + ) ) assert v.validate_python((1, 2, 3, '4', 5)) == (1, 2, 3, 4, 5) @@ -886,7 +894,7 @@ def test_positional_tuple(benchmark): @pytest.mark.benchmark(group='tuple') def test_variable_tuple(benchmark): - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0}) + v = SchemaValidator(schema=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)) @@ -894,7 +902,7 @@ def test_variable_tuple(benchmark): @pytest.mark.benchmark(group='tuple-many') def test_tuple_many_variable(benchmark): - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0}) + v = SchemaValidator(schema=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))) @@ -902,7 +910,7 @@ def test_tuple_many_variable(benchmark): @pytest.mark.benchmark(group='tuple-many') def test_tuple_many_positional(benchmark): - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0}) + v = SchemaValidator(schema=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))) @@ -911,16 +919,15 @@ def test_tuple_many_positional(benchmark): @pytest.mark.benchmark(group='arguments') def test_arguments(benchmark): v = SchemaValidator( - { - 'type': 'arguments', - 'arguments_schema': [ - {'name': 'args1', 'mode': 'positional_only', 'schema': {'type': 'int'}}, - {'name': 'args2', 'mode': 'positional_only', 'schema': {'type': 'str'}}, - {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'bool'}}, - {'name': 'b', 'mode': 'keyword_only', 'schema': {'type': 'str'}}, - {'name': 'c', 'mode': 'keyword_only', 'schema': {'type': 'int'}}, - ], - } + 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()}, + {'name': 'a', 'mode': 'positional_or_keyword', 'schema': core_schema.bool_schema()}, + {'name': 'b', 'mode': 'keyword_only', 'schema': core_schema.str_schema()}, + {'name': 'c', 'mode': 'keyword_only', 'schema': core_schema.int_schema()}, + ] + ) ) assert v.validate_python(ArgsKwargs((1, 'a', 'true'), {'b': 'bb', 'c': 3})) == ((1, 'a', True), {'b': 'bb', 'c': 3}) @@ -930,15 +937,13 @@ def test_arguments(benchmark): @pytest.mark.benchmark(group='defaults') def test_with_default(benchmark): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'name': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'John'}, - } - }, - } + 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') + ) + } + ) ) assert v.validate_python({'name': 'Foo'}) == {'name': 'Foo'} assert v.validate_python({}) == {'name': 'John'} @@ -952,10 +957,9 @@ def t(): @pytest.mark.benchmark(group='chain') def test_chain_list(benchmark): validator = SchemaValidator( - { - 'type': 'chain', - 'steps': [{'type': 'str'}, core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))], - } + schema=core_schema.chain_schema( + steps=[core_schema.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))] + ) ) assert validator.validate_python('42.42') == Decimal('42.42') @@ -965,9 +969,9 @@ def test_chain_list(benchmark): @pytest.mark.benchmark(group='chain') def test_chain_function(benchmark): validator = SchemaValidator( - { + schema={ 'type': 'function-after', - 'schema': {'type': 'str'}, + 'schema': core_schema.str_schema(), 'function': {'type': 'with-info', 'function': lambda v, info: Decimal(v)}, } ) @@ -979,14 +983,13 @@ def test_chain_function(benchmark): @pytest.mark.benchmark(group='chain-functions') def test_chain_two_functions(benchmark): validator = SchemaValidator( - { - 'type': 'chain', - 'steps': [ - {'type': 'str'}, + schema=core_schema.chain_schema( + steps=[ + core_schema.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v)), core_schema.with_info_plain_validator_function(lambda v, info: v * 2), - ], - } + ] + ) ) assert validator.validate_python('42.42') == Decimal('84.84') @@ -996,11 +999,11 @@ 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', - 'schema': {'type': 'str'}, + 'schema': core_schema.str_schema(), 'function': {'type': 'with-info', 'function': lambda v, info: Decimal(v)}, }, 'function': {'type': 'with-info', 'function': lambda v, info: v * 2}, @@ -1027,7 +1030,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) + v = SchemaValidator(schema=schema) input_value = tuple(range(100)) assert sum(v.validate_python(input_value)) == 4950 @@ -1046,7 +1049,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) + v = SchemaValidator(schema=schema) input_value = tuple(range(100)) assert sum(v.validate_python(input_value)) == 4950 @@ -1056,7 +1059,9 @@ def test_generator_rust(benchmark): @pytest.mark.benchmark(group='isinstance-json') def test_isinstance_json(benchmark): - validator = SchemaValidator(core_schema.json_or_python_schema(core_schema.str_schema(), core_schema.int_schema())) + validator = SchemaValidator( + schema=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') @@ -1068,7 +1073,7 @@ def t(): @pytest.mark.benchmark(group='error') def test_int_error(benchmark): - validator = SchemaValidator(core_schema.int_schema()) + validator = SchemaValidator(schema=core_schema.int_schema()) try: validator.validate_python('bar') except ValidationError as e: @@ -1095,7 +1100,7 @@ def t(): @pytest.mark.benchmark(group='definition') def test_definition_in_tree(benchmark): - validator = SchemaValidator(core_schema.list_schema(core_schema.int_schema())) + validator = SchemaValidator(schema=core_schema.list_schema(core_schema.int_schema())) values = [1, 2, 3.0, '4', '5', '6'] * 1000 benchmark(validator.validate_python, values) @@ -1103,7 +1108,7 @@ def test_definition_in_tree(benchmark): @pytest.mark.benchmark(group='definition') def test_definition_out_of_tree(benchmark): validator = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.list_schema(core_schema.definition_reference_schema('foobar')), [core_schema.int_schema(ref='foobar')], ) @@ -1123,7 +1128,7 @@ def __init__(self, **d): self.__pydantic_fields_set__ = set(d) validator = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1164,7 +1169,7 @@ class MyModel(BaseModel): pass validator = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1223,7 +1228,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(core_schema.literal_schema(expected=allowed_values)) + validator = SchemaValidator(schema=core_schema.literal_schema(expected=allowed_values)) if py_or_json == 'python': res = validator.validate_python(input) @@ -1245,7 +1250,7 @@ class MyModel: root: list[int] v = SchemaValidator( - core_schema.model_schema(MyModel, core_schema.list_schema(core_schema.int_schema()), root_model=True) + schema=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)) @@ -1254,14 +1259,14 @@ class MyModel: @pytest.mark.benchmark(group='strict_int') def test_strict_int(benchmark): - v = SchemaValidator(core_schema.int_schema(strict=True)) + v = SchemaValidator(schema=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(core_schema.int_schema(strict=True)) + v = SchemaValidator(schema=core_schema.int_schema(strict=True)) @benchmark def t(): @@ -1273,7 +1278,7 @@ def t(): @pytest.mark.benchmark(group='int_range') def test_int_range(benchmark): - v = SchemaValidator(core_schema.int_schema(gt=0, lt=100)) + v = SchemaValidator(schema=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'): @@ -1284,7 +1289,7 @@ def test_int_range(benchmark): @pytest.mark.benchmark(group='int_range') def test_int_range_json(benchmark): - v = SchemaValidator(core_schema.int_schema(gt=0, lt=100)) + v = SchemaValidator(schema=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'): @@ -1301,7 +1306,9 @@ def test_tagged_union_int_keys_python(benchmark): 'y': core_schema.typed_dict_field(core_schema.int_schema()), } ) - v = SchemaValidator(core_schema.tagged_union_schema({x: inner_schema for x in range(1000)}, discriminator='x')) + v = SchemaValidator( + schema=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} @@ -1321,7 +1328,9 @@ def test_tagged_union_int_keys_json(benchmark): 'y': core_schema.typed_dict_field(core_schema.int_schema()), } ) - v = SchemaValidator(core_schema.tagged_union_schema({x: inner_schema for x in range(1000)}, discriminator='x')) + v = SchemaValidator( + schema=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} @@ -1349,7 +1358,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) + v = SchemaValidator(schema=schema) payload = {'x': 0} assert v.validate_python(payload) == {'x': limit} @@ -1359,7 +1368,7 @@ def f(v: int, info: core_schema.ValidationInfo) -> int: class TestBenchmarkDecimal: @pytest.fixture(scope='class') def validator(self): - return SchemaValidator({'type': 'decimal'}) + return SchemaValidator(schema=core_schema.decimal_schema()) @pytest.fixture(scope='class') def pydantic_validator(self): @@ -1399,7 +1408,7 @@ def check_finite(value: decimal.Decimal) -> decimal.Decimal: schema = core_schema.no_info_after_validator_function(check_finite, schema) - return SchemaValidator(schema) + return SchemaValidator(schema=schema) @pytest.mark.benchmark(group='decimal from str') def test_decimal_from_string_core(self, benchmark, validator): @@ -1428,7 +1437,7 @@ def to_enum(input_value: Any, /) -> Enum: except ValueError: raise PydanticCustomError('enum', 'Input should be {expected}', {'expected': '1, 2 or 3'}) - v = SchemaValidator(core_schema.no_info_after_validator_function(to_enum, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.no_info_after_validator_function(to_enum, core_schema.int_schema())) assert v.validate_python(1) is FooInt.a @@ -1437,7 +1446,7 @@ def to_enum(input_value: Any, /) -> Enum: @pytest.mark.benchmark(group='enum int') def test_enum_int_core(benchmark): - v = SchemaValidator(core_schema.enum_schema(FooInt, list(FooInt.__members__.values()), sub_type='int')) + v = SchemaValidator(schema=core_schema.enum_schema(FooInt, list(FooInt.__members__.values()), sub_type='int')) assert v.validate_python(1) is FooInt.a @@ -1458,7 +1467,7 @@ def to_enum(input_value: Any, /) -> Enum: except ValueError: raise PydanticCustomError('enum', 'Input should be {expected}', {'expected': 'apple, banana or carrot'}) - v = SchemaValidator(core_schema.no_info_after_validator_function(to_enum, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.no_info_after_validator_function(to_enum, core_schema.str_schema())) assert v.validate_python('apple') is FooStr.a @@ -1467,7 +1476,7 @@ def to_enum(input_value: Any, /) -> Enum: @pytest.mark.benchmark(group='enum str') def test_enum_str_core(benchmark): - v = SchemaValidator(core_schema.enum_schema(FooStr, list(FooStr.__members__.values()), sub_type='str')) + v = SchemaValidator(schema=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 344e0ff02..8db8cda63 100644 --- a/tests/serializers/test_any.py +++ b/tests/serializers/test_any.py @@ -15,7 +15,13 @@ from dirty_equals import HasRepr, IsList import pydantic_core -from pydantic_core import PydanticSerializationError, SchemaSerializer, SchemaValidator, core_schema, to_json +from pydantic_core import ( + PydanticSerializationError, + SchemaSerializer, + SchemaValidator, + core_schema, + to_json, +) from ..conftest import plain_repr from .test_dataclasses import IsStrictDict, on_pypy @@ -491,7 +497,7 @@ class Foo: ), ['a'], ) - Foo.__pydantic_validator__ = SchemaValidator(schema) + Foo.__pydantic_validator__ = SchemaValidator(schema=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 d7fbcffaf..5365202cb 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) + v = SchemaValidator(schema=schema) m = v.validate_python({'extra': 'extra'}) diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py index b4bf1208b..5e8443805 100644 --- a/tests/serializers/test_list_tuple.py +++ b/tests/serializers/test_list_tuple.py @@ -4,7 +4,13 @@ import pytest -from pydantic_core import PydanticSerializationError, SchemaError, SchemaSerializer, core_schema, validate_core_schema +from pydantic_core import ( + PydanticSerializationError, + SchemaError, + SchemaSerializer, + core_schema, + validate_core_schema, +) def test_list_any(): diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py index cb0298622..503d9520e 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) + v = SchemaValidator(schema=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(model_schema) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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 13877d096..fe9d558bf 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(Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(schema=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(Other.__pydantic_core_schema__) + Other.__pydantic_validator__ = SchemaValidator(schema=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 1d1be238b..6fdc7eb31 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(Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(schema=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(Child.__pydantic_core_schema__) + Child.__pydantic_validator__ = SchemaValidator(schema=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(Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(schema=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(Child.__pydantic_core_schema__) + Child.__pydantic_validator__ = SchemaValidator(schema=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(Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(schema=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(Child.__pydantic_core_schema__) + Child.__pydantic_validator__ = SchemaValidator(schema=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(Parent.__pydantic_core_schema__) + Parent.__pydantic_validator__ = SchemaValidator(schema=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(Other.__pydantic_core_schema__) + Other.__pydantic_validator__ = SchemaValidator(schema=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_simple.py b/tests/serializers/test_simple.py index 19b3b4f55..303c23463 100644 --- a/tests/serializers/test_simple.py +++ b/tests/serializers/test_simple.py @@ -3,7 +3,7 @@ import pytest -from pydantic_core import SchemaSerializer, core_schema +from pydantic_core import CoreConfig, SchemaSerializer, core_schema try: import numpy @@ -149,15 +149,15 @@ def test_numpy(): (float('-inf'), 'null', {}), (float('nan'), 'null', {}), # explicit values of ser_json_inf_nan - (float('inf'), 'null', {'ser_json_inf_nan': 'null'}), - (float('-inf'), 'null', {'ser_json_inf_nan': 'null'}), - (float('nan'), 'null', {'ser_json_inf_nan': 'null'}), - (float('inf'), 'Infinity', {'ser_json_inf_nan': 'constants'}), - (float('-inf'), '-Infinity', {'ser_json_inf_nan': 'constants'}), - (float('nan'), 'NaN', {'ser_json_inf_nan': 'constants'}), - (float('inf'), '"Infinity"', {'ser_json_inf_nan': 'strings'}), - (float('-inf'), '"-Infinity"', {'ser_json_inf_nan': 'strings'}), - (float('nan'), '"NaN"', {'ser_json_inf_nan': 'strings'}), + (float('inf'), 'null', CoreConfig(ser_json_inf_nan='null')), + (float('-inf'), 'null', CoreConfig(ser_json_inf_nan='null')), + (float('nan'), 'null', CoreConfig(ser_json_inf_nan='null')), + (float('inf'), 'Infinity', CoreConfig(ser_json_inf_nan='constants')), + (float('-inf'), '-Infinity', CoreConfig(ser_json_inf_nan='constants')), + (float('nan'), 'NaN', CoreConfig(ser_json_inf_nan='constants')), + (float('inf'), '"Infinity"', CoreConfig(ser_json_inf_nan='strings')), + (float('-inf'), '"-Infinity"', CoreConfig(ser_json_inf_nan='strings')), + (float('nan'), '"NaN"', CoreConfig(ser_json_inf_nan='strings')), ], ) def test_float_inf_and_nan_serializers(value, expected_json, config): diff --git a/tests/serializers/test_url.py b/tests/serializers/test_url.py index be906c75b..385fa9a8e 100644 --- a/tests/serializers/test_url.py +++ b/tests/serializers/test_url.py @@ -6,7 +6,7 @@ def test_url(): - v = SchemaValidator(core_schema.url_schema()) + v = SchemaValidator(schema=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(core_schema.multi_host_url_schema()) + v = SchemaValidator(schema=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(core_schema.url_schema()) + v = SchemaValidator(schema=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(core_schema.multi_host_url_schema()) + v = SchemaValidator(schema=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 b81179de1..f177cd0ea 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({'type': 'bool'}) + v = SchemaValidator(schema=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({'type': 'bool'}) + v1 = SchemaValidator(schema=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) + v = SchemaValidator(schema=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({'type': 'tagged-union', 'choices': {'int': {'type': 'int'}}, 'discriminator': 'self-schema'}) + v = SchemaValidator(schema=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(s) + SchemaValidator(schema=s) diff --git a/tests/test_config.py b/tests/test_config.py index 8f552c20b..47027ad35 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -5,12 +5,13 @@ from dirty_equals import FunctionCheck, HasAttributes, IsInstance from pydantic_core import CoreConfig, SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from .conftest import Err, plain_repr def test_on_field(): - v = SchemaValidator({'type': 'str', 'min_length': 2, 'max_length': 5}) + v = SchemaValidator(schema=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 @@ -19,14 +20,14 @@ def test_on_field(): def test_on_config(): - v = SchemaValidator({'type': 'str'}, {'str_max_length': 5}) + v = SchemaValidator(schema=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({'type': 'str', 'max_length': 5}, {'str_max_length': 10}) + v = SchemaValidator(schema=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 @@ -39,12 +40,11 @@ class MyModel: def test_on_model_class(): v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'config': {'str_max_length': 5}, - 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}}, - } + 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())}), + ) ) assert 'max_length:Some(5)' in plain_repr(v) assert v.isinstance_python({'f': 'test'}) is True @@ -53,15 +53,11 @@ def test_on_model_class(): def test_field_priority_model(): v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'config': {'str_max_length': 10}, - 'schema': { - 'type': 'model-fields', - 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str', 'max_length': 5}}}, - }, - } + 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))}), + ) ) assert 'max_length:Some(5)' in plain_repr(v) assert v.isinstance_python({'f': 'test'}) is True @@ -71,29 +67,34 @@ def test_field_priority_model(): @pytest.mark.parametrize( 'config,float_field_schema,input_value,expected', [ - ({}, {'type': 'float'}, {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan))), ( - {'allow_inf_nan': True}, - {'type': 'float'}, + CoreConfig(), + cs.float_schema(), {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), ), ( - {'allow_inf_nan': False}, - {'type': 'float'}, + CoreConfig(allow_inf_nan=True), + cs.float_schema(), + {'x': 'nan'}, + IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), + ), + ( + CoreConfig(allow_inf_nan=False), + cs.float_schema(), {'x': 'nan'}, Err('Input should be a finite number [type=finite_number,'), ), # field `allow_inf_nan` (if set) should have priority over global config ( - {'allow_inf_nan': True}, - {'type': 'float', 'allow_inf_nan': False}, + CoreConfig(allow_inf_nan=True), + cs.float_schema(allow_inf_nan=False), {'x': 'nan'}, Err('Input should be a finite number [type=finite_number,'), ), ( - {'allow_inf_nan': False}, - {'type': 'float', 'allow_inf_nan': True}, + CoreConfig(allow_inf_nan=False), + cs.float_schema(allow_inf_nan=True), {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), ), @@ -102,12 +103,11 @@ def test_field_priority_model(): ) def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expected): v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': {'type': 'model-fields', 'fields': {'x': {'type': 'model-field', 'schema': float_field_schema}}}, - 'config': config, - } + schema=cs.model_schema( + cls=MyModel, + schema=cs.model_fields_schema(fields={'x': cs.model_field(schema=float_field_schema)}), + config=config, + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -120,19 +120,17 @@ def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expe @pytest.mark.parametrize( 'config,input_str', ( - ({}, 'type=string_type, input_value=123, input_type=int'), - ({'hide_input_in_errors': False}, 'type=string_type, input_value=123, input_type=int'), - ({'hide_input_in_errors': True}, 'type=string_type'), + (CoreConfig(), 'type=string_type, input_value=123, input_type=int'), + (CoreConfig(hide_input_in_errors=False), 'type=string_type, input_value=123, input_type=int'), + (CoreConfig(hide_input_in_errors=True), 'type=string_type'), ), ) def test_hide_input_in_errors(config, input_str): v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}}, - }, - config, + schema=cs.model_schema( + cls=MyModel, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())}) + ), + config=config, ) with pytest.raises(ValidationError, match=re.escape(f'Input should be a valid string [{input_str}]')): @@ -140,14 +138,14 @@ def test_hide_input_in_errors(config, input_str): def test_cache_strings(): - v = SchemaValidator({'type': 'str'}) + v = SchemaValidator(schema=cs.str_schema()) assert 'cache_strings=True' in plain_repr(v) - v = SchemaValidator({'type': 'str'}, {'cache_strings': True}) + v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=True)) assert 'cache_strings=True' in plain_repr(v) - v = SchemaValidator({'type': 'str'}, {'cache_strings': False}) + v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings=False)) assert 'cache_strings=False' in plain_repr(v) - v = SchemaValidator({'type': 'str'}, {'cache_strings': 'keys'}) + v = SchemaValidator(schema=cs.str_schema(), config=CoreConfig(cache_strings='keys')) assert "cache_strings='keys'" in plain_repr(v) diff --git a/tests/test_config_updated.py b/tests/test_config_updated.py deleted file mode 100644 index b8c8b6d3f..000000000 --- a/tests/test_config_updated.py +++ /dev/null @@ -1,123 +0,0 @@ -from pydantic_core import core_schema as cs -import math -import re - -import pytest -from dirty_equals import FunctionCheck, HasAttributes, IsInstance - -from pydantic_core import CoreConfig, SchemaValidator, ValidationError - -from .conftest import Err, plain_repr - - -def test_on_field(): - v = SchemaValidator(schema=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 - assert v.isinstance_python('test') is True - assert v.isinstance_python('test long') is False - - -def test_on_config(): - v = SchemaValidator(schema=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)) - assert 'max_length:Some(5)' in plain_repr(v) - assert v.isinstance_python('test') is True - assert v.isinstance_python('test long') is False - - -class MyModel: - # this is not required, but it avoids `__pydantic_fields_set__` being included in `__dict__` - __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' - - -def test_on_model_class(): - v = SchemaValidator(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())}))) - assert 'max_length:Some(5)' in plain_repr(v) - assert v.isinstance_python({'f': 'test'}) is True - assert v.isinstance_python({'f': 'test long'}) is False - - -def test_field_priority_model(): - v = SchemaValidator(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))}))) - assert 'max_length:Some(5)' in plain_repr(v) - assert v.isinstance_python({'f': 'test'}) is True - assert v.isinstance_python({'f': 'test long'}) is False - - -@pytest.mark.parametrize( - 'config,float_field_schema,input_value,expected', - [ - (CoreConfig(), cs.float_schema(), {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan))), - ( - CoreConfig(allow_inf_nan=True), - cs.float_schema(), - {'x': 'nan'}, - IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), - ), - ( - CoreConfig(allow_inf_nan=False), - cs.float_schema(), - {'x': 'nan'}, - Err('Input should be a finite number [type=finite_number,'), - ), - # field `allow_inf_nan` (if set) should have priority over global config - ( - CoreConfig(allow_inf_nan=True), - cs.float_schema(allow_inf_nan=False), - {'x': 'nan'}, - Err('Input should be a finite number [type=finite_number,'), - ), - ( - CoreConfig(allow_inf_nan=False), - cs.float_schema(allow_inf_nan=True), - {'x': 'nan'}, - IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)), - ), - ], - ids=repr, -) -def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expected): - v = SchemaValidator(schema=cs.model_schema(cls=MyModel, schema=cs.model_fields_schema(fields={'x': cs.model_field(schema=float_field_schema)}), config=config)) - if isinstance(expected, Err): - with pytest.raises(ValidationError, match=re.escape(expected.message)): - v.validate_python(input_value) - else: - output_dict = v.validate_python(input_value) - assert output_dict == expected - - -@pytest.mark.parametrize( - 'config,input_str', - ( - (CoreConfig(), 'type=string_type, input_value=123, input_type=int'), - (CoreConfig(hide_input_in_errors=False), 'type=string_type, input_value=123, input_type=int'), - (CoreConfig(hide_input_in_errors=True), 'type=string_type'), - ), -) -def test_hide_input_in_errors(config, input_str): - v = SchemaValidator(schema=cs.model_schema(cls=MyModel, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())})), config=config) - - with pytest.raises(ValidationError, match=re.escape(f'Input should be a valid string [{input_str}]')): - assert v.validate_python({'f': 123}) - - -def test_cache_strings(): - v = SchemaValidator(schema=cs.str_schema()) - assert 'cache_strings=True' in plain_repr(v) - - v = SchemaValidator(schema=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)) - assert 'cache_strings=False' in plain_repr(v) - - v = SchemaValidator(schema=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 550f94e3d..a16af954d 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(core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(schema=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(core_schema.with_info_plain_validator_function(my_function)) + v = SchemaValidator(schema=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(core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(schema=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(core_schema.with_info_plain_validator_function(c.validate, metadata={'instance': c})) + v = SchemaValidator(schema=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,7 +140,9 @@ def validate(self, input_value, info): c = CustomValidator() v = SchemaValidator( - core_schema.with_info_after_validator_function(c.validate, core_schema.str_schema(), metadata={'instance': c}) + schema=core_schema.with_info_after_validator_function( + c.validate, core_schema.str_schema(), metadata={'instance': c} + ) ) c.foo += 1 @@ -171,7 +173,7 @@ def test_pydantic_error_type_raise_no_ctx(): def f(input_value, info): raise PydanticKnownError('finite_number') - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(4) @@ -190,7 +192,7 @@ def test_pydantic_error_type_raise_ctx(extra: dict): def f(input_value, info): raise PydanticKnownError('greater_than', ctx) - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(4) @@ -205,7 +207,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(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) expect_ctx = {'ctx': {}} if ctx is not None else {} @@ -226,7 +228,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(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(4) @@ -241,7 +243,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(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) expect_ctx = {'ctx': {}} if ctx is not None else {} @@ -539,7 +541,7 @@ def test_all_errors(): @pytest.mark.skipif(sys.version_info < (3, 11), reason='This is the modern version used post 3.10.') def test_validation_error_cause_contents(): - enabled_config: CoreConfig = {'validation_error_cause': True} + enabled_config: CoreConfig = CoreConfig(validation_error_cause=True) def multi_raise_py_error(v: Any) -> Any: try: @@ -547,7 +549,9 @@ def multi_raise_py_error(v: Any) -> Any: except AssertionError as e: raise ValueError('Oh no!') from e - s2 = SchemaValidator(core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config) + s2 = SchemaValidator( + schema=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') @@ -573,7 +577,9 @@ def outer_raise_py_error(v: Any) -> Any: except ValidationError as e: raise ValueError('Sub val failure') from e - s3 = SchemaValidator(core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config) + s3 = SchemaValidator( + schema=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') @@ -605,7 +611,7 @@ def outer_raise_py_error(v: Any) -> Any: def test_validation_error_cause_contents_legacy(): from exceptiongroup import BaseExceptionGroup - enabled_config: CoreConfig = {'validation_error_cause': True} + enabled_config: CoreConfig = CoreConfig(validation_error_cause=True) def multi_raise_py_error(v: Any) -> Any: try: @@ -613,7 +619,9 @@ def multi_raise_py_error(v: Any) -> Any: except AssertionError as e: raise ValueError('Oh no!') from e - s2 = SchemaValidator(core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config) + s2 = SchemaValidator( + schema=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') @@ -641,7 +649,9 @@ def outer_raise_py_error(v: Any) -> Any: except ValidationError as e: raise ValueError('Sub val failure') from e - s3 = SchemaValidator(core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config) + s3 = SchemaValidator( + schema=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') @@ -683,10 +693,10 @@ class CauseResult(enum.Enum): [ # Without the backport should still work after 3.10 as not needed: ( 'Enabled', - {'validation_error_cause': True}, + CoreConfig(validation_error_cause=True), CauseResult.CAUSE if sys.version_info >= (3, 11) else CauseResult.IMPORT_ERROR, ), - ('Disabled specifically', {'validation_error_cause': False}, CauseResult.NO_CAUSE), + ('Disabled specifically', CoreConfig(validation_error_cause=False), CauseResult.NO_CAUSE), ('Disabled implicitly', {}, CauseResult.NO_CAUSE), ], ) @@ -697,7 +707,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(core_schema.no_info_plain_validator_function(singular_raise_py_error), config=config) + s = SchemaValidator(schema=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: @@ -721,12 +731,14 @@ def singular_raise_py_error(v: Any) -> Any: def test_validation_error_cause_traceback_preserved(): """Makes sure historic bug of traceback being lost is fixed.""" - enabled_config: CoreConfig = {'validation_error_cause': True} + enabled_config: CoreConfig = CoreConfig(validation_error_cause=True) def singular_raise_py_error(v: Any) -> Any: raise ValueError('Oh no!') - s1 = SchemaValidator(core_schema.no_info_plain_validator_function(singular_raise_py_error), config=enabled_config) + s1 = SchemaValidator( + schema=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') @@ -749,7 +761,7 @@ def __repr__(self): def test_error_on_repr(pydantic_version): - s = SchemaValidator({'type': 'int'}) + s = SchemaValidator(schema=core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python(BadRepr()) @@ -775,7 +787,7 @@ def test_error_on_repr(pydantic_version): def test_error_json(pydantic_version): - s = SchemaValidator({'type': 'str', 'min_length': 3}) + s = SchemaValidator(schema=core_schema.str_schema(min_length=3)) with pytest.raises(ValidationError) as exc_info: s.validate_python('12') @@ -815,7 +827,7 @@ def raise_py_error(v: Any) -> Any: except AssertionError as e: raise ValueError('Oh no!') from e - s = SchemaValidator(core_schema.no_info_plain_validator_function(raise_py_error)) + s = SchemaValidator(schema=core_schema.no_info_plain_validator_function(raise_py_error)) with pytest.raises(ValidationError) as exc_info: s.validate_python('anything') @@ -853,7 +865,7 @@ def raise_py_error(v: Any) -> Any: def test_error_json_cycle(): - s = SchemaValidator({'type': 'str', 'min_length': 3}) + s = SchemaValidator(schema=core_schema.str_schema(min_length=3)) cycle = [] cycle.append(cycle) msg = '[type=string_type, input_value=[[...]], input_type=list]' @@ -875,7 +887,7 @@ def __str__(self): def test_error_json_unknown(): - s = SchemaValidator({'type': 'str'}) + s = SchemaValidator(schema=core_schema.str_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python(Foobar()) @@ -909,7 +921,7 @@ def test_error_json_unknown(): def test_error_json_loc(): s = SchemaValidator( - core_schema.dict_schema(core_schema.str_schema(), core_schema.list_schema(core_schema.int_schema())) + 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']}) @@ -1057,7 +1069,7 @@ def test_raise_validation_error_custom_class_ctx(): def test_loc_with_dots(pydantic_version): v = SchemaValidator( - core_schema.typed_dict_schema( + 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()]), @@ -1089,7 +1101,7 @@ def test_loc_with_dots(pydantic_version): def test_hide_input_in_error() -> None: - s = SchemaValidator({'type': 'int'}) + s = SchemaValidator(schema=core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python('definitely not an int') @@ -1098,7 +1110,7 @@ def test_hide_input_in_error() -> None: def test_hide_input_in_json() -> None: - s = SchemaValidator({'type': 'int'}) + s = SchemaValidator(schema=core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python('definitely not an int') @@ -1111,7 +1123,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({'type': 'int'}) + s = SchemaValidator(schema=core_schema.int_schema()) with pytest.raises(ValidationError) as exc_info: s.validate_python('definitely not an int') @@ -1122,7 +1134,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({'type': 'int'}) + s = SchemaValidator(schema=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) @@ -1149,7 +1161,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; pydantic_core.SchemaValidator({'type': 'int'}).validate_python('ooo')" + code = "import pydantic_core; from pydantic_core import core_schema; pydantic_core.SchemaValidator(schema=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 512e480c5..f89ab8e30 100644 --- a/tests/test_garbage_collection.py +++ b/tests/test_garbage_collection.py @@ -57,7 +57,7 @@ class BaseModel: def __init_subclass__(cls) -> None: cls.__validator__ = SchemaValidator( - core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), + schema=core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config=core_schema.CoreConfig(extra_fields_behavior='allow'), ) @@ -84,12 +84,12 @@ class MyModel: iter: Iterable[int] v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( {'iter': core_schema.model_field(core_schema.generator_schema(core_schema.int_schema()))} ), - ), + ) ) class MyIterable: diff --git a/tests/test_hypothesis.py b/tests/test_hypothesis.py index 51674f620..75b275c35 100644 --- a/tests/test_hypothesis.py +++ b/tests/test_hypothesis.py @@ -15,7 +15,7 @@ @pytest.fixture(scope='module') def datetime_schema(): - return SchemaValidator({'type': 'datetime'}) + return SchemaValidator(schema=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( - cs.definitions_schema( + 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({'type': 'timedelta', 'gt': dt}) + v = SchemaValidator(schema=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({'type': 'url'}) + return SchemaValidator(schema=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({'type': 'multi-host-url'}) + return SchemaValidator(schema=cs.multi_host_url_schema()) @given(strategies.text()) diff --git a/tests/test_isinstance.py b/tests/test_isinstance.py index 38b6f0160..d4f4320a6 100644 --- a/tests/test_isinstance.py +++ b/tests/test_isinstance.py @@ -1,12 +1,13 @@ import pytest from pydantic_core import PydanticOmit, SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from .conftest import PyAndJson def test_isinstance(): - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) assert v.validate_python(123) == 123 assert v.isinstance_python(123) is True assert v.validate_python('123') == 123 @@ -19,7 +20,7 @@ def test_isinstance(): def test_isinstance_strict(): - v = SchemaValidator({'type': 'int', 'strict': True}) + v = SchemaValidator(schema=cs.int_schema(strict=True)) assert v.validate_python(123) == 123 assert v.isinstance_python(123) is True @@ -31,11 +32,9 @@ def test_isinstance_strict(): def test_internal_error(): v = SchemaValidator( - { - 'type': 'model', - 'cls': int, - 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': '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 dfa3597e1..aa0c18acc 100644 --- a/tests/test_json.py +++ b/tests/test_json.py @@ -7,6 +7,7 @@ import pydantic_core from pydantic_core import ( + CoreConfig, PydanticSerializationError, SchemaSerializer, SchemaValidator, @@ -25,28 +26,28 @@ [('false', False), ('true', True), ('0', False), ('1', True), ('"yes"', True), ('"no"', False)], ) def test_bool(input_value, output_value): - v = SchemaValidator({'type': 'bool'}) + v = SchemaValidator(schema=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({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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({'type': 'none'}).validate_json('null') is None + assert SchemaValidator(schema=core_schema.none_schema()).validate_json('null') is None def test_str(): - s = SchemaValidator({'type': 'str'}) + s = SchemaValidator(schema=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') @@ -55,7 +56,7 @@ def test_str(): def test_bytes(): - s = SchemaValidator({'type': 'bytes'}) + s = SchemaValidator(schema=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') @@ -81,7 +82,7 @@ def test_bytes(): ], ) def test_int(input_value, expected): - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=core_schema.int_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value) @@ -102,7 +103,7 @@ def test_int(input_value, expected): ], ) def test_float(input_value, expected): - v = SchemaValidator({'type': 'float'}) + v = SchemaValidator(schema=core_schema.float_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_json(input_value) @@ -112,13 +113,12 @@ def test_float(input_value, expected): def test_typed_dict(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) # language=json @@ -131,20 +131,21 @@ def test_typed_dict(): def test_float_no_remainder(): - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=core_schema.int_schema()) assert v.validate_json('123.0') == 123 def test_error_loc(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}} + 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()) + ) }, - 'extras_schema': {'type': 'int'}, - 'extra_behavior': 'allow', - } + extras_schema=core_schema.int_schema(), + extra_behavior='allow', + ) ) # assert v.validate_json('{"field_a": [1, 2, "3"]}') == ({'field_a': [1, 2, 3]}, {'field_a'}) @@ -162,7 +163,9 @@ def test_error_loc(): def test_dict(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator( + 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} # duplicate keys, the last value wins, like with python @@ -171,12 +174,12 @@ def test_dict(): def test_dict_any_value(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}}) + v = SchemaValidator(schema=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({'type': 'bool'}) + v = SchemaValidator(schema=core_schema.bool_schema()) with pytest.raises(ValidationError) as exc_info: v.validate_json('"foobar') @@ -272,7 +275,7 @@ def __init__(self, my_foo: int, my_inners: list['Foobar']): ) ], ) - v = SchemaValidator(c) + v = SchemaValidator(schema=c) s = SchemaSerializer(c) Foobar.__pydantic_validator__ = v @@ -361,7 +364,7 @@ def test_bad_repr(): def test_inf_nan_allow(): - v = SchemaValidator(core_schema.float_schema(allow_inf_nan=True)) + v = SchemaValidator(schema=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() @@ -383,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({'type': 'bytes'}, {'val_json_bytes': 'base64'}) + v = SchemaValidator(schema=core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64')) assert v.validate_json(encoded_url) == data assert v.validate_json(encoded_std) == data @@ -394,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( - {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'bytes'}}, - {'val_json_bytes': 'base64'}, + 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({'type': 'bytes'}, {'val_json_bytes': 'base64'}) + v = SchemaValidator(schema=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({'type': 'bytes'}, {'val_json_bytes': 'base64'}) + v = SchemaValidator(schema=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)) @@ -426,19 +429,19 @@ def test_json_bytes_hex_round_trip(): encoded = b'"68656c6c6f"' assert to_json(data, bytes_mode='hex') == encoded - v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'hex'}) + v = SchemaValidator(schema=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( - {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'bytes'}}, - {'val_json_bytes': 'hex'}, + 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({'type': 'bytes'}, {'val_json_bytes': 'hex'}) + v = SchemaValidator(schema=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 806c4cca9..30b183e00 100644 --- a/tests/test_misc.py +++ b/tests/test_misc.py @@ -5,7 +5,7 @@ import pytest from typing_extensions import get_args -from pydantic_core import CoreSchema, CoreSchemaType, PydanticUndefined, core_schema +from pydantic_core import CoreConfig, CoreSchema, CoreSchemaType, PydanticUndefined, core_schema from pydantic_core._pydantic_core import ( SchemaError, SchemaValidator, @@ -42,7 +42,7 @@ def test_schema_error(): def test_validation_error(pydantic_version): - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=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({'type': 'list', 'max_length': 2}) + v = SchemaValidator(schema=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({'type': 'int'}, {'title': 'MyInt'}) + v = SchemaValidator(schema=core_schema.int_schema(), config=CoreConfig(title='MyInt')) with pytest.raises(ValidationError) as exc_info: v.validate_python(1.5) @@ -116,17 +116,15 @@ class MyModel: field_b: int v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'x': {'type': 'model-field', 'schema': {'type': 'float'}}, - 'y': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + schema=core_schema.model_schema( + cls=MyModel, + schema=core_schema.model_fields_schema( + fields={ + 'x': core_schema.model_field(schema=core_schema.float_schema()), + 'y': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + ) ) with pytest.raises(ValidationError) as exc_info: v.validate_python({'x': 'x' * 60, 'y': 'y'}) @@ -195,7 +193,7 @@ def test_unicode_error_input_repr() -> None: schema = core_schema.int_schema() - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=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 9cd5aa325..4cf1e8eca 100644 --- a/tests/test_prebuilt.py +++ b/tests/test_prebuilt.py @@ -12,7 +12,7 @@ class InnerModel: ), ) - inner_schema_validator = SchemaValidator(inner_schema) + inner_schema_validator = SchemaValidator(schema=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(outer_schema) + outer_validator = SchemaValidator(schema=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 a15adfca5..cb74775d9 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) + v = SchemaValidator(schema=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(s) + SchemaValidator(schema=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(s) + SchemaValidator(schema=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(core_schema.invalid_schema()) + SchemaValidator(schema=core_schema.invalid_schema()) diff --git a/tests/test_tzinfo.py b/tests/test_tzinfo.py index 4d4279d22..7085d08e4 100644 --- a/tests/test_tzinfo.py +++ b/tests/test_tzinfo.py @@ -219,7 +219,7 @@ class Model: value: datetime v = SchemaValidator( - core_schema.model_schema( + 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 0e0350d0b..d140ddd67 100644 --- a/tests/test_validate_strings.py +++ b/tests/test_validate_strings.py @@ -10,7 +10,7 @@ def test_bool(): - v = SchemaValidator(core_schema.bool_schema()) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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(core_schema.dict_schema(core_schema.int_schema(), core_schema.date_schema())) + v = SchemaValidator(schema=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( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -88,7 +88,7 @@ class MyDataClass: field_b: date v = SchemaValidator( - core_schema.dataclass_schema( + schema=core_schema.dataclass_schema( MyDataClass, core_schema.dataclass_args_schema( 'MyDataClass', @@ -108,7 +108,7 @@ class MyDataClass: def test_typed_dict(): v = SchemaValidator( - core_schema.typed_dict_schema( + 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 5d71f5b55..f1ca1924d 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( - core_schema.model_fields_schema( + 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 6880283a8..c2bc99795 100644 --- a/tests/validators/test_allow_partial.py +++ b/tests/validators/test_allow_partial.py @@ -9,7 +9,7 @@ def test_list(): v = SchemaValidator( - core_schema.list_schema( + 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( - collection_type( + schema=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(core_schema.dict_schema(core_schema.int_schema(), core_schema.int_schema())) + v = SchemaValidator(schema=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( - core_schema.dict_schema(core_schema.int_schema(), core_schema.list_schema(core_schema.int_schema(ge=10))) + schema=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( - core_schema.typed_dict_schema( + 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( - core_schema.typed_dict_schema( + 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( - core_schema.typed_dict_schema( + 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,9 +261,9 @@ def test_double_nested(): def test_tuple_list(): """Tuples don't support partial, so behaviour should be disabled.""" v = SchemaValidator( - core_schema.tuple_positional_schema( + schema=core_schema.tuple_positional_schema( [core_schema.list_schema(core_schema.int_schema()), core_schema.int_schema()] - ), + ) ) assert v.validate_python([['1', '2'], '3'], allow_partial=True) == snapshot(([1, 2], 3)) with pytest.raises(ValidationError, match=r'1\s+Input should be a valid integer'): @@ -284,7 +284,7 @@ def test_dataclass(): ), ], ) - v = SchemaValidator(schema) + v = SchemaValidator(schema=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,7 +294,9 @@ def test_dataclass(): def test_nullable(): - v = SchemaValidator(core_schema.nullable_schema(core_schema.list_schema(core_schema.str_schema(min_length=2)))) + v = SchemaValidator( + schema=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'] @@ -310,7 +312,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(core_schema.list_schema(core_schema.json_schema(json_nested_type))) + v = SchemaValidator(schema=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}]) @@ -325,7 +327,7 @@ def test_json(json_nested_type): def test_json_trailing_strings(): - v = SchemaValidator(core_schema.list_schema(core_schema.json_schema())) + v = SchemaValidator(schema=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 1fb17dcee..9f9b63155 100644 --- a/tests/validators/test_arguments.py +++ b/tests/validators/test_arguments.py @@ -7,6 +7,7 @@ import pytest from pydantic_core import ArgsKwargs, SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, plain_repr @@ -737,17 +738,16 @@ def test_default_factory(py_and_json: PyAndJson, input_value, expected): def test_repr(): v = SchemaValidator( - { - 'type': 'arguments', - 'arguments_schema': [ - {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}, + schema=cs.arguments_schema( + arguments=[ + {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}, { 'name': 'a', 'mode': 'keyword_only', - 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 42}, + 'schema': cs.with_default_schema(schema=cs.int_schema(), default_factory=lambda: 42), }, - ], - } + ] + ) ) assert 'positional_params_count:1,' in plain_repr(v) @@ -755,17 +755,16 @@ def test_repr(): def test_build_non_default_follows(): with pytest.raises(SchemaError, match="Non-default argument 'b' follows default argument"): SchemaValidator( - { - 'type': 'arguments', - 'arguments_schema': [ + schema=cs.arguments_schema( + arguments=[ { 'name': 'a', 'mode': 'positional_or_keyword', - 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 42}, + 'schema': cs.with_default_schema(schema=cs.int_schema(), default_factory=lambda: 42), }, - {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}, - ], - } + {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}, + ] + ) ) @@ -773,13 +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( - { - 'type': 'arguments', - 'arguments_schema': [], - 'var_kwargs_mode': 'unpacked-typed-dict', - } - ) + SchemaValidator(schema=cs.arguments_schema(arguments=[], var_kwargs_mode='unpacked-typed-dict')) @pytest.mark.parametrize( @@ -943,7 +936,7 @@ def decorator(function): assert p.kind == Parameter.VAR_KEYWORD, p.kind schema['var_kwargs_schema'] = arg_schema - validator = SchemaValidator(schema, config=config) + validator = SchemaValidator(schema=schema, config=config) @wraps(function) def wrapper(*args, **kwargs): @@ -1104,27 +1097,21 @@ def foobar(*args, **kwargs): def test_invalid_schema(): with pytest.raises(SchemaError, match="'default' and 'default_factory' cannot be used together"): SchemaValidator( - { - 'type': 'arguments', - 'arguments_schema': [ + schema=cs.arguments_schema( + arguments=[ { 'name': 'a', 'mode': 'positional_or_keyword', - 'schema': { - 'type': 'default', - 'schema': {'type': 'int'}, - 'default': 1, - 'default_factory': lambda: 2, - }, + 'schema': cs.with_default_schema(schema=cs.int_schema(), default=1, default_factory=lambda: 2), } - ], - } + ] + ) ) def test_error_display(pydantic_version): v = SchemaValidator( - core_schema.arguments_schema( + 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 88f30add4..ee0132fb8 100644 --- a/tests/validators/test_bool.py +++ b/tests/validators/test_bool.py @@ -3,6 +3,7 @@ import pytest from pydantic_core import SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, plain_repr @@ -54,7 +55,7 @@ def test_bool_strict(py_and_json: PyAndJson): def test_bool_error(pydantic_version): - v = SchemaValidator({'type': 'bool'}) + v = SchemaValidator(schema=cs.bool_schema()) with pytest.raises(ValidationError) as exc_info: v.validate_python('wrong') @@ -76,12 +77,12 @@ def test_bool_error(pydantic_version): def test_bool_repr(): - v = SchemaValidator({'type': 'bool'}) + v = SchemaValidator(schema=cs.bool_schema()) assert ( plain_repr(v) == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:false}),definitions=[],cache_strings=True)' ) - v = SchemaValidator({'type': 'bool', 'strict': True}) + v = SchemaValidator(schema=cs.bool_schema(strict=True)) assert ( plain_repr(v) == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:true}),definitions=[],cache_strings=True)' @@ -104,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(core_schema.bool_schema()) + v = SchemaValidator(schema=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 8b9e6318b..71bba1348 100644 --- a/tests/validators/test_bytes.py +++ b/tests/validators/test_bytes.py @@ -4,12 +4,13 @@ import pytest from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson def test_strict_bytes_validator(): - v = SchemaValidator({'type': 'bytes', 'strict': True}) + v = SchemaValidator(schema=cs.bytes_schema(strict=True)) assert v.validate_python(b'foo') == b'foo' assert v.validate_json('"foo"') == b'foo' @@ -21,7 +22,7 @@ def test_strict_bytes_validator(): def test_lax_bytes_validator(): - v = SchemaValidator({'type': 'bytes'}) + v = SchemaValidator(schema=cs.bytes_schema()) assert v.validate_python(b'foo') == b'foo' assert v.validate_python('foo') == b'foo' @@ -56,7 +57,7 @@ def test_lax_bytes_validator(): ], ) def test_constrained_bytes_python_bytes(opts: dict[str, Any], input, expected): - v = SchemaValidator({'type': 'bytes', **opts}) + v = SchemaValidator(schema=cs.bytes_schema(**opts)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input) @@ -90,13 +91,13 @@ def test_constrained_bytes(py_and_json: PyAndJson, opts: dict[str, Any], input, def test_union(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'bytes'}], 'strict': True}) + v = SchemaValidator(schema=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({'type': 'bytes', 'min_length': 2, 'max_length': 3}) + v = SchemaValidator(schema=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 55964a754..fadc7bb5e 100644 --- a/tests/validators/test_call.py +++ b/tests/validators/test_call.py @@ -6,6 +6,7 @@ import pytest from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, plain_repr @@ -69,7 +70,7 @@ def my_function(a, b, c): return a + b + c v = SchemaValidator( - {'type': 'call', 'function': my_function, 'arguments_schema': {'type': 'any'}, 'return_schema': {'type': 'int'}} + schema=cs.call_schema(function=my_function, arguments=cs.any_schema(), return_schema=cs.int_schema()) ) if isinstance(expected, Exception): @@ -84,7 +85,7 @@ def test_function_return_any(input_value, expected): def my_function(a): return a - v = SchemaValidator({'type': 'call', 'function': my_function, 'arguments_schema': {'type': 'any'}}) + v = SchemaValidator(schema=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 @@ -95,20 +96,17 @@ def my_function(a): return a v = SchemaValidator( - { - 'type': 'union', - 'choices': [ - { - 'type': 'call', - 'function': my_function, - 'arguments_schema': { - 'type': 'arguments', - 'arguments_schema': [{'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}], - }, - }, - {'type': 'int'}, - ], - } + schema=cs.union_schema( + choices=[ + cs.call_schema( + function=my_function, + arguments=cs.arguments_schema( + arguments=[{'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}] + ), + ), + cs.int_schema(), + ] + ) ) assert v.validate_python((1,)) == 1 with pytest.raises(ValidationError) as exc_info: @@ -131,17 +129,15 @@ class my_dataclass: b: str v = SchemaValidator( - { - 'type': 'call', - 'function': my_dataclass, - 'arguments_schema': { - 'type': 'arguments', - 'arguments_schema': [ - {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}, - {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'str'}}, - ], - }, - } + schema=cs.call_schema( + function=my_dataclass, + arguments=cs.arguments_schema( + arguments=[ + {'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}, + {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.str_schema()}, + ] + ), + ) ) d = v.validate_python(('1', b'2')) assert dataclasses.is_dataclass(d) @@ -158,17 +154,15 @@ def test_named_tuple(): Point = namedtuple('Point', ['x', 'y']) v = SchemaValidator( - { - 'type': 'call', - 'function': Point, - 'arguments_schema': { - 'type': 'arguments', - 'arguments_schema': [ - {'name': 'x', 'mode': 'positional_or_keyword', 'schema': {'type': 'float'}}, - {'name': 'y', 'mode': 'positional_or_keyword', 'schema': {'type': 'float'}}, - ], - }, - } + schema=cs.call_schema( + function=Point, + arguments=cs.arguments_schema( + arguments=[ + {'name': 'x', 'mode': 'positional_or_keyword', 'schema': cs.float_schema()}, + {'name': 'y', 'mode': 'positional_or_keyword', 'schema': cs.float_schema()}, + ] + ), + ) ) d = v.validate_python(('1.1', '2.2')) assert isinstance(d, Point) @@ -186,17 +180,15 @@ def my_function(a, b, c): return a + b + c v = SchemaValidator( - { - 'type': 'call', - 'function': partial(my_function, c=3), - 'arguments_schema': { - 'type': 'arguments', - 'arguments_schema': [ - {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}, - {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}, - ], - }, - } + schema=cs.call_schema( + function=partial(my_function, c=3), + arguments=cs.arguments_schema( + arguments=[ + {'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}, + {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}, + ] + ), + ) ) assert 'name:"call[my_function]"' in plain_repr(v) assert v.validate_python((1, 2)) == 6 @@ -208,15 +200,13 @@ def my_function(a): return a v = SchemaValidator( - { - 'type': 'call', - 'function': my_function, - 'function_name': 'foobar', - 'arguments_schema': { - 'type': 'arguments', - 'arguments_schema': [{'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}], - }, - } + schema=cs.call_schema( + function=my_function, + function_name='foobar', + arguments=cs.arguments_schema( + arguments=[{'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}] + ), + ) ) assert 'name:"call[foobar]"' in plain_repr(v) assert v.validate_python((1,)) == 1 diff --git a/tests/validators/test_callable.py b/tests/validators/test_callable.py index 62765b0ce..209c289b3 100644 --- a/tests/validators/test_callable.py +++ b/tests/validators/test_callable.py @@ -1,6 +1,7 @@ import pytest from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import core_schema as cs def func(): @@ -17,7 +18,7 @@ def __call__(self, *args, **kwargs): def test_callable(): - v = SchemaValidator({'type': 'callable'}) + v = SchemaValidator(schema=cs.callable_schema()) assert v.validate_python(func) == func assert v.isinstance_python(func) is True @@ -47,12 +48,12 @@ def test_callable(): ], ) def test_callable_cases(input_value, expected): - v = SchemaValidator({'type': 'callable'}) + v = SchemaValidator(schema=cs.callable_schema()) assert v.isinstance_python(input_value) == expected def test_repr(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'int'}, {'type': 'callable'}]}) + v = SchemaValidator(schema=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 0ba59084d..f032cfbf3 100644 --- a/tests/validators/test_chain.py +++ b/tests/validators/test_chain.py @@ -3,16 +3,16 @@ import pytest from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import PyAndJson def test_chain(): validator = SchemaValidator( - { - 'type': 'chain', - 'steps': [{'type': 'str'}, core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))], - } + schema=cs.chain_schema( + steps=[cs.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))] + ) ) assert validator.validate_python('1.44') == Decimal('1.44') @@ -21,22 +21,21 @@ def test_chain(): def test_chain_many(): validator = SchemaValidator( - { - 'type': 'chain', - 'steps': [ + 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'), core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-3'), core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-4'), - ], - } + ] + ) ) assert validator.validate_python('input') == 'input-1-2-3-4' def test_chain_error(): - validator = SchemaValidator({'type': 'chain', 'steps': [{'type': 'str'}, {'type': 'int'}]}) + validator = SchemaValidator(schema=cs.chain_schema(steps=[cs.str_schema(), cs.int_schema()])) assert validator.validate_python('123') == 123 assert validator.validate_python(b'123') == 123 @@ -74,13 +73,11 @@ def test_json(py_and_json: PyAndJson, input_value, expected): def test_flatten(): validator = SchemaValidator( - { - 'type': 'chain', - 'steps': [ + schema=cs.chain_schema( + steps=[ core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1'), - { - 'type': 'chain', - 'steps': [ + cs.chain_schema( + steps=[ { 'type': 'function-plain', 'function': {'type': 'with-info', 'function': lambda v, info: f'{v}-2'}, @@ -89,10 +86,10 @@ def test_flatten(): 'type': 'function-plain', 'function': {'type': 'with-info', 'function': lambda v, info: f'{v}-3'}, }, - ], - }, - ], - } + ] + ), + ] + ) ) assert validator.validate_python('input') == 'input-1-2-3' @@ -101,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({'type': 'chain', 'steps': []}) + SchemaValidator(schema=cs.chain_schema(steps=[])) def test_chain_one(): validator = SchemaValidator( - {'type': 'chain', 'steps': [core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1')]} + schema=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 244091265..af653406d 100644 --- a/tests/validators/test_complex.py +++ b/tests/validators/test_complex.py @@ -6,6 +6,7 @@ import pytest from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from ..conftest import Err @@ -45,7 +46,7 @@ ids=repr, ) def test_complex_cases(input_value, expected): - v = SchemaValidator({'type': 'complex'}) + v = SchemaValidator(schema=cs.complex_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -76,7 +77,7 @@ def test_complex_cases(input_value, expected): ids=repr, ) def test_complex_strict(input_value, expected): - v = SchemaValidator({'type': 'complex', 'strict': True}) + v = SchemaValidator(schema=cs.complex_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -89,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({'type': 'complex'}) + v = SchemaValidator(schema=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({'type': 'complex'}) + v = SchemaValidator(schema=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 @@ -105,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({'type': 'complex'}) + v = SchemaValidator(schema=cs.complex_schema()) c = v.validate_python('5e600j') assert math.isinf(c.imag) @@ -115,7 +116,7 @@ def test_overflow_complex(): def test_json_complex(): - v = SchemaValidator({'type': 'complex'}) + v = SchemaValidator(schema=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) @@ -135,7 +136,7 @@ def test_json_complex(): def test_json_complex_strict(): - v = SchemaValidator({'type': 'complex', 'strict': True}) + v = SchemaValidator(schema=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) @@ -149,7 +150,7 @@ def test_json_complex_strict(): def test_string_complex(): - v = SchemaValidator({'type': 'complex'}) + v = SchemaValidator(schema=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_custom_error.py b/tests/validators/test_custom_error.py index f2a6e45b5..ada4aef47 100644 --- a/tests/validators/test_custom_error.py +++ b/tests/validators/test_custom_error.py @@ -40,5 +40,7 @@ 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): SchemaValidator( - core_schema.custom_error_schema(core_schema.int_schema(), 'recursion_loop', custom_error_message='xxx') + schema=core_schema.custom_error_schema( + core_schema.int_schema(), 'recursion_loop', custom_error_message='xxx' + ) ) diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py index 09bd4e762..444059eb2 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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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( - core_schema.dataclass_schema( + 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( - core_schema.dataclass_schema( + 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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=schema) foo = Foo(b'hello', 'True') assert dataclasses.is_dataclass(foo) @@ -707,7 +707,7 @@ class Foo: ), ['a', 'b'], ) - v = SchemaValidator(schema) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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( - core_schema.dataclass_schema( + schema=core_schema.dataclass_schema( MyDataclass, core_schema.dataclass_args_schema( 'MyDataclass', @@ -910,7 +910,7 @@ class MyModel: f: str v = SchemaValidator( - core_schema.dataclass_schema( + 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( - core_schema.dataclass_schema( + schema=core_schema.dataclass_schema( MyModel, core_schema.dataclass_args_schema( 'MyModel', [core_schema.dataclass_field('f', core_schema.str_schema(), frozen=True)] @@ -961,7 +961,7 @@ class MyModel: 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='ignore'), {}), - (core_schema.CoreConfig(extra_fields_behavior='ignore'), {'extra_behavior': None}), + (core_schema.CoreConfig(extra_fields_behavior='ignore'), {}), (core_schema.CoreConfig(), {'extra_behavior': 'ignore'}), (None, {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'ignore'}), @@ -973,7 +973,7 @@ class MyModel: f: str v = SchemaValidator( - core_schema.dataclass_schema( + 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 @@ -1009,7 +1009,7 @@ class MyModel: 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), - (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': None}), + (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), (core_schema.CoreConfig(), {'extra_behavior': 'forbid'}), (None, {'extra_behavior': 'forbid'}), (core_schema.CoreConfig(extra_fields_behavior='ignore'), {'extra_behavior': 'forbid'}), @@ -1021,7 +1021,7 @@ class MyModel: f: str v = SchemaValidator( - core_schema.dataclass_schema( + 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 @@ -1055,7 +1055,7 @@ class MyModel: 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), - (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': None}), + (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), (core_schema.CoreConfig(), {'extra_behavior': 'allow'}), (None, {'extra_behavior': 'allow'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'allow'}), @@ -1067,7 +1067,7 @@ class MyModel: f: str v = SchemaValidator( - core_schema.dataclass_schema( + 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(cs) + v = SchemaValidator(schema=cs) instance: Model = v.validate_python({'number': 1}) assert instance.number == 1 @@ -1142,7 +1142,7 @@ class Model: ['number'], ) - v = SchemaValidator(cs) + v = SchemaValidator(schema=cs) instance: Model = v.validate_python({'number': 1}) assert instance.number == 1 @@ -1177,7 +1177,7 @@ class Model: ['number'], ) - v = SchemaValidator(cs) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + val = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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(dataclass_schema) + Dataclass.__pydantic_validator__ = SchemaValidator(schema=dataclass_schema) return Dataclass @@ -1652,7 +1652,7 @@ def __post_init__(self): post_init=True, ) - v = SchemaValidator(schema) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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 63e87556c..0bbe9a92b 100644 --- a/tests/validators/test_date.py +++ b/tests/validators/test_date.py @@ -8,6 +8,7 @@ import pytest from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson @@ -73,7 +74,7 @@ ], ) def test_date(input_value, expected): - v = SchemaValidator({'type': 'date'}) + v = SchemaValidator(schema=cs.date_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): result = v.validate_python(input_value) @@ -136,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({'type': 'date', 'strict': strict_mode_type.schema}) + v = SchemaValidator(schema=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) @@ -157,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({'type': 'date', 'strict': strict_mode_type.schema}) + v = SchemaValidator(schema=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) @@ -167,7 +168,7 @@ def test_date_strict_json(input_value, expected, strict_mode_type): def test_date_strict_json_ctx(): - v = SchemaValidator({'type': 'date', 'strict': True}) + v = SchemaValidator(schema=cs.date_schema(strict=True)) with pytest.raises(ValidationError) as exc_info: v.validate_json('"foobar"') assert exc_info.value.errors(include_url=False) == [ @@ -204,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({'type': 'date', **kwargs}) # type: ignore + v = SchemaValidator(schema=cs.date_schema(**kwargs)) # type: ignore if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -219,7 +220,7 @@ def test_invalid_constraint(): def test_dict_py(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'date'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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} @@ -229,11 +230,11 @@ def test_dict(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'date'}]}) + v = SchemaValidator(schema=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({'type': 'union', 'choices': [{'type': 'date'}, {'type': 'str'}]}) + v = SchemaValidator(schema=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) @@ -282,13 +283,13 @@ def test_date_future(py_and_json: PyAndJson, input_value, expected): def test_date_past_future_today(): - v = SchemaValidator(core_schema.date_schema(now_op='past', now_utc_offset=0)) + v = SchemaValidator(schema=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(core_schema.date_schema(now_op='future', now_utc_offset=0)) + v = SchemaValidator(schema=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 a48a78a78..adeadffd7 100644 --- a/tests/validators/test_datetime.py +++ b/tests/validators/test_datetime.py @@ -9,6 +9,7 @@ import pytest from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson @@ -58,7 +59,7 @@ ], ) def test_datetime(input_value, expected): - v = SchemaValidator({'type': 'datetime'}) + v = SchemaValidator(schema=cs.datetime_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): result = v.validate_python(input_value) @@ -81,7 +82,7 @@ def test_datetime(input_value, expected): ], ) def test_datetime_strict(input_value, expected): - v = SchemaValidator({'type': 'datetime', 'strict': True}) + v = SchemaValidator(schema=cs.datetime_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -93,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({'type': 'datetime'}) + v = SchemaValidator(schema=cs.datetime_schema()) output = v.validate_python(dt) assert output == dt @@ -106,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({'type': 'datetime', 'gt': datetime(2022, 1, 1)}) + v = SchemaValidator(schema=cs.datetime_schema(gt=datetime(2022, 1, 1))) output = v.validate_python(dt) assert output == dt @@ -166,7 +167,7 @@ def test_datetime_json(py_and_json: PyAndJson, input_value, expected): ], ) def test_datetime_strict_json(input_value, expected): - v = SchemaValidator({'type': 'datetime', 'strict': True}) + v = SchemaValidator(schema=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)) @@ -176,7 +177,7 @@ def test_datetime_strict_json(input_value, expected): def test_custom_timezone_repr(): - output = SchemaValidator({'type': 'datetime'}).validate_python('2022-06-08T12:13:14-12:15') + output = SchemaValidator(schema=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 @@ -186,7 +187,7 @@ def test_custom_timezone_repr(): def test_custom_timezone_utc_repr(): - output = SchemaValidator({'type': 'datetime'}).validate_python('2022-06-08T12:13:14Z') + output = SchemaValidator(schema=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 @@ -200,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({'type': 'datetime', 'le': uk_3pm}).validate_python('2022-01-01T16:00:00+01:00') + v = SchemaValidator(schema=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({'type': 'datetime', 'ge': uk_3pm}).validate_python('2022-01-01T16:00:00+01:00') + v = SchemaValidator(schema=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({'type': 'datetime', 'gt': uk_3pm}).validate_python('2022-01-01T16:00:00+01:00') + SchemaValidator(schema=cs.datetime_schema(gt=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00') def test_tz_info_deepcopy(): - output = SchemaValidator({'type': 'datetime'}).validate_python('2023-02-15T16:23:44.037Z') + output = SchemaValidator(schema=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)' @@ -220,7 +221,7 @@ def test_tz_info_deepcopy(): def test_tz_info_copy(): - output = SchemaValidator({'type': 'datetime'}).validate_python('2023-02-15T16:23:44.037Z') + output = SchemaValidator(schema=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)' @@ -238,7 +239,7 @@ def dst(self, _dt): def tzname(self, _dt): return 'CustomTZ' - schema = SchemaValidator({'type': 'datetime', 'gt': datetime(2022, 1, 1, 15, 0, 0)}) + schema = SchemaValidator(schema=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) @@ -252,7 +253,7 @@ class CustomTz(tzinfo): def tzname(self, _dt): return 'CustomTZ' - schema = SchemaValidator({'type': 'datetime', 'gt': datetime(2022, 1, 1, 15, 0, 0)}) + schema = SchemaValidator(schema=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 @@ -277,7 +278,7 @@ def tzname(self, _dt): def test_dict_py(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'datetime'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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, @@ -293,11 +294,11 @@ def test_dict(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'datetime'}]}) + v = SchemaValidator(schema=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({'type': 'union', 'choices': [{'type': 'datetime'}, {'type': 'str'}]}) + v = SchemaValidator(schema=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) @@ -328,7 +329,7 @@ def test_datetime_past(py_and_json: PyAndJson, input_value, expected): def test_datetime_past_timezone(): - v = SchemaValidator(core_schema.datetime_schema(now_utc_offset=0, now_op='past')) + v = SchemaValidator(schema=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 @@ -371,7 +372,7 @@ def test_datetime_future(py_and_json: PyAndJson, input_value, expected): def test_datetime_future_timezone(): - v = SchemaValidator(core_schema.datetime_schema(now_utc_offset=0, now_op='future')) + v = SchemaValidator(schema=core_schema.datetime_schema(now_utc_offset=0, now_op='future')) now_utc = datetime.now(timezone.utc) soon_utc = now_utc + timedelta(minutes=1) @@ -397,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(core_schema.datetime_schema(now_op='future')) + v = SchemaValidator(schema=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) @@ -419,7 +420,7 @@ def test_raises_schema_error_for_unknown_constraint_kind(): def test_aware(): - v = SchemaValidator(core_schema.datetime_schema(tz_constraint='aware')) + v = SchemaValidator(schema=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) @@ -433,7 +434,7 @@ def test_aware(): def test_naive(): - v = SchemaValidator(core_schema.datetime_schema(tz_constraint='naive')) + v = SchemaValidator(schema=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) @@ -447,7 +448,7 @@ def test_naive(): def test_aware_specific(): - v = SchemaValidator(core_schema.datetime_schema(tz_constraint=0)) + v = SchemaValidator(schema=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) @@ -475,7 +476,7 @@ def test_aware_specific(): def test_neg_7200(): - v = SchemaValidator(core_schema.datetime_schema(tz_constraint=-7200)) + v = SchemaValidator(schema=core_schema.datetime_schema(tz_constraint=-7200)) value = datetime.now(tz=timezone(timedelta(hours=-2))) assert value is v.validate_python(value) @@ -492,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(core_schema.datetime_schema(tz_constraint=2**64)) + SchemaValidator(schema=core_schema.datetime_schema(tz_constraint=2**64)) def test_tz_constraint_wrong(): @@ -501,7 +502,7 @@ def test_tz_constraint_wrong(): def test_tz_hash() -> None: - v = SchemaValidator(core_schema.datetime_schema()) + v = SchemaValidator(schema=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' @@ -516,7 +517,7 @@ def test_tz_hash() -> None: def test_tz_cmp() -> None: - v = SchemaValidator(core_schema.datetime_schema()) + v = SchemaValidator(schema=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 0f165d5a8..129d578b9 100644 --- a/tests/validators/test_decimal.py +++ b/tests/validators/test_decimal.py @@ -10,6 +10,7 @@ from dirty_equals import FunctionCheck, IsStr from pydantic_core import SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, plain_repr @@ -90,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({'type': 'decimal', 'strict': True}) + v = SchemaValidator(schema=cs.decimal_schema(strict=True)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -120,7 +121,7 @@ def test_decimal_strict_py(input_value, expected): ids=repr, ) def test_decimal_strict_json(input_value, expected): - v = SchemaValidator({'type': 'decimal', 'strict': True}) + v = SchemaValidator(schema=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,7 +226,7 @@ def test_decimal_multiple_of(py_and_json: PyAndJson, multiple_of: float, input_v def test_union_decimal_py(): v = SchemaValidator( - {'type': 'union', 'choices': [{'type': 'decimal', 'strict': True}, {'type': 'decimal', 'multiple_of': 7}]} + schema=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 @@ -251,7 +252,7 @@ def test_union_decimal_py(): def test_union_decimal_json(): v = SchemaValidator( - {'type': 'union', 'choices': [{'type': 'decimal', 'strict': True}, {'type': 'decimal', 'multiple_of': 7}]} + schema=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 @@ -275,21 +276,21 @@ def test_union_decimal_simple(py_and_json: PyAndJson): def test_decimal_repr(): - v = SchemaValidator({'type': 'decimal'}) + v = SchemaValidator(schema=cs.decimal_schema()) assert plain_repr(v).startswith( 'SchemaValidator(title="decimal",validator=Decimal(DecimalValidator{strict:false,allow_inf_nan:false' ) - v = SchemaValidator({'type': 'decimal', 'strict': True}) + v = SchemaValidator(schema=cs.decimal_schema(strict=True)) assert plain_repr(v).startswith( 'SchemaValidator(title="decimal",validator=Decimal(DecimalValidator{strict:true,allow_inf_nan:false' ) - v = SchemaValidator({'type': 'decimal', 'multiple_of': 7}) + v = SchemaValidator(schema=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({'type': 'decimal'}) + v = SchemaValidator(schema=cs.decimal_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -383,7 +384,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({'type': 'decimal', 'allow_inf_nan': allow_inf_nan, 'strict': strict}) + v = SchemaValidator(schema=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) @@ -419,7 +420,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({'type': 'decimal', 'allow_inf_nan': allow_inf_nan, 'gt': 0}) + v = SchemaValidator(schema=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) @@ -457,12 +458,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({'type': 'decimal'}) + v = SchemaValidator(schema=cs.decimal_schema()) assert v.validate_json(input_value) == expected def test_validate_max_digits_and_decimal_places() -> None: - v = SchemaValidator({'type': 'decimal', 'max_digits': 5, 'decimal_places': 2}) + v = SchemaValidator(schema=cs.decimal_schema(max_digits=5, decimal_places=2)) # valid inputs assert v.validate_json('1.23') == Decimal('1.23') @@ -481,7 +482,7 @@ def test_validate_max_digits_and_decimal_places() -> None: def test_validate_max_digits_and_decimal_places_edge_case() -> None: - v = SchemaValidator({'type': 'decimal', 'max_digits': 34, 'decimal_places': 18}) + v = SchemaValidator(schema=cs.decimal_schema(max_digits=34, decimal_places=18)) # valid inputs assert v.validate_python(Decimal('9999999999999999.999999999999999999')) == Decimal( @@ -490,20 +491,20 @@ def test_validate_max_digits_and_decimal_places_edge_case() -> None: def test_str_validation_w_strict() -> None: - s = SchemaValidator(core_schema.decimal_schema(strict=True)) + s = SchemaValidator(schema=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(core_schema.decimal_schema(strict=False)) + s = SchemaValidator(schema=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(core_schema.union_schema([core_schema.decimal_schema(), core_schema.str_schema()])) + s = SchemaValidator(schema=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 d4102e95a..55412f401 100644 --- a/tests/validators/test_definitions.py +++ b/tests/validators/test_definitions.py @@ -7,7 +7,7 @@ def test_list_with_def(): v = SchemaValidator( - core_schema.definitions_schema( + 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( - core_schema.definitions_schema( + 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(core_schema.any_schema(metadata={'type': 'definition-ref'})) + v = SchemaValidator(schema=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( - core_schema.list_schema( + 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( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.dict_schema( core_schema.definition_reference_schema('foobar'), core_schema.definition_reference_schema('foobar') ), @@ -76,7 +76,7 @@ def test_dict_repeat(): def test_repeated_ref(): with pytest.raises(SchemaError, match='SchemaError: Duplicate ref: `foobar`'): SchemaValidator( - core_schema.tuple_positional_schema( + schema=core_schema.tuple_positional_schema( [ core_schema.definitions_schema( core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')] @@ -92,7 +92,7 @@ def test_repeated_ref(): def test_repeat_after(): with pytest.raises(SchemaError, match='SchemaError: Duplicate ref: `foobar`'): SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.tuple_positional_schema( [ core_schema.definitions_schema( @@ -108,7 +108,7 @@ def test_repeat_after(): def test_deep(): v = SchemaValidator( - core_schema.typed_dict_schema( + 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( - core_schema.tuple_positional_schema( + schema=core_schema.tuple_positional_schema( [ core_schema.definitions_schema( core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')] @@ -144,17 +144,17 @@ def test_use_after(): def test_definition_chain(): v = SchemaValidator( - core_schema.definitions_schema( + 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')], - ), + ) ) assert v.validate_python('1') == 1 def test_forwards_get_default_value(): v = SchemaValidator( - core_schema.definitions_schema( + 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 e835b9075..46eefe15c 100644 --- a/tests/validators/test_definitions_recursive.py +++ b/tests/validators/test_definitions_recursive.py @@ -7,7 +7,8 @@ from dirty_equals import AnyThing, HasAttributes, IsList, IsPartialDict, IsStr, IsTuple import pydantic_core -from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, plain_repr from .test_typed_dict import Cls @@ -15,7 +16,7 @@ def test_branch_nullable(): v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( {'type': 'definition-ref', 'schema_ref': 'Branch'}, [ { @@ -53,21 +54,20 @@ def test_branch_nullable(): def test_unused_ref(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'ref': 'Branch', - 'fields': { - 'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'other': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, + schema=cs.typed_dict_schema( + fields={ + 'name': cs.typed_dict_field(schema=cs.str_schema()), + 'other': cs.typed_dict_field(schema=cs.int_schema()), }, - } + ref='Branch', + ) ) assert v.validate_python({'name': 'root', 'other': '4'}) == {'name': 'root', 'other': 4} def test_nullable_error(): v = SchemaValidator( - core_schema.definitions_schema( + 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( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('BranchList'), [ core_schema.typed_dict_schema( @@ -151,7 +151,7 @@ class Bar: """ v = SchemaValidator( - core_schema.definitions_schema( + 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( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.model_schema( @@ -246,32 +246,24 @@ class Branch: def test_invalid_schema(): with pytest.raises(SchemaError, match='Definitions error: definition `Branch` was never filled'): SchemaValidator( - { - 'type': 'list', - 'items_schema': { - 'type': 'typed-dict', - 'fields': { - 'width': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - 'branch': { - 'type': 'typed-dict-field', - 'schema': { - 'type': 'default', - 'schema': { - 'type': 'nullable', - 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}, - }, - 'default': None, - }, - }, - }, - }, - } + schema=cs.list_schema( + items_schema=cs.typed_dict_schema( + fields={ + 'width': cs.typed_dict_field(schema=cs.int_schema()), + 'branch': cs.typed_dict_field( + schema=cs.with_default_schema( + schema=cs.nullable_schema(schema=cs.definition_reference_schema(schema_ref='Branch')) + ) + ), + } + ) + ) ) def test_outside_parent(): v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.typed_dict_schema( { 'tuple1': core_schema.typed_dict_field(core_schema.definition_reference_schema('tuple-iis')), @@ -294,7 +286,7 @@ def test_outside_parent(): def test_recursion_branch(): v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.typed_dict_schema( @@ -311,7 +303,7 @@ def test_recursion_branch(): ) ], ), - {'from_attributes': True}, + config=CoreConfig(from_attributes=True), ) assert ',definitions=[TypedDict(TypedDictValidator{' in plain_repr(v) @@ -338,7 +330,7 @@ def test_recursion_branch(): def test_recursion_branch_from_attributes(): v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.model_fields_schema( @@ -355,7 +347,7 @@ def test_recursion_branch_from_attributes(): ) ], ), - {'from_attributes': True}, + config=CoreConfig(from_attributes=True), ) assert v.validate_python({'name': 'root'}) == ({'name': 'root', 'branch': None}, None, {'name'}) @@ -387,7 +379,7 @@ def test_recursion_branch_from_attributes(): def test_definition_list(): v = SchemaValidator( - core_schema.definitions_schema( + 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')], ) @@ -414,7 +406,7 @@ def test_definition_list(): @pytest.fixture(scope='module') def multiple_tuple_schema() -> SchemaValidator: return SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.typed_dict_schema( { 'f1': core_schema.typed_dict_field(core_schema.definition_reference_schema('t')), @@ -517,7 +509,7 @@ def wrap_func(input_value, validator, info): return validator(input_value) + (42,) v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('wrapper'), [ core_schema.with_info_wrap_validator_function( @@ -551,7 +543,7 @@ def wrap_func(input_value, validator, info): def test_union_ref_strictness(): v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.typed_dict_schema( { 'a': core_schema.typed_dict_field(core_schema.definition_reference_schema('int-type')), @@ -579,7 +571,7 @@ def test_union_ref_strictness(): def test_union_container_strictness(): v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.typed_dict_schema( { 'b': core_schema.typed_dict_field( @@ -608,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( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('root-schema'), [ core_schema.union_schema( @@ -649,7 +641,7 @@ def f(input_value, info): return input_value + ' Changed' v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('root-schema'), [ core_schema.union_schema( @@ -697,7 +689,7 @@ def f(input_value, info): return f'f-{int(count) + 1}' v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('root-schema'), [ core_schema.union_schema( @@ -730,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( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema('Branch'), [ core_schema.typed_dict_schema( @@ -762,24 +754,18 @@ def test_many_uses_of_ref(): def test_error_inside_definition_wrapper(): with pytest.raises(SchemaError) as exc_info: SchemaValidator( - { - 'type': 'typed-dict', - 'ref': 'Branch', - 'fields': { - 'sub_branch': { - 'type': 'typed-dict-field', - 'schema': { - 'type': 'default', - 'schema': { - 'type': 'nullable', - 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}, - }, - 'default': None, - 'default_factory': lambda x: 'foobar', - }, - } + schema=cs.typed_dict_schema( + fields={ + 'sub_branch': cs.typed_dict_field( + schema=cs.with_default_schema( + schema=cs.nullable_schema(schema=cs.definition_reference_schema(schema_ref='Branch')), + default_factory=lambda x: 'foobar', + default=None, + ) + ) }, - } + ref='Branch', + ) ) assert str(exc_info.value) == ( 'Error building "typed-dict" validator:\n' @@ -812,7 +798,7 @@ def test_recursive_definitions_schema(pydantic_version) -> None: ], ) - v = SchemaValidator(s) + v = SchemaValidator(schema=s) assert v.validate_python({'b': [{'a': []}]}) == {'b': [{'a': []}]} @@ -841,7 +827,7 @@ def test_unsorted_definitions_schema() -> None: ], ) - v = SchemaValidator(s) + v = SchemaValidator(schema=s) assert v.validate_python({'x': 123}) == {'x': 123} @@ -876,7 +862,7 @@ class Model: ], ) - v = SchemaValidator(schema) + v = SchemaValidator(schema=schema) data = [Model(x=[Model(x=[])])] instance = Model(x=[]) @@ -924,7 +910,7 @@ def test_cyclic_data() -> None: ], ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) with pytest.raises(ValidationError) as exc_info: validator.validate_python(cyclic_data) @@ -974,7 +960,7 @@ def test_cyclic_data_threeway() -> None: ], ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) with pytest.raises(ValidationError) as exc_info: validator.validate_python(cyclic_data) @@ -1012,7 +998,7 @@ def test_complex_recursive_type() -> None: ], ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) with pytest.raises(ValidationError) as exc_info: validator.validate_python({'a': datetime.date(year=1992, month=12, day=11)}) @@ -1103,4 +1089,4 @@ def test_no_exponential_blowup(): ], ) - SchemaValidator(schema) + SchemaValidator(schema=schema) diff --git a/tests/validators/test_dict.py b/tests/validators/test_dict.py index 0d348b347..d9c4d2f7c 100644 --- a/tests/validators/test_dict.py +++ b/tests/validators/test_dict.py @@ -7,6 +7,7 @@ from dirty_equals import HasRepr, IsStr from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson @@ -38,7 +39,7 @@ def test_dict(py_and_json: PyAndJson): ids=repr, ) def test_dict_cases(input_value, expected): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'str'}}) + v = SchemaValidator(schema=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) @@ -62,7 +63,7 @@ def test_dict_value_error(py_and_json: PyAndJson): def test_dict_error_key_int(): - v = SchemaValidator({'type': 'dict', 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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)) @@ -83,7 +84,7 @@ def test_dict_error_key_int(): def test_dict_error_key_other(): - v = SchemaValidator({'type': 'dict', 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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) == [ @@ -97,8 +98,8 @@ def test_dict_error_key_other(): def test_dict_any_value(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}}) - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}}) + v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.str_schema())) + v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.str_schema())) assert v.validate_python({'1': 1, '2': 'a', '3': None}) == {'1': 1, '2': 'a', '3': None} @@ -116,17 +117,15 @@ def __iter__(self): def __len__(self): return len(self._d) - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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( - {'type': 'dict', 'strict': True, 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}} - ) + v = SchemaValidator(schema=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({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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}) @@ -151,7 +150,7 @@ def __iter__(self): def __len__(self): return 1 - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(BadMapping()) @@ -181,7 +180,7 @@ def __getitem__(self, key): def __len__(self): return 1 - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python(BadMapping()) @@ -219,7 +218,7 @@ def __len__(self): ], ) def test_dict_length_constraints(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator({'type': 'dict', **kwargs}) + v = SchemaValidator(schema=cs.dict_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -228,7 +227,7 @@ def test_dict_length_constraints(kwargs: dict[str, Any], input_value, expected): def test_json_dict(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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') @@ -239,13 +238,13 @@ def test_json_dict(): def test_dict_complex_key(): v = SchemaValidator( - {'type': 'dict', 'keys_schema': {'type': 'complex', 'strict': True}, 'values_schema': {'type': 'str'}} + schema=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({'type': 'dict', 'keys_schema': {'type': 'complex'}, 'values_schema': {'type': 'str'}}) + v = SchemaValidator(schema=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' ): @@ -253,7 +252,7 @@ def test_dict_complex_key(): def test_json_dict_complex_key(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'complex'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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 83e286417..94df99eef 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(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(schema=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(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True)) + v_strict = SchemaValidator(schema=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(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True)) + v_strict_f = SchemaValidator(schema=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(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='int')) + v = SchemaValidator(schema=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(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='str')) + v = SchemaValidator(schema=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(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='float')) + v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='float')) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -169,7 +169,9 @@ def _missing_(cls, v): assert MyEnum(2) is MyEnum.b assert MyEnum(3) is MyEnum.b - v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_)) + v = SchemaValidator( + schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_) + ) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -195,7 +197,9 @@ def _missing_(cls, v): with pytest.raises(ValueError, match='3 is not a valid'): MyEnum(3) - v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_)) + v = SchemaValidator( + schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_) + ) # debug(v) assert v.validate_python(MyEnum.a) is MyEnum.a @@ -227,7 +231,9 @@ def _missing_(cls, v): with pytest.raises(TypeError, match=e): MyEnum(3) - v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_)) + v = SchemaValidator( + schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_) + ) with pytest.raises(TypeError, match=e): v.validate_python(3) @@ -238,7 +244,7 @@ class MyEnum(int, Enum): b = 2 v = SchemaValidator( - core_schema.union_schema( + schema=core_schema.union_schema( [ core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_), core_schema.int_schema(), @@ -256,7 +262,7 @@ class MyEnum(Enum): b = [2] assert MyEnum([1]) is MyEnum.a - v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(schema=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 @@ -267,7 +273,7 @@ class MyEnum(Enum): pass with pytest.raises(SchemaError, match='`members` should have length > 0'): - SchemaValidator(core_schema.enum_schema(MyEnum, [])) + SchemaValidator(schema=core_schema.enum_schema(MyEnum, [])) def test_enum_with_str_subclass() -> None: @@ -275,7 +281,7 @@ class MyEnum(Enum): a = 'a' b = 'b' - v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(schema=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 @@ -293,7 +299,7 @@ class MyEnum(Enum): a = 1 b = 2 - v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(schema=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 @@ -311,7 +317,7 @@ class MyEnum(int, Enum): a = 1 b = 2 - v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) + v = SchemaValidator(schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()))) assert v.validate_python(1.0) is MyEnum.a @@ -322,7 +328,7 @@ class MyFlags(IntFlag): ON = 1 v = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( schema=core_schema.enum_schema(MyFlags, list(MyFlags.__members__.values())), default=MyFlags.OFF ) ) @@ -340,7 +346,9 @@ class ColorEnum(IntEnum): BLUE = 1 << 64 v = SchemaValidator( - core_schema.with_default_schema(schema=core_schema.enum_schema(ColorEnum, list(ColorEnum.__members__.values()))) + schema=core_schema.with_default_schema( + schema=core_schema.enum_schema(ColorEnum, list(ColorEnum.__members__.values())) + ) ) assert v.validate_python(ColorEnum.GREEN) is ColorEnum.GREEN @@ -359,14 +367,14 @@ class MyIntEnum(IntEnum): VALUE = value v = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) ) v_int = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( schema=core_schema.enum_schema(MyIntEnum, list(MyIntEnum.__members__.values())), default=MyIntEnum.VALUE, ) @@ -396,7 +404,7 @@ class MyEnum(Enum): THIRD_VALUE = 'Py03' v = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -412,7 +420,7 @@ class MyEnum(Enum): VALUE = '1' v = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -427,7 +435,7 @@ class MyEnum(Enum): VALUE = 1 v = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -452,7 +460,7 @@ def __init__(self, value): self.value = value v = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())), default=MyEnum.VALUE, ) @@ -482,7 +490,7 @@ def __new__(cls, species: str, sound: str): return obj - v = SchemaValidator(core_schema.enum_schema(Animal, list(Animal.__members__.values()))) + v = SchemaValidator(schema=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 1269a6d51..7ee68fa43 100644 --- a/tests/validators/test_float.py +++ b/tests/validators/test_float.py @@ -7,6 +7,7 @@ from dirty_equals import FunctionCheck, IsFloatNan, IsStr from pydantic_core import SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, plain_repr @@ -200,23 +201,23 @@ def test_union_float_simple(py_and_json: PyAndJson): def test_float_repr(): - v = SchemaValidator({'type': 'float'}) + v = SchemaValidator(schema=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({'type': 'float', 'strict': True}) + v = SchemaValidator(schema=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({'type': 'float', 'multiple_of': 7}) + v = SchemaValidator(schema=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({'type': 'float'}) + v = SchemaValidator(schema=cs.float_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -315,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({'type': 'float', 'allow_inf_nan': allow_inf_nan, 'strict': strict}) + v = SchemaValidator(schema=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) @@ -345,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({'type': 'float', 'allow_inf_nan': allow_inf_nan, 'gt': 0}) + v = SchemaValidator(schema=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) @@ -383,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({'type': 'float'}) + v = SchemaValidator(schema=cs.float_schema()) assert v.validate_json(input_value) == expected def test_string_with_underscores() -> None: - v = SchemaValidator({'type': 'float'}) + v = SchemaValidator(schema=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 @@ -400,7 +401,7 @@ def test_string_with_underscores() -> None: def test_allow_inf_nan_true_json() -> None: - v = SchemaValidator(core_schema.float_schema()) + v = SchemaValidator(schema=core_schema.float_schema()) assert v.validate_json('123') == 123 assert v.validate_json('NaN') == IsFloatNan() @@ -413,7 +414,7 @@ def test_allow_inf_nan_true_json() -> None: def test_allow_inf_nan_false_json() -> None: - v = SchemaValidator(core_schema.float_schema(), core_schema.CoreConfig(allow_inf_nan=False)) + v = SchemaValidator(schema=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 c75175766..27bef1330 100644 --- a/tests/validators/test_frozenset.py +++ b/tests/validators/test_frozenset.py @@ -5,6 +5,7 @@ import pytest from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, infinite_generator, plain_repr @@ -25,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({'type': 'frozenset'}) + v = SchemaValidator(schema=cs.frozenset_schema()) output = v.validate_python(input_value) assert output == expected assert isinstance(output, frozenset) def test_no_copy(): - v = SchemaValidator({'type': 'frozenset'}) + v = SchemaValidator(schema=cs.frozenset_schema()) input_value = frozenset([1, 2, 3]) output = v.validate_python(input_value) assert output == input_value @@ -84,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({'type': 'frozenset', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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) @@ -99,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({'type': 'frozenset'}) + v = SchemaValidator(schema=cs.frozenset_schema()) output = v.validate_python(input_value) assert output == expected assert isinstance(output, frozenset) def test_frozenset_multiple_errors(): - v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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) == [ @@ -168,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({'type': 'frozenset', **kwargs}) + v = SchemaValidator(schema=cs.frozenset_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -180,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({'type': 'union', 'choices': [{'type': 'frozenset'}, {'type': 'list'}]}) + v = SchemaValidator(schema=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) @@ -218,13 +219,12 @@ def test_union_frozenset_list(input_value, expected): ) def test_union_frozenset_int_frozenset_str(input_value, expected): v = SchemaValidator( - { - 'type': 'union', - 'choices': [ - {'type': 'frozenset', 'items_schema': {'type': 'int', 'strict': True}}, - {'type': 'frozenset', 'items_schema': {'type': 'str', 'strict': True}}, - ], - } + 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)), + ] + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: @@ -244,7 +244,7 @@ def test_frozenset_as_dict_keys(py_and_json: PyAndJson): def test_repr(): - v = SchemaValidator({'type': 'frozenset', 'strict': True, 'min_length': 42}) + v = SchemaValidator(schema=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({'type': 'frozenset', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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({'type': 'frozenset', 'items_schema': items_schema}) + v = SchemaValidator(schema=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({'type': 'frozenset', 'items_schema': {'type': 'int'}, 'fail_fast': fail_fast}) + v = SchemaValidator(schema=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 544bf416d..5d204847e 100644 --- a/tests/validators/test_function.py +++ b/tests/validators/test_function.py @@ -7,7 +7,8 @@ import pytest from dirty_equals import HasRepr -from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema +from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema +from pydantic_core import core_schema as cs from ..conftest import plain_repr @@ -25,7 +26,7 @@ def test_function_before(): def f(input_value, _info): return input_value + ' Changed' - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -34,7 +35,7 @@ def test_function_before_no_info(): def f(input_value): return input_value + ' Changed' - v = SchemaValidator(core_schema.no_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.no_info_before_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -43,7 +44,7 @@ def test_function_before_raise(): def f(input_value, info): raise ValueError('foobar') - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=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' @@ -64,10 +65,10 @@ def my_function(input_value, info): return input_value + 'x' v = SchemaValidator( - { + schema={ 'type': 'function-before', 'function': {'type': 'with-info', 'function': my_function}, - 'schema': {'type': 'str', 'max_length': 5}, + 'schema': cs.str_schema(max_length=5), } ) @@ -90,8 +91,8 @@ def my_function(input_value, info): 'config,input_str', ( ({}, "type=string_too_long, input_value='12345x', input_type=str"), - ({'hide_input_in_errors': False}, "type=string_too_long, input_value='12345x', input_type=str"), - ({'hide_input_in_errors': True}, 'type=string_too_long'), + (CoreConfig(hide_input_in_errors=False), "type=string_too_long, input_value='12345x', input_type=str"), + (CoreConfig(hide_input_in_errors=True), 'type=string_too_long'), ), ) def test_function_before_error_hide_input(config, input_str): @@ -99,12 +100,12 @@ def my_function(input_value, info): return input_value + 'x' v = SchemaValidator( - { + schema={ 'type': 'function-before', 'function': {'type': 'with-info', 'function': my_function}, - 'schema': {'type': 'str', 'max_length': 5}, + 'schema': cs.str_schema(max_length=5), }, - config, + config=config, ) with pytest.raises(ValidationError, match=re.escape(f'String should have at most 5 characters [{input_str}]')): @@ -118,13 +119,12 @@ def f(input_value, info): return input_value v = SchemaValidator( - { + schema={ 'type': 'function-before', 'function': {'type': 'with-info', 'function': f}, - 'schema': { - 'type': 'typed-dict', - 'fields': {'my_field': {'type': 'typed-dict-field', 'schema': {'type': 'str', 'max_length': 5}}}, - }, + 'schema': cs.typed_dict_schema( + fields={'my_field': cs.typed_dict_field(schema=cs.str_schema(max_length=5))} + ), } ) @@ -148,7 +148,11 @@ def f(input_value, info): (None, {}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'), (None, {'context': {1: 2}}, 'ValidationInfo(config=None, context={1: 2}, data=None, field_name=None)'), (None, {'context': None}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'), - ({'title': 'hello'}, {}, "ValidationInfo(config={'title': 'hello'}, context=None, data=None, field_name=None)"), + ( + CoreConfig(title='hello'), + {}, + "ValidationInfo(config={'title': 'hello'}, context=None, data=None, field_name=None)", + ), ], ) def test_val_info_repr(config, kwargs, expected_repr): @@ -157,7 +161,9 @@ def f(input_value, info: core_schema.ValidationInfo): assert str(info) == expected_repr return input_value - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()), config) + v = SchemaValidator( + schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema()), config=config + ) assert v.validate_python('input value', **kwargs) == 'input value' @@ -166,7 +172,7 @@ def test_function_wrap(): def f(input_value, validator, info): return validator(input_value=input_value) + ' Changed' - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -175,7 +181,7 @@ def test_function_wrap_no_info(): def f(input_value, validator): return validator(input_value=input_value) + ' Changed' - v = SchemaValidator(core_schema.no_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.no_info_wrap_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -185,7 +191,7 @@ def f(input_value, validator, info): assert repr(validator) == str(validator) return plain_repr(validator) - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) assert ( v.validate_python('input value') @@ -197,7 +203,7 @@ def test_function_wrap_str(): def f(input_value, validator, info): return plain_repr(validator) - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())) assert ( v.validate_python('input value') @@ -222,7 +228,7 @@ def f(input_value, validator, info): assert str(e).startswith('1 validation error for ValidatorCallable\n') raise e - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=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: @@ -241,8 +247,8 @@ def f(input_value, validator, info): 'config,input_str', ( ({}, "type=int_parsing, input_value='wrong', input_type=str"), - ({'hide_input_in_errors': False}, "type=int_parsing, input_value='wrong', input_type=str"), - ({'hide_input_in_errors': True}, 'type=int_parsing'), + (CoreConfig(hide_input_in_errors=False), "type=int_parsing, input_value='wrong', input_type=str"), + (CoreConfig(hide_input_in_errors=True), 'type=int_parsing'), ), ) def test_function_wrap_error_hide_input(config, input_str): @@ -254,7 +260,9 @@ def f(input_value, validator, info): assert str(e).startswith('1 validation error for ValidatorCallable\n') raise e - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()), config) + v = SchemaValidator( + schema=core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()), config=config + ) with pytest.raises( ValidationError, @@ -267,7 +275,7 @@ def test_function_wrap_location(): def f(input_value, validator, info): return validator(input_value, outer_location='foo') + 2 - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=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: @@ -287,7 +295,7 @@ def test_function_wrap_invalid_location(): def f(input_value, validator, info): return validator(input_value, ('4',)) + 2 - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f, core_schema.int_schema())) assert v.validate_python(4) == 6 @@ -308,7 +316,7 @@ def test_function_after(): def f(input_value, _info): return input_value + ' Changed' - v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_after_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -317,7 +325,7 @@ def test_function_no_info(): def f(input_value): return input_value + ' Changed' - v = SchemaValidator(core_schema.no_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.no_info_after_validator_function(f, core_schema.str_schema())) assert v.validate_python('input value') == 'input value Changed' @@ -326,7 +334,7 @@ def test_function_after_raise(): def f(input_value, info): raise ValueError('foobar') - v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=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' @@ -346,15 +354,17 @@ def f(input_value, info): 'config,input_str', ( ({}, "type=value_error, input_value='input value', input_type=str"), - ({'hide_input_in_errors': False}, "type=value_error, input_value='input value', input_type=str"), - ({'hide_input_in_errors': True}, 'type=value_error'), + (CoreConfig(hide_input_in_errors=False), "type=value_error, input_value='input value', input_type=str"), + (CoreConfig(hide_input_in_errors=True), 'type=value_error'), ), ) def test_function_after_error_hide_input(config, input_str): def f(input_value, info): raise ValueError('foobar') - v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()), config) + v = SchemaValidator( + schema=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') @@ -369,20 +379,18 @@ def f(input_value, info): return input_value + ' Changed' v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'test_field': { - 'type': 'typed-dict-field', - 'schema': { + schema=cs.typed_dict_schema( + fields={ + 'test_field': cs.typed_dict_field( + schema={ 'type': 'function-after', 'function': {'type': 'with-info', 'function': f, 'field_name': 'test_field'}, - 'schema': {'type': 'str'}, - }, - } + 'schema': cs.str_schema(), + } + ) }, - 'config': {'allow_inf_nan': True}, - } + config=CoreConfig(allow_inf_nan=True), + ) ) assert v.validate_python({'test_field': b'321'}) == {'test_field': '321 Changed'} @@ -397,7 +405,7 @@ def f(input_value, info: core_schema.ValidationInfo): f_kwargs = deepcopy_info(info) return input_value + ' Changed' - v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=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} @@ -407,7 +415,7 @@ def test_function_plain(): def f(input_value, _info): return input_value * 2 - v = SchemaValidator(core_schema.with_info_plain_validator_function(f)) + v = SchemaValidator(schema=core_schema.with_info_plain_validator_function(f)) assert v.validate_python(1) == 2 assert v.validate_python('x') == 'xx' @@ -417,7 +425,7 @@ def test_function_plain_no_info(): def f(input_value): return input_value * 2 - v = SchemaValidator(core_schema.no_info_plain_validator_function(f)) + v = SchemaValidator(schema=core_schema.no_info_plain_validator_function(f)) assert v.validate_python(1) == 2 assert v.validate_python('x') == 'xx' @@ -447,7 +455,7 @@ def __init__(self): self.__pydantic_extra__ = None # this attribute must be present for validate_assignment v = SchemaValidator( - core_schema.no_info_after_validator_function( + schema=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())}) @@ -472,7 +480,7 @@ def test_function_wrong_sig(): def f(input_value): return input_value + ' Changed' - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) # exception messages differ between python and pypy if platform.python_implementation() == 'PyPy': @@ -496,10 +504,10 @@ 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': {'type': 'str'}, + 'schema': cs.str_schema(), } ) @@ -523,7 +531,7 @@ def test_raise_assertion_error(): def f(input_value, info): raise AssertionError('foobar') - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python('input value') @@ -543,7 +551,7 @@ def test_raise_assertion_error_plain(): def f(input_value, info): raise AssertionError - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(ValidationError) as exc_info: v.validate_python('input value') @@ -568,7 +576,7 @@ def __str__(self): def f(input_value, info): raise MyError() - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(RuntimeError, match='internal error'): v.validate_python('input value') @@ -578,7 +586,7 @@ def test_raise_type_error(): def f(input_value, info): raise TypeError('foobar') - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.str_schema())) with pytest.raises(TypeError, match='^foobar$'): v.validate_python('input value') @@ -597,7 +605,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -623,7 +631,7 @@ def f(input_value: str, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value}' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -649,7 +657,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - core_schema.model_schema( + 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'))} @@ -671,7 +679,7 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor return f'input: {val(input_value)}' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -701,7 +709,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -725,7 +733,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value}' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -750,7 +758,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value.decode()}' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f))} @@ -771,7 +779,7 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor return f'input: {val(input_value)}' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -796,7 +804,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any: return f'input: {input_value}' v = SchemaValidator( - core_schema.typed_dict_schema( + 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()), @@ -853,7 +861,7 @@ def f(input_value: Any, *args: Any) -> Any: return input_value v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, { 'type': f'function-{mode}', @@ -885,7 +893,7 @@ def f(v: Any, info: core_schema.ValidationInfo) -> Any: calls.append(info.mode) return v - v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_before_validator_function(f, core_schema.int_schema())) assert v.validate_python(1) == 1 assert calls == ['python'] calls.clear() @@ -893,7 +901,7 @@ def f(v: Any, info: core_schema.ValidationInfo) -> Any: assert calls == ['json'] calls.clear() - v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_after_validator_function(f, core_schema.int_schema())) assert v.validate_python(1) == 1 assert calls == ['python'] calls.clear() @@ -905,7 +913,7 @@ def f_w(v: Any, handler: core_schema.ValidatorFunctionWrapHandler, info: core_sc calls.append(info.mode) return handler(v) - v = SchemaValidator(core_schema.with_info_wrap_validator_function(f_w, core_schema.int_schema())) + v = SchemaValidator(schema=core_schema.with_info_wrap_validator_function(f_w, core_schema.int_schema())) assert v.validate_python(1) == 1 assert calls == ['python'] calls.clear() @@ -922,7 +930,7 @@ def sample_repr(v: Any, info: core_schema.ValidationInfo) -> Any: return v v = SchemaValidator( - core_schema.chain_schema( + 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'), @@ -951,7 +959,7 @@ def identity(v): return v schema = core_schema.no_info_after_validator_function(identity, core_schema.date_schema(strict=True)) - v = SchemaValidator(schema) + v = SchemaValidator(schema=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 f8d7fd429..84d156235 100644 --- a/tests/validators/test_generator.py +++ b/tests/validators/test_generator.py @@ -3,7 +3,8 @@ import pytest from dirty_equals import HasRepr, IsStr -from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import CoreConfig, SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson @@ -33,9 +34,9 @@ def test_generator_json_int(py_and_json: PyAndJson, input_value, expected): @pytest.mark.parametrize( 'config,input_str', ( - ({}, 'type=iterable_type, input_value=5, input_type=int'), - ({'hide_input_in_errors': False}, 'type=iterable_type, input_value=5, input_type=int'), - ({'hide_input_in_errors': True}, 'type=iterable_type'), + (CoreConfig(), 'type=iterable_type, input_value=5, input_type=int'), + (CoreConfig(hide_input_in_errors=False), 'type=iterable_type, input_value=5, input_type=int'), + (CoreConfig(hide_input_in_errors=True), 'type=iterable_type'), ), ) def test_generator_json_hide_input(py_and_json: PyAndJson, config, input_str): @@ -150,7 +151,7 @@ def gen(): def test_generator_too_long(): - v = SchemaValidator({'type': 'generator', 'items_schema': {'type': 'int'}, 'max_length': 2}) + v = SchemaValidator(schema=cs.generator_schema(items_schema=cs.int_schema(), max_length=2)) validating_iterator = v.validate_python(gen()) @@ -174,7 +175,7 @@ def test_generator_too_long(): def test_generator_too_short(): - v = SchemaValidator({'type': 'generator', 'items_schema': {'type': 'int'}, 'min_length': 4}) + v = SchemaValidator(schema=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 c69d6bb9a..b5327fd2e 100644 --- a/tests/validators/test_int.py +++ b/tests/validators/test_int.py @@ -7,6 +7,7 @@ from dirty_equals import IsStr from pydantic_core import SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, plain_repr @@ -141,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({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -187,7 +188,7 @@ def test_int(input_value, expected): ], ) def test_positive_int(input_value, expected): - v = SchemaValidator({'type': 'int', 'gt': 0}) + v = SchemaValidator(schema=cs.int_schema(gt=0)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -208,7 +209,7 @@ def test_positive_int(input_value, expected): ], ) def test_negative_int(input_value, expected): - v = SchemaValidator({'type': 'int', 'lt': 0}) + v = SchemaValidator(schema=cs.int_schema(lt=0)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -236,7 +237,7 @@ def test_negative_int(input_value, expected): ], ) def test_positive_json(input_value, expected): - v = SchemaValidator({'type': 'int', 'gt': 0}) + v = SchemaValidator(schema=cs.int_schema(gt=0)) json_input = json.dumps(input_value) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -258,7 +259,7 @@ def test_positive_json(input_value, expected): ], ) def test_negative_json(input_value, expected): - v = SchemaValidator({'type': 'int', 'lt': 0}) + v = SchemaValidator(schema=cs.int_schema(lt=0)) json_input = json.dumps(input_value) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -383,22 +384,22 @@ def test_union_int_simple(py_and_json: PyAndJson): def test_int_repr(): - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) assert ( plain_repr(v) == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:false}),definitions=[],cache_strings=True)' ) - v = SchemaValidator({'type': 'int', 'strict': True}) + v = SchemaValidator(schema=cs.int_schema(strict=True)) assert ( plain_repr(v) == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:true}),definitions=[],cache_strings=True)' ) - v = SchemaValidator({'type': 'int', 'multiple_of': 7}) + v = SchemaValidator(schema=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({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) with pytest.raises(ValidationError) as exc_info: v.validate_python('1' * 4301) @@ -421,7 +422,7 @@ def test_too_long(pydantic_version): def test_long_python(): - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) s = v.validate_python('1' * 4_300) assert s == int('1' * 4_300) @@ -434,7 +435,7 @@ def test_long_python(): def test_long_python_inequality(): - v = SchemaValidator({'type': 'int', 'gt': 0, 'lt': int('1' * 4_300) - 5}) + v = SchemaValidator(schema=cs.int_schema(gt=0, lt=int('1' * 4_300) - 5)) s = str(int('1' * 4_300) - 6) s = v.validate_python(s) @@ -446,7 +447,7 @@ def test_long_python_inequality(): def test_long_json(): - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) assert v.validate_json('-' + '1' * 400) == int('-' + '1' * 400) @@ -463,7 +464,7 @@ def test_int_key(py_and_json: PyAndJson): def test_string_as_int_with_underscores() -> None: - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) assert v.validate_python('1_000_000') == 1_000_000 assert v.validate_json('"1_000_000"') == 1_000_000 @@ -479,7 +480,7 @@ class IntSubclass(int): def test_int_subclass() -> None: - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) v_lax = v.validate_python(IntSubclass(1)) assert v_lax == 1 assert type(v_lax) == int @@ -494,7 +495,7 @@ def test_int_subclass() -> None: def test_int_subclass_constraint() -> None: - v = SchemaValidator({'type': 'int', 'gt': 0}) + v = SchemaValidator(schema=cs.int_schema(gt=0)) v_lax = v.validate_python(IntSubclass(1)) assert v_lax == 1 assert type(v_lax) == int @@ -511,14 +512,14 @@ class FloatSubclass(float): def test_float_subclass() -> None: - v = SchemaValidator({'type': 'int'}) + v = SchemaValidator(schema=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({'type': 'int'}) + v = SchemaValidator(schema=cs.int_schema()) from enum import Enum @@ -531,7 +532,7 @@ class PlainEnum(Enum): def test_allow_inf_nan_true_json() -> None: - v = SchemaValidator(core_schema.int_schema(), core_schema.CoreConfig(allow_inf_nan=True)) + v = SchemaValidator(schema=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'): @@ -543,7 +544,7 @@ def test_allow_inf_nan_true_json() -> None: def test_allow_inf_nan_false_json() -> None: - v = SchemaValidator(core_schema.int_schema(), core_schema.CoreConfig(allow_inf_nan=False)) + v = SchemaValidator(schema=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'): @@ -555,7 +556,7 @@ def test_allow_inf_nan_false_json() -> None: def test_json_big_int_key(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'str'}}) + v = SchemaValidator(schema=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 9bce323a7..b1778e093 100644 --- a/tests/validators/test_is_instance.py +++ b/tests/validators/test_is_instance.py @@ -3,6 +3,7 @@ import pytest from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs class Foo: @@ -18,14 +19,14 @@ class Spam: def test_validate_json() -> None: - v = SchemaValidator({'type': 'is-instance', 'cls': Foo}) + v = SchemaValidator(schema=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({'type': 'is-instance', 'cls': Foo}) + v = SchemaValidator(schema=cs.is_instance_schema(cls=Foo)) foo = Foo() assert v.validate_python(foo) == foo assert v.isinstance_python(foo) is True @@ -65,14 +66,14 @@ def test_is_instance(): ], ) def test_is_instance_cases(schema_class, input_val, value): - v = SchemaValidator({'type': 'is-instance', 'cls': schema_class}) + v = SchemaValidator(schema=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({'type': 'is-instance', 'cls': input_cls}) + SchemaValidator(schema=cs.is_instance_schema(cls=input_cls)) class HasIsInstanceMeta(type): @@ -88,7 +89,7 @@ class HasIsInstance(metaclass=HasIsInstanceMeta): def test_instancecheck(): - v = SchemaValidator({'type': 'is-instance', 'cls': HasIsInstance}) + v = SchemaValidator(schema=cs.is_instance_schema(cls=HasIsInstance)) assert v.validate_python('true') == 'true' with pytest.raises(ValidationError, match='type=is_instance_of'): @@ -99,7 +100,7 @@ def test_instancecheck(): def test_repr(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'int'}, {'type': 'is-instance', 'cls': Foo}]}) + v = SchemaValidator(schema=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 @@ -122,13 +123,13 @@ def test_repr(): ], ) def test_is_type(input_val, value): - v = SchemaValidator({'type': 'is-instance', 'cls': type}) + v = SchemaValidator(schema=cs.is_instance_schema(cls=type)) assert v.isinstance_python(input_val) == value def test_is_instance_dict(): v = SchemaValidator( - core_schema.dict_schema( + schema=core_schema.dict_schema( keys_schema=core_schema.is_instance_schema(str), values_schema=core_schema.is_instance_schema(int) ) ) @@ -137,13 +138,13 @@ def test_is_instance_dict(): def test_is_instance_dict_not_str(): - v = SchemaValidator(core_schema.dict_schema(keys_schema=core_schema.is_instance_schema(int))) + v = SchemaValidator(schema=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(core_schema.is_instance_schema(typing.Sequence)) + v = SchemaValidator(schema=core_schema.is_instance_schema(typing.Sequence)) assert v.isinstance_python(1) is False assert v.isinstance_python([1]) is True @@ -152,7 +153,7 @@ def test_is_instance_sequence(): def test_is_instance_tuple(): - v = SchemaValidator(core_schema.is_instance_schema((int, str))) + v = SchemaValidator(schema=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 @@ -161,7 +162,7 @@ def test_is_instance_tuple(): def test_class_repr(): - v = SchemaValidator(core_schema.is_instance_schema(int, cls_repr='Foobar')) + v = SchemaValidator(schema=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') @@ -174,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) + v = SchemaValidator(schema=schema) with pytest.raises(ValidationError) as exc_info: v.validate_json('null') @@ -185,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) + v = SchemaValidator(schema=schema) assert v.validate_json('null') == int diff --git a/tests/validators/test_is_subclass.py b/tests/validators/test_is_subclass.py index 43e65b6b1..38264cc62 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(core_schema.is_subclass_schema(Foo)) + v = SchemaValidator(schema=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(core_schema.is_subclass_schema(Foo)) + v = SchemaValidator(schema=core_schema.is_subclass_schema(Foo)) assert v.isinstance_python(input_value) == valid def test_not_parent(): - v = SchemaValidator(core_schema.is_subclass_schema(Foobar)) + v = SchemaValidator(schema=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(core_schema.is_subclass_schema(Foo())) + SchemaValidator(schema=core_schema.is_subclass_schema(Foo())) def test_custom_repr(): - v = SchemaValidator(core_schema.is_subclass_schema(Foo, cls_repr='Spam')) + v = SchemaValidator(schema=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(core_schema.is_subclass_schema(Foo)) + v = SchemaValidator(schema=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 5d60d58f3..ed90eb911 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(core_schema.json_schema()) + v = SchemaValidator(schema=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(v) + v = SchemaValidator(schema=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(core_schema.json_schema()) + v = SchemaValidator(schema=core_schema.json_schema()) assert 'validator:None' in plain_repr(v) - v = SchemaValidator(core_schema.json_schema(core_schema.any_schema())) + v = SchemaValidator(schema=core_schema.json_schema(core_schema.any_schema())) assert 'validator:None' in plain_repr(v) - v = SchemaValidator(core_schema.json_schema(core_schema.int_schema())) + v = SchemaValidator(schema=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 6cd57b1c3..2430afa93 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(s) + v = SchemaValidator(schema=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 4c3a457d5..830ebe72d 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(core_schema.lax_or_strict_schema(core_schema.str_schema(), core_schema.int_schema())) + v = SchemaValidator(schema=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( - core_schema.lax_or_strict_schema(core_schema.str_schema(), core_schema.int_schema(), strict=True) + schema=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 991a90cbc..c6a70e561 100644 --- a/tests/validators/test_list.py +++ b/tests/validators/test_list.py @@ -9,6 +9,7 @@ from dirty_equals import Contains, HasRepr, IsInstance, IsList, IsStr from pydantic_core import SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, infinite_generator @@ -33,7 +34,7 @@ def test_list_py_or_json(py_and_json: PyAndJson, input_value, expected): def test_list_strict(): - v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}, 'strict': True}) + v = SchemaValidator(schema=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')) @@ -43,7 +44,7 @@ def test_list_strict(): def test_list_no_copy(): - v = SchemaValidator({'type': 'list'}) + v = SchemaValidator(schema=cs.list_schema()) assert v.validate_python([1, 2, 3]) is not [1, 2, 3] # noqa: F632 @@ -73,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({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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) @@ -82,7 +83,7 @@ def test_list_int(input_value, expected): def test_list_json(): - v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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: @@ -107,7 +108,7 @@ def test_list_json(): ], ) def test_list_any(input_value, expected): - v = SchemaValidator({'type': 'list'}) + v = SchemaValidator(schema=cs.list_schema()) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -127,7 +128,7 @@ def test_list_any(input_value, expected): ], ) def test_list_error(input_value, index): - v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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) == [ @@ -173,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({'type': 'list', **kwargs}) + v = SchemaValidator(schema=cs.list_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): v.validate_python(input_value) @@ -191,11 +192,9 @@ def test_list_length_constraints(kwargs: dict[str, Any], input_value, expected): ) def test_list_length_constraints_omit(input_value, expected): v = SchemaValidator( - { - 'type': 'list', - 'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}, - 'max_length': 4, - } + schema=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)): @@ -205,7 +204,7 @@ def test_list_length_constraints_omit(input_value, expected): def test_length_ctx(): - v = SchemaValidator({'type': 'list', 'min_length': 2, 'max_length': 3}) + v = SchemaValidator(schema=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)) @@ -238,7 +237,7 @@ def test_list_function(): def f(input_value, info): return input_value * 2 - v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)}) + v = SchemaValidator(schema=cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f))) assert v.validate_python([1, 2, 3]) == [2, 4, 6] @@ -247,7 +246,7 @@ def test_list_function_val_error(): def f(input_value, info): raise ValueError(f'error {input_value}') - v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)}) + v = SchemaValidator(schema=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]) @@ -273,7 +272,7 @@ def test_list_function_internal_error(): def f(input_value, info): raise RuntimeError(f'error {input_value}') - v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)}) + v = SchemaValidator(schema=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]) @@ -288,7 +287,7 @@ def gen(error: bool): raise RuntimeError('error') yield 3 - v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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)) @@ -322,7 +321,7 @@ def gen(error: bool): ], ) def test_list_from_dict_items(input_value, items_schema, expected): - v = SchemaValidator({'type': 'list', 'items_schema': items_schema}) + v = SchemaValidator(schema=cs.list_schema(items_schema=items_schema)) output = v.validate_python(input_value) assert isinstance(output, list) assert output == expected @@ -350,7 +349,7 @@ def __next__(self): else: raise RuntimeError('broken') - v = SchemaValidator({'type': 'list', 'items_schema': {'type': items_schema}}) + v = SchemaValidator(schema=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)) @@ -380,7 +379,7 @@ def f(v: int) -> int: core_schema.no_info_after_validator_function(f, core_schema.int_schema()), max_length=10 ) - v = SchemaValidator(s) + v = SchemaValidator(schema=s) data = list(range(15)) @@ -437,7 +436,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(s) + v = SchemaValidator(schema=s) with pytest.raises(ValidationError) as exc_info: v.validate_python([1, 'not-num', 'again']) @@ -515,7 +514,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(core_schema.list_schema(core_schema.int_schema(), strict=testcase.strict)) + v = SchemaValidator(schema=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) @@ -539,7 +538,7 @@ def test_list_allowed_inputs_python(testcase: ListInputTestCase): ) def test_list_dict_items_input(testcase: ListInputTestCase) -> None: v = SchemaValidator( - core_schema.list_schema( + 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 2b3f88a4e..f1b05339f 100644 --- a/tests/validators/test_literal.py +++ b/tests/validators/test_literal.py @@ -5,6 +5,7 @@ import pytest from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, plain_repr @@ -147,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({'type': 'literal', 'expected': kwarg_expected}) + v = SchemaValidator(schema=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) @@ -160,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({'type': 'literal', 'expected': []}) + SchemaValidator(schema=cs.literal_schema(expected=[])) def test_literal_none(): - v = SchemaValidator(core_schema.literal_schema([None])) + v = SchemaValidator(schema=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]"' @@ -172,7 +173,9 @@ def test_literal_none(): def test_union(): - v = SchemaValidator(core_schema.union_schema([core_schema.literal_schema(['a', 'b']), core_schema.int_schema()])) + v = SchemaValidator( + schema=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: @@ -200,7 +203,7 @@ class FooEnum(Enum): foo = 'foo_value' bar = 'bar_value' - v = SchemaValidator(core_schema.literal_schema([FooEnum.foo])) + v = SchemaValidator(schema=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') @@ -245,7 +248,7 @@ class Foo(str, Enum): foo = 'foo_value' bar = 'bar_value' - v = SchemaValidator(core_schema.literal_schema([Foo.foo])) + v = SchemaValidator(schema=core_schema.literal_schema([Foo.foo])) assert v.validate_python(Foo.foo) == Foo.foo assert v.validate_python('foo_value') == Foo.foo @@ -269,7 +272,7 @@ class Foo(int, Enum): foo = 2 bar = 3 - v = SchemaValidator(core_schema.literal_schema([Foo.foo])) + v = SchemaValidator(schema=core_schema.literal_schema([Foo.foo])) assert v.validate_python(Foo.foo) == Foo.foo assert v.validate_python(2) == Foo.foo @@ -321,7 +324,7 @@ def test_mix_int_enum_with_int(reverse: Callable[[list[Any]], list[Any]], err: A class Foo(int, Enum): foo = 1 - v = SchemaValidator(core_schema.literal_schema(reverse([1, Foo.foo]))) + v = SchemaValidator(schema=core_schema.literal_schema(reverse([1, Foo.foo]))) assert v.validate_python(Foo.foo) is Foo.foo val = v.validate_python(1) @@ -367,7 +370,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(core_schema.literal_schema(reverse(['foo_val', Foo.foo]))) + v = SchemaValidator(schema=core_schema.literal_schema(reverse(['foo_val', Foo.foo]))) assert v.validate_python(Foo.foo) is Foo.foo val = v.validate_python('foo_val') @@ -383,7 +386,7 @@ class Foo(str, Enum): def test_big_int(): big_int = 2**64 + 1 massive_int = 2**128 + 1 - v = SchemaValidator(core_schema.literal_schema([big_int, massive_int])) + v = SchemaValidator(schema=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' @@ -395,8 +398,8 @@ def test_enum_for_str() -> None: class S(str, Enum): a = 'a' - val_enum = SchemaValidator(core_schema.literal_schema([S.a])) - val_str = SchemaValidator(core_schema.literal_schema(['a'])) + val_enum = SchemaValidator(schema=core_schema.literal_schema([S.a])) + val_str = SchemaValidator(schema=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 1d6ab7f47..57ad33da7 100644 --- a/tests/validators/test_model.py +++ b/tests/validators/test_model.py @@ -7,7 +7,7 @@ import pytest from dirty_equals import HasRepr, IsInstance -from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema def test_model_class(): @@ -18,7 +18,7 @@ class MyModel: field_b: int v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -54,7 +54,7 @@ class MyModel: field_b: int v = SchemaValidator( - core_schema.model_schema( + 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( - core_schema.model_schema( + 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( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -184,14 +184,12 @@ def __setattr__(self, key, value): setattr_calls.clear() v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, - } + 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())} + ), + ) ) m = v.validate_python({'field_a': 'test'}) assert isinstance(m, MyModel) @@ -221,7 +219,7 @@ def f( ), ) - v = SchemaValidator(schema) + v = SchemaValidator(schema=schema) m = v.validate_python({'field_a': 123}) assert m.field_a == 123 @@ -255,7 +253,7 @@ def f(input_value: dict[str, Any], info: core_schema.ValidationInfo): ), ) - v = SchemaValidator(schema) + v = SchemaValidator(schema=schema) m = v.validate_python({'field_a': 123}) assert m.field_a == 123 @@ -290,7 +288,7 @@ def f(input_value_and_fields_set: tuple[dict[str, Any], set[str]]): ), ) - v = SchemaValidator(schema) + v = SchemaValidator(schema=schema) m = v.validate_python({'field_a': 123}) assert m.field_a == 123 @@ -317,18 +315,16 @@ def f(input_value, info): return input_value SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { + schema=core_schema.model_schema( + cls=MyModel, + schema={ 'type': f'function-{mode}', 'function': {'type': 'with-info', 'function': f}, - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, + 'schema': core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} + ), }, - } + ) ) @@ -339,7 +335,9 @@ class MyModel: def f(input_value): return input_value, {1: 2}, {'field_a'} - v = SchemaValidator({'type': 'model', 'cls': MyModel, 'schema': core_schema.no_info_plain_validator_function(f)}) + v = SchemaValidator( + schema=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'} @@ -352,17 +350,19 @@ class MyModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'union', - 'choices': [ - {'type': 'model-fields', 'fields': {'foo': {'type': 'model-field', 'schema': {'type': 'int'}}}}, - {'type': 'model-fields', 'fields': {'bar': {'type': 'model-field', 'schema': {'type': 'int'}}}}, - ], - }, - } + schema=core_schema.model_schema( + cls=MyModel, + schema=core_schema.union_schema( + choices=[ + core_schema.model_fields_schema( + fields={'foo': core_schema.model_field(schema=core_schema.int_schema())} + ), + core_schema.model_fields_schema( + fields={'bar': core_schema.model_field(schema=core_schema.int_schema())} + ), + ] + ), + ) ) m = v.validate_python({'foo': '123'}) assert isinstance(m, MyModel) @@ -379,33 +379,28 @@ class MyModel: pass v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'tagged-union', - 'discriminator': 'foo', - 'choices': { - 'apple': { - 'type': 'model-fields', - 'fields': { - 'foo': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'bar': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - 'banana': { - 'type': 'model-fields', - 'fields': { - 'foo': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'spam': { - 'type': 'model-field', - 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}, - }, - }, - }, + schema=core_schema.model_schema( + cls=MyModel, + schema=core_schema.tagged_union_schema( + discriminator='foo', + choices={ + 'apple': core_schema.model_fields_schema( + fields={ + 'foo': core_schema.model_field(schema=core_schema.str_schema()), + 'bar': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + 'banana': core_schema.model_fields_schema( + fields={ + 'foo': core_schema.model_field(schema=core_schema.str_schema()), + 'spam': core_schema.model_field( + schema=core_schema.list_schema(items_schema=core_schema.int_schema()) + ), + } + ), }, - }, - } + ), + ) ) m = v.validate_python({'foo': 'apple', 'bar': '123'}) assert isinstance(m, MyModel) @@ -433,7 +428,7 @@ def test_bad_sub_schema(): class MyModel: pass - v = SchemaValidator({'type': 'model', 'cls': MyModel, 'schema': {'type': 'int'}}) + v = SchemaValidator(schema=core_schema.model_schema(cls=MyModel, schema=core_schema.int_schema())) with pytest.raises(TypeError): v.validate_python(123) @@ -447,18 +442,16 @@ def f(input_value, info): return input_value v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { + schema=core_schema.model_schema( + cls=MyModel, + schema={ 'type': 'function-after', 'function': {'type': 'with-info', 'function': f}, - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, + 'schema': core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} + ), }, - } + ) ) m = v.validate_python({'field_a': 'test'}) assert isinstance(m, MyModel) @@ -469,14 +462,12 @@ def f(input_value, info): def test_model_class_not_type(): with pytest.raises(SchemaError, match=re.escape("TypeError: 'int' object cannot be converted to 'PyType'")): SchemaValidator( - { - 'type': 'model', - 'cls': 123, - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, - } + schema=core_schema.model_schema( + cls=123, + schema=core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} + ), + ) ) @@ -489,14 +480,12 @@ def __init__(self): self.field_a = 'init' v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, - } + 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())} + ), + ) ) m1 = v.validate_python({'field_a': 'test'}) assert isinstance(m1, MyModel) @@ -530,15 +519,13 @@ def __init__(self): self.field_b = 'init_b' v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, - 'post_init': 'model_post_init', - } + 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())} + ), + post_init='model_post_init', + ) ) m2 = MySubModel() @@ -579,16 +566,14 @@ def __init__(self): self.field_b = 'init_b' v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, - 'post_init': 'model_post_init', - 'revalidate_instances': 'always', - } + 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())} + ), + post_init='model_post_init', + revalidate_instances='always', + ) ) m2 = MySubModel() @@ -619,18 +604,16 @@ def __init__(self): self.field_b = 'init_b' v = SchemaValidator( - { - 'type': 'model', - 'strict': True, - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + schema=core_schema.model_schema( + strict=True, + cls=MyModel, + 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()), + } + ), + ) ) assert re.search(r'revalidate: \w+', repr(v)).group(0) == 'revalidate: Never' m = MyModel() @@ -666,22 +649,19 @@ class MyModel: field_c: int v = SchemaValidator( - { - 'type': 'model', - 'strict': True, - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'field_c': { - 'type': 'model-field', - 'schema': {'type': 'default', 'default': 42, 'schema': {'type': 'int'}}, - }, - }, - }, - } + schema=core_schema.model_schema( + strict=True, + cls=MyModel, + 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()), + 'field_c': core_schema.model_field( + schema=core_schema.with_default_schema(default=42, schema=core_schema.int_schema()) + ), + } + ), + ) ) m = v.validate_json('{"field_a": "foobar", "field_b": "123"}') assert isinstance(m, MyModel) @@ -693,11 +673,12 @@ class MyModel: def test_internal_error(): v = SchemaValidator( - { - 'type': 'model', - 'cls': int, - 'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'int'}}}}, - } + schema=core_schema.model_schema( + cls=int, + schema=core_schema.model_fields_schema( + fields={'f': core_schema.model_field(schema=core_schema.int_schema())} + ), + ) ) with pytest.raises(AttributeError, match=re.escape("'int' object has no attribute '__dict__'")): v.validate_python({'f': 123}) @@ -715,18 +696,16 @@ def __init__(self, a, b, fields_set): self.__pydantic_fields_set__ = fields_set v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'revalidate_instances': 'always', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + schema=core_schema.model_schema( + cls=MyModel, + revalidate_instances='always', + 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()), + } + ), + ) ) assert re.search(r'revalidate: \w+', repr(v)).group(0) == 'revalidate: Always' @@ -773,18 +752,16 @@ def __init__(self): self.field_c = 'init_c' v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'revalidate_instances': 'subclass-instances', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + schema=core_schema.model_schema( + cls=MyModel, + revalidate_instances='subclass-instances', + 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()), + } + ), + ) ) m1 = MyModel() @@ -816,19 +793,17 @@ def __init__(self, **kwargs): self.__dict__.update(kwargs) v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'extra_behavior': 'allow', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, + schema=core_schema.model_schema( + cls=MyModel, + schema=core_schema.model_fields_schema( + extra_behavior='allow', + fields={ + 'field_a': core_schema.model_field(schema=core_schema.str_schema()), + 'field_b': core_schema.model_field(schema=core_schema.int_schema()), }, - }, - 'config': {'revalidate_instances': 'always'}, - } + ), + config=CoreConfig(revalidate_instances='always'), + ) ) m = v.validate_python({'field_a': 'test', 'field_b': 12, 'more': (1, 2, 3)}) @@ -867,18 +842,16 @@ def call_me_maybe(self, *args): assert self.__pydantic_fields_set__ == {'field_a', 'field_b'} v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'post_init': 'call_me_maybe', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + schema=core_schema.model_schema( + cls=MyModel, + post_init='call_me_maybe', + 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()), + } + ), + ) ) m = v.validate_python({'field_a': 'test', 'field_b': 12}) assert isinstance(m, MyModel) @@ -897,19 +870,17 @@ def call_me_maybe(self, context): assert context is None v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'post_init': 'call_me_maybe', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - 'config': {'revalidate_instances': 'always'}, - } + schema=core_schema.model_schema( + cls=MyModel, + post_init='call_me_maybe', + 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()), + } + ), + config=CoreConfig(revalidate_instances='always'), + ) ) assert re.search(r'revalidate: \w+', repr(v)).group(0) == 'revalidate: Always' @@ -943,15 +914,13 @@ def call_me_maybe(self, context, **kwargs): raise ValueError(f'this is broken: {self.field_a}') v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'post_init': 'call_me_maybe', - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, - } + schema=core_schema.model_schema( + cls=MyModel, + post_init='call_me_maybe', + schema=core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} + ), + ) ) m = v.validate_python({'field_a': 'test'}) assert isinstance(m, MyModel) @@ -979,15 +948,13 @@ def wrong_signature(self): pass v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'post_init': 'wrong_signature', - 'schema': { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - }, - } + schema=core_schema.model_schema( + cls=MyModel, + post_init='wrong_signature', + schema=core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())} + ), + ) ) with pytest.raises(TypeError, match=r'wrong_signature\(\) takes 1 positional argument but 2 were given'): v.validate_python({'field_a': 'test'}) @@ -1004,18 +971,16 @@ def call_me_maybe(self, context, **kwargs): self.__pydantic_fields_set__ = {'field_a'} v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'post_init': 'call_me_maybe', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + schema=core_schema.model_schema( + cls=MyModel, + post_init='call_me_maybe', + 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()), + } + ), + ) ) m = v.validate_python({'field_a': 'test', 'field_b': 12}) assert isinstance(m, MyModel) @@ -1036,7 +1001,7 @@ def __init__(self): self.__pydantic_extra__ = None v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1085,7 +1050,7 @@ def func(x, info): return x * 2 v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1125,17 +1090,15 @@ def __init__(self): self.__pydantic_extra__ = None v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + 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()), + 'field_b': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + ) ) m = MyModel() @@ -1159,7 +1122,7 @@ class MyModel: __slots__ = {'__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'} v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema({'f': core_schema.model_field(core_schema.str_schema())}), frozen=True, @@ -1228,7 +1191,7 @@ def f(values_or_values_and_fields_set: Any, *args: Any) -> Any: return values_or_values_and_fields_set v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, function_schema( f, @@ -1265,7 +1228,7 @@ class MyModel: field_b: int v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( MyModel, core_schema.model_fields_schema( { @@ -1353,7 +1316,7 @@ class MyModel: # WHEN v = SchemaValidator( - core_schema.model_schema( + 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 491a3baf8..08b42e074 100644 --- a/tests/validators/test_model_fields.py +++ b/tests/validators/test_model_fields.py @@ -42,13 +42,12 @@ def __repr__(self): def test_simple(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) assert v.validate_python({'field_a': b'abc', 'field_b': 1}) == ( @@ -67,7 +66,7 @@ def test_strict(): 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, }, }, - {'strict': True}, + CoreConfig(strict=True), ) assert v.validate_python({'field_a': 'hello', 'field_b': 12}) == ( @@ -86,16 +85,14 @@ def test_strict(): def test_with_default(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 666}, - }, - }, - } + 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.with_default_schema(schema=core_schema.int_schema(), default=666) + ), + } + ) ) assert v.validate_python({'field_a': b'abc'}) == ({'field_a': 'abc', 'field_b': 666}, None, {'field_a'}) @@ -108,13 +105,12 @@ def test_with_default(): def test_missing_error(pydantic_version): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) with pytest.raises(ValidationError) as exc_info: v.validate_python({'field_a': b'abc'}) @@ -135,17 +131,21 @@ def test_missing_error(pydantic_version): ({}, Map(a=123), ({'a': 123, 'b': 4.2}, None, {'a'})), ({}, {b'a': '123'}, Err('Field required [type=missing,')), ({}, {'a': '123', 'c': 4}, ({'a': 123, 'b': 4.2}, None, {'a'})), - ({'extra_fields_behavior': 'allow'}, {'a': '123', 'c': 4}, ({'a': 123, 'b': 4.2}, {'c': 4}, {'a', 'c'})), - ({'extra_fields_behavior': 'allow'}, {'a': '123', b'c': 4}, Err('Keys should be strings [type=invalid_key,')), + (CoreConfig(extra_fields_behavior='allow'), {'a': '123', 'c': 4}, ({'a': 123, 'b': 4.2}, {'c': 4}, {'a', 'c'})), ( - {'strict': True}, + CoreConfig(extra_fields_behavior='allow'), + {'a': '123', b'c': 4}, + Err('Keys should be strings [type=invalid_key,'), + ), + ( + CoreConfig(strict=True), Map(a=123), Err('Input should be a valid dictionary or instance of Model [type=model_type,'), ), ({}, {'a': '123', 'b': '4.7'}, ({'a': 123, 'b': 4.7}, None, {'a', 'b'})), ({}, {'a': '123', 'b': 'nan'}, ({'a': 123, 'b': FunctionCheck(math.isnan)}, None, {'a', 'b'})), ( - {'allow_inf_nan': False}, + CoreConfig(allow_inf_nan=False), {'a': '123', 'b': 'nan'}, Err('Input should be a finite number [type=finite_number,'), ), @@ -154,17 +154,15 @@ def test_missing_error(pydantic_version): ) def test_config(config: CoreConfig, input_value, expected): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'float'}, 'default': 4.2}, - }, - }, - }, - config, + 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.with_default_schema(schema=core_schema.float_schema(), default=4.2) + ), + } + ), + config=config, ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -177,13 +175,12 @@ def test_config(config: CoreConfig, input_value, expected): def test_ignore_extra(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) assert v.validate_python({'field_a': b'123', 'field_b': 1, 'field_c': 123}) == ( @@ -195,11 +192,9 @@ def test_ignore_extra(): def test_forbid_extra(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - 'extra_behavior': 'forbid', - } + schema=core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}, extra_behavior='forbid' + ) ) with pytest.raises(ValidationError) as exc_info: @@ -213,19 +208,25 @@ def test_forbid_extra(): def test_allow_extra_invalid(): with pytest.raises(SchemaError, match='extras_schema can only be used if extra_behavior=allow'): SchemaValidator( - {'type': 'model-fields', 'fields': {}, 'extras_schema': {'type': 'int'}, 'extra_behavior': 'ignore'} + schema=core_schema.model_fields_schema( + fields={}, extras_schema=core_schema.int_schema(), extra_behavior='ignore' + ) ) def test_allow_extra_wrong(): with pytest.raises(SchemaError, match='Invalid extra_behavior: `wrong`'): - SchemaValidator({'type': 'model-fields', 'fields': {}}, {'extra_fields_behavior': 'wrong'}) + SchemaValidator( + schema=core_schema.model_fields_schema(fields={}), config=CoreConfig(extra_fields_behavior='wrong') + ) def test_str_config(): v = SchemaValidator( - {'type': 'model-fields', 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}}, - {'str_max_length': 5}, + 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'}) @@ -235,7 +236,9 @@ def test_str_config(): def test_validate_assignment(): v = SchemaValidator( - {'type': 'model-fields', 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': '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'}) @@ -247,10 +250,9 @@ def test_validate_assignment(): def test_validate_assignment_strict_field(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str', 'strict': True}}}, - } + schema=core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema(strict=True))} + ) ) assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'}) @@ -274,27 +276,24 @@ def func_b(input_value, info): return input_value / 2 v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': { - 'type': 'model-field', - 'schema': { + schema=core_schema.model_fields_schema( + fields={ + 'field_a': core_schema.model_field( + schema={ 'type': 'function-after', 'function': {'type': 'with-info', 'function': func_a}, - 'schema': {'type': 'str'}, - }, - }, - 'field_b': { - 'type': 'model-field', - 'schema': { + 'schema': core_schema.str_schema(), + } + ), + 'field_b': core_schema.model_field( + schema={ 'type': 'function-after', 'function': {'type': 'with-info', 'function': func_b}, - 'schema': {'type': 'int'}, - }, - }, - }, - } + 'schema': core_schema.int_schema(), + } + ), + } + ) ) assert v.validate_python({'field_a': 'test', 'field_b': 12.0}) == ( @@ -316,7 +315,9 @@ def func_b(input_value, info): def test_validate_assignment_ignore_extra(): v = SchemaValidator( - {'type': 'model-fields', 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': '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'}) @@ -338,11 +339,9 @@ def test_validate_assignment_ignore_extra(): def test_validate_assignment_allow_extra(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - 'extra_behavior': 'allow', - } + schema=core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}, extra_behavior='allow' + ) ) assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, {}, {'field_a'}) @@ -356,12 +355,11 @@ def test_validate_assignment_allow_extra(): def test_validate_assignment_allow_extra_validate(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}, - 'extras_schema': {'type': 'int'}, - 'extra_behavior': 'allow', - } + 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', + ) ) assert v.validate_assignment({'field_a': 'test'}, 'other_field', '456') == ( @@ -384,13 +382,12 @@ def test_validate_assignment_allow_extra_validate(): def test_validate_assignment_with_strict(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'x': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'y': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) r, model_extra, fields_set = v.validate_python({'x': 'a', 'y': '123'}) @@ -411,10 +408,13 @@ def test_validate_assignment_with_strict(): def test_json_error(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}}}, - } + schema=core_schema.model_fields_schema( + fields={ + 'field_a': core_schema.model_field( + schema=core_schema.list_schema(items_schema=core_schema.int_schema()) + ) + } + ) ) with pytest.raises(ValidationError) as exc_info: v.validate_json('{"field_a": [123, "wrong"]}') @@ -437,13 +437,12 @@ def test_missing_schema_key(): def test_fields_required_by_default(): """By default all fields should be required""" v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'x': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'y': {'type': 'model-field', 'schema': {'type': 'str'}}, - }, - } + 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()), + } + ) ) assert v.validate_python({'x': 'pika', 'y': 'chu'}) == ({'x': 'pika', 'y': 'chu'}, None, {'x', 'y'}) @@ -458,16 +457,14 @@ def test_fields_required_by_default(): def test_fields_required_by_default_with_default(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'x': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'y': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'bulbi'}, - }, - }, - } + 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.with_default_schema(schema=core_schema.str_schema(), default='bulbi') + ), + } + ) ) assert v.validate_python({'x': 'pika', 'y': 'chu'}) == ({'x': 'pika', 'y': 'chu'}, None, {'x', 'y'}) @@ -611,11 +608,10 @@ def test_aliases_path_multiple(py_and_json: PyAndJson, input_value, expected): ) def test_aliases_path_negative(input_value, expected): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'field_a': {'validation_alias': ['foo', -2], 'type': 'model-field', 'schema': {'type': 'int'}}}, - }, - {'loc_by_alias': False}, + 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), ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=expected.message): @@ -653,16 +649,13 @@ def test_aliases_path_negative_json(py_and_json: PyAndJson, input_value, expecte def test_aliases_debug(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': { - 'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3]], - 'type': 'model-field', - 'schema': {'type': 'int'}, - } - }, - } + 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() + ) + } + ) ) print(repr(v)) assert repr(v).startswith('SchemaValidator(title="model-fields", validator=ModelFields(') @@ -671,16 +664,13 @@ def test_aliases_debug(): def get_int_key(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': { - 'validation_alias': [['foo', 3], ['spam']], - 'type': 'model-field', - 'schema': {'type': 'int'}, - } - }, - } + schema=core_schema.model_fields_schema( + fields={ + 'field_a': core_schema.model_field( + validation_alias=[['foo', 3], ['spam']], schema=core_schema.int_schema() + ) + } + ) ) assert v.validate_python({'foo': {3: 33}}) == ({'field_a': 33}, {}, {'field_a'}) @@ -693,10 +683,9 @@ def __getitem__(self, v): def get_custom_getitem(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'field_a': {'validation_alias': ['foo'], 'type': 'model-field', 'schema': {'type': 'int'}}}, - } + schema=core_schema.model_fields_schema( + fields={'field_a': core_schema.model_field(validation_alias=['foo'], schema=core_schema.int_schema())} + ) ) assert v.validate_python(GetItemThing()) == ({'field_a': 321}, {}, {'field_a'}) assert v.validate_python({'bar': GetItemThing()}) == ({'field_a': 321}, {}, {'field_a'}) @@ -735,7 +724,7 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value): def test_alias_build_error(alias_schema, error): with pytest.raises(SchemaError, match=error): SchemaValidator( - validate_core_schema( + schema=validate_core_schema( { 'type': 'model-fields', 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'int'}, **alias_schema}}, @@ -838,7 +827,7 @@ def test_alias_error_loc_field_names(py_and_json: PyAndJson): def test_empty_model(): - v = SchemaValidator({'type': 'model-fields', 'fields': {}}) + v = SchemaValidator(schema=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,') @@ -848,31 +837,26 @@ def test_empty_model(): def test_model_fields_deep(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': { - 'type': 'model-field', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_c': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_d': { - 'type': 'model-field', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_e': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_f': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - }, - }, - }, - }, - }, - } + 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.model_fields_schema( + fields={ + 'field_c': core_schema.model_field(schema=core_schema.str_schema()), + 'field_d': core_schema.model_field( + schema=core_schema.model_fields_schema( + fields={ + 'field_e': core_schema.model_field(schema=core_schema.str_schema()), + 'field_f': core_schema.model_field(schema=core_schema.int_schema()), + } + ) + ), + } + ) + ), + } + ) ) model_dict, model_extra, fields_set = v.validate_python( {'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 4}}} @@ -943,15 +927,14 @@ class MyDataclass: @pytest.mark.parametrize('from_attributes_mode', ['schema', 'validation']) def test_from_attributes(input_value, expected, from_attributes_mode): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'c': {'type': 'model-field', 'schema': {'type': 'str'}}, + 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()), + 'c': core_schema.model_field(schema=core_schema.str_schema()), }, - 'from_attributes': from_attributes_mode == 'schema', - } + from_attributes=from_attributes_mode == 'schema', + ) ) kwargs = {} if from_attributes_mode == 'validation': @@ -967,16 +950,15 @@ def test_from_attributes(input_value, expected, from_attributes_mode): def test_from_attributes_type_error(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'c': {'type': 'model-field', 'schema': {'type': 'str'}}, + 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()), + 'c': core_schema.model_field(schema=core_schema.str_schema()), }, - 'from_attributes': True, - 'model_name': 'MyModel', - } + from_attributes=True, + model_name='MyModel', + ) ) with pytest.raises(ValidationError) as exc_info: v.validate_python('123') @@ -1006,12 +988,11 @@ def test_from_attributes_type_error(): def test_from_attributes_by_name(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}, 'validation_alias': 'a_alias'}}, - 'from_attributes': True, - 'populate_by_name': True, - } + 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, + ) ) assert v.validate_python(Cls(a_alias=1)) == ({'a': 1}, None, {'a'}) assert v.validate_python(Cls(a=1)) == ({'a': 1}, None, {'a'}) @@ -1019,11 +1000,9 @@ def test_from_attributes_by_name(): def test_from_attributes_override_true(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}}, - 'from_attributes': False, - } + schema=core_schema.model_fields_schema( + fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=False + ) ) with pytest.raises(ValidationError, match='Input should be a valid dictionary'): v.validate_python(Cls(a=1)) @@ -1035,11 +1014,9 @@ def test_from_attributes_override_true(): def test_from_attributes_override_false(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}}, - 'from_attributes': True, - } + schema=core_schema.model_fields_schema( + fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True + ) ) with pytest.raises(ValidationError, match='Input should be a valid dictionary'): v.validate_python(Cls(a=1), from_attributes=False) @@ -1056,15 +1033,14 @@ def __init__(self): self.b = 2 v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'c': {'type': 'model-field', 'schema': {'type': 'str'}}, + 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()), + 'c': core_schema.model_field(schema=core_schema.str_schema()), }, - 'from_attributes': True, - } + from_attributes=True, + ) ) with pytest.raises(ValidationError) as exc_info: @@ -1090,14 +1066,13 @@ def b(self): raise RuntimeError('intentional error') v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'int'}}, + 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()), }, - 'from_attributes': True, - } + from_attributes=True, + ) ) with pytest.raises(ValidationError) as exc_info: @@ -1158,12 +1133,11 @@ class MyDataclass: _d: int = 4 v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}}, - 'from_attributes': True, - 'extra_behavior': 'allow', - } + schema=core_schema.model_fields_schema( + fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, + from_attributes=True, + extra_behavior='allow', + ) ) assert v.validate_python(Foobar()) == ({'a': 1}, {}, {'a'}) @@ -1175,12 +1149,11 @@ class MyDataclass: def test_from_attributes_extra_ignore_no_attributes_accessed() -> None: v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}}, - 'from_attributes': True, - 'extra_behavior': 'ignore', - } + schema=core_schema.model_fields_schema( + fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, + from_attributes=True, + extra_behavior='ignore', + ) ) accessed: list[str] = [] @@ -1203,12 +1176,11 @@ class Source: b = 2 v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}}, - 'from_attributes': True, - 'extra_behavior': 'forbid', - } + schema=core_schema.model_fields_schema( + fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, + from_attributes=True, + extra_behavior='forbid', + ) ) assert v.validate_python(Source()) == ({'a': 1}, None, {'a'}) @@ -1231,11 +1203,9 @@ def foobar(): ) def test_from_attributes_function(input_value, expected): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'a': {'type': 'model-field', 'schema': {'type': 'any'}}}, - 'from_attributes': True, - } + schema=core_schema.model_fields_schema( + fields={'a': core_schema.model_field(schema=core_schema.any_schema())}, from_attributes=True + ) ) model_dict, model_extra, fields_set = v.validate_python(input_value) @@ -1255,11 +1225,9 @@ def x(self): raise BadError('intentional error') v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': {'x': {'type': 'model-field', 'schema': {'type': 'int'}}}, - 'from_attributes': True, - } + schema=core_schema.model_fields_schema( + fields={'x': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True + ) ) with pytest.raises(ValidationError) as exc_info: @@ -1314,18 +1282,15 @@ def x(self): ) def test_from_attributes_path(input_value, expected): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'my_field': { - 'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3], ['spam']], - 'type': 'model-field', - 'schema': {'type': 'int'}, - } + 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() + ) }, - 'from_attributes': True, - }, - {'loc_by_alias': False}, + from_attributes=True, + ), + config=CoreConfig(loc_by_alias=False), ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=expected.message): @@ -1345,17 +1310,14 @@ def foo(self): raise RuntimeError('intentional error') v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'my_field': { - 'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3], ['spam']], - 'type': 'model-field', - 'schema': {'type': 'int'}, - } + 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() + ) }, - 'from_attributes': True, - } + from_attributes=True, + ) ) with pytest.raises(ValidationError) as exc_info: v.validate_python(PropertyError()) @@ -1405,18 +1367,15 @@ def test_alias_extra(py_and_json: PyAndJson): def test_alias_extra_from_attributes(): v = SchemaValidator( - { - 'type': 'model-fields', - 'extra_behavior': 'allow', - 'from_attributes': True, - 'fields': { - 'field_a': { - 'validation_alias': [['FieldA'], ['foo', 2]], - 'type': 'model-field', - 'schema': {'type': 'int'}, - } + schema=core_schema.model_fields_schema( + extra_behavior='allow', + from_attributes=True, + fields={ + 'field_a': core_schema.model_field( + validation_alias=[['FieldA'], ['foo', 2]], schema=core_schema.int_schema() + ) }, - } + ) ) assert v.validate_python({'FieldA': 1}) == ({'field_a': 1}, {}, {'field_a'}) assert v.validate_python(Cls(FieldA=1)) == ({'field_a': 1}, {}, {'field_a'}) @@ -1453,15 +1412,15 @@ def test_alias_extra_forbid(py_and_json: PyAndJson): def test_with_default_factory(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'x': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda: 'pikachu'}, - } - }, - } + schema=core_schema.model_fields_schema( + fields={ + 'x': core_schema.model_field( + schema=core_schema.with_default_schema( + schema=core_schema.str_schema(), default_factory=lambda: 'pikachu' + ) + ) + } + ) ) assert v.validate_python({}) == ({'x': 'pikachu'}, None, set()) @@ -1477,15 +1436,15 @@ def test_with_default_factory(): ) def test_bad_default_factory(default_factory, error_message): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'x': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': default_factory}, - } - }, - } + schema=core_schema.model_fields_schema( + fields={ + 'x': core_schema.model_field( + schema=core_schema.with_default_schema( + schema=core_schema.str_schema(), default_factory=default_factory + ) + ) + } + ) ) with pytest.raises(TypeError, match=re.escape(error_message)): v.validate_python({}) @@ -1509,15 +1468,13 @@ def test_on_error_bad_name(self): def test_on_error_bad_default(self): with pytest.raises(SchemaError, match="'on_error = default' requires a `default` or `default_factory`"): SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'x': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'default'}, - } - }, - } + schema=core_schema.model_fields_schema( + fields={ + 'x': core_schema.model_field( + schema=core_schema.with_default_schema(schema=core_schema.str_schema(), on_error='default') + ) + } + ) ) def test_on_error_raise_by_default(self, py_and_json: PyAndJson): @@ -1625,18 +1582,15 @@ def wrap_function(input_value, validator, info): def test_frozen_field(): v = SchemaValidator( - { - 'type': 'model-fields', - 'fields': { - 'name': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'age': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'is_developer': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'bool'}, 'default': True}, - 'frozen': True, - }, - }, - } + 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()), + 'is_developer': core_schema.model_field( + schema=core_schema.with_default_schema(schema=core_schema.bool_schema(), default=True), frozen=True + ), + } + ) ) r1, model_extra, fields_set = v.validate_python({'name': 'Samuel', 'age': '36'}) assert r1 == {'name': 'Samuel', 'age': 36, 'is_developer': True} @@ -1655,7 +1609,7 @@ def test_frozen_field(): 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), - (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': None}), + (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), (core_schema.CoreConfig(), {'extra_behavior': 'allow'}), (None, {'extra_behavior': 'allow'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'allow'}), @@ -1663,7 +1617,7 @@ def test_frozen_field(): ) @pytest.mark.parametrize( 'extras_schema_kw, expected_extra_value', - [({}, '123'), ({'extras_schema': None}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], + [({}, '123'), ({}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], ids=['extras_schema=unset', 'extras_schema=None', 'extras_schema=int'], ) def test_extra_behavior_allow( @@ -1673,7 +1627,7 @@ def test_extra_behavior_allow( expected_extra_value: Any, ): v = SchemaValidator( - core_schema.model_fields_schema( + schema=core_schema.model_fields_schema( {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw, **extras_schema_kw ), config=config, @@ -1697,7 +1651,7 @@ def test_extra_behavior_allow( 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), - (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': None}), + (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), (core_schema.CoreConfig(), {'extra_behavior': 'forbid'}), (None, {'extra_behavior': 'forbid'}), (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'forbid'}), @@ -1705,7 +1659,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( - core_schema.model_fields_schema( + schema=core_schema.model_fields_schema( {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw ), config=config, @@ -1746,13 +1700,13 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche (None, {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(), {}), - (core_schema.CoreConfig(), {'extra_behavior': None}), - (None, {'extra_behavior': None}), + (core_schema.CoreConfig(), {}), + (None, {}), ], ) def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): v = SchemaValidator( - core_schema.model_fields_schema( + 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 f1226265a..a6240e42a 100644 --- a/tests/validators/test_model_init.py +++ b/tests/validators/test_model_init.py @@ -18,17 +18,15 @@ class MyModel: def test_model_init(): v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - } + 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()), + 'field_b': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + ) ) m = v.validate_python({'field_a': 'test', 'field_b': 12}) assert isinstance(m, MyModel) @@ -50,30 +48,25 @@ class MyModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': { - 'type': 'model-field', - 'schema': { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'x_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'x_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - }, - }, - }, - }, - } + 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()), + 'field_b': core_schema.model_field( + schema=core_schema.model_schema( + cls=MyModel, + schema=core_schema.model_fields_schema( + fields={ + 'x_a': core_schema.model_field(schema=core_schema.str_schema()), + 'x_b': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + ) + ), + } + ), + ) ) m = v.validate_python({'field_a': 'test', 'field_b': {'x_a': 'foo', 'x_b': 12}}) assert isinstance(m, MyModel) @@ -99,20 +92,18 @@ def f(input_value, _info): return input_value v = SchemaValidator( - { + schema={ 'type': 'function-before', 'function': {'type': 'with-info', 'function': f}, - 'schema': { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - }, + '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()), + 'field_b': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + ), } ) @@ -135,20 +126,18 @@ def f(input_value, _info): return input_value v = SchemaValidator( - { + schema={ 'type': 'function-after', 'function': {'type': 'with-info', 'function': f}, - 'schema': { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - }, + '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()), + 'field_b': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + ), } ) @@ -173,20 +162,18 @@ def f(input_value, handler, _info): return v v = SchemaValidator( - { + schema={ 'type': 'function-wrap', 'function': {'type': 'with-info', 'function': f}, - 'schema': { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - }, + '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()), + 'field_b': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + ), } ) @@ -202,7 +189,7 @@ def f(input_value, handler, _info): def test_simple(): - v = SchemaValidator({'type': 'str'}) + v = SchemaValidator(schema=core_schema.str_schema()) assert v.validate_python(b'abc') == 'abc' assert v.isinstance_python(b'abc') is True @@ -226,7 +213,7 @@ def __init__(self, **kwargs): self.c = self.a + 2 v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema( { @@ -283,7 +270,7 @@ def __init__(self, **data): ), custom_init=True, ) - ModelInner.__pydantic_validator__ = SchemaValidator(inner_schema) + ModelInner.__pydantic_validator__ = SchemaValidator(schema=inner_schema) class ModelOuter: __slots__ = '__dict__', '__pydantic_fields_set__' @@ -295,7 +282,7 @@ def __init__(self, **data): self.__pydantic_validator__.validate_python(data, self_instance=self) ModelOuter.__pydantic_validator__ = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( ModelOuter, core_schema.model_fields_schema( { @@ -343,7 +330,7 @@ def __init__(self, **data): config=CoreConfig(extra_fields_behavior='allow'), custom_init=True, ) - ModelInner.__pydantic_validator__ = SchemaValidator(inner_schema) + ModelInner.__pydantic_validator__ = SchemaValidator(schema=inner_schema) class ModelOuter: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' @@ -359,7 +346,7 @@ def __init__(self, **data): calls.append(('outer', self.__dict__, self.__pydantic_fields_set__, self.__pydantic_extra__)) ModelOuter.__pydantic_validator__ = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( ModelOuter, core_schema.model_fields_schema( { @@ -400,7 +387,7 @@ def __init__(self, **kwargs): self.__pydantic_extra__ = None v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( Model, core_schema.model_fields_schema({'a': core_schema.model_field(core_schema.int_schema())}), custom_init=True, @@ -465,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(model_schema) + Model.__pydantic_validator__ = SchemaValidator(schema=model_schema) return Model @@ -517,7 +504,7 @@ def __init__(self, **kwargs): ], } - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=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 4e0a55048..5098a31d2 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( - core_schema.model_schema(RootModel, core_schema.list_schema(core_schema.int_schema()), root_model=True) + schema=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( - core_schema.model_schema( + 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( - core_schema.model_schema( + schema=core_schema.model_schema( RootModel, core_schema.with_default_schema(core_schema.int_schema(), default=42), root_model=True, @@ -86,7 +86,9 @@ class RootModel: root: str v = SchemaValidator( - core_schema.model_schema(RootModel, core_schema.str_schema(), root_model=True, revalidate_instances='always') + schema=core_schema.model_schema( + RootModel, core_schema.str_schema(), root_model=True, revalidate_instances='always' + ) ) m = RootModel() @@ -100,7 +102,7 @@ class RootModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' root: str - v = SchemaValidator(core_schema.model_schema(RootModel, core_schema.str_schema(), root_model=True)) + v = SchemaValidator(schema=core_schema.model_schema(RootModel, core_schema.str_schema(), root_model=True)) m = v.validate_python('foobar') assert m.root == 'foobar' @@ -136,7 +138,7 @@ def f(input_value: str, info): return input_value + ' validated' v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( RootModel, core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='root'), root_model=True, @@ -161,7 +163,7 @@ class RootModel: __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' root: int - v = SchemaValidator(core_schema.model_schema(RootModel, core_schema.int_schema(), root_model=True)) + v = SchemaValidator(schema=core_schema.model_schema(RootModel, core_schema.int_schema(), root_model=True)) m = v.validate_python(1) @@ -177,7 +179,7 @@ class RootModel: root: int = 42 v = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( RootModel, core_schema.with_default_schema(core_schema.int_schema(), default=42), root_model=True ) ) @@ -202,7 +204,7 @@ class Model: value: RootModel = 42 v = SchemaValidator( - core_schema.model_schema( + 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 3a9640e82..088db58c6 100644 --- a/tests/validators/test_none.py +++ b/tests/validators/test_none.py @@ -1,10 +1,11 @@ import pytest from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import core_schema as cs def test_python_none(): - v = SchemaValidator({'type': 'none'}) + v = SchemaValidator(schema=cs.none_schema()) assert v.validate_python(None) is None with pytest.raises(ValidationError) as exc_info: v.validate_python(1) @@ -14,7 +15,7 @@ def test_python_none(): def test_json_none(): - v = SchemaValidator({'type': 'none'}) + v = SchemaValidator(schema=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 451559c76..b78abd9ba 100644 --- a/tests/validators/test_nullable.py +++ b/tests/validators/test_nullable.py @@ -9,7 +9,7 @@ def test_nullable(): - v = SchemaValidator({'type': 'nullable', 'schema': {'type': 'int'}}) + v = SchemaValidator(schema=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,13 +27,12 @@ def test_nullable(): def test_union_nullable_bool_int(): v = SchemaValidator( - { - 'type': 'union', - 'choices': [ - {'type': 'nullable', 'schema': {'type': 'bool'}}, - {'type': 'nullable', 'schema': {'type': 'int'}}, - ], - } + schema=core_schema.union_schema( + choices=[ + core_schema.nullable_schema(schema=core_schema.bool_schema()), + core_schema.nullable_schema(schema=core_schema.int_schema()), + ] + ) ) assert v.validate_python(None) is None assert v.validate_python(True) is True @@ -54,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) + validate.__pydantic_validator__ = SchemaValidator(schema=schema) return validate diff --git a/tests/validators/test_pickling.py b/tests/validators/test_pickling.py index 2037ab8c9..362f911df 100644 --- a/tests/validators/test_pickling.py +++ b/tests/validators/test_pickling.py @@ -10,7 +10,7 @@ def test_basic_schema_validator(): v = SchemaValidator( - validate_core_schema( + 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( - core_schema.model_fields_schema({'f': core_schema.model_field(core_schema.str_schema())}), + 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(core_schema.datetime_schema()) + v = SchemaValidator(schema=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 df94a8e31..998ed793a 100644 --- a/tests/validators/test_set.py +++ b/tests/validators/test_set.py @@ -5,6 +5,7 @@ import pytest from pydantic_core import SchemaValidator, ValidationError +from pydantic_core import core_schema as cs from ..conftest import Err, PyAndJson, infinite_generator @@ -75,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({'type': 'set', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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) @@ -85,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({'type': 'set'}) + v = SchemaValidator(schema=cs.set_schema()) assert v.validate_python(input_value) == expected def test_set_multiple_errors(): - v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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) == [ @@ -106,7 +107,7 @@ def test_set_multiple_errors(): def test_list_with_unhashable_items(): - v = SchemaValidator({'type': 'set'}) + v = SchemaValidator(schema=cs.set_schema()) class Unhashable: __hash__ = None @@ -165,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({'type': 'set', **kwargs}) + v = SchemaValidator(schema=cs.set_schema(**kwargs)) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): r = v.validate_python(input_value) @@ -176,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({'type': 'union', 'choices': [{'type': 'set'}, {'type': 'list'}]}) + v = SchemaValidator(schema=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) @@ -214,13 +215,12 @@ def test_union_set_list(input_value, expected): ) def test_union_set_int_set_str(input_value, expected): v = SchemaValidator( - { - 'type': 'union', - 'choices': [ - {'type': 'set', 'items_schema': {'type': 'int', 'strict': True}}, - {'type': 'set', 'items_schema': {'type': 'str', 'strict': True}}, - ], - } + 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)), + ] + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: @@ -245,7 +245,7 @@ def gen(error: bool): raise RuntimeError('my error') yield 3 - v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}}) + v = SchemaValidator(schema=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({'type': 'set', 'items_schema': items_schema}) + v = SchemaValidator(schema=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({'type': 'set'}) + v = SchemaValidator(schema=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({'type': 'set', 'items_schema': {'type': 'int'}, 'fail_fast': fail_fast}) + v = SchemaValidator(schema=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 864125a47..9c86f0a8a 100644 --- a/tests/validators/test_string.py +++ b/tests/validators/test_string.py @@ -6,7 +6,7 @@ import pytest -from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema +from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema from ..conftest import Err, PyAndJson, plain_repr @@ -56,7 +56,7 @@ def test_str(py_and_json: PyAndJson, input_value, expected): ], ) def test_str_not_json(input_value, expected): - v = SchemaValidator({'type': 'str'}) + v = SchemaValidator(schema=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({'type': 'str', **kwargs}) + v = SchemaValidator(schema=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({'type': 'str', 'min_length': 1}) + v = SchemaValidator(schema=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({'type': 'str', 'max_length': max_length}) + v = SchemaValidator(schema=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({'type': 'str'}, {'str_max_length': 5}) + v = SchemaValidator(schema=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(core_schema.str_schema(pattern='(abc', regex_engine=engine)) + SchemaValidator(schema=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(core_schema.str_schema(pattern='11', regex_engine=engine)) + v = SchemaValidator(schema=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) == [ @@ -209,7 +209,9 @@ def test_regex_error(engine): def test_default_validator(): - v = SchemaValidator(core_schema.str_schema(strict=True, to_lower=False), {'str_strip_whitespace': False}) + v = SchemaValidator( + schema=core_schema.str_schema(strict=True, to_lower=False), config=CoreConfig(str_strip_whitespace=False) + ) assert ( plain_repr(v) == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:true,coerce_numbers_to_str:false}),definitions=[],cache_strings=True)' @@ -229,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(core_schema.str_schema(strict=True, to_lower=to_lower)) + v = SchemaValidator(schema=core_schema.str_schema(strict=True, to_lower=to_lower)) class StrSubclass(str): pass @@ -240,7 +242,7 @@ class StrSubclass(str): @pytest.mark.parametrize('kwargs', [{}, {'to_lower': True}], ids=repr) def test_lax_subclass(FruitEnum, kwargs): - v = SchemaValidator(core_schema.str_schema(**kwargs)) + v = SchemaValidator(schema=core_schema.str_schema(**kwargs)) assert v.validate_python('foobar') == 'foobar' assert v.validate_python(b'foobar') == 'foobar' p = v.validate_python(FruitEnum.pear) @@ -251,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(core_schema.str_schema(**kwargs)) + v = SchemaValidator(schema=core_schema.str_schema(**kwargs)) from enum import Enum @@ -268,7 +270,7 @@ def test_subclass_preserved() -> None: class StrSubclass(str): pass - v = SchemaValidator(core_schema.str_schema()) + v = SchemaValidator(schema=core_schema.str_schema()) assert not isinstance(v.validate_python(StrSubclass('')), StrSubclass) assert not isinstance(v.validate_python(StrSubclass(''), strict=True), StrSubclass) @@ -276,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(core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()])) + v = SchemaValidator(schema=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) @@ -286,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(core_schema.str_schema(strict=string), config) + v = SchemaValidator(schema=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(core_schema.str_schema(strict=True), config) + v = SchemaValidator(schema=core_schema.str_schema(strict=True), config=config) with pytest.raises(ValidationError): v.validate_python(42) with pytest.raises(ValidationError): @@ -303,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(core_schema.str_schema(), config) + v = SchemaValidator(schema=core_schema.str_schema(), config=config) with pytest.raises(ValidationError): v.validate_python(True) with pytest.raises(ValidationError): @@ -321,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(core_schema.str_schema(), config) + v = SchemaValidator(schema=core_schema.str_schema(), config=config) assert v.validate_python(number) == expected_str @@ -336,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(core_schema.str_schema(), config) + v = SchemaValidator(schema=core_schema.str_schema(), config=config) assert v.validate_json(number) == expected_str @@ -347,11 +349,13 @@ 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(core_schema.str_schema(pattern=pattern)) + SchemaValidator(schema=core_schema.str_schema(pattern=pattern)) elif mode == 'schema': - SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='rust-regex')) + SchemaValidator(schema=core_schema.str_schema(pattern=pattern, regex_engine='rust-regex')) elif mode == 'config': - SchemaValidator(core_schema.str_schema(pattern=pattern), core_schema.CoreConfig(regex_engine='rust-regex')) + SchemaValidator( + schema=core_schema.str_schema(pattern=pattern), config=core_schema.CoreConfig(regex_engine='rust-regex') + ) assert exc_info.value.args[0] == ( 'Error building "str" validator:\n' @@ -367,9 +371,11 @@ def test_backtracking_regex_python(mode) -> None: pattern = r'r(#*)".*?"\1' if mode == 'schema': - v = SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='python-re')) + v = SchemaValidator(schema=core_schema.str_schema(pattern=pattern, regex_engine='python-re')) elif mode == 'config': - v = SchemaValidator(core_schema.str_schema(pattern=pattern), core_schema.CoreConfig(regex_engine='python-re')) + v = SchemaValidator( + schema=core_schema.str_schema(pattern=pattern), config=core_schema.CoreConfig(regex_engine='python-re') + ) assert v.validate_python('r""') == 'r""' assert v.validate_python('r#""#') == 'r#""#' with pytest.raises(ValidationError): @@ -379,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(core_schema.str_schema(coerce_numbers_to_str=True)) + v = SchemaValidator(schema=core_schema.str_schema(coerce_numbers_to_str=True)) assert v.validate_python(number) == str(number) assert v.validate_json(str(number)) == str(number) @@ -387,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(core_schema.str_schema(coerce_numbers_to_str=True), config=config) + v = SchemaValidator(schema=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(core_schema.str_schema(coerce_numbers_to_str=False), config=config) + v = SchemaValidator(schema=core_schema.str_schema(coerce_numbers_to_str=False), config=config) with pytest.raises(ValidationError): v.validate_python(number) with pytest.raises(ValidationError): @@ -401,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(core_schema.str_schema(coerce_numbers_to_str=True, strict=True)) + v = SchemaValidator(schema=core_schema.str_schema(coerce_numbers_to_str=True, strict=True)) with pytest.raises(ValidationError): v.validate_python(number) with pytest.raises(ValidationError): @@ -410,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(core_schema.str_schema(pattern=re.compile('abc', re.IGNORECASE), regex_engine=engine)) + v = SchemaValidator(schema=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 3061b2c34..3950f3560 100644 --- a/tests/validators/test_tagged_union.py +++ b/tests/validators/test_tagged_union.py @@ -209,36 +209,31 @@ class PlainEnum(Enum): TWO = 'two' v = SchemaValidator( - { - 'type': 'tagged-union', - 'discriminator': 'foo', - 'choices': { - BarEnum.ONE: { - 'type': 'typed-dict', - 'fields': { - 'foo': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - 'bar': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - }, - FooEnum.BANANA: { - 'type': 'typed-dict', - 'fields': { - 'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'spam': { - 'type': 'typed-dict-field', - 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}, - }, - }, - }, - PlainEnum.TWO: { - 'type': 'typed-dict', - 'fields': { - 'foo': {'type': 'typed-dict-field', 'schema': {'type': 'any'}}, - 'baz': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - }, + schema=core_schema.tagged_union_schema( + discriminator='foo', + choices={ + BarEnum.ONE: core_schema.typed_dict_schema( + fields={ + 'foo': core_schema.typed_dict_field(schema=core_schema.int_schema()), + 'bar': core_schema.typed_dict_field(schema=core_schema.int_schema()), + } + ), + FooEnum.BANANA: core_schema.typed_dict_schema( + fields={ + 'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()), + 'spam': core_schema.typed_dict_field( + schema=core_schema.list_schema(items_schema=core_schema.int_schema()) + ), + } + ), + PlainEnum.TWO: core_schema.typed_dict_schema( + fields={ + 'foo': core_schema.typed_dict_field(schema=core_schema.any_schema()), + 'baz': core_schema.typed_dict_field(schema=core_schema.int_schema()), + } + ), }, - } + ) ) assert v.validate_python({'foo': FooEnum.BANANA, 'spam': [1, 2, '3']}) == {'foo': FooEnum.BANANA, 'spam': [1, 2, 3]} @@ -457,27 +452,24 @@ def discriminator_function(obj): def test_from_attributes(): v = SchemaValidator( - { - 'type': 'tagged-union', - 'discriminator': 'foobar', - 'choices': { - 'apple': { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - 'banana': { - 'type': 'model-fields', - 'fields': { - 'c': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'd': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, + schema=core_schema.tagged_union_schema( + discriminator='foobar', + choices={ + 'apple': core_schema.model_fields_schema( + fields={ + 'a': core_schema.model_field(schema=core_schema.str_schema()), + 'b': core_schema.model_field(schema=core_schema.int_schema()), + } + ), + 'banana': core_schema.model_fields_schema( + fields={ + 'c': core_schema.model_field(schema=core_schema.str_schema()), + 'd': core_schema.model_field(schema=core_schema.int_schema()), + } + ), }, - }, - {'from_attributes': True}, + ), + config=CoreConfig(from_attributes=True), ) assert v.validate_python({'foobar': 'apple', 'a': 'apple', 'b': '13'}) == ( {'a': 'apple', 'b': 13}, @@ -495,7 +487,7 @@ def test_from_attributes(): def test_use_ref(): v = SchemaValidator( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.tagged_union_schema( discriminator='foobar', choices={ @@ -516,7 +508,9 @@ def test_use_ref(): def test_downcast_error(): - v = SchemaValidator({'type': 'tagged-union', 'discriminator': lambda x: 123, 'choices': {'str': {'type': 'str'}}}) + v = SchemaValidator( + 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') assert exc_info.value.errors(include_url=False) == [ @@ -531,31 +525,27 @@ def test_downcast_error(): def test_custom_error(): v = SchemaValidator( - { - 'type': 'tagged-union', - 'discriminator': 'foo', - 'custom_error_type': 'snap', - 'custom_error_message': 'Input should be a foo or bar', - 'choices': { - 'apple': { - 'type': 'typed-dict', - 'fields': { - 'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'bar': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - }, - 'banana': { - 'type': 'typed-dict', - 'fields': { - 'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'spam': { - 'type': 'typed-dict-field', - 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}, - }, - }, - }, + schema=core_schema.tagged_union_schema( + discriminator='foo', + custom_error_type='snap', + custom_error_message='Input should be a foo or bar', + choices={ + 'apple': core_schema.typed_dict_schema( + fields={ + 'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()), + 'bar': core_schema.typed_dict_field(schema=core_schema.int_schema()), + } + ), + 'banana': core_schema.typed_dict_schema( + fields={ + 'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()), + 'spam': core_schema.typed_dict_field( + schema=core_schema.list_schema(items_schema=core_schema.int_schema()) + ), + } + ), }, - } + ) ) assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123} with pytest.raises(ValidationError) as exc_info: @@ -573,30 +563,26 @@ def test_custom_error(): def test_custom_error_type(): v = SchemaValidator( - { - 'type': 'tagged-union', - 'discriminator': 'foo', - 'custom_error_type': 'finite_number', - 'choices': { - 'apple': { - 'type': 'typed-dict', - 'fields': { - 'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'bar': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - }, - 'banana': { - 'type': 'typed-dict', - 'fields': { - 'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'spam': { - 'type': 'typed-dict-field', - 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}, - }, - }, - }, + schema=core_schema.tagged_union_schema( + discriminator='foo', + custom_error_type='finite_number', + choices={ + 'apple': core_schema.typed_dict_schema( + fields={ + 'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()), + 'bar': core_schema.typed_dict_field(schema=core_schema.int_schema()), + } + ), + 'banana': core_schema.typed_dict_schema( + fields={ + 'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()), + 'spam': core_schema.typed_dict_field( + schema=core_schema.list_schema(items_schema=core_schema.int_schema()) + ), + } + ), }, - } + ) ) assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123} with pytest.raises(ValidationError) as exc_info: diff --git a/tests/validators/test_time.py b/tests/validators/test_time.py index 1061cd063..5ee84d94b 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({'type': 'time'}) + v = SchemaValidator(schema=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({'type': 'time', 'strict': True}) + v = SchemaValidator(schema=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({'type': 'time', 'strict': True}) + v = SchemaValidator(schema=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({'type': 'time', **kwargs}) + v = SchemaValidator(schema=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({'type': 'time', 'gt': time(12, 13, 14, 123_456)}) + v = SchemaValidator(schema=core_schema.time_schema(gt=time(12, 13, 14, 123_456))) with pytest.raises(ValidationError) as exc_info: v.validate_python('12:13') @@ -195,7 +195,9 @@ def test_invalid_constraint(): def test_dict_py(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'time'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator( + 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} @@ -205,17 +207,17 @@ def test_dict(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'time'}]}) + v = SchemaValidator(schema=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({'type': 'union', 'choices': [{'type': 'time'}, {'type': 'str'}]}) + v = SchemaValidator(schema=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(core_schema.time_schema(tz_constraint='aware')) + v = SchemaValidator(schema=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) @@ -229,7 +231,7 @@ def test_aware(): def test_naive(): - v = SchemaValidator(core_schema.time_schema(tz_constraint='naive')) + v = SchemaValidator(schema=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) @@ -243,7 +245,7 @@ def test_naive(): def test_aware_specific(): - v = SchemaValidator(core_schema.time_schema(tz_constraint=0)) + v = SchemaValidator(schema=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) @@ -271,7 +273,7 @@ def test_aware_specific(): def test_neg_7200(): - v = SchemaValidator(core_schema.time_schema(tz_constraint=-7200)) + v = SchemaValidator(schema=core_schema.time_schema(tz_constraint=-7200)) value = time(12, 13, 15, tzinfo=timezone(timedelta(hours=-2))) assert value is v.validate_python(value) @@ -288,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(core_schema.time_schema(tz_constraint=2**64)) + SchemaValidator(schema=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 6f9f9133f..2b4889870 100644 --- a/tests/validators/test_timedelta.py +++ b/tests/validators/test_timedelta.py @@ -5,7 +5,7 @@ import pytest -from pydantic_core import SchemaError, SchemaValidator, ValidationError, validate_core_schema +from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema from ..conftest import Err, PyAndJson @@ -57,7 +57,7 @@ ids=repr, ) def test_timedelta(input_value, expected): - v = SchemaValidator({'type': 'timedelta'}) + v = SchemaValidator(schema=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({'type': 'timedelta'}) + v = SchemaValidator(schema=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({'type': 'timedelta', 'strict': True}) + v = SchemaValidator(schema=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({'type': 'timedelta', 'strict': True}) + v = SchemaValidator(schema=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({'type': 'timedelta', **kwargs}) + v = SchemaValidator(schema=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({'type': 'timedelta', 'strict': True, 'le': timedelta(days=3)}) + v = SchemaValidator(schema=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) @@ -209,7 +209,11 @@ def test_invalid_constraint(): def test_dict_py(): - v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'timedelta'}, 'values_schema': {'type': 'int'}}) + v = SchemaValidator( + 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, timedelta(days=2, hours=2): 4, @@ -233,11 +237,15 @@ def test_dict_value(py_and_json: PyAndJson): def test_union(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'timedelta'}]}) + v = SchemaValidator( + schema=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({'type': 'union', 'choices': [{'type': 'timedelta'}, {'type': 'str'}]}) + v = SchemaValidator( + schema=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) @@ -265,7 +273,7 @@ def test_union(): ids=repr, ) def test_pytimedelta_as_timedelta(constraint, expected_duration): - v = SchemaValidator({'type': 'timedelta', 'gt': constraint}) + v = SchemaValidator(schema=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() @@ -274,7 +282,7 @@ def test_pytimedelta_as_timedelta(constraint, expected_duration): def test_large_value(): - v = SchemaValidator({'type': 'timedelta'}) + v = SchemaValidator(schema=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'): @@ -283,7 +291,7 @@ def test_large_value(): @pytest.mark.skipif(not pandas, reason='pandas not installed') def test_pandas(): - v = SchemaValidator({'type': 'timedelta', 'ge': timedelta(hours=2)}) + v = SchemaValidator(schema=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 986b7fcd0..816d32dac 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({'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0}) + v = SchemaValidator(schema=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( - core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index, strict=True) + schema=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({'type': 'tuple', 'items_schema': [], 'fail_fast': fail_fast}) + v = SchemaValidator(schema=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( - core_schema.tuple_schema(variadic_item_index=variadic_item_index, items_schema=items, strict=True) + schema=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'])) @@ -124,7 +124,9 @@ def test_tuple_strict_fails_without_tuple(wrong_coll_type: type[Any], variadic_i ids=repr, ) def test_tuple_var_len_kwargs(kwargs: dict[str, Any], input_value, expected): - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0, **kwargs}) + v = SchemaValidator( + schema=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)): v.validate_python(input_value) @@ -150,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(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index)) + v = SchemaValidator(schema=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) @@ -165,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(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index)) + v = SchemaValidator(schema=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) @@ -180,7 +182,7 @@ def test_tuple_validate_iterator(variadic_item_index, items): ], ) def test_tuple_var_len_errors(input_value, index): - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0}) + v = SchemaValidator(schema=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) == [ @@ -208,7 +210,7 @@ def test_tuple_var_len_errors(input_value, index): ], ) def test_tuple_fix_len_errors(input_value, items, index): - v = SchemaValidator({'type': 'tuple', 'items_schema': items}) + v = SchemaValidator(schema=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) == [ @@ -276,13 +278,12 @@ 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( - { - 'type': 'union', - 'choices': [ - {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0}, - {'type': 'list'}, - ], - } + schema=core_schema.union_schema( + choices=[ + core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0), + core_schema.list_schema(), + ] + ) ) assert v.validate_python(input_value) == expected @@ -320,13 +321,12 @@ def test_union_tuple_list(input_value, expected): ) def test_union_tuple_var_len(input_value, expected): v = SchemaValidator( - { - 'type': 'union', - 'choices': [ - {'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0, 'strict': True}, - {'type': 'tuple', 'items_schema': [{'type': 'str'}], 'variadic_item_index': 0, 'strict': True}, - ], - } + 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), + ] + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: @@ -367,13 +367,18 @@ def test_union_tuple_var_len(input_value, expected): ) def test_union_tuple_fix_len(input_value, expected): v = SchemaValidator( - { - 'type': 'union', - 'choices': [ - {'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}], 'strict': True}, - {'type': 'tuple', 'items_schema': [{'type': 'str'}, {'type': 'str'}, {'type': 'str'}], 'strict': True}, - ], - } + schema=core_schema.union_schema( + choices=[ + core_schema.tuple_schema( + items_schema=[core_schema.int_schema(), core_schema.int_schema(), core_schema.int_schema()], + strict=True, + ), + core_schema.tuple_schema( + items_schema=[core_schema.str_schema(), core_schema.str_schema(), core_schema.str_schema()], + strict=True, + ), + ] + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info: @@ -385,7 +390,9 @@ def test_union_tuple_fix_len(input_value, expected): def test_tuple_fix_error(): - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'str'}]}) + v = SchemaValidator( + schema=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]) @@ -407,7 +414,10 @@ def test_tuple_fix_error(): ) def test_tuple_fix_extra(input_value, expected): v = SchemaValidator( - {'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'str'}, {'type': 'str'}], 'variadic_item_index': 2} + schema=core_schema.tuple_schema( + items_schema=[core_schema.int_schema(), core_schema.str_schema(), core_schema.str_schema()], + variadic_item_index=2, + ) ) if isinstance(expected, Err): @@ -419,7 +429,11 @@ def test_tuple_fix_extra(input_value, expected): def test_tuple_fix_extra_any(): - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'str'}, {'type': 'any'}], 'variadic_item_index': 1}) + v = SchemaValidator( + schema=core_schema.tuple_schema( + items_schema=[core_schema.str_schema(), core_schema.any_schema()], variadic_item_index=1 + ) + ) assert v.validate_python([b'1']) == ('1',) assert v.validate_python([b'1', 2]) == ('1', 2) assert v.validate_python((b'1', 2)) == ('1', 2) @@ -439,7 +453,7 @@ def gen(error: bool): raise RuntimeError('error') yield 3 - v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0}) + v = SchemaValidator(schema=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,' @@ -466,7 +480,7 @@ def gen(error: bool): ], ) def test_frozenset_from_dict_items(input_value, items_schema, expected): - v = SchemaValidator({'type': 'tuple', 'items_schema': [items_schema], 'variadic_item_index': 0}) + v = SchemaValidator(schema=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 @@ -482,12 +496,11 @@ def test_frozenset_from_dict_items(input_value, items_schema, expected): ) def test_length_constraints_omit(input_value, expected): v = SchemaValidator( - { - 'type': 'tuple', - 'items_schema': [{'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}], - 'variadic_item_index': 0, - 'max_length': 4, - } + 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, + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -541,7 +554,7 @@ def test_tuple_fail_fast(fail_fast, expected): variadic_item_index=None, fail_fast=fail_fast, ) - v = SchemaValidator(s) + v = SchemaValidator(schema=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 b41a1188f..4d11c9e0a 100644 --- a/tests/validators/test_typed_dict.py +++ b/tests/validators/test_typed_dict.py @@ -41,13 +41,12 @@ def __repr__(self): def test_simple(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) assert v.validate_python({'field_a': b'abc', 'field_b': 1}) == {'field_a': 'abc', 'field_b': 1} @@ -61,7 +60,7 @@ def test_strict(): 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, 'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, }, - 'config': {'strict': True}, + 'config': CoreConfig(strict=True), } ) @@ -77,16 +76,14 @@ def test_strict(): def test_with_default(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_b': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 666}, - }, - }, - } + 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.with_default_schema(schema=core_schema.int_schema(), default=666) + ), + } + ) ) assert v.validate_python({'field_a': b'abc'}) == {'field_a': 'abc', 'field_b': 666} @@ -95,13 +92,12 @@ def test_with_default(): def test_missing_error(pydantic_version): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) with pytest.raises(ValidationError) as exc_info: v.validate_python({'field_a': b'abc'}) @@ -121,13 +117,17 @@ def test_missing_error(pydantic_version): ({}, Map(a=123), {'a': 123}), ({}, {b'a': '123'}, Err('Field required [type=missing,')), ({}, {'a': '123', 'c': 4}, {'a': 123}), - ({'extra_fields_behavior': 'allow'}, {'a': '123', 'c': 4}, {'a': 123, 'c': 4}), - ({'extra_fields_behavior': 'allow'}, {'a': '123', b'c': 4}, Err('Keys should be strings [type=invalid_key,')), - ({'strict': True}, Map(a=123), Err('Input should be a valid dictionary [type=dict_type,')), + (CoreConfig(extra_fields_behavior='allow'), {'a': '123', 'c': 4}, {'a': 123, 'c': 4}), + ( + CoreConfig(extra_fields_behavior='allow'), + {'a': '123', b'c': 4}, + Err('Keys should be strings [type=invalid_key,'), + ), + (CoreConfig(strict=True), Map(a=123), Err('Input should be a valid dictionary [type=dict_type,')), ({}, {'a': '123', 'b': '4.7'}, {'a': 123, 'b': 4.7}), ({}, {'a': '123', 'b': 'nan'}, {'a': 123, 'b': FunctionCheck(math.isnan)}), ( - {'allow_inf_nan': False}, + CoreConfig(allow_inf_nan=False), {'a': '123', 'b': 'nan'}, Err('Input should be a finite number [type=finite_number,'), ), @@ -136,14 +136,13 @@ def test_missing_error(pydantic_version): ) def test_config(config: CoreConfig, input_value, expected): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'a': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'typed-dict-field', 'schema': {'type': 'float'}, 'required': False}, + 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), }, - 'config': config, - } + config=config, + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=re.escape(expected.message)): @@ -156,13 +155,12 @@ def test_config(config: CoreConfig, input_value, expected): def test_ignore_extra(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - } + 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()), + } + ) ) assert v.validate_python({'field_a': b'123', 'field_b': 1, 'field_c': 123}) == {'field_a': '123', 'field_b': 1} @@ -170,11 +168,9 @@ def test_ignore_extra(): def test_forbid_extra(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}}, - 'extra_behavior': 'forbid', - } + schema=core_schema.typed_dict_schema( + fields={'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema())}, extra_behavior='forbid' + ) ) with pytest.raises(ValidationError) as exc_info: @@ -188,7 +184,9 @@ def test_forbid_extra(): def test_allow_extra_invalid(): with pytest.raises(SchemaError, match='extras_schema can only be used if extra_behavior=allow'): SchemaValidator( - {'type': 'typed-dict', 'fields': {}, 'extras_schema': {'type': 'int'}, 'extra_behavior': 'ignore'} + schema=core_schema.typed_dict_schema( + fields={}, extras_schema=core_schema.int_schema(), extra_behavior='ignore' + ) ) @@ -199,11 +197,10 @@ def test_allow_extra_wrong(): def test_str_config(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}}, - 'config': {'str_max_length': 5}, - } + 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), + ) ) assert v.validate_python({'field_a': 'test'}) == {'field_a': 'test'} @@ -213,12 +210,13 @@ def test_str_config(): def test_json_error(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}} - }, - } + 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()) + ) + } + ) ) with pytest.raises(ValidationError) as exc_info: v.validate_json('{"field_a": [123, "wrong"]}') @@ -241,13 +239,12 @@ def test_missing_schema_key(): def test_fields_required_by_default(): """By default all fields should be required""" v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - }, - } + 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()), + } + ) ) assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'} @@ -262,13 +259,12 @@ def test_fields_required_by_default(): def test_fields_required_by_default_with_optional(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}, 'required': False}, - }, - } + 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), + } + ) ) assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'} @@ -277,16 +273,14 @@ def test_fields_required_by_default_with_optional(): def test_fields_required_by_default_with_default(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'y': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'bulbi'}, - }, - }, - } + 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.with_default_schema(schema=core_schema.str_schema(), default='bulbi') + ), + } + ) ) assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'} @@ -296,14 +290,13 @@ 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( - { - 'type': 'typed-dict', - 'total': False, - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str', 'strict': True}}, - 'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, + schema=core_schema.typed_dict_schema( + total=False, + fields={ + 'x': core_schema.typed_dict_field(schema=core_schema.str_schema(strict=True)), + 'y': core_schema.typed_dict_field(schema=core_schema.str_schema()), }, - } + ) ) assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'} @@ -320,14 +313,13 @@ def test_all_optional_fields(): def test_all_optional_fields_with_required_fields(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'total': False, - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str', 'strict': True}, 'required': True}, - 'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, + schema=core_schema.typed_dict_schema( + total=False, + fields={ + 'x': core_schema.typed_dict_field(schema=core_schema.str_schema(strict=True), required=True), + 'y': core_schema.typed_dict_field(schema=core_schema.str_schema()), }, - } + ) ) assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'} @@ -345,16 +337,14 @@ def test_field_required_and_default(): """A field cannot be required and have a default value""" with pytest.raises(SchemaError, match="Field 'x': a required field cannot have a default value"): SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'pika'}, - 'required': True, - } - }, - } + schema=core_schema.typed_dict_schema( + fields={ + 'x': core_schema.typed_dict_field( + schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='pika'), + required=True, + ) + } + ) ) @@ -501,13 +491,12 @@ def test_aliases_path_multiple(py_and_json: PyAndJson, input_value, expected): ) def test_aliases_path_negative(input_value, expected): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'validation_alias': ['foo', -2], 'type': 'typed-dict-field', 'schema': {'type': 'int'}} + schema=core_schema.typed_dict_schema( + fields={ + 'field_a': core_schema.typed_dict_field(validation_alias=['foo', -2], schema=core_schema.int_schema()) }, - 'config': {'loc_by_alias': False}, - } + config=CoreConfig(loc_by_alias=False), + ) ) if isinstance(expected, Err): with pytest.raises(ValidationError, match=expected.message): @@ -547,16 +536,13 @@ def test_aliases_path_negative_json(py_and_json: PyAndJson, input_value, expecte def test_aliases_debug(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': { - 'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3]], - 'type': 'typed-dict-field', - 'schema': {'type': 'int'}, - } - }, - } + 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() + ) + } + ) ) print(repr(v)) assert repr(v).startswith('SchemaValidator(title="typed-dict", validator=TypedDict(') @@ -565,16 +551,13 @@ def test_aliases_debug(): def get_int_key(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': { - 'validation_alias': [['foo', 3], ['spam']], - 'type': 'typed-dict-field', - 'schema': {'type': 'int'}, - } - }, - } + schema=core_schema.typed_dict_schema( + fields={ + 'field_a': core_schema.typed_dict_field( + validation_alias=[['foo', 3], ['spam']], schema=core_schema.int_schema() + ) + } + ) ) assert v.validate_python({'foo': {3: 33}}) == ({'field_a': 33}, {'field_a'}) @@ -587,10 +570,9 @@ def __getitem__(self, v): def get_custom_getitem(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': {'field_a': {'validation_alias': ['foo'], 'type': 'typed-dict-field', 'schema': {'type': 'int'}}}, - } + schema=core_schema.typed_dict_schema( + fields={'field_a': core_schema.typed_dict_field(validation_alias=['foo'], schema=core_schema.int_schema())} + ) ) assert v.validate_python(GetItemThing()) == ({'field_a': 321}, {'field_a'}) assert v.validate_python({'bar': GetItemThing()}) == ({'field_a': 321}, {'field_a'}) @@ -629,7 +611,7 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value): def test_alias_build_error(alias_schema, error): with pytest.raises(SchemaError, match=error): SchemaValidator( - validate_core_schema( + schema=validate_core_schema( { 'type': 'typed-dict', 'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'int'}, **alias_schema}}, @@ -732,7 +714,7 @@ def test_alias_error_loc_field_names(py_and_json: PyAndJson): def test_empty_model(): - v = SchemaValidator({'type': 'typed-dict', 'fields': {}}) + v = SchemaValidator(schema=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') @@ -740,31 +722,26 @@ def test_empty_model(): def test_model_deep(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_b': { - 'type': 'typed-dict-field', - 'schema': { - 'type': 'typed-dict', - 'fields': { - 'field_c': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_d': { - 'type': 'typed-dict-field', - 'schema': { - 'type': 'typed-dict', - 'fields': { - 'field_e': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'field_f': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}, - }, - }, - }, - }, - }, - }, - }, - } + 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.typed_dict_schema( + fields={ + 'field_c': core_schema.typed_dict_field(schema=core_schema.str_schema()), + 'field_d': core_schema.typed_dict_field( + schema=core_schema.typed_dict_schema( + fields={ + 'field_e': core_schema.typed_dict_field(schema=core_schema.str_schema()), + 'field_f': core_schema.typed_dict_field(schema=core_schema.int_schema()), + } + ) + ), + } + ) + ), + } + ) ) output = v.validate_python({'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 4}}}) assert output == {'field_a': '1', 'field_b': ({'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 4}})} @@ -843,15 +820,15 @@ def test_alias_extra_forbid(py_and_json: PyAndJson): def test_with_default_factory(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda: 'pikachu'}, - } - }, - } + schema=core_schema.typed_dict_schema( + fields={ + 'x': core_schema.typed_dict_field( + schema=core_schema.with_default_schema( + schema=core_schema.str_schema(), default_factory=lambda: 'pikachu' + ) + ) + } + ) ) assert v.validate_python({}) == {'x': 'pikachu'} @@ -862,16 +839,16 @@ def test_field_required_and_default_factory(): """A field cannot be required and have a default factory""" with pytest.raises(SchemaError, match="Field 'x': a required field cannot have a default value"): SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda: 'pika'}, - 'required': True, - } - }, - } + schema=core_schema.typed_dict_schema( + fields={ + 'x': core_schema.typed_dict_field( + schema=core_schema.with_default_schema( + schema=core_schema.str_schema(), default_factory=lambda: 'pika' + ), + required=True, + ) + } + ) ) @@ -884,15 +861,15 @@ def test_field_required_and_default_factory(): ) def test_bad_default_factory(default_factory, error_message): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': default_factory}, - } - }, - } + schema=core_schema.typed_dict_schema( + fields={ + 'x': core_schema.typed_dict_field( + schema=core_schema.with_default_schema( + schema=core_schema.str_schema(), default_factory=default_factory + ) + ) + } + ) ) with pytest.raises(TypeError, match=re.escape(error_message)): v.validate_python({}) @@ -916,29 +893,25 @@ def test_on_error_bad_name(self): def test_on_error_bad_omit(self): with pytest.raises(SchemaError, match="Field 'x': 'on_error = omit' cannot be set for required fields"): SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'omit'}, - } - }, - } + schema=core_schema.typed_dict_schema( + fields={ + 'x': core_schema.typed_dict_field( + schema=core_schema.with_default_schema(schema=core_schema.str_schema(), on_error='omit') + ) + } + ) ) def test_on_error_bad_default(self): with pytest.raises(SchemaError, match="'on_error = default' requires a `default` or `default_factory`"): SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'default'}, - } - }, - } + schema=core_schema.typed_dict_schema( + fields={ + 'x': core_schema.typed_dict_field( + schema=core_schema.with_default_schema(schema=core_schema.str_schema(), on_error='default') + ) + } + ) ) def test_on_error_raise_by_default(self, py_and_json: PyAndJson): @@ -1084,7 +1057,7 @@ def wrap_function(input_value, validator, info): 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), - (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': None}), + (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), (core_schema.CoreConfig(), {'extra_behavior': 'allow'}), (None, {'extra_behavior': 'allow'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'allow'}), @@ -1092,7 +1065,7 @@ def wrap_function(input_value, validator, info): ) @pytest.mark.parametrize( 'extras_schema_kw, expected_extra_value', - [({}, '123'), ({'extras_schema': None}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], + [({}, '123'), ({}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], ids=['extras_schema=unset', 'extras_schema=None', 'extras_schema=int'], ) def test_extra_behavior_allow( @@ -1102,7 +1075,7 @@ def test_extra_behavior_allow( expected_extra_value: Any, ): v = SchemaValidator( - core_schema.typed_dict_schema( + schema=core_schema.typed_dict_schema( {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw, **extras_schema_kw, @@ -1118,7 +1091,7 @@ def test_extra_behavior_allow( 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), - (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': None}), + (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), (core_schema.CoreConfig(), {'extra_behavior': 'forbid'}), (None, {'extra_behavior': 'forbid'}), (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'forbid'}), @@ -1126,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( - core_schema.typed_dict_schema( + schema=core_schema.typed_dict_schema( {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw, config=config ) ) @@ -1149,13 +1122,13 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche (None, {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(), {}), - (core_schema.CoreConfig(), {'extra_behavior': None}), - (None, {'extra_behavior': None}), + (core_schema.CoreConfig(), {}), + (None, {}), ], ) def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): v = SchemaValidator( - core_schema.typed_dict_schema( + schema=core_schema.typed_dict_schema( {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw ), config=config, @@ -1181,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) + validate.__pydantic_validator__ = SchemaValidator(schema=schema) return validate diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py index 1951fb3de..993cb643f 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({'type': 'union', 'choices': [{'type': 'bool'}, {'type': 'int'}]}) + v = SchemaValidator(schema=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({'type': 'union', 'choices': [{'type': 'int'}, {'type': 'bool'}]}) + v = SchemaValidator(schema=core_schema.union_schema(choices=[core_schema.int_schema(), core_schema.bool_schema()])) assert v.validate_python(input_value) == expected_value @@ -63,33 +63,28 @@ class ModelB: @pytest.fixture(scope='class') def schema_validator(self) -> SchemaValidator: return SchemaValidator( - { - 'type': 'union', - 'choices': [ - { - 'type': 'model', - 'cls': self.ModelA, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'str'}}, - }, - }, - }, - { - 'type': 'model', - 'cls': self.ModelB, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'c': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'd': {'type': 'model-field', 'schema': {'type': 'str'}}, - }, - }, - }, - ], - } + schema=core_schema.union_schema( + choices=[ + core_schema.model_schema( + cls=self.ModelA, + 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.str_schema()), + } + ), + ), + core_schema.model_schema( + cls=self.ModelB, + schema=core_schema.model_fields_schema( + fields={ + 'c': core_schema.model_field(schema=core_schema.int_schema()), + 'd': core_schema.model_field(schema=core_schema.str_schema()), + } + ), + ), + ] + ) ) def test_model_a(self, schema_validator: SchemaValidator): @@ -131,37 +126,33 @@ class ModelB: @pytest.fixture(scope='class') def schema_validator(self) -> SchemaValidator: return SchemaValidator( - { - 'type': 'union', - 'choices': [ - { - 'type': 'model', - 'cls': self.ModelA, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'str'}}, - }, - }, - }, - { - 'type': 'model', - 'cls': self.ModelB, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - 'b': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'c': { - 'type': 'model-field', - 'schema': {'type': 'default', 'schema': {'type': 'float'}, 'default': 1.0}, - }, - }, - }, - }, - ], - } + schema=core_schema.union_schema( + choices=[ + core_schema.model_schema( + cls=self.ModelA, + 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.str_schema()), + } + ), + ), + core_schema.model_schema( + cls=self.ModelB, + 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.str_schema()), + 'c': core_schema.model_field( + schema=core_schema.with_default_schema( + schema=core_schema.float_schema(), default=1.0 + ) + ), + } + ), + ), + ] + ) ) def test_model_a(self, schema_validator: SchemaValidator): @@ -194,7 +185,7 @@ def test_model_b_not_ignored(self, schema_validator: SchemaValidator): def test_nullable_via_union(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'none'}, {'type': 'int'}]}) + v = SchemaValidator(schema=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: @@ -212,13 +203,12 @@ def test_nullable_via_union(): def test_union_list_bool_int(): v = SchemaValidator( - { - 'type': 'union', - 'choices': [ - {'type': 'list', 'items_schema': {'type': 'bool'}}, - {'type': 'list', 'items_schema': {'type': 'int'}}, - ], - } + 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()), + ] + ) ) assert v.validate_python(['true', True, 'no']) == [True, True, False] assert v.validate_python([5, 6, '789']) == [5, 6, 789] @@ -260,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({'type': 'union', 'choices': []}) + SchemaValidator(schema=core_schema.union_schema(choices=[])) def test_one_choice(): - v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}]}) + v = SchemaValidator(schema=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)' @@ -273,7 +263,9 @@ def test_one_choice(): def test_strict_union(): - v = SchemaValidator({'type': 'union', 'strict': True, 'choices': [{'type': 'bool'}, {'type': 'int'}]}) + v = SchemaValidator( + 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 @@ -288,12 +280,11 @@ def test_strict_union(): def test_custom_error(): v = SchemaValidator( - { - 'type': 'union', - 'choices': [{'type': 'str'}, {'type': 'bytes'}], - 'custom_error_type': 'my_error', - 'custom_error_message': 'Input should be a string or bytes', - } + 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', + ) ) assert v.validate_python('hello') == 'hello' assert v.validate_python(b'hello') == b'hello' @@ -307,7 +298,9 @@ def test_custom_error(): def test_custom_error_type(): v = SchemaValidator( - {'type': 'union', 'choices': [{'type': 'str'}, {'type': 'bytes'}], 'custom_error_type': 'string_type'} + schema=core_schema.union_schema( + choices=[core_schema.str_schema(), core_schema.bytes_schema()], custom_error_type='string_type' + ) ) assert v.validate_python('hello') == 'hello' assert v.validate_python(b'hello') == b'hello' @@ -321,12 +314,11 @@ def test_custom_error_type(): def test_custom_error_type_context(): v = SchemaValidator( - { - 'type': 'union', - 'choices': [{'type': 'str'}, {'type': 'bytes'}], - 'custom_error_type': 'less_than', - 'custom_error_context': {'lt': 42}, - } + schema=core_schema.union_schema( + choices=[core_schema.str_schema(), core_schema.bytes_schema()], + custom_error_type='less_than', + custom_error_context={'lt': 42}, + ) ) assert v.validate_python('hello') == 'hello' assert v.validate_python(b'hello') == b'hello' @@ -350,13 +342,13 @@ def test_dirty_behaviour(): def test_int_float(): - v = SchemaValidator(core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()])) + v = SchemaValidator(schema=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(core_schema.union_schema([core_schema.float_schema(), core_schema.int_schema()])) + v = SchemaValidator(schema=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) @@ -364,7 +356,7 @@ def test_int_float(): def test_str_float(): - v = SchemaValidator(core_schema.union_schema([core_schema.str_schema(), core_schema.float_schema()])) + v = SchemaValidator(schema=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) @@ -376,7 +368,7 @@ def test_str_float(): assert v.validate_json('"1.0"') == '1.0' assert v.validate_json('"1"') == '1' - v = SchemaValidator(core_schema.union_schema([core_schema.float_schema(), core_schema.str_schema()])) + v = SchemaValidator(schema=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) @@ -389,14 +381,16 @@ def test_str_float(): def test_no_strict_check(): - v = SchemaValidator(core_schema.union_schema([core_schema.is_instance_schema(int), core_schema.json_schema()])) + v = SchemaValidator( + schema=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( - core_schema.definitions_schema( + schema=core_schema.definitions_schema( core_schema.definition_reference_schema(schema_ref='tuple-ref'), [ core_schema.tuple_positional_schema( @@ -418,7 +412,9 @@ def test_strict_reference(): def test_case_labels(): v = SchemaValidator( - {'type': 'union', 'choices': [{'type': 'none'}, ({'type': 'int'}, 'my_label'), {'type': 'str'}]} + schema=core_schema.union_schema( + choices=[core_schema.none_schema(), ({'type': 'int'}, 'my_label'), core_schema.str_schema()] + ) ) assert v.validate_python(None) is None assert v.validate_python(1) == 1 @@ -438,7 +434,7 @@ def test_case_labels(): def test_left_to_right_doesnt_care_about_strict_check(): v = SchemaValidator( - core_schema.union_schema([core_schema.int_schema(), core_schema.json_schema()], mode='left_to_right') + schema=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) @@ -448,13 +444,13 @@ def test_left_to_right_union(): choices = [core_schema.int_schema(), core_schema.float_schema()] # smart union prefers float - v = SchemaValidator(core_schema.union_schema(choices, mode='smart')) + v = SchemaValidator(schema=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(core_schema.union_schema(choices, mode='left_to_right')) + v = SchemaValidator(schema=core_schema.union_schema(choices, mode='left_to_right')) out = v.validate_python(1) assert out == 1 assert isinstance(out, int) @@ -464,7 +460,7 @@ def test_left_to_right_union(): assert isinstance(out, int) # reversing them will select float - v = SchemaValidator(core_schema.union_schema(list(reversed(choices)), mode='left_to_right')) + v = SchemaValidator(schema=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) @@ -478,7 +474,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(core_schema.union_schema(choices, mode='left_to_right', strict=True)) + v = SchemaValidator(schema=core_schema.union_schema(choices, mode='left_to_right', strict=True)) out = v.validate_python(1) assert out == 1 assert isinstance(out, int) @@ -488,7 +484,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(core_schema.union_schema(list(reversed(choices)), mode='left_to_right', strict=True)) + v = SchemaValidator(schema=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) @@ -519,7 +515,7 @@ def remove_prefix(v: str): prefixed_uuid_schema = core_schema.no_info_before_validator_function(remove_prefix, core_schema.uuid_schema()) - v = SchemaValidator(core_schema.union_schema([special_values_schema, prefixed_uuid_schema])) + v = SchemaValidator(schema=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' @@ -548,7 +544,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(core_schema.union_schema([schema, core_schema.str_schema()])) + validator = SchemaValidator(schema=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 @@ -571,7 +567,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(core_schema.union_schema([core_schema.str_schema(), schema])) + validator = SchemaValidator(schema=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 @@ -605,7 +601,7 @@ class ModelB: ] ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) result = validator.validate_python({'x': 1}) assert isinstance(result, ModelA) @@ -635,7 +631,7 @@ class ModelB: ] ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) result = validator.validate_python({'x': 1}) assert isinstance(result, ModelA) @@ -674,7 +670,7 @@ class ModelB: ] ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) result = validator.validate_python({'x': 1}) assert isinstance(result, ModelA) @@ -690,12 +686,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) + validator = SchemaValidator(schema=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) + validator = SchemaValidator(schema=schema) assert repr(validator.validate_python(1)) == '1.0' @@ -704,7 +700,7 @@ def test_smart_union_validator_function(): inner_schema = core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()]) - validator = SchemaValidator(inner_schema) + validator = SchemaValidator(schema=inner_schema) assert repr(validator.validate_python(1)) == '1' assert repr(validator.validate_python(1.0)) == '1.0' @@ -712,7 +708,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) + validator = SchemaValidator(schema=schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '2.0' assert validator.validate_python('1') == '1' @@ -724,7 +720,7 @@ def test_smart_union_validator_function(): ] ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '2.0' assert validator.validate_python('1') == '1' @@ -740,7 +736,7 @@ def test_smart_union_validator_function_one_arm(): ] ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '1.0' @@ -751,7 +747,7 @@ def test_smart_union_validator_function_one_arm(): ] ) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) assert repr(validator.validate_python(1)) == '2' assert repr(validator.validate_python(1.0)) == '1.0' @@ -768,7 +764,7 @@ class BinaryEnum(IntEnum): schema = core_schema.union_schema([enum_schema, core_schema.int_schema()]) - validator = SchemaValidator(schema) + validator = SchemaValidator(schema=schema) assert validator.validate_python(0) is not BinaryEnum.ZERO assert validator.validate_python(1) is not BinaryEnum.ONE @@ -782,22 +778,17 @@ class ModelA: pass validator = SchemaValidator( - { - 'type': 'union', - 'choices': [ - { - 'type': 'model', - 'cls': ModelA, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'a': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - }, - {'type': 'literal', 'expected': [True]}, - ], - } + schema=core_schema.union_schema( + choices=[ + core_schema.model_schema( + cls=ModelA, + schema=core_schema.model_fields_schema( + fields={'a': core_schema.model_field(schema=core_schema.int_schema())} + ), + ), + core_schema.literal_schema(expected=[True]), + ] + ) ) # validation against Literal[True] fails bc of the unhashable dict @@ -882,7 +873,7 @@ class WrapModel: val: Optional[Union[self.ModelA, self.ModelB]] = None val = SchemaValidator( - core_schema.model_schema( + schema=core_schema.model_schema( WrapModel, core_schema.model_fields_schema( fields={ @@ -930,7 +921,7 @@ class ModelB(ModelA): ) for choices in permute_choices([dc_a_schema, dc_b_schema]): - validator = SchemaValidator(core_schema.union_schema(choices=choices)) + validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'x': 1}), ModelA) assert isinstance(validator.validate_python({'x': '1'}), ModelA) @@ -977,7 +968,7 @@ class ModelB: ) for choices in permute_choices([dc_a_schema, dc_b_schema]): - validator = SchemaValidator(core_schema.union_schema(choices=choices)) + validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'a': 1}), ModelA) assert isinstance(validator.validate_python({'b': 1}), ModelB) @@ -996,7 +987,7 @@ def test_td_smart_union_by_fields_set() -> None: ) for choices in permute_choices([td_a_schema, td_b_schema]): - validator = SchemaValidator(core_schema.union_schema(choices=choices)) + validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) assert set(validator.validate_python({'x': 1}).keys()) == {'x'} assert set(validator.validate_python({'x': '1'}).keys()) == {'x'} @@ -1061,7 +1052,7 @@ class ModelB: ) for choices in permute_choices([model_a_schema, model_b_schema]): - validator = SchemaValidator(core_schema.union_schema(choices=choices)) + validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'sub': {'x': 1}}), ModelA) assert isinstance(validator.validate_python({'sub': {'y': 3}}), ModelB) @@ -1144,7 +1135,7 @@ class ModelB: ) for choices in permute_choices([dc_a_schema, dc_b_schema]): - validator = SchemaValidator(core_schema.union_schema(choices=choices)) + validator = SchemaValidator(schema=core_schema.union_schema(choices=choices)) assert isinstance(validator.validate_python({'sub': {'x': 1}}), ModelA) assert isinstance(validator.validate_python({'sub': {'y': 3}}), ModelB) @@ -1171,7 +1162,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(core_schema.union_schema(choices=choices)) + validator = SchemaValidator(schema=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'} @@ -1261,7 +1252,7 @@ class ModelB: for model_a_schema in model_a_schema_options: for model_b_schema in model_b_schema_options: validator = SchemaValidator( - core_schema.union_schema( + schema=core_schema.union_schema( [ core_schema.model_schema( ModelA, @@ -1294,7 +1285,7 @@ class Model: x: Union[Foo, Bar] validator = SchemaValidator( - core_schema.model_schema( + 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 e8534a26a..8d721ea36 100644 --- a/tests/validators/test_url.py +++ b/tests/validators/test_url.py @@ -5,7 +5,7 @@ import pytest from dirty_equals import HasRepr, IsInstance -from pydantic_core import MultiHostUrl, SchemaError, SchemaValidator, Url, ValidationError, core_schema +from pydantic_core import CoreConfig, MultiHostUrl, SchemaError, SchemaValidator, Url, ValidationError, core_schema from ..conftest import Err, PyAndJson @@ -51,7 +51,7 @@ def test_url_from_constructor_ok(): @pytest.fixture(scope='module', name='url_validator') def url_validator_fixture(): - return SchemaValidator(core_schema.url_schema()) + return SchemaValidator(schema=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(core_schema.url_schema(**validator_kwargs)) + s = SchemaValidator(schema=core_schema.url_schema(**validator_kwargs)) url_test_case_helper(url, expected, SCHEMA_VALIDATOR_MODE, s) def test_url_host_required(): - s = SchemaValidator(core_schema.url_schema(host_required=True)) + s = SchemaValidator(schema=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(core_schema.multi_host_url_schema(**validator_kwargs)) + s = SchemaValidator(schema=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(core_schema.multi_host_url_schema(default_host='foo,bar')) + SchemaValidator(schema=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(core_schema.url_schema(), {'strict': True}) + return SchemaValidator(schema=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(core_schema.url_schema(max_length=25)) + v = SchemaValidator(schema=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(core_schema.url_schema(allowed_schemes=['http', 'https'])) + v = SchemaValidator(schema=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(core_schema.url_schema(allowed_schemes=['http', 'https'])) + v = SchemaValidator(schema=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(core_schema.url_schema(allowed_schemes=['a', 'b', 'c'])) + v = SchemaValidator(schema=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(core_schema.url_schema()) + v1 = SchemaValidator(schema=core_schema.url_schema()) url: Url = v1.validate_python('http://example.com/foobar/bar') assert str(url) == 'http://example.com/foobar/bar' - v2 = SchemaValidator(core_schema.url_schema(max_length=25)) + v2 = SchemaValidator(schema=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(core_schema.url_schema(allowed_schemes=['https'])) + v3 = SchemaValidator(schema=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(core_schema.multi_host_url_schema()) + return SchemaValidator(schema=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(core_schema.multi_host_url_schema(strict=True)) + return SchemaValidator(schema=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(core_schema.multi_host_url_schema(allowed_schemes=['http', 'foo'])) + v = SchemaValidator(schema=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(core_schema.multi_host_url_schema(max_length=25)) + v = SchemaValidator(schema=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(core_schema.multi_host_url_schema(allowed_schemes=[])) + SchemaValidator(schema=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 d1475f38e..92dad04e6 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({'type': 'uuid'}) + v = SchemaValidator(schema=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({'type': 'uuid', 'strict': True}) + v = SchemaValidator(schema=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) + v = SchemaValidator(schema=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({'type': 'uuid'}).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c') + output = SchemaValidator(schema=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({'type': 'uuid'}).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c') + output = SchemaValidator(schema=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) + v = SchemaValidator(schema=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 7c5972c5a..d7bc671fb 100644 --- a/tests/validators/test_with_default.py +++ b/tests/validators/test_with_default.py @@ -21,16 +21,14 @@ def test_typed_dict_default(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'y': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': '[default]'}, - }, - }, - } + 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.with_default_schema(schema=core_schema.str_schema(), default='[default]') + ), + } + ) ) assert v.validate_python({'x': 'x', 'y': 'y'}) == {'x': 'x', 'y': 'y'} assert v.validate_python({'x': 'x'}) == {'x': 'x', 'y': '[default]'} @@ -38,17 +36,15 @@ def test_typed_dict_default(): def test_typed_dict_omit(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'y': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'omit'}, - 'required': False, - }, - }, - } + 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.with_default_schema(schema=core_schema.str_schema(), on_error='omit'), + required=False, + ), + } + ) ) assert v.validate_python({'x': 'x', 'y': 'y'}) == {'x': 'x', 'y': 'y'} assert v.validate_python({'x': 'x'}) == {'x': 'x'} @@ -57,16 +53,17 @@ def test_typed_dict_omit(): def test_arguments(): v = SchemaValidator( - { - 'type': 'arguments', - 'arguments_schema': [ + schema=core_schema.arguments_schema( + arguments=[ { 'name': 'a', 'mode': 'positional_or_keyword', - 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 1}, + 'schema': core_schema.with_default_schema( + schema=core_schema.int_schema(), default_factory=lambda: 1 + ), } - ], - } + ] + ) ) assert v.validate_python({'a': 2}) == ((), {'a': 2}) assert v.validate_python(ArgsKwargs((2,))) == ((2,), {}) @@ -77,16 +74,17 @@ def test_arguments(): def test_arguments_omit(): with pytest.raises(SchemaError, match="Parameter 'a': omit_on_error cannot be used with arguments"): SchemaValidator( - { - 'type': 'arguments', - 'arguments_schema': [ + schema=core_schema.arguments_schema( + arguments=[ { 'name': 'a', 'mode': 'positional_or_keyword', - 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 1, 'on_error': 'omit'}, + 'schema': core_schema.with_default_schema( + schema=core_schema.int_schema(), default=1, on_error='omit' + ), } - ], - } + ] + ) ) @@ -113,7 +111,9 @@ def test_list_json(py_and_json: PyAndJson, input_value, expected): ) def test_list(input_value, expected): v = SchemaValidator( - {'type': 'list', 'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}} + schema=core_schema.list_schema( + items_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit') + ) ) assert v.validate_python(input_value) == expected @@ -130,7 +130,9 @@ def test_list(input_value, expected): ) def test_set(input_value, expected): v = SchemaValidator( - {'type': 'set', 'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}} + schema=core_schema.set_schema( + items_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit') + ) ) assert v.validate_python(input_value) == expected @@ -150,11 +152,10 @@ def test_dict_values(py_and_json: PyAndJson): def test_dict_keys(): v = SchemaValidator( - { - 'type': 'dict', - 'keys_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}, - 'values_schema': {'type': 'str'}, - } + 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(), + ) ) assert v.validate_python({1: 'a', '2': 'b'}) == {1: 'a', 2: 'b'} assert v.validate_python({1: 'a', 'wrong': 'b'}) == {1: 'a'} @@ -176,10 +177,12 @@ def test_tuple_variable(py_and_json: PyAndJson): def test_tuple_positional(): v = SchemaValidator( - { - 'type': 'tuple', - 'items_schema': [{'type': 'int'}, {'type': 'default', 'schema': {'type': 'int'}, 'default': 42}], - } + schema=core_schema.tuple_schema( + items_schema=[ + core_schema.int_schema(), + core_schema.with_default_schema(schema=core_schema.int_schema(), default=42), + ] + ) ) assert v.validate_python((1, '2')) == (1, 2) assert v.validate_python([1, '2']) == (1, 2) @@ -189,15 +192,14 @@ def test_tuple_positional(): def test_tuple_positional_omit(): v = SchemaValidator( - { - 'type': 'tuple', - 'items_schema': [ - {'type': 'int'}, - {'type': 'int'}, - {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}, + schema=core_schema.tuple_schema( + items_schema=[ + core_schema.int_schema(), + core_schema.int_schema(), + core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit'), ], - 'variadic_item_index': 2, - } + variadic_item_index=2, + ) ) assert v.validate_python((1, '2')) == (1, 2) assert v.validate_python((1, '2', 3, '4')) == (1, 2, 3, 4) @@ -207,7 +209,9 @@ def test_tuple_positional_omit(): def test_on_error_default(): - v = SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'default': 2, 'on_error': 'default'}) + v = SchemaValidator( + schema=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 @@ -218,7 +222,9 @@ def broken(): raise RuntimeError('this is broken') v = SchemaValidator( - {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'default', 'default_factory': broken} + schema=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 @@ -231,13 +237,12 @@ def broken(x): return 7 v = SchemaValidator( - { - 'type': 'default', - 'schema': {'type': 'int'}, - 'on_error': 'default', - 'default_factory': broken, - 'default_factory_takes_data': False, - } + schema=core_schema.with_default_schema( + schema=core_schema.int_schema(), + on_error='default', + default_factory=broken, + default_factory_takes_data=False, + ) ) assert v.validate_python(42) == 42 assert v.validate_python('42') == 42 @@ -247,16 +252,16 @@ def broken(x): def test_typed_dict_error(): v = SchemaValidator( - { - 'type': 'typed-dict', - 'fields': { - 'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}, - 'y': { - 'type': 'typed-dict-field', - 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda y: y * 2}, - }, - }, - } + 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.with_default_schema( + schema=core_schema.str_schema(), default_factory=lambda y: y * 2 + ) + ), + } + ) ) assert v.validate_python({'x': 'x', 'y': 'y'}) == {'x': 'x', 'y': 'y'} with pytest.raises(TypeError, match=r"\(\) missing 1 required positional argument: 'y'"): @@ -264,7 +269,9 @@ def test_typed_dict_error(): def test_on_error_default_not_int(): - v = SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'default': [1, 2, 3], 'on_error': 'default'}) + v = SchemaValidator( + schema=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 assert v.validate_python('wrong') == [1, 2, 3] @@ -272,7 +279,9 @@ def test_on_error_default_not_int(): def test_on_error_default_factory(): v = SchemaValidator( - {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 17, 'on_error': 'default'} + schema=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 @@ -280,7 +289,7 @@ def test_on_error_default_factory(): def test_on_error_omit(): - v = SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}) + v = SchemaValidator(schema=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') @@ -288,12 +297,16 @@ 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({'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'default'}) + SchemaValidator(schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='default')) def test_build_default_and_default_factory(): with pytest.raises(SchemaError, match="'default' and 'default_factory' cannot be used together"): - SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 1, 'default': 2}) + SchemaValidator( + schema=core_schema.with_default_schema( + schema=core_schema.int_schema(), default_factory=lambda: 1, default=2 + ) + ) def test_model_class(): @@ -303,22 +316,19 @@ class MyModel: field_b: int v = SchemaValidator( - { - 'type': 'model', - 'cls': MyModel, - 'schema': { - 'type': 'default', - 'schema': { - 'type': 'model-fields', - 'fields': { - 'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}, - 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}}, - }, - }, - 'default': ({'field_a': '[default-a]', 'field_b': '[default-b]'}, None, set()), - 'on_error': 'default', - }, - } + schema=core_schema.model_schema( + cls=MyModel, + schema=core_schema.with_default_schema( + 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()), + } + ), + default=({'field_a': '[default-a]', 'field_b': '[default-b]'}, None, set()), + on_error='default', + ), + ) ) m = v.validate_python({'field_a': 'test', 'field_b': 12}) assert isinstance(m, MyModel) @@ -354,7 +364,7 @@ def test_validate_default( else: config = None v = SchemaValidator( - core_schema.typed_dict_schema( + schema=core_schema.typed_dict_schema( { 'x': core_schema.typed_dict_field( core_schema.with_default_schema( @@ -376,7 +386,7 @@ def test_validate_default( def test_validate_default_factory(): v = SchemaValidator( - core_schema.tuple_positional_schema( + schema=core_schema.tuple_positional_schema( [core_schema.with_default_schema(core_schema.int_schema(), default_factory=lambda: '42')] ), config=dict(validate_default=True), @@ -387,7 +397,7 @@ def test_validate_default_factory(): def test_validate_default_error_tuple(): v = SchemaValidator( - core_schema.tuple_positional_schema( + schema=core_schema.tuple_positional_schema( [core_schema.with_default_schema(core_schema.int_schema(), default='wrong', validate_default=True)] ) ) @@ -408,7 +418,7 @@ def test_validate_default_error_tuple(): def test_validate_default_error_typed_dict(): v = SchemaValidator( - core_schema.typed_dict_schema( + 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) @@ -440,35 +450,27 @@ class Model: str_dict_with_default: dict[str, str] = stored_empty_dict v = SchemaValidator( - { - 'type': 'model', - 'cls': Model, - 'schema': { - 'type': 'model-fields', - 'fields': { - 'int_list_with_default': { - 'type': 'model-field', - 'schema': { - 'type': 'default', - 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}, - 'default': stored_empty_list, - }, - }, - 'str_dict_with_default': { - 'type': 'model-field', - 'schema': { - 'type': 'default', - 'schema': { - 'type': 'dict', - 'keys_schema': {'type': 'str'}, - 'values_schema': {'type': 'str'}, - }, - 'default': stored_empty_dict, - }, - }, - }, - }, - } + schema=core_schema.model_schema( + cls=Model, + schema=core_schema.model_fields_schema( + fields={ + 'int_list_with_default': core_schema.model_field( + schema=core_schema.with_default_schema( + schema=core_schema.list_schema(items_schema=core_schema.int_schema()), + default=stored_empty_list, + ) + ), + 'str_dict_with_default': core_schema.model_field( + schema=core_schema.with_default_schema( + schema=core_schema.dict_schema( + keys_schema=core_schema.str_schema(), values_schema=core_schema.str_schema() + ), + default=stored_empty_dict, + ) + ), + } + ), + ) ) m1 = v.validate_python({}) @@ -494,7 +496,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(s) + v = SchemaValidator(schema=s) r = v.get_default_value() assert r is not None @@ -504,7 +506,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(s, core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) r = v.get_default_value() assert r is not None @@ -514,7 +516,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(s, core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) with pytest.raises(ValidationError) as exc_info: v.get_default_value() @@ -531,7 +533,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(s, core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) r = v.get_default_value(strict=True) assert r is not None @@ -541,7 +543,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(s, core_schema.CoreConfig(validate_default=True)) + v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=True)) with pytest.raises(ValidationError) as exc_info: v.get_default_value(strict=True) @@ -553,7 +555,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(s, core_schema.CoreConfig(validate_default=validate_default)) + v = SchemaValidator(schema=s, config=core_schema.CoreConfig(validate_default=validate_default)) assert v.get_default_value() is None @@ -562,7 +564,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(s).get_default_value() + return SchemaValidator(schema=s).get_default_value() res = get_default() assert res is not None @@ -591,19 +593,29 @@ 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(core_schema.with_default_schema(core_schema.int_schema(), default=1)).get_default_value()) + res = f( + SchemaValidator(schema=core_schema.with_default_schema(core_schema.int_schema(), default=1)).get_default_value() + ) assert res == 'case1' - res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default=2)).get_default_value()) + res = f( + SchemaValidator(schema=core_schema.with_default_schema(core_schema.int_schema(), default=2)).get_default_value() + ) assert res == 'case2' - res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default=3)).get_default_value()) + res = f( + SchemaValidator(schema=core_schema.with_default_schema(core_schema.int_schema(), default=3)).get_default_value() + ) assert res == 'case3: 3' - res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default='4')).get_default_value()) + res = f( + SchemaValidator( + schema=core_schema.with_default_schema(core_schema.int_schema(), default='4') + ).get_default_value() + ) assert res == 'case4: str(4)' - res = f(SchemaValidator(core_schema.int_schema()).get_default_value()) + res = f(SchemaValidator(schema=core_schema.int_schema()).get_default_value()) assert res == 'case5' @@ -614,7 +626,7 @@ def val_func(v: Any, handler: core_schema.ValidatorFunctionWrapHandler) -> Any: return handler(v) validator = SchemaValidator( - core_schema.with_default_schema( + schema=core_schema.with_default_schema( core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema()), default=10 ) ) @@ -625,13 +637,15 @@ 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( - core_schema.with_default_schema(core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema())) + 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(core_schema.no_info_wrap_validator_function(val_func, core_schema.int_schema())) + validator = SchemaValidator(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('') @@ -652,7 +666,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) + Defaulted.__pydantic_validator__ = SchemaValidator(schema=schema) return Defaulted @@ -771,7 +785,7 @@ def _raise(ex: Exception) -> None: ) v = SchemaValidator( - core_schema_constructor( + schema=core_schema_constructor( { 'x': field_constructor( core_schema.with_default_schema(inner_schema, default=None, validate_default=True) @@ -806,7 +820,7 @@ def _raise(ex: Exception) -> None: ) z = core_schema.dataclass_field(name='z', schema=core_schema.str_schema()) - v = SchemaValidator(core_schema.dataclass_args_schema('XYZ', [x, y, z])) + v = SchemaValidator(schema=core_schema.dataclass_args_schema('XYZ', [x, y, z])) with pytest.raises(ValidationError) as exc_info: v.validate_python(input_value) From 3fa5d10aeb34f994bd8950c1dbaaf70dc8b435f5 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Mon, 10 Feb 2025 15:09:17 +0000 Subject: [PATCH 05/11] 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) From 96d2c1a2a4f49ff5c9b263ab40dc9e844539f722 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Mon, 10 Feb 2025 17:56:48 +0000 Subject: [PATCH 06/11] update uuid schema --- tests/test_misc.py | 4 +--- tests/validators/test_uuid.py | 4 ++-- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/tests/test_misc.py b/tests/test_misc.py index 6dbdda829..50162c24b 100644 --- a/tests/test_misc.py +++ b/tests/test_misc.py @@ -191,9 +191,7 @@ def test_undefined(): def test_unicode_error_input_repr() -> None: """https://github.com/pydantic/pydantic/issues/6448""" - schema = core_schema.int_schema() - - validator = SchemaValidator(schema) + validator = SchemaValidator(core_schema.int_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/validators/test_uuid.py b/tests/validators/test_uuid.py index c8a609482..5448f25f4 100644 --- a/tests/validators/test_uuid.py +++ b/tests/validators/test_uuid.py @@ -150,9 +150,9 @@ def test_uuid_strict(input_value, expected): ], ) def test_uuid_version(input_value, version, expected): - schema = {'type': 'uuid'} + schema = core_schema.uuid_schema() if version is not None: - schema['version'] = version + schema = core_schema.uuid_schema(version=version) v = SchemaValidator(schema) From f36b1f45891dda484d16780329436fd39c1ce469 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Tue, 11 Feb 2025 07:49:30 +0000 Subject: [PATCH 07/11] revert changes --- tests/validators/test_dataclasses.py | 2 +- tests/validators/test_model_fields.py | 4 ++-- tests/validators/test_typed_dict.py | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py index c5eeebf02..30675c66a 100644 --- a/tests/validators/test_dataclasses.py +++ b/tests/validators/test_dataclasses.py @@ -1055,7 +1055,7 @@ class MyModel: 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), - (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), + (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': None}), (core_schema.CoreConfig(), {'extra_behavior': 'allow'}), (None, {'extra_behavior': 'allow'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'allow'}), diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py index e156eaa6b..717134244 100644 --- a/tests/validators/test_model_fields.py +++ b/tests/validators/test_model_fields.py @@ -1603,7 +1603,7 @@ def test_frozen_field(): 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), - (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), + (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': None}), (core_schema.CoreConfig(), {'extra_behavior': 'allow'}), (None, {'extra_behavior': 'allow'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'allow'}), @@ -1645,7 +1645,7 @@ def test_extra_behavior_allow( 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), - (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), + (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': None}), (core_schema.CoreConfig(), {'extra_behavior': 'forbid'}), (None, {'extra_behavior': 'forbid'}), (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'forbid'}), diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py index cbbd21846..b0cd1f32f 100644 --- a/tests/validators/test_typed_dict.py +++ b/tests/validators/test_typed_dict.py @@ -1057,7 +1057,7 @@ def wrap_function(input_value, validator, info): 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), - (core_schema.CoreConfig(extra_fields_behavior='allow'), {}), + (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': None}), (core_schema.CoreConfig(), {'extra_behavior': 'allow'}), (None, {'extra_behavior': 'allow'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'allow'}), @@ -1091,7 +1091,7 @@ def test_extra_behavior_allow( 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), - (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), + (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': None}), (core_schema.CoreConfig(), {'extra_behavior': 'forbid'}), (None, {'extra_behavior': 'forbid'}), (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'forbid'}), From 3288aece6c251828793e70ccb20f7fcda0b61111 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Tue, 11 Feb 2025 07:59:33 +0000 Subject: [PATCH 08/11] revert removal of cases --- tests/validators/test_dataclasses.py | 2 +- tests/validators/test_model_fields.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py index 30675c66a..c7dc3810e 100644 --- a/tests/validators/test_dataclasses.py +++ b/tests/validators/test_dataclasses.py @@ -961,7 +961,7 @@ class MyModel: 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='ignore'), {}), - (core_schema.CoreConfig(extra_fields_behavior='ignore'), {}), + (core_schema.CoreConfig(extra_fields_behavior='ignore'), {'extra_behavior': None}), (core_schema.CoreConfig(), {'extra_behavior': 'ignore'}), (None, {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'ignore'}), diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py index 717134244..225eb2d2d 100644 --- a/tests/validators/test_model_fields.py +++ b/tests/validators/test_model_fields.py @@ -1611,7 +1611,7 @@ def test_frozen_field(): ) @pytest.mark.parametrize( 'extras_schema_kw, expected_extra_value', - [({}, '123'), ({}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], + [({}, '123'), ({'extras_schema': None}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], ids=['extras_schema=unset', 'extras_schema=None', 'extras_schema=int'], ) def test_extra_behavior_allow( From d69ee245a5362f5e1e373054f3ff8b00d032dbeb Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Tue, 11 Feb 2025 08:02:16 +0000 Subject: [PATCH 09/11] revert removal of cases --- tests/validators/test_model_fields.py | 4 ++-- tests/validators/test_typed_dict.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py index 225eb2d2d..c65a8ae6c 100644 --- a/tests/validators/test_model_fields.py +++ b/tests/validators/test_model_fields.py @@ -1693,8 +1693,8 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche (core_schema.CoreConfig(), {'extra_behavior': 'ignore'}), (None, {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'ignore'}), - (core_schema.CoreConfig(), {}), - (core_schema.CoreConfig(), {}), + (core_schema.CoreConfig(), {'extra_behavior': None}), + (None, {'extra_behavior': None}), (None, {}), ], ) diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py index b0cd1f32f..c8c6b0c95 100644 --- a/tests/validators/test_typed_dict.py +++ b/tests/validators/test_typed_dict.py @@ -1065,7 +1065,7 @@ def wrap_function(input_value, validator, info): ) @pytest.mark.parametrize( 'extras_schema_kw, expected_extra_value', - [({}, '123'), ({}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], + [({}, '123'), ({'extras_schema': None}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)], ids=['extras_schema=unset', 'extras_schema=None', 'extras_schema=int'], ) def test_extra_behavior_allow( From 458ffd97f263e0816b7af3614fa7f989e08a5807 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Tue, 11 Feb 2025 08:12:00 +0000 Subject: [PATCH 10/11] revert removal of cases --- tests/validators/test_dataclasses.py | 2 +- tests/validators/test_definitions_recursive.py | 3 ++- tests/validators/test_model_fields.py | 2 +- tests/validators/test_typed_dict.py | 4 ++-- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py index c7dc3810e..09bd4e762 100644 --- a/tests/validators/test_dataclasses.py +++ b/tests/validators/test_dataclasses.py @@ -1009,7 +1009,7 @@ class MyModel: 'config,schema_extra_behavior_kw', [ (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), - (core_schema.CoreConfig(extra_fields_behavior='forbid'), {}), + (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': None}), (core_schema.CoreConfig(), {'extra_behavior': 'forbid'}), (None, {'extra_behavior': 'forbid'}), (core_schema.CoreConfig(extra_fields_behavior='ignore'), {'extra_behavior': 'forbid'}), diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py index 77368c61a..3f1744dff 100644 --- a/tests/validators/test_definitions_recursive.py +++ b/tests/validators/test_definitions_recursive.py @@ -252,7 +252,8 @@ def test_invalid_schema(): 'width': cs.typed_dict_field(schema=cs.int_schema()), 'branch': cs.typed_dict_field( schema=cs.with_default_schema( - schema=cs.nullable_schema(schema=cs.definition_reference_schema(schema_ref='Branch')) + schema=cs.nullable_schema(schema=cs.definition_reference_schema(schema_ref='Branch')), + default=None ) ), } diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py index c65a8ae6c..e5dd53994 100644 --- a/tests/validators/test_model_fields.py +++ b/tests/validators/test_model_fields.py @@ -1693,9 +1693,9 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche (core_schema.CoreConfig(), {'extra_behavior': 'ignore'}), (None, {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'ignore'}), + (core_schema.CoreConfig(), {}), (core_schema.CoreConfig(), {'extra_behavior': None}), (None, {'extra_behavior': None}), - (None, {}), ], ) def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py index c8c6b0c95..6e3826a3b 100644 --- a/tests/validators/test_typed_dict.py +++ b/tests/validators/test_typed_dict.py @@ -1122,8 +1122,8 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche (None, {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'ignore'}), (core_schema.CoreConfig(), {}), - (core_schema.CoreConfig(), {}), - (None, {}), + (core_schema.CoreConfig(), {'extra_behavior': None}), + (None, {'extra_behavior': None}), ], ) def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]): From a13eac8c839c1373f56e528c26dd344a21d88b20 Mon Sep 17 00:00:00 2001 From: JONEMI21 Date: Tue, 11 Feb 2025 08:13:40 +0000 Subject: [PATCH 11/11] lint --- tests/validators/test_definitions_recursive.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py index 3f1744dff..4c2577408 100644 --- a/tests/validators/test_definitions_recursive.py +++ b/tests/validators/test_definitions_recursive.py @@ -253,7 +253,7 @@ def test_invalid_schema(): 'branch': cs.typed_dict_field( schema=cs.with_default_schema( schema=cs.nullable_schema(schema=cs.definition_reference_schema(schema_ref='Branch')), - default=None + default=None, ) ), }