Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/aiohttp/client.py: 54%

1"""HTTP Client for asyncio.""" 

2 

3import asyncio 

4import base64 

5import hashlib 

6import json 

7import os 

8import sys 

9import traceback 

10import warnings 

11from contextlib import suppress 

12from types import SimpleNamespace, TracebackType 

13from typing import ( 

14 TYPE_CHECKING, 

15 Any, 

16 Awaitable, 

17 Callable, 

18 Coroutine, 

19 Final, 

20 FrozenSet, 

21 Generator, 

22 Generic, 

23 Iterable, 

24 List, 

25 Literal, 

26 Mapping, 

27 Optional, 

28 Set, 

29 Tuple, 

30 Type, 

31 TypeVar, 

32 Union, 

33) 

34 

35import attr 

36from multidict import CIMultiDict, MultiDict, MultiDictProxy, istr 

37from yarl import URL 

38 

39from . import hdrs, http, payload 

40from .abc import AbstractCookieJar 

41from .client_exceptions import ( 

42 ClientConnectionError as ClientConnectionError, 

43 ClientConnectorCertificateError as ClientConnectorCertificateError, 

44 ClientConnectorError as ClientConnectorError, 

45 ClientConnectorSSLError as ClientConnectorSSLError, 

46 ClientError as ClientError, 

47 ClientHttpProxyError as ClientHttpProxyError, 

48 ClientOSError as ClientOSError, 

49 ClientPayloadError as ClientPayloadError, 

50 ClientProxyConnectionError as ClientProxyConnectionError, 

51 ClientResponseError as ClientResponseError, 

52 ClientSSLError as ClientSSLError, 

53 ContentTypeError as ContentTypeError, 

54 InvalidURL as InvalidURL, 

55 ServerConnectionError as ServerConnectionError, 

56 ServerDisconnectedError as ServerDisconnectedError, 

57 ServerFingerprintMismatch as ServerFingerprintMismatch, 

58 ServerTimeoutError as ServerTimeoutError, 

59 TooManyRedirects as TooManyRedirects, 

60 WSServerHandshakeError as WSServerHandshakeError, 

61) 

62from .client_reqrep import ( 

63 ClientRequest as ClientRequest, 

64 ClientResponse as ClientResponse, 

65 Fingerprint as Fingerprint, 

66 RequestInfo as RequestInfo, 

67 _merge_ssl_params, 

68) 

69from .client_ws import ClientWebSocketResponse as ClientWebSocketResponse 

70from .connector import ( 

71 BaseConnector as BaseConnector, 

72 NamedPipeConnector as NamedPipeConnector, 

73 TCPConnector as TCPConnector, 

74 UnixConnector as UnixConnector, 

75) 

76from .cookiejar import CookieJar 

77from .helpers import ( 

78 _SENTINEL, 

79 DEBUG, 

80 BasicAuth, 

81 TimeoutHandle, 

82 ceil_timeout, 

83 get_env_proxy_for_url, 

84 get_running_loop, 

85 method_must_be_empty_body, 

86 sentinel, 

87 strip_auth_from_url, 

88) 

89from .http import WS_KEY, HttpVersion, WebSocketReader, WebSocketWriter 

90from .http_websocket import WSHandshakeError, WSMessage, ws_ext_gen, ws_ext_parse 

91from .streams import FlowControlDataQueue 

92from .tracing import Trace, TraceConfig 

93from .typedefs import JSONEncoder, LooseCookies, LooseHeaders, StrOrURL 

94 

95__all__ = ( 

96 # client_exceptions 

97 "ClientConnectionError", 

98 "ClientConnectorCertificateError", 

99 "ClientConnectorError", 

100 "ClientConnectorSSLError", 

101 "ClientError", 

102 "ClientHttpProxyError", 

103 "ClientOSError", 

104 "ClientPayloadError", 

105 "ClientProxyConnectionError", 

106 "ClientResponseError", 

107 "ClientSSLError", 

108 "ContentTypeError", 

109 "InvalidURL", 

110 "ServerConnectionError", 

111 "ServerDisconnectedError", 

112 "ServerFingerprintMismatch", 

113 "ServerTimeoutError", 

114 "TooManyRedirects", 

115 "WSServerHandshakeError", 

116 # client_reqrep 

117 "ClientRequest", 

118 "ClientResponse", 

119 "Fingerprint", 

120 "RequestInfo", 

121 # connector 

122 "BaseConnector", 

123 "TCPConnector", 

124 "UnixConnector", 

125 "NamedPipeConnector", 

126 # client_ws 

127 "ClientWebSocketResponse", 

128 # client 

129 "ClientSession", 

130 "ClientTimeout", 

131 "request", 

132) 

