playwright-browserstack 1.62.0__py3-none-win_amd64.whl

playwright/sync_api/_android_generated.py

@@ -0,0 +1,494 @@
+# Copyright (c) 2025 BrowserStack. All rights reserved.
+#
+# This software is the confidential and proprietary information of BrowserStack.
+# You shall not disclose such Confidential Information and shall use it only in
+# accordance with the terms of the license agreement you entered into with BrowserStack.
+
+"""BrowserStack Android API wrappers for the sync API.
+
+These wrappers are hand-maintained on purpose. Upstream marks the Android API
+as JS-only (``langs.only``), so ``scripts/generate_sync_api.py`` cannot emit
+them: ``documentation_provider.py`` filters the classes out of ``api.json`` and
+then raises ``Invalid class Android``.
+
+They deliberately live outside ``_generated.py`` because
+``scripts/update_api.sh`` runs
+``git checkout HEAD -- playwright/sync_api/_generated.py`` before
+regenerating it, so anything added there is silently dropped on the next
+upstream version bump. Anything here survives untouched.
+
+Importing this module registers the Android impl->API mapping and attaches the
+``Playwright.android`` property, so ``playwright/sync_api/__init__.py`` must
+import it.
+"""
+
+import pathlib
+import typing
+from typing import Literal
+
+from playwright._impl._android import Android as AndroidImpl
+from playwright._impl._android import AndroidDevice as AndroidDeviceImpl
+from playwright._impl._android import AndroidInput as AndroidInputImpl
+from playwright._impl._android import AndroidSocket as AndroidSocketImpl
+from playwright._impl._android import AndroidWebView as AndroidWebViewImpl
+from playwright._impl._sync_base import SyncBase, mapping
+from playwright.sync_api._generated import BrowserContext, Page, Playwright
+
+__all__ = [
+    "Android",
+    "AndroidDevice",
+    "AndroidInput",
+    "AndroidSocket",
+    "AndroidWebView",
+]
+
+# Referenced by the string annotations in the wrappers below; imported for
+# runtime type resolution, not used directly here.
+_ = (BrowserContext, Page)
+
+
+class AndroidSocket(SyncBase):
+
+    def write(self, data: bytes) -> None:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.write(data=data)))
+
+    def close(self) -> None:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
+
+
+mapping.register(AndroidSocketImpl, AndroidSocket)
+
+
+class AndroidWebView(SyncBase):
+
+    def __init__(self, impl_obj: AndroidWebViewImpl) -> None:
+        self._impl_obj = impl_obj
+        self._loop = impl_obj._device._loop
+        self._dispatcher_fiber = impl_obj._device._dispatcher_fiber
+
+    @property
+    def pid(self) -> int:
+        return self._impl_obj.pid
+
+    @property
+    def pkg(self) -> str:
+        return self._impl_obj.pkg
+
+    def page(self) -> "Page":
+        return mapping.from_impl(self._sync(self._impl_obj.page()))
+
+
+mapping.register(AndroidWebViewImpl, AndroidWebView)
+
+
+class AndroidInput(SyncBase):
+
+    def __init__(self, impl_obj: AndroidInputImpl) -> None:
+        self._impl_obj = impl_obj
+        self._loop = impl_obj._device._loop
+        self._dispatcher_fiber = impl_obj._device._dispatcher_fiber
+
+    def type(self, text: str) -> None:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.type(text=text)))
+
+    def press(self, key: str) -> None:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.press(key=key)))
+
+    def tap(self, point: typing.Dict) -> None:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.tap(point=point)))
+
+    def swipe(
+        self,
+        start: typing.Dict,
+        segments: typing.List[typing.Dict],
+        steps: int,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.swipe(start=start, segments=segments, steps=steps)
+            )
+        )
+
+    def drag(self, start: typing.Dict, end: typing.Dict, steps: int) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.drag(start=start, end=end, steps=steps))
+        )
+
+
+mapping.register(AndroidInputImpl, AndroidInput)
+
+
+class AndroidDevice(SyncBase):
+
+    @property
+    def input(self) -> "AndroidInput":
+        return mapping.from_impl(self._impl_obj.input)
+
+    @property
+    def serial(self) -> str:
+        return self._impl_obj.serial
+
+    @property
+    def model(self) -> str:
+        return self._impl_obj.model
+
+    def screenshot(
+        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+    ) -> bytes:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.screenshot(path=path)))
+
+    def shell(self, command: str) -> bytes:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.shell(command=command))
+        )
+
+    def open(self, command: str) -> "AndroidSocket":
+        return mapping.from_impl(self._sync(self._impl_obj.open(command=command)))
+
+    def install_apk(
+        self,
+        file: typing.Union[str, pathlib.Path, bytes],
+        *,
+        args: typing.Optional[typing.List[str]] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.install_apk(file=file, args=args))
+        )
+
+    def push(
+        self,
+        file: typing.Union[str, pathlib.Path, bytes],
+        path: str,
+        *,
+        mode: typing.Optional[int] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.push(file=file, path=path, mode=mode))
+        )
+
+    def launch_browser(
+        self,
+        *,
+        pkg: typing.Optional[str] = None,
+        args: typing.Optional[typing.List[str]] = None,
+        proxy: typing.Optional[typing.Dict] = None,
+        permissions: typing.Optional[typing.List[str]] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        offline: typing.Optional[bool] = None,
+        http_credentials: typing.Optional[typing.Dict] = None,
+        device_scale_factor: typing.Optional[float] = None,
+        is_mobile: typing.Optional[bool] = None,
+        has_touch: typing.Optional[bool] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        locale: typing.Optional[str] = None,
+        timezone_id: typing.Optional[str] = None,
+        geolocation: typing.Optional[typing.Dict] = None,
+        user_agent: typing.Optional[str] = None,
+        accept_downloads: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        java_script_enabled: typing.Optional[bool] = None,
+        bypass_csp: typing.Optional[bool] = None,
+        viewport: typing.Optional[typing.Dict] = None,
+        screen: typing.Optional[typing.Dict] = None,
+        no_viewport: typing.Optional[bool] = None,
+        record_video: typing.Optional[typing.Dict] = None,
+        record_har: typing.Optional[typing.Dict] = None,
+        base_url: typing.Optional[str] = None,
+        strict_selectors: typing.Optional[bool] = None,
+        service_workers: typing.Optional[Literal["allow", "block"]] = None,
+    ) -> "BrowserContext":
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.launch_browser(
+                    pkg=pkg,
+                    args=args,
+                    proxy=proxy,
+                    permissions=permissions,
+                    extraHTTPHeaders=extra_http_headers,
+                    offline=offline,
+                    httpCredentials=http_credentials,
+                    deviceScaleFactor=device_scale_factor,
+                    isMobile=is_mobile,
+                    hasTouch=has_touch,
+                    colorScheme=color_scheme,
+                    locale=locale,
+                    timezoneId=timezone_id,
+                    geolocation=geolocation,
+                    userAgent=user_agent,
+                    acceptDownloads=accept_downloads,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    javaScriptEnabled=java_script_enabled,
+                    bypassCSP=bypass_csp,
+                    viewport=viewport,
+                    screen=screen,
+                    noViewport=no_viewport,
+                    recordVideo=record_video,
+                    recordHar=record_har,
+                    baseURL=base_url,
+                    strictSelectors=strict_selectors,
+                    serviceWorkers=service_workers,
+                )
+            )
+        )
+
+    def web_views(self) -> typing.List["AndroidWebView"]:
+        return mapping.from_impl_list(self._impl_obj.web_views())
+
+    def web_view(
+        self, selector: typing.Dict, *, timeout: typing.Optional[float] = None
+    ) -> "AndroidWebView":
+        return mapping.from_impl(
+            self._sync(self._impl_obj.web_view(selector=selector, timeout=timeout))
+        )
+
+    def wait(
+        self,
+        selector: typing.Dict,
+        *,
+        state: typing.Optional[Literal["gone"]] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait(selector=selector, state=state, timeout=timeout)
+            )
+        )
+
+    def fill(
+        self,
+        selector: typing.Dict,
+        text: str,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fill(selector=selector, text=text, timeout=timeout)
+            )
+        )
+
+    def tap(
+        self,
+        selector: typing.Dict,
+        *,
+        duration: typing.Optional[float] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.tap(
+                    selector=selector, duration=duration, timeout=timeout
+                )
+            )
+        )
+
+    def long_tap(
+        self, selector: typing.Dict, *, timeout: typing.Optional[float] = None
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.long_tap(selector=selector, timeout=timeout))
+        )
+
+    def drag(
+        self,
+        selector: typing.Dict,
+        dest: typing.Dict,
+        *,
+        speed: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.drag(
+                    selector=selector, dest=dest, speed=speed, timeout=timeout
+                )
+            )
+        )
+
+    def fling(
+        self,
+        selector: typing.Dict,
+        direction: Literal["down", "left", "right", "up"],
+        *,
+        speed: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fling(
+                    selector=selector, direction=direction, speed=speed, timeout=timeout
+                )
+            )
+        )
+
+    def pinch_close(
+        self,
+        selector: typing.Dict,
+        percent: float,
+        *,
+        speed: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.pinch_close(
+                    selector=selector, percent=percent, speed=speed, timeout=timeout
+                )
+            )
+        )
+
+    def pinch_open(
+        self,
+        selector: typing.Dict,
+        percent: float,
+        *,
+        speed: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.pinch_open(
+                    selector=selector, percent=percent, speed=speed, timeout=timeout
+                )
+            )
+        )
+
+    def scroll(
+        self,
+        selector: typing.Dict,
+        direction: Literal["down", "left", "right", "up"],
+        percent: float,
+        *,
+        speed: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.scroll(
+                    selector=selector,
+                    direction=direction,
+                    percent=percent,
+                    speed=speed,
+                    timeout=timeout,
+                )
+            )
+        )
+
+    def swipe(
+        self,
+        selector: typing.Dict,
+        direction: Literal["down", "left", "right", "up"],
+        percent: float,
+        *,
+        speed: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.swipe(
+                    selector=selector,
+                    direction=direction,
+                    percent=percent,
+                    speed=speed,
+                    timeout=timeout,
+                )
+            )
+        )
+
+    def press(
+        self,
+        selector: typing.Dict,
+        key: str,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.press(selector=selector, key=key, timeout=timeout)
+            )
+        )
+
+    def info(self, selector: typing.Dict) -> typing.Dict:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.info(selector=selector))
+        )
+
+    def set_default_timeout(self, timeout: float) -> None:
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_timeout(timeout=timeout)
+        )
+
+    def wait_for_event(
+        self,
+        event: str,
+        *,
+        predicate: typing.Optional[typing.Callable] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_event(
+                    event=event, predicate=predicate, timeout=timeout
+                )
+            )
+        )
+
+    def close(self) -> None:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
+
+
+mapping.register(AndroidDeviceImpl, AndroidDevice)
+
+
+class Android(SyncBase):
+
+    def devices(
+        self, *, port: typing.Optional[int] = None
+    ) -> typing.List["AndroidDevice"]:
+        return mapping.from_impl_list(self._sync(self._impl_obj.devices(port=port)))
+
+    def set_default_timeout(self, timeout: float) -> None:
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_timeout(timeout=timeout)
+        )
+
+    def connect(
+        self,
+        ws_endpoint: str,
+        *,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        slow_mo: typing.Optional[float] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> "AndroidDevice":
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.connect(
+                    wsEndpoint=ws_endpoint,
+                    headers=headers,
+                    slowMo=slow_mo,
+                    timeout=timeout,
+                )
+            )
+        )
+
+
+mapping.register(AndroidImpl, Android)
+
+
+# Attached here rather than in _generated.py so that regenerating that file
+# cannot drop it. See the module docstring.
+def _android(self: Playwright) -> Android:
+    """Playwright.android
+
+    Android support for Playwright.
+
+    Returns
+    -------
+    Android
+    """
+    return mapping.from_impl(self._impl_obj.android)
+
+
+Playwright.android = property(_android)  # type: ignore[attr-defined]

