playwright-browserstack 1.62.0__py3-none-win32.whl

playwright/_impl/_waiter.py

@@ -0,0 +1,197 @@
+# 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
+import inspect
+import math
+import uuid
+from asyncio.tasks import Task
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+from pyee import EventEmitter
+
+from playwright._impl._connection import ChannelOwner
+from playwright._impl._errors import Error, TimeoutError
+
+
+class Waiter:
+    def __init__(self, channel_owner: ChannelOwner, event: str) -> None:
+        self._result: asyncio.Future = asyncio.Future()
+        self._wait_id = uuid.uuid4().hex
+        self._loop = channel_owner._loop
+        self._pending_tasks: List[Task] = []
+        self._channel = channel_owner._channel
+        self._registered_listeners: List[Tuple[EventEmitter, str, Callable]] = []
+        self._logs: List[str] = []
+        self._wait_for_event_info_before(self._wait_id, event)
+
+    def _wait_for_event_info_before(self, wait_id: str, event: str) -> None:
+        self._send_wait_for_event_info(
+            {
+                "waitId": wait_id,
+                "phase": "before",
+                "event": event,
+            },
+            title=f'Wait for event "{event}"',
+        )
+
+    def _wait_for_event_info_after(self, wait_id: str, error: Exception = None) -> None:
+        self._send_wait_for_event_info(
+            {
+                "waitId": wait_id,
+                "phase": "after",
+                **({"error": str(error)} if error else {}),
+            },
+            is_internal=True,
+        )
+
+    def _send_wait_for_event_info(
+        self, params: Dict[str, Any], is_internal: bool = False, title: str = None
+    ) -> None:
+        # Wait info is fire-and-forget telemetry and must not affect the waiter.
+        try:
+            self._channel.send_no_reply(
+                "__waitInfo__",
+                None,
+                params,
+                is_internal=is_internal,
+                title=title,
+            )
+        except Error:
+            pass
+
+    def reject_on_event(
+        self,
+        emitter: EventEmitter,
+        event: str,
+        error: Union[Error, Callable[..., Error]],
+        predicate: Callable = None,
+    ) -> None:
+        def on_match() -> None:
+            self._reject(error() if callable(error) else error)
+
+        def listener(event_data: Any = None) -> None:
+            self._evaluate_predicate(predicate, event_data, on_match)
+
+        emitter.on(event, listener)
+        self._registered_listeners.append((emitter, event, listener))
+
+    def reject_on_timeout(self, timeout: float, message: str) -> None:
+        if timeout == 0:
+            return
+
+        async def reject() -> None:
+            await asyncio.sleep(timeout / 1000)
+            self._reject(TimeoutError(message))
+
+        self._pending_tasks.append(self._loop.create_task(reject()))
+
+    def _cleanup(self) -> None:
+        for task in self._pending_tasks:
+            if not task.done():
+                task.cancel()
+        for listener in self._registered_listeners:
+            listener[0].remove_listener(listener[1], listener[2])
+
+    def _fulfill(self, result: Any) -> None:
+        self._cleanup()
+        if not self._result.done():
+            self._result.set_result(result)
+        self._wait_for_event_info_after(self._wait_id)
+
+    def _reject(self, exception: Exception) -> None:
+        self._cleanup()
+        if exception:
+            base_class = TimeoutError if isinstance(exception, TimeoutError) else Error
+            exception = base_class(str(exception) + format_log_recording(self._logs))
+        if not self._result.done():
+            self._result.set_exception(exception)
+        self._wait_for_event_info_after(self._wait_id, exception)
+
+    def wait_for_event(
+        self,
+        emitter: EventEmitter,
+        event: str,
+        predicate: Callable = None,
+    ) -> None:
+        def listener(event_data: Any = None) -> None:
+            self._evaluate_predicate(
+                predicate, event_data, lambda: self._fulfill(event_data)
+            )
+
+        emitter.on(event, listener)
+        self._registered_listeners.append((emitter, event, listener))
+
+    def _evaluate_predicate(
+        self,
+        predicate: Optional[Callable],
+        event_data: Any,
+        on_match: Callable[[], None],
+    ) -> None:
+        if predicate is None:
+            on_match()
+            return
+        try:
+            result = predicate(event_data)
+        except Exception as e:
+            self._reject(e)
+            return
+        if inspect.iscoroutine(result):
+
+            async def _await_predicate(coro: Any) -> None:
+                try:
+                    matched = await coro
+                except Exception as e:
+                    self._reject(e)
+                    return
+                if matched and not self._result.done():
+                    on_match()
+
+            self._pending_tasks.append(self._loop.create_task(_await_predicate(result)))
+            return
+        if result:
+            on_match()
+
+    def result(self) -> asyncio.Future:
+        return self._result
+
+    def log(self, message: str) -> None:
+        self._logs.append(message)
+        self._send_wait_for_event_info(
+            {
+                "waitId": self._wait_id,
+                "phase": "log",
+                "message": message,
+            },
+            is_internal=True,
+        )
+
+
+def throw_on_timeout(timeout: float, exception: Exception) -> asyncio.Task:
+    async def throw() -> None:
+        await asyncio.sleep(timeout / 1000)
+        raise exception
+
+    return asyncio.create_task(throw())
+
+
+def format_log_recording(log: List[str]) -> str:
+    if not log:
+        return ""
+    header = " logs "
+    header_length = 60
+    left_length = math.floor((header_length - len(header)) / 2)
+    right_length = header_length - len(header) - left_length
+    new_line = "\n"
+    return f"{new_line}{'=' * left_length}{header}{'=' * right_length}{new_line}{new_line.join(log)}{new_line}{'=' * header_length}"

