patchright 1.52.0__py3-none-win_arm64.whl

patchright/__init__.py

@@ -0,0 +1,5 @@
+"""
+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.
+"""

patchright/__main__.py

@@ -0,0 +1,18 @@
+import subprocess
+import sys
+from patchright._impl._driver import compute_driver_executable, get_driver_env
+
+
+def main() -> None:
+    try:
+        driver_executable, driver_cli = compute_driver_executable()
+        completed_process = subprocess.run(
+            [driver_executable, driver_cli, *sys.argv[1:]], env=get_driver_env()
+        )
+        sys.exit(completed_process.returncode)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()

patchright/_impl/__pyinstaller/__init__.py

@@ -0,0 +1,20 @@
+# 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 os
+from typing import List
+
+
+def get_hook_dirs() -> List[str]:
+    return [os.path.dirname(__file__)]

patchright/_impl/__pyinstaller/hook-playwright.async_api.py

@@ -0,0 +1,3 @@
+from PyInstaller.utils.hooks import collect_data_files
+
+datas = collect_data_files("patchright")

patchright/_impl/__pyinstaller/hook-playwright.sync_api.py

@@ -0,0 +1,3 @@
+from PyInstaller.utils.hooks import collect_data_files
+
+datas = collect_data_files("patchright")

patchright/_impl/_accessibility.py

@@ -0,0 +1,50 @@
+from typing import Dict, Optional
+from patchright._impl._connection import Channel
+from patchright._impl._element_handle import ElementHandle
+from patchright._impl._helper import locals_to_params
+
+
+def _ax_node_from_protocol(axNode: Dict) -> Dict:
+    result = {**axNode}
+    if "valueNumber" in axNode:
+        result["value"] = axNode["valueNumber"]
+    elif "valueString" in axNode:
+        result["value"] = axNode["valueString"]
+    if "checked" in axNode:
+        result["checked"] = (
+            True
+            if axNode.get("checked") == "checked"
+            else (
+                False if axNode.get("checked") == "unchecked" else axNode.get("checked")
+            )
+        )
+    if "pressed" in axNode:
+        result["pressed"] = (
+            True
+            if axNode.get("pressed") == "pressed"
+            else False if axNode.get("pressed") == "released" else axNode.get("pressed")
+        )
+    if axNode.get("children"):
+        result["children"] = list(map(_ax_node_from_protocol, axNode["children"]))
+    if "valueNumber" in result:
+        del result["valueNumber"]
+    if "valueString" in result:
+        del result["valueString"]
+    return result
+
+
+class Accessibility:
+
+    def __init__(self, channel: Channel) -> None:
+        self._channel = channel
+        self._loop = channel._connection._loop
+        self._dispatcher_fiber = channel._connection._dispatcher_fiber
+
+    async def snapshot(
+        self, interestingOnly: bool = None, root: ElementHandle = None
+    ) -> Optional[Dict]:
+        params = locals_to_params(locals())
+        if root:
+            params["root"] = root._channel
+        result = await self._channel.send("accessibilitySnapshot", params)
+        return _ax_node_from_protocol(result) if result else None

patchright/_impl/_api_structures.py

