193
194
195
196
197
198
199
200
201
202

def init(
    self, scope: Scope, receive: Receive = emptyreceive, send: Send = emptysend
):
    super().__init(scope)
    assert scope[“type”] == “http”
    self._receive = receive
    self._send = send
    self._stream_consumed = False
    self._is_disconnected = False
    self._form = None

176
177
178
179

def url_for(self, name: str, **path_params: typing.Any) -> URL:
    router: Router = self.scope[“router”]
    url_path = router.url_path_for(name, **path_params)
    return url_path.make_absolute_url(base_url=self.base_url)

212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231

async def stream(self) -> typing.AsyncGenerator[bytes, None]:
    if hasattr(self, “_body”):
        yield self._body
        yield b“”
        return
    if self._stream_consumed:
        raise RuntimeError(“Stream consumed”)
    self._stream_consumed = True
    while True:
        message = await self._receive()
        if message[“type”] == “http.request”:
            body = message.get(“body”, b“”)
            if body:
                yield body
            if not message.get(“more_body”, False):
                break
        elif message[“type”] == “http.disconnect”:
            self._is_disconnected = True
            raise ClientDisconnect()
    yield b“”

233
234
235
236
237
238
239

async def body(self) -> bytes:
    if not hasattr(self, “_body”):
        chunks: “typing.List[bytes]” = []
        async for chunk in self.stream():
            chunks.append(chunk)
        self._body = b“”.join(chunks)
    return self._body

241
242
243
244
245

async def json(self) -> typing.Any:
    if not hasattr(self, “_json”):
        body = await self.body()
        self._json = json.loads(body)
    return self._json

280
281
282
283
284
285
286
287
288

def form(
    self,
    *,
    max_files: typing.Union[int, float] = 1000,
    max_fields: typing.Union[int, float] = 1000,
) -> AwaitableOrContextManager[FormData]:
    return AwaitableOrContextManagerWrapper(
        self._get_form(max_files=max_files, max_fields=max_fields)
    )

290
291
292

async def close(self) -> None:
    if self._form is not None:
        await self._form.close()

294
295
296
297
298
299
300
301
302
303
304
305
306

async def is_disconnected(self) -> bool:
    if not self._is_disconnected:
        message: Message = {}
        # If message isn’t immediately available, move on
        with anyio.CancelScope() as cs:
            cs.cancel()
            message = await self._receive()
        if message.get(“type”) == “http.disconnect”:
            self._is_disconnected = True
    return self._is_disconnected

308
309
310
311
312
313
314
315
316
317
318

async def send_push_promise(self, path: str) -> None:
    if “http.response.push” in self.scope.get(“extensions”, {}):
        raw_headers: “typing.List[typing.Tuple[bytes, bytes]]” = []
        for name in SERVER_PUSH_HEADERS_TO_COPY:
            for value in self.headers.getlist(name):
                raw_headers.append(
                    (name.encode(“latin-1”), value.encode(“latin-1”))
                )
        await self._send(
            {“type”: “http.response.push”, “path”: path, “headers”: raw_headers}
        )