133 

134 

135if TYPE_CHECKING: 

136 from ssl import SSLContext 

137else: 

138 SSLContext = None 

139 

140 

141@attr.s(auto_attribs=True, frozen=True, slots=True) 

142class ClientTimeout: 

143 total: Optional[float] = None 

144 connect: Optional[float] = None 

145 sock_read: Optional[float] = None 

146 sock_connect: Optional[float] = None 

147 ceil_threshold: float = 5 

148 

149 # pool_queue_timeout: Optional[float] = None 

150 # dns_resolution_timeout: Optional[float] = None 

151 # socket_connect_timeout: Optional[float] = None 

152 # connection_acquiring_timeout: Optional[float] = None 

153 # new_connection_timeout: Optional[float] = None 

154 # http_header_timeout: Optional[float] = None 

155 # response_body_timeout: Optional[float] = None 

156 

157 # to create a timeout specific for a single request, either 

158 # - create a completely new one to overwrite the default 

159 # - or use http://www.attrs.org/en/stable/api.html#attr.evolve 

160 # to overwrite the defaults 

161 

162 

163# 5 Minute default read timeout 

164DEFAULT_TIMEOUT: Final[ClientTimeout] = ClientTimeout(total=5 * 60) 

165 

166_RetType = TypeVar("_RetType") 

167_CharsetResolver = Callable[[ClientResponse, bytes], str] 

168 

169 

170class ClientSession: 

171 """First-class interface for making HTTP requests.""" 

172 

173 ATTRS = frozenset( 

174 [ 

175 "_base_url", 

176 "_source_traceback", 

177 "_connector", 

178 "requote_redirect_url", 

179 "_loop", 

180 "_cookie_jar", 

181 "_connector_owner", 

182 "_default_auth", 

183 "_version", 

184 "_json_serialize", 

185 "_requote_redirect_url", 

186 "_timeout", 

187 "_raise_for_status", 

188 "_auto_decompress", 

189 "_trust_env", 

190 "_default_headers", 

191 "_skip_auto_headers", 

192 "_request_class", 

193 "_response_class", 

194 "_ws_response_class", 

195 "_trace_configs", 

196 "_read_bufsize", 

197 "_max_line_size", 

198 "_max_field_size", 

199 "_resolve_charset", 

200 ] 

201 ) 

202 

203 _source_traceback: Optional[traceback.StackSummary] = None 

204 _connector: Optional[BaseConnector] = None 

205 

206 def __init__( 

207 self, 

208 base_url: Optional[StrOrURL] = None, 

209 *, 

210 connector: Optional[BaseConnector] = None, 

211 loop: Optional[asyncio.AbstractEventLoop] = None, 

212 cookies: Optional[LooseCookies] = None, 

213 headers: Optional[LooseHeaders] = None, 

214 skip_auto_headers: Optional[Iterable[str]] = None, 

215 auth: Optional[BasicAuth] = None, 

216 json_serialize: JSONEncoder = json.dumps, 

217 request_class: Type[ClientRequest] = ClientRequest, 

218 response_class: Type[ClientResponse] = ClientResponse, 

219 ws_response_class: Type[ClientWebSocketResponse] = ClientWebSocketResponse, 

220 version: HttpVersion = http.HttpVersion11, 

221 cookie_jar: Optional[AbstractCookieJar] = None, 

222 connector_owner: bool = True, 

223 raise_for_status: Union[ 

224 bool, Callable[[ClientResponse], Awaitable[None]] 

225 ] = False, 

226 read_timeout: Union[float, _SENTINEL] = sentinel, 

227 conn_timeout: Optional[float] = None, 

228 timeout: Union[object, ClientTimeout] = sentinel, 

229 auto_decompress: bool = True, 

230 trust_env: bool = False, 

231 requote_redirect_url: bool = True, 

232 trace_configs: Optional[List[TraceConfig]] = None, 

233 read_bufsize: int = 2**16, 

234 max_line_size: int = 8190, 

235 max_field_size: int = 8190, 

236 fallback_charset_resolver: _CharsetResolver = lambda r, b: "utf-8", 

237 ) -> None: 

