playwright-browserstack 1.62.0__py3-none-win32.whl

playwright/_impl/_frame.py

@@ -0,0 +1,985 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
+
+from pyee import EventEmitter
+
+from playwright._impl._api_structures import (
+    AriaRole,
+    DropPayload,
+    FilePayload,
+    FrameExpectOptions,
+    FrameExpectResult,
+    Position,
+)
+from playwright._impl._connection import (
+    ChannelOwner,
+    from_channel,
+    from_nullable_channel,
+)
+from playwright._impl._element_handle import ElementHandle, convert_select_option_values
+from playwright._impl._errors import Error
+from playwright._impl._event_context_manager import EventContextManagerImpl
+from playwright._impl._helper import (
+    DocumentLoadState,
+    FrameNavigatedEvent,
+    KeyboardModifier,
+    MouseButton,
+    TimeoutSettings,
+    URLMatch,
+    async_readfile,
+    locals_to_params,
+    monotonic_time,
+    url_matches,
+)
+from playwright._impl._js_handle import (
+    JSHandle,
+    Serializable,
+    add_source_url_to_script,
+    parse_result,
+    parse_value,
+    serialize_argument,
+)
+from playwright._impl._locator import (
+    FrameLocator,
+    Locator,
+    get_by_alt_text_selector,
+    get_by_label_selector,
+    get_by_placeholder_selector,
+    get_by_role_selector,
+    get_by_test_id_selector,
+    get_by_text_selector,
+    get_by_title_selector,
+    test_id_attribute_name,
+)
+from playwright._impl._network import Response
+from playwright._impl._set_input_files_helpers import convert_input_files
+from playwright._impl._waiter import Waiter
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
+
+
+class Frame(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._parent_frame = from_nullable_channel(initializer.get("parentFrame"))
+        if self._parent_frame:
+            self._parent_frame._child_frames.append(self)
+        self._name = initializer["name"]
+        self._url = initializer["url"]
+        self._detached = False
+        self._child_frames: List[Frame] = []
+        self._page: Optional[Page] = None
+        self._load_states: Set[str] = set(initializer["loadStates"])
+        self._event_emitter = EventEmitter()
+        self._channel.on(
+            "loadstate",
+            lambda params: self._on_load_state(params.get("add"), params.get("remove")),
+        )
+        self._channel.on(
+            "navigated",
+            lambda params: self._on_frame_navigated(params),
+        )
+
+    def __repr__(self) -> str:
+        return f"<Frame name={self.name} url={self.url!r}>"
+
+    def _on_load_state(
+        self, add: DocumentLoadState = None, remove: DocumentLoadState = None
+    ) -> None:
+        if add:
+            self._load_states.add(add)
+            self._event_emitter.emit("loadstate", add)
+        elif remove and remove in self._load_states:
+            self._load_states.remove(remove)
+        if not self._parent_frame and add == "load" and self._page:
+            self._page.emit("load", self._page)
+            self._page.context.emit("pageload", self._page)
+        if not self._parent_frame and add == "domcontentloaded" and self._page:
+            self._page.emit("domcontentloaded", self._page)
+
+    def _on_frame_navigated(self, event: FrameNavigatedEvent) -> None:
+        self._url = event["url"]
+        self._name = event["name"]
+        self._event_emitter.emit("navigated", event)
+        if "error" not in event and self._page:
+            self._page.emit("framenavigated", self)
+            self._page.context.emit("framenavigated", self)
+
+    async def _query_count(self, selector: str) -> int:
+        return await self._channel.send("queryCount", None, {"selector": selector})
+
+    @property
+    def page(self) -> "Page":
+        assert self._page
+        return self._page
+
+    async def goto(
+        self,
+        url: str,
+        timeout: float = None,
+        waitUntil: DocumentLoadState = None,
+        referer: str = None,
+    ) -> Optional[Response]:
+        return cast(
+            Optional[Response],
+            from_nullable_channel(
+                await self._channel.send(
+                    "goto", self._navigation_timeout, locals_to_params(locals())
+                )
+            ),
+        )
+
+    def _setup_navigation_waiter(self, wait_name: str, timeout: float = None) -> Waiter:
+        assert self._page
+        waiter = Waiter(self._page, f"frame.{wait_name}")
+        waiter.reject_on_event(
+            self._page,
+            "close",
+            lambda: cast("Page", self._page)._close_error_with_reason(),
+        )
+        waiter.reject_on_event(
+            self._page, "crash", Error("Navigation failed because page crashed!")
+        )
+        waiter.reject_on_event(
+            self._page,
+            "framedetached",
+            Error("Navigating frame was detached!"),
+            lambda frame: frame == self,
+        )
+        timeout = self._page._timeout_settings.navigation_timeout(timeout)
+        waiter.reject_on_timeout(timeout, f"Timeout {timeout}ms exceeded.")
+        return waiter
+
+    async def _expect(
+        self,
+        selector: Optional[str],
+        expression: str,
+        options: FrameExpectOptions,
+        title: str = None,
+    ) -> FrameExpectResult:
+        if "expectedValue" in options:
+            options["expectedValue"] = serialize_argument(options["expectedValue"])
+        try:
+            await self._channel.send(
+                "expect",
+                self._timeout,
+                {
+                    "selector": selector,
+                    "expression": expression,
+                    **options,
+                },
+                title=title,
+            )
+            return {"matches": not options.get("isNot")}
+        except Error as e:
+            if not e._details:
+                raise e
+            details = cast(Dict[str, Any], e._details)
+            received = details.get("received")
+            if received:
+                received = {
+                    "value": (
+                        parse_value(received["value"]) if "value" in received else None
+                    ),
+                    "ariaSnapshot": received.get("ariaSnapshot"),
+                }
+            return {
+                "matches": bool(options.get("isNot")),
+                "received": received,
+                "timedOut": details.get("timedOut"),
+                "errorMessage": (
+                    "Error: " + details["customErrorMessage"]
+                    if details.get("customErrorMessage")
+                    else None
+                ),
+                "log": e._log,
+            }
+
+    def expect_navigation(
+        self,
+        url: URLMatch = None,
+        waitUntil: DocumentLoadState = None,
+        timeout: float = None,
+    ) -> EventContextManagerImpl[Response]:
+        assert self._page
+        if not waitUntil:
+            waitUntil = "load"
+
+        if timeout is None:
+            timeout = self._page._timeout_settings.navigation_timeout()
+        deadline = monotonic_time() + timeout
+        waiter = self._setup_navigation_waiter("expect_navigation", timeout)
+
+        to_url = f' to "{url}"' if url else ""
+        waiter.log(f"waiting for navigation{to_url} until '{waitUntil}'")
+
+        def predicate(event: Any) -> bool:
+            # Any failed navigation results in a rejection.
+            if event.get("error"):
+                return True
+            waiter.log(f'  navigated to "{event["url"]}"')
+            return url_matches(
+                cast("Page", self._page)._browser_context._base_url,
+                event["url"],
+                url,
+            )
+
+        waiter.wait_for_event(
+            self._event_emitter,
+            "navigated",
+            predicate=predicate,
+        )
+
+        async def continuation() -> Optional[Response]:
+            event = await waiter.result()
+            if "error" in event:
+                raise Error(event["error"])
+            if waitUntil not in self._load_states:
+                t = deadline - monotonic_time()
+                if t > 0:
+                    await self._wait_for_load_state_impl(state=waitUntil, timeout=t)
+            if "newDocument" in event and "request" in event["newDocument"]:
+                request = from_channel(event["newDocument"]["request"])
+                return await request.response()
+            return None
+
+        return EventContextManagerImpl(asyncio.create_task(continuation()))
+
+    async def wait_for_url(
+        self,
+        url: URLMatch,
+        waitUntil: DocumentLoadState = None,
+        timeout: float = None,
+    ) -> None:
+        assert self._page
+        if url_matches(self._page._browser_context._base_url, self.url, url):
+            await self._wait_for_load_state_impl(state=waitUntil, timeout=timeout)
+            return
+        async with self.expect_navigation(
+            url=url, waitUntil=waitUntil, timeout=timeout
+        ):
+            pass
+
+    async def wait_for_load_state(
+        self,
+        state: Literal["domcontentloaded", "load", "networkidle"] = None,
+        timeout: float = None,
+    ) -> None:
+        return await self._wait_for_load_state_impl(state, timeout)
+
+    async def _wait_for_load_state_impl(
+        self, state: DocumentLoadState = None, timeout: float = None
+    ) -> None:
+        if not state:
+            state = "load"
+        if state not in ("load", "domcontentloaded", "networkidle", "commit"):
+            raise Error(
+                "state: expected one of (load|domcontentloaded|networkidle|commit)"
+            )
+        waiter = self._setup_navigation_waiter("wait_for_load_state", timeout)
+
+        if state in self._load_states:
+            waiter.log(f'  not waiting, "{state}" event already fired')
+            # TODO: align with upstream
+            waiter._fulfill(None)
+        else:
+
+            def handle_load_state_event(actual_state: str) -> bool:
+                waiter.log(f'"{actual_state}" event fired')
+                return actual_state == state
+
+            waiter.wait_for_event(
+                self._event_emitter,
+                "loadstate",
+                handle_load_state_event,
+            )
+        await waiter.result()
+
+    def _timeout(self, timeout: Optional[float]) -> float:
+        timeout_settings = (
+            self._page._timeout_settings if self._page else TimeoutSettings(None)
+        )
+        return timeout_settings.timeout(timeout)
+
+    def _navigation_timeout(self, timeout: Optional[float]) -> float:
+        timeout_settings = (
+            self._page._timeout_settings if self._page else TimeoutSettings(None)
+        )
+        return timeout_settings.navigation_timeout(timeout)
+
+    async def frame_element(self) -> ElementHandle:
+        return from_channel(await self._channel.send("frameElement", None))
+
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
+        return parse_result(
+            await self._channel.send(
+                "evaluateExpression",
+                None,
+                dict(
+                    expression=expression,
+                    arg=serialize_argument(arg),
+                ),
+            )
+        )
+
+    async def evaluate_handle(
+        self, expression: str, arg: Serializable = None
+    ) -> JSHandle:
+        return from_channel(
+            await self._channel.send(
+                "evaluateExpressionHandle",
+                None,
+                dict(
+                    expression=expression,
+                    arg=serialize_argument(arg),
+                ),
+            )
+        )
+
+    async def query_selector(
+        self, selector: str, strict: bool = None
+    ) -> Optional[ElementHandle]:
+        return from_nullable_channel(
+            await self._channel.send("querySelector", None, locals_to_params(locals()))
+        )
+
+    async def query_selector_all(self, selector: str) -> List[ElementHandle]:
+        return list(
+            map(
+                from_channel,
+                await self._channel.send(
+                    "querySelectorAll", None, dict(selector=selector)
+                ),
+            )
+        )
+
+    async def wait_for_selector(
+        self,
+        selector: str,
+        strict: bool = None,
+        timeout: float = None,
+        state: Literal["attached", "detached", "hidden", "visible"] = None,
+    ) -> Optional[ElementHandle]:
+        return from_nullable_channel(
+            await self._channel.send(
+                "waitForSelector", self._timeout, locals_to_params(locals())
+            )
+        )
+
+    async def is_checked(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isChecked", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_disabled(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isDisabled", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_editable(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isEditable", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_enabled(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isEnabled", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_hidden(self, selector: str, strict: bool = None) -> bool:
+        return await self._channel.send(
+            "isHidden", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_visible(self, selector: str, strict: bool = None) -> bool:
+        return await self._channel.send(
+            "isVisible", self._timeout, locals_to_params(locals())
+        )
+
+    async def dispatch_event(
+        self,
+        selector: str,
+        type: str,
+        eventInit: Dict = None,
+        strict: bool = None,
+        timeout: float = None,
+    ) -> None:
+        await self._channel.send(
+            "dispatchEvent",
+            self._timeout,
+            locals_to_params(
+                dict(
+                    selector=selector,
+                    type=type,
+                    eventInit=serialize_argument(eventInit),
+                    strict=strict,
+                    timeout=timeout,
+                ),
+            ),
+        )
+
+    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",
+                None,
+                locals_to_params(
+                    dict(
+                        selector=selector,
+                        expression=expression,
+                        arg=serialize_argument(arg),
+                        strict=strict,
+                    )
+                ),
+            )
+        )
+
+    async def eval_on_selector_all(
+        self,
+        selector: str,
+        expression: str,
+        arg: Serializable = None,
+    ) -> Any:
+        return parse_result(
+            await self._channel.send(
+                "evalOnSelectorAll",
+                None,
+                dict(
+                    selector=selector,
+                    expression=expression,
+                    arg=serialize_argument(arg),
+                ),
+            )
+        )
+
+    async def content(self) -> str:
+        return await self._channel.send("content", None)
+
+    async def set_content(
+        self,
+        html: str,
+        timeout: float = None,
+        waitUntil: DocumentLoadState = None,
+    ) -> None:
+        await self._channel.send(
+            "setContent", self._navigation_timeout, locals_to_params(locals())
+        )
+
+    @property
+    def name(self) -> str:
+        return self._name or ""
+
+    @property
+    def url(self) -> str:
+        return self._url or ""
+
+    @property
+    def parent_frame(self) -> Optional["Frame"]:
+        return self._parent_frame
+
+    @property
+    def child_frames(self) -> List["Frame"]:
+        return self._child_frames.copy()
+
+    def is_detached(self) -> bool:
+        return self._detached
+
+    async def add_script_tag(
+        self,
+        url: str = None,
+        path: Union[str, Path] = None,
+        content: str = None,
+        type: str = None,
+    ) -> ElementHandle:
+        params = locals_to_params(locals())
+        if path:
+            params["content"] = add_source_url_to_script(
+                (await async_readfile(path)).decode(), path
+            )
+            del params["path"]
+        return from_channel(await self._channel.send("addScriptTag", None, params))
+
+    async def add_style_tag(
+        self, url: str = None, path: Union[str, Path] = None, content: str = None
+    ) -> ElementHandle:
+        params = locals_to_params(locals())
+        if path:
+            params["content"] = (
+                (await async_readfile(path)).decode()
+                + "\n/*# sourceURL="
+                + str(Path(path))
+                + "*/"
+            )
+            del params["path"]
+        return from_channel(await self._channel.send("addStyleTag", None, params))
+
+    async def click(
+        self,
+        selector: str,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
+        button: MouseButton = None,
+        clickCount: int = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._click(**locals_to_params(locals()))
+
+    async def _click(
+        self,
+        selector: str,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
+        button: MouseButton = None,
+        clickCount: int = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        steps: int = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._channel.send("click", self._timeout, locals_to_params(locals()))
+
+    async def dblclick(
+        self,
+        selector: str,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
+        button: MouseButton = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._channel.send(
+            "dblclick", self._timeout, locals_to_params(locals()), title="Double click"
+        )
+
+    async def tap(
+        self,
+        selector: str,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._channel.send("tap", self._timeout, locals_to_params(locals()))
+
+    async def fill(
+        self,
+        selector: str,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
+    ) -> None:
+        await self._fill(**locals_to_params(locals()))
+
+    async def _fill(
+        self,
+        selector: str,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
+        title: str = None,
+    ) -> None:
+        await self._channel.send("fill", self._timeout, locals_to_params(locals()))
+
+    def locator(
+        self,
+        selector: str,
+        hasText: Union[str, Pattern[str]] = None,
+        hasNotText: Union[str, Pattern[str]] = None,
+        has: Locator = None,
+        hasNot: Locator = None,
+    ) -> Locator:
+        return Locator(
+            self,
+            selector,
+            has_text=hasText,
+            has_not_text=hasNotText,
+            has=has,
+            has_not=hasNot,
+        )
+
+    def get_by_alt_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_alt_text_selector(text, exact=exact))
+
+    def get_by_label(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_label_selector(text, exact=exact))
+
+    def get_by_placeholder(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_placeholder_selector(text, exact=exact))
+
+    def get_by_role(
+        self,
+        role: AriaRole,
+        checked: bool = None,
+        disabled: bool = None,
+        expanded: bool = None,
+        includeHidden: bool = None,
+        level: int = None,
+        name: Union[str, Pattern[str]] = None,
+        pressed: bool = None,
+        selected: bool = None,
+        exact: bool = None,
+        description: Union[str, Pattern[str]] = None,
+    ) -> "Locator":
+        return self.locator(
+            get_by_role_selector(
+                role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=includeHidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
+        return self.locator(get_by_test_id_selector(test_id_attribute_name(), testId))
+
+    def get_by_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_text_selector(text, exact=exact))
+
+    def get_by_title(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_title_selector(text, exact=exact))
+
+    def frame_locator(self, selector: str) -> FrameLocator:
+        return FrameLocator(self, selector)
+
+    async def focus(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> None:
+        await self._channel.send("focus", self._timeout, locals_to_params(locals()))
+
+    async def text_content(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> Optional[str]:
+        return await self._channel.send(
+            "textContent", self._timeout, locals_to_params(locals())
+        )
+
+    async def inner_text(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> str:
+        return await self._channel.send(
+            "innerText", self._timeout, locals_to_params(locals())
+        )
+
+    async def inner_html(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> str:
+        return await self._channel.send(
+            "innerHTML", self._timeout, locals_to_params(locals())
+        )
+
+    async def get_attribute(
+        self, selector: str, name: str, strict: bool = None, timeout: float = None
+    ) -> Optional[str]:
+        return await self._channel.send(
+            "getAttribute", self._timeout, locals_to_params(locals())
+        )
+
+    async def hover(
+        self,
+        selector: str,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        force: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._channel.send("hover", self._timeout, locals_to_params(locals()))
+
+    async def drag_and_drop(
+        self,
+        source: str,
+        target: str,
+        sourcePosition: Position = None,
+        targetPosition: Position = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        timeout: float = None,
+        trial: bool = None,
+        steps: int = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._channel.send(
+            "dragAndDrop", self._timeout, locals_to_params(locals())
+        )
+
+    async def select_option(
+        self,
+        selector: str,
+        value: Union[str, Sequence[str]] = None,
+        index: Union[int, Sequence[int]] = None,
+        label: Union[str, Sequence[str]] = None,
+        element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
+    ) -> List[str]:
+        params = locals_to_params(
+            dict(
+                selector=selector,
+                timeout=timeout,
+                strict=strict,
+                force=force,
+                **convert_select_option_values(value, index, label, element),
+            )
+        )
+        return await self._channel.send("selectOption", self._timeout, params)
+
+    async def input_value(
+        self,
+        selector: str,
+        strict: bool = None,
+        timeout: float = None,
+    ) -> str:
+        return await self._channel.send(
+            "inputValue", self._timeout, locals_to_params(locals())
+        )
+
+    async def set_input_files(
+        self,
+        selector: str,
+        files: Union[
+            str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
+        ],
+        strict: bool = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+    ) -> None:
+        converted = await convert_input_files(files, self.page.context)
+        await self._channel.send(
+            "setInputFiles",
+            self._timeout,
+            {
+                "selector": selector,
+                "strict": strict,
+                "timeout": self._timeout(timeout),
+                **converted,
+            },
+        )
+
+    async def _drop(
+        self,
+        selector: str,
+        payload: "DropPayload",
+        strict: bool = None,
+        position: Position = None,
+        timeout: float = None,
+    ) -> None:
+        params: Dict[str, Any] = {
+            "selector": selector,
+            "strict": strict,
+            "position": position,
+            "timeout": self._timeout(timeout),
+        }
+        files = payload.get("files") if payload else None
+        if files is not None:
+            converted = await convert_input_files(files, self.page.context)
+            if "directoryStream" in converted or "directoryLocalPath" in converted:
+                raise Error(
+                    "Dropping a directory is not supported, pass individual files instead."
+                )
+            params.update(converted)
+        data = payload.get("data") if payload else None
+        if data is not None:
+            params["data"] = [{"mimeType": k, "value": v} for k, v in data.items()]
+        await self._channel.send("drop", self._timeout, params)
+
+    async def type(
+        self,
+        selector: str,
+        text: str,
+        delay: float = None,
+        strict: bool = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+    ) -> None:
+        await self._channel.send("type", self._timeout, locals_to_params(locals()))
+
+    async def press(
+        self,
+        selector: str,
+        key: str,
+        delay: float = None,
+        strict: bool = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+    ) -> None:
+        await self._channel.send("press", self._timeout, locals_to_params(locals()))
+
+    async def check(
+        self,
+        selector: str,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._channel.send("check", self._timeout, locals_to_params(locals()))
+
+    async def uncheck(
+        self,
+        selector: str,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        await self._channel.send("uncheck", self._timeout, locals_to_params(locals()))
+
+    async def wait_for_timeout(self, timeout: float) -> None:
+        await self._channel.send("waitForTimeout", None, {"waitTimeout": timeout})
+
+    async def wait_for_function(
+        self,
+        expression: str,
+        arg: Serializable = None,
+        timeout: float = None,
+        polling: Union[float, Literal["raf"]] = None,
+    ) -> JSHandle:
+        if isinstance(polling, str) and polling != "raf":
+            raise Error(f"Unknown polling option: {polling}")
+        params = locals_to_params(locals())
+        params["arg"] = serialize_argument(arg)
+        if polling is not None and polling != "raf":
+            params["pollingInterval"] = polling
+        return from_channel(
+            await self._channel.send("waitForFunction", self._timeout, params)
+        )
+
+    async def title(self) -> str:
+        return await self._channel.send("title", None)
+
+    async def set_checked(
+        self,
+        selector: str,
+        checked: bool,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        scroll: Literal["auto", "none"] = None,
+    ) -> None:
+        if checked:
+            await self.check(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                strict=strict,
+                trial=trial,
+                scroll=scroll,
+            )
+        else:
+            await self.uncheck(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                strict=strict,
+                trial=trial,
+                scroll=scroll,
+            )
+
+    async def _highlight(self, selector: str, style: str = None) -> None:
+        await self._channel.send(
+            "highlight", None, {"selector": selector, "style": style}
+        )
+
+    async def _hide_highlight(self, selector: str) -> None:
+        await self._channel.send("hideHighlight", None, {"selector": selector})