playwright-browserstack 1.62.0__py3-none-win32.whl

playwright/_impl/_path_utils.py

@@ -0,0 +1,27 @@
+# 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 inspect
+from pathlib import Path
+from types import FrameType
+from typing import cast
+
+
+def get_file_dirname() -> Path:
+    """Returns the callee (`__file__`) directory name"""
+    frame = cast(FrameType, inspect.currentframe()).f_back
+    module = inspect.getmodule(frame)
+    assert module
+    assert module.__file__
+    return Path(module.__file__).parent.absolute()

playwright/_impl/_playwright.py

@@ -0,0 +1,68 @@
+# 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.
+
+from typing import Dict
+
+from playwright._impl._android import Android
+from playwright._impl._browser_type import BrowserType
+from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._fetch import APIRequest
+from playwright._impl._selectors import Selectors
+
+
+class Playwright(ChannelOwner):
+    devices: Dict
+    selectors: Selectors
+    chromium: BrowserType
+    firefox: BrowserType
+    webkit: BrowserType
+    request: APIRequest
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self.request = APIRequest(self)
+        self.chromium = from_channel(initializer["chromium"])
+        self.chromium._playwright = self
+        self.firefox = from_channel(initializer["firefox"])
+        self.firefox._playwright = self
+        self.webkit = from_channel(initializer["webkit"])
+        self.webkit._playwright = self
+
+        self.selectors = Selectors(self._loop, self._dispatcher_fiber)
+
+        self.devices = self._connection.local_utils.devices
+        # Deliberately not annotated at class level: scripts/generate_api.py
+        # discovers members via get_type_hints(), and an `android` annotation
+        # makes it emit a property into _generated.py that references the
+        # undefined name "Android" there. See RELEASING.md section 9.
+        self.android: "Android" = from_channel(initializer["android"])
+        self.android._playwright = self
+
+    def __getitem__(self, value: str) -> "BrowserType":
+        if value == "chromium":
+            return self.chromium
+        elif value == "firefox":
+            return self.firefox
+        elif value == "webkit":
+            return self.webkit
+        raise ValueError("Invalid browser " + value)
+
+    def _set_selectors(self, selectors: Selectors) -> None:
+        self.selectors = selectors
+
+    async def stop(self) -> None:
+        pass

playwright/_impl/_screencast.py

