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, if `Extra.allow` is set in the `config` of `@validate_arguments`, it should allow extra fields in a `TypedDict` argument, but currently, it raises a `ValidationError`.

Let's start by reproducing the bug.

{
  "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 bug is reproduced. The unexpected `ValidationError` is raised because the `Extra.allow` config is not being respected for the `TypedDict` in the `validate_arguments` decorator.

Now I need to find where `validate_arguments` is implemented and how it handles `TypedDict` and the `extra` configuration.

I'll start by searching for `validate_arguments` in the codebase.

{
  "command": "grep -rn --include=\"*.py\" \"validate_arguments\" pydantic/"
}

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

`validate_arguments` is defined in `pydantic/decorator.py`. Let's examine that file.

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

I need to read more of `pydantic/decorator.py` to see how `create_model` is called and how it uses the `config`.

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

I see the code in `create_model` method of `ValidatedFunction` class:

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

Wait, `class Config(CustomConfig): extra = Extra.forbid` seems to be the problem. It's explicitly setting `extra = Extra.forbid`, regardless of what `CustomConfig` (which comes from the `config` argument of `validate_arguments`) says.

If the user passes `config={'extra': Extra.allow}`, `CustomConfig` will have `extra = Extra.allow`. But then `DecoratorBaseModel.Config` overrides it with `extra = Extra.forbid`.

Wait, if `CustomConfig` is a class, then `class Config(CustomConfig): extra = Extra.forbid` will indeed override it.

The user's example:
```python
@validate_arguments(config={'extra': Extra.allow})
def test(other: TypedTest):
    pass
```
In this case, `config` is `{'extra': Extra.allow}`.
`CustomConfig` becomes `type('Config', (), config)`, which is a class with `extra = Extra.allow`.
Then `class Config(CustomConfig): extra = Extra.forbid` is defined inside `DecoratorBaseModel`.
So `DecoratorBaseModel.Config.extra` will be `Extra.forbid`.

This looks like the bug. However, I need to make sure that `extra = Extra.forbid` was intended for some reason.

If `extra = Extra.forbid` is removed, then `CustomConfig` will be used. If `CustomConfig` doesn't have `extra`, it will use the default `BaseModel` config (which is `Extra.ignore` I believe).

Wait, if `extra` is not specified in `config`, we might want it to be `Extra.forbid` by default for `@validate_arguments` to catch unexpected keyword arguments.

Let's check. If I don't provide `config`, `CustomConfig` is `class CustomConfig: pass`.
Then `class Config(CustomConfig): extra = Extra.forbid` sets it to `Extra.forbid`.

So the current behavior is:
- If `config` is not provided: `extra = Extra.forbid`.
- If `config` is provided and contains `extra`: it is still overridden by `Extra.forbid`.
- If `config` is provided and does NOT contain `extra`: `extra = Extra.forbid`.

The desired behavior should be:
- If `config` is provided and contains `extra`: use that.
- Otherwise: default to `Extra.forbid`.

How to achieve this?

We can check if `extra` is already present in `CustomConfig` (or the original `config` dict).

Let's see how `CustomConfig` is constructed:
```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 a dict, `CustomConfig` is a class created with that dict as attributes.
If `config` is already a class, `CustomConfig` is that class.

We can change the `Config` definition inside `DecoratorBaseModel`.

Actually, instead of:
```python
            class Config(CustomConfig):
                extra = Extra.forbid
```
We could do something like:
```python
            class Config(CustomConfig):
                if not hasattr(CustomConfig, 'extra'):
                    extra = Extra.forbid
```
But you can't put `if` statements inside a class body to conditionally define class attributes in that way for the config.

Wait, we can just set the attribute on `CustomConfig` before using it in `DecoratorBaseModel`, or just set it on `DecoratorBaseModel.Config` after the class is defined if it's missing.

Actually, the simplest way might be to check if `extra` is in `CustomConfig` and if not, add it.

Wait, `CustomConfig` might be a class provided by the user.

Let's refine the logic:
If `config` is a dict, and `'extra'` is not in `config`, we can add `'extra': Extra.forbid` to it.
If `config` is a class, and `hasattr(config, 'extra')` is false, we can't easily add it to the class without modifying it.

Actually, the `Config` class inside `DecoratorBaseModel` is what Pydantic uses for the model's configuration.

If we change:
```python
            class Config(CustomConfig):
                extra = Extra.forbid
```
to:
```python
            class Config(CustomConfig):
                pass
```
And before that, we ensure `CustomConfig` has `extra = Extra.forbid` if it's not already specified.

Wait, if `config` is `None`, `CustomConfig` is `class CustomConfig: pass`.
If we then use `class Config(CustomConfig): pass`, `Config` will not have `extra` specified, so it will use `BaseModel`'s default (which is `Extra.ignore`). But we want `Extra.forbid` for `@validate_arguments`.

So we need to ensure `extra = Extra.forbid` is the default.

Let's see if we can do this:

```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                config = config.copy()
                if 'extra' not in config:
                    config['extra'] = Extra.forbid
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                # config is a class. We can't easily modify it.
                # Maybe we can create a new class that inherits from it?
                CustomConfig = config  # noqa: F811
            else:
                CustomConfig = type('Config', (), {'extra': Extra.forbid})
```

Wait, if `config` is a class and doesn't have `extra`, we still want `extra = Extra.forbid`.

Maybe we can just do:

```python
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                if not hasattr(CustomConfig, 'extra'):
                    extra = Extra.forbid
```
Wait, I said this doesn't work. Let's check.

```python
class A:
    pass

class B(A):
    if not hasattr(A, 'extra'):
        extra = 1

print(B.extra) # 1
```
Actually, it DOES work! The `if` statement is executed during the definition of class `B` and `extra` is set as a class attribute of `B`.

Let's verify this.

{
  "command": "python3 - <<'PY'\nfrom enum import Enum\nclass Extra(Enum):\n    allow = 1\n    ignore = 2\n    forbid = 3\n\nclass CustomConfig:\n    pass\n\nclass DecoratorBaseModel:\n    class Config(CustomConfig):\n        if not hasattr(CustomConfig, 'extra'):\n            extra = Extra.forbid\n\nprint(f\"Default: {DecoratorBaseModel.Config.extra}\")\n\nclass CustomConfigWithExtra:\n    extra = Extra.allow\n\nclass DecoratorBaseModel2:\n    class Config(CustomConfigWithExtra):\n        if not hasattr(CustomConfigWithExtra, 'extra'):\n            extra = Extra.forbid\n\nprint(f\"With extra: {DecoratorBaseModel2.Config.extra}\")\nPY\n"
}

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

Yes, it works.

However, I should check if `CustomConfig` is always available in the scope of `DecoratorBaseModel` definition.
In `pydantic/decorator.py`:

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

`CustomConfig` is defined in the `create_model` method before `DecoratorBaseModel` is defined.

Wait, if I use `if not hasattr(CustomConfig, 'extra'): extra = Extra.forbid` inside `class Config(CustomConfig)`, it will work.

But wait, let's check what happens if `config` passed to `validate_arguments` is `None`.
```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` is the `CustomConfig` class defined at the beginning of `create_model` (which is empty).
So `hasattr(CustomConfig, 'extra')` will be `False`, and `Extra.forbid` will be set. This is correct.

Wait, if I use `if not hasattr(CustomConfig, 'extra'): extra = Extra.forbid`, `extra` will be a class attribute of `Config`.

Is there any other place where `extra` config is used for `TypedDict`?
The issue says `"extra" config not respected for TypedDicts in functions`.
The `validate_arguments` decorator creates a `BaseModel` using `create_model`.
`create_model` creates a model whose fields are the function arguments.
The `TypedDict` is one of the types of these fields.

Pydantic's `BaseModel` handles validation of fields. If a field is a `TypedDict`, Pydantic's internal validation for `TypedDict` should respect the model's `Config.extra`.

Wait, let's verify if `TypedDict` validation in Pydantic actually respects `Config.extra`.
If I have a `BaseModel` with a `TypedDict` field, and I pass extra fields to that `TypedDict`, does it respect `model.Config.extra`?

Let's test this independently.

{
  "command": "python3 - <<'PY'\nfrom typing_extensions import TypedDict\nfrom pydantic import BaseModel, Extra\n\nclass TypedTest(TypedDict):\n    y: str\n\nclass ModelAllow(BaseModel):\n    other: TypedTest\n    class Config:\n        extra = Extra.allow\n\nclass ModelForbid(BaseModel):\n    other: TypedTest\n    class Config:\n        extra = Extra.forbid\n\nprint(\"Testing ModelAllow...\")\ntry:\n    ModelAllow(other={'y': 'b', 'z': 'a'})\n    print(\"ModelAllow success\")\nexcept Exception as e:\n    print(f\"ModelAllow failed: {e}\")\n\nprint(\"\\nTesting ModelForbid...\")\ntry:\n    ModelForbid(other={'y': 'b', 'z': 'a'})\n    print(\"ModelForbid success\")\nexcept Exception as e:\n    print(f\"ModelForbid failed: {e}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing ModelAllow...\nModelAllow success\n\nTesting ModelForbid...\nModelForbid failed: 1 validation error for ModelForbid\nother -> z\n  extra fields not permitted (type=value_error.extra)\n",
  "stderr": "",
  "exit_code": 0
}

Yes, `BaseModel`'s `Config.extra` is respected when validating `TypedDict` fields.
So the problem is indeed that `validate_arguments` always sets `Config.extra = Extra.forbid` on the generated model, ignoring the user's `config`.

Now I will apply the fix to `pydantic/decorator.py`.

Wait, I should check if there's a cleaner way to do this than putting an `if` statement inside the class.

Another way:
```python
        # ...
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                pass
        
        if not hasattr(CustomConfig, 'extra'):
            DecoratorBaseModel.Config.extra = Extra.forbid
```
But `DecoratorBaseModel.Config` is just a reference to the `Config` class.

Actually, if `config` is a dict, we can just modify the dict.
If `config` is a class, we can't modify it easily.

Let's see `create_model`'s `config` handling 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 we change it to:

```python
        class CustomConfig:
            pass

        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                conf = config.copy()
                if 'extra' not in conf:
                    conf['extra'] = Extra.forbid
                CustomConfig = type('Config', (), conf)  # noqa: F811
            elif config is not None:
                CustomConfig = config  # noqa: F811
            else:
                CustomConfig = type('Config', (), {'extra': Extra.forbid})
```

And then:
```python
            class Config(CustomConfig):
                pass
```

But wait, if `config` is a class and it doesn't have `extra`, we still want `extra = Extra.forbid`.
In that case, `CustomConfig` is that class.
Then `class Config(CustomConfig): pass` will not have `extra` set, so it will use `Extra.ignore` (default).

So if `config` is a class, we should probably check if it has `extra` and if not, set it on the `Config` class.

The `if not hasattr(CustomConfig, 'extra'): extra = Extra.forbid` inside `class Config(CustomConfig)` is actually quite clever and works for both cases (dict-turned-class and direct class).

Let's double check if it's acceptable in terms of style.

Actually, the `Config` inner class is a Pydantic convention.

Another way to do it:

```python
        class DecoratorBaseModel(BaseModel):
            # ...
            class Config(CustomConfig):
                pass
        
        if not hasattr(CustomConfig, 'extra'):
            DecoratorBaseModel.Config.extra = Extra.forbid
```

Wait, if `DecoratorBaseModel.Config` is a class, setting `extra` on it will set it for all instances and it will be picked up by Pydantic's model machinery.

Let's test this.

{
  "command": "python3 - <<'PY'\nfrom enum import Enum\nclass Extra(Enum):\n    allow = 1\n    ignore = 2\n    forbid = 3\n\nclass CustomConfig:\n    pass\n\nclass DecoratorBaseModel:\n    class Config(CustomConfig):\n        pass\n\nif not hasattr(CustomConfig, 'extra'):\n    DecoratorBaseModel.Config.extra = Extra.forbid\n\nprint(f\"Default: {DecoratorBaseModel.Config.extra}\")\n\nclass CustomConfigWithExtra:\n    extra = Extra.allow\n\nclass DecoratorBaseModel2:\n    class Config(CustomConfigWithExtra):\n        pass\n\nif not hasattr(CustomConfigWithExtra, 'extra'):\n    DecoratorBaseModel2.Config.extra = Extra.forbid\n\nprint(f\"With extra: {DecoratorBaseModel2.Config.extra}\")\nPY\n"
}

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

This also works. And it's cleaner than putting an `if` statement inside the class body.

Wait, I should check if `DecoratorBaseModel.Config` is really what I think it is.
In Pydantic's `BaseModel`, the `Config` inner class is used during initialization.

Let's look at `pydantic/decorator.py` again.

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

        self.model = create_model(to_camel(self.raw_function.__name__), __base__=DecoratorBaseModel, **fields)
```

In `create_model`, if `__base__` is provided, the new model inherits from it, including its `Config`.

If I use `DecoratorBaseModel.Config.extra = Extra.forbid`, I'm modifying the `Config` class of `DecoratorBaseModel`.

Wait, `DecoratorBaseModel` is defined *inside* the `create_model` method of `ValidatedFunction`.
So it's a local class.

Actually, let's just use the `if not hasattr` inside the class, it's very compact. Or even better, just modify the `config` dict if it's a dict.

If I use the `if` inside the class:
```python
            class Config(CustomConfig):
                if not hasattr(CustomConfig, 'extra'):
                    extra = Extra.forbid
```

Is there any reason NOT to do this?
One potential issue is that `extra` becomes a class variable of `Config`, not just an attribute. But that's exactly what Pydantic expects for `Config`.

Let's see what's the most Pydantic-way.

Usually, Pydantic models define `class Config: ...`.

Let's see if I can just modify `CustomConfig` based on its type.

```python
        if not TYPE_CHECKING:  # pragma: no branch
            if isinstance(config, dict):
                config = config.copy()
                if 'extra' not in config:
                    config['extra'] = Extra.forbid
                CustomConfig = type('Config', (), config)  # noqa: F811
            elif config is not None:
                # It's a class. We can't modify it.
                CustomConfig = config  # noqa: F811
            else:
                CustomConfig = type('Config', (), {'extra': Extra.forbid})
```

And then:
```python
            class Config(CustomConfig):
                pass
```

But if it's a class and doesn't have `extra`, it will still use `Extra.ignore`.

So the `if not hasattr` inside `Config` class is actually the most robust way to handle both dict and class inputs for `config`.

Let's double check if `Extra` is imported. Yes, `from .config import Extra` is at the top of `pydantic/decorator.py`.

Let's refine the `if not hasattr` approach.

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

Wait, what if `CustomConfig` had `extra` set to `None`? `hasattr` would still be true.

Let's check what Pydantic does for `extra` config.
If `extra` is not provided in `Config`, it defaults to `Extra.ignore` (or `Extra.forbid` in some versions of Pydantic).

Wait, the problem reports Pydantic 1.8.2.
In Pydantic v1, the default for `extra` is `Extra.ignore`.

If I want it to be `Extra.forbid` by default for `validate_arguments`, I must specify it.

Let's check if there are any other things in `CustomConfig` that we should be careful about.

{
  "command": "python3 - <<'PY'\nfrom typing import Any\nclass Extra:\n    allow = 'allow'\n    ignore = 'ignore'\n    forbid = 'forbid'\n\nclass CustomConfig:\n    pass\n\nclass DecoratorBaseModel:\n    class Config(CustomConfig):\n        if not hasattr(CustomConfig, 'extra'):\n            extra = Extra.forbid\n\nprint(f\"Default: {DecoratorBaseModel.Config.extra}\")\n\nclass CustomConfigWithExtra:\n    extra = Extra.allow\n\nclass DecoratorBaseModel2:\n    class Config(CustomConfigWithExtra):\n        if not hasattr(CustomConfigWithExtra, 'extra'):\n            extra = Extra.forbid\n\nprint(f\"With extra: {DecoratorBaseModel2.Config.extra}\")\nPY\n"
}

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

Okay, the logic is sound.

Now let's see if there are any other places we need to fix. The issue only mentioned `validate_arguments`.
In `pydantic/decorator.py`, `validate_arguments` is the only public function exported.

Wait, let me check if `extra` config is handled differently for `TypedDict` in other places.
The issue is specifically about `validate_arguments` and `TypedDict`.

The root cause is that `validate_arguments` forces `extra = Extra.forbid` on the internal model it creates to validate function arguments.

I'll apply the fix.

```python
<<<<
            class Config(CustomConfig):
                extra = Extra.forbid
====
            class Config(CustomConfig):
                if not hasattr(CustomConfig, 'extra'):
                    extra = Extra.forbid
>>>>
```

Let's check the context in `pydantic/decorator.py`.

```python
            @validator(V_DUPLICATE_KWARGS, check_fields=False, allow_reuse=True)
            def check_duplicate_kwargs(cls, v: Optional[List[str]]) -> None:
                if v is None:
                    return

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

            class Config(CustomConfig):
                extra = Extra.forbid

        self.model = create_model(to_camel(self.raw_function.__name__), __base__=DecoratorBaseModel, **fields)
```

I'll apply this change.

{
  "filepath": "pydantic/decorator.py",
  "new_string": "            class Config(CustomConfig):\n                if not hasattr(CustomConfig, 'extra'):\n                    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,7 @@\n                 raise TypeError(f'multiple values for argument{plural}: {keys}')\n \n             class Config(CustomConfig):\n-                extra = Extra.forbid\n+                if not hasattr(CustomConfig, 'extra'):\n+                    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 verify the fix with the reproduction script.

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

The reproduction script now passes.

Now I should also verify that the default behavior (when `config` is not provided) is still `Extra.forbid`, as we wanted to preserve that.

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

Success! The default behavior is preserved (extra fields not permitted).

And let's check if it works when `config` is provided but without `extra`.

{
  "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={'some_other_config': True})\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
}

Still `Extra.forbid`, which is correct.

One more check: if `config` is passed as a class.

{
  "command": "python3 - <<'PY'\nfrom typing_extensions import TypedDict\nfrom pydantic import validate_arguments, Extra\n\nclass TypedTest(TypedDict):\n    y: str\n\nclass MyConfig:\n    extra = Extra.allow\n\n@validate_arguments(config=MyConfig)\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
}

And if `config` is a class without `extra`:

{
  "command": "python3 - <<'PY'\nfrom typing_extensions import TypedDict\nfrom pydantic import validate_arguments, Extra\n\nclass TypedTest(TypedDict):\n    y: str\n\nclass MyConfig:\n    pass\n\n@validate_arguments(config=MyConfig)\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
}

Everything looks correct now.

I'll check if there are any related tests that I should be aware of or if I should add any.
The instructions say "Every part of your fix MUST reside in non-test production source files." and "Before running official verification, the grading harness strips and reverts all changes to tests/".
So I cannot add new tests in `tests/`.

But I should check if I broke any existing tests.

I'll search for tests that use `validate_arguments`.

{
  "command": "grep -rn \"validate_arguments\" tests/"
}

{
  "status": "ok",
  "stdout": "tests/test_decorator.py:11:from pydantic import BaseModel, Field, ValidationError, validate_arguments\ntests/test_decorator.py:19:    @validate_arguments\ntests/test_decorator.py:73:    @validate_arguments\ntests/test_decorator.py:96:    @validate_arguments\ntests/test_decorator.py:121:    @validate_arguments\ntests/test_decorator.py:135:        foo = validate_arguments(foo)\ntests/test_decorator.py:148:    @validate_arguments\ntests/test_decorator.py:158:    @validate_arguments\ntests/test_decorator.py:171:from pydantic import validate_arguments\ntests/test_decorator.py:173:@validate_arguments\ntests/test_decorator.py:202:    @validate_arguments\ntests/test_decorator.py:233:        @validate_arguments\ntests/test_decorator.py:241:        @validate_arguments\ntests/test_decorator.py:249:        @validate_arguments\ntests/test_decorator.py:257:        @validate_arguments\ntests/test_decorator.py:263:    @validate_arguments\ntests/test_decorator.py:279:    @validate_arguments\ntests/test_decorator.py:298:        @validate_arguments\ntests/test_decorator.py:319:        @validate_arguments\ntests/test_decorator.py:338:    @validate_arguments(config=dict(title='Testing'))\ntests/test_decorator.py:351:    @validate_arguments(config=Config)\ntests/test_decorator.py:363:        @validate_arguments(config=dict(fields={'b': 'bang'}))\ntests/test_decorator.py:373:    @validate_arguments(config=dict(arbitrary_types_allowed=True))\ntests/test_decorator.py:394:    @validate_arguments\ntests/test_decorator.py:406:    @validate_arguments(config=dict(validate_all=True))\ntests/test_decorator.py:421:from pydantic import Field, validate_arguments\ntests/test_decorator.py:423:@validate_arguments(config=dict(validate_all=True))\ntests/mypy/modules/fail4.py:1:from pydantic import validate_arguments\ntests/mypy/modules/fail4.py:4:@validate_arguments\ntests/mypy/modules/fail4.py:20:@validate_arguments\ntests/mypy/modules/success.py:45:    validate_arguments,\ntests/mypy/modules/success.py:161:@validate_arguments\ntests/mypy/modules/success.py:171:@validate_arguments(config={'arbitrary_types_allowed': True})\n",
  "stderr": "",
  "exit_code": 0
}

I'll run `tests/test_decorator.py`.

{
  "command": "pytest tests/test_decorator.py -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": "......................                                                   [100%]\n22 passed in 0.04s\n",
  "stderr": "",
  "exit_code": 0
}

All tests in `tests/test_decorator.py` passed.

I'm confident in the fix.

{
  "command": "git status --short && git diff"
}

{
  "status": "ok",
  "stdout": " M pydantic/decorator.py\ndiff --git a/pydantic/decorator.py b/pydantic/decorator.py\nindex ca709b4..bfa9134 100644\n--- a/pydantic/decorator.py\n+++ b/pydantic/decorator.py\n@@ -254,6 +254,7 @@ class ValidatedFunction:\n                 raise TypeError(f'multiple values for argument{plural}: {keys}')\n \n             class Config(CustomConfig):\n-                extra = Extra.forbid\n+                if not hasattr(CustomConfig, 'extra'):\n+                    extra = Extra.forbid\n \n         self.model = create_model(to_camel(self.raw_function.__name__), __base__=DecoratorBaseModel, **fields)\n",
  "stderr": "",
  "exit_code": 0
}

Wait, looking at the diff:
```python
-                extra = Extra.forbid
+                if not hasattr(CustomConfig, 'extra'):
+                    extra = Extra.forbid
```
Wait, `class Config(CustomConfig):` is where this is.
In Python, you cannot have an `if` statement directly inside a class body for defining a class-level attribute in this way if you want it to be a class attribute.

Well, actually, you *can*. If `extra = Extra.forbid` is executed, it defines a class attribute `extra`.
But wait, the `if` statement is executed during the class definition.

Let's test this.

{
  "command": "python3 - <<'PY'\nclass Base:\n    pass\n\nclass Child(Base):\n    if not hasattr(Base, 'extra'):\n        extra = 'forbid'\n\nprint(f\"Child extra: {getattr(Child, 'extra', 'Not found')}\")\n\nclass BaseWithExtra:\n    extra = 'allow'\n\nclass Child2(BaseWithExtra):\n    if not hasattr(BaseWithExtra, 'extra'):\n        extra = 'forbid'\n\nprint(f\"Child2 extra: {getattr(Child2, 'extra', 'Not found')}\")\nPY\n"
}

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