238 if loop is None: 

239 if connector is not None: 

240 loop = connector._loop 

241 

242 loop = get_running_loop(loop) 

243 

244 if base_url is None or isinstance(base_url, URL): 

245 self._base_url: Optional[URL] = base_url 

246 else: 

247 self._base_url = URL(base_url) 

248 assert ( 

249 self._base_url.origin() == self._base_url 

250 ), "Only absolute URLs without path part are supported" 

251 

252 if connector is None: 

253 connector = TCPConnector(loop=loop) 

254 

255 if connector._loop is not loop: 

256 raise RuntimeError("Session and connector has to use same event loop") 

257 

258 self._loop = loop 

259 

260 if loop.get_debug(): 

261 self._source_traceback = traceback.extract_stack(sys._getframe(1)) 

262 

263 if cookie_jar is None: 

264 cookie_jar = CookieJar(loop=loop) 

265 self._cookie_jar = cookie_jar 

266 

267 if cookies is not None: 

268 self._cookie_jar.update_cookies(cookies) 

269 

270 self._connector = connector 

271 self._connector_owner = connector_owner 

272 self._default_auth = auth 

273 self._version = version 

274 self._json_serialize = json_serialize 

275 if timeout is sentinel: 

276 self._timeout = DEFAULT_TIMEOUT 

277 if read_timeout is not sentinel: 

278 warnings.warn( 

279 "read_timeout is deprecated, " "use timeout argument instead", 

280 DeprecationWarning, 

281 stacklevel=2, 

282 ) 

283 self._timeout = attr.evolve(self._timeout, total=read_timeout) 

284 if conn_timeout is not None: 

285 self._timeout = attr.evolve(self._timeout, connect=conn_timeout) 

286 warnings.warn( 

287 "conn_timeout is deprecated, " "use timeout argument instead", 

288 DeprecationWarning, 

289 stacklevel=2, 

290 ) 

291 else: 

292 self._timeout = timeout # type: ignore[assignment] 

293 if read_timeout is not sentinel: 

294 raise ValueError( 

295 "read_timeout and timeout parameters " 

296 "conflict, please setup " 

297 "timeout.read" 

298 ) 

299 if conn_timeout is not None: 

300 raise ValueError( 

301 "conn_timeout and timeout parameters " 

302 "conflict, please setup " 

303 "timeout.connect" 

304 ) 

305 self._raise_for_status = raise_for_status 

306 self._auto_decompress = auto_decompress 

307 self._trust_env = trust_env 

308 self._requote_redirect_url = requote_redirect_url 

309 self._read_bufsize = read_bufsize 

310 self._max_line_size = max_line_size 

311 self._max_field_size = max_field_size 

312 

313 # Convert to list of tuples 

314 if headers: 

315 real_headers: CIMultiDict[str] = CIMultiDict(headers) 

316 else: 

317 real_headers = CIMultiDict() 

318 self._default_headers: CIMultiDict[str] = real_headers 

319 if skip_auto_headers is not None: 

320 self._skip_auto_headers = frozenset(istr(i) for i in skip_auto_headers) 

321 else: 

322 self._skip_auto_headers = frozenset() 

323 

324 self._request_class = request_class 

325 self._response_class = response_class 

326 self._ws_response_class = ws_response_class 

327 

328 self._trace_configs = trace_configs or [] 

329 for trace_config in self._trace_configs: 

330 trace_config.freeze() 

331 

332 self._resolve_charset = fallback_charset_resolver 

333 

334 def __init_subclass__(cls: Type["ClientSession"]) -> None: 

335 warnings.warn( 

336 "Inheritance class {} from ClientSession " 

337 "is discouraged".format(cls.__name__), 

338 DeprecationWarning, 

339 stacklevel=2, 

340 ) 

341 

342 if DEBUG: 

343 

344 def __setattr__(self, name: str, val: Any) -> None: 

345 if name not in self.ATTRS: 

346 warnings.warn( 

347 "Setting custom ClientSession.{} attribute " 

348 "is discouraged".format(name), 

349 DeprecationWarning, 

350 stacklevel=2, 

351 ) 

352 super().__setattr__(name, val) 

353 

