pure-patchright 1.62.3__py3-none-any.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/_api_structures.py

@@ -0,0 +1,343 @@
+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"]
+    partitionKey: Optional[str]
+
+
+class StorageStateCookie(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"]]
+    partitionKey: Optional[str]
+
+
+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[StorageStateCookie]
+    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
+    line: int
+    column: int
+    lineNumber: int
+    columnNumber: int
+
+
+class WebErrorLocation(TypedDict):
+    url: str
+    line: int
+    column: int
+
+
+class FilePayload(TypedDict):
+    name: str
+    mimeType: str
+    buffer: bytes
+
+
+class DropPayload(TypedDict, total=False):
+    files: Optional[
+        Union[str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]]
+    ]
+    data: Optional[Dict[str, str]]
+
+
+class RemoteAddr(TypedDict):
+    ipAddress: str
+    port: int
+
+
+class BrowserBindResult(TypedDict):
+    endpoint: str
+
+
+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]
+    pseudo: Optional[str]
+
+
+class FrameExpectResult(TypedDict, total=False):
+    matches: bool
+    received: Any
+    log: Optional[List[str]]
+    errorMessage: Optional[str]
+    timedOut: Optional[bool]
+
+
+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]
+
+
+class DebuggerLocation(TypedDict):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
+
+
+class DebuggerPausedDetails(TypedDict):
+    location: DebuggerLocation
+    title: str
+
+
+class ScreencastSize(TypedDict):
+    width: int
+    height: int
+
+
+class VirtualCredential(TypedDict):
+    id: str
+    rpId: str
+    userHandle: str
+    privateKey: str
+    publicKey: str
+
+
+class ScreencastFrame(TypedDict):
+    data: bytes
+    timestamp: float
+    viewportWidth: int
+    viewportHeight: int

patchright/_impl/_artifact.py

@@ -0,0 +1,46 @@
+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", None)
+        return pathlib.Path(path)
+
+    async def save_as(self, path: Union[str, Path]) -> None:
+        stream = cast(
+            Stream, from_channel(await self._channel.send("saveAsStream", None))
+        )
+        make_dirs_for_file(path)
+        await stream.save_as(path)
+
+    async def failure(self) -> Optional[str]:
+        reason = await self._channel.send("failure", None)
+        if reason is None:
+            return None
+        return patch_error_message(reason)
+
+    async def delete(self) -> None:
+        await self._channel.send("delete", None)
+
+    async def read_info_buffer(self) -> bytes:
+        stream = cast(Stream, from_channel(await self._channel.send("stream", None)))
+        buffer = await stream.read_all()
+        return buffer
+
+    async def cancel(self) -> None:
+        await self._channel.send("cancel", None)