playwright-browserstack 1.62.0__py3-none-win_amd64.whl

playwright/async_api/_android_generated.py

@@ -0,0 +1,462 @@
+# 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 async API.
+
+These wrappers are hand-maintained on purpose. Upstream marks the Android API
+as JS-only (``langs.only``), so ``scripts/generate_async_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/async_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/async_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._async_base import AsyncBase, mapping
+from playwright.async_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(AsyncBase):
+
+    async def write(self, data: bytes) -> None:
+        return mapping.from_maybe_impl(await self._impl_obj.write(data=data))
+
+    async def close(self) -> None:
+        return mapping.from_maybe_impl(await self._impl_obj.close())
+
+
+mapping.register(AndroidSocketImpl, AndroidSocket)
+
+
+class AndroidWebView(AsyncBase):
+
+    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
+
+    async def page(self) -> "Page":
+        return mapping.from_impl(await self._impl_obj.page())
+
+
+mapping.register(AndroidWebViewImpl, AndroidWebView)
+
+
+class AndroidInput(AsyncBase):
+
+    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
+
+    async def type(self, text: str) -> None:
+        return mapping.from_maybe_impl(await self._impl_obj.type(text=text))
+
+    async def press(self, key: str) -> None:
+        return mapping.from_maybe_impl(await self._impl_obj.press(key=key))
+
+    async def tap(self, point: typing.Dict) -> None:
+        return mapping.from_maybe_impl(await self._impl_obj.tap(point=point))
+
+    async def swipe(
+        self,
+        start: typing.Dict,
+        segments: typing.List[typing.Dict],
+        steps: int,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.swipe(start=start, segments=segments, steps=steps)
+        )
+
+    async def drag(self, start: typing.Dict, end: typing.Dict, steps: int) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.drag(start=start, end=end, steps=steps)
+        )
+
+
+mapping.register(AndroidInputImpl, AndroidInput)
+
+
+class AndroidDevice(AsyncBase):
+
+    @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
+
+    async def screenshot(
+        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+    ) -> bytes:
+        return mapping.from_maybe_impl(await self._impl_obj.screenshot(path=path))
+
+    async def shell(self, command: str) -> bytes:
+        return mapping.from_maybe_impl(await self._impl_obj.shell(command=command))
+
+    async def open(self, command: str) -> "AndroidSocket":
+        return mapping.from_impl(await self._impl_obj.open(command=command))
+
+    async def install_apk(
+        self,
+        file: typing.Union[str, pathlib.Path, bytes],
+        *,
+        args: typing.Optional[typing.List[str]] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.install_apk(file=file, args=args)
+        )
+
+    async def push(
+        self,
+        file: typing.Union[str, pathlib.Path, bytes],
+        path: str,
+        *,
+        mode: typing.Optional[int] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.push(file=file, path=path, mode=mode)
+        )
+
+    async 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(
+            await 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,
+            )
+        )
+
+    async def web_views(self) -> typing.List["AndroidWebView"]:
+        return mapping.from_impl_list(self._impl_obj.web_views())
+
+    async def web_view(
+        self, selector: typing.Dict, *, timeout: typing.Optional[float] = None
+    ) -> "AndroidWebView":
+        return mapping.from_impl(
+            await self._impl_obj.web_view(selector=selector, timeout=timeout)
+        )
+
+    async def wait(
+        self,
+        selector: typing.Dict,
+        *,
+        state: typing.Optional[Literal["gone"]] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait(selector=selector, state=state, timeout=timeout)
+        )
+
+    async def fill(
+        self,
+        selector: typing.Dict,
+        text: str,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.fill(selector=selector, text=text, timeout=timeout)
+        )
+
+    async def tap(
+        self,
+        selector: typing.Dict,
+        *,
+        duration: typing.Optional[float] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.tap(
+                selector=selector, duration=duration, timeout=timeout
+            )
+        )
+
+    async def long_tap(
+        self, selector: typing.Dict, *, timeout: typing.Optional[float] = None
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.long_tap(selector=selector, timeout=timeout)
+        )
+
+    async 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(
+            await self._impl_obj.drag(
+                selector=selector, dest=dest, speed=speed, timeout=timeout
+            )
+        )
+
+    async 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(
+            await self._impl_obj.fling(
+                selector=selector, direction=direction, speed=speed, timeout=timeout
+            )
+        )
+
+    async 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(
+            await self._impl_obj.pinch_close(
+                selector=selector, percent=percent, speed=speed, timeout=timeout
+            )
+        )
+
+    async 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(
+            await self._impl_obj.pinch_open(
+                selector=selector, percent=percent, speed=speed, timeout=timeout
+            )
+        )
+
+    async 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(
+            await self._impl_obj.scroll(
+                selector=selector,
+                direction=direction,
+                percent=percent,
+                speed=speed,
+                timeout=timeout,
+            )
+        )
+
+    async 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(
+            await self._impl_obj.swipe(
+                selector=selector,
+                direction=direction,
+                percent=percent,
+                speed=speed,
+                timeout=timeout,
+            )
+        )
+
+    async def press(
+        self,
+        selector: typing.Dict,
+        key: str,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.press(selector=selector, key=key, timeout=timeout)
+        )
+
+    async def info(self, selector: typing.Dict) -> typing.Dict:
+        return mapping.from_maybe_impl(await 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)
+        )
+
+    async 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(
+            await self._impl_obj.wait_for_event(
+                event=event, predicate=predicate, timeout=timeout
+            )
+        )
+
+    async def close(self) -> None:
+        return mapping.from_maybe_impl(await self._impl_obj.close())
+
+
+mapping.register(AndroidDeviceImpl, AndroidDevice)
+
+
+class Android(AsyncBase):
+
+    async def devices(
+        self, *, port: typing.Optional[int] = None
+    ) -> typing.List["AndroidDevice"]:
+        return mapping.from_impl_list(await 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)
+        )
+
+    async 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(
+            await 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/async_api/_context_manager.py

@@ -0,0 +1,57 @@
+# 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 Any
+
+from playwright._impl._connection import Connection
+from playwright._impl._object_factory import create_remote_object
+from playwright._impl._transport import PipeTransport
+from playwright.async_api._generated import Playwright as AsyncPlaywright
+
+
+class PlaywrightContextManager:
+    def __init__(self) -> None:
+        self._connection: Connection
+        self._exit_was_called = False
+
+    async def __aenter__(self) -> AsyncPlaywright:
+        loop = asyncio.get_running_loop()
+        self._connection = Connection(
+            None,
+            create_remote_object,
+            PipeTransport(loop),
+            loop,
+        )
+        loop.create_task(self._connection.run())
+        playwright_future = self._connection.playwright_future
+
+        done, _ = await asyncio.wait(
+            {self._connection._transport.on_error_future, playwright_future},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if not playwright_future.done():
+            playwright_future.cancel()
+        playwright = AsyncPlaywright(next(iter(done)).result())
+        playwright.stop = self.__aexit__  # type: ignore
+        return playwright
+
+    async def start(self) -> AsyncPlaywright:
+        return await self.__aenter__()
+
+    async def __aexit__(self, *args: Any) -> None:
+        if self._exit_was_called:
+            return
+        self._exit_was_called = True
+        await self._connection.stop_async()