playwright-browserstack 1.62.0__py3-none-win_amd64.whl

playwright/_impl/_sync_base.py

@@ -0,0 +1,151 @@
+# 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 traceback
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Generator,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+import greenlet
+
+from playwright._impl._connection import _capture_stack_trace
+from playwright._impl._helper import Error
+from playwright._impl._impl_to_api_mapping import ImplToApiMapping, ImplWrapper
+
+mapping = ImplToApiMapping()
+
+
+T = TypeVar("T")
+Self = TypeVar("Self", bound="SyncContextManager")
+
+
+class EventInfo(Generic[T]):
+    def __init__(self, sync_base: "SyncBase", future: "asyncio.Future[T]") -> None:
+        self._sync_base = sync_base
+        self._future = future
+        g_self = greenlet.getcurrent()
+        self._future.add_done_callback(lambda _: g_self.switch())
+
+    @property
+    def value(self) -> T:
+        while not self._future.done():
+            self._sync_base._dispatcher_fiber.switch()
+        asyncio._set_running_loop(self._sync_base._loop)
+        exception = self._future.exception()
+        if exception:
+            raise exception
+        return cast(T, mapping.from_maybe_impl(self._future.result()))
+
+    def _cancel(self) -> None:
+        self._future.cancel()
+
+    def is_done(self) -> bool:
+        return self._future.done()
+
+
+class EventContextManager(Generic[T], AbstractContextManager):
+    def __init__(self, sync_base: "SyncBase", future: "asyncio.Future[T]") -> None:
+        self._event = EventInfo[T](sync_base, future)
+
+    def __enter__(self) -> EventInfo[T]:
+        return self._event
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if exc_val:
+            self._event._cancel()
+        else:
+            self._event.value
+
+
+class SyncBase(ImplWrapper):
+    def __init__(self, impl_obj: Any) -> None:
+        super().__init__(impl_obj)
+        self._loop: asyncio.AbstractEventLoop = impl_obj._loop
+        self._dispatcher_fiber = impl_obj._dispatcher_fiber
+
+    def __str__(self) -> str:
+        return self._impl_obj.__str__()
+
+    def _sync(
+        self,
+        coro: Union[Coroutine[Any, Any, Any], Generator[Any, Any, Any]],
+    ) -> Any:
+        __tracebackhide__ = True
+        if self._loop.is_closed():
+            coro.close()
+            raise Error("Event loop is closed! Is Playwright already stopped?")
+
+        g_self = greenlet.getcurrent()
+        task: asyncio.tasks.Task[Any] = self._loop.create_task(coro)
+        setattr(task, "__pw_stack__", _capture_stack_trace())
+        setattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10))
+
+        task.add_done_callback(lambda _: g_self.switch())
+        while not task.done():
+            self._dispatcher_fiber.switch()
+        asyncio._set_running_loop(self._loop)
+        return task.result()
+
+    def _wrap_handler(
+        self, handler: Union[Callable[..., Any], Any]
+    ) -> Callable[..., None]:
+        if callable(handler):
+            return mapping.wrap_handler(handler)
+        return handler
+
+    def on(self, event: Any, f: Any) -> None:
+        """Registers the function ``f`` to the event name ``event``."""
+        self._impl_obj.on(event, self._wrap_handler(f))
+
+    def once(self, event: Any, f: Any) -> None:
+        """The same as ``self.on``, except that the listener is automatically
+        removed after being called.
+        """
+        self._impl_obj.once(event, self._wrap_handler(f))
+
+    def remove_listener(self, event: Any, f: Any) -> None:
+        """Removes the function ``f`` from ``event``."""
+        self._impl_obj.remove_listener(event, self._wrap_handler(f))
+
+
+class SyncContextManager(SyncBase):
+    def __enter__(self: Self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        _traceback: Optional[TracebackType],
+    ) -> None:
+        self.close()
+
+    def close(self) -> None: ...

playwright/_impl/_tracing.py

