\\n

{title}

\"\\n \"\\n{msg}\\n \\n\"\\n ).format(title=title, msg=msg)\\n ct = \"text/html\"\\n else:\\n if tb:\\n msg = tb\\n message = title + \"\\n\\n\" + msg\\n\\n resp = Response(status=status, text=message, content_type=ct)\\n resp.force_close()\\n\\n return resp\\n\\n def _make_error_handler(\\n self, err_info: _ErrInfo\\n ) -> Callable[[BaseRequest], Awaitable[StreamResponse]]:\\n async def handler(request: BaseRequest) -> StreamResponse:\\n return self.handle_error(\\n request, err_info.status, err_info.exc, err_info.message\\n )\\n\\n return handler\\n"},"path":{"kind":"string","value":".venv\\Lib\\site-packages\\aiohttp\\web_protocol.py"},"filename":{"kind":"string","value":"web_protocol.py"},"language":{"kind":"string","value":"Python"},"size_bytes":{"kind":"number","value":27807,"string":"27,807"},"quality_score":{"kind":"number","value":0.95,"string":"0.95"},"complexity":{"kind":"number","value":0.1515151515151515,"string":"0.151515"},"documentation_ratio":{"kind":"number","value":0.0582089552238805,"string":"0.058209"},"repository":{"kind":"string","value":"awesome-app"},"stars":{"kind":"number","value":513,"string":"513"},"created_date":{"kind":"string","value":"2025-02-28T23:00:21.746508"},"license":{"kind":"string","value":"Apache-2.0"},"is_test":{"kind":"bool","value":false,"string":"false"},"file_hash":{"kind":"string","value":"51806960302777bb5319c8fc106fa976"}}},{"rowIdx":99,"cells":{"content":{"kind":"string","value":"import asyncio\\nimport datetime\\nimport io\\nimport re\\nimport socket\\nimport string\\nimport tempfile\\nimport types\\nimport warnings\\nfrom types import MappingProxyType\\nfrom typing import (\\n TYPE_CHECKING,\\n Any,\\n Dict,\\n Final,\\n Iterator,\\n Mapping,\\n MutableMapping,\\n Optional,\\n Pattern,\\n Tuple,\\n Union,\\n cast,\\n)\\nfrom urllib.parse import parse_qsl\\n\\nimport attr\\nfrom multidict import (\\n CIMultiDict,\\n CIMultiDictProxy,\\n MultiDict,\\n MultiDictProxy,\\n MultiMapping,\\n)\\nfrom yarl import URL\\n\\nfrom . import hdrs\\nfrom ._cookie_helpers import parse_cookie_header\\nfrom .abc import AbstractStreamWriter\\nfrom .helpers import (\\n _SENTINEL,\\n DEBUG,\\n ETAG_ANY,\\n LIST_QUOTED_ETAG_RE,\\n ChainMapProxy,\\n ETag,\\n HeadersMixin,\\n parse_http_date,\\n reify,\\n sentinel,\\n set_exception,\\n)\\nfrom .http_parser import RawRequestMessage\\nfrom .http_writer import HttpVersion\\nfrom .multipart import BodyPartReader, MultipartReader\\nfrom .streams import EmptyStreamReader, StreamReader\\nfrom .typedefs import (\\n DEFAULT_JSON_DECODER,\\n JSONDecoder,\\n LooseHeaders,\\n RawHeaders,\\n StrOrURL,\\n)\\nfrom .web_exceptions import HTTPRequestEntityTooLarge\\nfrom .web_response import StreamResponse\\n\\n__all__ = (\"BaseRequest\", \"FileField\", \"Request\")\\n\\n\\nif TYPE_CHECKING:\\n from .web_app import Application\\n from .web_protocol import RequestHandler\\n from .web_urldispatcher import UrlMappingMatchInfo\\n\\n\\n@attr.s(auto_attribs=True, frozen=True, slots=True)\\nclass FileField:\\n name: str\\n filename: str\\n file: io.BufferedReader\\n content_type: str\\n headers: CIMultiDictProxy[str]\\n\\n\\n_TCHAR: Final[str] = string.digits + string.ascii_letters + r\"!#$%&'*+.^_`|~-\"\\n# '-' at the end to prevent interpretation as range in a char class\\n\\n_TOKEN: Final[str] = rf\"[{_TCHAR}]+\"\\n\\n_QDTEXT: Final[str] = r\"[{}]\".format(\\n r\"\".join(chr(c) for c in (0x09, 0x20, 0x21) + tuple(range(0x23, 0x7F)))\\n)\\n# qdtext includes 0x5C to escape 0x5D ('\\]')\\n# qdtext excludes obs-text (because obsoleted, and encoding not specified)\\n\\n_QUOTED_PAIR: Final[str] = r\"\\\\[\\t !-~]\"\\n\\n_QUOTED_STRING: Final[str] = r'\"(?:{quoted_pair}|{qdtext})*\"'.format(\\n qdtext=_QDTEXT, quoted_pair=_QUOTED_PAIR\\n)\\n\\n_FORWARDED_PAIR: Final[str] = (\\n r\"({token})=({token}|{quoted_string})(:\\d{{1,4}})?\".format(\\n token=_TOKEN, quoted_string=_QUOTED_STRING\\n )\\n)\\n\\n_QUOTED_PAIR_REPLACE_RE: Final[Pattern[str]] = re.compile(r\"\\\\([\\t !-~])\")\\n# same pattern as _QUOTED_PAIR but contains a capture group\\n\\n_FORWARDED_PAIR_RE: Final[Pattern[str]] = re.compile(_FORWARDED_PAIR)\\n\\n############################################################\\n# HTTP Request\\n############################################################\\n\\n\\nclass BaseRequest(MutableMapping[str, Any], HeadersMixin):\\n\\n POST_METHODS = {\\n hdrs.METH_PATCH,\\n hdrs.METH_POST,\\n hdrs.METH_PUT,\\n hdrs.METH_TRACE,\\n hdrs.METH_DELETE,\\n }\\n\\n ATTRS = HeadersMixin.ATTRS | frozenset(\\n [\\n \"_message\",\\n \"_protocol\",\\n \"_payload_writer\",\\n \"_payload\",\\n \"_headers\",\\n \"_method\",\\n \"_version\",\\n \"_rel_url\",\\n \"_post\",\\n \"_read_bytes\",\\n \"_state\",\\n \"_cache\",\\n \"_task\",\\n \"_client_max_size\",\\n \"_loop\",\\n \"_transport_sslcontext\",\\n \"_transport_peername\",\\n ]\\n )\\n _post: Optional[MultiDictProxy[Union[str, bytes, FileField]]] = None\\n _read_bytes: Optional[bytes] = None\\n\\n def __init__(\\n self,\\n message: RawRequestMessage,\\n payload: StreamReader,\\n protocol: \"RequestHandler\",\\n payload_writer: AbstractStreamWriter,\\n task: \"asyncio.Task[None]\",\\n loop: asyncio.AbstractEventLoop,\\n *,\\n client_max_size: int = 1024**2,\\n state: Optional[Dict[str, Any]] = None,\\n scheme: Optional[str] = None,\\n host: Optional[str] = None,\\n remote: Optional[str] = None,\\n ) -> None:\\n self._message = message\\n self._protocol = protocol\\n self._payload_writer = payload_writer\\n\\n self._payload = payload\\n self._headers: CIMultiDictProxy[str] = message.headers\\n self._method = message.method\\n self._version = message.version\\n self._cache: Dict[str, Any] = {}\\n url = message.url\\n if url.absolute:\\n if scheme is not None:\\n url = url.with_scheme(scheme)\\n if host is not None:\\n url = url.with_host(host)\\n # absolute URL is given,\\n # override auto-calculating url, host, and scheme\\n # all other properties should be good\\n self._cache[\"url\"] = url\\n self._cache[\"host\"] = url.host\\n self._cache[\"scheme\"] = url.scheme\\n self._rel_url = url.relative()\\n else:\\n self._rel_url = url\\n if scheme is not None:\\n self._cache[\"scheme\"] = scheme\\n if host is not None:\\n self._cache[\"host\"] = host\\n\\n self._state = {} if state is None else state\\n self._task = task\\n self._client_max_size = client_max_size\\n self._loop = loop\\n\\n self._transport_sslcontext = protocol.ssl_context\\n self._transport_peername = protocol.peername\\n\\n if remote is not None:\\n self._cache[\"remote\"] = remote\\n\\n def clone(\\n self,\\n *,\\n method: Union[str, _SENTINEL] = sentinel,\\n rel_url: Union[StrOrURL, _SENTINEL] = sentinel,\\n headers: Union[LooseHeaders, _SENTINEL] = sentinel,\\n scheme: Union[str, _SENTINEL] = sentinel,\\n host: Union[str, _SENTINEL] = sentinel,\\n remote: Union[str, _SENTINEL] = sentinel,\\n client_max_size: Union[int, _SENTINEL] = sentinel,\\n ) -> \"BaseRequest\":\\n \"\"\"Clone itself with replacement some attributes.\\n\\n Creates and returns a new instance of Request object. If no parameters\\n are given, an exact copy is returned. If a parameter is not passed, it\\n will reuse the one from the current request object.\\n \"\"\"\\n if self._read_bytes:\\n raise RuntimeError(\"Cannot clone request after reading its content\")\\n\\n dct: Dict[str, Any] = {}\\n if method is not sentinel:\\n dct[\"method\"] = method\\n if rel_url is not sentinel:\\n new_url: URL = URL(rel_url)\\n dct[\"url\"] = new_url\\n dct[\"path\"] = str(new_url)\\n if headers is not sentinel:\\n # a copy semantic\\n dct[\"headers\"] = CIMultiDictProxy(CIMultiDict(headers))\\n dct[\"raw_headers\"] = tuple(\\n (k.encode(\"utf-8\"), v.encode(\"utf-8\"))\\n for k, v in dct[\"headers\"].items()\\n )\\n\\n message = self._message._replace(**dct)\\n\\n kwargs = {}\\n if scheme is not sentinel:\\n kwargs[\"scheme\"] = scheme\\n if host is not sentinel:\\n kwargs[\"host\"] = host\\n if remote is not sentinel:\\n kwargs[\"remote\"] = remote\\n if client_max_size is sentinel:\\n client_max_size = self._client_max_size\\n\\n return self.__class__(\\n message,\\n self._payload,\\n self._protocol,\\n self._payload_writer,\\n self._task,\\n self._loop,\\n client_max_size=client_max_size,\\n state=self._state.copy(),\\n **kwargs,\\n )\\n\\n @property\\n def task(self) -> \"asyncio.Task[None]\":\\n return self._task\\n\\n @property\\n def protocol(self) -> \"RequestHandler\":\\n return self._protocol\\n\\n @property\\n def transport(self) -> Optional[asyncio.Transport]:\\n if self._protocol is None:\\n return None\\n return self._protocol.transport\\n\\n @property\\n def writer(self) -> AbstractStreamWriter:\\n return self._payload_writer\\n\\n @property\\n def client_max_size(self) -> int:\\n return self._client_max_size\\n\\n @reify\\n def message(self) -> RawRequestMessage:\\n warnings.warn(\"Request.message is deprecated\", DeprecationWarning, stacklevel=3)\\n return self._message\\n\\n @reify\\n def rel_url(self) -> URL:\\n return self._rel_url\\n\\n @reify\\n def loop(self) -> asyncio.AbstractEventLoop:\\n warnings.warn(\\n \"request.loop property is deprecated\", DeprecationWarning, stacklevel=2\\n )\\n return self._loop\\n\\n # MutableMapping API\\n\\n def __getitem__(self, key: str) -> Any:\\n return self._state[key]\\n\\n def __setitem__(self, key: str, value: Any) -> None:\\n self._state[key] = value\\n\\n def __delitem__(self, key: str) -> None:\\n del self._state[key]\\n\\n def __len__(self) -> int:\\n return len(self._state)\\n\\n def __iter__(self) -> Iterator[str]:\\n return iter(self._state)\\n\\n ########\\n\\n @reify\\n def secure(self) -> bool:\\n \"\"\"A bool indicating if the request is handled with SSL.\"\"\"\\n return self.scheme == \"https\"\\n\\n @reify\\n def forwarded(self) -> Tuple[Mapping[str, str], ...]:\\n \"\"\"A tuple containing all parsed Forwarded header(s).\\n\\n Makes an effort to parse Forwarded headers as specified by RFC 7239:\\n\\n - It adds one (immutable) dictionary per Forwarded 'field-value', ie\\n per proxy. The element corresponds to the data in the Forwarded\\n field-value added by the first proxy encountered by the client. Each\\n subsequent item corresponds to those added by later proxies.\\n - It checks that every value has valid syntax in general as specified\\n in section 4: either a 'token' or a 'quoted-string'.\\n - It un-escapes found escape sequences.\\n - It does NOT validate 'by' and 'for' contents as specified in section\\n 6.\\n - It does NOT validate 'host' contents (Host ABNF).\\n - It does NOT validate 'proto' contents for valid URI scheme names.\\n\\n Returns a tuple containing one or more immutable dicts\\n \"\"\"\\n elems = []\\n for field_value in self._message.headers.getall(hdrs.FORWARDED, ()):\\n length = len(field_value)\\n pos = 0\\n need_separator = False\\n elem: Dict[str, str] = {}\\n elems.append(types.MappingProxyType(elem))\\n while 0 <= pos < length:\\n match = _FORWARDED_PAIR_RE.match(field_value, pos)\\n if match is not None: # got a valid forwarded-pair\\n if need_separator:\\n # bad syntax here, skip to next comma\\n pos = field_value.find(\",\", pos)\\n else:\\n name, value, port = match.groups()\\n if value[0] == '\"':\\n # quoted string: remove quotes and unescape\\n value = _QUOTED_PAIR_REPLACE_RE.sub(r\"\\1\", value[1:-1])\\n if port:\\n value += port\\n elem[name.lower()] = value\\n pos += len(match.group(0))\\n need_separator = True\\n elif field_value[pos] == \",\": # next forwarded-element\\n need_separator = False\\n elem = {}\\n elems.append(types.MappingProxyType(elem))\\n pos += 1\\n elif field_value[pos] == \";\": # next forwarded-pair\\n need_separator = False\\n pos += 1\\n elif field_value[pos] in \" \\t\":\\n # Allow whitespace even between forwarded-pairs, though\\n # RFC 7239 doesn't. This simplifies code and is in line\\n # with Postel's law.\\n pos += 1\\n else:\\n # bad syntax here, skip to next comma\\n pos = field_value.find(\",\", pos)\\n return tuple(elems)\\n\\n @reify\\n def scheme(self) -> str:\\n \"\"\"A string representing the scheme of the request.\\n\\n Hostname is resolved in this order:\\n\\n - overridden value by .clone(scheme=new_scheme) call.\\n - type of connection to peer: HTTPS if socket is SSL, HTTP otherwise.\\n\\n 'http' or 'https'.\\n \"\"\"\\n if self._transport_sslcontext:\\n return \"https\"\\n else:\\n return \"http\"\\n\\n @reify\\n def method(self) -> str:\\n \"\"\"Read only property for getting HTTP method.\\n\\n The value is upper-cased str like 'GET', 'POST', 'PUT' etc.\\n \"\"\"\\n return self._method\\n\\n @reify\\n def version(self) -> HttpVersion:\\n \"\"\"Read only property for getting HTTP version of request.\\n\\n Returns aiohttp.protocol.HttpVersion instance.\\n \"\"\"\\n return self._version\\n\\n @reify\\n def host(self) -> str:\\n \"\"\"Hostname of the request.\\n\\n Hostname is resolved in this order:\\n\\n - overridden value by .clone(host=new_host) call.\\n - HOST HTTP header\\n - socket.getfqdn() value\\n\\n For example, 'example.com' or 'localhost:8080'.\\n\\n For historical reasons, the port number may be included.\\n \"\"\"\\n host = self._message.headers.get(hdrs.HOST)\\n if host is not None:\\n return host\\n return socket.getfqdn()\\n\\n @reify\\n def remote(self) -> Optional[str]:\\n \"\"\"Remote IP of client initiated HTTP request.\\n\\n The IP is resolved in this order:\\n\\n - overridden value by .clone(remote=new_remote) call.\\n - peername of opened socket\\n \"\"\"\\n if self._transport_peername is None:\\n return None\\n if isinstance(self._transport_peername, (list, tuple)):\\n return str(self._transport_peername[0])\\n return str(self._transport_peername)\\n\\n @reify\\n def url(self) -> URL:\\n \"\"\"The full URL of the request.\"\"\"\\n # authority is used here because it may include the port number\\n # and we want yarl to parse it correctly\\n return URL.build(scheme=self.scheme, authority=self.host).join(self._rel_url)\\n\\n @reify\\n def path(self) -> str:\\n \"\"\"The URL including *PATH INFO* without the host or scheme.\\n\\n E.g., ``/app/blog``\\n \"\"\"\\n return self._rel_url.path\\n\\n @reify\\n def path_qs(self) -> str:\\n \"\"\"The URL including PATH_INFO and the query string.\\n\\n E.g, /app/blog?id=10\\n \"\"\"\\n return str(self._rel_url)\\n\\n @reify\\n def raw_path(self) -> str:\\n \"\"\"The URL including raw *PATH INFO* without the host or scheme.\\n\\n Warning, the path is unquoted and may contains non valid URL characters\\n\\n E.g., ``/my%2Fpath%7Cwith%21some%25strange%24characters``\\n \"\"\"\\n return self._message.path\\n\\n @reify\\n def query(self) -> \"MultiMapping[str]\":\\n \"\"\"A multidict with all the variables in the query string.\"\"\"\\n return self._rel_url.query\\n\\n @reify\\n def query_string(self) -> str:\\n \"\"\"The query string in the URL.\\n\\n E.g., id=10\\n \"\"\"\\n return self._rel_url.query_string\\n\\n @reify\\n def headers(self) -> CIMultiDictProxy[str]:\\n \"\"\"A case-insensitive multidict proxy with all headers.\"\"\"\\n return self._headers\\n\\n @reify\\n def raw_headers(self) -> RawHeaders:\\n \"\"\"A sequence of pairs for all headers.\"\"\"\\n return self._message.raw_headers\\n\\n @reify\\n def if_modified_since(self) -> Optional[datetime.datetime]:\\n \"\"\"The value of If-Modified-Since HTTP header, or None.\\n\\n This header is represented as a `datetime` object.\\n \"\"\"\\n return parse_http_date(self.headers.get(hdrs.IF_MODIFIED_SINCE))\\n\\n @reify\\n def if_unmodified_since(self) -> Optional[datetime.datetime]:\\n \"\"\"The value of If-Unmodified-Since HTTP header, or None.\\n\\n This header is represented as a `datetime` object.\\n \"\"\"\\n return parse_http_date(self.headers.get(hdrs.IF_UNMODIFIED_SINCE))\\n\\n @staticmethod\\n def _etag_values(etag_header: str) -> Iterator[ETag]:\\n \"\"\"Extract `ETag` objects from raw header.\"\"\"\\n if etag_header == ETAG_ANY:\\n yield ETag(\\n is_weak=False,\\n value=ETAG_ANY,\\n )\\n else:\\n for match in LIST_QUOTED_ETAG_RE.finditer(etag_header):\\n is_weak, value, garbage = match.group(2, 3, 4)\\n # Any symbol captured by 4th group means\\n # that the following sequence is invalid.\\n if garbage:\\n break\\n\\n yield ETag(\\n is_weak=bool(is_weak),\\n value=value,\\n )\\n\\n @classmethod\\n def _if_match_or_none_impl(\\n cls, header_value: Optional[str]\\n ) -> Optional[Tuple[ETag, ...]]:\\n if not header_value:\\n return None\\n\\n return tuple(cls._etag_values(header_value))\\n\\n @reify\\n def if_match(self) -> Optional[Tuple[ETag, ...]]:\\n \"\"\"The value of If-Match HTTP header, or None.\\n\\n This header is represented as a `tuple` of `ETag` objects.\\n \"\"\"\\n return self._if_match_or_none_impl(self.headers.get(hdrs.IF_MATCH))\\n\\n @reify\\n def if_none_match(self) -> Optional[Tuple[ETag, ...]]:\\n \"\"\"The value of If-None-Match HTTP header, or None.\\n\\n This header is represented as a `tuple` of `ETag` objects.\\n \"\"\"\\n return self._if_match_or_none_impl(self.headers.get(hdrs.IF_NONE_MATCH))\\n\\n @reify\\n def if_range(self) -> Optional[datetime.datetime]:\\n \"\"\"The value of If-Range HTTP header, or None.\\n\\n This header is represented as a `datetime` object.\\n \"\"\"\\n return parse_http_date(self.headers.get(hdrs.IF_RANGE))\\n\\n @reify\\n def keep_alive(self) -> bool:\\n \"\"\"Is keepalive enabled by client?\"\"\"\\n return not self._message.should_close\\n\\n @reify\\n def cookies(self) -> Mapping[str, str]:\\n \"\"\"Return request cookies.\\n\\n A read-only dictionary-like object.\\n \"\"\"\\n # Use parse_cookie_header for RFC 6265 compliant Cookie header parsing\\n # that accepts special characters in cookie names (fixes #2683)\\n parsed = parse_cookie_header(self.headers.get(hdrs.COOKIE, \"\"))\\n # Extract values from Morsel objects\\n return MappingProxyType({name: morsel.value for name, morsel in parsed})\\n\\n @reify\\n def http_range(self) -> slice:\\n \"\"\"The content of Range HTTP header.\\n\\n Return a slice instance.\\n\\n \"\"\"\\n rng = self._headers.get(hdrs.RANGE)\\n start, end = None, None\\n if rng is not None:\\n try:\\n pattern = r\"^bytes=(\\d*)-(\\d*)$\"\\n start, end = re.findall(pattern, rng)[0]\\n except IndexError: # pattern was not found in header\\n raise ValueError(\"range not in acceptable format\")\\n\\n end = int(end) if end else None\\n start = int(start) if start else None\\n\\n if start is None and end is not None:\\n # end with no start is to return tail of content\\n start = -end\\n end = None\\n\\n if start is not None and end is not None:\\n # end is inclusive in range header, exclusive for slice\\n end += 1\\n\\n if start >= end:\\n raise ValueError(\"start cannot be after end\")\\n\\n if start is end is None: # No valid range supplied\\n raise ValueError(\"No start or end of range specified\")\\n\\n return slice(start, end, 1)\\n\\n @reify\\n def content(self) -> StreamReader:\\n \"\"\"Return raw payload stream.\"\"\"\\n return self._payload\\n\\n @property\\n def has_body(self) -> bool:\\n \"\"\"Return True if request's HTTP BODY can be read, False otherwise.\"\"\"\\n warnings.warn(\\n \"Deprecated, use .can_read_body #2005\", DeprecationWarning, stacklevel=2\\n )\\n return not self._payload.at_eof()\\n\\n @property\\n def can_read_body(self) -> bool:\\n \"\"\"Return True if request's HTTP BODY can be read, False otherwise.\"\"\"\\n return not self._payload.at_eof()\\n\\n @reify\\n def body_exists(self) -> bool:\\n \"\"\"Return True if request has HTTP BODY, False otherwise.\"\"\"\\n return type(self._payload) is not EmptyStreamReader\\n\\n async def release(self) -> None:\\n \"\"\"Release request.\\n\\n Eat unread part of HTTP BODY if present.\\n \"\"\"\\n while not self._payload.at_eof():\\n await self._payload.readany()\\n\\n async def read(self) -> bytes:\\n \"\"\"Read request body if present.\\n\\n Returns bytes object with full request content.\\n \"\"\"\\n if self._read_bytes is None:\\n body = bytearray()\\n while True:\\n chunk = await self._payload.readany()\\n body.extend(chunk)\\n if self._client_max_size:\\n body_size = len(body)\\n if body_size >= self._client_max_size:\\n raise HTTPRequestEntityTooLarge(\\n max_size=self._client_max_size, actual_size=body_size\\n )\\n if not chunk:\\n break\\n self._read_bytes = bytes(body)\\n return self._read_bytes\\n\\n async def text(self) -> str:\\n \"\"\"Return BODY as text using encoding from .charset.\"\"\"\\n bytes_body = await self.read()\\n encoding = self.charset or \"utf-8\"\\n return bytes_body.decode(encoding)\\n\\n async def json(self, *, loads: JSONDecoder = DEFAULT_JSON_DECODER) -> Any:\\n \"\"\"Return BODY as JSON.\"\"\"\\n body = await self.text()\\n return loads(body)\\n\\n async def multipart(self) -> MultipartReader:\\n \"\"\"Return async iterator to process BODY as multipart.\"\"\"\\n return MultipartReader(self._headers, self._payload)\\n\\n async def post(self) -> \"MultiDictProxy[Union[str, bytes, FileField]]\":\\n \"\"\"Return POST parameters.\"\"\"\\n if self._post is not None:\\n return self._post\\n if self._method not in self.POST_METHODS:\\n self._post = MultiDictProxy(MultiDict())\\n return self._post\\n\\n content_type = self.content_type\\n if content_type not in (\\n \"\",\\n \"application/x-www-form-urlencoded\",\\n \"multipart/form-data\",\\n ):\\n self._post = MultiDictProxy(MultiDict())\\n return self._post\\n\\n out: MultiDict[Union[str, bytes, FileField]] = MultiDict()\\n\\n if content_type == \"multipart/form-data\":\\n multipart = await self.multipart()\\n max_size = self._client_max_size\\n\\n field = await multipart.next()\\n while field is not None:\\n size = 0\\n field_ct = field.headers.get(hdrs.CONTENT_TYPE)\\n\\n if isinstance(field, BodyPartReader):\\n assert field.name is not None\\n\\n # Note that according to RFC 7578, the Content-Type header\\n # is optional, even for files, so we can't assume it's\\n # present.\\n # https://tools.ietf.org/html/rfc7578#section-4.4\\n if field.filename:\\n # store file in temp file\\n tmp = await self._loop.run_in_executor(\\n None, tempfile.TemporaryFile\\n )\\n chunk = await field.read_chunk(size=2**16)\\n while chunk:\\n chunk = field.decode(chunk)\\n await self._loop.run_in_executor(None, tmp.write, chunk)\\n size += len(chunk)\\n if 0 < max_size < size:\\n await self._loop.run_in_executor(None, tmp.close)\\n raise HTTPRequestEntityTooLarge(\\n max_size=max_size, actual_size=size\\n )\\n chunk = await field.read_chunk(size=2**16)\\n await self._loop.run_in_executor(None, tmp.seek, 0)\\n\\n if field_ct is None:\\n field_ct = \"application/octet-stream\"\\n\\n ff = FileField(\\n field.name,\\n field.filename,\\n cast(io.BufferedReader, tmp),\\n field_ct,\\n field.headers,\\n )\\n out.add(field.name, ff)\\n else:\\n # deal with ordinary data\\n value = await field.read(decode=True)\\n if field_ct is None or field_ct.startswith(\"text/\"):\\n charset = field.get_charset(default=\"utf-8\")\\n out.add(field.name, value.decode(charset))\\n else:\\n out.add(field.name, value)\\n size += len(value)\\n if 0 < max_size < size:\\n raise HTTPRequestEntityTooLarge(\\n max_size=max_size, actual_size=size\\n )\\n else:\\n raise ValueError(\\n \"To decode nested multipart you need to use custom reader\",\\n )\\n\\n field = await multipart.next()\\n else:\\n data = await self.read()\\n if data:\\n charset = self.charset or \"utf-8\"\\n out.extend(\\n parse_qsl(\\n data.rstrip().decode(charset),\\n keep_blank_values=True,\\n encoding=charset,\\n )\\n )\\n\\n self._post = MultiDictProxy(out)\\n return self._post\\n\\n def get_extra_info(self, name: str, default: Any = None) -> Any:\\n \"\"\"Extra info from protocol transport\"\"\"\\n protocol = self._protocol\\n if protocol is None:\\n return default\\n\\n transport = protocol.transport\\n if transport is None:\\n return default\\n\\n return transport.get_extra_info(name, default)\\n\\n def __repr__(self) -> str:\\n ascii_encodable_path = self.path.encode(\"ascii\", \"backslashreplace\").decode(\\n \"ascii\"\\n )\\n return \"<{} {} {} >\".format(\\n self.__class__.__name__, self._method, ascii_encodable_path\\n )\\n\\n def __eq__(self, other: object) -> bool:\\n return id(self) == id(other)\\n\\n def __bool__(self) -> bool:\\n return True\\n\\n async def _prepare_hook(self, response: StreamResponse) -> None:\\n return\\n\\n def _cancel(self, exc: BaseException) -> None:\\n set_exception(self._payload, exc)\\n\\n def _finish(self) -> None:\\n if self._post is None or self.content_type != \"multipart/form-data\":\\n return\\n\\n # NOTE: Release file descriptors for the\\n # NOTE: `tempfile.Temporaryfile`-created `_io.BufferedRandom`\\n # NOTE: instances of files sent within multipart request body\\n # NOTE: via HTTP POST request.\\n for file_name, file_field_object in self._post.items():\\n if isinstance(file_field_object, FileField):\\n file_field_object.file.close()\\n\\n\\nclass Request(BaseRequest):\\n\\n ATTRS = BaseRequest.ATTRS | frozenset([\"_match_info\"])\\n\\n _match_info: Optional[\"UrlMappingMatchInfo\"] = None\\n\\n if DEBUG:\\n\\n def __setattr__(self, name: str, val: Any) -> None:\\n if name not in self.ATTRS:\\n warnings.warn(\\n \"Setting custom {}.{} attribute \"\\n \"is discouraged\".format(self.__class__.__name__, name),\\n DeprecationWarning,\\n stacklevel=2,\\n )\\n super().__setattr__(name, val)\\n\\n def clone(\\n self,\\n *,\\n method: Union[str, _SENTINEL] = sentinel,\\n rel_url: Union[StrOrURL, _SENTINEL] = sentinel,\\n headers: Union[LooseHeaders, _SENTINEL] = sentinel,\\n scheme: Union[str, _SENTINEL] = sentinel,\\n host: Union[str, _SENTINEL] = sentinel,\\n remote: Union[str, _SENTINEL] = sentinel,\\n client_max_size: Union[int, _SENTINEL] = sentinel,\\n ) -> \"Request\":\\n ret = super().clone(\\n method=method,\\n rel_url=rel_url,\\n headers=headers,\\n scheme=scheme,\\n host=host,\\n remote=remote,\\n client_max_size=client_max_size,\\n )\\n new_ret = cast(Request, ret)\\n new_ret._match_info = self._match_info\\n return new_ret\\n\\n @reify\\n def match_info(self) -> \"UrlMappingMatchInfo\":\\n \"\"\"Result of route resolving.\"\"\"\\n match_info = self._match_info\\n assert match_info is not None\\n return match_info\\n\\n @property\\n def app(self) -> \"Application\":\\n \"\"\"Application instance.\"\"\"\\n match_info = self._match_info\\n assert match_info is not None\\n return match_info.current_app\\n\\n @property\\n def config_dict(self) -> ChainMapProxy:\\n match_info = self._match_info\\n assert match_info is not None\\n lst = match_info.apps\\n app = self.app\\n idx = lst.index(app)\\n sublist = list(reversed(lst[: idx + 1]))\\n return ChainMapProxy(sublist)\\n\\n async def _prepare_hook(self, response: StreamResponse) -> None:\\n match_info = self._match_info\\n if match_info is None:\\n return\\n for app in match_info._apps:\\n if on_response_prepare := app.on_response_prepare:\\n await on_response_prepare.send(self, response)\\n"},"path":{"kind":"string","value":".venv\\Lib\\site-packages\\aiohttp\\web_request.py"},"filename":{"kind":"string","value":"web_request.py"},"language":{"kind":"string","value":"Python"},"size_bytes":{"kind":"number","value":30749,"string":"30,749"},"quality_score":{"kind":"number","value":0.95,"string":"0.95"},"complexity":{"kind":"number","value":0.168122270742358,"string":"0.168122"},"documentation_ratio":{"kind":"number","value":0.0548302872062663,"string":"0.05483"},"repository":{"kind":"string","value":"python-kit"},"stars":{"kind":"number","value":831,"string":"831"},"created_date":{"kind":"string","value":"2023-07-25T09:51:52.066489"},"license":{"kind":"string","value":"MIT"},"is_test":{"kind":"bool","value":false,"string":"false"},"file_hash":{"kind":"string","value":"0e5c6299cd865d7738801f77c5f7bd72"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":128738,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc2MjUxMTE0Nywic3ViIjoiL2RhdGFzZXRzL3ZpbnNibGFjay9UaGVfU3RhY2tfUHJvY2Vzc2VkLXYyIiwiZXhwIjoxNzYyNTE0NzQ3LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.r4poUHNxYRwviHQniNpObHvUdbJOX4GFqr7rjXCR96bkWgUH1Z3_rZjekbDTXYg_2p48BHIBhvZQQP7oGkq_Cg","displayUrls":true,"sqlConsoleEnabled":true},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">