playwright/_impl/_web_error.py

@@ -0,0 +1,48 @@
+# 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.
+
+from asyncio import AbstractEventLoop
+from typing import Any, Optional
+
+from playwright._impl._api_structures import WebErrorLocation
+from playwright._impl._helper import Error
+from playwright._impl._page import Page
+
+
+class WebError:
+    def __init__(
+        self,
+        loop: AbstractEventLoop,
+        dispatcher_fiber: Any,
+        page: Optional[Page],
+        error: Error,
+        location: WebErrorLocation,
+    ) -> None:
+        self._loop = loop
+        self._dispatcher_fiber = dispatcher_fiber
+        self._page = page
+        self._error = error
+        self._location = location
+
+    @property
+    def page(self) -> Optional[Page]:
+        return self._page
+
+    @property
+    def error(self) -> Error:
+        return self._error
+
+    @property
+    def location(self) -> WebErrorLocation:
+        return self._location

playwright/_impl/_web_storage.py

@@ -0,0 +1,58 @@
+# 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.
+
+from typing import TYPE_CHECKING, List, Literal, Optional
+
+from playwright._impl._api_structures import NameValue
+
+if TYPE_CHECKING:
+    from playwright._impl._page import Page
+
+
+WebStorageKind = Literal["local", "session"]
+
+
+class WebStorage:
+    def __init__(self, page: "Page", kind: WebStorageKind) -> None:
+        self._page = page
+        self._kind = kind
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+
+    async def items(self) -> List[NameValue]:
+        result = await self._page._channel.send_return_as_dict(
+            "webStorageItems", None, {"kind": self._kind}
+        )
+        return (result or {}).get("items", [])
+
+    async def get_item(self, name: str) -> Optional[str]:
+        result = await self._page._channel.send_return_as_dict(
+            "webStorageGetItem", None, {"kind": self._kind, "name": name}
+        )
+        return (result or {}).get("value")
+
+    async def set_item(self, name: str, value: str) -> None:
+        await self._page._channel.send(
+            "webStorageSetItem",
+            None,
+            {"kind": self._kind, "name": name, "value": value},
+        )
+
+    async def remove_item(self, name: str) -> None:
+        await self._page._channel.send(
+            "webStorageRemoveItem", None, {"kind": self._kind, "name": name}
+        )
+
+    async def clear(self) -> None:
+        await self._page._channel.send("webStorageClear", None, {"kind": self._kind})

playwright/_impl/_writable_stream.py