@@ -0,0 +1,281 @@
+# 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 pathlib
+from typing import Any, Dict, Literal, Optional, Pattern, Union, cast
+
+from playwright._impl._api_structures import TracingGroupLocation
+from playwright._impl._artifact import Artifact
+from playwright._impl._connection import (
+    ChannelOwner,
+    from_channel,
+    from_nullable_channel,
+)
+from playwright._impl._disposable import DisposableStub
+from playwright._impl._helper import Error, locals_to_params
+
+
+class Tracing(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._include_sources: bool = False
+        self._is_live: bool = False
+        self._stacks_id: Optional[str] = None
+        self._is_tracing: bool = False
+        self._traces_dir: Optional[str] = None
+        self._har_id: Optional[str] = None
+        self._har_recorders: Dict[str, Dict[str, str]] = {}
+
+    async def start(
+        self,
+        name: str = None,
+        title: str = None,
+        snapshots: bool = None,
+        screenshots: bool = None,
+        sources: bool = None,
+        live: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        self._include_sources = bool(sources)
+        self._is_live = bool(live)
+
+        await self._channel.send(
+            "tracingStart",
+            None,
+            {
+                "name": name,
+                "snapshots": snapshots,
+                "screenshots": screenshots,
+                "live": live,
+            },
+        )
+        trace_name = await self._channel.send(
+            "tracingStartChunk", None, {"title": title, "name": name}
+        )
+        await self._start_collecting_stacks(trace_name)
+
+    async def start_chunk(self, title: str = None, name: str = None) -> None:
+        params = locals_to_params(locals())
+        trace_name = await self._channel.send("tracingStartChunk", None, params)
+        await self._start_collecting_stacks(trace_name)
+
+    async def _start_collecting_stacks(self, trace_name: str) -> None:
+        if not self._is_tracing:
+            self._is_tracing = True
+            self._connection.set_is_tracing(True)
+        self._stacks_id = await self._connection.local_utils.tracing_started(
+            self._traces_dir, trace_name, self._is_live
+        )
+
+    async def stop_chunk(self, path: Union[pathlib.Path, str] = None) -> None:
+        await self._do_stop_chunk(path)
+
+    async def stop(self, path: Union[pathlib.Path, str] = None) -> None:
+        await self._do_stop_chunk(path)
+        await self._channel.send(
+            "tracingStop",
+            None,
+        )
+
+    async def _do_stop_chunk(self, file_path: Union[pathlib.Path, str] = None) -> None:
+        self._reset_stack_counter()
+
+        if not file_path:
+            # Not interested in any artifacts
+            await self._channel.send("tracingStopChunk", None, {"mode": "discard"})
+            if self._stacks_id:
+                await self._connection.local_utils.trace_discarded(self._stacks_id)
+            return
+
+        is_local = not self._connection.is_remote
+
+        if is_local:
+            result = await self._channel.send_return_as_dict(
+                "tracingStopChunk", None, {"mode": "entries"}
+            )
+            await self._connection.local_utils.zip(
+                {
+                    "zipFile": str(file_path),
+                    "entries": result["entries"],
+                    "stacksId": self._stacks_id,
+                    "mode": "write",
+                    "includeSources": self._include_sources,
+                }
+            )
+            return
+
+        result = await self._channel.send_return_as_dict(
+            "tracingStopChunk",
+            None,
+            {
+                "mode": "archive",
+            },
+        )
+
+        artifact = cast(
+            Optional[Artifact],
+            from_nullable_channel(result.get("artifact")),
+        )
+
+        # The artifact may be missing if the browser closed while stopping tracing.
+        if not artifact:
+            if self._stacks_id:
+                await self._connection.local_utils.trace_discarded(self._stacks_id)
+            return
+
+        # Save trace to the final local file.
+        await artifact.save_as(file_path)
+        await artifact.delete()
+
+        await self._connection.local_utils.zip(
+            {
+                "zipFile": str(file_path),
+                "entries": [],
+                "stacksId": self._stacks_id,
+                "mode": "append",
+                "includeSources": self._include_sources,
+            }
+        )
+
+    def _reset_stack_counter(self) -> None:
+        if self._is_tracing:
+            self._is_tracing = False
+            self._connection.set_is_tracing(False)
+
+    async def group(
+        self, name: str, location: TracingGroupLocation = None
+    ) -> DisposableStub:
+        await self._channel.send("tracingGroup", None, locals_to_params(locals()))
+        return DisposableStub(lambda: self.group_end(), self)
+
+    async def group_end(self) -> None:
+        await self._channel.send(
+            "tracingGroupEnd",
+            None,
+        )
+
+    async def start_har(
+        self,
+        path: Union[pathlib.Path, str],
+        content: Literal["attach", "embed", "omit"] = None,
+        mode: Literal["full", "minimal"] = None,
+        urlFilter: Union[str, Pattern[str]] = None,
+    ) -> DisposableStub:
+        if self._har_id:
+            raise Error("HAR recording has already been started")
+        is_zip = str(path).endswith(".zip")
+        default_content: Literal["attach", "embed", "omit"] = (
+            "attach" if is_zip else "embed"
+        )
+        self._har_id = await self._record_into_har(
+            har=path,
+            page=None,
+            url=urlFilter,
+            update_content=content or default_content,
+            update_mode=mode or "full",
+        )
+        return DisposableStub(lambda: self.stop_har(), self)
+
+    async def _record_into_har(
+        self,
+        har: Union[pathlib.Path, str],
+        page: Optional[ChannelOwner],
+        url: Union[str, Pattern[str]] = None,
+        update_content: Literal["attach", "embed", "omit"] = None,
+        update_mode: Literal["full", "minimal"] = None,
+        resourcesDir: Optional[str] = None,
+    ) -> str:
+        is_zip = str(har).endswith(".zip")
+        url_glob: Optional[str] = None
+        url_regex_source: Optional[str] = None
+        url_regex_flags: Optional[str] = None
+        if isinstance(url, str):
+            url_glob = url
+        elif url is not None:
+            url_regex_source = url.pattern
+            url_regex_flags = "".join(
+                flag
+                for flag, mask in (("i", 2), ("m", 8), ("s", 16))
+                if url.flags & mask
+            )
+        options: Dict[str, object] = {
+            "content": update_content or "attach",
+            "mode": update_mode or "minimal",
+            "harPath": None if is_zip else str(har),
+        }
+        if url_glob is not None:
+            options["urlGlob"] = url_glob
+        if url_regex_source is not None:
+            options["urlRegexSource"] = url_regex_source
+        if url_regex_flags is not None:
+            options["urlRegexFlags"] = url_regex_flags
+        if resourcesDir is not None:
+            options["resourcesDir"] = resourcesDir
+        params: Dict[str, Any] = {"options": options}
+        if page is not None:
+            params["page"] = page._channel
+        result = await self._channel.send_return_as_dict("harStart", None, params)
+        har_id = result["harId"]
+        self._har_recorders[har_id] = {"path": str(har)}
+        return har_id
+
+    async def _export_all_hars(self) -> None:
+        for har_id in list(self._har_recorders.keys()):
+            await self._export_har(har_id)
+        self._har_id = None
+
+    async def stop_har(self) -> None:
+        har_id = self._har_id
+        if not har_id:
+            return
+        self._har_id = None
+        await self._export_har(har_id)
+
+    async def _export_har(self, har_id: str) -> None:
+        params = self._har_recorders.pop(har_id, None)
+        if not params:
+            return
+        is_local = not self._connection.is_remote
+        is_zip = params["path"].endswith(".zip")
+
+        if is_local:
+            result = await self._channel.send_return_as_dict(
+                "harExport", None, {"harId": har_id, "mode": "entries"}
+            )
+            if not is_zip:
+                # Server wrote HAR and resources to the user's chosen paths.
+                return
+            await self._connection.local_utils.zip(
+                {
+                    "zipFile": params["path"],
+                    "entries": result["entries"],
+                    "mode": "write",
+                    "includeSources": False,
+                }
+            )
+            return
+
+        result = await self._channel.send_return_as_dict(
+            "harExport", None, {"harId": har_id, "mode": "archive"}
+        )
+        artifact = cast(Artifact, from_channel(result["artifact"]))
+        if is_zip:
+            await artifact.save_as(params["path"])
+            await artifact.delete()
+            return
+        # Uncompressed har is not supported in thin clients
+        await artifact.save_as(params["path"] + ".tmp")
+        await artifact.delete()

playwright/_impl/_transport.py

@@ -0,0 +1,184 @@
+# 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 io
+import json
+import os
+import subprocess
+import sys
+from abc import ABC, abstractmethod
+from typing import Callable, Dict, Optional, Union
+
+from playwright._impl._driver import compute_driver_executable, get_driver_env
+from playwright._impl._helper import ParsedMessagePayload
+
+
+# Sourced from: https://github.com/pytest-dev/pytest/blob/da01ee0a4bb0af780167ecd228ab3ad249511302/src/_pytest/faulthandler.py#L69-L77
+def _get_stderr_fileno() -> Optional[int]:
+    try:
+        # when using pythonw, sys.stderr is None.
+        # when Pyinstaller is used, there is no closed attribute because Pyinstaller monkey-patches it with a NullWriter class
+        if sys.stderr is None or not hasattr(sys.stderr, "closed"):
+            return None
+        if sys.stderr.closed:
+            return None
+
+        return sys.stderr.fileno()
+    except (NotImplementedError, AttributeError, io.UnsupportedOperation):
+        # pytest-xdist monkeypatches sys.stderr with an object that is not an actual file.
+        # https://docs.python.org/3/library/faulthandler.html#issue-with-file-descriptors
+        # This is potentially dangerous, but the best we can do.
+        if not hasattr(sys, "__stderr__") or not sys.__stderr__:
+            return None
+        return sys.__stderr__.fileno()
+
+
+class Transport(ABC):
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self.on_message: Callable[[ParsedMessagePayload], None] = lambda _: None
+        self.on_error_future: asyncio.Future = loop.create_future()
+
+    @abstractmethod
+    def request_stop(self) -> None:
+        pass
+
+    def dispose(self) -> None:
+        pass
+
+    @abstractmethod
+    async def wait_until_stopped(self) -> None:
+        pass
+
+    @abstractmethod
+    async def connect(self) -> None:
+        pass
+
+    @abstractmethod
+    async def run(self) -> None:
+        pass
+
+    @abstractmethod
+    def send(self, message: Dict) -> None:
+        pass
+
+    def serialize_message(self, message: Dict) -> bytes:
+        msg = json.dumps(message)
+        if "DEBUGP" in os.environ:  # pragma: no cover
+            print("\x1b[32mSEND>\x1b[0m", json.dumps(message, indent=2))
+        return msg.encode()
+
+    def deserialize_message(self, data: Union[str, bytes]) -> ParsedMessagePayload:
+        obj = json.loads(data)
+
+        if "DEBUGP" in os.environ:  # pragma: no cover
+            print("\x1b[33mRECV>\x1b[0m", json.dumps(obj, indent=2))
+        return obj
+
+
+class PipeTransport(Transport):
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(loop)
+        self._stopped = False
+
+    def request_stop(self) -> None:
+        assert self._output
+        self._stopped = True
+        self._output.close()
+
+    async def wait_until_stopped(self) -> None:
+        await self._stopped_future
+
+    async def connect(self) -> None:
+        self._stopped_future: asyncio.Future = asyncio.Future()
+
+        try:
+            # For pyinstaller and Nuitka
+            env = get_driver_env()
+            if getattr(sys, "frozen", False) or globals().get("__compiled__"):
+                env.setdefault("PLAYWRIGHT_BROWSERS_PATH", "0")
+
+            startupinfo = None
+            if sys.platform == "win32":
+                startupinfo = subprocess.STARTUPINFO()
+                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+                startupinfo.wShowWindow = subprocess.SW_HIDE
+
+            executable_path, entrypoint_path = compute_driver_executable()
+            self._proc = await asyncio.create_subprocess_exec(
+                executable_path,
+                entrypoint_path,
+                "run-driver",
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=_get_stderr_fileno(),
+                limit=32768,
+                env=env,
+                startupinfo=startupinfo,
+            )
+        except Exception as exc:
+            self.on_error_future.set_exception(exc)
+            raise exc
+
+        self._output = self._proc.stdin
+
+    async def run(self) -> None:
+        assert self._proc.stdout
+        assert self._proc.stdin
+        try:
+            while not self._stopped:
+                try:
+                    buffer = await self._proc.stdout.readexactly(4)
+                    if self._stopped:
+                        break
+                    length = int.from_bytes(buffer, byteorder="little", signed=False)
+                    buffer = bytes(0)
+                    while length:
+                        to_read = min(length, 32768)
+                        data = await self._proc.stdout.readexactly(to_read)
+                        if self._stopped:
+                            break
+                        length -= to_read
+                        if len(buffer):
+                            buffer = buffer + data
+                        else:
+                            buffer = data
+                    if self._stopped:
+                        break
+
+                    obj = self.deserialize_message(buffer)
+                    self.on_message(obj)
+                except asyncio.IncompleteReadError:
+                    if not self._stopped:
+                        self.on_error_future.set_exception(
+                            Exception("Connection closed while reading from the driver")
+                        )
+                    break
+                await asyncio.sleep(0)
+
+            await self._proc.communicate()
+        finally:
+            # Release waiters on wait_until_stopped() even if this task was
+            # cancelled before reaching the end (e.g. by asyncio.run()'s
+            # task-cancellation phase that runs before asyncio-atexit hooks).
+            if not self._stopped_future.done():
+                self._stopped_future.set_result(None)
+
+    def send(self, message: Dict) -> None:
+        assert self._output
+        data = self.serialize_message(message)
+        self._output.write(
+            len(data).to_bytes(4, byteorder="little", signed=False) + data
+        )

playwright/_impl/_video.py

@@ -0,0 +1,56 @@
+# 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 pathlib
+from typing import TYPE_CHECKING, Optional, Union
+
+from playwright._impl._artifact import Artifact
+from playwright._impl._helper import Error
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
+
+
+class Video:
+    def __init__(self, page: "Page", artifact: Optional[Artifact]) -> None:
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+        self._page = page
+        self._is_remote = page._connection.is_remote
+        self._artifact = artifact
+
+    def __repr__(self) -> str:
+        return f"<Video page={self._page}>"
+
+    async def path(self) -> pathlib.Path:
+        if self._is_remote:
+            raise Error(
+                "Path is not available when using browserType.connect(). Use save_as() to save a local copy."
+            )
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        return self._artifact.absolute_path
+
+    async def save_as(self, path: Union[str, pathlib.Path]) -> None:
+        if self._page._connection._is_sync and not self._page._is_closed:
+            raise Error(
+                "Page is not yet closed. Close the page prior to calling save_as"
+            )
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        await self._artifact.save_as(path)
+
+    async def delete(self) -> None:
+        if self._artifact:
+            await self._artifact.delete()