We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
FalconParser should ideally support falcon's native media decoding
Falcon has a native media handling mechanism which can decode an incoming request body based on the `Content-Type` header and adding the dictionary of resulting key-value pairs as a cached property `req.media`. I've written my own FalconParser subclass that (very naively) uses this, but it seems like something that might be worth supporting out of the box.

```python
    def parse_json(self, req, name, field):
        """
        Pull a JSON body value from the request.
        uses falcon's native req.media
        """
        json_data = self._cache.get("json_data")
        if json_data is None:
            self._cache["json_data"] = json_data = req.media
        return core.get_value(json_data, name, field, allow_many_nested=True)
```

This could probably be improved upon; since the `media` property  is already cached on the request object, we could just access `req.media` directly without caching on the parser. (Not sure if this impacts other things that might use that cache, though; I haven't dug deep enough to fully understand that implication.) Also, since `media` was added in 1.3, if webargs still wanted to support older versions of falcon we could add a check for it and fall back to the existing behavior.

Maybe something like:

```python
    def parse_json(self, req, name, field):
        """Pull a JSON body value from the request.
        .. note::
            The request stream will be read and left at EOF.
        """
        json_data = req.media if hasattr(req, 'media') else self._cache.get("json_data")
        if json_data is None:
            self._cache["json_data"] = json_data = parse_json_body(req)
        return core.get_value(json_data, name, field, allow_many_nested=True)
```

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `src/webargs/falconparser.py`
Content:
```
1 """Falcon request argument parsing module.
2 """
3 import falcon
4 from falcon.util.uri import parse_query_string
5 
6 from webargs import core
7 from webargs.multidictproxy import MultiDictProxy
8 
9 HTTP_422 = "422 Unprocessable Entity"
10 
11 # Mapping of int status codes to string status
12 status_map = {422: HTTP_422}
13 
14 
15 # Collect all exceptions from falcon.status_codes
16 def _find_exceptions():
17     for name in filter(lambda n: n.startswith("HTTP"), dir(falcon.status_codes)):
18         status = getattr(falcon.status_codes, name)
19         status_code = int(status.split(" ")[0])
20         status_map[status_code] = status
21 
22 
23 _find_exceptions()
24 del _find_exceptions
25 
26 
27 def is_json_request(req):
28     content_type = req.get_header("Content-Type")
29     return content_type and core.is_json(content_type)
30 
31 
32 # NOTE: Adapted from falcon.request.Request._parse_form_urlencoded
33 def parse_form_body(req):
34     if (
35         req.content_type is not None
36         and "application/x-www-form-urlencoded" in req.content_type
37     ):
38         body = req.stream.read(req.content_length or 0)
39         try:
40             body = body.decode("ascii")
41         except UnicodeDecodeError:
42             body = None
43             req.log_error(
44                 "Non-ASCII characters found in form body "
45                 "with Content-Type of "
46                 "application/x-www-form-urlencoded. Body "
47                 "will be ignored."
48             )
49 
50         if body:
51             return parse_query_string(body, keep_blank=req.options.keep_blank_qs_values)
52 
53     return core.missing
54 
55 
56 class HTTPError(falcon.HTTPError):
57     """HTTPError that stores a dictionary of validation error messages."""
58 
59     def __init__(self, status, errors, *args, **kwargs):
60         self.errors = errors
61         super().__init__(status, *args, **kwargs)
62 
63     def to_dict(self, *args, **kwargs):
64         """Override `falcon.HTTPError` to include error messages in responses."""
65         ret = super().to_dict(*args, **kwargs)
66         if self.errors is not None:
67             ret["errors"] = self.errors
68         return ret
69 
70 
71 class FalconParser(core.Parser):
72     """Falcon request argument parser."""
73 
74     # Note on the use of MultiDictProxy throughout:
75     # Falcon parses query strings and form values into ordinary dicts, but with
76     # the values listified where appropriate
77     # it is still therefore necessary in these cases to wrap them in
78     # MultiDictProxy because we need to use the schema to determine when single
79     # values should be wrapped in lists due to the type of the destination
80     # field
81 
82     def load_querystring(self, req, schema):
83         """Return query params from the request as a MultiDictProxy."""
84         return MultiDictProxy(req.params, schema)
85 
86     def load_form(self, req, schema):
87         """Return form values from the request as a MultiDictProxy
88 
89         .. note::
90 
91             The request stream will be read and left at EOF.
92         """
93         form = parse_form_body(req)
94         if form is core.missing:
95             return form
96         return MultiDictProxy(form, schema)
97 
98     def _raw_load_json(self, req):
99         """Return a json payload from the request for the core parser's load_json
100 
101         Checks the input mimetype and may return 'missing' if the mimetype is
102         non-json, even if the request body is parseable as json."""
103         if not is_json_request(req) or req.content_length in (None, 0):
104             return core.missing
105         body = req.stream.read(req.content_length)
106         if body:
107             return core.parse_json(body)
108         return core.missing
109 
110     def load_headers(self, req, schema):
111         """Return headers from the request."""
112         # Falcon only exposes headers as a dict (not multidict)
113         return req.headers
114 
115     def load_cookies(self, req, schema):
116         """Return cookies from the request."""
117         # Cookies are expressed in Falcon as a dict, but the possibility of
118         # multiple values for a cookie is preserved internally -- if desired in
119         # the future, webargs could add a MultiDict type for Cookies here built
120         # from (req, schema), but Falcon does not provide one out of the box
121         return req.cookies
122 
123     def get_request_from_view_args(self, view, args, kwargs):
124         """Get request from a resource method's arguments. Assumes that
125         request is the second argument.
126         """
127         req = args[1]
128         if not isinstance(req, falcon.Request):
129             raise TypeError("Argument is not a falcon.Request")
130         return req
131 
132     def load_files(self, req, schema):
133         raise NotImplementedError(
134             f"Parsing files not yet supported by {self.__class__.__name__}"
135         )
136 
137     def handle_error(self, error, req, schema, *, error_status_code, error_headers):
138         """Handles errors during parsing."""
139         status = status_map.get(error_status_code or self.DEFAULT_VALIDATION_STATUS)
140         if status is None:
141             raise LookupError(f"Status code {error_status_code} not supported")
142         raise HTTPError(status, errors=error.messages, headers=error_headers)
143 
144     def _handle_invalid_json_error(self, error, req, *args, **kwargs):
145         status = status_map[400]
146         messages = {"json": ["Invalid JSON body."]}
147         raise HTTPError(status, errors=messages)
148 
149 
150 parser = FalconParser()
151 use_args = parser.use_args
152 use_kwargs = parser.use_kwargs
153
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/src/webargs/falconparser.py b/src/webargs/falconparser.py
--- a/src/webargs/falconparser.py
+++ b/src/webargs/falconparser.py
@@ -3,6 +3,8 @@
 import falcon
 from falcon.util.uri import parse_query_string
 
+import marshmallow as ma
+
 from webargs import core
 from webargs.multidictproxy import MultiDictProxy
 
@@ -69,7 +71,21 @@
 
 
 class FalconParser(core.Parser):
-    """Falcon request argument parser."""
+    """Falcon request argument parser.
+
+    Defaults to using the `media` location. See :py:meth:`~FalconParser.load_media` for
+    details on the media location."""
+
+    # by default, Falcon will use the 'media' location to load data
+    #
+    # this effectively looks the same as loading JSON data by default, but if
+    # you add a handler for a different media type to Falcon, webargs will
+    # automatically pick up on that capability
+    DEFAULT_LOCATION = "media"
+    DEFAULT_UNKNOWN_BY_LOCATION = dict(
+        media=ma.RAISE, **core.Parser.DEFAULT_UNKNOWN_BY_LOCATION
+    )
+    __location_map__ = dict(media="load_media", **core.Parser.__location_map__)
 
     # Note on the use of MultiDictProxy throughout:
     # Falcon parses query strings and form values into ordinary dicts, but with
@@ -95,6 +111,25 @@
             return form
         return MultiDictProxy(form, schema)
 
+    def load_media(self, req, schema):
+        """Return data unpacked and parsed by one of Falcon's media handlers.
+        By default, Falcon only handles JSON payloads.
+
+        To configure additional media handlers, see the
+        `Falcon documentation on media types`__.
+
+        .. _FalconMedia: https://falcon.readthedocs.io/en/stable/api/media.html
+        __ FalconMedia_
+
+        .. note::
+
+            The request stream will be read and left at EOF.
+        """
+        # if there is no body, return missing instead of erroring
+        if req.content_length in (None, 0):
+            return core.missing
+        return req.media
+
     def _raw_load_json(self, req):
         """Return a json payload from the request for the core parser's load_json

{"golden_diff": "diff --git a/src/webargs/falconparser.py b/src/webargs/falconparser.py\n--- a/src/webargs/falconparser.py\n+++ b/src/webargs/falconparser.py\n@@ -3,6 +3,8 @@\n import falcon\n from falcon.util.uri import parse_query_string\n \n+import marshmallow as ma\n+\n from webargs import core\n from webargs.multidictproxy import MultiDictProxy\n \n@@ -69,7 +71,21 @@\n \n \n class FalconParser(core.Parser):\n-    \"\"\"Falcon request argument parser.\"\"\"\n+    \"\"\"Falcon request argument parser.\n+\n+    Defaults to using the `media` location. See :py:meth:`~FalconParser.load_media` for\n+    details on the media location.\"\"\"\n+\n+    # by default, Falcon will use the 'media' location to load data\n+    #\n+    # this effectively looks the same as loading JSON data by default, but if\n+    # you add a handler for a different media type to Falcon, webargs will\n+    # automatically pick up on that capability\n+    DEFAULT_LOCATION = \"media\"\n+    DEFAULT_UNKNOWN_BY_LOCATION = dict(\n+        media=ma.RAISE, **core.Parser.DEFAULT_UNKNOWN_BY_LOCATION\n+    )\n+    __location_map__ = dict(media=\"load_media\", **core.Parser.__location_map__)\n \n     # Note on the use of MultiDictProxy throughout:\n     # Falcon parses query strings and form values into ordinary dicts, but with\n@@ -95,6 +111,25 @@\n             return form\n         return MultiDictProxy(form, schema)\n \n+    def load_media(self, req, schema):\n+        \"\"\"Return data unpacked and parsed by one of Falcon's media handlers.\n+        By default, Falcon only handles JSON payloads.\n+\n+        To configure additional media handlers, see the\n+        `Falcon documentation on media types`__.\n+\n+        .. _FalconMedia: https://falcon.readthedocs.io/en/stable/api/media.html\n+        __ FalconMedia_\n+\n+        .. note::\n+\n+            The request stream will be read and left at EOF.\n+        \"\"\"\n+        # if there is no body, return missing instead of erroring\n+        if req.content_length in (None, 0):\n+            return core.missing\n+        return req.media\n+\n     def _raw_load_json(self, req):\n         \"\"\"Return a json payload from the request for the core parser's load_json\n", "issue": "FalconParser should ideally support falcon's native media decoding\nFalcon has a native media handling mechanism which can decode an incoming request body based on the `Content-Type` header and adding the dictionary of resulting key-value pairs as a cached property `req.media`. I've written my own FalconParser subclass that (very naively) uses this, but it seems like something that might be worth supporting out of the box.\r\n\r\n```python\r\n    def parse_json(self, req, name, field):\r\n        \"\"\"\r\n        Pull a JSON body value from the request.\r\n        uses falcon's native req.media\r\n        \"\"\"\r\n        json_data = self._cache.get(\"json_data\")\r\n        if json_data is None:\r\n            self._cache[\"json_data\"] = json_data = req.media\r\n        return core.get_value(json_data, name, field, allow_many_nested=True)\r\n```\r\n\r\nThis could probably be improved upon; since the `media` property  is already cached on the request object, we could just access `req.media` directly without caching on the parser. (Not sure if this impacts other things that might use that cache, though; I haven't dug deep enough to fully understand that implication.) Also, since `media` was added in 1.3, if webargs still wanted to support older versions of falcon we could add a check for it and fall back to the existing behavior.\r\n\r\nMaybe something like:\r\n\r\n```python\r\n    def parse_json(self, req, name, field):\r\n        \"\"\"Pull a JSON body value from the request.\r\n        .. note::\r\n            The request stream will be read and left at EOF.\r\n        \"\"\"\r\n        json_data = req.media if hasattr(req, 'media') else self._cache.get(\"json_data\")\r\n        if json_data is None:\r\n            self._cache[\"json_data\"] = json_data = parse_json_body(req)\r\n        return core.get_value(json_data, name, field, allow_many_nested=True)\r\n```\n", "before_files": [{"content": "\"\"\"Falcon request argument parsing module.\n\"\"\"\nimport falcon\nfrom falcon.util.uri import parse_query_string\n\nfrom webargs import core\nfrom webargs.multidictproxy import MultiDictProxy\n\nHTTP_422 = \"422 Unprocessable Entity\"\n\n# Mapping of int status codes to string status\nstatus_map = {422: HTTP_422}\n\n\n# Collect all exceptions from falcon.status_codes\ndef _find_exceptions():\n    for name in filter(lambda n: n.startswith(\"HTTP\"), dir(falcon.status_codes)):\n        status = getattr(falcon.status_codes, name)\n        status_code = int(status.split(\" \")[0])\n        status_map[status_code] = status\n\n\n_find_exceptions()\ndel _find_exceptions\n\n\ndef is_json_request(req):\n    content_type = req.get_header(\"Content-Type\")\n    return content_type and core.is_json(content_type)\n\n\n# NOTE: Adapted from falcon.request.Request._parse_form_urlencoded\ndef parse_form_body(req):\n    if (\n        req.content_type is not None\n        and \"application/x-www-form-urlencoded\" in req.content_type\n    ):\n        body = req.stream.read(req.content_length or 0)\n        try:\n            body = body.decode(\"ascii\")\n        except UnicodeDecodeError:\n            body = None\n            req.log_error(\n                \"Non-ASCII characters found in form body \"\n                \"with Content-Type of \"\n                \"application/x-www-form-urlencoded. Body \"\n                \"will be ignored.\"\n            )\n\n        if body:\n            return parse_query_string(body, keep_blank=req.options.keep_blank_qs_values)\n\n    return core.missing\n\n\nclass HTTPError(falcon.HTTPError):\n    \"\"\"HTTPError that stores a dictionary of validation error messages.\"\"\"\n\n    def __init__(self, status, errors, *args, **kwargs):\n        self.errors = errors\n        super().__init__(status, *args, **kwargs)\n\n    def to_dict(self, *args, **kwargs):\n        \"\"\"Override `falcon.HTTPError` to include error messages in responses.\"\"\"\n        ret = super().to_dict(*args, **kwargs)\n        if self.errors is not None:\n            ret[\"errors\"] = self.errors\n        return ret\n\n\nclass FalconParser(core.Parser):\n    \"\"\"Falcon request argument parser.\"\"\"\n\n    # Note on the use of MultiDictProxy throughout:\n    # Falcon parses query strings and form values into ordinary dicts, but with\n    # the values listified where appropriate\n    # it is still therefore necessary in these cases to wrap them in\n    # MultiDictProxy because we need to use the schema to determine when single\n    # values should be wrapped in lists due to the type of the destination\n    # field\n\n    def load_querystring(self, req, schema):\n        \"\"\"Return query params from the request as a MultiDictProxy.\"\"\"\n        return MultiDictProxy(req.params, schema)\n\n    def load_form(self, req, schema):\n        \"\"\"Return form values from the request as a MultiDictProxy\n\n        .. note::\n\n            The request stream will be read and left at EOF.\n        \"\"\"\n        form = parse_form_body(req)\n        if form is core.missing:\n            return form\n        return MultiDictProxy(form, schema)\n\n    def _raw_load_json(self, req):\n        \"\"\"Return a json payload from the request for the core parser's load_json\n\n        Checks the input mimetype and may return 'missing' if the mimetype is\n        non-json, even if the request body is parseable as json.\"\"\"\n        if not is_json_request(req) or req.content_length in (None, 0):\n            return core.missing\n        body = req.stream.read(req.content_length)\n        if body:\n            return core.parse_json(body)\n        return core.missing\n\n    def load_headers(self, req, schema):\n        \"\"\"Return headers from the request.\"\"\"\n        # Falcon only exposes headers as a dict (not multidict)\n        return req.headers\n\n    def load_cookies(self, req, schema):\n        \"\"\"Return cookies from the request.\"\"\"\n        # Cookies are expressed in Falcon as a dict, but the possibility of\n        # multiple values for a cookie is preserved internally -- if desired in\n        # the future, webargs could add a MultiDict type for Cookies here built\n        # from (req, schema), but Falcon does not provide one out of the box\n        return req.cookies\n\n    def get_request_from_view_args(self, view, args, kwargs):\n        \"\"\"Get request from a resource method's arguments. Assumes that\n        request is the second argument.\n        \"\"\"\n        req = args[1]\n        if not isinstance(req, falcon.Request):\n            raise TypeError(\"Argument is not a falcon.Request\")\n        return req\n\n    def load_files(self, req, schema):\n        raise NotImplementedError(\n            f\"Parsing files not yet supported by {self.__class__.__name__}\"\n        )\n\n    def handle_error(self, error, req, schema, *, error_status_code, error_headers):\n        \"\"\"Handles errors during parsing.\"\"\"\n        status = status_map.get(error_status_code or self.DEFAULT_VALIDATION_STATUS)\n        if status is None:\n            raise LookupError(f\"Status code {error_status_code} not supported\")\n        raise HTTPError(status, errors=error.messages, headers=error_headers)\n\n    def _handle_invalid_json_error(self, error, req, *args, **kwargs):\n        status = status_map[400]\n        messages = {\"json\": [\"Invalid JSON body.\"]}\n        raise HTTPError(status, errors=messages)\n\n\nparser = FalconParser()\nuse_args = parser.use_args\nuse_kwargs = parser.use_kwargs\n", "path": "src/webargs/falconparser.py"}], "after_files": [{"content": "\"\"\"Falcon request argument parsing module.\n\"\"\"\nimport falcon\nfrom falcon.util.uri import parse_query_string\n\nimport marshmallow as ma\n\nfrom webargs import core\nfrom webargs.multidictproxy import MultiDictProxy\n\nHTTP_422 = \"422 Unprocessable Entity\"\n\n# Mapping of int status codes to string status\nstatus_map = {422: HTTP_422}\n\n\n# Collect all exceptions from falcon.status_codes\ndef _find_exceptions():\n    for name in filter(lambda n: n.startswith(\"HTTP\"), dir(falcon.status_codes)):\n        status = getattr(falcon.status_codes, name)\n        status_code = int(status.split(\" \")[0])\n        status_map[status_code] = status\n\n\n_find_exceptions()\ndel _find_exceptions\n\n\ndef is_json_request(req):\n    content_type = req.get_header(\"Content-Type\")\n    return content_type and core.is_json(content_type)\n\n\n# NOTE: Adapted from falcon.request.Request._parse_form_urlencoded\ndef parse_form_body(req):\n    if (\n        req.content_type is not None\n        and \"application/x-www-form-urlencoded\" in req.content_type\n    ):\n        body = req.stream.read(req.content_length or 0)\n        try:\n            body = body.decode(\"ascii\")\n        except UnicodeDecodeError:\n            body = None\n            req.log_error(\n                \"Non-ASCII characters found in form body \"\n                \"with Content-Type of \"\n                \"application/x-www-form-urlencoded. Body \"\n                \"will be ignored.\"\n            )\n\n        if body:\n            return parse_query_string(body, keep_blank=req.options.keep_blank_qs_values)\n\n    return core.missing\n\n\nclass HTTPError(falcon.HTTPError):\n    \"\"\"HTTPError that stores a dictionary of validation error messages.\"\"\"\n\n    def __init__(self, status, errors, *args, **kwargs):\n        self.errors = errors\n        super().__init__(status, *args, **kwargs)\n\n    def to_dict(self, *args, **kwargs):\n        \"\"\"Override `falcon.HTTPError` to include error messages in responses.\"\"\"\n        ret = super().to_dict(*args, **kwargs)\n        if self.errors is not None:\n            ret[\"errors\"] = self.errors\n        return ret\n\n\nclass FalconParser(core.Parser):\n    \"\"\"Falcon request argument parser.\n\n    Defaults to using the `media` location. See :py:meth:`~FalconParser.load_media` for\n    details on the media location.\"\"\"\n\n    # by default, Falcon will use the 'media' location to load data\n    #\n    # this effectively looks the same as loading JSON data by default, but if\n    # you add a handler for a different media type to Falcon, webargs will\n    # automatically pick up on that capability\n    DEFAULT_LOCATION = \"media\"\n    DEFAULT_UNKNOWN_BY_LOCATION = dict(\n        media=ma.RAISE, **core.Parser.DEFAULT_UNKNOWN_BY_LOCATION\n    )\n    __location_map__ = dict(media=\"load_media\", **core.Parser.__location_map__)\n\n    # Note on the use of MultiDictProxy throughout:\n    # Falcon parses query strings and form values into ordinary dicts, but with\n    # the values listified where appropriate\n    # it is still therefore necessary in these cases to wrap them in\n    # MultiDictProxy because we need to use the schema to determine when single\n    # values should be wrapped in lists due to the type of the destination\n    # field\n\n    def load_querystring(self, req, schema):\n        \"\"\"Return query params from the request as a MultiDictProxy.\"\"\"\n        return MultiDictProxy(req.params, schema)\n\n    def load_form(self, req, schema):\n        \"\"\"Return form values from the request as a MultiDictProxy\n\n        .. note::\n\n            The request stream will be read and left at EOF.\n        \"\"\"\n        form = parse_form_body(req)\n        if form is core.missing:\n            return form\n        return MultiDictProxy(form, schema)\n\n    def load_media(self, req, schema):\n        \"\"\"Return data unpacked and parsed by one of Falcon's media handlers.\n        By default, Falcon only handles JSON payloads.\n\n        To configure additional media handlers, see the\n        `Falcon documentation on media types`__.\n\n        .. _FalconMedia: https://falcon.readthedocs.io/en/stable/api/media.html\n        __ FalconMedia_\n\n        .. note::\n\n            The request stream will be read and left at EOF.\n        \"\"\"\n        # if there is no body, return missing instead of erroring\n        if req.content_length in (None, 0):\n            return core.missing\n        return req.media\n\n    def _raw_load_json(self, req):\n        \"\"\"Return a json payload from the request for the core parser's load_json\n\n        Checks the input mimetype and may return 'missing' if the mimetype is\n        non-json, even if the request body is parseable as json.\"\"\"\n        if not is_json_request(req) or req.content_length in (None, 0):\n            return core.missing\n        body = req.stream.read(req.content_length)\n        if body:\n            return core.parse_json(body)\n        return core.missing\n\n    def load_headers(self, req, schema):\n        \"\"\"Return headers from the request.\"\"\"\n        # Falcon only exposes headers as a dict (not multidict)\n        return req.headers\n\n    def load_cookies(self, req, schema):\n        \"\"\"Return cookies from the request.\"\"\"\n        # Cookies are expressed in Falcon as a dict, but the possibility of\n        # multiple values for a cookie is preserved internally -- if desired in\n        # the future, webargs could add a MultiDict type for Cookies here built\n        # from (req, schema), but Falcon does not provide one out of the box\n        return req.cookies\n\n    def get_request_from_view_args(self, view, args, kwargs):\n        \"\"\"Get request from a resource method's arguments. Assumes that\n        request is the second argument.\n        \"\"\"\n        req = args[1]\n        if not isinstance(req, falcon.Request):\n            raise TypeError(\"Argument is not a falcon.Request\")\n        return req\n\n    def load_files(self, req, schema):\n        raise NotImplementedError(\n            f\"Parsing files not yet supported by {self.__class__.__name__}\"\n        )\n\n    def handle_error(self, error, req, schema, *, error_status_code, error_headers):\n        \"\"\"Handles errors during parsing.\"\"\"\n        status = status_map.get(error_status_code or self.DEFAULT_VALIDATION_STATUS)\n        if status is None:\n            raise LookupError(f\"Status code {error_status_code} not supported\")\n        raise HTTPError(status, errors=error.messages, headers=error_headers)\n\n    def _handle_invalid_json_error(self, error, req, *args, **kwargs):\n        status = status_map[400]\n        messages = {\"json\": [\"Invalid JSON body.\"]}\n        raise HTTPError(status, errors=messages)\n\n\nparser = FalconParser()\nuse_args = parser.use_args\nuse_kwargs = parser.use_kwargs\n", "path": "src/webargs/falconparser.py"}]}