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": "11:__all__ = ('validate_arguments',)\n21:def validate_arguments(func: None = None, *, config: 'ConfigType' = None) -> Callable[['AnyCallableT'], 'AnyCallableT']:\n26:def validate_arguments(func: 'AnyCallableT') -> 'AnyCallableT':\n30:def validate_arguments(func: Optional['AnyCallableT'] = None, *, config: 'ConfigType' = None) -> Any:\n69:                f'are not permitted as argument names when using the \"{validate_arguments.__name__}\" decorator'\n218:                '@validate_arguments is not yet supported, please remove.'\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": "Testing ModelAllow:\nSuccess\n\nTesting ModelForbid:\n1 validation error for ModelForbid\nother -> z\n  extra fields not permitted (type=value_error.extra)\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "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",
  "filepath": "pydantic/main.py",
  "content": "import sys\nimport warnings\nfrom abc import ABCMeta\nfrom copy import deepcopy\nfrom enum import Enum\nfrom functools import partial\nfrom pathlib import Path\nfrom types import FunctionType\nfrom typing import (\n    TYPE_CHECKING,\n    AbstractSet,\n    Any,\n    Callable,\n    Dict,\n    List,\n    Mapping,\n    Optional,\n    Tuple,\n    Type,\n    TypeVar,\n    Union,\n    cast,\n    no_type_check,\n    overload,\n)\n\nfrom .class_validators import ValidatorGroup, extract_root_validators, extract_validators, inherit_validators\nfrom .config import BaseConfig, Extra, inherit_config, prepare_config\nfrom .error_wrappers import ErrorWrapper, ValidationError\nfrom .errors import ConfigError, DictError, ExtraError, MissingError\nfrom .fields import MAPPING_LIKE_SHAPES, ModelField, ModelPrivateAttr, PrivateAttr, Undefined\nfrom .json import custom_pydantic_encoder, pydantic_encoder\nfrom .parse import Protocol, load_file, load_str_bytes\nfrom .schema import default_ref_template, model_schema\nfrom .types import PyObject, StrBytes\nfrom .typing import (\n    AnyCallable,\n    get_args,\n    get_origin,\n    is_classvar,\n    is_namedtuple,\n    is_union_origin,\n    resolve_annotations,\n    update_field_forward_refs,\n)\nfrom .utils import (\n    ROOT_KEY,\n    ClassAttribute,\n    GetterDict,\n    Representation,\n    ValueItems,\n    generate_model_signature,\n    is_valid_field,\n    is_valid_private_name,\n    lenient_issubclass,\n    sequence_like,\n    smart_deepcopy,\n    unique_list,\n    validate_field_name,\n)\n\nif TYPE_CHECKING:\n    from inspect import Signature\n\n    from .class_validators import ValidatorListDict\n    from .types import ModelOrDc\n    from .typing import (\n        AbstractSetIntStr,\n        CallableGenerator,\n        DictAny,\n        DictStrAny,\n        MappingIntStrAny,\n        ReprArgs,\n        SetStr,\n        TupleGenerator,\n    )\n\n    Model = TypeVar('Model', bound='BaseModel')\n\n\ntry:\n    import cython  # type: ignore\nexcept ImportError:\n    compiled: bool = False\nelse:  # pragma: no cover\n    try:\n        compiled = cython.compiled\n    except AttributeError:\n        compiled = False\n\n__all__ = 'BaseModel', 'compiled', 'create_model', 'validate_model'\n\n\ndef validate_custom_root_type(fields: Dict[str, ModelField]) -> None:\n    if len(fields) > 1:\n        raise ValueError(f'{ROOT_KEY} cannot be mixed with other fields')\n\n\ndef generate_hash_function(frozen: bool) -> Optional[Callable[[Any], int]]:\n    def hash_function(self_: Any) -> int:\n        return hash(self_.__class__) + hash(tuple(self_.__dict__.values()))\n\n    return hash_function if frozen else None\n\n\n# If a field is of type `Callable`, its default value should be a function and cannot to ignored.\nANNOTATED_FIELD_UNTOUCHED_TYPES: Tuple[Any, ...] = (property, type, classmethod, staticmethod)\n# When creating a `BaseModel` instance, we bypass all the methods, properties... added to the model\nUNTOUCHED_TYPES: Tuple[Any, ...] = (FunctionType,) + ANNOTATED_FIELD_UNTOUCHED_TYPES\n# Note `ModelMetaclass` refers to `BaseModel`, but is also used to *create* `BaseModel`, so we need to add this extra\n# (somewhat hacky) boolean to keep track of whether we've created the `BaseModel` class yet, and therefore whether it's\n# safe to refer to it. If it *hasn't* been created, we assume that the `__new__` call we're in the middle of is for\n# the `BaseModel` class, since that's defined immediately after the metaclass.\n_is_base_model_class_defined = False\n\n\nclass ModelMetaclass(ABCMeta):\n    @no_type_check  # noqa C901\n    def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901\n        fields: Dict[str, ModelField] = {}\n        config = BaseConfig\n        validators: 'ValidatorListDict' = {}\n\n        pre_root_validators, post_root_validators = [], []\n        private_attributes: Dict[str, ModelPrivateAttr] = {}\n        base_private_attributes: Dict[str, ModelPrivateAttr] = {}\n        slots: SetStr = namespace.get('__slots__', ())\n        slots = {slots} if isinstance(slots, str) else set(slots)\n        class_vars: SetStr = set()\n        hash_func: Optional[Callable[[Any], int]] = None\n\n        for base in reversed(bases):\n            if _is_base_model_class_defined and issubclass(base, BaseModel) and base != BaseModel:\n                fields.update(smart_deepcopy(base.__fields__))\n                config = inherit_config(base.__config__, config)\n                validators = inherit_validators(base.__validators__, validators)\n                pre_root_validators += base.__pre_root_validators__\n                post_root_validators += base.__post_root_validators__\n                base_private_attributes.update(base.__private_attributes__)\n                class_vars.update(base.__class_vars__)\n                hash_func = base.__hash__\n\n        allowed_config_kwargs: SetStr = {\n            key\n            for key in dir(config)\n            if not (key.startswith('__') and key.endswith('__'))  # skip dunder methods and attributes\n        }\n        config_kwargs = {key: kwargs.pop(key) for key in kwargs.keys() & allowed_config_kwargs}\n        config_from_namespace = namespace.get('Config')\n        if config_kwargs and config_from_namespace:",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 1014,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pydantic/main.py",
  "content": "            raise TypeError('Specifying config in two places is ambiguous, use either Config attribute or class kwargs')\n        config = inherit_config(config_from_namespace, config, **config_kwargs)\n\n        validators = inherit_validators(extract_validators(namespace), validators)\n        vg = ValidatorGroup(validators)\n\n        for f in fields.values():\n            f.set_config(config)\n            extra_validators = vg.get_validators(f.name)\n            if extra_validators:\n                f.class_validators.update(extra_validators)\n                # re-run prepare to add extra validators\n                f.populate_validators()\n\n        prepare_config(config, name)\n\n        untouched_types = ANNOTATED_FIELD_UNTOUCHED_TYPES\n\n        def is_untouched(v: Any) -> bool:\n            return isinstance(v, untouched_types) or v.__class__.__name__ == 'cython_function_or_method'\n\n        if (namespace.get('__module__'), namespace.get('__qualname__')) != ('pydantic.main', 'BaseModel'):\n            annotations = resolve_annotations(namespace.get('__annotations__', {}), namespace.get('__module__', None))\n            # annotation only fields need to come first in fields\n            for ann_name, ann_type in annotations.items():\n                if is_classvar(ann_type):\n                    class_vars.add(ann_name)\n                elif is_valid_field(ann_name):\n                    validate_field_name(bases, ann_name)\n                    value = namespace.get(ann_name, Undefined)\n                    allowed_types = get_args(ann_type) if is_union_origin(get_origin(ann_type)) else (ann_type,)\n                    if (\n                        is_untouched(value)\n                        and ann_type != PyObject\n                        and not any(\n                            lenient_issubclass(get_origin(allowed_type), Type) for allowed_type in allowed_types\n                        )\n                    ):\n                        continue\n                    fields[ann_name] = ModelField.infer(\n                        name=ann_name,\n                        value=value,\n                        annotation=ann_type,\n                        class_validators=vg.get_validators(ann_name),\n                        config=config,\n                    )\n                elif ann_name not in namespace and config.underscore_attrs_are_private:\n                    private_attributes[ann_name] = PrivateAttr()\n\n            untouched_types = UNTOUCHED_TYPES + config.keep_untouched\n            for var_name, value in namespace.items():\n                can_be_changed = var_name not in class_vars and not is_untouched(value)\n                if isinstance(value, ModelPrivateAttr):\n                    if not is_valid_private_name(var_name):\n                        raise NameError(\n                            f'Private attributes \"{var_name}\" must not be a valid field name; '\n                            f'Use sunder or dunder names, e. g. \"_{var_name}\" or \"__{var_name}__\"'\n                        )\n                    private_attributes[var_name] = value\n                elif config.underscore_attrs_are_private and is_valid_private_name(var_name) and can_be_changed:\n                    private_attributes[var_name] = PrivateAttr(default=value)\n                elif is_valid_field(var_name) and var_name not in annotations and can_be_changed:\n                    validate_field_name(bases, var_name)\n                    inferred = ModelField.infer(\n                        name=var_name,\n                        value=value,\n                        annotation=annotations.get(var_name, Undefined),\n                        class_validators=vg.get_validators(var_name),\n                        config=config,\n                    )\n                    if var_name in fields:\n                        if lenient_issubclass(inferred.type_, fields[var_name].type_):\n                            inferred.type_ = fields[var_name].type_\n                        else:\n                            raise TypeError(\n                                f'The type of {name}.{var_name} differs from the new default value; '\n                                f'if you wish to change the type of this field, please use a type annotation'\n                            )\n                    fields[var_name] = inferred\n\n        _custom_root_type = ROOT_KEY in fields\n        if _custom_root_type:\n            validate_custom_root_type(fields)\n        vg.check_for_unused()\n        if config.json_encoders:\n            json_encoder = partial(custom_pydantic_encoder, config.json_encoders)\n        else:\n            json_encoder = pydantic_encoder\n        pre_rv_new, post_rv_new = extract_root_validators(namespace)\n\n        if hash_func is None:\n            hash_func = generate_hash_function(config.frozen)\n\n        exclude_from_namespace = fields | private_attributes.keys() | {'__slots__'}\n        new_namespace = {\n            '__config__': config,\n            '__fields__': fields,\n            '__exclude_fields__': {\n                name: field.field_info.exclude for name, field in fields.items() if field.field_info.exclude is not None\n            }\n            or None,\n            '__include_fields__': {\n                name: field.field_info.include for name, field in fields.items() if field.field_info.include is not None\n            }\n            or None,\n            '__validators__': vg.validators,\n            '__pre_root_validators__': unique_list(\n                pre_root_validators + pre_rv_new,\n                name_factory=lambda v: v.__name__,\n            ),\n            '__post_root_validators__': unique_list(\n                post_root_validators + post_rv_new,\n                name_factory=lambda skip_on_failure_and_v: skip_on_failure_and_v[1].__name__,\n            ),\n            '__schema_cache__': {},\n            '__json_encoder__': staticmethod(json_encoder),\n            '__custom_root_type__': _custom_root_type,\n            '__private_attributes__': {**base_private_attributes, **private_attributes},\n            '__slots__': slots | private_attributes.keys(),\n            '__hash__': hash_func,\n            '__class_vars__': class_vars,\n            **{n: v for n, v in namespace.items() if n not in exclude_from_namespace},\n        }\n\n        cls = super().__new__(mcs, name, bases, new_namespace, **kwargs)\n        # set __signature__ attr only for model class, but not for its instances\n        cls.__signature__ = ClassAttribute('__signature__', generate_model_signature(cls.__init__, fields, config))\n        return cls\n\n\nobject_setattr = object.__setattr__\n\n\nclass BaseModel(Representation, metaclass=ModelMetaclass):\n    if TYPE_CHECKING:\n        # populated by the metaclass, defined here to help IDEs only\n        __fields__: Dict[str, ModelField] = {}\n        __include_fields__: Optional[Mapping[str, Any]] = None\n        __exclude_fields__: Optional[Mapping[str, Any]] = None\n        __validators__: Dict[str, AnyCallable] = {}\n        __pre_root_validators__: List[AnyCallable]\n        __post_root_validators__: List[Tuple[bool, AnyCallable]]\n        __config__: Type[BaseConfig] = BaseConfig\n        __root__: Any = None\n        __json_encoder__: Callable[[Any], Any] = lambda x: x\n        __schema_cache__: 'DictAny' = {}\n        __custom_root_type__: bool = False\n        __signature__: 'Signature'\n        __private_attributes__: Dict[str, ModelPrivateAttr]\n        __class_vars__: SetStr",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 1014,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "849:def create_model(\n862:def create_model(\n874:def create_model(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pydantic/main.py",
  "content": "def create_model(\n    __model_name: str,\n    *,\n    __config__: Optional[Type[BaseConfig]] = None,\n    __base__: None = None,\n    __module__: str = __name__,\n    __validators__: Dict[str, classmethod] = None,\n    **field_definitions: Any,\n) -> Type['BaseModel']:\n    ...\n\n\n@overload\ndef create_model(\n    __model_name: str,\n    *,\n    __config__: Optional[Type[BaseConfig]] = None,\n    __base__: Type['Model'],\n    __module__: str = __name__,\n    __validators__: Dict[str, classmethod] = None,\n    **field_definitions: Any,\n) -> Type['Model']:\n    ...\n\n\ndef create_model(\n    __model_name: str,\n    *,\n    __config__: Optional[Type[BaseConfig]] = None,\n    __base__: Optional[Type['Model']] = None,\n    __module__: str = __name__,\n    __validators__: Dict[str, classmethod] = None,\n    **field_definitions: Any,\n) -> Type['Model']:\n    \"\"\"\n    Dynamically create a model.\n    :param __model_name: name of the created model\n    :param __config__: config class to use for the new model\n    :param __base__: base class for the new model to inherit from\n    :param __module__: module of the created model\n    :param __validators__: a dict of method names and @validator class methods\n    :param field_definitions: fields of the model (or extra fields if a base is supplied)\n        in the format `<name>=(<type>, <default default>)` or `<name>=<default value>, e.g.\n        `foobar=(str, ...)` or `foobar=123`, or, for complex use-cases, in the format\n        `<name>=<FieldInfo>`, e.g. `foo=Field(default_factory=datetime.utcnow, alias='bar')`\n    \"\"\"\n\n    if __base__ is not None:\n        if __config__ is not None:\n            raise ConfigError('to avoid confusion __config__ and __base__ cannot be used together')\n    else:\n        __base__ = cast(Type['Model'], BaseModel)\n\n    fields = {}\n    annotations = {}\n\n    for f_name, f_def in field_definitions.items():\n        if not is_valid_field(f_name):\n            warnings.warn(f'fields may not start with an underscore, ignoring \"{f_name}\"', RuntimeWarning)\n        if isinstance(f_def, tuple):\n            try:\n                f_annotation, f_value = f_def\n            except ValueError as e:\n                raise ConfigError(\n                    'field definitions should either be a tuple of (<type>, <default>) or just a '\n                    'default value, unfortunately this means tuples as '\n                    'default values are not allowed'\n                ) from e\n        else:\n            f_annotation, f_value = None, f_def\n\n        if f_annotation:\n            annotations[f_name] = f_annotation\n        fields[f_name] = f_value\n\n    namespace: 'DictStrAny' = {'__annotations__': annotations, '__module__': __module__}\n    if __validators__:\n        namespace.update(__validators__)\n    namespace.update(fields)\n    if __config__:\n        namespace['Config'] = inherit_config(__config__, BaseConfig)\n\n    return type(__model_name, (__base__,), namespace)\n\n\n_missing = object()\n\n\ndef validate_model(  # noqa: C901 (ignore complexity)\n    model: Type[BaseModel], input_data: 'DictStrAny', cls: 'ModelOrDc' = None\n) -> Tuple['DictStrAny', 'SetStr', Optional[ValidationError]]:\n    \"\"\"\n    validate data against a model.\n    \"\"\"\n    values = {}\n    errors = []\n    # input_data names, possibly alias\n    names_used = set()\n    # field names, never aliases\n    fields_set = set()\n    config = model.__config__\n    check_extra = config.extra is not Extra.ignore",
  "start_line": 849,
  "end_line": 950,
  "total_lines": 1014,
  "is_truncated": false
}

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

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