354 def __del__(self, _warnings: Any = warnings) -> None: 

355 if not self.closed: 

356 kwargs = {"source": self} 

357 _warnings.warn( 

358 f"Unclosed client session {self!r}", ResourceWarning, **kwargs 

359 ) 

360 context = {"client_session": self, "message": "Unclosed client session"} 

361 if self._source_traceback is not None: 

362 context["source_traceback"] = self._source_traceback 

363 self._loop.call_exception_handler(context) 

364 

365 def request( 

366 self, method: str, url: StrOrURL, **kwargs: Any 

367 ) -> "_RequestContextManager": 

368 """Perform HTTP request.""" 

369 return _RequestContextManager(self._request(method, url, **kwargs)) 

370 

371 def _build_url(self, str_or_url: StrOrURL) -> URL: 

372 url = URL(str_or_url) 

373 if self._base_url is None: 

374 return url 

375 else: 

376 assert not url.is_absolute() and url.path.startswith("/") 

377 return self._base_url.join(url) 

378 

379 async def _request( 

380 self, 

381 method: str, 

382 str_or_url: StrOrURL, 

383 *, 

384 params: Optional[Mapping[str, str]] = None, 

385 data: Any = None, 

386 json: Any = None, 

387 cookies: Optional[LooseCookies] = None, 

388 headers: Optional[LooseHeaders] = None, 

389 skip_auto_headers: Optional[Iterable[str]] = None, 

390 auth: Optional[BasicAuth] = None, 

391 allow_redirects: bool = True, 

392 max_redirects: int = 10, 

393 compress: Optional[str] = None, 

394 chunked: Optional[bool] = None, 

395 expect100: bool = False, 

396 raise_for_status: Union[ 

397 None, bool, Callable[[ClientResponse], Awaitable[None]] 

398 ] = None, 

399 read_until_eof: bool = True, 

400 proxy: Optional[StrOrURL] = None, 

401 proxy_auth: Optional[BasicAuth] = None, 

402 timeout: Union[ClientTimeout, _SENTINEL] = sentinel, 

403 verify_ssl: Optional[bool] = None, 

404 fingerprint: Optional[bytes] = None, 

405 ssl_context: Optional[SSLContext] = None, 

406 ssl: Optional[Union[SSLContext, Literal[False], Fingerprint]] = None, 

407 server_hostname: Optional[str] = None, 

408 proxy_headers: Optional[LooseHeaders] = None, 

409 trace_request_ctx: Optional[SimpleNamespace] = None, 

410 read_bufsize: Optional[int] = None, 

411 auto_decompress: Optional[bool] = None, 

412 max_line_size: Optional[int] = None, 

413 max_field_size: Optional[int] = None, 

414 ) -> ClientResponse: 

415 

416 # NOTE: timeout clamps existing connect and read timeouts. We cannot 

417 # set the default to None because we need to detect if the user wants 

418 # to use the existing timeouts by setting timeout to None. 

419 

420 if self.closed: 

421 raise RuntimeError("Session is closed") 

422 

423 ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint) 

424 

425 if data is not None and json is not None: 

426 raise ValueError( 

427 "data and json parameters can not be used at the same time" 

428 ) 

429 elif json is not None: 

430 data = payload.JsonPayload(json, dumps=self._json_serialize) 

431 

432 if not isinstance(chunked, bool) and chunked is not None: 

433 warnings.warn("Chunk size is deprecated #1615", DeprecationWarning) 

434 

435 redirects = 0 

436 history = [] 

437 version = self._version 

438 params = params or {} 

439 

440 # Merge with default headers and transform to CIMultiDict 

441 headers = self._prepare_headers(headers) 

442 proxy_headers = self._prepare_headers(proxy_headers) 

443 

444 try: 

445 url = self._build_url(str_or_url) 

446 except ValueError as e: 

447 raise InvalidURL(str_or_url) from e 

448 

449 skip_headers = set(self._skip_auto_headers) 

450 if skip_auto_headers is not None: 

451 for i in skip_auto_headers: 

452 skip_headers.add(istr(i)) 

453 

454 if proxy is not None: 

455 try: 

456 proxy = URL(proxy) 

457 except ValueError as e: 

458 raise InvalidURL(proxy) from e 

459 

460 if timeout is sentinel: 

461 real_timeout: ClientTimeout = self._timeout 