@@ -0,0 +1,177 @@
+# 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
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Union
+
+from playwright._impl._api_structures import ScreencastFrame, ScreencastSize
+from playwright._impl._artifact import Artifact
+from playwright._impl._connection import from_nullable_channel
+from playwright._impl._disposable import DisposableStub
+from playwright._impl._errors import Error
+from playwright._impl._helper import locals_to_params
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
+
+
+ScreencastFrameCallback = Callable[[ScreencastFrame], Any]
+ScreencastPosition = Literal[
+    "bottom",
+    "bottom-left",
+    "bottom-right",
+    "top",
+    "top-left",
+    "top-right",
+]
+ScreencastCursor = Literal[
+    "none",
+    "pointer",
+]
+
+
+class Screencast:
+    def __init__(self, page: "Page") -> None:
+        self._page = page
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+        self._started = False
+        self._save_path: Optional[Union[str, Path]] = None
+        self._on_frame: Optional[ScreencastFrameCallback] = None
+        self._artifact: Optional[Artifact] = None
+        page._channel.on("screencastFrame", self._dispatch_frame)
+
+    def _ack_frame(self, frame_id: int) -> None:
+        try:
+            self._page._channel.send_no_reply(
+                "screencastFrameAck", None, {"frameId": frame_id}
+            )
+        except (Error, OSError):
+            pass
+
+    async def _await_callback_and_ack(self, result: Any, frame_id: int) -> None:
+        try:
+            await result
+        finally:
+            self._ack_frame(frame_id)
+
+    def _dispatch_frame(self, params: dict) -> Any:
+        result = None
+        task = None
+        try:
+            if not self._on_frame:
+                return
+            data = params["data"]
+            if isinstance(data, str):
+                data = base64.b64decode(data)
+            result = self._on_frame(
+                {
+                    "data": data,
+                    "timestamp": params.get("timestamp", 0),
+                    "viewportWidth": params["viewportWidth"],
+                    "viewportHeight": params["viewportHeight"],
+                }
+            )
+        finally:
+            if hasattr(result, "__await__"):
+                task = self._loop.create_task(
+                    self._await_callback_and_ack(result, params["frameId"])
+                )
+            else:
+                self._ack_frame(params["frameId"])
+        return task
+
+    async def start(
+        self,
+        onFrame: ScreencastFrameCallback = None,
+        path: Union[str, Path] = None,
+        quality: int = None,
+        size: ScreencastSize = None,
+    ) -> DisposableStub:
+        if self._started:
+            raise Error("Screencast is already started")
+        self._started = True
+        self._on_frame = onFrame
+        result = await self._page._channel.send_return_as_dict(
+            "screencastStart",
+            None,
+            {
+                "size": size,
+                "quality": quality,
+                "sendFrames": bool(onFrame),
+                "record": bool(path),
+            },
+        )
+        artifact_channel = (result or {}).get("artifact")
+        if artifact_channel:
+            self._artifact = from_nullable_channel(artifact_channel)
+            self._save_path = path
+        return DisposableStub(lambda: self.stop(), self._page)
+
+    async def stop(self) -> None:
+        self._started = False
+        self._on_frame = None
+        await self._page._channel.send("screencastStop", None)
+        if self._save_path and self._artifact:
+            await self._artifact.save_as(self._save_path)
+        self._artifact = None
+        self._save_path = None
+
+    async def show_actions(
+        self,
+        duration: float = None,
+        position: ScreencastPosition = None,
+        fontSize: int = None,
+        cursor: ScreencastCursor = None,
+    ) -> DisposableStub:
+        await self._page._channel.send(
+            "screencastShowActions", None, locals_to_params(locals())
+        )
+        return DisposableStub(lambda: self.hide_actions(), self._page)
+
+    async def hide_actions(self) -> None:
+        await self._page._channel.send("screencastHideActions", None)
+
+    async def show_overlay(self, html: str, duration: float = None) -> DisposableStub:
+        result = await self._page._channel.send_return_as_dict(
+            "screencastShowOverlay", None, locals_to_params(locals())
+        )
+        overlay_id = (result or {}).get("id")
+        return DisposableStub(
+            lambda: self._page._channel.send(
+                "screencastRemoveOverlay", None, {"id": overlay_id}
+            ),
+            self._page,
+        )
+
+    async def show_chapter(
+        self,
+        title: str,
+        description: str = None,
+        duration: float = None,
+    ) -> None:
+        await self._page._channel.send(
+            "screencastChapter", None, locals_to_params(locals())
+        )
+
+    async def show_overlays(self) -> None:
+        await self._page._channel.send(
+            "screencastSetOverlayVisible", None, {"visible": True}
+        )
+
+    async def hide_overlays(self) -> None:
+        await self._page._channel.send(
+            "screencastSetOverlayVisible", None, {"visible": False}
+        )

playwright/_impl/_selectors.py

@@ -0,0 +1,67 @@
+# 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 Any, Dict, List, Optional, Set, Union
+
+from playwright._impl._browser_context import BrowserContext
+from playwright._impl._errors import Error
+from playwright._impl._helper import async_readfile
+from playwright._impl._locator import set_test_id_attribute_name
+
+
+class Selectors:
+    def __init__(self, loop: asyncio.AbstractEventLoop, dispatcher_fiber: Any) -> None:
+        self._loop = loop
+        self._contexts_for_selectors: Set[BrowserContext] = set()
+        self._selector_engines: List[Dict] = []
+        self._dispatcher_fiber = dispatcher_fiber
+        self._test_id_attribute_name: Optional[str] = None
+
+    async def register(
+        self,
+        name: str,
+        script: str = None,
+        path: Union[str, Path] = None,
+        contentScript: bool = None,
+    ) -> None:
+        if any(engine for engine in self._selector_engines if engine["name"] == name):
+            raise Error(
+                f'Selectors.register: "{name}" selector engine has been already registered'
+            )
+        if not script and not path:
+            raise Error("Either source or path should be specified")
+        if path:
+            script = (await async_readfile(path)).decode()
+        engine: Dict[str, Any] = dict(name=name, source=script)
+        if contentScript:
+            engine["contentScript"] = contentScript
+        for context in self._contexts_for_selectors:
+            await context._channel.send(
+                "registerSelectorEngine",
+                None,
+                {"selectorEngine": engine},
+            )
+        self._selector_engines.append(engine)
+
+    def set_test_id_attribute(self, attributeName: str) -> None:
+        set_test_id_attribute_name(attributeName)
+        self._test_id_attribute_name = attributeName
+        for context in self._contexts_for_selectors:
+            context._channel.send_no_reply(
+                "setTestIdAttributeName",
+                None,
+                {"testIdAttributeName": attributeName},
+            )