@@ -0,0 +1,277 @@
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Sequence, TypedDict, Union
+
+
+class Cookie(TypedDict, total=False):
+    name: str
+    value: str
+    domain: str
+    path: str
+    expires: float
+    httpOnly: bool
+    secure: bool
+    sameSite: Literal["Lax", "None", "Strict"]
+
+
+class SetCookieParam(TypedDict, total=False):
+    name: str
+    value: str
+    url: Optional[str]
+    domain: Optional[str]
+    path: Optional[str]
+    expires: Optional[float]
+    httpOnly: Optional[bool]
+    secure: Optional[bool]
+    sameSite: Optional[Literal["Lax", "None", "Strict"]]
+
+
+class FloatRect(TypedDict):
+    x: float
+    y: float
+    width: float
+    height: float
+
+
+class Geolocation(TypedDict, total=False):
+    latitude: float
+    longitude: float
+    accuracy: Optional[float]
+
+
+class HttpCredentials(TypedDict, total=False):
+    username: str
+    password: str
+    origin: Optional[str]
+    send: Optional[Literal["always", "unauthorized"]]
+
+
+class LocalStorageEntry(TypedDict):
+    name: str
+    value: str
+
+
+class OriginState(TypedDict):
+    origin: str
+    localStorage: List[LocalStorageEntry]
+
+
+class PdfMargins(TypedDict, total=False):
+    top: Optional[Union[str, float]]
+    right: Optional[Union[str, float]]
+    bottom: Optional[Union[str, float]]
+    left: Optional[Union[str, float]]
+
+
+class Position(TypedDict):
+    x: float
+    y: float
+
+
+class ProxySettings(TypedDict, total=False):
+    server: str
+    bypass: Optional[str]
+    username: Optional[str]
+    password: Optional[str]
+
+
+class StorageState(TypedDict, total=False):
+    cookies: List[Cookie]
+    origins: List[OriginState]
+
+
+class ClientCertificate(TypedDict, total=False):
+    origin: str
+    certPath: Optional[Union[str, Path]]
+    cert: Optional[bytes]
+    keyPath: Optional[Union[str, Path]]
+    key: Optional[bytes]
+    pfxPath: Optional[Union[str, Path]]
+    pfx: Optional[bytes]
+    passphrase: Optional[str]
+
+
+class ResourceTiming(TypedDict):
+    startTime: float
+    domainLookupStart: float
+    domainLookupEnd: float
+    connectStart: float
+    secureConnectionStart: float
+    connectEnd: float
+    requestStart: float
+    responseStart: float
+    responseEnd: float
+
+
+class RequestSizes(TypedDict):
+    requestBodySize: int
+    requestHeadersSize: int
+    responseBodySize: int
+    responseHeadersSize: int
+
+
+class ViewportSize(TypedDict):
+    width: int
+    height: int
+
+
+class SourceLocation(TypedDict):
+    url: str
+    lineNumber: int
+    columnNumber: int
+
+
+class FilePayload(TypedDict):
+    name: str
+    mimeType: str
+    buffer: bytes
+
+
+class RemoteAddr(TypedDict):
+    ipAddress: str
+    port: int
+
+
+class SecurityDetails(TypedDict):
+    issuer: Optional[str]
+    protocol: Optional[str]
+    subjectName: Optional[str]
+    validFrom: Optional[float]
+    validTo: Optional[float]
+
+
+class NameValue(TypedDict):
+    name: str
+    value: str
+
+
+HeadersArray = List[NameValue]
+Headers = Dict[str, str]
+
+
+class ServerFilePayload(TypedDict):
+    name: str
+    mimeType: str
+    buffer: str
+
+
+class FormField(TypedDict, total=False):
+    name: str
+    value: Optional[str]
+    file: Optional[ServerFilePayload]
+
+
+class ExpectedTextValue(TypedDict, total=False):
+    string: str
+    regexSource: str
+    regexFlags: str
+    matchSubstring: bool
+    normalizeWhiteSpace: bool
+    ignoreCase: Optional[bool]
+
+
+class FrameExpectOptions(TypedDict, total=False):
+    expressionArg: Any
+    expectedText: Optional[Sequence[ExpectedTextValue]]
+    expectedNumber: Optional[float]
+    expectedValue: Optional[Any]
+    useInnerText: Optional[bool]
+    isNot: bool
+    timeout: Optional[float]
+
+
+class FrameExpectResult(TypedDict):
+    matches: bool
+    received: Any
+    log: List[str]
+
+
+AriaRole = Literal[
+    "alert",
+    "alertdialog",
+    "application",
+    "article",
+    "banner",
+    "blockquote",
+    "button",
+    "caption",
+    "cell",
+    "checkbox",
+    "code",
+    "columnheader",
+    "combobox",
+    "complementary",
+    "contentinfo",
+    "definition",
+    "deletion",
+    "dialog",
+    "directory",
+    "document",
+    "emphasis",
+    "feed",
+    "figure",
+    "form",
+    "generic",
+    "grid",
+    "gridcell",
+    "group",
+    "heading",
+    "img",
+    "insertion",
+    "link",
+    "list",
+    "listbox",
+    "listitem",
+    "log",
+    "main",
+    "marquee",
+    "math",
+    "menu",
+    "menubar",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "meter",
+    "navigation",
+    "none",
+    "note",
+    "option",
+    "paragraph",
+    "presentation",
+    "progressbar",
+    "radio",
+    "radiogroup",
+    "region",
+    "row",
+    "rowgroup",
+    "rowheader",
+    "scrollbar",
+    "search",
+    "searchbox",
+    "separator",
+    "slider",
+    "spinbutton",
+    "status",
+    "strong",
+    "subscript",
+    "superscript",
+    "switch",
+    "tab",
+    "table",
+    "tablist",
+    "tabpanel",
+    "term",
+    "textbox",
+    "time",
+    "timer",
+    "toolbar",
+    "tooltip",
+    "tree",
+    "treegrid",
+    "treeitem",
+]
+
+
+class TracingGroupLocation(TypedDict):
+    file: str
+    line: Optional[int]
+    column: Optional[int]

patchright/_impl/_artifact.py

@@ -0,0 +1,45 @@
+import pathlib
+from pathlib import Path
+from typing import Dict, Optional, Union, cast
+from patchright._impl._connection import ChannelOwner, from_channel
+from patchright._impl._helper import Error, make_dirs_for_file, patch_error_message
+from patchright._impl._stream import Stream
+
+
+class Artifact(ChannelOwner):
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self.absolute_path = initializer["absolutePath"]
+
+    async def path_after_finished(self) -> pathlib.Path:
+        if self._connection.is_remote:
+            raise Error(
+                "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
+            )
+        path = await self._channel.send("pathAfterFinished")
+        return pathlib.Path(path)
+
+    async def save_as(self, path: Union[str, Path]) -> None:
+        stream = cast(Stream, from_channel(await self._channel.send("saveAsStream")))
+        make_dirs_for_file(path)
+        await stream.save_as(path)
+
+    async def failure(self) -> Optional[str]:
+        reason = await self._channel.send("failure")
+        if reason is None:
+            return None
+        return patch_error_message(reason)
+
+    async def delete(self) -> None:
+        await self._channel.send("delete")
+
+    async def read_info_buffer(self) -> bytes:
+        stream = cast(Stream, from_channel(await self._channel.send("stream")))
+        buffer = await stream.read_all()
+        return buffer
+
+    async def cancel(self) -> None:
+        await self._channel.send("cancel")