async def dispatchEvent(self,
selector: str,
type: str,
eventInit: Dict = None,
timeout: int = None) -> None:
await self._channel.send(
"dispatchEvent",
dict(selector=selector,
type=type,
eventInit=serialize_argument(eventInit)),
)
async def evaluateHandle(self,
expression: str,
arg: Serializable = None,
force_expr: bool = None) -> JSHandle:
return from_channel(await self._channel.send(
"evaluateExpressionHandle",
dict(
expression=expression,
isFunction=not (force_expr),
arg=serialize_argument(arg),
),
))
async def evaluate(self,
expression: str,
arg: Serializable = None,
force_expr: bool = None) -> Any:
if not is_function_body(expression):
force_expr = True
return parse_result(await self._channel.send(
"evaluateExpression",
dict(
expression=expression,
isFunction=not (force_expr),
arg=serialize_argument(arg),
),
))
async def waitForFunction(
self,
expression: str,
arg: Serializable = None,
force_expr: bool = None,
timeout: int = None,
polling: Union[int, Literal["raf"]] = None,
) -> JSHandle:
if not is_function_body(expression):
force_expr = True
params = locals_to_params(locals())
params["isFunction"] = not (force_expr)
params["arg"] = serialize_argument(arg)
return from_channel(await self._channel.send("waitForFunction",
params))
async def evalOnSelectorAll(
self,
selector: str,
expression: str,
arg: Serializable = None,
force_expr: bool = None,
) -> Any:
return parse_result(await self._channel.send(
"evalOnSelectorAll",
dict(
selector=selector,
expression=expression,
isFunction=not (force_expr),
arg=serialize_argument(arg),
),
))
async def call(self, func: Callable) -> None:
try:
frame = from_channel(self._initializer["frame"])
source = dict(context=frame._page.context, page=frame._page, frame=frame)
if self._initializer.get("handle"):
result = func(source, from_channel(self._initializer["handle"]))
else:
func_args = list(map(parse_result, self._initializer["args"]))
result = func(source, *func_args)
if asyncio.isfuture(result):
result = await result
await self._channel.send("resolve", dict(result=serialize_argument(result)))
except Exception as e:
tb = sys.exc_info()[2]
asyncio.create_task(
self._channel.send("reject", dict(error=serialize_error(e, tb)))
)
async def dispatchEvent(self, type: str, eventInit: Dict = None) -> None:
await self._channel.send(
"dispatchEvent",
dict(type=type, eventInit=serialize_argument(eventInit)))