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',\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/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/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",
  "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",
  "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",
  "filepath": "pydantic/config.py",
  "content": "import json\nfrom enum import Enum\nfrom typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Type, Union\n\nfrom .typing import AnyCallable\nfrom .utils import GetterDict\n\nif TYPE_CHECKING:\n    from typing import overload\n\n    import typing_extensions\n\n    from .fields import ModelField\n    from .main import BaseModel\n\n    ConfigType = Type['BaseConfig']\n\n    class SchemaExtraCallable(typing_extensions.Protocol):\n        @overload\n        def __call__(self, schema: Dict[str, Any]) -> None:\n            pass\n\n        @overload\n        def __call__(self, schema: Dict[str, Any], model_class: Type[BaseModel]) -> None:\n            pass\n\n\nelse:\n    SchemaExtraCallable = Callable[..., None]\n\n__all__ = 'BaseConfig', 'Extra', 'inherit_config', 'prepare_config'\n\n\nclass Extra(str, Enum):\n    allow = 'allow'\n    ignore = 'ignore'\n    forbid = 'forbid'\n\n\nclass BaseConfig:\n    title: Optional[str] = None\n    anystr_lower: bool = False\n    anystr_strip_whitespace: bool = False\n    min_anystr_length: int = 0\n    max_anystr_length: Optional[int] = None\n    validate_all: bool = False\n    extra: Extra = Extra.ignore\n    allow_mutation: bool = True\n    frozen: bool = False\n    allow_population_by_field_name: bool = False\n    use_enum_values: bool = False\n    fields: Dict[str, Union[str, Dict[str, str]]] = {}\n    validate_assignment: bool = False\n    error_msg_templates: Dict[str, str] = {}\n    arbitrary_types_allowed: bool = False\n    orm_mode: bool = False\n    getter_dict: Type[GetterDict] = GetterDict\n    alias_generator: Optional[Callable[[str], str]] = None\n    keep_untouched: Tuple[type, ...] = ()\n    schema_extra: Union[Dict[str, Any], 'SchemaExtraCallable'] = {}\n    json_loads: Callable[[str], Any] = json.loads\n    json_dumps: Callable[..., str] = json.dumps\n    json_encoders: Dict[Type[Any], AnyCallable] = {}\n    underscore_attrs_are_private: bool = False\n\n    # Whether or not inherited models as fields should be reconstructed as base model\n    copy_on_model_validation: bool = True\n\n    @classmethod\n    def get_field_info(cls, name: str) -> Dict[str, Any]:\n        \"\"\"\n        Get properties of FieldInfo from the `fields` property of the config class.\n        \"\"\"\n\n        fields_value = cls.fields.get(name)\n\n        if isinstance(fields_value, str):\n            field_info: Dict[str, Any] = {'alias': fields_value}\n        elif isinstance(fields_value, dict):\n            field_info = fields_value\n        else:\n            field_info = {}\n\n        if 'alias' in field_info:\n            field_info.setdefault('alias_priority', 2)\n\n        if field_info.get('alias_priority', 0) <= 1 and cls.alias_generator:\n            alias = cls.alias_generator(name)\n            if not isinstance(alias, str):\n                raise TypeError(f'Config.alias_generator must return str, not {alias.__class__}')\n            field_info.update(alias=alias, alias_priority=1)\n        return field_info\n\n    @classmethod\n    def prepare_field(cls, field: 'ModelField') -> None:\n        \"\"\"\n        Optional hook to check or modify fields during model creation.\n        \"\"\"\n        pass\n\n\ndef inherit_config(self_config: 'ConfigType', parent_config: 'ConfigType', **namespace: Any) -> 'ConfigType':\n    if not self_config:\n        base_classes: Tuple['ConfigType', ...] = (parent_config,)\n    elif self_config == parent_config:\n        base_classes = (self_config,)\n    else:\n        base_classes = self_config, parent_config\n\n    namespace['json_encoders'] = {\n        **getattr(parent_config, 'json_encoders', {}),\n        **getattr(self_config, 'json_encoders', {}),\n        **namespace.get('json_encoders', {}),\n    }\n\n    return type('Config', base_classes, namespace)\n\n\ndef prepare_config(config: Type[BaseConfig], cls_name: str) -> None:\n    if not isinstance(config.extra, Extra):\n        try:\n            config.extra = Extra(config.extra)\n        except ValueError:\n            raise ValueError(f'\"{cls_name}\": {config.extra} is not a valid value for \"extra\"')",
  "start_line": 1,
  "end_line": 124,
  "total_lines": 124,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Case 1: False\nCase 2: False\nCase 3: True, extra=allow\nCase 4: True, extra=allow\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Case 5: True, extra=ignore\n",
  "stderr": "",
  "exit_code": 0
}