samuelcolvin__pydantic-3177

{
  "status": "ok",
  "stdout": "1 validation error for Test\nother -> z\n  extra fields not permitted (type=value_error.extra)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "pydantic/fields.py:407:                    # check also `Required` because of `validate_arguments` that sets `...` as default value\npydantic/decorator.py:11:__all__ = ('validate_arguments',)\npydantic/decorator.py:21:def validate_arguments(func: None = None, *, config: 'ConfigType' = None) -> Callable[['AnyCallableT'], 'AnyCallableT']:\npydantic/decorator.py:26:def validate_arguments(func: 'AnyCallableT') -> 'AnyCallableT':\npydantic/decorator.py:30:def validate_arguments(func: Optional['AnyCallableT'] = None, *, config: 'ConfigType' = None) -> Any:\npydantic/decorator.py:69:                f'are not permitted as argument names when using the \"{validate_arguments.__name__}\" decorator'\npydantic/decorator.py:218:                '@validate_arguments is not yet supported, please remove.'\npydantic/__init__.py:6:from .decorator import validate_arguments\npydantic/__init__.py:35:    'validate_arguments',\npydantic/error_wrappers.py:8:    from typing_extensions import TypedDict\npydantic/error_wrappers.py:16:    class _ErrorDictRequired(TypedDict):\npydantic/networks.py:34:    from typing_extensions import TypedDict\npydantic/networks.py:42:    class Parts(TypedDict, total=False):\npydantic/annotated_types.py:7:    from typing_extensions import TypedDict\npydantic/annotated_types.py:11:    # Mypy bug: `Type[TypedDict]` is resolved as `Any` https://github.com/python/mypy/issues/11030\npydantic/annotated_types.py:12:    typeddict_cls: Type['TypedDict'],  # type: ignore[valid-type]\npydantic/annotated_types.py:16:    Create a `BaseModel` based on the fields of a `TypedDict`.\npydantic/annotated_types.py:17:    Since `typing.TypedDict` in Python 3.8 does not store runtime information about optional keys,\npydantic/annotated_types.py:22:    # Best case scenario: with python 3.9+ or when `TypedDict` is imported from `typing_extensions`\npydantic/annotated_types.py:25:            'You should use `typing_extensions.TypedDict` instead of `typing.TypedDict`. '\npydantic/validators.py:46:    from typing_extensions import Literal, TypedDict\npydantic/validators.py:581:    typeddict_cls: Type['TypedDict'], config: Type['BaseConfig']  # type: ignore[valid-type]\npydantic/validators.py:585:    TypedDictModel = create_model_from_typeddict(\npydantic/validators.py:590:    typeddict_cls.__pydantic_model__ = TypedDictModel  # type: ignore[attr-defined]\npydantic/validators.py:592:    def typeddict_validator(values: 'TypedDict') -> Dict[str, Any]:  # type: ignore[valid-type]\npydantic/validators.py:593:        return TypedDictModel.parse_obj(values).dict(exclude_unset=True)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "pydantic/annotated_types.py:10:def create_model_from_typeddict(\npydantic/__init__.py:3:from .annotated_types import create_model_from_namedtuple, create_model_from_typeddict\npydantic/__init__.py:25:    'create_model_from_typeddict',\npydantic/validators.py:583:    from .annotated_types import create_model_from_typeddict\npydantic/validators.py:585:    TypedDictModel = create_model_from_typeddict(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pydantic/decorator.py",
  "content": "from functools import wraps\nfrom typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload\n\nfrom . import validator\nfrom .config import Extra\nfrom .errors import ConfigError\nfrom .main import BaseModel, create_model\nfrom .typing import get_all_type_hints\nfrom .utils import to_camel\n\n__all__ = ('validate_arguments',)\n\nif TYPE_CHECKING:\n    from .typing import AnyCallable\n\n    AnyCallableT = TypeVar('AnyCallableT', bound=AnyCallable)\n    ConfigType = Union[None, Type[Any], Dict[str, Any]]\n\n\n@overload\ndef validate_arguments(func: None = None, *, config: 'ConfigType' = None) -> Callable[['AnyCallableT'], 'AnyCallableT']:\n    ...\n\n\n@overload\ndef validate_arguments(func: 'AnyCallableT') -> 'AnyCallableT':\n    ...\n\n\ndef validate_arguments(func: Optional['AnyCallableT'] = None, *, config: 'ConfigType' = None) -> Any:\n    \"\"\"\n    Decorator to validate the arguments passed to a function.\n    \"\"\"\n\n    def validate(_func: 'AnyCallable') -> 'AnyCallable':\n        vd = ValidatedFunction(_func, config)\n\n        @wraps(_func)\n        def wrapper_function(*args: Any, **kwargs: Any) -> Any:\n            return vd.call(*args, **kwargs)\n\n        wrapper_function.vd = vd  # type: ignore\n        wrapper_function.validate = vd.init_model_instance  # type: ignore\n        wrapper_function.raw_function = vd.raw_function  # type: ignore\n        wrapper_function.model = vd.model  # type: ignore\n        return wrapper_function\n\n    if func:\n        return validate(func)\n    else:\n        return validate\n\n\nALT_V_ARGS = 'v__args'\nALT_V_KWARGS = 'v__kwargs'\nV_POSITIONAL_ONLY_NAME = 'v__positional_only'\nV_DUPLICATE_KWARGS = 'v__duplicate_kwargs'\n\n\nclass ValidatedFunction:\n    def __init__(self, function: 'AnyCallableT', config: 'ConfigType'):  # noqa C901\n        from inspect import Parameter, signature\n\n        parameters: Mapping[str, Parameter] = signature(function).parameters\n\n        if parameters.keys() & {ALT_V_ARGS, ALT_V_KWARGS, V_POSITIONAL_ONLY_NAME, V_DUPLICATE_KWARGS}:\n            raise ConfigError(\n                f'\"{ALT_V_ARGS}\", \"{ALT_V_KWARGS}\", \"{V_POSITIONAL_ONLY_NAME}\" and \"{V_DUPLICATE_KWARGS}\" '\n                f'are not permitted as argument names when using the \"{validate_arguments.__name__}\" decorator'\n            )\n\n        self.raw_function = function\n        self.arg_mapping: Dict[int, str] = {}\n        self.positional_only_args = set()\n        self.v_args_name = 'args'\n        self.v_kwargs_name = 'kwargs'\n\n        type_hints = get_all_type_hints(function)\n        takes_args = False\n        takes_kwargs = False\n        fields: Dict[str, Tuple[Any, Any]] = {}\n        for i, (name, p) in enumerate(parameters.items()):\n            if p.annotation is p.empty:\n                annotation = Any\n            else:\n                annotation = type_hints[name]\n\n            default = ... if p.default is p.empty else p.default\n            if p.kind == Parameter.POSITIONAL_ONLY:\n                self.arg_mapping[i] = name\n                fields[name] = annotation, default\n                fields[V_POSITIONAL_ONLY_NAME] = List[str], None\n                self.positional_only_args.add(name)\n            elif p.kind == Parameter.POSITIONAL_OR_KEYWORD:\n                self.arg_mapping[i] = name\n                fields[name] = annotation, default\n                fields[V_DUPLICATE_KWARGS] = List[str], None\n            elif p.kind == Parameter.KEYWORD_ONLY:\n                fields[name] = annotation, default\n            elif p.kind == Parameter.VAR_POSITIONAL:\n                self.v_args_name = name\n                fields[name] = Tuple[annotation, ...], None\n                takes_args = True\n            else:\n                assert p.kind == Parameter.VAR_KEYWORD, p.kind\n                self.v_kwargs_name = name\n                fields[name] = Dict[str, annotation], None  # type: ignore\n                takes_kwargs = True\n\n        # these checks avoid a clash between \"args\" and a field with that name\n        if not takes_args and self.v_args_name in fields:\n            self.v_args_name = ALT_V_ARGS\n\n        # same with \"kwargs\"\n        if not takes_kwargs and self.v_kwargs_name in fields:\n            self.v_kwargs_name = ALT_V_KWARGS\n\n        if not takes_args:\n            # we add the field so validation below can raise the correct exception\n            fields[self.v_args_name] = List[Any], None\n\n        if not takes_kwargs:\n            # same with kwargs\n            fields[self.v_kwargs_name] = Dict[Any, Any], None\n\n        self.create_model(fields, takes_args, takes_kwargs, config)\n\n    def init_model_instance(self, *args: Any, **kwargs: Any) -> BaseModel:\n        values = self.build_values(args, kwargs)\n        return self.model(**values)\n\n    def call(self, *args: Any, **kwargs: Any) -> Any:\n        m = self.init_model_instance(*args, **kwargs)\n        return self.execute(m)\n\n    def build_values(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Dict[str, Any]:\n        values: Dict[str, Any] = {}\n        if args:\n            arg_iter = enumerate(args)\n            while True:\n                try:\n                    i, a = next(arg_iter)\n                except StopIteration:\n                    break\n                arg_name = self.arg_mapping.get(i)\n                if arg_name is not None:\n                    values[arg_name] = a\n                else:\n                    values[self.v_args_name] = [a] + [a for _, a in arg_iter]\n                    break",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 259,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pydantic/decorator.py",
  "content": "\n        var_kwargs = {}\n        wrong_positional_args = []\n        duplicate_kwargs = []\n        non_var_fields = set(self.model.__fields__) - {self.v_args_name, self.v_kwargs_name}\n        for k, v in kwargs.items():\n            if k in non_var_fields:\n                if k in self.positional_only_args:\n                    wrong_positional_args.append(k)\n                if k in values:\n                    duplicate_kwargs.append(k)\n                values[k] = v\n            else:\n                var_kwargs[k] = v\n\n        if var_kwargs:\n            values[self.v_kwargs_name] = var_kwargs\n        if wrong_positional_args:\n            values[V_POSITIONAL_ONLY_NAME] = wrong_positional_args\n        if duplicate_kwargs:\n            values[V_DUPLICATE_KWARGS] = duplicate_kwargs\n        return values\n\n    def execute(self, m: BaseModel) -> Any:\n        d = {k: v for k, v in m._iter() if k in m.__fields_set__ or m.__fields__[k].default_factory}\n        var_kwargs = d.pop(self.v_kwargs_name, {})\n\n        if self.v_args_name in d:\n            args_: List[Any] = []\n            in_kwargs = False\n            kwargs = {}\n            for name, value in d.items():\n                if in_kwargs:\n                    kwargs[name] = value\n                elif name == self.v_args_name:\n                    args_ += value\n                    in_kwargs = True\n                else:\n                    args_.append(value)\n            return self.raw_function(*args_, **kwargs, **var_kwargs)\n        elif self.positional_only_args:\n            args_ = []\n            kwargs = {}\n            for name, value in d.items():\n                if name in self.positional_only_args:\n                    args_.append(value)\n                else:\n                    kwargs[name] = value\n            return self.raw_function(*args_, **kwargs, **var_kwargs)\n        else:\n            return self.raw_function(**d, **var_kwargs)\n\n    def create_model(self, fields: Dict[str, Any], takes_args: bool, takes_kwargs: bool, config: 'ConfigType') -> None:\n        pos_args = len(self.arg_mapping)\n\n        class CustomConfig:\n            pass\n\n        if not TYPE_CHECKING:  # pragma: no branch\n            if isinstance(config, dict):\n                CustomConfig = type('Config', (), config)  # noqa: F811\n            elif config is not None:\n                CustomConfig = config  # noqa: F811\n\n        if hasattr(CustomConfig, 'fields') or hasattr(CustomConfig, 'alias_generator'):\n            raise ConfigError(\n                'Setting the \"fields\" and \"alias_generator\" property on custom Config for '\n                '@validate_arguments is not yet supported, please remove.'\n            )\n\n        class DecoratorBaseModel(BaseModel):\n            @validator(self.v_args_name, check_fields=False, allow_reuse=True)\n            def check_args(cls, v: Optional[List[Any]]) -> Optional[List[Any]]:\n                if takes_args or v is None:\n                    return v\n\n                raise TypeError(f'{pos_args} positional arguments expected but {pos_args + len(v)} given')\n\n            @validator(self.v_kwargs_name, check_fields=False, allow_reuse=True)\n            def check_kwargs(cls, v: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:\n                if takes_kwargs or v is None:\n                    return v\n\n                plural = '' if len(v) == 1 else 's'\n                keys = ', '.join(map(repr, v.keys()))\n                raise TypeError(f'unexpected keyword argument{plural}: {keys}')\n\n            @validator(V_POSITIONAL_ONLY_NAME, check_fields=False, allow_reuse=True)\n            def check_positional_only(cls, v: Optional[List[str]]) -> None:\n                if v is None:\n                    return\n\n                plural = '' if len(v) == 1 else 's'\n                keys = ', '.join(map(repr, v))\n                raise TypeError(f'positional-only argument{plural} passed as keyword argument{plural}: {keys}')\n\n            @validator(V_DUPLICATE_KWARGS, check_fields=False, allow_reuse=True)\n            def check_duplicate_kwargs(cls, v: Optional[List[str]]) -> None:\n                if v is None:\n                    return\n\n                plural = '' if len(v) == 1 else 's'\n                keys = ', '.join(map(repr, v))\n                raise TypeError(f'multiple values for argument{plural}: {keys}')\n\n            class Config(CustomConfig):\n                extra = Extra.forbid\n\n        self.model = create_model(to_camel(self.raw_function.__name__), __base__=DecoratorBaseModel, **fields)",
  "start_line": 151,
  "end_line": 259,
  "total_lines": 259,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "import re\nfrom collections import OrderedDict, deque\nfrom collections.abc import Hashable as CollectionsHashable\nfrom datetime import date, datetime, time, timedelta\nfrom decimal import Decimal, DecimalException\nfrom enum import Enum, IntEnum\nfrom ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network\nfrom pathlib import Path\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Callable,\n    Deque,\n    Dict,\n    FrozenSet,\n    Generator,\n    Hashable,\n    List,\n    NamedTuple,\n    Pattern,\n    Set,\n    Tuple,\n    Type,\n    TypeVar,\n    Union,\n)\nfrom uuid import UUID\n\nfrom . import errors\nfrom .datetime_parse import parse_date, parse_datetime, parse_duration, parse_time\nfrom .typing import (\n    AnyCallable,\n    ForwardRef,\n    all_literal_values,\n    display_as_type,\n    get_class,\n    is_callable_type,\n    is_literal_type,\n    is_namedtuple,\n    is_none_type,\n    is_typeddict,\n)\nfrom .utils import almost_equal_floats, lenient_issubclass, sequence_like\n\nif TYPE_CHECKING:\n    from typing_extensions import Literal, TypedDict\n\n    from .config import BaseConfig\n    from .fields import ModelField\n    from .types import ConstrainedDecimal, ConstrainedFloat, ConstrainedInt\n\n    ConstrainedNumber = Union[ConstrainedDecimal, ConstrainedFloat, ConstrainedInt]\n    AnyOrderedDict = OrderedDict[Any, Any]\n    Number = Union[int, float, Decimal]\n    StrBytes = Union[str, bytes]\n\n\ndef str_validator(v: Any) -> Union[str]:\n    if isinstance(v, str):\n        if isinstance(v, Enum):\n            return v.value\n        else:\n            return v\n    elif isinstance(v, (float, int, Decimal)):\n        # is there anything else we want to add here? If you think so, create an issue.\n        return str(v)\n    elif isinstance(v, (bytes, bytearray)):\n        return v.decode()\n    else:\n        raise errors.StrError()\n\n\ndef strict_str_validator(v: Any) -> Union[str]:\n    if isinstance(v, str) and not isinstance(v, Enum):\n        return v\n    raise errors.StrError()\n\n\ndef bytes_validator(v: Any) -> bytes:\n    if isinstance(v, bytes):\n        return v\n    elif isinstance(v, bytearray):\n        return bytes(v)\n    elif isinstance(v, str):\n        return v.encode()\n    elif isinstance(v, (float, int, Decimal)):\n        return str(v).encode()\n    else:\n        raise errors.BytesError()\n\n\ndef strict_bytes_validator(v: Any) -> Union[bytes]:\n    if isinstance(v, bytes):\n        return v\n    elif isinstance(v, bytearray):\n        return bytes(v)\n    else:\n        raise errors.BytesError()\n\n\nBOOL_FALSE = {0, '0', 'off', 'f', 'false', 'n', 'no'}\nBOOL_TRUE = {1, '1', 'on', 't', 'true', 'y', 'yes'}\n\n\ndef bool_validator(v: Any) -> bool:\n    if v is True or v is False:\n        return v\n    if isinstance(v, bytes):\n        v = v.decode()\n    if isinstance(v, str):\n        v = v.lower()\n    try:\n        if v in BOOL_TRUE:\n            return True\n        if v in BOOL_FALSE:\n            return False\n    except TypeError:\n        raise errors.BoolError()\n    raise errors.BoolError()\n\n\ndef int_validator(v: Any) -> int:\n    if isinstance(v, int) and not (v is True or v is False):\n        return v\n\n    try:\n        return int(v)\n    except (TypeError, ValueError):\n        raise errors.IntegerError()\n\n\ndef strict_int_validator(v: Any) -> int:\n    if isinstance(v, int) and not (v is True or v is False):\n        return v\n    raise errors.IntegerError()\n\n\ndef float_validator(v: Any) -> float:\n    if isinstance(v, float):\n        return v\n\n    try:\n        return float(v)\n    except (TypeError, ValueError):\n        raise errors.FloatError()\n\n\ndef strict_float_validator(v: Any) -> float:\n    if isinstance(v, float):\n        return v",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 723,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "import re\nfrom collections import OrderedDict, deque\nfrom collections.abc import Hashable as CollectionsHashable\nfrom datetime import date, datetime, time, timedelta\nfrom decimal import Decimal, DecimalException\nfrom enum import Enum, IntEnum\nfrom ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network\nfrom pathlib import Path\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Callable,\n    Deque,\n    Dict,\n    FrozenSet,\n    Generator,\n    Hashable,\n    List,\n    NamedTuple,\n    Pattern,\n    Set,\n    Tuple,\n    Type,\n    TypeVar,\n    Union,\n)\nfrom uuid import UUID\n\nfrom . import errors\nfrom .datetime_parse import parse_date, parse_datetime, parse_duration, parse_time\nfrom .typing import (\n    AnyCallable,\n    ForwardRef,\n    all_literal_values,\n    display_as_type,\n    get_class,\n    is_callable_type,\n    is_literal_type,\n    is_namedtuple,\n    is_none_type,\n    is_typeddict,\n)\nfrom .utils import almost_equal_floats, lenient_issubclass, sequence_like\n\nif TYPE_CHECKING:\n    from typing_extensions import Literal, TypedDict\n\n    from .config import BaseConfig\n    from .fields import ModelField\n    from .types import ConstrainedDecimal, ConstrainedFloat, ConstrainedInt\n\n    ConstrainedNumber = Union[ConstrainedDecimal, ConstrainedFloat, ConstrainedInt]\n    AnyOrderedDict = OrderedDict[Any, Any]\n    Number = Union[int, float, Decimal]\n    StrBytes = Union[str, bytes]\n\n\ndef str_validator(v: Any) -> Union[str]:\n    if isinstance(v, str):\n        if isinstance(v, Enum):\n            return v.value\n        else:\n            return v\n    elif isinstance(v, (float, int, Decimal)):\n        # is there anything else we want to add here? If you think so, create an issue.\n        return str(v)\n    elif isinstance(v, (bytes, bytearray)):\n        return v.decode()\n    else:\n        raise errors.StrError()\n\n\ndef strict_str_validator(v: Any) -> Union[str]:\n    if isinstance(v, str) and not isinstance(v, Enum):\n        return v\n    raise errors.StrError()\n\n\ndef bytes_validator(v: Any) -> bytes:\n    if isinstance(v, bytes):\n        return v\n    elif isinstance(v, bytearray):\n        return bytes(v)\n    elif isinstance(v, str):\n        return v.encode()\n    elif isinstance(v, (float, int, Decimal)):\n        return str(v).encode()\n    else:\n        raise errors.BytesError()\n\n\ndef strict_bytes_validator(v: Any) -> Union[bytes]:\n    if isinstance(v, bytes):\n        return v\n    elif isinstance(v, bytearray):\n        return bytes(v)\n    else:\n        raise errors.BytesError()\n\n\nBOOL_FALSE = {0, '0', 'off', 'f', 'false', 'n', 'no'}\nBOOL_TRUE = {1, '1', 'on', 't', 'true', 'y', 'yes'}\n\n\ndef bool_validator(v: Any) -> bool:\n    if v is True or v is False:\n        return v\n    if isinstance(v, bytes):\n        v = v.decode()\n    if isinstance(v, str):\n        v = v.lower()\n    try:\n        if v in BOOL_TRUE:\n            return True\n        if v in BOOL_FALSE:\n            return False\n    except TypeError:\n        raise errors.BoolError()\n    raise errors.BoolError()\n\n\ndef int_validator(v: Any) -> int:\n    if isinstance(v, int) and not (v is True or v is False):\n        return v\n\n    try:\n        return int(v)\n    except (TypeError, ValueError):\n        raise errors.IntegerError()\n\n\ndef strict_int_validator(v: Any) -> int:\n    if isinstance(v, int) and not (v is True or v is False):\n        return v\n    raise errors.IntegerError()\n\n\ndef float_validator(v: Any) -> float:\n    if isinstance(v, float):\n        return v\n\n    try:\n        return float(v)\n    except (TypeError, ValueError):\n        raise errors.FloatError()\n\n\ndef strict_float_validator(v: Any) -> float:\n    if isinstance(v, float):\n        return v",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 723,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "\n    NamedTupleModel = create_model_from_namedtuple(\n        namedtuple_cls,\n        __module__=namedtuple_cls.__module__,\n    )\n    namedtuple_cls.__pydantic_model__ = NamedTupleModel  # type: ignore[attr-defined]\n\n    def namedtuple_validator(values: Tuple[Any, ...]) -> NamedTupleT:\n        annotations = NamedTupleModel.__annotations__\n\n        if len(values) > len(annotations):\n            raise errors.ListMaxLengthError(limit_value=len(annotations))\n\n        dict_values: Dict[str, Any] = dict(zip(annotations, values))\n        validated_dict_values: Dict[str, Any] = dict(NamedTupleModel(**dict_values))\n        return namedtuple_cls(**validated_dict_values)\n\n    return namedtuple_validator\n\n\ndef make_typeddict_validator(\n    typeddict_cls: Type['TypedDict'], config: Type['BaseConfig']  # type: ignore[valid-type]\n) -> Callable[[Any], Dict[str, Any]]:\n    from .annotated_types import create_model_from_typeddict\n\n    TypedDictModel = create_model_from_typeddict(\n        typeddict_cls,\n        __config__=config,\n        __module__=typeddict_cls.__module__,\n    )\n    typeddict_cls.__pydantic_model__ = TypedDictModel  # type: ignore[attr-defined]\n\n    def typeddict_validator(values: 'TypedDict') -> Dict[str, Any]:  # type: ignore[valid-type]\n        return TypedDictModel.parse_obj(values).dict(exclude_unset=True)\n\n    return typeddict_validator\n\n\nclass IfConfig:\n    def __init__(self, validator: AnyCallable, *config_attr_names: str) -> None:\n        self.validator = validator\n        self.config_attr_names = config_attr_names\n\n    def check(self, config: Type['BaseConfig']) -> bool:\n        return any(getattr(config, name) not in {None, False} for name in self.config_attr_names)\n\n\n# order is important here, for example: bool is a subclass of int so has to come first, datetime before date same,\n# IPv4Interface before IPv4Address, etc\n_VALIDATORS: List[Tuple[Type[Any], List[Any]]] = [\n    (IntEnum, [int_validator, enum_member_validator]),\n    (Enum, [enum_member_validator]),\n    (\n        str,\n        [\n            str_validator,\n            IfConfig(anystr_strip_whitespace, 'anystr_strip_whitespace'),\n            IfConfig(anystr_lower, 'anystr_lower'),\n            IfConfig(anystr_length_validator, 'min_anystr_length', 'max_anystr_length'),\n        ],\n    ),\n    (\n        bytes,\n        [\n            bytes_validator,\n            IfConfig(anystr_strip_whitespace, 'anystr_strip_whitespace'),\n            IfConfig(anystr_lower, 'anystr_lower'),\n            IfConfig(anystr_length_validator, 'min_anystr_length', 'max_anystr_length'),\n        ],\n    ),\n    (bool, [bool_validator]),\n    (int, [int_validator]),\n    (float, [float_validator]),\n    (Path, [path_validator]),\n    (datetime, [parse_datetime]),\n    (date, [parse_date]),\n    (time, [parse_time]),\n    (timedelta, [parse_duration]),\n    (OrderedDict, [ordered_dict_validator]),\n    (dict, [dict_validator]),\n    (list, [list_validator]),\n    (tuple, [tuple_validator]),\n    (set, [set_validator]),\n    (frozenset, [frozenset_validator]),\n    (deque, [deque_validator]),\n    (UUID, [uuid_validator]),\n    (Decimal, [decimal_validator]),\n    (IPv4Interface, [ip_v4_interface_validator]),\n    (IPv6Interface, [ip_v6_interface_validator]),\n    (IPv4Address, [ip_v4_address_validator]),\n    (IPv6Address, [ip_v6_address_validator]),\n    (IPv4Network, [ip_v4_network_validator]),\n    (IPv6Network, [ip_v6_network_validator]),\n]\n\n\ndef find_validators(  # noqa: C901 (ignore complexity)\n    type_: Type[Any], config: Type['BaseConfig']\n) -> Generator[AnyCallable, None, None]:\n    from .dataclasses import is_builtin_dataclass, make_dataclass_validator\n\n    if type_ is Any or type_ is object:\n        return\n    type_type = type_.__class__\n    if type_type == ForwardRef or type_type == TypeVar:\n        return\n\n    if is_none_type(type_):\n        yield none_validator\n        return\n    if type_ is Pattern:\n        yield pattern_validator\n        return\n    if type_ is Hashable or type_ is CollectionsHashable:\n        yield hashable_validator\n        return\n    if is_callable_type(type_):\n        yield callable_validator\n        return\n    if is_literal_type(type_):\n        yield make_literal_validator(type_)\n        return\n    if is_builtin_dataclass(type_):\n        yield from make_dataclass_validator(type_, config)\n        return\n    if type_ is Enum:\n        yield enum_validator\n        return\n    if type_ is IntEnum:\n        yield int_enum_validator\n        return\n    if is_namedtuple(type_):\n        yield tuple_validator\n        yield make_namedtuple_validator(type_)\n        return\n    if is_typeddict(type_):\n        yield make_typeddict_validator(type_, config)\n        return\n\n    class_ = get_class(type_)\n    if class_ is not None:\n        if isinstance(class_, type):\n            yield make_class_validator(class_)\n        else:\n            yield any_class_validator\n        return\n\n    for val_type, validators in _VALIDATORS:\n        try:\n            if issubclass(type_, val_type):",
  "start_line": 560,
  "end_line": 709,
  "total_lines": 723,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "test() got an unexpected keyword argument 'y'\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Testing Extra.allow...\ntest_allow: Failed: 1 validation error for TestAllow\nother -> z\n  extra fields not permitted (type=value_error.extra)\n\nTesting default (should forbid)...\ntest_default: Failed (Expected): 1 validation error for TestDefault\nother -> z\n  extra fields not permitted (type=value_error.extra)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pydantic/decorator.py",
  "content": "from functools import wraps\nfrom typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload\n\nfrom . import validator\nfrom .config import Extra\nfrom .errors import ConfigError\nfrom .main import BaseModel, create_model\nfrom .typing import get_all_type_hints\nfrom .utils import to_camel\n\n__all__ = ('validate_arguments',)\n\nif TYPE_CHECKING:\n    from .typing import AnyCallable\n\n    AnyCallableT = TypeVar('AnyCallableT', bound=AnyCallable)\n    ConfigType = Union[None, Type[Any], Dict[str, Any]]\n\n\n@overload\ndef validate_arguments(func: None = None, *, config: 'ConfigType' = None) -> Callable[['AnyCallableT'], 'AnyCallableT']:\n    ...\n\n\n@overload\ndef validate_arguments(func: 'AnyCallableT') -> 'AnyCallableT':\n    ...\n\n\ndef validate_arguments(func: Optional['AnyCallableT'] = None, *, config: 'ConfigType' = None) -> Any:\n    \"\"\"\n    Decorator to validate the arguments passed to a function.\n    \"\"\"\n\n    def validate(_func: 'AnyCallable') -> 'AnyCallable':\n        vd = ValidatedFunction(_func, config)\n\n        @wraps(_func)\n        def wrapper_function(*args: Any, **kwargs: Any) -> Any:\n            return vd.call(*args, **kwargs)\n\n        wrapper_function.vd = vd  # type: ignore\n        wrapper_function.validate = vd.init_model_instance  # type: ignore\n        wrapper_function.raw_function = vd.raw_function  # type: ignore\n        wrapper_function.model = vd.model  # type: ignore\n        return wrapper_function\n\n    if func:\n        return validate(func)\n    else:",
  "start_line": 1,
  "end_line": 50,
  "total_lines": 259,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pydantic/decorator.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/pydantic/decorator.py\n+++ b/pydantic/decorator.py\n@@ -254,6 +254,6 @@\n                 raise TypeError(f'multiple values for argument{plural}: {keys}')\n \n             class Config(CustomConfig):\n-                extra = Extra.forbid\n+                extra = getattr(CustomConfig, 'extra', Extra.forbid)\n \n         self.model = create_model(to_camel(self.raw_function.__name__), __base__=DecoratorBaseModel, **fields)\n",
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Testing Extra.allow...\ntest_allow: Success\n\nTesting default (should forbid)...\ntest_default: Failed (Expected): 1 validation error for TestDefault\nother -> z\n  extra fields not permitted (type=value_error.extra)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Testing Extra.ignore...\ntest_ignore: Success\n",
  "stderr": "",
  "exit_code": 0
}