pure-patchright 1.62.3__py3-none-any.whl

patchright/_impl/_console_message.py

@@ -0,0 +1,83 @@
+from asyncio import AbstractEventLoop
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
+from patchright._impl._api_structures import SourceLocation
+from patchright._impl._connection import from_channel, from_nullable_channel
+from patchright._impl._js_handle import JSHandle
+
+if TYPE_CHECKING:
+    from patchright._impl._page import Page
+    from patchright._impl._worker import Worker
+
+
+class ConsoleMessage:
+    def __init__(
+        self, event: Dict, loop: AbstractEventLoop, dispatcher_fiber: Any
+    ) -> None:
+        self._event = event
+        self._loop = loop
+        self._dispatcher_fiber = dispatcher_fiber
+        self._page: Optional["Page"] = from_nullable_channel(event.get("page"))
+        self._worker: Optional["Worker"] = from_nullable_channel(event.get("worker"))
+
+    def __repr__(self) -> str:
+        return f"<ConsoleMessage type={self.type} text={self.text}>"
+
+    def __str__(self) -> str:
+        return self.text
+
+    @property
+    def type(
+        self,
+    ) -> Union[
+        Literal["assert"],
+        Literal["clear"],
+        Literal["count"],
+        Literal["debug"],
+        Literal["dir"],
+        Literal["dirxml"],
+        Literal["endGroup"],
+        Literal["error"],
+        Literal["info"],
+        Literal["log"],
+        Literal["profile"],
+        Literal["profileEnd"],
+        Literal["startGroup"],
+        Literal["startGroupCollapsed"],
+        Literal["table"],
+        Literal["time"],
+        Literal["timeEnd"],
+        Literal["trace"],
+        Literal["warning"],
+    ]:
+        return self._event["type"]
+
+    @property
+    def text(self) -> str:
+        return self._event["text"]
+
+    @property
+    def args(self) -> List[JSHandle]:
+        return list(map(from_channel, self._event["args"]))
+
+    @property
+    def location(self) -> SourceLocation:
+        loc = self._event["location"]
+        return {
+            "url": loc["url"],
+            "line": loc["lineNumber"],
+            "column": loc["columnNumber"],
+            "lineNumber": loc["lineNumber"],
+            "columnNumber": loc["columnNumber"],
+        }
+
+    @property
+    def timestamp(self) -> float:
+        return self._event["timestamp"]
+
+    @property
+    def page(self) -> Optional["Page"]:
+        return self._page
+
+    @property
+    def worker(self) -> Optional["Worker"]:
+        return self._worker

patchright/_impl/_credentials.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING, List
+from patchright._impl._api_structures import VirtualCredential
+from patchright._impl._helper import locals_to_params
+
+if TYPE_CHECKING:
+    from patchright._impl._browser_context import BrowserContext
+
+
+class Credentials:
+    def __init__(self, browser_context: "BrowserContext") -> None:
+        self._browser_context = browser_context
+        self._loop = browser_context._loop
+        self._dispatcher_fiber = browser_context._dispatcher_fiber
+
+    async def install(self) -> None:
+        await self._browser_context._channel.send("credentialsInstall", None)
+
+    async def create(
+        self,
+        rpId: str,
+        id: str = None,
+        userHandle: str = None,
+        privateKey: str = None,
+        publicKey: str = None,
+    ) -> VirtualCredential:
+        result = await self._browser_context._channel.send_return_as_dict(
+            "credentialsCreate", None, locals_to_params(locals())
+        )
+        return (result or {})["credential"]
+
+    async def delete(self, id: str) -> None:
+        await self._browser_context._channel.send("credentialsDelete", None, {"id": id})
+
+    async def get(self, rpId: str = None, id: str = None) -> List[VirtualCredential]:
+        result = await self._browser_context._channel.send_return_as_dict(
+            "credentialsGet", None, locals_to_params(locals())
+        )
+        return (result or {}).get("credentials", [])

patchright/_impl/_debugger.py

@@ -0,0 +1,37 @@
+from types import SimpleNamespace
+from typing import Any, Dict, Optional
+from patchright._impl._api_structures import DebuggerLocation, DebuggerPausedDetails
+from patchright._impl._connection import ChannelOwner
+
+
+class Debugger(ChannelOwner):
+    Events = SimpleNamespace(PausedStateChanged="pausedstatechanged")
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._paused_details: Optional[DebuggerPausedDetails] = None
+        self._channel.on(
+            "pausedStateChanged", lambda params: self._on_paused_state_changed(params)
+        )
+
+    def _on_paused_state_changed(self, params: Dict[str, Any]) -> None:
+        self._paused_details = params.get("pausedDetails")
+        self.emit(Debugger.Events.PausedStateChanged)
+
+    async def request_pause(self) -> None:
+        await self._channel.send("requestPause", None)
+
+    async def resume(self) -> None:
+        await self._channel.send("resume", None)
+
+    async def next(self) -> None:
+        await self._channel.send("next", None)
+
+    async def run_to(self, location: DebuggerLocation) -> None:
+        await self._channel.send("runTo", None, {"location": location})
+
+    @property
+    def paused_details(self) -> Optional[DebuggerPausedDetails]:
+        return self._paused_details

