pure-patchright 1.62.3__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (142) hide show
  1. patchright/__init__.py +5 -0
  2. patchright/__main__.py +18 -0
  3. patchright/_impl/__init__.py +0 -0
  4. patchright/_impl/__pyinstaller/__init__.py +20 -0
  5. patchright/_impl/__pyinstaller/hook-playwright.async_api.py +3 -0
  6. patchright/_impl/__pyinstaller/hook-playwright.sync_api.py +3 -0
  7. patchright/_impl/_api_structures.py +343 -0
  8. patchright/_impl/_artifact.py +46 -0
  9. patchright/_impl/_assertions.py +1014 -0
  10. patchright/_impl/_async_base.py +88 -0
  11. patchright/_impl/_browser.py +267 -0
  12. patchright/_impl/_browser_context.py +759 -0
  13. patchright/_impl/_browser_type.py +336 -0
  14. patchright/_impl/_cdp_session.py +25 -0
  15. patchright/_impl/_clock.py +62 -0
  16. patchright/_impl/_connection.py +686 -0
  17. patchright/_impl/_console_message.py +83 -0
  18. patchright/_impl/_credentials.py +38 -0
  19. patchright/_impl/_debugger.py +37 -0
  20. patchright/_impl/_dialog.py +45 -0
  21. patchright/_impl/_disposable.py +71 -0
  22. patchright/_impl/_download.py +49 -0
  23. patchright/_impl/_driver.py +24 -0
  24. patchright/_impl/_element_handle.py +446 -0
  25. patchright/_impl/_errors.py +46 -0
  26. patchright/_impl/_event_context_manager.py +19 -0
  27. patchright/_impl/_fetch.py +592 -0
  28. patchright/_impl/_file_chooser.py +42 -0
  29. patchright/_impl/_form_data.py +19 -0
  30. patchright/_impl/_frame.py +959 -0
  31. patchright/_impl/_glob.py +47 -0
  32. patchright/_impl/_greenlets.py +35 -0
  33. patchright/_impl/_har_router.py +98 -0
  34. patchright/_impl/_helper.py +551 -0
  35. patchright/_impl/_impl_to_api_mapping.py +141 -0
  36. patchright/_impl/_input.py +85 -0
  37. patchright/_impl/_js_handle.py +297 -0
  38. patchright/_impl/_json_pipe.py +55 -0
  39. patchright/_impl/_local_utils.py +73 -0
  40. patchright/_impl/_locator.py +894 -0
  41. patchright/_impl/_map.py +18 -0
  42. patchright/_impl/_network.py +953 -0
  43. patchright/_impl/_object_factory.py +93 -0
  44. patchright/_impl/_page.py +1601 -0
  45. patchright/_impl/_path_utils.py +13 -0
  46. patchright/_impl/_playwright.py +43 -0
  47. patchright/_impl/_screencast.py +149 -0
  48. patchright/_impl/_selectors.py +48 -0
  49. patchright/_impl/_set_input_files_helpers.py +134 -0
  50. patchright/_impl/_str_utils.py +59 -0
  51. patchright/_impl/_stream.py +31 -0
  52. patchright/_impl/_sync_base.py +130 -0
  53. patchright/_impl/_tracing.py +243 -0
  54. patchright/_impl/_transport.py +151 -0
  55. patchright/_impl/_video.py +41 -0
  56. patchright/_impl/_waiter.py +168 -0
  57. patchright/_impl/_web_error.py +33 -0
  58. patchright/_impl/_web_storage.py +41 -0
  59. patchright/_impl/_writable_stream.py +26 -0
  60. patchright/_repo_version.py +1 -0
  61. patchright/async_api/__init__.py +234 -0
  62. patchright/async_api/_context_manager.py +38 -0
  63. patchright/async_api/_generated.py +23396 -0
  64. patchright/driver/README.md +1 -0
  65. patchright/driver/package/README.md +3 -0
  66. patchright/driver/package/ThirdPartyNotices.txt +13 -0
  67. patchright/driver/package/bin/install_media_pack.ps1 +5 -0
  68. patchright/driver/package/bin/install_webkit_wsl.ps1 +33 -0
  69. patchright/driver/package/bin/reinstall_chrome_beta_linux.sh +42 -0
  70. patchright/driver/package/bin/reinstall_chrome_beta_mac.sh +13 -0
  71. patchright/driver/package/bin/reinstall_chrome_beta_win.ps1 +24 -0
  72. patchright/driver/package/bin/reinstall_chrome_stable_linux.sh +42 -0
  73. patchright/driver/package/bin/reinstall_chrome_stable_mac.sh +12 -0
  74. patchright/driver/package/bin/reinstall_chrome_stable_win.ps1 +24 -0
  75. patchright/driver/package/bin/reinstall_msedge_beta_linux.sh +48 -0
  76. patchright/driver/package/bin/reinstall_msedge_beta_mac.sh +11 -0
  77. patchright/driver/package/bin/reinstall_msedge_beta_win.ps1 +23 -0
  78. patchright/driver/package/bin/reinstall_msedge_dev_linux.sh +48 -0
  79. patchright/driver/package/bin/reinstall_msedge_dev_mac.sh +11 -0
  80. patchright/driver/package/bin/reinstall_msedge_dev_win.ps1 +23 -0
  81. patchright/driver/package/bin/reinstall_msedge_stable_linux.sh +48 -0
  82. patchright/driver/package/bin/reinstall_msedge_stable_mac.sh +11 -0
  83. patchright/driver/package/bin/reinstall_msedge_stable_win.ps1 +24 -0
  84. patchright/driver/package/browsers.json +75 -0
  85. patchright/driver/package/cli.js +21 -0
  86. patchright/driver/package/index.js +17 -0
  87. patchright/driver/package/index.mjs +28 -0
  88. patchright/driver/package/lib/bootstrap.js +88 -0
  89. patchright/driver/package/lib/coreBundle.js +77498 -0
  90. patchright/driver/package/lib/entry/cliDaemon.js +5 -0
  91. patchright/driver/package/lib/entry/dashboardApp.js +3 -0
  92. patchright/driver/package/lib/entry/mcp.js +10 -0
  93. patchright/driver/package/lib/entry/oopBrowserDownload.js +3 -0
  94. patchright/driver/package/lib/package.js +50 -0
  95. patchright/driver/package/lib/server/chromium/appIcon.png +0 -0
  96. patchright/driver/package/lib/server/electron/loader.js +107 -0
  97. patchright/driver/package/lib/serverRegistry.js +7347 -0
  98. patchright/driver/package/lib/serverRegistry.js.LICENSE +354 -0
  99. patchright/driver/package/lib/tools/cli-client/channelSessions.js +141 -0
  100. patchright/driver/package/lib/tools/cli-client/cli.js +6 -0
  101. patchright/driver/package/lib/tools/cli-client/help.json +708 -0
  102. patchright/driver/package/lib/tools/cli-client/minimist.js +128 -0
  103. patchright/driver/package/lib/tools/cli-client/output.js +343 -0
  104. patchright/driver/package/lib/tools/cli-client/program.js +404 -0
  105. patchright/driver/package/lib/tools/cli-client/registry.js +176 -0
  106. patchright/driver/package/lib/tools/cli-client/session.js +258 -0
  107. patchright/driver/package/lib/tools/dashboard/appIcon.png +0 -0
  108. patchright/driver/package/lib/tools/skills/playwright-cli/SKILL.md +420 -0
  109. patchright/driver/package/lib/tools/skills/playwright-cli/references/element-attributes.md +23 -0
  110. patchright/driver/package/lib/tools/skills/playwright-cli/references/playwright-tests.md +39 -0
  111. patchright/driver/package/lib/tools/skills/playwright-cli/references/request-mocking.md +87 -0
  112. patchright/driver/package/lib/tools/skills/playwright-cli/references/running-code.md +241 -0
  113. patchright/driver/package/lib/tools/skills/playwright-cli/references/session-management.md +225 -0
  114. patchright/driver/package/lib/tools/skills/playwright-cli/references/storage-state.md +275 -0
  115. patchright/driver/package/lib/tools/skills/playwright-cli/references/test-generation.md +433 -0
  116. patchright/driver/package/lib/tools/skills/playwright-cli/references/tracing.md +139 -0
  117. patchright/driver/package/lib/tools/skills/playwright-cli/references/video-recording.md +143 -0
  118. patchright/driver/package/lib/tools/skills/playwright-component-testing/SKILL.md +143 -0
  119. patchright/driver/package/lib/tools/skills/playwright-component-testing/references/gallery-spec.md +144 -0
  120. patchright/driver/package/lib/tools/skills/playwright-component-testing/references/migration.md +85 -0
  121. patchright/driver/package/lib/tools/skills/playwright-component-testing/references/react.md +67 -0
  122. patchright/driver/package/lib/tools/skills/playwright-component-testing/references/vue.md +75 -0
  123. patchright/driver/package/lib/tools/skills/playwright-trace/SKILL.md +171 -0
  124. patchright/driver/package/lib/tools/utils/extension.js +101 -0
  125. patchright/driver/package/lib/tools/utils/socketConnection.js +108 -0
  126. patchright/driver/package/lib/utilsBundle.js +90764 -0
  127. patchright/driver/package/lib/utilsBundle.js.LICENSE +2179 -0
  128. patchright/driver/package/lib/webp_codec.LICENSE +173 -0
  129. patchright/driver/package/lib/webp_codec.wasm +0 -0
  130. patchright/driver/package/lib/xdg-open +1267 -0
  131. patchright/driver/package/package.json +34 -0
  132. patchright/py.typed +0 -0
  133. patchright/sync_api/__init__.py +234 -0
  134. patchright/sync_api/_context_manager.py +73 -0
  135. patchright/sync_api/_generated.py +23590 -0
  136. pure_patchright-1.62.3.dist-info/LICENSE +201 -0
  137. pure_patchright-1.62.3.dist-info/METADATA +96 -0
  138. pure_patchright-1.62.3.dist-info/RECORD +142 -0
  139. pure_patchright-1.62.3.dist-info/WHEEL +4 -0
  140. pure_patchright-1.62.3.dist-info/entry_points.txt +5 -0
  141. pure_patchright-1.62.3.dist-info/licenses/LICENSE +202 -0
  142. pure_patchright-1.62.3.dist-info/top_level.txt +1 -0