playwright/sync_api/_context_manager.py

@@ -0,0 +1,98 @@
+# 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 typing import TYPE_CHECKING, Any, Optional, cast
+
+from greenlet import greenlet
+
+from playwright._impl._connection import ChannelOwner, Connection
+from playwright._impl._errors import Error
+from playwright._impl._greenlets import MainGreenlet
+from playwright._impl._object_factory import create_remote_object
+from playwright._impl._playwright import Playwright
+from playwright._impl._transport import PipeTransport
+from playwright.sync_api._generated import Playwright as SyncPlaywright
+
+if TYPE_CHECKING:
+    from asyncio.unix_events import AbstractChildWatcher
+
+
+class PlaywrightContextManager:
+    def __init__(self) -> None:
+        self._playwright: SyncPlaywright
+        self._loop: asyncio.AbstractEventLoop
+        self._own_loop = False
+        self._watcher: Optional[AbstractChildWatcher] = None
+        self._exit_was_called = False
+
+    def __enter__(self) -> SyncPlaywright:
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = asyncio.new_event_loop()
+            self._own_loop = True
+        if self._loop.is_running():
+            raise Error(
+                """It looks like you are using Playwright Sync API inside the asyncio loop.
+Please use the Async API instead."""
+            )
+
+        # Create a new fiber for the protocol dispatcher. It will be pumping events
+        # until the end of times. We will pass control to that fiber every time we
+        # block while waiting for a response.
+        def greenlet_main() -> None:
+            self._loop.run_until_complete(self._connection.run_as_sync())
+
+        dispatcher_fiber = MainGreenlet(greenlet_main)
+
+        self._connection = Connection(
+            dispatcher_fiber,
+            create_remote_object,
+            PipeTransport(self._loop),
+            self._loop,
+        )
+
+        g_self = greenlet.getcurrent()
+
+        def callback_wrapper(channel_owner: ChannelOwner) -> None:
+            playwright_impl = cast(Playwright, channel_owner)
+            self._playwright = SyncPlaywright(playwright_impl)
+            g_self.switch()
+
+        # Switch control to the dispatcher, it'll fire an event and pass control to
+        # the calling greenlet.
+        self._connection.call_on_object_with_known_name("Playwright", callback_wrapper)
+        dispatcher_fiber.switch()
+
+        playwright = self._playwright
+        playwright.stop = self.__exit__  # type: ignore
+        return playwright
+
+    def start(self) -> SyncPlaywright:
+        return self.__enter__()
+
+    def __exit__(self, *args: Any) -> None:
+        if self._exit_was_called:
+            return
+        self._exit_was_called = True
+        self._connection.stop_sync()
+        if self._watcher:
+            self._watcher.close()
+        if self._own_loop:
+            tasks = asyncio.all_tasks(self._loop)
+            for t in [t for t in tasks if not (t.done() or t.cancelled())]:
+                t.cancel()
+            self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+            self._loop.close()