462 else: 

463 if not isinstance(timeout, ClientTimeout): 

464 real_timeout = ClientTimeout(total=timeout) 

465 else: 

466 real_timeout = timeout 

467 # timeout is cumulative for all request operations 

468 # (request, redirects, responses, data consuming) 

469 tm = TimeoutHandle( 

470 self._loop, real_timeout.total, ceil_threshold=real_timeout.ceil_threshold 

471 ) 

472 handle = tm.start() 

473 

474 if read_bufsize is None: 

475 read_bufsize = self._read_bufsize 

476 

477 if auto_decompress is None: 

478 auto_decompress = self._auto_decompress 

479 

480 if max_line_size is None: 

481 max_line_size = self._max_line_size 

482 

483 if max_field_size is None: 

484 max_field_size = self._max_field_size 

485 

486 traces = [ 

487 Trace( 

488 self, 

489 trace_config, 

490 trace_config.trace_config_ctx(trace_request_ctx=trace_request_ctx), 

491 ) 

492 for trace_config in self._trace_configs 

493 ] 

494 

495 for trace in traces: 

496 await trace.send_request_start(method, url.update_query(params), headers) 

497 

498 timer = tm.timer() 

499 try: 

500 with timer: 

501 while True: 

502 url, auth_from_url = strip_auth_from_url(url) 

503 if auth and auth_from_url: 

504 raise ValueError( 

505 "Cannot combine AUTH argument with " 

506 "credentials encoded in URL" 

507 ) 

508 

509 if auth is None: 

510 auth = auth_from_url 

511 if auth is None: 

512 auth = self._default_auth 

513 # It would be confusing if we support explicit 

514 # Authorization header with auth argument 

515 if ( 

516 headers is not None 

517 and auth is not None 

518 and hdrs.AUTHORIZATION in headers 

519 ): 

520 raise ValueError( 

521 "Cannot combine AUTHORIZATION header " 

522 "with AUTH argument or credentials " 

523 "encoded in URL" 

524 ) 

525 

526 all_cookies = self._cookie_jar.filter_cookies(url) 

527 

528 if cookies is not None: 

529 tmp_cookie_jar = CookieJar() 

530 tmp_cookie_jar.update_cookies(cookies) 

531 req_cookies = tmp_cookie_jar.filter_cookies(url) 

532 if req_cookies: 

533 all_cookies.load(req_cookies) 

534 

535 if proxy is not None: 

536 proxy = URL(proxy) 

537 elif self._trust_env: 

538 with suppress(LookupError): 

539 proxy, proxy_auth = get_env_proxy_for_url(url) 

540 

541 req = self._request_class( 

542 method, 

543 url, 

544 params=params, 

545 headers=headers, 

546 skip_auto_headers=skip_headers, 

547 data=data, 

548 cookies=all_cookies, 

549 auth=auth, 

550 version=version, 

551 compress=compress, 

552 chunked=chunked, 

553 expect100=expect100, 

554 loop=self._loop, 

555 response_class=self._response_class, 

556 proxy=proxy, 

557 proxy_auth=proxy_auth, 

558 timer=timer, 

559 session=self, 

560 ssl=ssl, 

561 server_hostname=server_hostname, 

562 proxy_headers=proxy_headers, 

563 traces=traces, 

564 trust_env=self.trust_env, 

565 ) 

566 

567 # connection timeout 

568 try: 

569 async with ceil_timeout( 

570 real_timeout.connect, 

571 ceil_threshold=real_timeout.ceil_threshold, 

572 ): 

573 assert self._connector is not None 

574 conn = await self._connector.connect( 

575 req, traces=traces, timeout=real_timeout 

576 ) 

577 except asyncio.TimeoutError as exc: 

578 raise ServerTimeoutError( 

579 "Connection timeout " "to host {}".format(url) 

580 ) from exc 

581 

582 assert conn.transport is not None 

583 

584 assert conn.protocol is not None 

585 conn.protocol.set_response_params( 

586 timer=timer, 

587 skip_payload=method_must_be_empty_body(method), 

588 read_until_eof=read_until_eof, 

589 auto_decompress=auto_decompress, 

590 read_timeout=real_timeout.sock_read, 

591 read_bufsize=read_bufsize, 

592 timeout_ceil_threshold=self._connector._timeout_ceil_threshold, 

593 max_line_size=max_line_size, 

594 max_field_size=max_field_size, 

595 ) 