@@ -0,0 +1,953 @@
1
+ import asyncio
2
+ import base64
3
+ import json
4
+ import json as json_utils
5
+ import mimetypes
6
+ import re
7
+ from collections import defaultdict
8
+ from pathlib import Path
9
+ from types import SimpleNamespace
10
+ from typing import (
11
+ TYPE_CHECKING,
12
+ Any,
13
+ Callable,
14
+ Coroutine,
15
+ Dict,
16
+ List,
17
+ Optional,
18
+ TypedDict,
19
+ Union,
20
+ cast,
21
+ )
22
+ from urllib import parse
23
+ from patchright._impl._api_structures import (
24
+ ClientCertificate,
25
+ Headers,
26
+ HeadersArray,
27
+ RemoteAddr,
28
+ RequestSizes,
29
+ ResourceTiming,
30
+ SecurityDetails,
31
+ )
32
+ from patchright._impl._connection import (
33
+ ChannelOwner,
34
+ _capture_stack_trace,
35
+ from_channel,
36
+ from_nullable_channel,
37
+ )
38
+ from patchright._impl._errors import Error, TargetClosedError
39
+ from patchright._impl._event_context_manager import EventContextManagerImpl
40
+ from patchright._impl._helper import (
41
+ URLMatch,
42
+ WebSocketRouteHandlerCallback,
43
+ async_readfile,
44
+ locals_to_params,
45
+ url_matches,
46
+ )
47
+ from patchright._impl._str_utils import escape_regex_flags
48
+ from patchright._impl._waiter import Waiter
49
+
50
+ if TYPE_CHECKING:
51
+ from patchright._impl._browser_context import BrowserContext
52
+ from patchright._impl._fetch import APIResponse
53
+ from patchright._impl._frame import Frame
54
+ from patchright._impl._page import Page, Worker
55
+
56
+
57
+ class FallbackOverrideParameters(TypedDict, total=False):
58
+ url: Optional[str]
59
+ method: Optional[str]
60
+ headers: Optional[Dict[str, str]]
61
+ postData: Optional[Union[str, bytes]]
62
+ patchrightInitScript: Optional[bool]
63
+
64
+
65
+ class SerializedFallbackOverrides:
66
+ def __init__(self) -> None:
67
+ self.url: Optional[str] = None
68
+ self.method: Optional[str] = None
69
+ self.headers: Optional[Dict[str, str]] = None
70
+ self.post_data_buffer: Optional[bytes] = None
71
+ self.patchright_init_script: bool = False
72
+
73
+
74
+ def serialize_headers(headers: Dict[str, str]) -> HeadersArray:
75
+ return [
76
+ {"name": name, "value": value}
77
+ for name, value in headers.items()
78
+ if value is not None
79
+ ]
80
+
81
+
82
+ async def to_client_certificates_protocol(
83
+ clientCertificates: Optional[List[ClientCertificate]],
84
+ ) -> Optional[List[Dict[str, str]]]:
85
+ if not clientCertificates:
86
+ return None
87
+ out = []
88
+ for clientCertificate in clientCertificates:
89
+ out_record = {"origin": clientCertificate["origin"]}
90
+ if passphrase := clientCertificate.get("passphrase"):
91
+ out_record["passphrase"] = passphrase
92
+ if pfx := clientCertificate.get("pfx"):
93
+ out_record["pfx"] = base64.b64encode(pfx).decode()
94
+ if pfx_path := clientCertificate.get("pfxPath"):
95
+ out_record["pfx"] = base64.b64encode(
96
+ await async_readfile(pfx_path)
97
+ ).decode()
98
+ if cert := clientCertificate.get("cert"):
99
+ out_record["cert"] = base64.b64encode(cert).decode()
100
+ if cert_path := clientCertificate.get("certPath"):
101
+ out_record["cert"] = base64.b64encode(
102
+ await async_readfile(cert_path)
103
+ ).decode()
104
+ if key := clientCertificate.get("key"):
105
+ out_record["key"] = base64.b64encode(key).decode()
106
+ if key_path := clientCertificate.get("keyPath"):
107
+ out_record["key"] = base64.b64encode(
108
+ await async_readfile(key_path)
109
+ ).decode()
110
+ out.append(out_record)
111
+ return out
112
+
113
+
114
+ class Request(ChannelOwner):
115
+ def __init__(
116
+ self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
117
+ ) -> None:
118
+ super().__init__(parent, type, guid, initializer)
119
+ self._redirected_from: Optional["Request"] = from_nullable_channel(
120
+ initializer.get("redirectedFrom")
121
+ )
122
+ self._redirected_to: Optional["Request"] = None
123
+ if self._redirected_from:
124
+ self._redirected_from._redirected_to = self
125
+ self._failure_text: Optional[str] = None
126
+ self._timing: ResourceTiming = {
127
+ "startTime": 0,
128
+ "domainLookupStart": -1,
129
+ "domainLookupEnd": -1,
130
+ "connectStart": -1,
131
+ "secureConnectionStart": -1,
132
+ "connectEnd": -1,
133
+ "requestStart": -1,
134
+ "responseStart": -1,
135
+ "responseEnd": -1,
136
+ }
137
+ self._provisional_headers = RawHeaders(self._initializer["headers"])
138
+ self._all_headers_future: Optional[asyncio.Future[RawHeaders]] = None
139
+ self._fallback_overrides: SerializedFallbackOverrides = (
140
+ SerializedFallbackOverrides()
141
+ )
142
+ self._response: Optional["Response"] = None
143
+
144
+ def __repr__(self) -> str:
145
+ return f"<Request url={self.url!r} method={self.method!r}>"
146
+
147
+ def _apply_fallback_overrides(self, overrides: FallbackOverrideParameters) -> None:
148
+ if overrides.get("url"):
149
+ self._fallback_overrides.url = overrides["url"]
150
+ if overrides.get("method"):
151
+ self._fallback_overrides.method = overrides["method"]
152
+ if overrides.get("headers"):
153
+ self._fallback_overrides.headers = overrides["headers"]
154
+ if overrides.get("patchrightInitScript"):
155
+ self._fallback_overrides.patchright_init_script = True
156
+ post_data = overrides.get("postData")
157
+ if isinstance(post_data, str):
158
+ self._fallback_overrides.post_data_buffer = post_data.encode()
159
+ elif isinstance(post_data, bytes):
160
+ self._fallback_overrides.post_data_buffer = post_data
161
+ elif post_data is not None:
162
+ self._fallback_overrides.post_data_buffer = json.dumps(post_data).encode()
163
+
164
+ @property
165
+ def url(self) -> str:
166
+ return cast(str, self._fallback_overrides.url or self._initializer["url"])
167
+
168
+ @property
169
+ def resource_type(self) -> str:
170
+ return self._initializer["resourceType"]
171
+
172
+ @property
173
+ def service_worker(self) -> Optional["Worker"]:
174
+ return cast(
175
+ Optional["Worker"],
176
+ from_nullable_channel(self._initializer.get("serviceWorker")),
177
+ )
178
+
179
+ @property
180
+ def method(self) -> str:
181
+ return cast(str, self._fallback_overrides.method or self._initializer["method"])
182
+
183
+ async def sizes(self) -> RequestSizes:
184
+ response = await self.response()
185
+ if not response:
186
+ raise Error("Unable to fetch sizes for failed request")
187
+ return await response._channel.send("sizes", None)
188
+
189
+ @property
190
+ def post_data(self) -> Optional[str]:
191
+ data = self._fallback_overrides.post_data_buffer
192
+ if data is not None:
193
+ return data.decode()
194
+ base64_post_data = self._initializer.get("postData")
195
+ if base64_post_data is not None:
196
+ return base64.b64decode(base64_post_data).decode()
197
+ return None
198
+
199
+ @property
200
+ def post_data_json(self) -> Optional[Any]:
201
+ post_data = self.post_data
202
+ if not post_data:
203
+ return None
204
+ content_type = self.headers.get("content-type")
205
+ if content_type and "application/x-www-form-urlencoded" in content_type:
206
+ return dict(parse.parse_qsl(post_data))
207
+ try:
208
+ return json.loads(post_data)
209
+ except Exception:
210
+ raise Error(f"POST data is not a valid JSON object: {post_data}")
211
+
212
+ @property
213
+ def post_data_buffer(self) -> Optional[bytes]:
214
+ if self._fallback_overrides.post_data_buffer:
215
+ return self._fallback_overrides.post_data_buffer
216
+ if self._initializer.get("postData"):
217
+ return base64.b64decode(self._initializer["postData"])
218
+ return None
219
+
220
+ async def response(self) -> Optional["Response"]:
221
+ return from_nullable_channel(await self._channel.send("response", None))
222
+
223
+ @property
224
+ def existing_response(self) -> Optional["Response"]:
225
+ return self._response
226
+
227
+ @property
228
+ def frame(self) -> "Frame":
229
+ if not self._initializer.get("frame"):
230
+ raise Error("Service Worker requests do not have an associated frame.")
231
+ frame = cast("Frame", from_channel(self._initializer["frame"]))
232
+ if not frame._page:
233
+ raise Error(
234
+ "\n".join(
235
+ [
236
+ "Frame for this navigation request is not available, because the request",
237
+ "was issued before the frame is created. You can check whether the request",
238
+ "is a navigation request by calling isNavigationRequest() method.",
239
+ ]
240
+ )
241
+ )
242
+ return frame
243
+
244
+ def is_navigation_request(self) -> bool:
245
+ return self._initializer["isNavigationRequest"]
246
+
247
+ @property
248
+ def redirected_from(self) -> Optional["Request"]:
249
+ return self._redirected_from
250
+
251
+ @property
252
+ def redirected_to(self) -> Optional["Request"]:
253
+ return self._redirected_to
254
+
255
+ @property
256
+ def failure(self) -> Optional[str]:
257
+ return self._failure_text
258
+
259
+ @property
260
+ def timing(self) -> ResourceTiming:
261
+ return self._timing
262
+
263
+ def _set_response_end_timing(self, response_end_timing: float) -> None:
264
+ self._timing["responseEnd"] = response_end_timing
265
+ if self._timing["responseStart"] == -1:
266
+ self._timing["responseStart"] = response_end_timing
267
+
268
+ @property
269
+ def headers(self) -> Headers:
270
+ override = self._fallback_overrides.headers
271
+ if override:
272
+ return RawHeaders._from_headers_dict_lossy(override).headers()
273
+ return self._provisional_headers.headers()
274
+
275
+ async def all_headers(self) -> Headers:
276
+ headers = await self._actual_headers()
277
+ page = self._safe_page()
278
+ if page and page._close_was_called:
279
+ raise TargetClosedError()
280
+ return headers.headers()
281
+
282
+ async def headers_array(self) -> HeadersArray:
283
+ return (await self._actual_headers()).headers_array()
284
+
285
+ async def header_value(self, name: str) -> Optional[str]:
286
+ return (await self._actual_headers()).get(name)
287
+
288
+ async def _actual_headers(self) -> "RawHeaders":
289
+ override = self._fallback_overrides.headers
290
+ if override:
291
+ return RawHeaders(serialize_headers(override))
292
+ if not self._all_headers_future:
293
+ self._all_headers_future = asyncio.Future()
294
+ headers = await self._channel.send(
295
+ "rawRequestHeaders", None, is_internal=True
296
+ )
297
+ self._all_headers_future.set_result(RawHeaders(headers))
298
+ return await self._all_headers_future
299
+
300
+ def _target_closed_future(self) -> asyncio.Future:
301
+ frame = cast(
302
+ Optional["Frame"], from_nullable_channel(self._initializer.get("frame"))
303
+ )
304
+ if not frame:
305
+ return asyncio.Future()
306
+ page = frame._page
307
+ if not page:
308
+ return asyncio.Future()
309
+ return page._closed_or_crashed_future
310
+
311
+ def _safe_page(self) -> "Optional[Page]":
312
+ frame = from_nullable_channel(self._initializer.get("frame"))
313
+ if not frame:
314
+ return None
315
+ return cast("Frame", frame)._page
316
+
317
+
318
+ class Route(ChannelOwner):
319
+ def __init__(
320
+ self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
321
+ ) -> None:
322
+ super().__init__(parent, type, guid, initializer)
323
+ self._handling_future: Optional[asyncio.Future["bool"]] = None
324
+ self._context: "BrowserContext" = cast("BrowserContext", None)
325
+ self._did_throw = False
326
+
327
+ def _start_handling(self) -> "asyncio.Future[bool]":
328
+ self._handling_future = asyncio.Future()
329
+ return self._handling_future
330
+
331
+ def _report_handled(self, done: bool) -> None:
332
+ chain = self._handling_future
333
+ assert chain
334
+ self._handling_future = None
335
+ chain.set_result(done)
336
+
337
+ def _check_not_handled(self) -> None:
338
+ if not self._handling_future:
339
+ raise Error("Route is already handled!")
340
+
341
+ def __repr__(self) -> str:
342
+ return f"<Route request={self.request}>"
343
+
344
+ @property
345
+ def request(self) -> Request:
346
+ return from_channel(self._initializer["request"])
347
+
348
+ async def abort(self, errorCode: str = None) -> None:
349
+ await self._handle_route(
350
+ lambda: self._race_with_page_close(
351
+ self._channel.send("abort", None, {"errorCode": errorCode})
352
+ )
353
+ )
354
+
355
+ async def fulfill(
356
+ self,
357
+ status: int = None,
358
+ headers: Dict[str, str] = None,
359
+ body: Union[str, bytes] = None,
360
+ json: Any = None,
361
+ path: Union[str, Path] = None,
362
+ contentType: str = None,
363
+ response: "APIResponse" = None,
364
+ ) -> None:
365
+ await self._handle_route(
366
+ lambda: self._inner_fulfill(
367
+ status, headers, body, json, path, contentType, response
368
+ )
369
+ )
370
+
371
+ async def _inner_fulfill(
372
+ self,
373
+ status: int = None,
374
+ headers: Dict[str, str] = None,
375
+ body: Union[str, bytes] = None,
376
+ json: Any = None,
377
+ path: Union[str, Path] = None,
378
+ contentType: str = None,
379
+ response: "APIResponse" = None,
380
+ ) -> None:
381
+ params = locals_to_params(locals())
382
+ if json is not None:
383
+ if body is not None:
384
+ raise Error("Can specify either body or json parameters")
385
+ body = json_utils.dumps(json)
386
+ if response:
387
+ del params["response"]
388
+ params["status"] = (
389
+ params["status"] if params.get("status") else response.status
390
+ )
391
+ params["headers"] = (
392
+ params["headers"] if params.get("headers") else response.headers
393
+ )
394
+ from patchright._impl._fetch import APIResponse
395
+
396
+ if body is None and path is None and isinstance(response, APIResponse):
397
+ if response._request._connection is self._connection:
398
+ params["fetchResponseUid"] = response._fetch_uid
399
+ else:
400
+ body = await response.body()
401
+ length = 0
402
+ if isinstance(body, str):
403
+ params["body"] = body
404
+ params["isBase64"] = False
405
+ length = len(body.encode())
406
+ elif isinstance(body, bytes):
407
+ params["body"] = base64.b64encode(body).decode()
408
+ params["isBase64"] = True
409
+ length = len(body)
410
+ elif path:
411
+ del params["path"]
412
+ file_content = Path(path).read_bytes()
413
+ params["body"] = base64.b64encode(file_content).decode()
414
+ params["isBase64"] = True
415
+ length = len(file_content)
416
+ headers = {k.lower(): str(v) for k, v in params.get("headers", {}).items()}
417
+ if params.get("contentType"):
418
+ headers["content-type"] = params["contentType"]
419
+ elif json:
420
+ headers["content-type"] = "application/json"
421
+ elif path:
422
+ headers["content-type"] = (
423
+ mimetypes.guess_type(str(Path(path)))[0] or "application/octet-stream"
424
+ )
425
+ if length and "content-length" not in headers:
426
+ headers["content-length"] = str(length)
427
+ params["headers"] = serialize_headers(headers)
428
+ await self._race_with_page_close(self._channel.send("fulfill", None, params))
429
+
430
+ async def _handle_route(self, callback: Callable) -> None:
431
+ self._check_not_handled()
432
+ try:
433
+ await callback()
434
+ self._report_handled(True)
435
+ except Exception as e:
436
+ self._did_throw = True
437
+ raise e
438
+
439
+ async def fetch(
440
+ self,
441
+ url: str = None,
442
+ method: str = None,
443
+ headers: Dict[str, str] = None,
444
+ postData: Union[Any, str, bytes] = None,
445
+ maxRedirects: int = None,
446
+ maxRetries: int = None,
447
+ timeout: float = None,
448
+ ) -> "APIResponse":
449
+ return await self._connection.wrap_api_call(
450
+ lambda: self._context.request._inner_fetch(
451
+ self.request,
452
+ url,
453
+ method,
454
+ headers,
455
+ postData,
456
+ maxRedirects=maxRedirects,
457
+ maxRetries=maxRetries,
458
+ timeout=timeout,
459
+ )
460
+ )
461
+
462
+ async def fallback(
463
+ self,
464
+ url: str = None,
465
+ method: str = None,
466
+ headers: Dict[str, str] = None,
467
+ postData: Union[Any, str, bytes] = None,
468
+ patchrightInitScript: Optional[bool] = None,
469
+ ) -> None:
470
+ overrides = cast(FallbackOverrideParameters, locals_to_params(locals()))
471
+ self._check_not_handled()
472
+ self.request._apply_fallback_overrides(overrides)
473
+ self._report_handled(False)
474
+
475
+ async def continue_(
476
+ self,
477
+ url: str = None,
478
+ method: str = None,
479
+ headers: Dict[str, str] = None,
480
+ postData: Union[Any, str, bytes] = None,
481
+ patchrightInitScript: Optional[bool] = None,
482
+ ) -> None:
483
+ overrides = cast(FallbackOverrideParameters, locals_to_params(locals()))
484
+
485
+ async def _inner() -> None:
486
+ self.request._apply_fallback_overrides(overrides)
487
+ await self._inner_continue(False)
488
+
489
+ return await self._handle_route(_inner)
490
+
491
+ async def _inner_continue(self, is_fallback: bool = False) -> None:
492
+ options = self.request._fallback_overrides
493
+ await self._race_with_page_close(
494
+ self._channel.send(
495
+ "continue",
496
+ None,
497
+ {
498
+ "url": options.url,
499
+ "method": options.method,
500
+ "headers": serialize_headers(options.headers)
501
+ if options.headers
502
+ else None,
503
+ "postData": base64.b64encode(options.post_data_buffer).decode()
504
+ if options.post_data_buffer is not None
505
+ else None,
506
+ "isFallback": is_fallback,
507
+ "patchrightInitScript": True
508
+ if options.patchright_init_script
509
+ else None,
510
+ },
511
+ )
512
+ )
513
+
514
+ async def _redirected_navigation_request(self, url: str) -> None:
515
+ await self._handle_route(
516
+ lambda: self._race_with_page_close(
517
+ self._channel.send("redirectNavigationRequest", None, {"url": url})
518
+ )
519
+ )
520
+
521
+ async def _race_with_page_close(self, future: Coroutine) -> None:
522
+ fut = asyncio.create_task(future)
523
+ setattr(
524
+ fut,
525
+ "__pw_stack__",
526
+ getattr(asyncio.current_task(self._loop), "__pw_stack__", None)
527
+ or _capture_stack_trace(),
528
+ )
529
+ target_closed_future = self.request._target_closed_future()
530
+ await asyncio.wait(
531
+ [fut, target_closed_future], return_when=asyncio.FIRST_COMPLETED
532
+ )
533
+ if fut.done() and fut.exception():
534
+ raise cast(BaseException, fut.exception())
535
+ if target_closed_future.done():
536
+ await asyncio.gather(fut, return_exceptions=True)
537
+
538
+
539
+ class ServerWebSocketRoute:
540
+ def __init__(self, ws: "WebSocketRoute"):
541
+ self._ws = ws
542
+
543
+ def on_message(self, handler: Callable[[Union[str, bytes]], Any]) -> None:
544
+ self._ws._on_server_message = handler
545
+
546
+ def on_close(self, handler: Callable[[Optional[int], Optional[str]], Any]) -> None:
547
+ self._ws._on_server_close = handler
548
+
549
+ def connect_to_server(self) -> None:
550
+ raise NotImplementedError(
551
+ "connectToServer must be called on the page-side WebSocketRoute"
552
+ )
553
+
554
+ @property
555
+ def url(self) -> str:
556
+ return self._ws._initializer["url"]
557
+
558
+ @property
559
+ def protocols(self) -> List[str]:
560
+ return list(self._ws._initializer.get("protocols", []))
561
+
562
+ def close(self, code: int = None, reason: str = None) -> None:
563
+ self._ws._channel.send_may_fail(
564
+ "closeServer", None, {"code": code, "reason": reason, "wasClean": True}
565
+ )
566
+
567
+ def send(self, message: Union[str, bytes]) -> None:
568
+ if isinstance(message, str):
569
+ self._ws._channel.send_may_fail(
570
+ "sendToServer", None, {"message": message, "isBase64": False}
571
+ )
572
+ else:
573
+ self._ws._channel.send_may_fail(
574
+ "sendToServer",
575
+ None,
576
+ {"message": base64.b64encode(message).decode(), "isBase64": True},
577
+ )
578
+
579
+
580
+ class WebSocketRoute(ChannelOwner):
581
+ def __init__(
582
+ self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
583
+ ) -> None:
584
+ super().__init__(parent, type, guid, initializer)
585
+ self._on_page_message: Optional[Callable[[Union[str, bytes]], Any]] = None
586
+ self._on_page_close: Optional[Callable[[Optional[int], Optional[str]], Any]] = (
587
+ None
588
+ )
589
+ self._on_server_message: Optional[Callable[[Union[str, bytes]], Any]] = None
590
+ self._on_server_close: Optional[
591
+ Callable[[Optional[int], Optional[str]], Any]
592
+ ] = None
593
+ self._server = ServerWebSocketRoute(self)
594
+ self._connected = False
595
+ self._channel.on("messageFromPage", self._channel_message_from_page)
596
+ self._channel.on("messageFromServer", self._channel_message_from_server)
597
+ self._channel.on("closePage", self._channel_close_page)
598
+ self._channel.on("closeServer", self._channel_close_server)
599
+
600
+ def _channel_message_from_page(self, event: Dict) -> None:
601
+ if self._on_page_message:
602
+ self._on_page_message(
603
+ base64.b64decode(event["message"])
604
+ if event["isBase64"]
605
+ else event["message"]
606
+ )
607
+ elif self._connected:
608
+ self._channel.send_may_fail("sendToServer", None, event)
609
+
610
+ def _channel_message_from_server(self, event: Dict) -> None:
611
+ if self._on_server_message:
612
+ self._on_server_message(
613
+ base64.b64decode(event["message"])
614
+ if event["isBase64"]
615
+ else event["message"]
616
+ )
617
+ else:
618
+ self._channel.send_may_fail("sendToPage", None, event)
619
+
620
+ def _channel_close_page(self, event: Dict) -> None:
621
+ if self._on_page_close:
622
+ self._on_page_close(event["code"], event["reason"])
623
+ else:
624
+ self._channel.send_may_fail("closeServer", None, event)
625
+
626
+ def _channel_close_server(self, event: Dict) -> None:
627
+ if self._on_server_close:
628
+ self._on_server_close(event["code"], event["reason"])
629
+ else:
630
+ self._channel.send_may_fail("closePage", None, event)
631
+
632
+ @property
633
+ def url(self) -> str:
634
+ return self._initializer["url"]
635
+
636
+ @property
637
+ def protocols(self) -> List[str]:
638
+ return list(self._initializer.get("protocols", []))
639
+
640
+ async def close(self, code: int = None, reason: str = None) -> None:
641
+ try:
642
+ await self._channel.send(
643
+ "closePage", None, {"code": code, "reason": reason, "wasClean": True}
644
+ )
645
+ except Exception:
646
+ pass
647
+
648
+ def connect_to_server(self) -> "WebSocketRoute":
649
+ if self._connected:
650
+ raise Error("Already connected to the server")
651
+ self._connected = True
652
+ self._channel.send_may_fail("connect", None)
653
+ return cast("WebSocketRoute", self._server)
654
+
655
+ def send(self, message: Union[str, bytes]) -> None:
656
+ if isinstance(message, str):
657
+ self._channel.send_may_fail(
658
+ "sendToPage", None, {"message": message, "isBase64": False}
659
+ )
660
+ else:
661
+ self._channel.send_may_fail(
662
+ "sendToPage",
663
+ None,
664
+ {"message": base64.b64encode(message).decode(), "isBase64": True},
665
+ )
666
+
667
+ def on_message(self, handler: Callable[[Union[str, bytes]], Any]) -> None:
668
+ self._on_page_message = handler
669
+
670
+ def on_close(self, handler: Callable[[Optional[int], Optional[str]], Any]) -> None:
671
+ self._on_page_close = handler
672
+
673
+ async def _after_handle(self) -> None:
674
+ if self._connected:
675
+ return
676
+ try:
677
+ await self._channel.send("ensureOpened", None)
678
+ except Exception:
679
+ pass
680
+
681
+
682
+ class WebSocketRouteHandler:
683
+ def __init__(
684
+ self,
685
+ base_url: Optional[str],
686
+ url: URLMatch,
687
+ handler: WebSocketRouteHandlerCallback,
688
+ ):
689
+ self._base_url = base_url
690
+ self.url = url
691
+ self.handler = handler
692
+
693
+ @staticmethod
694
+ def prepare_interception_patterns(
695
+ handlers: List["WebSocketRouteHandler"],
696
+ ) -> List[dict]:
697
+ patterns = []
698
+ all_urls = False
699
+ for handler in handlers:
700
+ if isinstance(handler.url, str):
701
+ patterns.append({"glob": handler.url})
702
+ elif isinstance(handler.url, re.Pattern):
703
+ patterns.append(
704
+ {
705
+ "regexSource": handler.url.pattern,
706
+ "regexFlags": escape_regex_flags(handler.url),
707
+ }
708
+ )
709
+ else:
710
+ all_urls = True
711
+ if all_urls:
712
+ return [{"glob": "**/*"}]
713
+ return patterns
714
+
715
+ def matches(self, ws_url: str) -> bool:
716
+ return url_matches(self._base_url, ws_url, self.url, True)
717
+
718
+ async def handle(self, websocket_route: "WebSocketRoute") -> None:
719
+ coro_or_future = self.handler(websocket_route)
720
+ if asyncio.iscoroutine(coro_or_future):
721
+ await coro_or_future
722
+ await websocket_route._after_handle()
723
+
724
+
725
+ class Response(ChannelOwner):
726
+ def __init__(
727
+ self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
728
+ ) -> None:
729
+ super().__init__(parent, type, guid, initializer)
730
+ self._request: Request = from_channel(self._initializer["request"])
731
+ self._request._response = self
732
+ timing = self._initializer["timing"]
733
+ self._request._timing["startTime"] = timing["startTime"]
734
+ self._request._timing["domainLookupStart"] = timing["domainLookupStart"]
735
+ self._request._timing["domainLookupEnd"] = timing["domainLookupEnd"]
736
+ self._request._timing["connectStart"] = timing["connectStart"]
737
+ self._request._timing["secureConnectionStart"] = timing["secureConnectionStart"]
738
+ self._request._timing["connectEnd"] = timing["connectEnd"]
739
+ self._request._timing["requestStart"] = timing["requestStart"]
740
+ self._request._timing["responseStart"] = timing["responseStart"]
741
+ self._provisional_headers = RawHeaders(
742
+ cast(HeadersArray, self._initializer["headers"])
743
+ )
744
+ self._raw_headers_future: Optional[asyncio.Future[RawHeaders]] = None
745
+ self._finished_future: asyncio.Future[bool] = asyncio.Future()
746
+
747
+ def __repr__(self) -> str:
748
+ return f"<Response url={self.url!r} request={self.request}>"
749
+
750
+ @property
751
+ def url(self) -> str:
752
+ return self._initializer["url"]
753
+
754
+ @property
755
+ def ok(self) -> bool:
756
+ return self._initializer["status"] == 0 or (
757
+ self._initializer["status"] >= 200 and self._initializer["status"] <= 299
758
+ )
759
+
760
+ @property
761
+ def status(self) -> int:
762
+ return self._initializer["status"]
763
+
764
+ @property
765
+ def status_text(self) -> str:
766
+ return self._initializer["statusText"]
767
+
768
+ @property
769
+ def headers(self) -> Headers:
770
+ return self._provisional_headers.headers()
771
+
772
+ @property
773
+ def from_service_worker(self) -> bool:
774
+ return self._initializer["fromServiceWorker"]
775
+
776
+ async def all_headers(self) -> Headers:
777
+ return (await self._actual_headers()).headers()
778
+
779
+ async def headers_array(self) -> HeadersArray:
780
+ return (await self._actual_headers()).headers_array()
781
+
782
+ async def header_value(self, name: str) -> Optional[str]:
783
+ return (await self._actual_headers()).get(name)
784
+
785
+ async def header_values(self, name: str) -> List[str]:
786
+ return (await self._actual_headers()).get_all(name)
787
+
788
+ async def _actual_headers(self) -> "RawHeaders":
789
+ if not self._raw_headers_future:
790
+ self._raw_headers_future = asyncio.Future()
791
+ headers = cast(
792
+ HeadersArray, await self._channel.send("rawResponseHeaders", None)
793
+ )
794
+ self._raw_headers_future.set_result(RawHeaders(headers))
795
+ return await self._raw_headers_future
796
+
797
+ async def server_addr(self) -> Optional[RemoteAddr]:
798
+ return await self._channel.send("serverAddr", None)
799
+
800
+ async def security_details(self) -> Optional[SecurityDetails]:
801
+ return await self._channel.send("securityDetails", None)
802
+
803
+ async def http_version(self) -> str:
804
+ return await self._channel.send("httpVersion", None)
805
+
806
+ async def finished(self) -> None:
807
+
808
+ async def on_finished() -> None:
809
+ await self._request._target_closed_future()
810
+ raise Error("Target closed")
811
+
812
+ on_finished_task = asyncio.create_task(on_finished())
813
+ await asyncio.wait(
814
+ cast(
815
+ List[Union[asyncio.Task, asyncio.Future]],
816
+ [self._finished_future, on_finished_task],
817
+ ),
818
+ return_when=asyncio.FIRST_COMPLETED,
819
+ )
820
+ if on_finished_task.done():
821
+ await on_finished_task
822
+
823
+ async def body(self) -> bytes:
824
+ binary = await self._channel.send("body", None)
825
+ return base64.b64decode(binary)
826
+
827
+ async def text(self) -> str:
828
+ content = await self.body()
829
+ return content.decode()
830
+
831
+ async def json(self) -> Any:
832
+ return json.loads(await self.text())
833
+
834
+ @property
835
+ def request(self) -> Request:
836
+ return self._request
837
+
838
+ @property
839
+ def frame(self) -> "Frame":
840
+ return self._request.frame
841
+
842
+
843
+ class WebSocket(ChannelOwner):
844
+ Events = SimpleNamespace(
845
+ Close="close",
846
+ FrameReceived="framereceived",
847
+ FrameSent="framesent",
848
+ Error="socketerror",
849
+ )
850
+
851
+ def __init__(
852
+ self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
853
+ ) -> None:
854
+ super().__init__(parent, type, guid, initializer)
855
+ self._is_closed = False
856
+ self._page = cast("Page", parent)
857
+ self._channel.on(
858
+ "frameSent",
859
+ lambda params: self._on_frame_sent(params["opcode"], params["data"]),
860
+ )
861
+ self._channel.on(
862
+ "frameReceived",
863
+ lambda params: self._on_frame_received(params["opcode"], params["data"]),
864
+ )
865
+ self._channel.on(
866
+ "socketError",
867
+ lambda params: self.emit(WebSocket.Events.Error, params["error"]),
868
+ )
869
+ self._channel.on("close", lambda params: self._on_close())
870
+
871
+ def __repr__(self) -> str:
872
+ return f"<WebSocket url={self.url!r}>"
873
+
874
+ @property
875
+ def url(self) -> str:
876
+ return self._initializer["url"]
877
+
878
+ def expect_event(
879
+ self, event: str, predicate: Callable = None, timeout: float = None
880
+ ) -> EventContextManagerImpl:
881
+ if timeout is None:
882
+ timeout = cast(Any, self._parent)._timeout_settings.timeout()
883
+ waiter = Waiter(self, f"web_socket.expect_event({event})")
884
+ waiter.reject_on_timeout(
885
+ cast(float, timeout),
886
+ f'Timeout {timeout}ms exceeded while waiting for event "{event}"',
887
+ )
888
+ if event != WebSocket.Events.Close:
889
+ waiter.reject_on_event(self, WebSocket.Events.Close, Error("Socket closed"))
890
+ if event != WebSocket.Events.Error:
891
+ waiter.reject_on_event(self, WebSocket.Events.Error, Error("Socket error"))
892
+ waiter.reject_on_event(
893
+ self._page, "close", lambda: self._page._close_error_with_reason()
894
+ )
895
+ waiter.wait_for_event(self, event, predicate)
896
+ return EventContextManagerImpl(waiter.result())
897
+
898
+ async def wait_for_event(
899
+ self, event: str, predicate: Callable = None, timeout: float = None
900
+ ) -> Any:
901
+ async with self.expect_event(event, predicate, timeout) as event_info:
902
+ pass
903
+ return await event_info
904
+
905
+ def _on_frame_sent(self, opcode: int, data: str) -> None:
906
+ if opcode == 2:
907
+ self.emit(WebSocket.Events.FrameSent, base64.b64decode(data))
908
+ elif opcode == 1:
909
+ self.emit(WebSocket.Events.FrameSent, data)
910
+
911
+ def _on_frame_received(self, opcode: int, data: str) -> None:
912
+ if opcode == 2:
913
+ self.emit(WebSocket.Events.FrameReceived, base64.b64decode(data))
914
+ elif opcode == 1:
915
+ self.emit(WebSocket.Events.FrameReceived, data)
916
+
917
+ def is_closed(self) -> bool:
918
+ return self._is_closed
919
+
920
+ def _on_close(self) -> None:
921
+ self._is_closed = True
922
+ self.emit(WebSocket.Events.Close, self)
923
+
924
+
925
+ class RawHeaders:
926
+ def __init__(self, headers: HeadersArray) -> None:
927
+ self._headers_array = headers
928
+ self._headers_map: Dict[str, Dict[str, bool]] = defaultdict(dict)
929
+ for header in headers:
930
+ self._headers_map[header["name"].lower()][header["value"]] = True
931
+
932
+ @staticmethod
933
+ def _from_headers_dict_lossy(headers: Dict[str, str]) -> "RawHeaders":
934
+ return RawHeaders(serialize_headers(headers))
935
+
936
+ def get(self, name: str) -> Optional[str]:
937
+ values = self.get_all(name)
938
+ if not values:
939
+ return None
940
+ separator = "\n" if name.lower() == "set-cookie" else ", "
941
+ return separator.join(values)
942
+
943
+ def get_all(self, name: str) -> List[str]:
944
+ return list(self._headers_map[name.lower()].keys())
945
+
946
+ def headers(self) -> Dict[str, str]:
947
+ result = {}
948
+ for name in self._headers_map.keys():
949
+ result[name] = cast(str, self.get(name))
950
+ return result
951
+
952
+ def headers_array(self) -> HeadersArray:
953
+ return self._headers_array