browserless-bap 0.2.0__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.
- browserless_bap/__init__.py +35 -0
- browserless_bap/_codec.py +29 -0
- browserless_bap/_io.py +27 -0
- browserless_bap/_page_generated.py +1322 -0
- browserless_bap/_unset.py +12 -0
- browserless_bap/_version.py +1 -0
- browserless_bap/async_api.py +3 -0
- browserless_bap/browser.py +108 -0
- browserless_bap/browserless.py +30 -0
- browserless_bap/element_handle.py +120 -0
- browserless_bap/emitter.py +134 -0
- browserless_bap/errors.py +64 -0
- browserless_bap/graphql/__init__.py +11 -0
- browserless_bap/graphql/builder.py +37 -0
- browserless_bap/graphql/mutations.py +417 -0
- browserless_bap/graphql/subscriptions.py +47 -0
- browserless_bap/page.py +771 -0
- browserless_bap/py.typed +1 -0
- browserless_bap/sync_api/__init__.py +24 -0
- browserless_bap/sync_api/_base.py +32 -0
- browserless_bap/sync_api/_bridge.py +419 -0
- browserless_bap/sync_api/_page_generated.py +979 -0
- browserless_bap/sync_api/browser.py +48 -0
- browserless_bap/sync_api/browserless.py +33 -0
- browserless_bap/sync_api/element_handle.py +70 -0
- browserless_bap/sync_api/page.py +383 -0
- browserless_bap/transport.py +522 -0
- browserless_bap/types/__init__.py +7 -0
- browserless_bap/types/enums.py +717 -0
- browserless_bap/types/events.py +121 -0
- browserless_bap/types/inputs.py +71 -0
- browserless_bap/types/options.py +367 -0
- browserless_bap/types/responses.py +314 -0
- browserless_bap-0.2.0.dist-info/METADATA +264 -0
- browserless_bap-0.2.0.dist-info/RECORD +37 -0
- browserless_bap-0.2.0.dist-info/WHEEL +4 -0
- browserless_bap-0.2.0.dist-info/licenses/LICENSE +21 -0
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
"""Synchronous Browser facade."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Iterator
|
|
6
|
+
from contextlib import contextmanager
|
|
7
|
+
from typing import Any, Self
|
|
8
|
+
|
|
9
|
+
from ._base import SyncBase
|
|
10
|
+
from .page import Page
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class Browser(SyncBase[Any]):
|
|
14
|
+
def new_page(self) -> Page:
|
|
15
|
+
return Page(self._invoke("new_page"), self._bridge)
|
|
16
|
+
|
|
17
|
+
def get_pages(self) -> list[Page]:
|
|
18
|
+
return [Page(page, self._bridge) for page in self._invoke("get_pages")]
|
|
19
|
+
|
|
20
|
+
def pages(self) -> list[Page]:
|
|
21
|
+
return self.get_pages()
|
|
22
|
+
|
|
23
|
+
@contextmanager
|
|
24
|
+
def page(self) -> Iterator[Page]:
|
|
25
|
+
"""Open a page and close it when the context exits."""
|
|
26
|
+
|
|
27
|
+
page = self.new_page()
|
|
28
|
+
try:
|
|
29
|
+
yield page
|
|
30
|
+
finally:
|
|
31
|
+
page.close()
|
|
32
|
+
|
|
33
|
+
def close(self) -> None:
|
|
34
|
+
try:
|
|
35
|
+
self._invoke("close")
|
|
36
|
+
finally:
|
|
37
|
+
self._bridge.untrack_browser(self._impl)
|
|
38
|
+
|
|
39
|
+
def __enter__(self) -> Self:
|
|
40
|
+
return self
|
|
41
|
+
|
|
42
|
+
def __exit__(
|
|
43
|
+
self,
|
|
44
|
+
exc_type: type[BaseException] | None,
|
|
45
|
+
exc: BaseException | None,
|
|
46
|
+
traceback: object,
|
|
47
|
+
) -> None:
|
|
48
|
+
self.close()
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
"""Synchronous package entry point."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from typing import Any, Never
|
|
6
|
+
|
|
7
|
+
from browserless_bap.browserless import Browserless as AsyncBrowserless
|
|
8
|
+
|
|
9
|
+
from ._bridge import get_loop_thread
|
|
10
|
+
from .browser import Browser
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class Browserless:
|
|
14
|
+
def __new__(cls, *args: object, **kwargs: object) -> Never:
|
|
15
|
+
raise TypeError("Browserless is a namespace; call Browserless.connect(...)")
|
|
16
|
+
|
|
17
|
+
@staticmethod
|
|
18
|
+
def connect(
|
|
19
|
+
*,
|
|
20
|
+
browser_ws_endpoint: str | None = None,
|
|
21
|
+
token: str | None = None,
|
|
22
|
+
timeout: float = 30_000,
|
|
23
|
+
transport: Any = None,
|
|
24
|
+
) -> Browser:
|
|
25
|
+
bridge = get_loop_thread()
|
|
26
|
+
impl = AsyncBrowserless.connect(
|
|
27
|
+
browser_ws_endpoint=browser_ws_endpoint,
|
|
28
|
+
token=token,
|
|
29
|
+
timeout=timeout,
|
|
30
|
+
transport=transport,
|
|
31
|
+
)
|
|
32
|
+
bridge.track_browser(impl)
|
|
33
|
+
return Browser(impl, bridge)
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
"""Synchronous element handle."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Sequence
|
|
6
|
+
from typing import Any, Unpack, cast
|
|
7
|
+
|
|
8
|
+
from ..types.options import ClickOptions, TypeOptions
|
|
9
|
+
from ..types.responses import ClickResponse, HoverResponse, SelectResponse, TypeResponse
|
|
10
|
+
from ._base import SyncBase
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class ElementHandle(SyncBase[Any]):
|
|
14
|
+
@property
|
|
15
|
+
def inner_html(self) -> str | None:
|
|
16
|
+
return cast(str | None, self._impl.inner_html)
|
|
17
|
+
|
|
18
|
+
@property
|
|
19
|
+
def inner_text(self) -> str | None:
|
|
20
|
+
return cast(str | None, self._impl.inner_text)
|
|
21
|
+
|
|
22
|
+
@property
|
|
23
|
+
def id(self) -> str | None:
|
|
24
|
+
return cast(str | None, self._impl.id)
|
|
25
|
+
|
|
26
|
+
@property
|
|
27
|
+
def class_name(self) -> str | None:
|
|
28
|
+
return cast(str | None, self._impl.class_name)
|
|
29
|
+
|
|
30
|
+
@property
|
|
31
|
+
def local_name(self) -> str | None:
|
|
32
|
+
return cast(str | None, self._impl.local_name)
|
|
33
|
+
|
|
34
|
+
@property
|
|
35
|
+
def outer_html(self) -> str | None:
|
|
36
|
+
return cast(str | None, self._impl.outer_html)
|
|
37
|
+
|
|
38
|
+
@property
|
|
39
|
+
def child_element_count(self) -> int | None:
|
|
40
|
+
return cast(int | None, self._impl.child_element_count)
|
|
41
|
+
|
|
42
|
+
@property
|
|
43
|
+
def selector(self) -> str:
|
|
44
|
+
return cast(str, self._impl.selector)
|
|
45
|
+
|
|
46
|
+
def click(self, **options: Unpack[ClickOptions]) -> ClickResponse:
|
|
47
|
+
return cast(ClickResponse, self._invoke("click", **options))
|
|
48
|
+
|
|
49
|
+
def hover(self) -> HoverResponse:
|
|
50
|
+
return cast(HoverResponse, self._invoke("hover"))
|
|
51
|
+
|
|
52
|
+
def type(self, text: str, **options: Unpack[TypeOptions]) -> TypeResponse:
|
|
53
|
+
return cast(TypeResponse, self._invoke("type", text, **options))
|
|
54
|
+
|
|
55
|
+
def select_option(self, value: str | Sequence[str]) -> SelectResponse:
|
|
56
|
+
return cast(SelectResponse, self._invoke("select_option", value))
|
|
57
|
+
|
|
58
|
+
def screenshot(self, *, path: str | None = None) -> bytes:
|
|
59
|
+
return cast(bytes, self._invoke("screenshot", path=path))
|
|
60
|
+
|
|
61
|
+
def text_content(self) -> str:
|
|
62
|
+
return cast(str, self._invoke("text_content"))
|
|
63
|
+
|
|
64
|
+
def query_selector(self, selector: str) -> ElementHandle | None:
|
|
65
|
+
value = self._invoke("query_selector", selector)
|
|
66
|
+
return None if value is None else ElementHandle(value, self._bridge)
|
|
67
|
+
|
|
68
|
+
def query_selector_all(self, selector: str) -> list[ElementHandle]:
|
|
69
|
+
values = cast(list[object], self._invoke("query_selector_all", selector))
|
|
70
|
+
return [ElementHandle(value, self._bridge) for value in values]
|
|
@@ -0,0 +1,383 @@
|
|
|
1
|
+
"""Synchronous Page facade."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Callable, Mapping, Sequence
|
|
6
|
+
from pathlib import Path
|
|
7
|
+
from typing import Any, Self, cast
|
|
8
|
+
|
|
9
|
+
from .._unset import UNSET, UnsetType
|
|
10
|
+
from ..element_handle import ElementHandle as AsyncElementHandle
|
|
11
|
+
from ..types.enums import (
|
|
12
|
+
Method,
|
|
13
|
+
OperatorType,
|
|
14
|
+
ResourceType,
|
|
15
|
+
WaitForFunctionPolling,
|
|
16
|
+
WaitUntilGoto,
|
|
17
|
+
)
|
|
18
|
+
from ..types.inputs import CookieInput
|
|
19
|
+
from ..types.responses import (
|
|
20
|
+
AddScriptTagResponse,
|
|
21
|
+
AddStyleTagResponse,
|
|
22
|
+
CookieResponse,
|
|
23
|
+
HTTPHeadersResponse,
|
|
24
|
+
HTTPResponse,
|
|
25
|
+
LiveURLCompleteEvent,
|
|
26
|
+
ResponseResponse,
|
|
27
|
+
SelectResponse,
|
|
28
|
+
WaitForEvent,
|
|
29
|
+
WaitForFunction,
|
|
30
|
+
WaitForRequestResponse,
|
|
31
|
+
WaitForResponseResponse,
|
|
32
|
+
)
|
|
33
|
+
from ._base import SyncBase
|
|
34
|
+
from ._page_generated import PageGenerated
|
|
35
|
+
from .element_handle import ElementHandle
|
|
36
|
+
|
|
37
|
+
Callback = Callable[[object], object]
|
|
38
|
+
_SUBSCRIPTION_START_TIMEOUT = 5.0
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
class Page(PageGenerated, SyncBase[Any]):
|
|
42
|
+
def __init__(self, impl: Any, bridge: Any = None) -> None:
|
|
43
|
+
SyncBase.__init__(self, impl, bridge)
|
|
44
|
+
self._event_wrappers: dict[tuple[str, Callback, bool], Callback] = {}
|
|
45
|
+
|
|
46
|
+
@property
|
|
47
|
+
def closed(self) -> bool:
|
|
48
|
+
return bool(self._impl.closed)
|
|
49
|
+
|
|
50
|
+
def _wrap_result(self, value: object) -> object:
|
|
51
|
+
if value is None:
|
|
52
|
+
return None
|
|
53
|
+
if isinstance(value, AsyncElementHandle):
|
|
54
|
+
return ElementHandle(value, self._bridge)
|
|
55
|
+
if (
|
|
56
|
+
isinstance(value, list)
|
|
57
|
+
and value
|
|
58
|
+
and all(isinstance(item, AsyncElementHandle) for item in value)
|
|
59
|
+
):
|
|
60
|
+
return [ElementHandle(item, self._bridge) for item in value]
|
|
61
|
+
return value
|
|
62
|
+
|
|
63
|
+
def _invoke(self, method_name: str, *args: object, **kwargs: object) -> object:
|
|
64
|
+
return self._wrap_result(super()._invoke(method_name, *args, **kwargs))
|
|
65
|
+
|
|
66
|
+
def wait_for_live_complete(
|
|
67
|
+
self, *, timeout: float | None = None
|
|
68
|
+
) -> LiveURLCompleteEvent:
|
|
69
|
+
"""Wait for the current handoff; timeout is in milliseconds (0 disables it)."""
|
|
70
|
+
return cast(
|
|
71
|
+
LiveURLCompleteEvent,
|
|
72
|
+
self._invoke("wait_for_live_complete", timeout=timeout),
|
|
73
|
+
)
|
|
74
|
+
|
|
75
|
+
def subscribe(self, listener: Callback) -> Callable[[], None]:
|
|
76
|
+
self.on("message", listener)
|
|
77
|
+
|
|
78
|
+
def unsubscribe() -> None:
|
|
79
|
+
self.off("message", listener)
|
|
80
|
+
|
|
81
|
+
return unsubscribe
|
|
82
|
+
|
|
83
|
+
def listener_count(self, event: str) -> int:
|
|
84
|
+
"""Return the number of listeners registered for `event`."""
|
|
85
|
+
|
|
86
|
+
return cast(int, self._invoke("listener_count", event))
|
|
87
|
+
|
|
88
|
+
def _callback_wrapper(
|
|
89
|
+
self,
|
|
90
|
+
event: str,
|
|
91
|
+
callback: Callback,
|
|
92
|
+
*,
|
|
93
|
+
once: bool = False,
|
|
94
|
+
) -> Callback:
|
|
95
|
+
key = (event, callback, once)
|
|
96
|
+
existing = self._event_wrappers.get(key)
|
|
97
|
+
if existing is not None:
|
|
98
|
+
return existing
|
|
99
|
+
|
|
100
|
+
def route_error(error: BaseException) -> None:
|
|
101
|
+
async def emit_error() -> None:
|
|
102
|
+
self._impl.emit("error", error)
|
|
103
|
+
|
|
104
|
+
self._bridge.submit(emit_error())
|
|
105
|
+
|
|
106
|
+
def dispatch(payload: object) -> None:
|
|
107
|
+
if once:
|
|
108
|
+
self._event_wrappers.pop(key, None)
|
|
109
|
+
self._impl.off(event, dispatch)
|
|
110
|
+
self._bridge.dispatcher.submit(
|
|
111
|
+
callback,
|
|
112
|
+
payload,
|
|
113
|
+
on_error=route_error if event != "error" else None,
|
|
114
|
+
)
|
|
115
|
+
|
|
116
|
+
self._event_wrappers[key] = dispatch
|
|
117
|
+
return dispatch
|
|
118
|
+
|
|
119
|
+
def _wait_for_subscription(self, event: str) -> None:
|
|
120
|
+
waiter = getattr(self._impl, "_wait_subscription_started", None)
|
|
121
|
+
if waiter is None:
|
|
122
|
+
return
|
|
123
|
+
try:
|
|
124
|
+
self._bridge.run(
|
|
125
|
+
cast(Any, waiter(event)),
|
|
126
|
+
timeout=_SUBSCRIPTION_START_TIMEOUT,
|
|
127
|
+
)
|
|
128
|
+
except Exception:
|
|
129
|
+
# Establishment is bounded and best-effort. The async Page owns
|
|
130
|
+
# routing a real subscription failure to its ``error`` event.
|
|
131
|
+
return
|
|
132
|
+
|
|
133
|
+
def on(self, event: str, callback: Callback) -> Self:
|
|
134
|
+
wrapper = self._callback_wrapper(event, callback)
|
|
135
|
+
self._invoke("on", event, wrapper)
|
|
136
|
+
self._wait_for_subscription(event)
|
|
137
|
+
return self
|
|
138
|
+
|
|
139
|
+
def once(self, event: str, callback: Callback) -> Self:
|
|
140
|
+
wrapper = self._callback_wrapper(event, callback, once=True)
|
|
141
|
+
self._invoke("on", event, wrapper)
|
|
142
|
+
self._wait_for_subscription(event)
|
|
143
|
+
return self
|
|
144
|
+
|
|
145
|
+
def off(self, event: str, callback: Callback) -> Self:
|
|
146
|
+
keys = [key for key in self._event_wrappers if key[:2] == (event, callback)]
|
|
147
|
+
wrappers = [
|
|
148
|
+
wrapper
|
|
149
|
+
for wrapper in (self._event_wrappers.pop(key, None) for key in keys)
|
|
150
|
+
if wrapper is not None
|
|
151
|
+
]
|
|
152
|
+
for wrapper in wrappers or [callback]:
|
|
153
|
+
self._invoke("off", event, wrapper)
|
|
154
|
+
return self
|
|
155
|
+
|
|
156
|
+
def emit(self, event: str, payload: object) -> bool:
|
|
157
|
+
return bool(self._invoke("emit", event, payload))
|
|
158
|
+
|
|
159
|
+
def remove_all_listeners(self, event: str | None = None) -> Self:
|
|
160
|
+
if event is None:
|
|
161
|
+
self._event_wrappers.clear()
|
|
162
|
+
else:
|
|
163
|
+
for key in [key for key in self._event_wrappers if key[0] == event]:
|
|
164
|
+
self._event_wrappers.pop(key, None)
|
|
165
|
+
self._invoke("remove_all_listeners", event)
|
|
166
|
+
return self
|
|
167
|
+
|
|
168
|
+
def goto(
|
|
169
|
+
self,
|
|
170
|
+
url: str,
|
|
171
|
+
*,
|
|
172
|
+
timeout: float | UnsetType = UNSET,
|
|
173
|
+
wait_until: WaitUntilGoto | UnsetType = UNSET,
|
|
174
|
+
wait_until_all: list[WaitUntilGoto] | UnsetType = UNSET,
|
|
175
|
+
referer: str | UnsetType = UNSET,
|
|
176
|
+
referrer_policy: str | UnsetType = UNSET,
|
|
177
|
+
remote_response_metadata: bool | UnsetType = UNSET,
|
|
178
|
+
) -> HTTPResponse | None:
|
|
179
|
+
return cast(
|
|
180
|
+
HTTPResponse | None,
|
|
181
|
+
self._invoke(
|
|
182
|
+
"goto",
|
|
183
|
+
url,
|
|
184
|
+
timeout=timeout,
|
|
185
|
+
wait_until=wait_until,
|
|
186
|
+
wait_until_all=wait_until_all,
|
|
187
|
+
referer=referer,
|
|
188
|
+
referrer_policy=referrer_policy,
|
|
189
|
+
remote_response_metadata=remote_response_metadata,
|
|
190
|
+
),
|
|
191
|
+
)
|
|
192
|
+
|
|
193
|
+
def response(
|
|
194
|
+
self,
|
|
195
|
+
*,
|
|
196
|
+
status: list[int] | UnsetType = UNSET,
|
|
197
|
+
method: list[Method] | UnsetType = UNSET,
|
|
198
|
+
operator: OperatorType | UnsetType = UNSET,
|
|
199
|
+
timeout: float | UnsetType = UNSET,
|
|
200
|
+
type: list[ResourceType] | UnsetType = UNSET,
|
|
201
|
+
url: list[str] | UnsetType = UNSET,
|
|
202
|
+
wait: bool | UnsetType = UNSET,
|
|
203
|
+
body_encoding: bool | UnsetType = UNSET,
|
|
204
|
+
) -> list[ResponseResponse]:
|
|
205
|
+
return cast(
|
|
206
|
+
list[ResponseResponse],
|
|
207
|
+
self._invoke(
|
|
208
|
+
"response",
|
|
209
|
+
status=status,
|
|
210
|
+
method=method,
|
|
211
|
+
operator=operator,
|
|
212
|
+
timeout=timeout,
|
|
213
|
+
type=type,
|
|
214
|
+
url=url,
|
|
215
|
+
wait=wait,
|
|
216
|
+
body_encoding=body_encoding,
|
|
217
|
+
),
|
|
218
|
+
)
|
|
219
|
+
|
|
220
|
+
def select_option(
|
|
221
|
+
self, selector: str, value: str | Sequence[str]
|
|
222
|
+
) -> SelectResponse:
|
|
223
|
+
return cast(SelectResponse, self._invoke("select_option", selector, value))
|
|
224
|
+
|
|
225
|
+
def add_cookies(self, cookies: Sequence[CookieInput]) -> CookieResponse:
|
|
226
|
+
return cast(CookieResponse, self._invoke("add_cookies", cookies))
|
|
227
|
+
|
|
228
|
+
def set_extra_http_headers(self, headers: Mapping[str, str]) -> HTTPHeadersResponse:
|
|
229
|
+
return cast(
|
|
230
|
+
HTTPHeadersResponse, self._invoke("set_extra_http_headers", headers)
|
|
231
|
+
)
|
|
232
|
+
|
|
233
|
+
def evaluate(
|
|
234
|
+
self,
|
|
235
|
+
expression: str,
|
|
236
|
+
*,
|
|
237
|
+
timeout: float | UnsetType = UNSET,
|
|
238
|
+
url: str | UnsetType = UNSET,
|
|
239
|
+
) -> str | None:
|
|
240
|
+
return cast(
|
|
241
|
+
str | None,
|
|
242
|
+
self._invoke("evaluate", expression, timeout=timeout, url=url),
|
|
243
|
+
)
|
|
244
|
+
|
|
245
|
+
def wait_for_function(
|
|
246
|
+
self,
|
|
247
|
+
expression: str,
|
|
248
|
+
*,
|
|
249
|
+
polling: float | UnsetType = UNSET,
|
|
250
|
+
polling_type: WaitForFunctionPolling | UnsetType = UNSET,
|
|
251
|
+
timeout: float | UnsetType = UNSET,
|
|
252
|
+
complete_on_promise_resolution: bool | UnsetType = UNSET,
|
|
253
|
+
) -> WaitForFunction:
|
|
254
|
+
return cast(
|
|
255
|
+
WaitForFunction,
|
|
256
|
+
self._invoke(
|
|
257
|
+
"wait_for_function",
|
|
258
|
+
expression,
|
|
259
|
+
polling=polling,
|
|
260
|
+
polling_type=polling_type,
|
|
261
|
+
timeout=timeout,
|
|
262
|
+
complete_on_promise_resolution=complete_on_promise_resolution,
|
|
263
|
+
),
|
|
264
|
+
)
|
|
265
|
+
|
|
266
|
+
def wait_for_event(
|
|
267
|
+
self,
|
|
268
|
+
event: str,
|
|
269
|
+
*,
|
|
270
|
+
timeout: float | UnsetType = UNSET,
|
|
271
|
+
) -> WaitForEvent:
|
|
272
|
+
"""Wait for the next event payload, bounded by `timeout` when provided."""
|
|
273
|
+
|
|
274
|
+
return cast(
|
|
275
|
+
WaitForEvent, self._invoke("wait_for_event", event, timeout=timeout)
|
|
276
|
+
)
|
|
277
|
+
|
|
278
|
+
def add_script_tag(
|
|
279
|
+
self,
|
|
280
|
+
*,
|
|
281
|
+
url: str | UnsetType = UNSET,
|
|
282
|
+
path: str | Path | UnsetType = UNSET,
|
|
283
|
+
content: str | UnsetType = UNSET,
|
|
284
|
+
id: str | UnsetType = UNSET,
|
|
285
|
+
type: str | UnsetType = UNSET,
|
|
286
|
+
) -> AddScriptTagResponse:
|
|
287
|
+
return cast(
|
|
288
|
+
AddScriptTagResponse,
|
|
289
|
+
self._invoke(
|
|
290
|
+
"add_script_tag",
|
|
291
|
+
url=url,
|
|
292
|
+
path=path,
|
|
293
|
+
content=content,
|
|
294
|
+
id=id,
|
|
295
|
+
type=type,
|
|
296
|
+
),
|
|
297
|
+
)
|
|
298
|
+
|
|
299
|
+
def add_style_tag(
|
|
300
|
+
self,
|
|
301
|
+
*,
|
|
302
|
+
url: str | UnsetType = UNSET,
|
|
303
|
+
path: str | Path | UnsetType = UNSET,
|
|
304
|
+
content: str | UnsetType = UNSET,
|
|
305
|
+
) -> AddStyleTagResponse:
|
|
306
|
+
return cast(
|
|
307
|
+
AddStyleTagResponse,
|
|
308
|
+
self._invoke("add_style_tag", url=url, path=path, content=content),
|
|
309
|
+
)
|
|
310
|
+
|
|
311
|
+
def wait_for_request(
|
|
312
|
+
self,
|
|
313
|
+
url: str | UnsetType = UNSET,
|
|
314
|
+
*,
|
|
315
|
+
method: Method | UnsetType = UNSET,
|
|
316
|
+
operator: OperatorType | UnsetType = UNSET,
|
|
317
|
+
timeout: float | UnsetType = UNSET,
|
|
318
|
+
) -> WaitForRequestResponse:
|
|
319
|
+
return cast(
|
|
320
|
+
WaitForRequestResponse,
|
|
321
|
+
self._invoke(
|
|
322
|
+
"wait_for_request",
|
|
323
|
+
url,
|
|
324
|
+
method=method,
|
|
325
|
+
operator=operator,
|
|
326
|
+
timeout=timeout,
|
|
327
|
+
),
|
|
328
|
+
)
|
|
329
|
+
|
|
330
|
+
def wait_for_response(
|
|
331
|
+
self,
|
|
332
|
+
url: str | UnsetType = UNSET,
|
|
333
|
+
*,
|
|
334
|
+
statuses: Sequence[int] | UnsetType = UNSET,
|
|
335
|
+
codes: Sequence[int] | UnsetType = UNSET,
|
|
336
|
+
operator: OperatorType | UnsetType = UNSET,
|
|
337
|
+
timeout: float | UnsetType = UNSET,
|
|
338
|
+
) -> WaitForResponseResponse:
|
|
339
|
+
return cast(
|
|
340
|
+
WaitForResponseResponse,
|
|
341
|
+
self._invoke(
|
|
342
|
+
"wait_for_response",
|
|
343
|
+
url,
|
|
344
|
+
statuses=statuses,
|
|
345
|
+
codes=codes,
|
|
346
|
+
operator=operator,
|
|
347
|
+
timeout=timeout,
|
|
348
|
+
),
|
|
349
|
+
)
|
|
350
|
+
|
|
351
|
+
def wait_for_timeout(self, ms: float) -> None:
|
|
352
|
+
self._invoke("wait_for_timeout", ms)
|
|
353
|
+
|
|
354
|
+
def send(
|
|
355
|
+
self,
|
|
356
|
+
query: str,
|
|
357
|
+
*,
|
|
358
|
+
variables: Mapping[str, Any] | None = None,
|
|
359
|
+
timeout: float | None = None,
|
|
360
|
+
) -> Any:
|
|
361
|
+
return self._invoke(
|
|
362
|
+
"send",
|
|
363
|
+
query,
|
|
364
|
+
variables=variables,
|
|
365
|
+
timeout=timeout,
|
|
366
|
+
)
|
|
367
|
+
|
|
368
|
+
def close(self) -> None:
|
|
369
|
+
try:
|
|
370
|
+
self._invoke("close")
|
|
371
|
+
finally:
|
|
372
|
+
self._event_wrappers.clear()
|
|
373
|
+
|
|
374
|
+
def __enter__(self) -> Self:
|
|
375
|
+
return self
|
|
376
|
+
|
|
377
|
+
def __exit__(
|
|
378
|
+
self,
|
|
379
|
+
exc_type: type[BaseException] | None,
|
|
380
|
+
exc: BaseException | None,
|
|
381
|
+
traceback: object,
|
|
382
|
+
) -> None:
|
|
383
|
+
self.close()
|