596 

597 try: 

598 try: 

599 resp = await req.send(conn) 

600 try: 

601 await resp.start(conn) 

602 except BaseException: 

603 resp.close() 

604 raise 

605 except BaseException: 

606 conn.close() 

607 raise 

608 except ClientError: 

609 raise 

610 except OSError as exc: 

611 if exc.errno is None and isinstance(exc, asyncio.TimeoutError): 

612 raise 

613 raise ClientOSError(*exc.args) from exc 

614 

615 self._cookie_jar.update_cookies(resp.cookies, resp.url) 

616 

617 # redirects 

618 if resp.status in (301, 302, 303, 307, 308) and allow_redirects: 

619 

620 for trace in traces: 

621 await trace.send_request_redirect( 

622 method, url.update_query(params), headers, resp 

623 ) 

624 

625 redirects += 1 

626 history.append(resp) 

627 if max_redirects and redirects >= max_redirects: 

628 resp.close() 

629 raise TooManyRedirects( 

630 history[0].request_info, tuple(history) 

631 ) 

632 

633 # For 301 and 302, mimic IE, now changed in RFC 

634 # https://github.com/kennethreitz/requests/pull/269 

635 if (resp.status == 303 and resp.method != hdrs.METH_HEAD) or ( 

636 resp.status in (301, 302) and resp.method == hdrs.METH_POST 

637 ): 

638 method = hdrs.METH_GET 

639 data = None 

640 if headers.get(hdrs.CONTENT_LENGTH): 

641 headers.pop(hdrs.CONTENT_LENGTH) 

642 

643 r_url = resp.headers.get(hdrs.LOCATION) or resp.headers.get( 

644 hdrs.URI 

645 ) 

646 if r_url is None: 

647 # see github.com/aio-libs/aiohttp/issues/2022 

648 break 

649 else: 

650 # reading from correct redirection 

651 # response is forbidden 

652 resp.release() 

653 

654 try: 

655 parsed_url = URL( 

656 r_url, encoded=not self._requote_redirect_url 

657 ) 

658 

659 except ValueError as e: 

660 raise InvalidURL(r_url) from e 

661 

662 scheme = parsed_url.scheme 

663 if scheme not in ("http", "https", ""): 

664 resp.close() 

665 raise ValueError("Can redirect only to http or https") 

666 elif not scheme: 

667 parsed_url = url.join(parsed_url) 

668 

669 if url.origin() != parsed_url.origin(): 

670 auth = None 

671 headers.pop(hdrs.AUTHORIZATION, None) 

672 

673 url = parsed_url 

674 params = {} 

675 resp.release() 

676 continue 

677 

678 break 

679 

680 # check response status 

681 if raise_for_status is None: 

682 raise_for_status = self._raise_for_status 

683 

684 if raise_for_status is None: 

685 pass 

686 elif callable(raise_for_status): 

687 await raise_for_status(resp) 

688 elif raise_for_status: 

689 resp.raise_for_status() 

690 

691 # register connection 

692 if handle is not None: 

693 if resp.connection is not None: 

694 resp.connection.add_callback(handle.cancel) 

695 else: 

696 handle.cancel() 

697 

698 resp._history = tuple(history) 

699 

700 for trace in traces: 

701 await trace.send_request_end( 

702 method, url.update_query(params), headers, resp 

703 ) 

704 return resp 

705 

706 except BaseException as e: 

707 # cleanup timer 

708 tm.close() 

709 if handle: 

710 handle.cancel() 

711 handle = None 

712 

713 for trace in traces: 

714 await trace.send_request_exception( 

715 method, url.update_query(params), headers, e 

716 ) 

717 raise 

718 

719 def ws_connect( 

720 self, 

721 url: StrOrURL, 

722 *, 

723 method: str = hdrs.METH_GET, 

724 protocols: Iterable[str] = (), 

725 timeout: float = 10.0, 

726 receive_timeout: Optional[float] = None, 

727 autoclose: bool = True, 

728 autoping: bool = True, 

729 heartbeat: Optional[float] = None, 

730 auth: Optional[BasicAuth] = None, 

731 origin: Optional[str] = None, 

732 params: Optional[Mapping[str, str]] = None, 

733 headers: Optional[LooseHeaders] = None, 

734 proxy: Optional[StrOrURL] = None, 

735 proxy_auth: Optional[BasicAuth] = None, 

736 ssl: Union[SSLContext, Literal[False], None, Fingerprint] = None, 

737 verify_ssl: Optional[bool] = None, 

738 fingerprint: Optional[bytes] = None, 

739 ssl_context: Optional[SSLContext] = None, 

740 proxy_headers: Optional[LooseHeaders] = None, 

741 compress: int = 0, 

742 max_msg_size: int = 4 * 1024 * 1024, 

743 ) -> "_WSRequestContextManager": 