patchright/_impl/_dialog.py

@@ -0,0 +1,45 @@
+from typing import TYPE_CHECKING, Dict, Optional
+from patchright._impl._connection import ChannelOwner, from_nullable_channel
+from patchright._impl._errors import is_target_closed_error
+from patchright._impl._helper import locals_to_params
+
+if TYPE_CHECKING:
+    from patchright._impl._page import Page
+
+
+class Dialog(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._page: Optional["Page"] = from_nullable_channel(initializer.get("page"))
+
+    def __repr__(self) -> str:
+        return f"<Dialog type={self.type} message={self.message} default_value={self.default_value}>"
+
+    @property
+    def type(self) -> str:
+        return self._initializer["type"]
+
+    @property
+    def message(self) -> str:
+        return self._initializer["message"]
+
+    @property
+    def default_value(self) -> str:
+        return self._initializer["defaultValue"]
+
+    @property
+    def page(self) -> Optional["Page"]:
+        return self._page
+
+    async def accept(self, promptText: str = None) -> None:
+        await self._channel.send("accept", None, locals_to_params(locals()))
+
+    async def dismiss(self) -> None:
+        try:
+            await self._channel.send("dismiss", None)
+        except Exception as e:
+            if is_target_closed_error(e):
+                return
+            raise

patchright/_impl/_disposable.py

@@ -0,0 +1,71 @@
+import asyncio
+import traceback
+from typing import Awaitable, Callable, Dict
+import greenlet
+from patchright._impl._connection import ChannelOwner, _capture_stack_trace
+from patchright._impl._errors import Error, is_target_closed_error
+
+
+class Disposable(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def dispose(self) -> None:
+        try:
+            await self._channel.send("dispose", None)
+        except Exception as e:
+            if not is_target_closed_error(e):
+                raise e
+
+    async def close(self) -> None:
+        await self.dispose()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"
+
+
+class DisposableStub:
+    def __init__(
+        self, dispose_fn: Callable[[], Awaitable[None]], parent: ChannelOwner
+    ) -> None:
+        self._dispose_fn = dispose_fn
+        self._loop = parent._loop
+        self._dispatcher_fiber = parent._dispatcher_fiber
+
+    async def dispose(self) -> None:
+        await self._dispose_fn()
+
+    async def __aenter__(self) -> "DisposableStub":
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.dispose()
+
+    def __enter__(self) -> "DisposableStub":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self._sync(self.dispose())
+
+    def _sync(self, coro: object) -> object:
+        __tracebackhide__ = True
+        if self._loop.is_closed():
+            coro.close()
+            raise Error("Event loop is closed! Is Playwright already stopped?")
+        g_self = greenlet.getcurrent()
+        task = 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()
+
+    async def close(self) -> None:
+        await self.dispose()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"

patchright/_impl/_download.py

@@ -0,0 +1,49 @@
+import pathlib
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Union
+from patchright._impl._artifact import Artifact
+
+if TYPE_CHECKING:
+    from patchright._impl._page import Page
+
+
+class Download:
+    def __init__(
+        self, page: "Page", url: str, suggested_filename: str, artifact: Artifact
+    ) -> None:
+        self._page = page
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+        self._url = url
+        self._suggested_filename = suggested_filename
+        self._artifact = artifact
+
+    def __repr__(self) -> str:
+        return f"<Download url={self.url!r} suggested_filename={self.suggested_filename!r}>"
+
+    @property
+    def page(self) -> "Page":
+        return self._page
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def suggested_filename(self) -> str:
+        return self._suggested_filename
+
+    async def delete(self) -> None:
+        await self._artifact.delete()
+
+    async def failure(self) -> Optional[str]:
+        return await self._artifact.failure()
+
+    async def path(self) -> pathlib.Path:
+        return await self._artifact.path_after_finished()
+
+    async def save_as(self, path: Union[str, Path]) -> None:
+        await self._artifact.save_as(path)
+
+    async def cancel(self) -> None:
+        return await self._artifact.cancel()

patchright/_impl/_driver.py

@@ -0,0 +1,24 @@
+import inspect
+import os
+import sys
+from pathlib import Path
+from typing import Tuple
+import patchright
+from patchright._repo_version import version
+import shutil
+from patchright._impl._errors import Error
+
+def compute_driver_executable() -> Tuple[str, str]:
+    driver_path = Path(inspect.getfile(patchright)).parent / 'driver'
+    cli_path = str(driver_path / 'package' / 'cli.js')
+    node_path = os.getenv('PLAYWRIGHT_NODEJS_PATH') or shutil.which('node') or shutil.which('nodejs')
+    if not node_path:
+        raise Error('Node.js executable not found. Install Node.js (>=18) on PATH or set PLAYWRIGHT_NODEJS_PATH pointing to the Node.js binary.')
+    return (node_path, cli_path)
+
+def get_driver_env() -> dict:
+    env = os.environ.copy()
+    env['PW_LANG_NAME'] = 'python'
+    env['PW_LANG_NAME_VERSION'] = f'{sys.version_info.major}.{sys.version_info.minor}'
+    env['PW_CLI_DISPLAY_VERSION'] = version
+    return env