samuelcolvin__pydantic-3177

The user is reporting a bug where the `extra` config is not respected for `TypedDict` when using the `validate_arguments` decorator in pydantic.

Specifically:
```python
from typing_extensions import TypedDict
from pydantic import validate_arguments, Extra

class TypedTest(TypedDict):
    y: str

@validate_arguments(config={'extra': Extra.allow})
def test(other: TypedTest):
    pass

test(other={'y': 'b', 'z': 'a'})
```
This should pass with `Extra.allow`, but it currently raises a `ValidationError` saying "extra fields not permitted".

Let's start by reproducing this.

{
  "command": "python3 - <<'PY'\nfrom typing_extensions import TypedDict\nfrom pydantic import validate_arguments, Extra\n\nclass TypedTest(TypedDict):\n    y: str\n\n@validate_arguments(config={'extra': Extra.allow})\ndef test(other: TypedTest):\n    pass\n\ntry:\n    test(other={'y': 'b', 'z': 'a'})\n    print(\"Success\")\nexcept Exception as e:\n    print(e)\nPY\n"
}

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

The reproduction is successful. The `extra` config is not respected for `TypedDict`.

Now I need to find where `validate_arguments` and `TypedDict` validation are handled in Pydantic.

`validate_arguments` is likely in `pydantic/decorator.py`.
Validation for `TypedDict` should be handled by Pydantic's internal type handling, possibly in `pydantic/main.py`, `pydantic/typing.py`, or `pydantic/parse.py`.

Let's search for `validate_arguments` and where `TypedDict` is handled.

{
  "command": "grep -rn --include=\"*.py\" \"validate_arguments\" pydantic/ | head -n 20\ngrep -rn --include=\"*.py\" \"TypedDict\" pydantic/ | head -n 20\n"
}

{
  "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
}

`pydantic/decorator.py` is where `validate_arguments` is defined.
`pydantic/validators.py` seems to have some `TypedDict` handling: `typeddict_validator` and `create_model_from_typeddict` (wait, `create_model_from_typeddict` is called but not defined in `validators.py`? Let me check `validators.py` and maybe `main.py` or `typing.py`).

Wait, `pydantic/validators.py:585: TypedDictModel = create_model_from_typeddict(`. I should check where `create_model_from_typeddict` is defined.

Let's search for `create_model_from_typeddict`.

{
  "command": "grep -rn \"create_model_from_typeddict\" pydantic/\n"
}

{
  "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
}

Okay, `create_model_from_typeddict` is in `pydantic/annotated_types.py`.

And `pydantic/validators.py` has `typeddict_validator`:
```python
def typeddict_validator(values: 'TypedDict') -> Dict[str, Any]:  # type: ignore[valid-type]
    return TypedDictModel.parse_obj(values).dict(exclude_unset=True)
```

Looking at the reproduction:
```python
@validate_arguments(config={'extra': Extra.allow})
def test(other: TypedTest):
    pass
```
`validate_arguments` creates a Pydantic model internally to validate the arguments of the function.

Let's look at `pydantic/decorator.py` to see how it uses the config.

{
  "filepath": "pydantic/decorator.py"
}

{
  "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
}

The `ValidatedFunction` uses `self.create_model(fields, takes_args, takes_kwargs, config)`. I need to read the rest of `pydantic/decorator.py`.

{
  "filepath": "pydantic/decorator.py",
  "start_line": 151
}

{
  "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
}

In `create_model`:
```python
        class DecoratorBaseModel(BaseModel):
            # ... validators ...
            class Config(CustomConfig):
                extra = Extra.forbid
```
The `DecoratorBaseModel` has `extra = Extra.forbid` by default.
Wait, it's `class Config(CustomConfig): extra = Extra.forbid`. If `CustomConfig` has `extra = Extra.allow`, it should be overridden by `extra = Extra.forbid` inside `DecoratorBaseModel.Config`.

Wait, if `config` is passed to `validate_arguments`, it becomes `CustomConfig`.
If `config={'extra': Extra.allow}`, then `CustomConfig` has `extra = Extra.allow`.
But `DecoratorBaseModel.Config` explicitly sets `extra = Extra.forbid`.

Actually, the user is reporting that a `TypedDict` argument is failing validation because of extra fields.
The `TypedDict` is being validated by Pydantic.

In the reproduction:
```python
class TypedTest(TypedDict):
    y: str

@validate_arguments(config={'extra': Extra.allow})
def test(other: TypedTest):
    pass
```
The arguments of `test` are validated by `DecoratorBaseModel`.
The field `other` has type `TypedTest`.

