patchright 1.48.0__py3-none-win32.whl

patchright/_impl/_path_utils.py

@@ -0,0 +1,11 @@
+import inspect
+from pathlib import Path
+
+
+def get_file_dirname() -> Path:
+    """Returns the callee (`__file__`) directory name"""
+    frame = inspect.stack()[1]
+    module = inspect.getmodule(frame[0])
+    assert module
+    assert module.__file__
+    return Path(module.__file__).parent.absolute()

patchright/_impl/_playwright.py

@@ -0,0 +1,51 @@
+from typing import Dict
+from patchright._impl._browser_type import BrowserType
+from patchright._impl._connection import ChannelOwner, from_channel
+from patchright._impl._fetch import APIRequest
+from patchright._impl._selectors import Selectors, SelectorsOwner
+
+
+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)
+        selectors_owner: SelectorsOwner = from_channel(initializer["selectors"])
+        self.selectors._add_channel(selectors_owner)
+        self._connection.on(
+            "close", lambda: self.selectors._remove_channel(selectors_owner)
+        )
+        self.devices = self._connection.local_utils.devices
+
+    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:
+        selectors_owner = from_channel(self._initializer["selectors"])
+        self.selectors._remove_channel(selectors_owner)
+        self.selectors = selectors
+        self.selectors._add_channel(selectors_owner)
+
+    async def stop(self) -> None:
+        pass

patchright/_impl/_selectors.py

@@ -0,0 +1,62 @@
+import asyncio
+from pathlib import Path
+from typing import Any, Dict, List, Set, Union
+from patchright._impl._connection import ChannelOwner
+from patchright._impl._errors import Error
+from patchright._impl._helper import async_readfile
+from patchright._impl._locator import set_test_id_attribute_name, test_id_attribute_name
+
+
+class Selectors:
+
+    def __init__(self, loop: asyncio.AbstractEventLoop, dispatcher_fiber: Any) -> None:
+        self._loop = loop
+        self._channels: Set[SelectorsOwner] = set()
+        self._registrations: List[Dict] = []
+        self._dispatcher_fiber = dispatcher_fiber
+
+    async def register(
+        self,
+        name: str,
+        script: str = None,
+        path: Union[str, Path] = None,
+        contentScript: bool = None,
+    ) -> None:
+        if not script and (not path):
+            raise Error("Either source or path should be specified")
+        if path:
+            script = (await async_readfile(path)).decode()
+        params: Dict[str, Any] = dict(name=name, source=script)
+        if contentScript:
+            params["contentScript"] = True
+        for channel in self._channels:
+            await channel._channel.send("register", params)
+        self._registrations.append(params)
+
+    def set_test_id_attribute(self, attributeName: str) -> None:
+        set_test_id_attribute_name(attributeName)
+        for channel in self._channels:
+            channel._channel.send_no_reply(
+                "setTestIdAttributeName", {"testIdAttributeName": attributeName}
+            )
+
+    def _add_channel(self, channel: "SelectorsOwner") -> None:
+        self._channels.add(channel)
+        for params in self._registrations:
+            channel._channel.send_no_reply("register", params)
+            channel._channel.send_no_reply(
+                "setTestIdAttributeName",
+                {"testIdAttributeName": test_id_attribute_name()},
+            )
+
+    def _remove_channel(self, channel: "SelectorsOwner") -> None:
+        if channel in self._channels:
+            self._channels.remove(channel)
+
+
+class SelectorsOwner(ChannelOwner):
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)

patchright/_impl/_set_input_files_helpers.py

@@ -0,0 +1,135 @@
+import base64
+import collections.abc
+import os
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypedDict,
+    Union,
+    cast,
+)
+from patchright._impl._connection import Channel, from_channel
+from patchright._impl._helper import Error
+from patchright._impl._writable_stream import WritableStream
+
+if TYPE_CHECKING:
+    from patchright._impl._browser_context import BrowserContext
+from patchright._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",
+                    {
+                        "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:
+        if os.path.isdir(item):
+            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)

patchright/_impl/_str_utils.py

@@ -0,0 +1,57 @@
+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("[.*+?^>${}()|[\\]\\\\]", "\\$&", text)
+
+
+def escape_regex_for_selector(text: Pattern) -> str:
+    return (
+        "/"
+        + re.sub(
+            "(^|[^\\\\])(\\\\\\\\)*([\"\\'`])", "\\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)
+    return (
+        '"'
+        + value.replace("\\", "\\\\").replace('"', '\\"')
+        + '"'
+        + ("s" if exact else "i")
+    )

patchright/_impl/_stream.py

@@ -0,0 +1,32 @@
+import base64
+from pathlib import Path
+from typing import Dict, Union
+from patchright._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", {"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", {"size": 1024 * 1024})
+            if not chunk:
+                break
+            binary += base64.b64decode(chunk)
+        return binary

patchright/_impl/_sync_base.py

@@ -0,0 +1,134 @@
+import asyncio
+import inspect
+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 patchright._impl._helper import Error
+from patchright._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__", inspect.stack())
+        setattr(task, "__pw_stack_trace__", traceback.extract_stack())
+        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: Type[BaseException],
+        exc_val: BaseException,
+        _traceback: TracebackType,
+    ) -> None:
+        self.close()
+
+    def close(self) -> None: ...

patchright/_impl/_tracing.py

@@ -0,0 +1,103 @@
+import pathlib
+from typing import Dict, Optional, Union, cast
+from patchright._impl._artifact import Artifact
+from patchright._impl._connection import ChannelOwner, from_nullable_channel
+from patchright._impl._helper import 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.mark_as_internal_type()
+        self._include_sources: bool = False
+        self._stacks_id: Optional[str] = None
+        self._is_tracing: bool = False
+        self._traces_dir: Optional[str] = None
+
+    async def start(
+        self,
+        name: str = None,
+        title: str = None,
+        snapshots: bool = None,
+        screenshots: bool = None,
+        sources: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        self._include_sources = bool(sources)
+        await self._channel.send("tracingStart", params)
+        trace_name = await self._channel.send(
+            "tracingStartChunk", {"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", 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
+        )
+
+    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")
+
+    async def _do_stop_chunk(self, file_path: Union[pathlib.Path, str] = None) -> None:
+        self._reset_stack_counter()
+        if not file_path:
+            await self._channel.send("tracingStopChunk", {"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", {"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", {"mode": "archive"}
+        )
+        artifact = cast(
+            Optional[Artifact], from_nullable_channel(result.get("artifact"))
+        )
+        if not artifact:
+            if self._stacks_id:
+                await self._connection.local_utils.trace_discarded(self._stacks_id)
+            return
+        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)