def dispatch(self, msg: ParsedMessagePayload) -> None:
id = msg.get("id")
if id:
callback = self._callbacks.pop(id)
if callback.future.cancelled():
return
error = msg.get("error")
if error:
parsed_error = parse_error(error["error"]) # type: ignore
parsed_error.stack = "".join(
traceback.format_list(callback.stack_trace)[-10:])
callback.future.set_exception(parsed_error)
else:
result = self._replace_guids_with_channels(msg.get("result"))
callback.future.set_result(result)
return
guid = msg["guid"]
method = msg.get("method")
params = msg.get("params")
if method == "__create__":
assert params
parent = self._objects[guid]
self._create_remote_object(parent, params["type"], params["guid"],
params["initializer"])
return
object = self._objects.get(guid)
if not object:
raise Exception(f'Cannot find object to "{method}": {guid}')
if method == "__adopt__":
child_guid = cast(Dict[str, str], params)["guid"]
child = self._objects.get(child_guid)
if not child:
raise Exception(f"Unknown new child: {child_guid}")
object._adopt(child)
return
if method == "__dispose__":
self._objects[guid]._dispose()
return
object = self._objects[guid]
try:
if self._is_sync:
for listener in object._channel.listeners(method):
# Each event handler is a potentilly blocking context, create a fiber for each
# and switch to them in order, until they block inside and pass control to each
# other and then eventually back to dispatcher as listener functions return.
g = greenlet(listener)
g.switch(self._replace_guids_with_channels(params))
else:
object._channel.emit(method,
self._replace_guids_with_channels(params))
except BaseException as exc:
print("Error occured in event listener", file=sys.stderr)
traceback.print_exc()
self._error = exc
def _dispatch(self, msg: ParsedMessagePayload) -> None:
id = msg.get("id")
if id:
callback = self._callbacks.pop(id)
if callback.future.cancelled():
return
error = msg.get("error")
if error:
parsed_error = parse_error(error["error"]) # type: ignore
parsed_error.stack = "".join(
traceback.format_list(callback.stack_trace)[-10:]
)
callback.future.set_exception(parsed_error)
else:
result = self._replace_guids_with_channels(msg.get("result"))
callback.future.set_result(result)
return
guid = msg["guid"]
method = msg.get("method")
params = msg["params"]
if method == "__create__":
parent = self._objects[guid]
self._create_remote_object(
parent, params["type"], params["guid"], params["initializer"]
)
return
if method == "__dispose__":
self._objects[guid]._dispose()
return
object = self._objects[guid]
try:
if self._is_sync:
for listener in object._channel.listeners(method):
g = greenlet(listener)
g.switch(self._replace_guids_with_channels(params))
else:
object._channel.emit(method, self._replace_guids_with_channels(params))
except Exception:
print(
"Error dispatching the event",
"".join(traceback.format_exception(*sys.exc_info())),
)
def __init__(self, parent: ChannelOwner, type: str, guid: str,
initializer: Dict) -> None:
super().__init__(parent, type, guid, initializer)
self.accessibility = Accessibility(self._channel)
self.keyboard = Keyboard(self._channel)
self.mouse = Mouse(self._channel)
self.touchscreen = Touchscreen(self._channel)
self._main_frame: Frame = from_channel(initializer["mainFrame"])
self._main_frame._page = self
self._frames = [self._main_frame]
self._viewport_size: Optional[ViewportSize] = initializer.get(
"viewportSize")
self._is_closed = False
self._workers: List["Worker"] = []
self._bindings: Dict[str, Any] = {}
self._routes: List[RouteHandlerEntry] = []
self._owned_context: Optional["BrowserContext"] = None
self._timeout_settings: TimeoutSettings = TimeoutSettings(None)
self._video: Optional[Video] = None
self._opener = cast("Page",
from_nullable_channel(initializer.get("opener")))
self._channel.on(
"bindingCall",
lambda params: self._on_binding(from_channel(params["binding"])),
)
self._channel.on("close", lambda _: self._on_close())
self._channel.on(
"console",
lambda params: self.emit(Page.Events.Console,
from_channel(params["message"])),
)
self._channel.on("crash", lambda _: self._on_crash())
self._channel.on("dialog", lambda params: self._on_dialog(params))
self._channel.on("domcontentloaded",
lambda _: self.emit(Page.Events.DOMContentLoaded))
self._channel.on("download", lambda params: self._on_download(params))
self._channel.on(
"fileChooser",
lambda params: self.emit(
Page.Events.FileChooser,
FileChooser(self, from_channel(params["element"]), params[
"isMultiple"]),
),
)
self._channel.on(
"frameAttached",
lambda params: self._on_frame_attached(
from_channel(params["frame"])),
)
self._channel.on(
"frameDetached",
lambda params: self._on_frame_detached(
from_channel(params["frame"])),
)
self._channel.on("load", lambda _: self.emit(Page.Events.Load))
self._channel.on(
"pageError",
lambda params: self.emit(Page.Events.PageError,
parse_error(params["error"]["error"])),
)
self._channel.on(
"request",
lambda params: self.emit(Page.Events.Request,
from_channel(params["request"])),
)
self._channel.on(
"requestFailed",
lambda params: self._on_request_failed(
from_channel(params["request"]),
params["responseEndTiming"],
params["failureText"],
),
)
self._channel.on(
"requestFinished",
lambda params: self._on_request_finished(
from_channel(params["request"]), params["responseEndTiming"]),
)
self._channel.on(
"response",
lambda params: self.emit(Page.Events.Response,
from_channel(params["response"])),
)
self._channel.on(
"route",
lambda params: self._on_route(from_channel(params["route"]),
from_channel(params["request"])),
)
self._channel.on("video", lambda params: self._on_video(params))
self._channel.on(
"webSocket",
lambda params: self.emit(Page.Events.WebSocket,
from_channel(params["webSocket"])),
)
self._channel.on(
"worker",
lambda params: self._on_worker(from_channel(params["worker"])))
