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",
  "filepath": "pydantic/decorator.py",
  "content": "from functools import wraps\nfrom typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload\n\nfrom . import validator\nfrom .config import Extra\nfrom .errors import ConfigError\nfrom .main import BaseModel, create_model\nfrom .typing import get_all_type_hints\nfrom .utils import to_camel\n\n__all__ = ('validate_arguments',)\n\nif TYPE_CHECKING:\n    from .typing import AnyCallable\n\n    AnyCallableT = TypeVar('AnyCallableT', bound=AnyCallable)\n    ConfigType = Union[None, Type[Any], Dict[str, Any]]\n\n\n@overload\ndef validate_arguments(func: None = None, *, config: 'ConfigType' = None) -> Callable[['AnyCallableT'], 'AnyCallableT']:\n    ...\n\n\n@overload\ndef validate_arguments(func: 'AnyCallableT') -> 'AnyCallableT':\n    ...\n\n\ndef validate_arguments(func: Optional['AnyCallableT'] = None, *, config: 'ConfigType' = None) -> Any:\n    \"\"\"\n    Decorator to validate the arguments passed to a function.\n    \"\"\"\n\n    def validate(_func: 'AnyCallable') -> 'AnyCallable':\n        vd = ValidatedFunction(_func, config)\n\n        @wraps(_func)\n        def wrapper_function(*args: Any, **kwargs: Any) -> Any:\n            return vd.call(*args, **kwargs)\n\n        wrapper_function.vd = vd  # type: ignore\n        wrapper_function.validate = vd.init_model_instance  # type: ignore\n        wrapper_function.raw_function = vd.raw_function  # type: ignore\n        wrapper_function.model = vd.model  # type: ignore\n        return wrapper_function\n\n    if func:\n        return validate(func)\n    else:\n        return validate\n\n\nALT_V_ARGS = 'v__args'\nALT_V_KWARGS = 'v__kwargs'\nV_POSITIONAL_ONLY_NAME = 'v__positional_only'\nV_DUPLICATE_KWARGS = 'v__duplicate_kwargs'\n\n\nclass ValidatedFunction:\n    def __init__(self, function: 'AnyCallableT', config: 'ConfigType'):  # noqa C901\n        from inspect import Parameter, signature\n\n        parameters: Mapping[str, Parameter] = signature(function).parameters\n\n        if parameters.keys() & {ALT_V_ARGS, ALT_V_KWARGS, V_POSITIONAL_ONLY_NAME, V_DUPLICATE_KWARGS}:\n            raise ConfigError(\n                f'\"{ALT_V_ARGS}\", \"{ALT_V_KWARGS}\", \"{V_POSITIONAL_ONLY_NAME}\" and \"{V_DUPLICATE_KWARGS}\" '\n                f'are not permitted as argument names when using the \"{validate_arguments.__name__}\" decorator'\n            )\n\n        self.raw_function = function\n        self.arg_mapping: Dict[int, str] = {}\n        self.positional_only_args = set()\n        self.v_args_name = 'args'\n        self.v_kwargs_name = 'kwargs'\n\n        type_hints = get_all_type_hints(function)\n        takes_args = False\n        takes_kwargs = False\n        fields: Dict[str, Tuple[Any, Any]] = {}\n        for i, (name, p) in enumerate(parameters.items()):\n            if p.annotation is p.empty:\n                annotation = Any\n            else:\n                annotation = type_hints[name]\n\n            default = ... if p.default is p.empty else p.default\n            if p.kind == Parameter.POSITIONAL_ONLY:\n                self.arg_mapping[i] = name\n                fields[name] = annotation, default\n                fields[V_POSITIONAL_ONLY_NAME] = List[str], None\n                self.positional_only_args.add(name)\n            elif p.kind == Parameter.POSITIONAL_OR_KEYWORD:\n                self.arg_mapping[i] = name\n                fields[name] = annotation, default\n                fields[V_DUPLICATE_KWARGS] = List[str], None\n            elif p.kind == Parameter.KEYWORD_ONLY:\n                fields[name] = annotation, default\n            elif p.kind == Parameter.VAR_POSITIONAL:\n                self.v_args_name = name\n                fields[name] = Tuple[annotation, ...], None\n                takes_args = True\n            else:\n                assert p.kind == Parameter.VAR_KEYWORD, p.kind\n                self.v_kwargs_name = name\n                fields[name] = Dict[str, annotation], None  # type: ignore\n                takes_kwargs = True\n\n        # these checks avoid a clash between \"args\" and a field with that name\n        if not takes_args and self.v_args_name in fields:\n            self.v_args_name = ALT_V_ARGS\n\n        # same with \"kwargs\"\n        if not takes_kwargs and self.v_kwargs_name in fields:\n            self.v_kwargs_name = ALT_V_KWARGS\n\n        if not takes_args:\n            # we add the field so validation below can raise the correct exception\n            fields[self.v_args_name] = List[Any], None\n\n        if not takes_kwargs:\n            # same with kwargs\n            fields[self.v_kwargs_name] = Dict[Any, Any], None\n\n        self.create_model(fields, takes_args, takes_kwargs, config)\n\n    def init_model_instance(self, *args: Any, **kwargs: Any) -> BaseModel:\n        values = self.build_values(args, kwargs)\n        return self.model(**values)\n\n    def call(self, *args: Any, **kwargs: Any) -> Any:\n        m = self.init_model_instance(*args, **kwargs)\n        return self.execute(m)\n\n    def build_values(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Dict[str, Any]:\n        values: Dict[str, Any] = {}\n        if args:\n            arg_iter = enumerate(args)\n            while True:\n                try:\n                    i, a = next(arg_iter)\n                except StopIteration:\n                    break\n                arg_name = self.arg_mapping.get(i)\n                if arg_name is not None:\n                    values[arg_name] = a\n                else:\n                    values[self.v_args_name] = [a] + [a for _, a in arg_iter]\n                    break",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 259,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pydantic/decorator.py",
  "content": "\n        var_kwargs = {}\n        wrong_positional_args = []\n        duplicate_kwargs = []\n        non_var_fields = set(self.model.__fields__) - {self.v_args_name, self.v_kwargs_name}\n        for k, v in kwargs.items():\n            if k in non_var_fields:\n                if k in self.positional_only_args:\n                    wrong_positional_args.append(k)\n                if k in values:\n                    duplicate_kwargs.append(k)\n                values[k] = v\n            else:\n                var_kwargs[k] = v\n\n        if var_kwargs:\n            values[self.v_kwargs_name] = var_kwargs\n        if wrong_positional_args:\n            values[V_POSITIONAL_ONLY_NAME] = wrong_positional_args\n        if duplicate_kwargs:\n            values[V_DUPLICATE_KWARGS] = duplicate_kwargs\n        return values\n\n    def execute(self, m: BaseModel) -> Any:\n        d = {k: v for k, v in m._iter() if k in m.__fields_set__ or m.__fields__[k].default_factory}\n        var_kwargs = d.pop(self.v_kwargs_name, {})\n\n        if self.v_args_name in d:\n            args_: List[Any] = []\n            in_kwargs = False\n            kwargs = {}\n            for name, value in d.items():\n                if in_kwargs:\n                    kwargs[name] = value\n                elif name == self.v_args_name:\n                    args_ += value\n                    in_kwargs = True\n                else:\n                    args_.append(value)\n            return self.raw_function(*args_, **kwargs, **var_kwargs)\n        elif self.positional_only_args:\n            args_ = []\n            kwargs = {}\n            for name, value in d.items():\n                if name in self.positional_only_args:\n                    args_.append(value)\n                else:\n                    kwargs[name] = value\n            return self.raw_function(*args_, **kwargs, **var_kwargs)\n        else:\n            return self.raw_function(**d, **var_kwargs)\n\n    def create_model(self, fields: Dict[str, Any], takes_args: bool, takes_kwargs: bool, config: 'ConfigType') -> None:\n        pos_args = len(self.arg_mapping)\n\n        class CustomConfig:\n            pass\n\n        if not TYPE_CHECKING:  # pragma: no branch\n            if isinstance(config, dict):\n                CustomConfig = type('Config', (), config)  # noqa: F811\n            elif config is not None:\n                CustomConfig = config  # noqa: F811\n\n        if hasattr(CustomConfig, 'fields') or hasattr(CustomConfig, 'alias_generator'):\n            raise ConfigError(\n                'Setting the \"fields\" and \"alias_generator\" property on custom Config for '\n                '@validate_arguments is not yet supported, please remove.'\n            )\n\n        class DecoratorBaseModel(BaseModel):\n            @validator(self.v_args_name, check_fields=False, allow_reuse=True)\n            def check_args(cls, v: Optional[List[Any]]) -> Optional[List[Any]]:\n                if takes_args or v is None:\n                    return v\n\n                raise TypeError(f'{pos_args} positional arguments expected but {pos_args + len(v)} given')\n\n            @validator(self.v_kwargs_name, check_fields=False, allow_reuse=True)\n            def check_kwargs(cls, v: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:\n                if takes_kwargs or v is None:\n                    return v\n\n                plural = '' if len(v) == 1 else 's'\n                keys = ', '.join(map(repr, v.keys()))\n                raise TypeError(f'unexpected keyword argument{plural}: {keys}')\n\n            @validator(V_POSITIONAL_ONLY_NAME, check_fields=False, allow_reuse=True)\n            def check_positional_only(cls, v: Optional[List[str]]) -> None:\n                if v is None:\n                    return\n\n                plural = '' if len(v) == 1 else 's'\n                keys = ', '.join(map(repr, v))\n                raise TypeError(f'positional-only argument{plural} passed as keyword argument{plural}: {keys}')\n\n            @validator(V_DUPLICATE_KWARGS, check_fields=False, allow_reuse=True)\n            def check_duplicate_kwargs(cls, v: Optional[List[str]]) -> None:\n                if v is None:\n                    return\n\n                plural = '' if len(v) == 1 else 's'\n                keys = ', '.join(map(repr, v))\n                raise TypeError(f'multiple values for argument{plural}: {keys}')\n\n            class Config(CustomConfig):\n                extra = Extra.forbid\n\n        self.model = create_model(to_camel(self.raw_function.__name__), __base__=DecoratorBaseModel, **fields)",
  "start_line": 151,
  "end_line": 259,
  "total_lines": 259,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "pydantic/error_wrappers.py:8:    from typing_extensions import TypedDict\npydantic/error_wrappers.py:16:    class _ErrorDictRequired(TypedDict):\npydantic/networks.py:34:    from typing_extensions import TypedDict\npydantic/networks.py:42:    class Parts(TypedDict, total=False):\npydantic/annotated_types.py:7:    from typing_extensions import TypedDict\npydantic/annotated_types.py:11:    # Mypy bug: `Type[TypedDict]` is resolved as `Any` https://github.com/python/mypy/issues/11030\npydantic/annotated_types.py:12:    typeddict_cls: Type['TypedDict'],  # type: ignore[valid-type]\npydantic/annotated_types.py:16:    Create a `BaseModel` based on the fields of a `TypedDict`.\npydantic/annotated_types.py:17:    Since `typing.TypedDict` in Python 3.8 does not store runtime information about optional keys,\npydantic/annotated_types.py:22:    # Best case scenario: with python 3.9+ or when `TypedDict` is imported from `typing_extensions`\npydantic/annotated_types.py:25:            'You should use `typing_extensions.TypedDict` instead of `typing.TypedDict`. '\npydantic/validators.py:46:    from typing_extensions import Literal, TypedDict\npydantic/validators.py:581:    typeddict_cls: Type['TypedDict'], config: Type['BaseConfig']  # type: ignore[valid-type]\npydantic/validators.py:585:    TypedDictModel = create_model_from_typeddict(\npydantic/validators.py:590:    typeddict_cls.__pydantic_model__ = TypedDictModel  # type: ignore[attr-defined]\npydantic/validators.py:592:    def typeddict_validator(values: 'TypedDict') -> Dict[str, Any]:  # type: ignore[valid-type]\npydantic/validators.py:593:        return TypedDictModel.parse_obj(values).dict(exclude_unset=True)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "583:    from .annotated_types import create_model_from_typeddict\n585:    TypedDictModel = create_model_from_typeddict(\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "import re\nfrom collections import OrderedDict, deque\nfrom collections.abc import Hashable as CollectionsHashable\nfrom datetime import date, datetime, time, timedelta\nfrom decimal import Decimal, DecimalException\nfrom enum import Enum, IntEnum\nfrom ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network\nfrom pathlib import Path\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Callable,\n    Deque,\n    Dict,\n    FrozenSet,\n    Generator,\n    Hashable,\n    List,\n    NamedTuple,\n    Pattern,\n    Set,\n    Tuple,\n    Type,\n    TypeVar,\n    Union,\n)\nfrom uuid import UUID\n\nfrom . import errors\nfrom .datetime_parse import parse_date, parse_datetime, parse_duration, parse_time\nfrom .typing import (\n    AnyCallable,\n    ForwardRef,\n    all_literal_values,\n    display_as_type,\n    get_class,\n    is_callable_type,\n    is_literal_type,\n    is_namedtuple,\n    is_none_type,\n    is_typeddict,\n)\nfrom .utils import almost_equal_floats, lenient_issubclass, sequence_like\n\nif TYPE_CHECKING:\n    from typing_extensions import Literal, TypedDict\n\n    from .config import BaseConfig\n    from .fields import ModelField\n    from .types import ConstrainedDecimal, ConstrainedFloat, ConstrainedInt\n\n    ConstrainedNumber = Union[ConstrainedDecimal, ConstrainedFloat, ConstrainedInt]\n    AnyOrderedDict = OrderedDict[Any, Any]\n    Number = Union[int, float, Decimal]\n    StrBytes = Union[str, bytes]\n\n\ndef str_validator(v: Any) -> Union[str]:\n    if isinstance(v, str):\n        if isinstance(v, Enum):\n            return v.value\n        else:\n            return v\n    elif isinstance(v, (float, int, Decimal)):\n        # is there anything else we want to add here? If you think so, create an issue.\n        return str(v)\n    elif isinstance(v, (bytes, bytearray)):\n        return v.decode()\n    else:\n        raise errors.StrError()\n\n\ndef strict_str_validator(v: Any) -> Union[str]:\n    if isinstance(v, str) and not isinstance(v, Enum):\n        return v\n    raise errors.StrError()\n\n\ndef bytes_validator(v: Any) -> bytes:\n    if isinstance(v, bytes):\n        return v\n    elif isinstance(v, bytearray):\n        return bytes(v)\n    elif isinstance(v, str):\n        return v.encode()\n    elif isinstance(v, (float, int, Decimal)):\n        return str(v).encode()\n    else:\n        raise errors.BytesError()\n\n\ndef strict_bytes_validator(v: Any) -> Union[bytes]:\n    if isinstance(v, bytes):\n        return v\n    elif isinstance(v, bytearray):\n        return bytes(v)\n    else:\n        raise errors.BytesError()\n\n\nBOOL_FALSE = {0, '0', 'off', 'f', 'false', 'n', 'no'}\nBOOL_TRUE = {1, '1', 'on', 't', 'true', 'y', 'yes'}\n\n\ndef bool_validator(v: Any) -> bool:\n    if v is True or v is False:\n        return v\n    if isinstance(v, bytes):\n        v = v.decode()\n    if isinstance(v, str):\n        v = v.lower()\n    try:\n        if v in BOOL_TRUE:\n            return True\n        if v in BOOL_FALSE:\n            return False\n    except TypeError:\n        raise errors.BoolError()\n    raise errors.BoolError()\n\n\ndef int_validator(v: Any) -> int:\n    if isinstance(v, int) and not (v is True or v is False):\n        return v\n\n    try:\n        return int(v)\n    except (TypeError, ValueError):\n        raise errors.IntegerError()\n\n\ndef strict_int_validator(v: Any) -> int:\n    if isinstance(v, int) and not (v is True or v is False):\n        return v\n    raise errors.IntegerError()\n\n\ndef float_validator(v: Any) -> float:\n    if isinstance(v, float):\n        return v\n\n    try:\n        return float(v)\n    except (TypeError, ValueError):\n        raise errors.FloatError()\n\n\ndef strict_float_validator(v: Any) -> float:\n    if isinstance(v, float):\n        return v",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 723,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "583:    from .annotated_types import create_model_from_typeddict\n585:    TypedDictModel = create_model_from_typeddict(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "        return re.compile(str_value)\n    except re.error:\n        raise errors.PatternError()\n\n\nNamedTupleT = TypeVar('NamedTupleT', bound=NamedTuple)\n\n\ndef make_namedtuple_validator(namedtuple_cls: Type[NamedTupleT]) -> Callable[[Tuple[Any, ...]], NamedTupleT]:\n    from .annotated_types import create_model_from_namedtuple\n\n    NamedTupleModel = create_model_from_namedtuple(\n        namedtuple_cls,\n        __module__=namedtuple_cls.__module__,\n    )\n    namedtuple_cls.__pydantic_model__ = NamedTupleModel  # type: ignore[attr-defined]\n\n    def namedtuple_validator(values: Tuple[Any, ...]) -> NamedTupleT:\n        annotations = NamedTupleModel.__annotations__\n\n        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\n        self.config_attr_names = config_attr_names\n\n    def check(self, config: Type['BaseConfig']) -> bool:\n        return any(getattr(config, name) not in {None, False} for name in self.config_attr_names)\n\n\n# order is important here, for example: bool is a subclass of int so has to come first, datetime before date same,\n# IPv4Interface before IPv4Address, etc\n_VALIDATORS: List[Tuple[Type[Any], List[Any]]] = [\n    (IntEnum, [int_validator, enum_member_validator]),\n    (Enum, [enum_member_validator]),\n    (\n        str,\n        [\n            str_validator,\n            IfConfig(anystr_strip_whitespace, 'anystr_strip_whitespace'),\n            IfConfig(anystr_lower, 'anystr_lower'),\n            IfConfig(anystr_length_validator, 'min_anystr_length', 'max_anystr_length'),\n        ],\n    ),",
  "start_line": 550,
  "end_line": 620,
  "total_lines": 723,
  "is_truncated": false
}

