async def eval_on_selector_all(
self,
selector: str,
expression: str,
arg: Serializable = None,
) -> Any:
return parse_result(
await self._channel.send(
"evalOnSelectorAll",
dict(
selector=selector,
expression=expression,
arg=serialize_argument(arg),
),
)
)
async def eval_on_selector(
self,
selector: str,
expression: str,
arg: Serializable = None,
force_expr: bool = None,
) -> Any:
return parse_result(await self._channel.send(
"evalOnSelector",
dict(
selector=selector,
expression=expression,
isFunction=not (force_expr),
arg=serialize_argument(arg),
),
))
async def _expect(self, expression: str,
options: FrameExpectOptions) -> FrameExpectResult:
if "expectedValue" in options:
options["expectedValue"] = serialize_argument(
options["expectedValue"])
result = await self._frame._channel.send_return_as_dict(
"expect",
{
"selector": self._selector,
"expression": expression,
**options,
},
)
if result.get("received"):
result["received"] = parse_value(result["received"])
return result
async def eval_on_selector(
self,
selector: str,
expression: str,
arg: Serializable = None,
strict: bool = None,
) -> Any:
return parse_result(await self._channel.send(
"evalOnSelector",
locals_to_params(
dict(
selector=selector,
expression=expression,
arg=serialize_argument(arg),
strict=strict,
)),
))
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 dispatch_event(
self,
selector: str,
type: str,
eventInit: Dict = None,
strict: bool = None,
timeout: float = None,
) -> None:
await self._channel.send(
"dispatchEvent",
locals_to_params(
dict(
selector=selector,
type=type,
eventInit=serialize_argument(eventInit),
strict=strict,
timeout=timeout,
), ),
)
async def dispatch_event(self, type: str, eventInit: Dict = None) -> None:
await self._channel.send(
"dispatchEvent",
dict(type=type, eventInit=serialize_argument(eventInit)))