@@ -0,0 +1,42 @@
+# 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 base64
+import os
+from pathlib import Path
+from typing import Dict, Union
+
+from playwright._impl._connection import ChannelOwner
+
+# COPY_BUFSIZE is taken from shutil.py in the standard library
+_WINDOWS = os.name == "nt"
+COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 64 * 1024
+
+
+class WritableStream(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def copy(self, path: Union[str, Path]) -> None:
+        with open(path, "rb") as f:
+            while True:
+                data = f.read(COPY_BUFSIZE)
+                if not data:
+                    break
+                await self._channel.send(
+                    "write", None, {"binary": base64.b64encode(data).decode()}
+                )
+        await self._channel.send("close", None)

playwright/_repo_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.62.0'
+__version_tuple__ = version_tuple = (1, 62, 0)
+
+__commit_id__ = commit_id = 'gd1456f41f'

playwright/async_api/__init__.py

@@ -0,0 +1,275 @@
+# Copyright (c) Microsoft Corporation.
+# Modifications Copyright 2025 BrowserStack
+#
+# 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.
+
+"""
+Python package `playwright` is a Python library to automate Chromium,
+Firefox and WebKit with a single API. Playwright is built to enable cross-browser
+web automation that is ever-green, capable, reliable and fast.
+"""
+
+from typing import Any, Optional, Union, overload
+
+import playwright._impl._api_structures
+import playwright._impl._errors
+import playwright._impl._form_data
+import playwright.async_api._generated
+from playwright._impl._assertions import (
+    APIResponseAssertions as APIResponseAssertionsImpl,
+)
+from playwright._impl._assertions import LocatorAssertions as LocatorAssertionsImpl
+from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
+from playwright.async_api._android_generated import (
+    Android,
+    AndroidDevice,
+    AndroidInput,
+    AndroidSocket,
+    AndroidWebView,
+)
+from playwright.async_api._context_manager import PlaywrightContextManager
+from playwright.async_api._generated import (
+    APIRequest,
+    APIRequestContext,
+    APIResponse,
+    APIResponseAssertions,
+    Browser,
+    BrowserContext,
+    BrowserType,
+    CDPSession,
+    ConsoleMessage,
+    Dialog,
+    Download,
+    ElementHandle,
+    FileChooser,
+    Frame,
+    FrameLocator,
+    JSHandle,
+    Keyboard,
+    Locator,
+    LocatorAssertions,
+    Mouse,
+    Page,
+    PageAssertions,
+    Playwright,
+    Request,
+    Response,
+    Route,
+    Selectors,
+    Touchscreen,
+    Video,
+    WebError,
+    WebSocket,
+    WebSocketRoute,
+    Worker,
+)
+
+ChromiumBrowserContext = BrowserContext
+
+Cookie = playwright._impl._api_structures.Cookie
+FilePayload = playwright._impl._api_structures.FilePayload
+FormData = playwright._impl._form_data.FormData
+FloatRect = playwright._impl._api_structures.FloatRect
+Geolocation = playwright._impl._api_structures.Geolocation
+HttpCredentials = playwright._impl._api_structures.HttpCredentials
+BrowserBindResult = playwright._impl._api_structures.BrowserBindResult
+DebuggerLocation = playwright._impl._api_structures.DebuggerLocation
+DebuggerPausedDetails = playwright._impl._api_structures.DebuggerPausedDetails
+PdfMargins = playwright._impl._api_structures.PdfMargins
+Position = playwright._impl._api_structures.Position
+ProxySettings = playwright._impl._api_structures.ProxySettings
+ResourceTiming = playwright._impl._api_structures.ResourceTiming
+ScreencastFrame = playwright._impl._api_structures.ScreencastFrame
+ScreencastSize = playwright._impl._api_structures.ScreencastSize
+SourceLocation = playwright._impl._api_structures.SourceLocation
+StorageState = playwright._impl._api_structures.StorageState
+StorageStateCookie = playwright._impl._api_structures.StorageStateCookie
+ViewportSize = playwright._impl._api_structures.ViewportSize
+VirtualCredential = playwright._impl._api_structures.VirtualCredential
+
+Error = playwright._impl._errors.Error
+TimeoutError = playwright._impl._errors.TimeoutError
+
+
+def async_playwright() -> PlaywrightContextManager:
+    return PlaywrightContextManager()
+
+
+class Expect:
+    _unset: Any = object()
+
+    def __init__(self) -> None:
+        self._timeout: Optional[float] = None
+
+    def set_options(self, timeout: Optional[float] = _unset) -> None:
+        """
+        This method sets global `expect()` options.
+
+        Args:
+            timeout (float): Timeout value in milliseconds. Default to 5000 milliseconds.
+
+        Returns:
+            None
+        """
+        if timeout is not self._unset:
+            self._timeout = timeout
+
+    @overload
+    def __call__(
+        self, actual: Page, message: Optional[str] = None
+    ) -> PageAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: Locator, message: Optional[str] = None
+    ) -> LocatorAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: APIResponse, message: Optional[str] = None
+    ) -> APIResponseAssertions: ...
+
+    def __call__(
+        self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        return self._dispatch(actual, message, is_soft=False)
+
+    @overload
+    def soft(self, actual: Page, message: Optional[str] = None) -> PageAssertions: ...
+
+    @overload
+    def soft(
+        self, actual: Locator, message: Optional[str] = None
+    ) -> LocatorAssertions: ...
+
+    @overload
+    def soft(
+        self, actual: APIResponse, message: Optional[str] = None
+    ) -> APIResponseAssertions: ...
+
+    def soft(
+        self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        """
+        Creates a [soft assertion](https://playwright.dev/python/docs/test-assertions#soft-assertions).
+        Failing soft assertions do not abort test execution, but mark the test
+        as failed. Multiple failures from the same test are surfaced together
+        at the end of the test.
+
+        Requires the [pytest-playwright](https://pypi.org/project/pytest-playwright/)
+        plugin to establish the per-test scope that collects soft assertion
+        failures.
+        """
+        return self._dispatch(actual, message, is_soft=True)
+
+    def _dispatch(
+        self,
+        actual: Union[Page, Locator, APIResponse],
+        message: Optional[str],
+        is_soft: bool,
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        if isinstance(actual, Page):
+            return PageAssertions(
+                PageAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        elif isinstance(actual, Locator):
+            return LocatorAssertions(
+                LocatorAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        elif isinstance(actual, APIResponse):
+            return APIResponseAssertions(
+                APIResponseAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        raise ValueError(f"Unsupported type: {type(actual)}")
+
+
+expect = Expect()
+
+
+__all__ = [
+    "expect",
+    "async_playwright",
+    "Android",
+    "AndroidDevice",
+    "AndroidInput",
+    "AndroidSocket",
+    "AndroidWebView",
+    "APIRequest",
+    "APIRequestContext",
+    "APIResponse",
+    "Browser",
+    "BrowserBindResult",
+    "BrowserContext",
+    "BrowserType",
+    "CDPSession",
+    "ChromiumBrowserContext",
+    "ConsoleMessage",
+    "Cookie",
+    "Dialog",
+    "Download",
+    "ElementHandle",
+    "Error",
+    "FileChooser",
+    "FilePayload",
+    "FloatRect",
+    "FormData",
+    "Frame",
+    "FrameLocator",
+    "Geolocation",
+    "HttpCredentials",
+    "JSHandle",
+    "Keyboard",
+    "Locator",
+    "Mouse",
+    "DebuggerLocation",
+    "DebuggerPausedDetails",
+    "Page",
+    "PdfMargins",
+    "Position",
+    "Playwright",
+    "ProxySettings",
+    "Request",
+    "ResourceTiming",
+    "Response",
+    "Route",
+    "ScreencastFrame",
+    "ScreencastSize",
+    "Selectors",
+    "SourceLocation",
+    "StorageState",
+    "StorageStateCookie",
+    "TimeoutError",
+    "Touchscreen",
+    "Video",
+    "ViewportSize",
+    "VirtualCredential",
+    "WebError",
+    "WebSocket",
+    "WebSocketRoute",
+    "Worker",
+]