{
  "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": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

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

{
  "status": "ok",
  "filepath": "pydantic/validators.py",
  "content": "    if type_ is Pattern:\n        yield pattern_validator\n        return\n    if type_ is Hashable or type_ is CollectionsHashable:\n        yield hashable_validator\n        return\n    if is_callable_type(type_):\n        yield callable_validator\n        return\n    if is_literal_type(type_):\n        yield make_literal_validator(type_)\n        return\n    if is_builtin_dataclass(type_):\n        yield from make_dataclass_validator(type_, config)\n        return\n    if type_ is Enum:\n        yield enum_validator\n        return\n    if type_ is IntEnum:\n        yield int_enum_validator\n        return\n    if is_namedtuple(type_):\n        yield tuple_validator\n        yield make_namedtuple_validator(type_)\n        return\n    if is_typeddict(type_):\n        yield make_typeddict_validator(type_, config)\n        return\n\n    class_ = get_class(type_)\n    if class_ is not None:\n        if isinstance(class_, type):\n            yield make_class_validator(class_)\n        else:\n            yield any_class_validator\n        return\n\n    for val_type, validators in _VALIDATORS:\n        try:\n            if issubclass(type_, val_type):\n                for v in validators:\n                    if isinstance(v, IfConfig):\n                        if v.check(config):\n                            yield v.validator\n                    else:\n                        yield v\n                return\n        except TypeError:\n            raise RuntimeError(f'error checking inheritance of {type_!r} (type: {display_as_type(type_)})')\n\n    if config.arbitrary_types_allowed:\n        yield make_arbitrary_type_validator(type_)\n    else:\n        raise RuntimeError(f'no validator found for {type_}, see `arbitrary_types_allowed` in Config')",
  "start_line": 670,
  "end_line": 723,
  "total_lines": 723,
  "is_truncated": false
}

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