playwright/_impl/_set_input_files_helpers.py

@@ -0,0 +1,158 @@
+# 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 collections.abc
+import os
+import stat
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypedDict,
+    Union,
+    cast,
+)
+
+from playwright._impl._connection import Channel, from_channel
+from playwright._impl._helper import Error
+from playwright._impl._writable_stream import WritableStream
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._browser_context import BrowserContext
+
+from playwright._impl._api_structures import FilePayload
+
+SIZE_LIMIT_IN_BYTES = 50 * 1024 * 1024
+
+
+class InputFilesList(TypedDict, total=False):
+    streams: Optional[List[Channel]]
+    directoryStream: Optional[Channel]
+    localDirectory: Optional[str]
+    localPaths: Optional[List[str]]
+    payloads: Optional[List[Dict[str, Union[str, bytes]]]]
+
+
+def _list_files(directory: str) -> List[str]:
+    files = []
+    for root, _, filenames in os.walk(directory):
+        for filename in filenames:
+            files.append(os.path.join(root, filename))
+    return files
+
+
+async def convert_input_files(
+    files: Union[
+        str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
+    ],
+    context: "BrowserContext",
+) -> InputFilesList:
+    items = (
+        files
+        if isinstance(files, collections.abc.Sequence) and not isinstance(files, str)
+        else [files]
+    )
+
+    if any([isinstance(item, (str, Path)) for item in items]):
+        if not all([isinstance(item, (str, Path)) for item in items]):
+            raise Error("File paths cannot be mixed with buffers")
+
+        (local_paths, local_directory) = resolve_paths_and_directory_for_input_files(
+            cast(Sequence[Union[str, Path]], items)
+        )
+
+        if context._channel._connection.is_remote:
+            files_to_stream = cast(
+                List[str],
+                (_list_files(local_directory) if local_directory else local_paths),
+            )
+            streams = []
+            result = await context._connection.wrap_api_call(
+                lambda: context._channel.send_return_as_dict(
+                    "createTempFiles",
+                    None,
+                    {
+                        "rootDirName": (
+                            os.path.basename(local_directory)
+                            if local_directory
+                            else None
+                        ),
+                        "items": list(
+                            map(
+                                lambda file: dict(
+                                    name=(
+                                        os.path.relpath(file, local_directory)
+                                        if local_directory
+                                        else os.path.basename(file)
+                                    ),
+                                    lastModifiedMs=int(os.path.getmtime(file) * 1000),
+                                ),
+                                files_to_stream,
+                            )
+                        ),
+                    },
+                )
+            )
+            for i, file in enumerate(result["writableStreams"]):
+                stream: WritableStream = from_channel(file)
+                await stream.copy(files_to_stream[i])
+                streams.append(stream._channel)
+            return InputFilesList(
+                streams=None if local_directory else streams,
+                directoryStream=result.get("rootDir"),
+            )
+        return InputFilesList(localPaths=local_paths, localDirectory=local_directory)
+
+    file_payload_exceeds_size_limit = (
+        sum([len(f.get("buffer", "")) for f in items if not isinstance(f, (str, Path))])
+        > SIZE_LIMIT_IN_BYTES
+    )
+    if file_payload_exceeds_size_limit:
+        raise Error(
+            "Cannot set buffer larger than 50Mb, please write it to a file and pass its path instead."
+        )
+
+    return InputFilesList(
+        payloads=[
+            {
+                "name": item["name"],
+                "mimeType": item["mimeType"],
+                "buffer": base64.b64encode(item["buffer"]).decode(),
+            }
+            for item in cast(List[FilePayload], items)
+        ]
+    )
+
+
+def resolve_paths_and_directory_for_input_files(
+    items: Sequence[Union[str, Path]],
+) -> Tuple[Optional[List[str]], Optional[str]]:
+    local_paths: Optional[List[str]] = None
+    local_directory: Optional[str] = None
+    for item in items:
+        item_stat = os.stat(item)  # Raises FileNotFoundError if doesn't exist
+        if stat.S_ISDIR(item_stat.st_mode):
+            if local_directory:
+                raise Error("Multiple directories are not supported")
+            local_directory = str(Path(item).resolve())
+        else:
+            local_paths = local_paths or []
+            local_paths.append(str(Path(item).resolve()))
+    if local_paths and local_directory:
+        raise Error("File paths must be all files or a single directory")
+    return (local_paths, local_directory)