744 """Initiate websocket connection.""" 

745 return _WSRequestContextManager( 

746 self._ws_connect( 

747 url, 

748 method=method, 

749 protocols=protocols, 

750 timeout=timeout, 

751 receive_timeout=receive_timeout, 

752 autoclose=autoclose, 

753 autoping=autoping, 

754 heartbeat=heartbeat, 

755 auth=auth, 

756 origin=origin, 

757 params=params, 

758 headers=headers, 

759 proxy=proxy, 

760 proxy_auth=proxy_auth, 

761 ssl=ssl, 

762 verify_ssl=verify_ssl, 

763 fingerprint=fingerprint, 

764 ssl_context=ssl_context, 

765 proxy_headers=proxy_headers, 

766 compress=compress, 

767 max_msg_size=max_msg_size, 

768 ) 

769 ) 

770 

771 async def _ws_connect( 

772 self, 

773 url: StrOrURL, 

774 *, 

775 method: str = hdrs.METH_GET, 

776 protocols: Iterable[str] = (), 

777 timeout: float = 10.0, 

778 receive_timeout: Optional[float] = None, 

779 autoclose: bool = True, 

780 autoping: bool = True, 

781 heartbeat: Optional[float] = None, 

782 auth: Optional[BasicAuth] = None, 

783 origin: Optional[str] = None, 

784 params: Optional[Mapping[str, str]] = None, 

785 headers: Optional[LooseHeaders] = None, 

786 proxy: Optional[StrOrURL] = None, 

787 proxy_auth: Optional[BasicAuth] = None, 

788 ssl: Union[SSLContext, Literal[False], None, Fingerprint] = None, 

789 verify_ssl: Optional[bool] = None, 

790 fingerprint: Optional[bytes] = None, 

791 ssl_context: Optional[SSLContext] = None, 

792 proxy_headers: Optional[LooseHeaders] = None, 

793 compress: int = 0, 

794 max_msg_size: int = 4 * 1024 * 1024, 

795 ) -> ClientWebSocketResponse: 

796 

797 if headers is None: 

798 real_headers: CIMultiDict[str] = CIMultiDict() 

799 else: 

800 real_headers = CIMultiDict(headers) 

801 

802 default_headers = { 

803 hdrs.UPGRADE: "websocket", 

804 hdrs.CONNECTION: "Upgrade", 

805 hdrs.SEC_WEBSOCKET_VERSION: "13", 

806 } 

807 

808 for key, value in default_headers.items(): 

809 real_headers.setdefault(key, value) 

810 

811 sec_key = base64.b64encode(os.urandom(16)) 

812 real_headers[hdrs.SEC_WEBSOCKET_KEY] = sec_key.decode() 

813 

814 if protocols: 

815 real_headers[hdrs.SEC_WEBSOCKET_PROTOCOL] = ",".join(protocols) 

816 if origin is not None: 

817 real_headers[hdrs.ORIGIN] = origin 

818 if compress: 

819 extstr = ws_ext_gen(compress=compress) 

820 real_headers[hdrs.SEC_WEBSOCKET_EXTENSIONS] = extstr 

821 

822 ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint) 

823 

824 # send request 

825 resp = await self.request( 

826 method, 

827 url, 

828 params=params, 

829 headers=real_headers, 

830 read_until_eof=False, 

831 auth=auth, 

832 proxy=proxy, 

833 proxy_auth=proxy_auth, 

834 ssl=ssl, 

835 proxy_headers=proxy_headers, 

836 ) 

837 

838 try: 

839 # check handshake 

840 if resp.status != 101: 

841 raise WSServerHandshakeError( 

842 resp.request_info, 

843 resp.history, 

844 message="Invalid response status", 

845 status=resp.status, 

846 headers=resp.headers,