When `test(other={'y': 'b', 'z': 'a'})` is called, Pydantic validates `other`.
The validation of `TypedDict` is done by `typeddict_validator` in `pydantic/validators.py`.

Let's examine `pydantic/validators.py` again.

{
  "end_line": 600,
  "filepath": "pydantic/validators.py",
  "start_line": 570
}

{
  "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
}

`make_typeddict_validator` takes `config: Type['BaseConfig']`.
It creates a `TypedDictModel` using `create_model_from_typeddict(typeddict_cls, __config__=config, ...)`.

Let's see how `create_model_from_typeddict` is implemented in `pydantic/annotated_types.py`.

{
  "filepath": "pydantic/annotated_types.py"
}

{
  "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
}

`create_model_from_typeddict` calls `create_model(typeddict_cls.__name__, **kwargs, **field_definitions)`.
The `__config__` passed via `kwargs` is passed to `create_model`.

Now, how is the validator for `TypedDict` (which calls `make_typeddict_validator`) created?

I suspect it's in `pydantic/main.py` or `pydantic/typing.py` where Pydantic determines how to validate a type.

Let's search for `make_typeddict_validator` usage.

{
  "command": "grep -rn \"make_typeddict_validator\" pydantic/\n"
}

{
  "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
}

Let's find where `make_typeddict_validator` is called in `pydantic/validators.py`.

{
  "end_line": 710,
  "filepath": "pydantic/validators.py",
  "start_line": 670
}

{
  "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:",
  "start_line": 670,
  "end_line": 710,
  "total_lines": 723,
  "is_truncated": false
}

It seems `make_typeddict_validator` is called with `config`. This `config` likely comes from the `Config` class of the model being validated.

In `validate_arguments`, it creates a `DecoratorBaseModel` whose `Config` is inherited from `CustomConfig` (which is the `config` passed to `validate_arguments`).

Wait, look at this:
```python
            class Config(CustomConfig):
                extra = Extra.forbid
```
`DecoratorBaseModel.Config` always sets `extra = Extra.forbid`. This means any extra arguments passed to the function will be forbidden, regardless of the `config` passed to `validate_arguments`.

Wait, that's for the function arguments. But the issue is about *extra fields in a TypedDict argument*.

In `validate_arguments`, the fields are the function arguments.
For `def test(other: TypedTest)`, there is one field `other` of type `TypedTest`.
The value of `other` is `{'y': 'b', 'z': 'a'}`.
This value is passed to the validator for `TypedTest`.

The validator for `TypedTest` is created by `make_typeddict_validator(TypedTest, config)`.
What is this `config`?

The validator is applied to the field `other`. The `config` used for validation of fields in a model is the model's config.
In this case, the model is `DecoratorBaseModel`.
`DecoratorBaseModel.Config` has `extra = Extra.forbid`.

However, `make_typeddict_validator` is called with `config`.
If `DecoratorBaseModel`'s config is used, it has `extra = Extra.forbid`.

Wait, if `validate_arguments(config={'extra': Extra.allow})` is used, then `CustomConfig` has `extra = Extra.allow`.
But `DecoratorBaseModel.Config` inherits from `CustomConfig` AND sets `extra = Extra.forbid`.

```python
            class Config(CustomConfig):
                extra = Extra.forbid
```
So `DecoratorBaseModel.Config.extra` is ALWAYS `Extra.forbid`.

Is this intended?
The `validate_arguments` config is used to customize the validation of the function arguments.
If we want to allow extra arguments to the function, we would need `extra = Extra.allow` in `DecoratorBaseModel.Config`.
But `DecoratorBaseModel.Config` explicitly sets `extra = Extra.forbid`. This is to prevent users from passing unexpected keyword arguments to the function.

Wait, if `DecoratorBaseModel.Config.extra = Extra.forbid`, then any extra arguments passed to the function will trigger a validation error. This is expected for the function arguments themselves.

But the user is passing an extra field *inside* the `TypedDict`.
The `TypedDict` validator is created using the model's config.
If the model's config is `Extra.forbid`, then `make_typeddict_validator` creates a `TypedDictModel` with `extra = Extra.forbid`.

If the user wants to allow extra fields in the `TypedDict`, they should be able to do so via the `config` in `validate_arguments`.

If the user provides `config={'extra': Extra.allow}`, then `CustomConfig` has `extra = Extra.allow`.
`DecoratorBaseModel.Config` inherits from `CustomConfig`.
If we change:
```python
            class Config(CustomConfig):
                extra = Extra.forbid
```
to something that respects `CustomConfig.extra` if it's set?