playwright/_impl/_str_utils.py

@@ -0,0 +1,76 @@
+# 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 json
+import re
+from typing import Pattern, Union
+
+
+def escape_regex_flags(pattern: Pattern) -> str:
+    flags = ""
+    if pattern.flags != 0:
+        flags = ""
+    if (pattern.flags & int(re.IGNORECASE)) != 0:
+        flags += "i"
+    if (pattern.flags & int(re.DOTALL)) != 0:
+        flags += "s"
+    if (pattern.flags & int(re.MULTILINE)) != 0:
+        flags += "m"
+    assert (
+        pattern.flags
+        & ~(int(re.MULTILINE) | int(re.IGNORECASE) | int(re.DOTALL) | int(re.UNICODE))
+        == 0
+    ), "Unexpected re.Pattern flag, only MULTILINE, IGNORECASE and DOTALL are supported."
+    return flags
+
+
+def escape_for_regex(text: str) -> str:
+    return re.sub(r"[.*+?^>${}()|[\]\\]", "\\$&", text)
+
+
+def escape_regex_for_selector(text: Pattern) -> str:
+    # Even number of backslashes followed by the quote -> insert a backslash.
+    return (
+        "/"
+        + re.sub(r'(^|[^\\])(\\\\)*(["\'`])', r"\1\2\\\3", text.pattern).replace(
+            ">>", "\\>\\>"
+        )
+        + "/"
+        + escape_regex_flags(text)
+    )
+
+
+def escape_for_text_selector(
+    text: Union[str, Pattern[str]], exact: bool = None, case_sensitive: bool = None
+) -> str:
+    if isinstance(text, Pattern):
+        return escape_regex_for_selector(text)
+    return json.dumps(text) + ("s" if exact else "i")
+
+
+def escape_for_attribute_selector(
+    value: Union[str, Pattern], exact: bool = None
+) -> str:
+    if isinstance(value, Pattern):
+        return escape_regex_for_selector(value)
+    # TODO: this should actually be
+    #   cssEscape(value).replace(/\\ /g, ' ')
+    # However, our attribute selectors do not conform to CSS parsing spec,
+    # so we escape them differently.
+    return (
+        '"'
+        + value.replace("\\", "\\\\").replace('"', '\\"')
+        + '"'
+        + ("s" if exact else "i")
+    )

playwright/_impl/_stream.py

@@ -0,0 +1,46 @@
+# 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
+from pathlib import Path
+from typing import Dict, Union
+
+from playwright._impl._connection import ChannelOwner
+
+
+class Stream(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def save_as(self, path: Union[str, Path]) -> None:
+        file = await self._loop.run_in_executor(None, lambda: open(path, "wb"))
+        while True:
+            binary = await self._channel.send("read", None, {"size": 1024 * 1024})
+            if not binary:
+                break
+            await self._loop.run_in_executor(
+                None, lambda: file.write(base64.b64decode(binary))
+            )
+        await self._loop.run_in_executor(None, lambda: file.close())
+
+    async def read_all(self) -> bytes:
+        binary = b""
+        while True:
+            chunk = await self._channel.send("read", None, {"size": 1024 * 1024})
+            if not chunk:
+                break
+            binary += base64.b64decode(chunk)
+        return binary