fastapi_14306

{"status": "ok", "stdout": "fastapi/exceptions.py:165:class RequestValidationError(ValidationException):\nfastapi/exceptions.py:171:class WebSocketRequestValidationError(ValidationException):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/exceptions.py:175:class ResponseValidationError(ValidationException):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n    def errors(self) -> Sequence[Any]:\n        return self._errors\n\n\nclass RequestValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n\nclass WebSocketRequestValidationError(ValidationException):\n    pass\n\n\nclass ResponseValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n    def __str__(self) -> str:\n        message = f\"{len(self._errors)} validation errors:\\n\"\n        for err in self._errors:\n            message += f\"  {err}\\n\"\n        return message\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "class DependencyScopeError(FastAPIError):\n    \"\"\"\n    A dependency declared that it depends on another dependency with an invalid\n    (narrower) scope.\n    \"\"\"\n\n\nclass ValidationException(Exception):\n    def __init__(self, errors: Sequence[Any]) -> None:\n        self._errors = errors\n\n    def errors(self) -> Sequence[Any]:\n        return self._errors\n\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./tests/test_exception_handlers.py:3:from fastapi.exceptions import RequestValidationError\n./tests/test_exception_handlers.py:23:        RequestValidationError: request_validation_exception_handler,\n./fastapi/exception_handlers.py:2:from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError\n./fastapi/exception_handlers.py:21:    request: Request, exc: RequestValidationError\n./fastapi/exception_handlers.py:30:    websocket: WebSocket, exc: WebSocketRequestValidationError\n./fastapi/applications.py:24:from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError\n./fastapi/applications.py:988:            RequestValidationError, request_validation_exception_handler\n./fastapi/applications.py:991:            WebSocketRequestValidationError,\n./fastapi/routing.py:50:    RequestValidationError,\n./fastapi/routing.py:52:    WebSocketRequestValidationError,\n./fastapi/routing.py:347:            validation_error = RequestValidationError(\n./fastapi/routing.py:423:            validation_error = RequestValidationError(\n./fastapi/routing.py:453:            raise WebSocketRequestValidationError(\n./fastapi/exceptions.py:165:class RequestValidationError(ValidationException):\n./fastapi/exceptions.py:171:class WebSocketRequestValidationError(ValidationException):\n./docs_src/handling_errors/tutorial006.py:6:from fastapi.exceptions import RequestValidationError\n./docs_src/handling_errors/tutorial006.py:18:@app.exception_handler(RequestValidationError)\n./docs_src/handling_errors/tutorial004.py:2:from fastapi.exceptions import RequestValidationError\n./docs_src/handling_errors/tutorial004.py:14:@app.exception_handler(RequestValidationError)\n./docs_src/handling_errors/tutorial005.py:3:from fastapi.exceptions import RequestValidationError\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./tests/test_filter_pydantic_sub_model/test_filter_pydantic_sub_model_pv1.py:2:from fastapi.exceptions import ResponseValidationError\n./tests/test_filter_pydantic_sub_model/test_filter_pydantic_sub_model_pv1.py:29:    with pytest.raises(ResponseValidationError) as err:\n./tests/test_response_model_as_return_annotation.py:5:from fastapi.exceptions import FastAPIError, ResponseValidationError\n./tests/test_response_model_as_return_annotation.py:282:    with pytest.raises(ResponseValidationError) as excinfo:\n./tests/test_response_model_as_return_annotation.py:288:    with pytest.raises(ResponseValidationError) as excinfo:\n./tests/test_response_model_as_return_annotation.py:320:    with pytest.raises(ResponseValidationError) as excinfo:\n./tests/test_response_model_as_return_annotation.py:326:    with pytest.raises(ResponseValidationError) as excinfo:\n./tests/test_response_model_as_return_annotation.py:404:    with pytest.raises(ResponseValidationError) as excinfo:\n./tests/test_response_model_as_return_annotation.py:410:    with pytest.raises(ResponseValidationError) as excinfo:\n./tests/test_validate_response.py:5:from fastapi.exceptions import ResponseValidationError\n./tests/test_validate_response.py:54:    with pytest.raises(ResponseValidationError):\n./tests/test_validate_response.py:59:    with pytest.raises(ResponseValidationError):\n./tests/test_validate_response.py:78:    with pytest.raises(ResponseValidationError):\n./tests/test_validate_response.py:83:    with pytest.raises(ResponseValidationError):\n./tests/test_validate_response_dataclass.py:5:from fastapi.exceptions import ResponseValidationError\n./tests/test_validate_response_dataclass.py:42:    with pytest.raises(ResponseValidationError):\n./tests/test_validate_response_dataclass.py:47:    with pytest.raises(ResponseValidationError):\n./tests/test_validate_response_dataclass.py:52:    with pytest.raises(ResponseValidationError):\n./tests/test_filter_pydantic_sub_model_pv

{"status": "ok", "stdout": "fastapi/routing.py:51:    ResponseValidationError,\nfastapi/routing.py:248:            raise ResponseValidationError(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            value, errors_ = await run_in_threadpool(\n                field.validate, response_content, {}, loc=(\"response\",)\n            )\n        if isinstance(errors_, list):\n            errors.extend(errors_)\n        elif errors_:\n            errors.append(errors_)\n        if errors:\n            raise ResponseValidationError(\n                errors=_normalize_errors(errors), body=response_content\n            )\n\n        if hasattr(field, \"serialize\"):\n            return field.serialize(\n                value,\n                include=include,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                    if body_bytes:\n                        json_body: Any = Undefined\n                        content_type_value = request.headers.get(\"content-type\")\n                        if not content_type_value:\n                            json_body = await request.json()\n                        else:\n                            message = email.message.Message()\n                            message[\"content-type\"] = content_type_value\n                            if message.get_content_maintype() == \"application\":\n                                subtype = message.get_content_subtype()\n                                if subtype == \"json\" or subtype.endswith(\"+json\"):\n                                    json_body = await request.json()\n                        if json_body != Undefined:\n                            body = json_body\n                        else:\n                            body = body_bytes\n        except json.JSONDecodeError as e:\n            validation_error = RequestValidationError(\n                [\n                    {\n                        \"type\": \"json_invalid\",\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                                if subtype == \"json\" or subtype.endswith(\"+json\"):\n                                    json_body = await request.json()\n                        if json_body != Undefined:\n                            body = json_body\n                        else:\n                            body = body_bytes\n        except json.JSONDecodeError as e:\n            validation_error = RequestValidationError(\n                [\n                    {\n                        \"type\": \"json_invalid\",\n                        \"loc\": (\"body\", e.pos),\n                        \"msg\": \"JSON decode error\",\n                        \"input\": {},\n                        \"ctx\": {\"error\": e.msg},\n                    }\n                ],\n                body=e.doc,\n            )\n            raise validation_error from e\n        except HTTPException:\n            # If a middleware raises an HTTPException, it should be raised again\n            raise\n        except Exception as e:\n            http_error = HTTPException(\n                status_code=400, detail=\"There was an error parsing the body\"\n            )\n            raise http_error from e\n\n        # Solve dependencies and run path operation function, auto-closing dependencies\n        errors: List[Any] = []\n        async_exit_stack = request.scope.get(\"fastapi_inner_astack\")\n        assert isinstance(async_exit_stack, AsyncExitStack), (\n            \"fastapi_inner_astack not found in request scope\"\n        )\n        solved_result = await solve_dependencies(\n            request=request,\n            dependant=dependant,\n            body=body,\n            dependency_overrides_provider=dependency_overrides_provider,\n            async_exit_stack=async_exit_stack,\n            embed_body_fields=embed_body_fields,\n        )\n        errors = solved_result.errors\n        if not errors:\n            raw_response = await run_endpoint_functi

{"status": "ok", "stdout": "                    response.body = b\"\"\n                response.headers.raw.extend(solved_result.response.headers.raw)\n        if errors:\n            validation_error = RequestValidationError(\n                _normalize_errors(errors), body=body\n            )\n            raise validation_error\n\n        # Return response\n        assert response\n        return response\n\n    return app\n\n\ndef get_websocket_app(\n    dependant: Dependant,\n    dependency_overrides_provider: Optional[Any] = None,\n    embed_body_fields: bool = False,\n) -> Callable[[WebSocket], Coroutine[Any, Any, Any]]:\n    async def app(websocket: WebSocket) -> None:\n        async_exit_stack = websocket.scope.get(\"fastapi_inner_astack\")\n        assert isinstance(async_exit_stack, AsyncExitStack), (\n            \"fastapi_inner_astack not found in request scope\"\n        )\n        solved_result = await solve_dependencies(\n            request=websocket,\n            dependant=dependant,\n            dependency_overrides_provider=dependency_overrides_provider,\n            async_exit_stack=async_exit_stack,\n            embed_body_fields=embed_body_fields,\n        )\n        if solved_result.errors:\n            raise WebSocketRequestValidationError(\n                _normalize_errors(solved_result.errors)\n            )\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n    def errors(self) -> Sequence[Any]:\n        return self._errors\n\n\nclass RequestValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n\nclass WebSocketRequestValidationError(ValidationException):\n    pass\n\n\nclass ResponseValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n    def __str__(self) -> str:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\nclass WebSocketRequestValidationError(ValidationException):\n    pass\n\n\nclass ResponseValidationError(ValidationException):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "RequestErrorModel: Type[BaseModel] = create_model(\"Request\")\nWebSocketErrorModel: Type[BaseModel] = create_model(\"WebSocket\")\n\n\nclass FastAPIError(RuntimeError):\n    \"\"\"\n    A generic, FastAPI-specific error.\n    \"\"\"\n\n\nclass DependencyScopeError(FastAPIError):\n    \"\"\"\n    A dependency declared that it depends on another dependency with an invalid\n    (narrower) scope.\n    \"\"\"\n\n\nclass ValidationException(Exception):\n    def __init__(self, errors: Sequence[Any]) -> None:\n        self._errors = errors\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "class DependencyScopeError(FastAPIError):\n    \"\"\"\n    A dependency declared that it depends on another dependency with an invalid\n    (narrower) scope.\n    \"\"\"\n\n\nclass ValidationException(Exception):\n    def __init__(self, errors: Sequence[Any]) -> None:\n        self._errors = errors\n\n    def errors(self) -> Sequence[Any]:\n        return self._errors\n\n\nclass RequestValidationError(ValidationException):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/routing.py:4:import inspect\nfastapi/routing.py:607:        self.description = description or inspect.cleandoc(self.endpoint.__doc__ or \"\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from typing import Any, Dict, Optional, Sequence, Type, Union\n\nfrom annotated_doc import Doc\nfrom pydantic import BaseModel, create_model\nfrom starlette.exceptions import HTTPException as StarletteHTTPException\nfrom starlette.exceptions import WebSocketException as StarletteWebSocketException\nfrom typing_extensions import Annotated\n\n\nclass HTTPException(StarletteHTTPException):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    errors in your code.\n\n    Read more about it in the\n    [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/).\n\n    ## Example\n\n    ```python\n    from fastapi import FastAPI, HTTPException\n\n    app = FastAPI()\n\n    items = {\"foo\": \"The Foo Wrestlers\"}\n\n\n    @app.get(\"/items/{item_id}\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n                It could contain text that could be human-readable or interpretable\n                by the client code, etc.\n                \"\"\"\n            ),\n        ] = None,\n    ) -> None:\n        super().__init__(code=code, reason=reason)\n\n\nRequestErrorModel: Type[BaseModel] = create_model(\"Request\")\nWebSocketErrorModel: Type[BaseModel] = create_model(\"WebSocket\")\n\n\nclass FastAPIError(RuntimeError):\n    \"\"\"\n    A generic, FastAPI-specific error.\n    \"\"\"\n\n\nclass DependencyScopeError(FastAPIError):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "class DependencyScopeError(FastAPIError):\n    \"\"\"\n    A dependency declared that it depends on another dependency with an invalid\n    (narrower) scope.\n    \"\"\"\n\n\nclass ValidationException(Exception):\n    def __init__(self, errors: Sequence[Any]) -> None:\n        self._errors = errors\n\n    def errors(self) -> Sequence[Any]:\n        return self._errors\n\n\nclass RequestValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\nclass WebSocketRequestValidationError(ValidationException):\n    pass\n\n\nclass ResponseValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n    def __str__(self) -> str:\n        message = f\"{len(self._errors)} validation errors:\\n\"\n        for err in self._errors:\n            message += f\"  {err}\\n\"\n        return message\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "157:class ValidationException(Exception):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "class ValidationException(Exception):\n    def __init__(self, errors: Sequence[Any]) -> None:\n        self._errors = errors\n\n    def errors(self) -> Sequence[Any]:\n        return self._errors\n\n\nclass RequestValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\nclass WebSocketRequestValidationError(ValidationException):\n    pass\n\n\nclass ResponseValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n    def __str__(self) -> str:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    def __str__(self) -> str:\n        message = f\"{len(self._errors)} validation errors:\\n\"\n        for err in self._errors:\n            message += f\"  {err}\\n\"\n        return message\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/routing.py:50:    RequestValidationError,\nfastapi/routing.py:52:    WebSocketRequestValidationError,\nfastapi/routing.py:347:            validation_error = RequestValidationError(\nfastapi/routing.py:423:            validation_error = RequestValidationError(\nfastapi/routing.py:453:            raise WebSocketRequestValidationError(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                                if subtype == \"json\" or subtype.endswith(\"+json\"):\n                                    json_body = await request.json()\n                        if json_body != Undefined:\n                            body = json_body\n                        else:\n                            body = body_bytes\n        except json.JSONDecodeError as e:\n            validation_error = RequestValidationError(\n                [\n                    {\n                        \"type\": \"json_invalid\",\n                        \"loc\": (\"body\", e.pos),\n                        \"msg\": \"JSON decode error\",\n                        \"input\": {},\n                        \"ctx\": {\"error\": e.msg},\n                    }\n                ],\n                body=e.doc,\n            )\n            raise validation_error from e\n        except HTTPException:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                    exclude_none=response_model_exclude_none,\n                    is_coroutine=is_coroutine,\n                )\n                response = actual_response_class(content, **response_args)\n                if not is_body_allowed_for_status_code(response.status_code):\n                    response.body = b\"\"\n                response.headers.raw.extend(solved_result.response.headers.raw)\n        if errors:\n            validation_error = RequestValidationError(\n                _normalize_errors(errors), body=body\n            )\n            raise validation_error\n\n        # Return response\n        assert response\n        return response\n\n    return app\n\n\ndef get_websocket_app(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        solved_result = await solve_dependencies(\n            request=websocket,\n            dependant=dependant,\n            dependency_overrides_provider=dependency_overrides_provider,\n            async_exit_stack=async_exit_stack,\n            embed_body_fields=embed_body_fields,\n        )\n        if solved_result.errors:\n            raise WebSocketRequestValidationError(\n                _normalize_errors(solved_result.errors)\n            )\n        assert dependant.call is not None, \"dependant.call must be a function\"\n        await dependant.call(**solved_result.values)\n\n    return app\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            value, errors_ = await run_in_threadpool(\n                field.validate, response_content, {}, loc=(\"response\",)\n            )\n        if isinstance(errors_, list):\n            errors.extend(errors_)\n        elif errors_:\n            errors.append(errors_)\n        if errors:\n            raise ResponseValidationError(\n                errors=_normalize_errors(errors), body=response_content\n            )\n\n        if hasattr(field, \"serialize\"):\n            return field.serialize(\n                value,\n                include=include,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "504:class APIRoute(routing.Route):\n673:class APIRouter(routing.Router):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            child_scope[\"route\"] = self\n        return match, child_scope\n\n\nclass APIRoute(routing.Route):\n    def __init__(\n        self,\n        path: str,\n        endpoint: Callable[..., Any],\n        *,\n        response_model: Any = Default(None),\n        status_code: Optional[int] = None,\n        tags: Optional[List[Union[str, Enum]]] = None,\n        dependencies: Optional[Sequence[params.Depends]] = None,\n        summary: Optional[str] = None,\n        description: Optional[str] = None,\n        response_description: str = \"Successful Response\",\n        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,\n        deprecated: Optional[bool] = None,\n        name: Optional[str] = None,\n        methods: Optional[Union[Set[str], List[str]]] = None,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        methods: Optional[Union[Set[str], List[str]]] = None,\n        operation_id: Optional[str] = None,\n        response_model_include: Optional[IncEx] = None,\n        response_model_exclude: Optional[IncEx] = None,\n        response_model_by_alias: bool = True,\n        response_model_exclude_unset: bool = False,\n        response_model_exclude_defaults: bool = False,\n        response_model_exclude_none: bool = False,\n        include_in_schema: bool = True,\n        response_class: Union[Type[Response], DefaultPlaceholder] = Default(\n            JSONResponse\n        ),\n        dependency_overrides_provider: Optional[Any] = None,\n        callbacks: Optional[List[BaseRoute]] = None,\n        openapi_extra: Optional[Dict[str, Any]] = None,\n        generate_unique_id_function: Union[\n            Callable[[\"APIRoute\"], str], DefaultPlaceholder\n        ] = Default(generate_unique_id),\n    ) -> None:\n        self.path = path\n        self.endpoint = endpoint\n        if isinstance(response_model, DefaultPlaceholder):\n            return_annotation = get_typed_return_annotation(endpoint)\n            if lenient_issubclass(return_annotation, Response):\n                response_model = None\n            else:\n                response_model = return_annotation\n        self.response_model = response_model\n        self.summary = summary\n        self.response_description = response_description\n        self.deprecated = deprecated\n        self.operation_id = operation_id\n        self.response_model_include = response_model_include\n        self.response_model_exclude = response_model_exclude\n        self.response_model_by_alias = response_model_by_alias\n        self.response_model_exclude_unset = response_model_exclude_unset\n        self.response_model_exclude_defaults = response_model_exclude_defaults\n        self.response_model_exclude_none = response_model_exclude_none\n        self.include_in_schema = include_in_schema

{"status": "ok", "stdout": "            self.secure_cloned_response_field: Optional[ModelField] = (\n                create_cloned_field(self.response_field)\n            )\n        else:\n            self.response_field = None  # type: ignore\n            self.secure_cloned_response_field = None\n        self.dependencies = list(dependencies or [])\n        self.description = description or inspect.cleandoc(self.endpoint.__doc__ or \"\")\n        # if a \"form feed\" character (page break) is found in the description text,\n        # truncate description text to the content preceding the first \"form feed\"\n        self.description = self.description.split(\"\\f\")[0].strip()\n        response_fields = {}\n        for additional_status_code, response in self.responses.items():\n            assert isinstance(response, dict), \"An additional response must be a dict\"\n            model = response.get(\"model\")\n            if model:\n                assert is_body_allowed_for_status_code(additional_status_code), (\n                    f\"Status code {additional_status_code} must not have a response body\"\n                )\n                response_name = f\"Response_{additional_status_code}_{self.unique_id}\"\n                response_field = create_model_field(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        return get_request_handler(\n            dependant=self.dependant,\n            body_field=self.body_field,\n            status_code=self.status_code,\n            response_class=self.response_class,\n            response_field=self.secure_cloned_response_field,\n            response_model_include=self.response_model_include,\n            response_model_exclude=self.response_model_exclude,\n            response_model_by_alias=self.response_model_by_alias,\n            response_model_exclude_unset=self.response_model_exclude_unset,\n            response_model_exclude_defaults=self.response_model_exclude_defaults,\n            response_model_exclude_none=self.response_model_exclude_none,\n            dependency_overrides_provider=self.dependency_overrides_provider,\n            embed_body_fields=self._embed_body_fields,\n        )\n\n    def matches(self, scope: Scope) -> Tuple[Match, Scope]:\n        match, child_scope = super().matches(scope)\n        if match != Match.NONE:\n            child_scope[\"route\"] = self\n        return match, child_scope\n\n\nclass APIRouter(routing.Router):\n    \"\"\"\n    `APIRouter` class, used to group *path operations*, for example to structure\n    an app in multiple files. It would then be included in the `FastAPI` app, or\n    in another `APIRouter` (ultimately included in the app).\n\n    Read more about it in the\n    [FastAPI docs for Bigger Applications - Multiple Files](https://fastapi.tiangolo.com/tutorial/bigger-applications/).\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                current_status_code = (\n                    status_code if status_code else solved_result.response.status_code\n                )\n                if current_status_code is not None:\n                    response_args[\"status_code\"] = current_status_code\n                if solved_result.response.status_code:\n                    response_args[\"status_code\"] = solved_result.response.status_code\n                content = await serialize_response(\n                    field=response_field,\n                    response_content=raw_response,\n                    include=response_model_include,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "289:def get_request_handler(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_request_handler(\n    dependant: Dependant,\n    body_field: Optional[ModelField] = None,\n    status_code: Optional[int] = None,\n    response_class: Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse),\n    response_field: Optional[ModelField] = None,\n    response_model_include: Optional[IncEx] = None,\n    response_model_exclude: Optional[IncEx] = None,\n    response_model_by_alias: bool = True,\n    response_model_exclude_unset: bool = False,\n    response_model_exclude_defaults: bool = False,\n    response_model_exclude_none: bool = False,\n    dependency_overrides_provider: Optional[Any] = None,\n    embed_body_fields: bool = False,\n) -> Callable[[Request], Coroutine[Any, Any, Response]]:\n    assert dependant.call is not None, \"dependant.call must be a function\"\n    is_coroutine = dependant.is_coroutine_callable\n    is_body_form = body_field and isinstance(\n        body_field.field_info, (params.Form, temp_pydantic_v1_params.Form)\n    )\n    if isinstance(response_class, DefaultPlaceholder):\n        actual_response_class: Type[Response] = response_class.value\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        actual_response_class: Type[Response] = response_class.value\n    else:\n        actual_response_class = response_class\n\n    async def app(request: Request) -> Response:\n        response: Union[Response, None] = None\n        file_stack = request.scope.get(\"fastapi_middleware_astack\")\n        assert isinstance(file_stack, AsyncExitStack), (\n            \"fastapi_middleware_astack not found in request scope\"\n        )\n\n        # Read body and auto-close files\n        try:\n            body: Any = None\n            if body_field:\n                if is_body_form:\n                    body = await request.form()\n                    file_stack.push_async_callback(body.close)\n                else:\n                    body_bytes = await request.body()\n                    if body_bytes:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                    if body_bytes:\n                        json_body: Any = Undefined\n                        content_type_value = request.headers.get(\"content-type\")\n                        if not content_type_value:\n                            json_body = await request.json()\n                        else:\n                            message = email.message.Message()\n                            message[\"content-type\"] = content_type_value\n                            if message.get_content_maintype() == \"application\":\n                                subtype = message.get_content_subtype()\n                                if subtype == \"json\" or subtype.endswith(\"+json\"):\n                                    json_body = await request.json()\n                        if json_body != Undefined:\n                            body = json_body\n                        else:\n                            body = body_bytes\n        except json.JSONDecodeError as e:\n            validation_error = RequestValidationError(\n                [\n                    {\n                        \"type\": \"json_invalid\",\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                        \"type\": \"json_invalid\",\n                        \"loc\": (\"body\", e.pos),\n                        \"msg\": \"JSON decode error\",\n                        \"input\": {},\n                        \"ctx\": {\"error\": e.msg},\n                    }\n                ],\n                body=e.doc,\n            )\n            raise validation_error from e\n        except HTTPException:\n            # If a middleware raises an HTTPException, it should be raised again\n            raise\n        except Exception as e:\n            http_error = HTTPException(\n                status_code=400, detail=\"There was an error parsing the body\"\n            )\n            raise http_error from e\n\n        # Solve dependencies and run path operation function, auto-closing dependencies\n        errors: List[Any] = []\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        errors: List[Any] = []\n        async_exit_stack = request.scope.get(\"fastapi_inner_astack\")\n        assert isinstance(async_exit_stack, AsyncExitStack), (\n            \"fastapi_inner_astack not found in request scope\"\n        )\n        solved_result = await solve_dependencies(\n            request=request,\n            dependant=dependant,\n            body=body,\n            dependency_overrides_provider=dependency_overrides_provider,\n            async_exit_stack=async_exit_stack,\n            embed_body_fields=embed_body_fields,\n        )\n        errors = solved_result.errors\n        if not errors:\n            raw_response = await run_endpoint_function(\n                dependant=dependant,\n                values=solved_result.values,\n                is_coroutine=is_coroutine,\n            )\n            if isinstance(raw_response, Response):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            if isinstance(raw_response, Response):\n                if raw_response.background is None:\n                    raw_response.background = solved_result.background_tasks\n                response = raw_response\n            else:\n                response_args: Dict[str, Any] = {\n                    \"background\": solved_result.background_tasks\n                }\n                # If status_code was set, use it, otherwise use the default from the\n                # response class, in the case of redirect it's 307\n                current_status_code = (\n                    status_code if status_code else solved_result.response.status_code\n                )\n                if current_status_code is not None:\n                    response_args[\"status_code\"] = current_status_code\n                if solved_result.response.status_code:\n                    response_args[\"status_code\"] = solved_result.response.status_code\n                content = await serialize_response(\n                    field=response_field,\n                    response_content=raw_response,\n                    include=response_model_include,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                    include=response_model_include,\n                    exclude=response_model_exclude,\n                    by_alias=response_model_by_alias,\n                    exclude_unset=response_model_exclude_unset,\n                    exclude_defaults=response_model_exclude_defaults,\n                    exclude_none=response_model_exclude_none,\n                    is_coroutine=is_coroutine,\n                )\n                response = actual_response_class(content, **response_args)\n                if not is_body_allowed_for_status_code(response.status_code):\n                    response.body = b\"\"\n                response.headers.raw.extend(solved_result.response.headers.raw)\n        if errors:\n            validation_error = RequestValidationError(\n                _normalize_errors(errors), body=body\n            )\n            raise validation_error\n\n        # Return response\n        assert response\n        return response\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        return response\n\n    return app\n\n\ndef get_websocket_app(\n    dependant: Dependant,\n    dependency_overrides_provider: Optional[Any] = None,\n    embed_body_fields: bool = False,\n) -> Callable[[WebSocket], Coroutine[Any, Any, Any]]:\n    async def app(websocket: WebSocket) -> None:\n        async_exit_stack = websocket.scope.get(\"fastapi_inner_astack\")\n        assert isinstance(async_exit_stack, AsyncExitStack), (\n            \"fastapi_inner_astack not found in request scope\"\n        )\n        solved_result = await solve_dependencies(\n            request=websocket,\n            dependant=dependant,\n            dependency_overrides_provider=dependency_overrides_provider,\n            async_exit_stack=async_exit_stack,\n            embed_body_fields=embed_body_fields,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            embed_body_fields=embed_body_fields,\n        )\n        if solved_result.errors:\n            raise WebSocketRequestValidationError(\n                _normalize_errors(solved_result.errors)\n            )\n        assert dependant.call is not None, \"dependant.call must be a function\"\n        await dependant.call(**solved_result.values)\n\n    return app\n\n\nclass APIWebSocketRoute(routing.WebSocketRoute):\n    def __init__(\n        self,\n        path: str,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        path: str,\n        endpoint: Callable[..., Any],\n        *,\n        name: Optional[str] = None,\n        dependencies: Optional[Sequence[params.Depends]] = None,\n        dependency_overrides_provider: Optional[Any] = None,\n    ) -> None:\n        self.path = path\n        self.endpoint = endpoint\n        self.name = get_name(endpoint) if name is None else name\n        self.dependencies = list(dependencies or [])\n        self.path_regex, self.path_format, self.param_convertors = compile_path(path)\n        self.dependant = get_dependant(\n            path=self.path_format, call=self.endpoint, scope=\"function\"\n        )\n        for depends in self.dependencies[::-1]:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        for depends in self.dependencies[::-1]:\n            self.dependant.dependencies.insert(\n                0,\n                get_parameterless_sub_dependant(depends=depends, path=self.path_format),\n            )\n        self._flat_dependant = get_flat_dependant(self.dependant)\n        self._embed_body_fields = _should_embed_body_fields(\n            self._flat_dependant.body_params\n        )\n        self.app = websocket_session(\n            get_websocket_app(\n                dependant=self.dependant,\n                dependency_overrides_provider=dependency_overrides_provider,\n                embed_body_fields=self._embed_body_fields,\n            )\n        )\n\n    def matches(self, scope: Scope) -> Tuple[Match, Scope]:\n        match, child_scope = super().matches(scope)\n        if match != Match.NONE:\n            child_scope[\"route\"] = self\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "157:class ValidationException(Exception):\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "Traceback (most recent call last):\n  File \"/tmp/check_exceptions.py\", line 54, in <module>\n    test()\n    ~~~~^^\n  File \"/tmp/check_exceptions.py\", line 49, in test\n    assert \"File\" in ctx\n           ^^^^^^^^^^^^^\nAssertionError\n", "details": {"stdout": "Context: Error getting context: 'function' object has no attribute 'f_lineno'\n", "stderr": "Traceback (most recent call last):\n  File \"/tmp/check_exceptions.py\", line 54, in <module>\n    test()\n    ~~~~^^\n  File \"/tmp/check_exceptions.py\", line 49, in test\n    assert \"File\" in ctx\n           ^^^^^^^^^^^^^\nAssertionError\n", "exit_code": 1}, "budget_warning": "Only 10 tool call(s) remaining (50/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "Context: File /tmp/check_exceptions.py, line 15, in my_endpoint\n    GET /test\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 9 tool call(s) remaining (51/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0, "budget_warning": "Only 8 tool call(s) remaining (52/60 used). Finalize your edits and call submit_patch soon."}

{"status": "error", "error_type": "CommandError", "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 9, in <module>\nAssertionError\n", "details": {"stdout": "", "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 9, in <module>\nAssertionError\n", "exit_code": 1}, "budget_warning": "Only 7 tool call(s) remaining (53/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n\nclass WebSocketRequestValidationError(ValidationException):\n    pass\n\n\nclass ResponseValidationError(ValidationException):\n    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n        super().__init__(errors)\n        self.body = body\n\n    def __str__(self) -> str:\n        message = f\"{len(self._errors)} validation errors:\\n\"\n        for err in self._errors:\n            message += f\"  {err}\\n\"\n        return message\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 6 tool call(s) remaining (54/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0, "budget_warning": "Only 5 tool call(s) remaining (55/60 used). Finalize your edits and call submit_patch soon."}

{"status": "error", "error_type": "CommandError", "error_message": "sed: 1: \"fastapi/exceptions.py\": invalid command code f\n", "details": {"stdout": "", "stderr": "sed: 1: \"fastapi/exceptions.py\": invalid command code f\n", "exit_code": 1}, "budget_warning": "Only 4 tool call(s) remaining (56/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0, "budget_warning": "Only 3 tool call(s) remaining (57/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "diff --git a/fastapi/exceptions.py b/fastapi/exceptions.py\nindex 0620428b..6cb737fa 100644\n--- a/fastapi/exceptions.py\n+++ b/fastapi/exceptions.py\n@@ -155,12 +155,21 @@ class DependencyScopeError(FastAPIError):\n \n \n class ValidationException(Exception):\n-    def __init__(self, errors: Sequence[Any]) -> None:\n+    def __init__(self, errors: Sequence[Any], *, context: str = None) -> None:\n         self._errors = errors\n+        self.context = context\n \n     def errors(self) -> Sequence[Any]:\n         return self._errors\n \n+    def __str__(self) -> str:\n+        message = f\"{len(self._errors)} validation errors:\\n\"\n+        for err in self._errors:\n+            message += f\"  {err}\\n\"\n+        if self.context:\n+            message += f\"\\n{self.context}\\n\"\n+        return message\n+\n \n class RequestValidationError(ValidationException):\n     def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 2 tool call(s) remaining (58/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "On branch main\nChanges not staged for commit:\n  (use \"git add <file>...\" to update what will be committed)\n  (use \"git restore <file>...\" to discard changes in working directory)\n\tmodified:   fastapi/exceptions.py\n\nno changes added to commit (use \"git add\" and/or \"git commit -a\")\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 1 tool call(s) remaining (59/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "patch_size": 920, "files_changed": 1}