But if we remove `extra = Extra.forbid`, then by default (if `CustomConfig` doesn't have `extra`), `BaseModel.Config.extra` is `Extra.ignore`.
Pydantic's default for `BaseModel` is `Extra.ignore`.
But `validate_arguments` seems to want to forbid extra arguments by default.

Let's check the default behavior of `validate_arguments` without `config`.

{
  "command": "python3 - <<'PY'\nfrom pydantic import validate_arguments\n\n@validate_arguments\ndef test(y: str):\n    pass\n\ntry:\n    test(y='b', z='a')\n    print(\"Success\")\nexcept Exception as e:\n    print(e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "1 validation error for Test\nkwargs\n  unexpected keyword argument: 'z' (type=type_error)\n",
  "stderr": "",
  "exit_code": 0
}

Wait, the error is:
`1 validation error for Test\nkwargs\n  unexpected keyword argument: 'z' (type=type_error)`
This error comes from the `check_kwargs` validator in `DecoratorBaseModel`, not from `extra = Extra.forbid` in `Config`.

```python
            @validator(self.v_kwargs_name, check_fields=False, allow_reuse=True)
            def check_kwargs(cls, v: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
                if takes_kwargs or v is None:
                    return v

                plural = '' if len(v) == 1 else 's'
                keys = ', '.join(map(repr, v.keys()))
                raise TypeError(f'unexpected keyword argument{plural}: {keys}')
```

So `extra = Extra.forbid` in `DecoratorBaseModel.Config` is not what's catching the extra function arguments.

Then why is it there?
Maybe it's to prevent `BaseModel`'s internal handling of extra fields from interfering?

Let's see what happens if we use `Extra.allow` in `validate_arguments` and pass an extra argument to the function.

{
  "command": "python3 - <<'PY'\nfrom pydantic import validate_arguments, Extra\n\n@validate_arguments(config={'extra': Extra.allow})\ndef test(y: str):\n    pass\n\ntry:\n    test(y='b', z='a')\n    print(\"Success\")\nexcept Exception as e:\n    print(e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "1 validation error for Test\nkwargs\n  unexpected keyword argument: 'z' (type=type_error)\n",
  "stderr": "",
  "exit_code": 0
}

Still the same error. The `check_kwargs` validator is still firing.

So `extra = Extra.forbid` in `DecoratorBaseModel.Config` doesn't seem to affect function arguments because they are handled by the `v_kwargs_name` field.

But what about the `TypedDict`?
The `TypedDict` is a field in the `DecoratorBaseModel`.
When Pydantic validates the fields of `DecoratorBaseModel`, it uses the config of `DecoratorBaseModel`.
`DecoratorBaseModel.Config.extra` is `Extra.forbid`.

When `make_typeddict_validator(type_, config)` is called, `config` is `DecoratorBaseModel.Config`.
Thus, `TypedDictModel` is created with `extra = Extra.forbid`.

If we want `validate_arguments(config={'extra': Extra.allow})` to allow extra fields in `TypedDict`s, we need `DecoratorBaseModel.Config.extra` to be `Extra.allow` when the user specifies it.

But if we just do:
```python
            class Config(CustomConfig):
                extra = Extra.forbid
```
We are overriding whatever `CustomConfig` had.

If we want to respect `CustomConfig.extra` if it's provided, and default to `Extra.forbid` otherwise, we can do something like:

```python
        # in create_model
        # ...
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                if not hasattr(CustomConfig, 'extra'):
                    extra = Extra.forbid
```
Wait, you can't have an `if` inside a class definition like that for class attributes. You'd have to do it outside or use a different approach.

Actually, `CustomConfig` is a class.

```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
```

If the user passed `config={'extra': Extra.allow}`, then `CustomConfig.extra` is `Extra.allow`.
Then `DecoratorBaseModel.Config` inherits from `CustomConfig`, but then it sets `extra = Extra.forbid`.

If we want to avoid overriding `extra` if it's already present in `CustomConfig`, we could do:

```python
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                pass
```
And set `extra = Extra.forbid` on `CustomConfig` if it's not already there.

Let's try this hypothesis. If we change `DecoratorBaseModel.Config` to just `class Config(CustomConfig): pass` and ensure `CustomConfig` has `extra = Extra.forbid` by default.

Wait, `CustomConfig` is:
1. `type('Config', (), config)` if `config` is a dict.
2. `config` if `config` is a class.
3. `CustomConfig` (the one defined as `class CustomConfig: pass`) if `config` is `None`.

In case 3, `CustomConfig` is empty. So `Config` would inherit from `BaseModel.Config` (implicitly via `DecoratorBaseModel`) and `CustomConfig`.
Wait, `DecoratorBaseModel` inherits from `BaseModel`. `BaseModel` has its own `Config`.

If we have:
```python
class DecoratorBaseModel(BaseModel):
    class Config(CustomConfig):
        extra = Extra.forbid
```
Then `DecoratorBaseModel.Config` is a class that inherits from `CustomConfig`.
If `CustomConfig` is the empty class, then `DecoratorBaseModel.Config` only has `extra = Extra.forbid`.

If `CustomConfig` has `extra = Extra.allow`, then `DecoratorBaseModel.Config` still has `extra = Extra.forbid` because it's defined in the subclass.

If we change it to:
```python
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                pass
```
Then:
- If `config` was `{'extra': Extra.allow}`, `CustomConfig.extra` is `Extra.allow`, so `DecoratorBaseModel.Config.extra` is `Extra.allow`.
- If `config` was `None`, `CustomConfig` is empty. `DecoratorBaseModel.Config` is empty. `BaseModel`'s default config (which is `Extra.ignore`) will be used? No, Pydantic models' `Config` class is used to override defaults. If `Config` is empty, it uses `BaseModel` defaults.

Wait, does the user want the default to remain `Extra.forbid`?
The current implementation explicitly sets `extra = Extra.forbid`.

If we want to maintain the default of `Extra.forbid` but allow the user to override it via `config`, we should check if `extra` is already in `CustomConfig`.

Let's see how to do that.

```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
            else:
                CustomConfig = type('Config', (), {}) # Ensure it's a class
```

And then for `DecoratorBaseModel.Config`:

```python
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                # We want to set extra = Extra.forbid ONLY IF CustomConfig doesn't have it
                pass
```

But you can't easily do conditional attribute setting inside a class definition.
However, we can set it on `CustomConfig` itself before it's used in `DecoratorBaseModel`.

```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
            else:
                CustomConfig = type('Config', (), {}) # Ensure it's a class

            if not hasattr(CustomConfig, 'extra'):
                CustomConfig.extra = Extra.forbid
```

Wait, if `CustomConfig` is a class passed by the user, we might not want to modify it in place. We should create a subclass.

```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
            else:
                CustomConfig = type('Config', (), {})

            # Create a new config class that inherits from CustomConfig and adds extra=Extra.forbid if needed
            # But wait, CustomConfig might already be a Config class.
            
            # Better:
            BaseConfig = CustomConfig
            if not hasattr(CustomConfig, 'extra'):
                # Create a subclass that adds extra = Extra.forbid
                BaseConfig = type('Config', (CustomConfig,), {'extra': Extra.forbid})
```

And then:
```python
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(BaseConfig):
                pass
```

Let's verify if this fixes the issue.

Wait, if `DecoratorBaseModel.Config` is used for `make_typeddict_validator`, and it now has `extra = Extra.allow` (when the user passed it), then `TypedDictModel` will be created with `extra = Extra.allow`, and the validation should pass.

Let's try the reproduction again with this change in mind.

Actually, I'll first check if there are any other places where `DecoratorBaseModel.Config` is used. It's used by the `DecoratorBaseModel` itself. If `extra` is `Extra.allow`, then `DecoratorBaseModel` would allow extra fields.
But wait, `DecoratorBaseModel` is used to validate the arguments of the function.
The arguments of the function are:
- the actual parameters of the function
- `v_args_name` (list of positional args)
- `v_kwargs_name` (dict of keyword args)
- `V_POSITIONAL_ONLY_NAME` (list of wrong positional args)
- `V_DUPLICATE_KWARGS` (list of duplicate kwargs)

If we set `extra = Extra.allow`, it means we can pass extra fields to `DecoratorBaseModel(**values)`.
But `values` is constructed by `build_values`:

```python
    def build_values(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Dict[str, Any]:
        values: Dict[str, Any] = {}
        # ... (handles args) ...
        # ... (handles kwargs) ...
```

Wait, let's look at the end of `build_values` (lines 151-178).

```python
        var_kwargs = {}
        wrong_positional_args = []
        duplicate_kwargs = []
        non_var_fields = set(self.model.__fields__) - {self.v_args_name, self.v_kwargs_name}
        for k, v in kwargs.items():
            if k in non_var_fields:
                if k in self.positional_only_args:
                    wrong_positional_args.append(k)
                if k in values:
                    duplicate_kwargs.append(k)
                values[k] = v
            else:
                var_kwargs[k] = v

        if var_kwargs:
            values[self.v_kwargs_name] = var_kwargs
```

If there are extra kwargs that don't match any function parameter, they are put into `var_kwargs`, which is then assigned to `values[self.v_kwargs_name]`.
Then `DecoratorBaseModel(**values)` is called.
Since `values` only contains names of fields that are actually in `DecoratorBaseModel` (the parameters, and the `v_args_name`, `v_kwargs_name`, etc.), there are NO extra fields being passed to `DecoratorBaseModel`.

So `extra = Extra.allow` in `DecoratorBaseModel.Config` will NOT allow extra arguments to the function, because the `build_values` method and the `check_kwargs` validator already handle that.

Therefore, it is safe to let `DecoratorBaseModel.Config.extra` be whatever the user specified in `config={'extra': ...}`, defaulting to `Extra.forbid`.

Wait, let's re-verify: does `check_kwargs` use `self.model.Config.extra`?
No, it's a validator on the `v_kwargs_name` field.

```python
            @validator(self.v_kwargs_name, check_fields=False, allow_reuse=True)
            def check_kwargs(cls, v: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
                if takes_kwargs or v is None:
                    return v

                plural = '' if len(v) == 1 else 's'
                keys = ', '.join(map(repr, v.keys()))
                raise TypeError(f'unexpected keyword argument{plural}: {keys}')
```

If `takes_kwargs` is `False` (i.e., the function doesn't have `**kwargs`), it always raises `TypeError` if there are extra kwargs. This is correct.

So the only place `DecoratorBaseModel.Config.extra` is used is when it's passed to `make_typeddict_validator`, which then uses it to create the `TypedDictModel`.

This seems to be the root cause.

Let's implement the fix.

I will modify `pydantic/decorator.py`.

Current code:
```python
        class DecoratorBaseModel(BaseModel):
            # ... validators ...
            class Config(CustomConfig):
                extra = Extra.forbid
```

Proposed change:
I'll change it to:
```python
        class DecoratorBaseModel(BaseModel):
            # ... validators ...
            class Config(CustomConfig):
                if not hasattr(CustomConfig, 'extra'):
                    extra = Extra.forbid
```
Wait, as I said, I can't do `if` inside the class.

I'll do:
```python
        class DecoratorBaseModel(BaseModel):
            # ... validators ...
            class Config(CustomConfig):
                pass
```
And then I'll make sure `CustomConfig` has `extra = Extra.forbid` by default.

Wait, if `CustomConfig` is `None`, it's initialized as `CustomConfig = type('Config', (), {})`.
If I do:
```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
            else:
                CustomConfig = type('Config', (), {})

            if not hasattr(CustomConfig, 'extra'):
                # To avoid modifying the passed config class, we can't just do CustomConfig.extra = Extra.forbid
                # But wait, if it's a dict, we can. If it's a class we created with type(), we can.
                # If it's a class passed by the user, we should not.
                pass
```

Wait, if I just change `DecoratorBaseModel.Config` to:

```python
            class Config(CustomConfig):
                extra = getattr(CustomConfig, 'extra', Extra.forbid)
```
Wait, `getattr` inside a class definition for a class attribute? That works! `CustomConfig` is available in the scope.

Let's try this.

```python
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                extra = getattr(CustomConfig, 'extra', Extra.forbid)
```

Wait, if `CustomConfig` is not a class but some other type?
In `create_model`:
```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
```
If `config` is `None`, `CustomConfig` is not defined in that block.

Let's look at the original code again.

```python
        class CustomConfig:
            pass

        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
```

If `config` is `None`, `CustomConfig` remains the `class CustomConfig: pass` defined at the beginning.
So `CustomConfig` is always a class.

So `extra = getattr(CustomConfig, 'extra', Extra.forbid)` should work perfectly.

Let's double check the reproduction with this change.

Wait, let's see if `Extra.forbid` is available in `pydantic/decorator.py`. Yes, `from .config import Extra`.

Let's try it.

{
  "filepath": "pydantic/decorator.py",
  "new_string": "            class Config(CustomConfig):\n                extra = getattr(CustomConfig, 'extra', Extra.forbid)",
  "old_string": "            class Config(CustomConfig):\n                extra = Extra.forbid"
}

{
  "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
}

Now let's run the reproduction again.

{
  "command": "python3 - <<'PY'\nfrom typing_extensions import TypedDict\nfrom pydantic import validate_arguments, Extra\n\nclass TypedTest(TypedDict):\n    y: str\n\n@validate_arguments(config={'extra': Extra.allow})\ndef test(other: TypedTest):\n    pass\n\ntry:\n    test(other={'y': 'b', 'z': 'a'})\n    print(\"Success\")\nexcept Exception as e:\n    print(e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Success\n",
  "stderr": "",
  "exit_code": 0
}