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",
  "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": "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",
  "stdout": "pydantic/annotated_types.py:10:def create_model_from_typeddict(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pydantic/annotated_types.py",
  "content": "from typing import TYPE_CHECKING, Any, Dict, FrozenSet, NamedTuple, Type\n\nfrom .fields import Required\nfrom .main import BaseModel, create_model\n\nif TYPE_CHECKING:\n    from typing_extensions import TypedDict\n\n\ndef create_model_from_typeddict(\n    # Mypy bug: `Type[TypedDict]` is resolved as `Any` https://github.com/python/mypy/issues/11030\n    typeddict_cls: Type['TypedDict'],  # type: ignore[valid-type]\n    **kwargs: Any,\n) -> Type['BaseModel']:\n    \"\"\"\n    Create a `BaseModel` based on the fields of a `TypedDict`.\n    Since `typing.TypedDict` in Python 3.8 does not store runtime information about optional keys,\n    we raise an error if this happens (see https://bugs.python.org/issue38834).\n    \"\"\"\n    field_definitions: Dict[str, Any]\n\n    # Best case scenario: with python 3.9+ or when `TypedDict` is imported from `typing_extensions`\n    if not hasattr(typeddict_cls, '__required_keys__'):\n        raise TypeError(\n            'You should use `typing_extensions.TypedDict` instead of `typing.TypedDict`. '\n            'Without it, there is no way to differentiate required and optional fields when subclassed.'\n        )\n\n    required_keys: FrozenSet[str] = typeddict_cls.__required_keys__  # type: ignore[attr-defined]\n    field_definitions = {\n        field_name: (field_type, Required if field_name in required_keys else None)\n        for field_name, field_type in typeddict_cls.__annotations__.items()\n    }\n\n    return create_model(typeddict_cls.__name__, **kwargs, **field_definitions)\n\n\ndef create_model_from_namedtuple(namedtuple_cls: Type['NamedTuple'], **kwargs: Any) -> Type['BaseModel']:\n    \"\"\"\n    Create a `BaseModel` based on the fields of a named tuple.\n    A named tuple can be created with `typing.NamedTuple` and declared annotations\n    but also with `collections.namedtuple`, in this case we consider all fields\n    to have type `Any`.\n    \"\"\"\n    # With python 3.10+, `__annotations__` always exists but can be empty hence the `getattr... or...` logic\n    namedtuple_annotations: Dict[str, Type[Any]] = getattr(namedtuple_cls, '__annotations__', None) or {\n        k: Any for k in namedtuple_cls._fields\n    }\n    field_definitions: Dict[str, Any] = {\n        field_name: (field_type, Required) for field_name, field_type in namedtuple_annotations.items()\n    }\n    return create_model(namedtuple_cls.__name__, **kwargs, **field_definitions)",
  "start_line": 1,
  "end_line": 52,
  "total_lines": 52,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "        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",
  "start_line": 570,
  "end_line": 600,
  "total_lines": 723,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "pydantic/validators.py:580:def make_typeddict_validator(\npydantic/validators.py:696:        yield make_typeddict_validator(type_, config)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "    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):\n                for v in validators:\n                    if isinstance(v, IfConfig):\n                        if v.check(config):\n                            yield v.validator\n                    else:\n                        yield v\n                return\n        except TypeError:\n            raise RuntimeError(f'error checking inheritance of {type_!r} (type: {display_as_type(type_)})')\n\n    if config.arbitrary_types_allowed:",
  "start_line": 670,
  "end_line": 720,
  "total_lines": 723,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "660-\n661-    if type_ is Any or type_ is object:\n662-        return\n663-    type_type = type_.__class__\n664-    if type_type == ForwardRef or type_type == TypeVar:\n665-        return\n666-\n667-    if is_none_type(type_):\n668-        yield none_validator\n669-        return\n670:    if type_ is Pattern:\n671-        yield pattern_validator\n672-        return\n673-    if type_ is Hashable or type_ is CollectionsHashable:\n674-        yield hashable_validator\n675-        return\n676-    if is_callable_type(type_):\n677-        yield callable_validator\n678-        return\n679-    if is_literal_type(type_):\n680-        yield make_literal_validator(type_)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "        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:",
  "start_line": 600,
  "end_line": 670,
  "total_lines": 723,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Default extra: forbid\nAllow extra: allow\n",
  "stderr": "",
  "exit_code": 0
}