a
This commit is contained in:
+19
@@ -0,0 +1,19 @@
|
||||
# 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.
|
||||
|
||||
"""
|
||||
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.
|
||||
"""
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
# 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 subprocess
|
||||
import sys
|
||||
|
||||
from playwright._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()
|
||||
+20
@@ -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__)]
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
# 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.
|
||||
|
||||
from PyInstaller.utils.hooks import collect_data_files # type: ignore
|
||||
|
||||
datas = collect_data_files("playwright")
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
# 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.
|
||||
|
||||
from PyInstaller.utils.hooks import collect_data_files # type: ignore
|
||||
|
||||
datas = collect_data_files("playwright")
|
||||
+313
@@ -0,0 +1,313 @@
|
||||
# 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.
|
||||
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Literal, Optional, Sequence, TypedDict, Union
|
||||
|
||||
# These are the structures that we like keeping in a JSON form for their potential
|
||||
# reuse between SDKs / services. They are public and are a part of the
|
||||
# stable API.
|
||||
|
||||
# Explicitly mark optional params as such for the documentation
|
||||
# If there is at least one optional param, set total=False for better mypy handling.
|
||||
|
||||
|
||||
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"]
|
||||
|
||||
|
||||
# TODO: We are waiting for PEP705 so SetCookieParam can be readonly and matches Cookie.
|
||||
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
|
||||
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]
|
||||
errorMessage: Optional[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]
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
# 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 pathlib import Path
|
||||
from typing import Dict, Optional, Union, cast
|
||||
|
||||
from playwright._impl._connection import ChannelOwner, from_channel
|
||||
from playwright._impl._helper import Error, make_dirs_for_file, patch_error_message
|
||||
from playwright._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: # pyright: ignore[reportIncompatibleMethodOverride]
|
||||
await self._channel.send(
|
||||
"cancel",
|
||||
None,
|
||||
)
|
||||
+1031
File diff suppressed because it is too large
Load Diff
+105
@@ -0,0 +1,105 @@
|
||||
# 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
|
||||
from contextlib import AbstractAsyncContextManager
|
||||
from types import TracebackType
|
||||
from typing import Any, Callable, Generic, Optional, Type, TypeVar, Union
|
||||
|
||||
from playwright._impl._impl_to_api_mapping import ImplToApiMapping, ImplWrapper
|
||||
|
||||
mapping = ImplToApiMapping()
|
||||
|
||||
|
||||
T = TypeVar("T")
|
||||
Self = TypeVar("Self", bound="AsyncContextManager")
|
||||
|
||||
|
||||
class AsyncEventInfo(Generic[T]):
|
||||
def __init__(self, future: "asyncio.Future[T]") -> None:
|
||||
self._future = future
|
||||
|
||||
@property
|
||||
async def value(self) -> T:
|
||||
return mapping.from_maybe_impl(await self._future)
|
||||
|
||||
def _cancel(self) -> None:
|
||||
self._future.cancel()
|
||||
|
||||
def is_done(self) -> bool:
|
||||
return self._future.done()
|
||||
|
||||
|
||||
class AsyncEventContextManager(Generic[T], AbstractAsyncContextManager):
|
||||
def __init__(self, future: "asyncio.Future[T]") -> None:
|
||||
self._event = AsyncEventInfo[T](future)
|
||||
|
||||
async def __aenter__(self) -> AsyncEventInfo[T]:
|
||||
return self._event
|
||||
|
||||
async def __aexit__(
|
||||
self,
|
||||
exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
exc_tb: Optional[TracebackType],
|
||||
) -> None:
|
||||
if exc_val:
|
||||
self._event._cancel()
|
||||
else:
|
||||
await self._event.value
|
||||
|
||||
|
||||
class AsyncBase(ImplWrapper):
|
||||
def __init__(self, impl_obj: Any) -> None:
|
||||
super().__init__(impl_obj)
|
||||
self._loop = impl_obj._loop
|
||||
|
||||
def __str__(self) -> str:
|
||||
return self._impl_obj.__str__()
|
||||
|
||||
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 AsyncContextManager(AsyncBase):
|
||||
async def __aenter__(self: Self) -> Self:
|
||||
return self
|
||||
|
||||
async def __aexit__(
|
||||
self,
|
||||
exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
traceback: Optional[TracebackType],
|
||||
) -> None:
|
||||
await self.close()
|
||||
|
||||
async def close(self) -> None: ...
|
||||
+276
@@ -0,0 +1,276 @@
|
||||
# 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.
|
||||
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Dict,
|
||||
List,
|
||||
Optional,
|
||||
Pattern,
|
||||
Sequence,
|
||||
Set,
|
||||
Union,
|
||||
cast,
|
||||
)
|
||||
|
||||
from playwright._impl._api_structures import (
|
||||
ClientCertificate,
|
||||
Geolocation,
|
||||
HttpCredentials,
|
||||
ProxySettings,
|
||||
StorageState,
|
||||
ViewportSize,
|
||||
)
|
||||
from playwright._impl._artifact import Artifact
|
||||
from playwright._impl._browser_context import BrowserContext
|
||||
from playwright._impl._cdp_session import CDPSession
|
||||
from playwright._impl._connection import ChannelOwner, from_channel
|
||||
from playwright._impl._errors import is_target_closed_error
|
||||
from playwright._impl._helper import (
|
||||
ColorScheme,
|
||||
Contrast,
|
||||
ForcedColors,
|
||||
HarContentPolicy,
|
||||
HarMode,
|
||||
ReducedMotion,
|
||||
ServiceWorkersPolicy,
|
||||
locals_to_params,
|
||||
make_dirs_for_file,
|
||||
)
|
||||
from playwright._impl._page import Page
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._browser_type import BrowserType
|
||||
|
||||
|
||||
class Browser(ChannelOwner):
|
||||
Events = SimpleNamespace(
|
||||
Disconnected="disconnected",
|
||||
)
|
||||
|
||||
def __init__(
|
||||
self, parent: "BrowserType", type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self._browser_type: Optional["BrowserType"] = None
|
||||
self._is_connected = True
|
||||
self._should_close_connection_on_close = False
|
||||
self._cr_tracing_path: Optional[str] = None
|
||||
|
||||
self._contexts: Set[BrowserContext] = set()
|
||||
self._traces_dir: Optional[str] = None
|
||||
self._channel.on(
|
||||
"context",
|
||||
lambda params: self._did_create_context(
|
||||
cast(BrowserContext, from_channel(params["context"]))
|
||||
),
|
||||
)
|
||||
self._channel.on("close", lambda _: self._on_close())
|
||||
self._close_reason: Optional[str] = None
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<Browser type={self._browser_type} version={self.version}>"
|
||||
|
||||
def _connect_to_browser_type(
|
||||
self,
|
||||
browser_type: "BrowserType",
|
||||
traces_dir: Optional[str] = None,
|
||||
) -> None:
|
||||
# Note: when using connect(), `browserType` is different from `this.parent`.
|
||||
# This is why browser type is not wired up in the constructor, and instead this separate method is called later on.
|
||||
self._browser_type = browser_type
|
||||
self._traces_dir = traces_dir
|
||||
for context in self._contexts:
|
||||
self._setup_browser_context(context)
|
||||
|
||||
def _did_create_context(self, context: BrowserContext) -> None:
|
||||
context._browser = self
|
||||
self._contexts.add(context)
|
||||
# Note: when connecting to a browser, initial contexts arrive before `_browserType` is set,
|
||||
# and will be configured later in `ConnectToBrowserType`.
|
||||
if self._browser_type:
|
||||
self._setup_browser_context(context)
|
||||
|
||||
def _setup_browser_context(self, context: BrowserContext) -> None:
|
||||
context._tracing._traces_dir = self._traces_dir
|
||||
assert self._browser_type is not None
|
||||
self._browser_type._playwright.selectors._contexts_for_selectors.add(context)
|
||||
|
||||
def _on_close(self) -> None:
|
||||
self._is_connected = False
|
||||
self.emit(Browser.Events.Disconnected, self)
|
||||
|
||||
@property
|
||||
def contexts(self) -> List[BrowserContext]:
|
||||
return list(self._contexts)
|
||||
|
||||
@property
|
||||
def browser_type(self) -> "BrowserType":
|
||||
assert self._browser_type is not None
|
||||
return self._browser_type
|
||||
|
||||
def is_connected(self) -> bool:
|
||||
return self._is_connected
|
||||
|
||||
async def new_context(
|
||||
self,
|
||||
viewport: ViewportSize = None,
|
||||
screen: ViewportSize = None,
|
||||
noViewport: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
javaScriptEnabled: bool = None,
|
||||
bypassCSP: bool = None,
|
||||
userAgent: str = None,
|
||||
locale: str = None,
|
||||
timezoneId: str = None,
|
||||
geolocation: Geolocation = None,
|
||||
permissions: Sequence[str] = None,
|
||||
extraHTTPHeaders: Dict[str, str] = None,
|
||||
offline: bool = None,
|
||||
httpCredentials: HttpCredentials = None,
|
||||
deviceScaleFactor: float = None,
|
||||
isMobile: bool = None,
|
||||
hasTouch: bool = None,
|
||||
colorScheme: ColorScheme = None,
|
||||
reducedMotion: ReducedMotion = None,
|
||||
forcedColors: ForcedColors = None,
|
||||
contrast: Contrast = None,
|
||||
acceptDownloads: bool = None,
|
||||
defaultBrowserType: str = None,
|
||||
proxy: ProxySettings = None,
|
||||
recordHarPath: Union[Path, str] = None,
|
||||
recordHarOmitContent: bool = None,
|
||||
recordVideoDir: Union[Path, str] = None,
|
||||
recordVideoSize: ViewportSize = None,
|
||||
storageState: Union[StorageState, str, Path] = None,
|
||||
baseURL: str = None,
|
||||
strictSelectors: bool = None,
|
||||
serviceWorkers: ServiceWorkersPolicy = None,
|
||||
recordHarUrlFilter: Union[Pattern[str], str] = None,
|
||||
recordHarMode: HarMode = None,
|
||||
recordHarContent: HarContentPolicy = None,
|
||||
clientCertificates: List[ClientCertificate] = None,
|
||||
) -> BrowserContext:
|
||||
params = locals_to_params(locals())
|
||||
assert self._browser_type is not None
|
||||
await self._browser_type._prepare_browser_context_params(params)
|
||||
|
||||
channel = await self._channel.send("newContext", None, params)
|
||||
context = cast(BrowserContext, from_channel(channel))
|
||||
await context._initialize_har_from_options(
|
||||
record_har_content=recordHarContent,
|
||||
record_har_mode=recordHarMode,
|
||||
record_har_omit_content=recordHarOmitContent,
|
||||
record_har_path=recordHarPath,
|
||||
record_har_url_filter=recordHarUrlFilter,
|
||||
)
|
||||
return context
|
||||
|
||||
async def new_page(
|
||||
self,
|
||||
viewport: ViewportSize = None,
|
||||
screen: ViewportSize = None,
|
||||
noViewport: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
javaScriptEnabled: bool = None,
|
||||
bypassCSP: bool = None,
|
||||
userAgent: str = None,
|
||||
locale: str = None,
|
||||
timezoneId: str = None,
|
||||
geolocation: Geolocation = None,
|
||||
permissions: Sequence[str] = None,
|
||||
extraHTTPHeaders: Dict[str, str] = None,
|
||||
offline: bool = None,
|
||||
httpCredentials: HttpCredentials = None,
|
||||
deviceScaleFactor: float = None,
|
||||
isMobile: bool = None,
|
||||
hasTouch: bool = None,
|
||||
colorScheme: ColorScheme = None,
|
||||
forcedColors: ForcedColors = None,
|
||||
contrast: Contrast = None,
|
||||
reducedMotion: ReducedMotion = None,
|
||||
acceptDownloads: bool = None,
|
||||
defaultBrowserType: str = None,
|
||||
proxy: ProxySettings = None,
|
||||
recordHarPath: Union[Path, str] = None,
|
||||
recordHarOmitContent: bool = None,
|
||||
recordVideoDir: Union[Path, str] = None,
|
||||
recordVideoSize: ViewportSize = None,
|
||||
storageState: Union[StorageState, str, Path] = None,
|
||||
baseURL: str = None,
|
||||
strictSelectors: bool = None,
|
||||
serviceWorkers: ServiceWorkersPolicy = None,
|
||||
recordHarUrlFilter: Union[Pattern[str], str] = None,
|
||||
recordHarMode: HarMode = None,
|
||||
recordHarContent: HarContentPolicy = None,
|
||||
clientCertificates: List[ClientCertificate] = None,
|
||||
) -> Page:
|
||||
params = locals_to_params(locals())
|
||||
|
||||
async def inner() -> Page:
|
||||
context = await self.new_context(**params)
|
||||
page = await context.new_page()
|
||||
page._owned_context = context
|
||||
context._owner_page = page
|
||||
return page
|
||||
|
||||
return await self._connection.wrap_api_call(inner, title="Create page")
|
||||
|
||||
async def close(self, reason: str = None) -> None:
|
||||
self._close_reason = reason
|
||||
try:
|
||||
if self._should_close_connection_on_close:
|
||||
await self._connection.stop_async()
|
||||
else:
|
||||
await self._channel.send("close", None, {"reason": reason})
|
||||
except Exception as e:
|
||||
if not is_target_closed_error(e):
|
||||
raise e
|
||||
|
||||
@property
|
||||
def version(self) -> str:
|
||||
return self._initializer["version"]
|
||||
|
||||
async def new_browser_cdp_session(self) -> CDPSession:
|
||||
return from_channel(await self._channel.send("newBrowserCDPSession", None))
|
||||
|
||||
async def start_tracing(
|
||||
self,
|
||||
page: Page = None,
|
||||
path: Union[str, Path] = None,
|
||||
screenshots: bool = None,
|
||||
categories: Sequence[str] = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
if page:
|
||||
params["page"] = page._channel
|
||||
if path:
|
||||
self._cr_tracing_path = str(path)
|
||||
params["path"] = str(path)
|
||||
await self._channel.send("startTracing", None, params)
|
||||
|
||||
async def stop_tracing(self) -> bytes:
|
||||
artifact = cast(
|
||||
Artifact, from_channel(await self._channel.send("stopTracing", None))
|
||||
)
|
||||
buffer = await artifact.read_info_buffer()
|
||||
await artifact.delete()
|
||||
if self._cr_tracing_path:
|
||||
make_dirs_for_file(self._cr_tracing_path)
|
||||
with open(self._cr_tracing_path, "wb") as f:
|
||||
f.write(buffer)
|
||||
self._cr_tracing_path = None
|
||||
return buffer
|
||||
+761
@@ -0,0 +1,761 @@
|
||||
# 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 json
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Callable,
|
||||
Dict,
|
||||
List,
|
||||
Literal,
|
||||
Optional,
|
||||
Pattern,
|
||||
Sequence,
|
||||
Set,
|
||||
Union,
|
||||
cast,
|
||||
)
|
||||
|
||||
from playwright._impl._api_structures import (
|
||||
Cookie,
|
||||
Geolocation,
|
||||
SetCookieParam,
|
||||
StorageState,
|
||||
)
|
||||
from playwright._impl._artifact import Artifact
|
||||
from playwright._impl._cdp_session import CDPSession
|
||||
from playwright._impl._clock import Clock
|
||||
from playwright._impl._connection import (
|
||||
ChannelOwner,
|
||||
from_channel,
|
||||
from_nullable_channel,
|
||||
)
|
||||
from playwright._impl._console_message import ConsoleMessage
|
||||
from playwright._impl._dialog import Dialog
|
||||
from playwright._impl._errors import Error, TargetClosedError
|
||||
from playwright._impl._event_context_manager import EventContextManagerImpl
|
||||
from playwright._impl._fetch import APIRequestContext
|
||||
from playwright._impl._frame import Frame
|
||||
from playwright._impl._har_router import HarRouter
|
||||
from playwright._impl._helper import (
|
||||
HarContentPolicy,
|
||||
HarMode,
|
||||
HarRecordingMetadata,
|
||||
RouteFromHarNotFoundPolicy,
|
||||
RouteHandler,
|
||||
RouteHandlerCallback,
|
||||
TimeoutSettings,
|
||||
URLMatch,
|
||||
WebSocketRouteHandlerCallback,
|
||||
async_readfile,
|
||||
async_writefile,
|
||||
locals_to_params,
|
||||
parse_error,
|
||||
to_impl,
|
||||
)
|
||||
from playwright._impl._network import (
|
||||
Request,
|
||||
Response,
|
||||
Route,
|
||||
WebSocketRoute,
|
||||
WebSocketRouteHandler,
|
||||
serialize_headers,
|
||||
)
|
||||
from playwright._impl._page import BindingCall, Page, Worker
|
||||
from playwright._impl._str_utils import escape_regex_flags
|
||||
from playwright._impl._tracing import Tracing
|
||||
from playwright._impl._waiter import Waiter
|
||||
from playwright._impl._web_error import WebError
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._browser import Browser
|
||||
|
||||
|
||||
class BrowserContext(ChannelOwner):
|
||||
Events = SimpleNamespace(
|
||||
# Deprecated in v1.56, never emitted anymore.
|
||||
BackgroundPage="backgroundpage",
|
||||
Close="close",
|
||||
Console="console",
|
||||
Dialog="dialog",
|
||||
Page="page",
|
||||
WebError="weberror",
|
||||
ServiceWorker="serviceworker",
|
||||
Request="request",
|
||||
Response="response",
|
||||
RequestFailed="requestfailed",
|
||||
RequestFinished="requestfinished",
|
||||
)
|
||||
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
# Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
|
||||
# circular import workaround:
|
||||
self._browser: Optional["Browser"] = None
|
||||
if parent.__class__.__name__ == "Browser":
|
||||
self._browser = cast("Browser", parent)
|
||||
self._pages: List[Page] = []
|
||||
self._routes: List[RouteHandler] = []
|
||||
self._web_socket_routes: List[WebSocketRouteHandler] = []
|
||||
self._bindings: Dict[str, Any] = {}
|
||||
self._timeout_settings = TimeoutSettings(None)
|
||||
self._owner_page: Optional[Page] = None
|
||||
self._options: Dict[str, Any] = initializer["options"]
|
||||
self._service_workers: Set[Worker] = set()
|
||||
self._base_url: Optional[str] = self._options.get("baseURL")
|
||||
self._videos_dir: Optional[str] = self._options.get("recordVideo")
|
||||
self._tracing = cast(Tracing, from_channel(initializer["tracing"]))
|
||||
self._har_recorders: Dict[str, HarRecordingMetadata] = {}
|
||||
self._request: APIRequestContext = from_channel(initializer["requestContext"])
|
||||
self._clock = Clock(self)
|
||||
self._channel.on(
|
||||
"bindingCall",
|
||||
lambda params: self._on_binding(from_channel(params["binding"])),
|
||||
)
|
||||
self._channel.on("close", lambda _: self._on_close())
|
||||
self._channel.on(
|
||||
"page", lambda params: self._on_page(from_channel(params["page"]))
|
||||
)
|
||||
self._channel.on(
|
||||
"route",
|
||||
lambda params: self._loop.create_task(
|
||||
self._on_route(
|
||||
from_channel(params.get("route")),
|
||||
)
|
||||
),
|
||||
)
|
||||
self._channel.on(
|
||||
"webSocketRoute",
|
||||
lambda params: self._loop.create_task(
|
||||
self._on_web_socket_route(
|
||||
from_channel(params["webSocketRoute"]),
|
||||
)
|
||||
),
|
||||
)
|
||||
|
||||
self._channel.on(
|
||||
"serviceWorker",
|
||||
lambda params: self._on_service_worker(from_channel(params["worker"])),
|
||||
)
|
||||
self._channel.on(
|
||||
"console",
|
||||
lambda event: self._on_console_message(event),
|
||||
)
|
||||
|
||||
self._channel.on(
|
||||
"dialog", lambda params: self._on_dialog(from_channel(params["dialog"]))
|
||||
)
|
||||
self._channel.on(
|
||||
"pageError",
|
||||
lambda params: self._on_page_error(
|
||||
parse_error(params["error"]["error"]),
|
||||
from_nullable_channel(params["page"]),
|
||||
),
|
||||
)
|
||||
self._channel.on(
|
||||
"request",
|
||||
lambda params: self._on_request(
|
||||
from_channel(params["request"]),
|
||||
from_nullable_channel(params.get("page")),
|
||||
),
|
||||
)
|
||||
self._channel.on(
|
||||
"response",
|
||||
lambda params: self._on_response(
|
||||
from_channel(params["response"]),
|
||||
from_nullable_channel(params.get("page")),
|
||||
),
|
||||
)
|
||||
self._channel.on(
|
||||
"requestFailed",
|
||||
lambda params: self._on_request_failed(
|
||||
from_channel(params["request"]),
|
||||
params["responseEndTiming"],
|
||||
params.get("failureText"),
|
||||
from_nullable_channel(params.get("page")),
|
||||
),
|
||||
)
|
||||
self._channel.on(
|
||||
"requestFinished",
|
||||
lambda params: self._on_request_finished(
|
||||
from_channel(params["request"]),
|
||||
from_nullable_channel(params.get("response")),
|
||||
params["responseEndTiming"],
|
||||
from_nullable_channel(params.get("page")),
|
||||
),
|
||||
)
|
||||
self._closed_future: asyncio.Future = asyncio.Future()
|
||||
self.once(
|
||||
self.Events.Close, lambda context: self._closed_future.set_result(True)
|
||||
)
|
||||
self._close_reason: Optional[str] = None
|
||||
self._har_routers: List[HarRouter] = []
|
||||
self._set_event_to_subscription_mapping(
|
||||
{
|
||||
BrowserContext.Events.Console: "console",
|
||||
BrowserContext.Events.Dialog: "dialog",
|
||||
BrowserContext.Events.Request: "request",
|
||||
BrowserContext.Events.Response: "response",
|
||||
BrowserContext.Events.RequestFinished: "requestFinished",
|
||||
BrowserContext.Events.RequestFailed: "requestFailed",
|
||||
}
|
||||
)
|
||||
self._closing_or_closed = False
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<BrowserContext browser={self.browser}>"
|
||||
|
||||
def _on_page(self, page: Page) -> None:
|
||||
self._pages.append(page)
|
||||
self.emit(BrowserContext.Events.Page, page)
|
||||
if page._opener and not page._opener.is_closed():
|
||||
page._opener.emit(Page.Events.Popup, page)
|
||||
|
||||
async def _on_route(self, route: Route) -> None:
|
||||
route._context = self
|
||||
page = route.request._safe_page()
|
||||
route_handlers = self._routes.copy()
|
||||
for route_handler in route_handlers:
|
||||
# If the page or the context was closed we stall all requests right away.
|
||||
if (page and page._close_was_called) or self._closing_or_closed:
|
||||
return
|
||||
if not route_handler.matches(route.request.url):
|
||||
continue
|
||||
if route_handler not in self._routes:
|
||||
continue
|
||||
if route_handler.will_expire:
|
||||
self._routes.remove(route_handler)
|
||||
try:
|
||||
handled = await route_handler.handle(route)
|
||||
finally:
|
||||
if len(self._routes) == 0:
|
||||
asyncio.create_task(
|
||||
self._connection.wrap_api_call(
|
||||
lambda: self._update_interception_patterns(), True
|
||||
)
|
||||
)
|
||||
if handled:
|
||||
return
|
||||
try:
|
||||
# If the page is closed or unrouteAll() was called without waiting and interception disabled,
|
||||
# the method will throw an error - silence it.
|
||||
await route._inner_continue(True)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
async def _on_web_socket_route(self, web_socket_route: WebSocketRoute) -> None:
|
||||
route_handler = next(
|
||||
(
|
||||
route_handler
|
||||
for route_handler in self._web_socket_routes
|
||||
if route_handler.matches(web_socket_route.url)
|
||||
),
|
||||
None,
|
||||
)
|
||||
if route_handler:
|
||||
await route_handler.handle(web_socket_route)
|
||||
else:
|
||||
web_socket_route.connect_to_server()
|
||||
|
||||
def _on_binding(self, binding_call: BindingCall) -> None:
|
||||
func = self._bindings.get(binding_call._initializer["name"])
|
||||
if func is None:
|
||||
return
|
||||
asyncio.create_task(binding_call.call(func))
|
||||
|
||||
def set_default_navigation_timeout(self, timeout: float) -> None:
|
||||
return self._set_default_navigation_timeout_impl(timeout)
|
||||
|
||||
def _set_default_navigation_timeout_impl(self, timeout: Optional[float]) -> None:
|
||||
self._timeout_settings.set_default_navigation_timeout(timeout)
|
||||
|
||||
def set_default_timeout(self, timeout: float) -> None:
|
||||
return self._set_default_timeout_impl(timeout)
|
||||
|
||||
def _set_default_timeout_impl(self, timeout: Optional[float]) -> None:
|
||||
self._timeout_settings.set_default_timeout(timeout)
|
||||
|
||||
@property
|
||||
def pages(self) -> List[Page]:
|
||||
return self._pages.copy()
|
||||
|
||||
@property
|
||||
def browser(self) -> Optional["Browser"]:
|
||||
return self._browser
|
||||
|
||||
async def _initialize_har_from_options(
|
||||
self,
|
||||
record_har_path: Optional[Union[Path, str]],
|
||||
record_har_content: Optional[HarContentPolicy],
|
||||
record_har_omit_content: Optional[bool],
|
||||
record_har_url_filter: Optional[Union[Pattern[str], str]],
|
||||
record_har_mode: Optional[HarMode],
|
||||
) -> None:
|
||||
if not record_har_path:
|
||||
return
|
||||
record_har_path = str(record_har_path)
|
||||
default_policy: HarContentPolicy = (
|
||||
"attach" if record_har_path.endswith(".zip") else "embed"
|
||||
)
|
||||
content_policy: HarContentPolicy = record_har_content or (
|
||||
"omit" if record_har_omit_content is True else default_policy
|
||||
)
|
||||
await self._record_into_har(
|
||||
har=record_har_path,
|
||||
page=None,
|
||||
url=record_har_url_filter,
|
||||
update_content=content_policy,
|
||||
update_mode=(record_har_mode or "full"),
|
||||
)
|
||||
|
||||
async def new_page(self) -> Page:
|
||||
if self._owner_page:
|
||||
raise Error("Please use browser.new_context()")
|
||||
return from_channel(await self._channel.send("newPage", None))
|
||||
|
||||
async def cookies(self, urls: Union[str, Sequence[str]] = None) -> List[Cookie]:
|
||||
if urls is None:
|
||||
urls = []
|
||||
if isinstance(urls, str):
|
||||
urls = [urls]
|
||||
return await self._channel.send("cookies", None, dict(urls=urls))
|
||||
|
||||
async def add_cookies(self, cookies: Sequence[SetCookieParam]) -> None:
|
||||
await self._channel.send("addCookies", None, dict(cookies=cookies))
|
||||
|
||||
async def clear_cookies(
|
||||
self,
|
||||
name: Union[str, Pattern[str]] = None,
|
||||
domain: Union[str, Pattern[str]] = None,
|
||||
path: Union[str, Pattern[str]] = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"clearCookies",
|
||||
None,
|
||||
{
|
||||
"name": name if isinstance(name, str) else None,
|
||||
"nameRegexSource": name.pattern if isinstance(name, Pattern) else None,
|
||||
"nameRegexFlags": (
|
||||
escape_regex_flags(name) if isinstance(name, Pattern) else None
|
||||
),
|
||||
"domain": domain if isinstance(domain, str) else None,
|
||||
"domainRegexSource": (
|
||||
domain.pattern if isinstance(domain, Pattern) else None
|
||||
),
|
||||
"domainRegexFlags": (
|
||||
escape_regex_flags(domain) if isinstance(domain, Pattern) else None
|
||||
),
|
||||
"path": path if isinstance(path, str) else None,
|
||||
"pathRegexSource": path.pattern if isinstance(path, Pattern) else None,
|
||||
"pathRegexFlags": (
|
||||
escape_regex_flags(path) if isinstance(path, Pattern) else None
|
||||
),
|
||||
},
|
||||
)
|
||||
|
||||
async def grant_permissions(
|
||||
self, permissions: Sequence[str], origin: str = None
|
||||
) -> None:
|
||||
await self._channel.send("grantPermissions", None, locals_to_params(locals()))
|
||||
|
||||
async def clear_permissions(self) -> None:
|
||||
await self._channel.send("clearPermissions", None)
|
||||
|
||||
async def set_geolocation(self, geolocation: Geolocation = None) -> None:
|
||||
await self._channel.send("setGeolocation", None, locals_to_params(locals()))
|
||||
|
||||
async def set_extra_http_headers(self, headers: Dict[str, str]) -> None:
|
||||
await self._channel.send(
|
||||
"setExtraHTTPHeaders", None, dict(headers=serialize_headers(headers))
|
||||
)
|
||||
|
||||
async def set_offline(self, offline: bool) -> None:
|
||||
await self._channel.send("setOffline", None, dict(offline=offline))
|
||||
|
||||
async def add_init_script(
|
||||
self, script: str = None, path: Union[str, Path] = None
|
||||
) -> None:
|
||||
if path:
|
||||
script = (await async_readfile(path)).decode()
|
||||
if not isinstance(script, str):
|
||||
raise Error("Either path or script parameter must be specified")
|
||||
await self._channel.send("addInitScript", None, dict(source=script))
|
||||
|
||||
async def expose_binding(
|
||||
self, name: str, callback: Callable, handle: bool = None
|
||||
) -> None:
|
||||
for page in self._pages:
|
||||
if name in page._bindings:
|
||||
raise Error(
|
||||
f'Function "{name}" has been already registered in one of the pages'
|
||||
)
|
||||
if name in self._bindings:
|
||||
raise Error(f'Function "{name}" has been already registered')
|
||||
self._bindings[name] = callback
|
||||
await self._channel.send(
|
||||
"exposeBinding", None, dict(name=name, needsHandle=handle or False)
|
||||
)
|
||||
|
||||
async def expose_function(self, name: str, callback: Callable) -> None:
|
||||
await self.expose_binding(name, lambda source, *args: callback(*args))
|
||||
|
||||
async def route(
|
||||
self, url: URLMatch, handler: RouteHandlerCallback, times: int = None
|
||||
) -> None:
|
||||
self._routes.insert(
|
||||
0,
|
||||
RouteHandler(
|
||||
self._base_url,
|
||||
url,
|
||||
handler,
|
||||
True if self._dispatcher_fiber else False,
|
||||
times,
|
||||
),
|
||||
)
|
||||
await self._update_interception_patterns()
|
||||
|
||||
async def unroute(
|
||||
self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
|
||||
) -> None:
|
||||
removed = []
|
||||
remaining = []
|
||||
for route in self._routes:
|
||||
if route.url != url or (handler and route.handler != handler):
|
||||
remaining.append(route)
|
||||
else:
|
||||
removed.append(route)
|
||||
await self._unroute_internal(removed, remaining, "default")
|
||||
|
||||
async def _unroute_internal(
|
||||
self,
|
||||
removed: List[RouteHandler],
|
||||
remaining: List[RouteHandler],
|
||||
behavior: Literal["default", "ignoreErrors", "wait"] = None,
|
||||
) -> None:
|
||||
self._routes = remaining
|
||||
if behavior is not None and behavior != "default":
|
||||
await asyncio.gather(*map(lambda router: router.stop(behavior), removed)) # type: ignore
|
||||
await self._update_interception_patterns()
|
||||
|
||||
async def route_web_socket(
|
||||
self, url: URLMatch, handler: WebSocketRouteHandlerCallback
|
||||
) -> None:
|
||||
self._web_socket_routes.insert(
|
||||
0,
|
||||
WebSocketRouteHandler(self._base_url, url, handler),
|
||||
)
|
||||
await self._update_web_socket_interception_patterns()
|
||||
|
||||
def _dispose_har_routers(self) -> None:
|
||||
for router in self._har_routers:
|
||||
router.dispose()
|
||||
self._har_routers = []
|
||||
|
||||
async def unroute_all(
|
||||
self, behavior: Literal["default", "ignoreErrors", "wait"] = None
|
||||
) -> None:
|
||||
await self._unroute_internal(self._routes, [], behavior)
|
||||
self._dispose_har_routers()
|
||||
|
||||
async def _record_into_har(
|
||||
self,
|
||||
har: Union[Path, str],
|
||||
page: Optional[Page] = None,
|
||||
url: Union[Pattern[str], str] = None,
|
||||
update_content: HarContentPolicy = None,
|
||||
update_mode: HarMode = None,
|
||||
) -> None:
|
||||
update_content = update_content or "attach"
|
||||
params: Dict[str, Any] = {
|
||||
"options": {
|
||||
"zip": str(har).endswith(".zip"),
|
||||
"content": update_content,
|
||||
"urlGlob": url if isinstance(url, str) else None,
|
||||
"urlRegexSource": url.pattern if isinstance(url, Pattern) else None,
|
||||
"urlRegexFlags": (
|
||||
escape_regex_flags(url) if isinstance(url, Pattern) else None
|
||||
),
|
||||
"mode": update_mode or "minimal",
|
||||
}
|
||||
}
|
||||
if page:
|
||||
params["page"] = page._channel
|
||||
har_id = await self._channel.send("harStart", None, params)
|
||||
self._har_recorders[har_id] = {
|
||||
"path": str(har),
|
||||
"content": update_content,
|
||||
}
|
||||
|
||||
async def route_from_har(
|
||||
self,
|
||||
har: Union[Path, str],
|
||||
url: Union[Pattern[str], str] = None,
|
||||
notFound: RouteFromHarNotFoundPolicy = None,
|
||||
update: bool = None,
|
||||
updateContent: Literal["attach", "embed"] = None,
|
||||
updateMode: HarMode = None,
|
||||
) -> None:
|
||||
if update:
|
||||
await self._record_into_har(
|
||||
har=har,
|
||||
page=None,
|
||||
url=url,
|
||||
update_content=updateContent,
|
||||
update_mode=updateMode,
|
||||
)
|
||||
return
|
||||
router = await HarRouter.create(
|
||||
local_utils=self._connection.local_utils,
|
||||
file=str(har),
|
||||
not_found_action=notFound or "abort",
|
||||
url_matcher=url,
|
||||
)
|
||||
self._har_routers.append(router)
|
||||
await router.add_context_route(self)
|
||||
|
||||
async def _update_interception_patterns(self) -> None:
|
||||
patterns = RouteHandler.prepare_interception_patterns(self._routes)
|
||||
await self._channel.send(
|
||||
"setNetworkInterceptionPatterns", None, {"patterns": patterns}
|
||||
)
|
||||
|
||||
async def _update_web_socket_interception_patterns(self) -> None:
|
||||
patterns = WebSocketRouteHandler.prepare_interception_patterns(
|
||||
self._web_socket_routes
|
||||
)
|
||||
await self._channel.send(
|
||||
"setWebSocketInterceptionPatterns", None, {"patterns": patterns}
|
||||
)
|
||||
|
||||
def expect_event(
|
||||
self,
|
||||
event: str,
|
||||
predicate: Callable = None,
|
||||
timeout: float = None,
|
||||
) -> EventContextManagerImpl:
|
||||
if timeout is None:
|
||||
timeout = self._timeout_settings.timeout()
|
||||
waiter = Waiter(self, f"browser_context.expect_event({event})")
|
||||
waiter.reject_on_timeout(
|
||||
timeout, f'Timeout {timeout}ms exceeded while waiting for event "{event}"'
|
||||
)
|
||||
if event != BrowserContext.Events.Close:
|
||||
waiter.reject_on_event(
|
||||
self, BrowserContext.Events.Close, lambda: TargetClosedError()
|
||||
)
|
||||
waiter.wait_for_event(self, event, predicate)
|
||||
return EventContextManagerImpl(waiter.result())
|
||||
|
||||
def _on_close(self) -> None:
|
||||
self._closing_or_closed = True
|
||||
if self._browser:
|
||||
if self in self._browser._contexts:
|
||||
self._browser._contexts.remove(self)
|
||||
assert self._browser._browser_type is not None
|
||||
if (
|
||||
self
|
||||
in self._browser._browser_type._playwright.selectors._contexts_for_selectors
|
||||
):
|
||||
self._browser._browser_type._playwright.selectors._contexts_for_selectors.remove(
|
||||
self
|
||||
)
|
||||
|
||||
self._dispose_har_routers()
|
||||
self._tracing._reset_stack_counter()
|
||||
self.emit(BrowserContext.Events.Close, self)
|
||||
|
||||
async def close(self, reason: str = None) -> None:
|
||||
if self._closing_or_closed:
|
||||
return
|
||||
self._close_reason = reason
|
||||
self._closing_or_closed = True
|
||||
|
||||
await self.request.dispose(reason=reason)
|
||||
|
||||
async def _inner_close() -> None:
|
||||
for har_id, params in self._har_recorders.items():
|
||||
har = cast(
|
||||
Artifact,
|
||||
from_channel(
|
||||
await self._channel.send("harExport", None, {"harId": har_id})
|
||||
),
|
||||
)
|
||||
# Server side will compress artifact if content is attach or if file is .zip.
|
||||
is_compressed = params.get("content") == "attach" or params[
|
||||
"path"
|
||||
].endswith(".zip")
|
||||
need_compressed = params["path"].endswith(".zip")
|
||||
if is_compressed and not need_compressed:
|
||||
tmp_path = params["path"] + ".tmp"
|
||||
await har.save_as(tmp_path)
|
||||
await self._connection.local_utils.har_unzip(
|
||||
zipFile=tmp_path, harFile=params["path"]
|
||||
)
|
||||
else:
|
||||
await har.save_as(params["path"])
|
||||
await har.delete()
|
||||
|
||||
await self._channel._connection.wrap_api_call(_inner_close, True)
|
||||
await self._channel.send("close", None, {"reason": reason})
|
||||
await self._closed_future
|
||||
|
||||
async def storage_state(
|
||||
self, path: Union[str, Path] = None, indexedDB: bool = None
|
||||
) -> StorageState:
|
||||
result = await self._channel.send_return_as_dict(
|
||||
"storageState", None, {"indexedDB": indexedDB}
|
||||
)
|
||||
if path:
|
||||
await async_writefile(path, json.dumps(result))
|
||||
return result
|
||||
|
||||
def _effective_close_reason(self) -> Optional[str]:
|
||||
if self._close_reason:
|
||||
return self._close_reason
|
||||
if self._browser:
|
||||
return self._browser._close_reason
|
||||
return None
|
||||
|
||||
async def wait_for_event(
|
||||
self, event: str, predicate: Callable = None, timeout: float = None
|
||||
) -> Any:
|
||||
async with self.expect_event(event, predicate, timeout) as event_info:
|
||||
pass
|
||||
return await event_info
|
||||
|
||||
def expect_console_message(
|
||||
self,
|
||||
predicate: Callable[[ConsoleMessage], bool] = None,
|
||||
timeout: float = None,
|
||||
) -> EventContextManagerImpl[ConsoleMessage]:
|
||||
return self.expect_event(Page.Events.Console, predicate, timeout)
|
||||
|
||||
def expect_page(
|
||||
self,
|
||||
predicate: Callable[[Page], bool] = None,
|
||||
timeout: float = None,
|
||||
) -> EventContextManagerImpl[Page]:
|
||||
return self.expect_event(BrowserContext.Events.Page, predicate, timeout)
|
||||
|
||||
def _on_service_worker(self, worker: Worker) -> None:
|
||||
worker._context = self
|
||||
self._service_workers.add(worker)
|
||||
self.emit(BrowserContext.Events.ServiceWorker, worker)
|
||||
|
||||
def _on_request_failed(
|
||||
self,
|
||||
request: Request,
|
||||
response_end_timing: float,
|
||||
failure_text: Optional[str],
|
||||
page: Optional[Page],
|
||||
) -> None:
|
||||
request._failure_text = failure_text
|
||||
request._set_response_end_timing(response_end_timing)
|
||||
self.emit(BrowserContext.Events.RequestFailed, request)
|
||||
if page:
|
||||
page.emit(Page.Events.RequestFailed, request)
|
||||
|
||||
def _on_request_finished(
|
||||
self,
|
||||
request: Request,
|
||||
response: Optional[Response],
|
||||
response_end_timing: float,
|
||||
page: Optional[Page],
|
||||
) -> None:
|
||||
request._set_response_end_timing(response_end_timing)
|
||||
self.emit(BrowserContext.Events.RequestFinished, request)
|
||||
if page:
|
||||
page.emit(Page.Events.RequestFinished, request)
|
||||
if response:
|
||||
response._finished_future.set_result(True)
|
||||
|
||||
def _on_console_message(self, event: Dict) -> None:
|
||||
message = ConsoleMessage(event, self._loop, self._dispatcher_fiber)
|
||||
worker = message.worker
|
||||
if worker:
|
||||
worker.emit(Worker.Events.Console, message)
|
||||
page = message.page
|
||||
if page:
|
||||
page.emit(Page.Events.Console, message)
|
||||
self.emit(BrowserContext.Events.Console, message)
|
||||
|
||||
def _on_dialog(self, dialog: Dialog) -> None:
|
||||
has_listeners = self.emit(BrowserContext.Events.Dialog, dialog)
|
||||
page = dialog.page
|
||||
if page:
|
||||
has_listeners = page.emit(Page.Events.Dialog, dialog) or has_listeners
|
||||
if not has_listeners:
|
||||
# Although we do similar handling on the server side, we still need this logic
|
||||
# on the client side due to a possible race condition between two async calls:
|
||||
# a) removing "dialog" listener subscription (client->server)
|
||||
# b) actual "dialog" event (server->client)
|
||||
if dialog.type == "beforeunload":
|
||||
asyncio.create_task(dialog.accept())
|
||||
else:
|
||||
asyncio.create_task(dialog.dismiss())
|
||||
|
||||
def _on_page_error(self, error: Error, page: Optional[Page]) -> None:
|
||||
self.emit(
|
||||
BrowserContext.Events.WebError,
|
||||
WebError(self._loop, self._dispatcher_fiber, page, error),
|
||||
)
|
||||
if page:
|
||||
page.emit(Page.Events.PageError, error)
|
||||
|
||||
def _on_request(self, request: Request, page: Optional[Page]) -> None:
|
||||
self.emit(BrowserContext.Events.Request, request)
|
||||
if page:
|
||||
page.emit(Page.Events.Request, request)
|
||||
|
||||
def _on_response(self, response: Response, page: Optional[Page]) -> None:
|
||||
self.emit(BrowserContext.Events.Response, response)
|
||||
if page:
|
||||
page.emit(Page.Events.Response, response)
|
||||
|
||||
@property
|
||||
def background_pages(self) -> List[Page]:
|
||||
return []
|
||||
|
||||
@property
|
||||
def service_workers(self) -> List[Worker]:
|
||||
return list(self._service_workers)
|
||||
|
||||
async def new_cdp_session(self, page: Union[Page, Frame]) -> CDPSession:
|
||||
page = to_impl(page)
|
||||
params = {}
|
||||
if isinstance(page, Page):
|
||||
params["page"] = page._channel
|
||||
elif isinstance(page, Frame):
|
||||
params["frame"] = page._channel
|
||||
else:
|
||||
raise Error("page: expected Page or Frame")
|
||||
return from_channel(await self._channel.send("newCDPSession", None, params))
|
||||
|
||||
@property
|
||||
def tracing(self) -> Tracing:
|
||||
return self._tracing
|
||||
|
||||
@property
|
||||
def request(self) -> "APIRequestContext":
|
||||
return self._request
|
||||
|
||||
@property
|
||||
def clock(self) -> Clock:
|
||||
return self._clock
|
||||
+363
@@ -0,0 +1,363 @@
|
||||
# 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 json
|
||||
import pathlib
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
|
||||
|
||||
from playwright._impl._api_structures import (
|
||||
ClientCertificate,
|
||||
Geolocation,
|
||||
HttpCredentials,
|
||||
ProxySettings,
|
||||
ViewportSize,
|
||||
)
|
||||
from playwright._impl._browser import Browser
|
||||
from playwright._impl._browser_context import BrowserContext
|
||||
from playwright._impl._connection import ChannelOwner, Connection, from_channel
|
||||
from playwright._impl._errors import Error
|
||||
from playwright._impl._helper import (
|
||||
PLAYWRIGHT_MAX_DEADLINE,
|
||||
ColorScheme,
|
||||
Contrast,
|
||||
Env,
|
||||
ForcedColors,
|
||||
HarContentPolicy,
|
||||
HarMode,
|
||||
ReducedMotion,
|
||||
ServiceWorkersPolicy,
|
||||
TimeoutSettings,
|
||||
async_readfile,
|
||||
locals_to_params,
|
||||
)
|
||||
from playwright._impl._json_pipe import JsonPipeTransport
|
||||
from playwright._impl._network import serialize_headers, to_client_certificates_protocol
|
||||
from playwright._impl._waiter import throw_on_timeout
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from playwright._impl._playwright import Playwright
|
||||
|
||||
|
||||
class BrowserType(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self._playwright: "Playwright"
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<BrowserType name={self.name} executable_path={self.executable_path}>"
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
return self._initializer["name"]
|
||||
|
||||
@property
|
||||
def executable_path(self) -> str:
|
||||
return self._initializer["executablePath"]
|
||||
|
||||
async def launch(
|
||||
self,
|
||||
executablePath: Union[str, Path] = None,
|
||||
channel: str = None,
|
||||
args: Sequence[str] = None,
|
||||
ignoreDefaultArgs: Union[bool, Sequence[str]] = None,
|
||||
handleSIGINT: bool = None,
|
||||
handleSIGTERM: bool = None,
|
||||
handleSIGHUP: bool = None,
|
||||
timeout: float = None,
|
||||
env: Env = None,
|
||||
headless: bool = None,
|
||||
proxy: ProxySettings = None,
|
||||
downloadsPath: Union[str, Path] = None,
|
||||
slowMo: float = None,
|
||||
tracesDir: Union[pathlib.Path, str] = None,
|
||||
chromiumSandbox: bool = None,
|
||||
firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
|
||||
) -> Browser:
|
||||
params = locals_to_params(locals())
|
||||
normalize_launch_params(params)
|
||||
browser = cast(
|
||||
Browser,
|
||||
from_channel(
|
||||
await self._channel.send(
|
||||
"launch", TimeoutSettings.launch_timeout, params
|
||||
)
|
||||
),
|
||||
)
|
||||
browser._connect_to_browser_type(
|
||||
self, str(tracesDir) if tracesDir is not None else None
|
||||
)
|
||||
return browser
|
||||
|
||||
async def launch_persistent_context(
|
||||
self,
|
||||
userDataDir: Union[str, Path],
|
||||
channel: str = None,
|
||||
executablePath: Union[str, Path] = None,
|
||||
args: Sequence[str] = None,
|
||||
ignoreDefaultArgs: Union[bool, Sequence[str]] = None,
|
||||
handleSIGINT: bool = None,
|
||||
handleSIGTERM: bool = None,
|
||||
handleSIGHUP: bool = None,
|
||||
timeout: float = None,
|
||||
env: Env = None,
|
||||
headless: bool = None,
|
||||
proxy: ProxySettings = None,
|
||||
downloadsPath: Union[str, Path] = None,
|
||||
slowMo: float = None,
|
||||
viewport: ViewportSize = None,
|
||||
screen: ViewportSize = None,
|
||||
noViewport: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
javaScriptEnabled: bool = None,
|
||||
bypassCSP: bool = None,
|
||||
userAgent: str = None,
|
||||
locale: str = None,
|
||||
timezoneId: str = None,
|
||||
geolocation: Geolocation = None,
|
||||
permissions: Sequence[str] = None,
|
||||
extraHTTPHeaders: Dict[str, str] = None,
|
||||
offline: bool = None,
|
||||
httpCredentials: HttpCredentials = None,
|
||||
deviceScaleFactor: float = None,
|
||||
isMobile: bool = None,
|
||||
hasTouch: bool = None,
|
||||
colorScheme: ColorScheme = None,
|
||||
reducedMotion: ReducedMotion = None,
|
||||
forcedColors: ForcedColors = None,
|
||||
contrast: Contrast = None,
|
||||
acceptDownloads: bool = None,
|
||||
tracesDir: Union[pathlib.Path, str] = None,
|
||||
chromiumSandbox: bool = None,
|
||||
firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
|
||||
recordHarPath: Union[Path, str] = None,
|
||||
recordHarOmitContent: bool = None,
|
||||
recordVideoDir: Union[Path, str] = None,
|
||||
recordVideoSize: ViewportSize = None,
|
||||
baseURL: str = None,
|
||||
strictSelectors: bool = None,
|
||||
serviceWorkers: ServiceWorkersPolicy = None,
|
||||
recordHarUrlFilter: Union[Pattern[str], str] = None,
|
||||
recordHarMode: HarMode = None,
|
||||
recordHarContent: HarContentPolicy = None,
|
||||
clientCertificates: List[ClientCertificate] = None,
|
||||
) -> BrowserContext:
|
||||
userDataDir = self._user_data_dir(userDataDir)
|
||||
params = locals_to_params(locals())
|
||||
await self._prepare_browser_context_params(params)
|
||||
normalize_launch_params(params)
|
||||
result = await self._channel.send_return_as_dict(
|
||||
"launchPersistentContext", TimeoutSettings.launch_timeout, params
|
||||
)
|
||||
browser = cast(
|
||||
Browser,
|
||||
from_channel(result["browser"]),
|
||||
)
|
||||
browser._connect_to_browser_type(
|
||||
self, str(tracesDir) if tracesDir is not None else None
|
||||
)
|
||||
context = cast(BrowserContext, from_channel(result["context"]))
|
||||
await context._initialize_har_from_options(
|
||||
record_har_content=recordHarContent,
|
||||
record_har_mode=recordHarMode,
|
||||
record_har_omit_content=recordHarOmitContent,
|
||||
record_har_path=recordHarPath,
|
||||
record_har_url_filter=recordHarUrlFilter,
|
||||
)
|
||||
return context
|
||||
|
||||
def _user_data_dir(self, userDataDir: Optional[Union[str, Path]]) -> str:
|
||||
if not userDataDir:
|
||||
return ""
|
||||
if not Path(userDataDir).is_absolute():
|
||||
# Can be dropped once we drop Python 3.9 support (10/2025):
|
||||
# https://github.com/python/cpython/issues/82852
|
||||
if sys.platform == "win32" and sys.version_info[:2] < (3, 10):
|
||||
return str(pathlib.Path.cwd() / userDataDir)
|
||||
return str(Path(userDataDir).resolve())
|
||||
return str(Path(userDataDir))
|
||||
|
||||
async def connect_over_cdp(
|
||||
self,
|
||||
endpointURL: str,
|
||||
timeout: float = None,
|
||||
slowMo: float = None,
|
||||
headers: Dict[str, str] = None,
|
||||
isLocal: bool = None,
|
||||
) -> Browser:
|
||||
params = locals_to_params(locals())
|
||||
if params.get("headers"):
|
||||
params["headers"] = serialize_headers(params["headers"])
|
||||
response = await self._channel.send_return_as_dict(
|
||||
"connectOverCDP", TimeoutSettings.launch_timeout, params
|
||||
)
|
||||
browser = cast(Browser, from_channel(response["browser"]))
|
||||
browser._connect_to_browser_type(self, None)
|
||||
|
||||
return browser
|
||||
|
||||
async def connect(
|
||||
self,
|
||||
wsEndpoint: str,
|
||||
timeout: float = None,
|
||||
slowMo: float = None,
|
||||
headers: Dict[str, str] = None,
|
||||
exposeNetwork: str = None,
|
||||
) -> Browser:
|
||||
if slowMo is None:
|
||||
slowMo = 0
|
||||
|
||||
headers = {**(headers if headers else {}), "x-playwright-browser": self.name}
|
||||
local_utils = self._connection.local_utils
|
||||
pipe_channel = (
|
||||
await local_utils._channel.send_return_as_dict(
|
||||
"connect",
|
||||
None,
|
||||
{
|
||||
"wsEndpoint": wsEndpoint,
|
||||
"headers": headers,
|
||||
"slowMo": slowMo,
|
||||
"timeout": timeout if timeout is not None else 0,
|
||||
"exposeNetwork": exposeNetwork,
|
||||
},
|
||||
)
|
||||
)["pipe"]
|
||||
transport = JsonPipeTransport(self._connection._loop, pipe_channel)
|
||||
|
||||
connection = Connection(
|
||||
self._connection._dispatcher_fiber,
|
||||
self._connection._object_factory,
|
||||
transport,
|
||||
self._connection._loop,
|
||||
local_utils=self._connection.local_utils,
|
||||
)
|
||||
connection.mark_as_remote()
|
||||
|
||||
browser = None
|
||||
|
||||
def handle_transport_close(reason: Optional[str]) -> None:
|
||||
if browser:
|
||||
for context in browser.contexts:
|
||||
for page in context.pages:
|
||||
page._on_close()
|
||||
context._on_close()
|
||||
browser._on_close()
|
||||
connection.cleanup(reason)
|
||||
# TODO: Backport https://github.com/microsoft/playwright/commit/d8d5289e8692c9b1265d23ee66988d1ac5122f33
|
||||
# Give a chance to any API call promises to reject upon page/context closure.
|
||||
# This happens naturally when we receive page.onClose and browser.onClose from the server
|
||||
# in separate tasks. However, upon pipe closure we used to dispatch them all synchronously
|
||||
# here and promises did not have a chance to reject.
|
||||
# The order of rejects vs closure is a part of the API contract and our test runner
|
||||
# relies on it to attribute rejections to the right test.
|
||||
|
||||
transport.once("close", handle_transport_close)
|
||||
|
||||
connection._is_sync = self._connection._is_sync
|
||||
connection._loop.create_task(connection.run())
|
||||
playwright_future = connection.playwright_future
|
||||
|
||||
timeout_future = throw_on_timeout(
|
||||
timeout if timeout is not None else PLAYWRIGHT_MAX_DEADLINE,
|
||||
Error("Connection timed out"),
|
||||
)
|
||||
done, pending = await asyncio.wait(
|
||||
{transport.on_error_future, playwright_future, timeout_future},
|
||||
return_when=asyncio.FIRST_COMPLETED,
|
||||
)
|
||||
if not playwright_future.done():
|
||||
playwright_future.cancel()
|
||||
if not timeout_future.done():
|
||||
timeout_future.cancel()
|
||||
playwright: "Playwright" = next(iter(done)).result()
|
||||
playwright._set_selectors(self._playwright.selectors)
|
||||
self._connection._child_ws_connections.append(connection)
|
||||
pre_launched_browser = playwright._initializer.get("preLaunchedBrowser")
|
||||
assert pre_launched_browser
|
||||
browser = cast(Browser, from_channel(pre_launched_browser))
|
||||
browser._should_close_connection_on_close = True
|
||||
browser._connect_to_browser_type(self, None)
|
||||
|
||||
return browser
|
||||
|
||||
async def _prepare_browser_context_params(self, params: Dict) -> None:
|
||||
if params.get("noViewport"):
|
||||
del params["noViewport"]
|
||||
params["noDefaultViewport"] = True
|
||||
if "defaultBrowserType" in params:
|
||||
del params["defaultBrowserType"]
|
||||
if "extraHTTPHeaders" in params:
|
||||
params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
|
||||
if "recordVideoDir" in params:
|
||||
params["recordVideo"] = {"dir": Path(params["recordVideoDir"]).absolute()}
|
||||
if "recordVideoSize" in params:
|
||||
params["recordVideo"]["size"] = params["recordVideoSize"]
|
||||
del params["recordVideoSize"]
|
||||
del params["recordVideoDir"]
|
||||
if "storageState" in params:
|
||||
storageState = params["storageState"]
|
||||
if not isinstance(storageState, dict):
|
||||
params["storageState"] = json.loads(
|
||||
(await async_readfile(storageState)).decode()
|
||||
)
|
||||
if params.get("colorScheme", None) == "null":
|
||||
params["colorScheme"] = "no-override"
|
||||
if params.get("reducedMotion", None) == "null":
|
||||
params["reducedMotion"] = "no-override"
|
||||
if params.get("forcedColors", None) == "null":
|
||||
params["forcedColors"] = "no-override"
|
||||
if params.get("contrast", None) == "null":
|
||||
params["contrast"] = "no-override"
|
||||
if "acceptDownloads" in params:
|
||||
params["acceptDownloads"] = (
|
||||
"accept" if params["acceptDownloads"] else "deny"
|
||||
)
|
||||
|
||||
if "clientCertificates" in params:
|
||||
params["clientCertificates"] = await to_client_certificates_protocol(
|
||||
params["clientCertificates"]
|
||||
)
|
||||
params["selectorEngines"] = self._playwright.selectors._selector_engines
|
||||
params["testIdAttributeName"] = (
|
||||
self._playwright.selectors._test_id_attribute_name
|
||||
)
|
||||
|
||||
# Remove HAR options
|
||||
params.pop("recordHarPath", None)
|
||||
params.pop("recordHarOmitContent", None)
|
||||
params.pop("recordHarUrlFilter", None)
|
||||
params.pop("recordHarMode", None)
|
||||
params.pop("recordHarContent", None)
|
||||
|
||||
|
||||
def normalize_launch_params(params: Dict) -> None:
|
||||
if "env" in params:
|
||||
params["env"] = [
|
||||
{"name": name, "value": str(value)}
|
||||
for [name, value] in params["env"].items()
|
||||
]
|
||||
if "ignoreDefaultArgs" in params:
|
||||
if params["ignoreDefaultArgs"] is True:
|
||||
params["ignoreAllDefaultArgs"] = True
|
||||
del params["ignoreDefaultArgs"]
|
||||
if "executablePath" in params:
|
||||
params["executablePath"] = str(Path(params["executablePath"]))
|
||||
if "downloadsPath" in params:
|
||||
params["downloadsPath"] = str(Path(params["downloadsPath"]))
|
||||
if "tracesDir" in params:
|
||||
params["tracesDir"] = str(Path(params["tracesDir"]))
|
||||
+38
@@ -0,0 +1,38 @@
|
||||
# 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.
|
||||
|
||||
from typing import Any, Dict
|
||||
|
||||
from playwright._impl._connection import ChannelOwner
|
||||
from playwright._impl._helper import locals_to_params
|
||||
|
||||
|
||||
class CDPSession(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self._channel.on("event", lambda params: self._on_event(params))
|
||||
|
||||
def _on_event(self, params: Any) -> None:
|
||||
self.emit(params["method"], params.get("params"))
|
||||
|
||||
async def send(self, method: str, params: Dict = None) -> Dict:
|
||||
return await self._channel.send("send", None, locals_to_params(locals()))
|
||||
|
||||
async def detach(self) -> None:
|
||||
await self._channel.send(
|
||||
"detach",
|
||||
None,
|
||||
)
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
# 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 datetime
|
||||
from typing import TYPE_CHECKING, Dict, Union
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from playwright._impl._browser_context import BrowserContext
|
||||
|
||||
|
||||
class Clock:
|
||||
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, time: Union[float, str, datetime.datetime] = None) -> None:
|
||||
await self._browser_context._channel.send(
|
||||
"clockInstall",
|
||||
None,
|
||||
parse_time(time) if time is not None else {},
|
||||
)
|
||||
|
||||
async def fast_forward(
|
||||
self,
|
||||
ticks: Union[int, str],
|
||||
) -> None:
|
||||
await self._browser_context._channel.send(
|
||||
"clockFastForward",
|
||||
None,
|
||||
parse_ticks(ticks),
|
||||
)
|
||||
|
||||
async def pause_at(
|
||||
self,
|
||||
time: Union[float, str, datetime.datetime],
|
||||
) -> None:
|
||||
await self._browser_context._channel.send(
|
||||
"clockPauseAt",
|
||||
None,
|
||||
parse_time(time),
|
||||
)
|
||||
|
||||
async def resume(
|
||||
self,
|
||||
) -> None:
|
||||
await self._browser_context._channel.send("clockResume", None)
|
||||
|
||||
async def run_for(
|
||||
self,
|
||||
ticks: Union[int, str],
|
||||
) -> None:
|
||||
await self._browser_context._channel.send(
|
||||
"clockRunFor",
|
||||
None,
|
||||
parse_ticks(ticks),
|
||||
)
|
||||
|
||||
async def set_fixed_time(
|
||||
self,
|
||||
time: Union[float, str, datetime.datetime],
|
||||
) -> None:
|
||||
await self._browser_context._channel.send(
|
||||
"clockSetFixedTime",
|
||||
None,
|
||||
parse_time(time),
|
||||
)
|
||||
|
||||
async def set_system_time(
|
||||
self,
|
||||
time: Union[float, str, datetime.datetime],
|
||||
) -> None:
|
||||
await self._browser_context._channel.send(
|
||||
"clockSetSystemTime",
|
||||
None,
|
||||
parse_time(time),
|
||||
)
|
||||
|
||||
|
||||
def parse_time(
|
||||
time: Union[float, str, datetime.datetime],
|
||||
) -> Dict[str, Union[int, str]]:
|
||||
if isinstance(time, (float, int)):
|
||||
return {"timeNumber": int(time * 1_000)}
|
||||
if isinstance(time, str):
|
||||
return {"timeString": time}
|
||||
return {"timeNumber": int(time.timestamp() * 1_000)}
|
||||
|
||||
|
||||
def parse_ticks(ticks: Union[int, str]) -> Dict[str, Union[int, str]]:
|
||||
if isinstance(ticks, int):
|
||||
return {"ticksNumber": ticks}
|
||||
return {"ticksString": ticks}
|
||||
+673
@@ -0,0 +1,673 @@
|
||||
# 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 collections.abc
|
||||
import contextvars
|
||||
import datetime
|
||||
import inspect
|
||||
import sys
|
||||
import traceback
|
||||
from pathlib import Path
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Callable,
|
||||
Dict,
|
||||
List,
|
||||
Mapping,
|
||||
Optional,
|
||||
TypedDict,
|
||||
Union,
|
||||
cast,
|
||||
)
|
||||
|
||||
from pyee import EventEmitter
|
||||
from pyee.asyncio import AsyncIOEventEmitter
|
||||
|
||||
import playwright
|
||||
import playwright._impl._impl_to_api_mapping
|
||||
from playwright._impl._errors import TargetClosedError, rewrite_error
|
||||
from playwright._impl._greenlets import EventGreenlet
|
||||
from playwright._impl._helper import Error, ParsedMessagePayload, parse_error
|
||||
from playwright._impl._transport import Transport
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from playwright._impl._local_utils import LocalUtils
|
||||
from playwright._impl._playwright import Playwright
|
||||
|
||||
TimeoutCalculator = Optional[Callable[[Optional[float]], float]]
|
||||
|
||||
|
||||
class Channel(AsyncIOEventEmitter):
|
||||
def __init__(self, connection: "Connection", object: "ChannelOwner") -> None:
|
||||
super().__init__()
|
||||
self._connection = connection
|
||||
self._guid = object._guid
|
||||
self._object = object
|
||||
self.on("error", lambda exc: self._connection._on_event_listener_error(exc))
|
||||
|
||||
async def send(
|
||||
self,
|
||||
method: str,
|
||||
timeout_calculator: TimeoutCalculator,
|
||||
params: Dict = None,
|
||||
is_internal: bool = False,
|
||||
title: str = None,
|
||||
) -> Any:
|
||||
return await self._connection.wrap_api_call(
|
||||
lambda: self._inner_send(method, timeout_calculator, params, False),
|
||||
is_internal,
|
||||
title,
|
||||
)
|
||||
|
||||
async def send_return_as_dict(
|
||||
self,
|
||||
method: str,
|
||||
timeout_calculator: TimeoutCalculator,
|
||||
params: Dict = None,
|
||||
is_internal: bool = False,
|
||||
title: str = None,
|
||||
) -> Any:
|
||||
return await self._connection.wrap_api_call(
|
||||
lambda: self._inner_send(method, timeout_calculator, params, True),
|
||||
is_internal,
|
||||
title,
|
||||
)
|
||||
|
||||
def send_no_reply(
|
||||
self,
|
||||
method: str,
|
||||
timeout_calculator: TimeoutCalculator,
|
||||
params: Dict = None,
|
||||
is_internal: bool = False,
|
||||
title: str = None,
|
||||
) -> None:
|
||||
# No reply messages are used to e.g. waitForEventInfo(after).
|
||||
self._connection.wrap_api_call_sync(
|
||||
lambda: self._connection._send_message_to_server(
|
||||
self._object,
|
||||
method,
|
||||
_augment_params(params, timeout_calculator),
|
||||
True,
|
||||
),
|
||||
is_internal,
|
||||
title,
|
||||
)
|
||||
|
||||
async def _inner_send(
|
||||
self,
|
||||
method: str,
|
||||
timeout_calculator: TimeoutCalculator,
|
||||
params: Optional[Dict],
|
||||
return_as_dict: bool,
|
||||
) -> Any:
|
||||
if self._connection._error:
|
||||
error = self._connection._error
|
||||
self._connection._error = None
|
||||
raise error
|
||||
callback = self._connection._send_message_to_server(
|
||||
self._object, method, _augment_params(params, timeout_calculator)
|
||||
)
|
||||
done, _ = await asyncio.wait(
|
||||
{
|
||||
self._connection._transport.on_error_future,
|
||||
callback.future,
|
||||
},
|
||||
return_when=asyncio.FIRST_COMPLETED,
|
||||
)
|
||||
if not callback.future.done():
|
||||
callback.future.cancel()
|
||||
result = next(iter(done)).result()
|
||||
# Protocol now has named return values, assume result is one level deeper unless
|
||||
# there is explicit ambiguity.
|
||||
if not result:
|
||||
return None
|
||||
assert isinstance(result, dict)
|
||||
if return_as_dict:
|
||||
return result
|
||||
if len(result) == 0:
|
||||
return None
|
||||
assert len(result) == 1
|
||||
key = next(iter(result))
|
||||
return result[key]
|
||||
|
||||
|
||||
class ChannelOwner(AsyncIOEventEmitter):
|
||||
def __init__(
|
||||
self,
|
||||
parent: Union["ChannelOwner", "Connection"],
|
||||
type: str,
|
||||
guid: str,
|
||||
initializer: Dict,
|
||||
) -> None:
|
||||
super().__init__(loop=parent._loop)
|
||||
self._loop: asyncio.AbstractEventLoop = parent._loop
|
||||
self._dispatcher_fiber: Any = parent._dispatcher_fiber
|
||||
self._type = type
|
||||
self._guid: str = guid
|
||||
self._connection: Connection = (
|
||||
parent._connection if isinstance(parent, ChannelOwner) else parent
|
||||
)
|
||||
self._parent: Optional[ChannelOwner] = (
|
||||
parent if isinstance(parent, ChannelOwner) else None
|
||||
)
|
||||
self._objects: Dict[str, "ChannelOwner"] = {}
|
||||
self._channel: Channel = Channel(self._connection, self)
|
||||
self._initializer = initializer
|
||||
self._was_collected = False
|
||||
|
||||
self._connection._objects[guid] = self
|
||||
if self._parent:
|
||||
self._parent._objects[guid] = self
|
||||
|
||||
self._event_to_subscription_mapping: Dict[str, str] = {}
|
||||
|
||||
def _dispose(self, reason: Optional[str]) -> None:
|
||||
# Clean up from parent and connection.
|
||||
if self._parent:
|
||||
del self._parent._objects[self._guid]
|
||||
del self._connection._objects[self._guid]
|
||||
self._was_collected = reason == "gc"
|
||||
|
||||
# Dispose all children.
|
||||
for object in list(self._objects.values()):
|
||||
object._dispose(reason)
|
||||
self._objects.clear()
|
||||
|
||||
def _adopt(self, child: "ChannelOwner") -> None:
|
||||
del cast("ChannelOwner", child._parent)._objects[child._guid]
|
||||
self._objects[child._guid] = child
|
||||
child._parent = self
|
||||
|
||||
def _set_event_to_subscription_mapping(self, mapping: Dict[str, str]) -> None:
|
||||
self._event_to_subscription_mapping = mapping
|
||||
|
||||
def _update_subscription(self, event: str, enabled: bool) -> None:
|
||||
protocol_event = self._event_to_subscription_mapping.get(event)
|
||||
if protocol_event:
|
||||
self._connection.wrap_api_call_sync(
|
||||
lambda: self._channel.send_no_reply(
|
||||
"updateSubscription",
|
||||
None,
|
||||
{"event": protocol_event, "enabled": enabled},
|
||||
),
|
||||
True,
|
||||
)
|
||||
|
||||
def _add_event_handler(self, event: str, k: Any, v: Any) -> None:
|
||||
if not self.listeners(event):
|
||||
self._update_subscription(event, True)
|
||||
super()._add_event_handler(event, k, v)
|
||||
|
||||
def remove_listener(self, event: str, f: Any) -> None:
|
||||
super().remove_listener(event, f)
|
||||
if not self.listeners(event):
|
||||
self._update_subscription(event, False)
|
||||
|
||||
|
||||
class ProtocolCallback:
|
||||
def __init__(self, loop: asyncio.AbstractEventLoop, no_reply: bool = False) -> None:
|
||||
self.stack_trace: traceback.StackSummary
|
||||
self.no_reply = no_reply
|
||||
self.future = loop.create_future()
|
||||
if no_reply:
|
||||
self.future.set_result(None)
|
||||
# The outer task can get cancelled by the user, this forwards the cancellation to the inner task.
|
||||
current_task = asyncio.current_task()
|
||||
|
||||
def cb(task: asyncio.Task) -> None:
|
||||
if current_task:
|
||||
current_task.remove_done_callback(cb)
|
||||
if task.cancelled():
|
||||
self.future.cancel()
|
||||
|
||||
if current_task:
|
||||
current_task.add_done_callback(cb)
|
||||
self.future.add_done_callback(
|
||||
lambda _: (
|
||||
current_task.remove_done_callback(cb) if current_task else None
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class RootChannelOwner(ChannelOwner):
|
||||
def __init__(self, connection: "Connection") -> None:
|
||||
super().__init__(connection, "Root", "", {})
|
||||
|
||||
async def initialize(self) -> "Playwright":
|
||||
return from_channel(
|
||||
await self._channel.send(
|
||||
"initialize",
|
||||
None,
|
||||
{
|
||||
"sdkLanguage": "python",
|
||||
},
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class Connection(EventEmitter):
|
||||
def __init__(
|
||||
self,
|
||||
dispatcher_fiber: Any,
|
||||
object_factory: Callable[[ChannelOwner, str, str, Dict], ChannelOwner],
|
||||
transport: Transport,
|
||||
loop: asyncio.AbstractEventLoop,
|
||||
local_utils: Optional["LocalUtils"] = None,
|
||||
) -> None:
|
||||
super().__init__()
|
||||
self._dispatcher_fiber = dispatcher_fiber
|
||||
self._transport = transport
|
||||
self._transport.on_message = lambda msg: self.dispatch(msg)
|
||||
self._waiting_for_object: Dict[str, Callable[[ChannelOwner], None]] = {}
|
||||
self._last_id = 0
|
||||
self._objects: Dict[str, ChannelOwner] = {}
|
||||
self._callbacks: Dict[int, ProtocolCallback] = {}
|
||||
self._object_factory = object_factory
|
||||
self._is_sync = False
|
||||
self._child_ws_connections: List["Connection"] = []
|
||||
self._loop = loop
|
||||
self.playwright_future: asyncio.Future["Playwright"] = loop.create_future()
|
||||
self._error: Optional[BaseException] = None
|
||||
self.is_remote = False
|
||||
self._init_task: Optional[asyncio.Task] = None
|
||||
self._api_zone: contextvars.ContextVar[Optional[ParsedStackTrace]] = (
|
||||
contextvars.ContextVar("ApiZone", default=None)
|
||||
)
|
||||
self._local_utils: Optional["LocalUtils"] = local_utils
|
||||
self._tracing_count = 0
|
||||
self._closed_error: Optional[Exception] = None
|
||||
|
||||
@property
|
||||
def local_utils(self) -> "LocalUtils":
|
||||
assert self._local_utils
|
||||
return self._local_utils
|
||||
|
||||
def mark_as_remote(self) -> None:
|
||||
self.is_remote = True
|
||||
|
||||
async def run_as_sync(self) -> None:
|
||||
self._is_sync = True
|
||||
await self.run()
|
||||
|
||||
async def run(self) -> None:
|
||||
self._loop = asyncio.get_running_loop()
|
||||
self._root_object = RootChannelOwner(self)
|
||||
|
||||
async def init() -> None:
|
||||
self.playwright_future.set_result(await self._root_object.initialize())
|
||||
|
||||
await self._transport.connect()
|
||||
self._init_task = self._loop.create_task(init())
|
||||
await self._transport.run()
|
||||
|
||||
def stop_sync(self) -> None:
|
||||
self._transport.request_stop()
|
||||
self._dispatcher_fiber.switch()
|
||||
self._loop.run_until_complete(self._transport.wait_until_stopped())
|
||||
self.cleanup()
|
||||
|
||||
async def stop_async(self) -> None:
|
||||
self._transport.request_stop()
|
||||
await self._transport.wait_until_stopped()
|
||||
self.cleanup()
|
||||
|
||||
def cleanup(self, cause: str = None) -> None:
|
||||
self._closed_error = TargetClosedError(cause) if cause else TargetClosedError()
|
||||
if self._init_task and not self._init_task.done():
|
||||
self._init_task.cancel()
|
||||
for ws_connection in self._child_ws_connections:
|
||||
ws_connection._transport.dispose()
|
||||
for callback in self._callbacks.values():
|
||||
# To prevent 'Future exception was never retrieved' we ignore all callbacks that are no_reply.
|
||||
if callback.no_reply:
|
||||
continue
|
||||
if callback.future.cancelled():
|
||||
continue
|
||||
callback.future.set_exception(self._closed_error)
|
||||
self._callbacks.clear()
|
||||
self.emit("close")
|
||||
|
||||
def call_on_object_with_known_name(
|
||||
self, guid: str, callback: Callable[[ChannelOwner], None]
|
||||
) -> None:
|
||||
self._waiting_for_object[guid] = callback
|
||||
|
||||
def set_is_tracing(self, is_tracing: bool) -> None:
|
||||
if is_tracing:
|
||||
self._tracing_count += 1
|
||||
else:
|
||||
self._tracing_count -= 1
|
||||
|
||||
def _send_message_to_server(
|
||||
self, object: ChannelOwner, method: str, params: Dict, no_reply: bool = False
|
||||
) -> ProtocolCallback:
|
||||
if self._closed_error:
|
||||
raise self._closed_error
|
||||
if object._was_collected:
|
||||
raise Error(
|
||||
"The object has been collected to prevent unbounded heap growth."
|
||||
)
|
||||
self._last_id += 1
|
||||
id = self._last_id
|
||||
callback = ProtocolCallback(self._loop, no_reply=no_reply)
|
||||
task = asyncio.current_task(self._loop)
|
||||
callback.stack_trace = cast(
|
||||
traceback.StackSummary,
|
||||
getattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10)),
|
||||
)
|
||||
callback.no_reply = no_reply
|
||||
stack_trace_information = cast(ParsedStackTrace, self._api_zone.get())
|
||||
frames = stack_trace_information.get("frames", [])
|
||||
location = (
|
||||
{
|
||||
"file": frames[0]["file"],
|
||||
"line": frames[0]["line"],
|
||||
"column": frames[0]["column"],
|
||||
}
|
||||
if frames
|
||||
else None
|
||||
)
|
||||
metadata = {
|
||||
"wallTime": int(datetime.datetime.now().timestamp() * 1000),
|
||||
"apiName": stack_trace_information["apiName"],
|
||||
"internal": not stack_trace_information["apiName"],
|
||||
}
|
||||
if location:
|
||||
metadata["location"] = location # type: ignore
|
||||
title = stack_trace_information["title"]
|
||||
if title:
|
||||
metadata["title"] = title
|
||||
message = {
|
||||
"id": id,
|
||||
"guid": object._guid,
|
||||
"method": method,
|
||||
"params": self._replace_channels_with_guids(params),
|
||||
"metadata": metadata,
|
||||
}
|
||||
if self._tracing_count > 0 and frames and object._guid != "localUtils":
|
||||
self.local_utils.add_stack_to_tracing_no_reply(id, frames)
|
||||
|
||||
self._callbacks[id] = callback
|
||||
self._transport.send(message)
|
||||
|
||||
return callback
|
||||
|
||||
def dispatch(self, msg: ParsedMessagePayload) -> None:
|
||||
if self._closed_error:
|
||||
return
|
||||
id = msg.get("id")
|
||||
if id:
|
||||
callback = self._callbacks.pop(id)
|
||||
if callback.future.cancelled():
|
||||
return
|
||||
# No reply messages are used to e.g. waitForEventInfo(after) which returns exceptions on page close.
|
||||
# To prevent 'Future exception was never retrieved' we just ignore such messages.
|
||||
if callback.no_reply:
|
||||
return
|
||||
error = msg.get("error")
|
||||
if error and not msg.get("result"):
|
||||
parsed_error = parse_error(
|
||||
error["error"], format_call_log(msg.get("log")) # type: ignore
|
||||
)
|
||||
parsed_error._stack = "".join(callback.stack_trace.format())
|
||||
callback.future.set_exception(parsed_error)
|
||||
else:
|
||||
result = self._replace_guids_with_channels(msg.get("result"))
|
||||
callback.future.set_result(result)
|
||||
return
|
||||
|
||||
guid = msg["guid"]
|
||||
method = msg["method"]
|
||||
params = msg.get("params")
|
||||
if method == "__create__":
|
||||
assert params
|
||||
parent = self._objects[guid]
|
||||
self._create_remote_object(
|
||||
parent, params["type"], params["guid"], params["initializer"]
|
||||
)
|
||||
return
|
||||
|
||||
object = self._objects.get(guid)
|
||||
if not object:
|
||||
raise Exception(f'Cannot find object to "{method}": {guid}')
|
||||
|
||||
if method == "__adopt__":
|
||||
child_guid = cast(Dict[str, str], params)["guid"]
|
||||
child = self._objects.get(child_guid)
|
||||
if not child:
|
||||
raise Exception(f"Unknown new child: {child_guid}")
|
||||
object._adopt(child)
|
||||
return
|
||||
|
||||
if method == "__dispose__":
|
||||
assert isinstance(params, dict)
|
||||
self._objects[guid]._dispose(cast(Optional[str], params.get("reason")))
|
||||
return
|
||||
object = self._objects[guid]
|
||||
should_replace_guids_with_channels = "jsonPipe@" not in guid
|
||||
try:
|
||||
if self._is_sync:
|
||||
for listener in object._channel.listeners(method):
|
||||
# Event handlers like route/locatorHandlerTriggered require us to perform async work.
|
||||
# In order to report their potential errors to the user, we need to catch it and store it in the connection
|
||||
def _done_callback(future: asyncio.Future) -> None:
|
||||
exc = future.exception()
|
||||
if exc:
|
||||
self._on_event_listener_error(exc)
|
||||
|
||||
def _listener_with_error_handler_attached(params: Any) -> None:
|
||||
potential_future = listener(params)
|
||||
if asyncio.isfuture(potential_future):
|
||||
potential_future.add_done_callback(_done_callback)
|
||||
|
||||
# Each event handler is a potentilly blocking context, create a fiber for each
|
||||
# and switch to them in order, until they block inside and pass control to each
|
||||
# other and then eventually back to dispatcher as listener functions return.
|
||||
g = EventGreenlet(_listener_with_error_handler_attached)
|
||||
if should_replace_guids_with_channels:
|
||||
g.switch(self._replace_guids_with_channels(params))
|
||||
else:
|
||||
g.switch(params)
|
||||
else:
|
||||
if should_replace_guids_with_channels:
|
||||
object._channel.emit(
|
||||
method, self._replace_guids_with_channels(params)
|
||||
)
|
||||
else:
|
||||
object._channel.emit(method, params)
|
||||
except BaseException as exc:
|
||||
self._on_event_listener_error(exc)
|
||||
|
||||
def _on_event_listener_error(self, exc: BaseException) -> None:
|
||||
print("Error occurred in event listener", file=sys.stderr)
|
||||
traceback.print_exception(type(exc), exc, exc.__traceback__, file=sys.stderr)
|
||||
# Save the error to throw at the next API call. This "replicates" unhandled rejection in Node.js.
|
||||
self._error = exc
|
||||
|
||||
def _create_remote_object(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> ChannelOwner:
|
||||
initializer = self._replace_guids_with_channels(initializer)
|
||||
result = self._object_factory(parent, type, guid, initializer)
|
||||
if guid in self._waiting_for_object:
|
||||
self._waiting_for_object.pop(guid)(result)
|
||||
return result
|
||||
|
||||
def _replace_channels_with_guids(
|
||||
self,
|
||||
payload: Any,
|
||||
) -> Any:
|
||||
if payload is None:
|
||||
return payload
|
||||
if isinstance(payload, Path):
|
||||
return str(payload)
|
||||
if isinstance(payload, collections.abc.Sequence) and not isinstance(
|
||||
payload, str
|
||||
):
|
||||
return list(map(self._replace_channels_with_guids, payload))
|
||||
if isinstance(payload, Channel):
|
||||
return dict(guid=payload._guid)
|
||||
if isinstance(payload, dict):
|
||||
result = {}
|
||||
for key, value in payload.items():
|
||||
result[key] = self._replace_channels_with_guids(value)
|
||||
return result
|
||||
return payload
|
||||
|
||||
def _replace_guids_with_channels(self, payload: Any) -> Any:
|
||||
if payload is None:
|
||||
return payload
|
||||
if isinstance(payload, list):
|
||||
return list(map(self._replace_guids_with_channels, payload))
|
||||
if isinstance(payload, dict):
|
||||
if payload.get("guid") in self._objects:
|
||||
return self._objects[payload["guid"]]._channel
|
||||
result = {}
|
||||
for key, value in payload.items():
|
||||
result[key] = self._replace_guids_with_channels(value)
|
||||
return result
|
||||
return payload
|
||||
|
||||
async def wrap_api_call(
|
||||
self, cb: Callable[[], Any], is_internal: bool = False, title: str = None
|
||||
) -> Any:
|
||||
if self._api_zone.get():
|
||||
return await cb()
|
||||
task = asyncio.current_task(self._loop)
|
||||
st: List[inspect.FrameInfo] = getattr(
|
||||
task, "__pw_stack__", None
|
||||
) or inspect.stack(0)
|
||||
|
||||
parsed_st = _extract_stack_trace_information_from_stack(st, is_internal, title)
|
||||
self._api_zone.set(parsed_st)
|
||||
try:
|
||||
return await cb()
|
||||
except Exception as error:
|
||||
raise rewrite_error(error, f"{parsed_st['apiName']}: {error}") from None
|
||||
finally:
|
||||
self._api_zone.set(None)
|
||||
|
||||
def wrap_api_call_sync(
|
||||
self, cb: Callable[[], Any], is_internal: bool = False, title: str = None
|
||||
) -> Any:
|
||||
if self._api_zone.get():
|
||||
return cb()
|
||||
task = asyncio.current_task(self._loop)
|
||||
st: List[inspect.FrameInfo] = getattr(
|
||||
task, "__pw_stack__", None
|
||||
) or inspect.stack(0)
|
||||
parsed_st = _extract_stack_trace_information_from_stack(st, is_internal, title)
|
||||
self._api_zone.set(parsed_st)
|
||||
try:
|
||||
return cb()
|
||||
except Exception as error:
|
||||
raise rewrite_error(error, f"{parsed_st['apiName']}: {error}") from None
|
||||
finally:
|
||||
self._api_zone.set(None)
|
||||
|
||||
|
||||
def from_channel(channel: Channel) -> Any:
|
||||
return channel._object
|
||||
|
||||
|
||||
def from_nullable_channel(channel: Optional[Channel]) -> Optional[Any]:
|
||||
return channel._object if channel else None
|
||||
|
||||
|
||||
class StackFrame(TypedDict):
|
||||
file: str
|
||||
line: int
|
||||
column: int
|
||||
function: Optional[str]
|
||||
|
||||
|
||||
class ParsedStackTrace(TypedDict):
|
||||
frames: List[StackFrame]
|
||||
apiName: Optional[str]
|
||||
title: Optional[str]
|
||||
|
||||
|
||||
def _extract_stack_trace_information_from_stack(
|
||||
st: List[inspect.FrameInfo], is_internal: bool, title: str = None
|
||||
) -> ParsedStackTrace:
|
||||
playwright_module_path = str(Path(playwright.__file__).parents[0])
|
||||
last_internal_api_name = ""
|
||||
api_name = ""
|
||||
parsed_frames: List[StackFrame] = []
|
||||
for frame in st:
|
||||
# Sync and Async implementations can have event handlers. When these are sync, they
|
||||
# get evaluated in the context of the event loop, so they contain the stack trace of when
|
||||
# the message was received. _impl_to_api_mapping is glue between the user-code and internal
|
||||
# code to translate impl classes to api classes. We want to ignore these frames.
|
||||
if playwright._impl._impl_to_api_mapping.__file__ == frame.filename:
|
||||
continue
|
||||
is_playwright_internal = frame.filename.startswith(playwright_module_path)
|
||||
|
||||
method_name = ""
|
||||
if "self" in frame[0].f_locals:
|
||||
method_name = frame[0].f_locals["self"].__class__.__name__ + "."
|
||||
method_name += frame[0].f_code.co_name
|
||||
|
||||
if not is_playwright_internal:
|
||||
parsed_frames.append(
|
||||
{
|
||||
"file": frame.filename,
|
||||
"line": frame.lineno,
|
||||
"column": 0,
|
||||
"function": method_name,
|
||||
}
|
||||
)
|
||||
if is_playwright_internal:
|
||||
last_internal_api_name = method_name
|
||||
elif last_internal_api_name:
|
||||
api_name = last_internal_api_name
|
||||
last_internal_api_name = ""
|
||||
if not api_name:
|
||||
api_name = last_internal_api_name
|
||||
|
||||
return {
|
||||
"frames": parsed_frames,
|
||||
"apiName": "" if is_internal else api_name,
|
||||
"title": title,
|
||||
}
|
||||
|
||||
|
||||
def _augment_params(
|
||||
params: Optional[Dict],
|
||||
timeout_calculator: Optional[Callable[[Optional[float]], float]],
|
||||
) -> Dict:
|
||||
if params is None:
|
||||
params = {}
|
||||
if timeout_calculator:
|
||||
params["timeout"] = timeout_calculator(params.get("timeout"))
|
||||
return _filter_none(params)
|
||||
|
||||
|
||||
def _filter_none(d: Mapping) -> Dict:
|
||||
result = {}
|
||||
for k, v in d.items():
|
||||
if v is None:
|
||||
continue
|
||||
result[k] = _filter_none(v) if isinstance(v, dict) else v
|
||||
return result
|
||||
|
||||
|
||||
def format_call_log(log: Optional[List[str]]) -> str:
|
||||
if not log:
|
||||
return ""
|
||||
if len(list(filter(lambda x: x.strip(), log))) == 0:
|
||||
return ""
|
||||
return "\nCall log:\n" + "\n".join(log) + "\n"
|
||||
+85
@@ -0,0 +1,85 @@
|
||||
# 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.
|
||||
|
||||
from asyncio import AbstractEventLoop
|
||||
from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
|
||||
|
||||
from playwright._impl._api_structures import SourceLocation
|
||||
from playwright._impl._connection import from_channel, from_nullable_channel
|
||||
from playwright._impl._js_handle import JSHandle
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._page import Page
|
||||
from playwright._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:
|
||||
return self._event["location"]
|
||||
|
||||
@property
|
||||
def page(self) -> Optional["Page"]:
|
||||
return self._page
|
||||
|
||||
@property
|
||||
def worker(self) -> Optional["Worker"]:
|
||||
return self._worker
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
# 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.
|
||||
|
||||
from typing import TYPE_CHECKING, Dict, Optional
|
||||
|
||||
from playwright._impl._connection import ChannelOwner, from_nullable_channel
|
||||
from playwright._impl._helper import locals_to_params
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._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:
|
||||
await self._channel.send(
|
||||
"dismiss",
|
||||
None,
|
||||
)
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
# 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 pathlib import Path
|
||||
from typing import TYPE_CHECKING, Optional, Union
|
||||
|
||||
from playwright._impl._artifact import Artifact
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._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()
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
# 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 inspect
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import Tuple
|
||||
|
||||
import playwright
|
||||
from playwright._repo_version import version
|
||||
|
||||
|
||||
def compute_driver_executable() -> Tuple[str, str]:
|
||||
driver_path = Path(inspect.getfile(playwright)).parent / "driver"
|
||||
cli_path = str(driver_path / "package" / "cli.js")
|
||||
if sys.platform == "win32":
|
||||
return (
|
||||
os.getenv("PLAYWRIGHT_NODEJS_PATH", str(driver_path / "node.exe")),
|
||||
cli_path,
|
||||
)
|
||||
return (os.getenv("PLAYWRIGHT_NODEJS_PATH", str(driver_path / "node")), 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
|
||||
+466
@@ -0,0 +1,466 @@
|
||||
# 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 base64
|
||||
import mimetypes
|
||||
from pathlib import Path
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Callable,
|
||||
Dict,
|
||||
List,
|
||||
Literal,
|
||||
Optional,
|
||||
Sequence,
|
||||
Union,
|
||||
cast,
|
||||
)
|
||||
|
||||
from playwright._impl._api_structures import FilePayload, FloatRect, Position
|
||||
from playwright._impl._connection import ChannelOwner, from_nullable_channel
|
||||
from playwright._impl._helper import (
|
||||
Error,
|
||||
KeyboardModifier,
|
||||
MouseButton,
|
||||
async_writefile,
|
||||
locals_to_params,
|
||||
make_dirs_for_file,
|
||||
)
|
||||
from playwright._impl._js_handle import (
|
||||
JSHandle,
|
||||
Serializable,
|
||||
parse_result,
|
||||
serialize_argument,
|
||||
)
|
||||
from playwright._impl._set_input_files_helpers import convert_input_files
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._frame import Frame
|
||||
from playwright._impl._locator import Locator
|
||||
|
||||
|
||||
class ElementHandle(JSHandle):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self._frame = cast("Frame", parent)
|
||||
|
||||
async def _createSelectorForTest(self, name: str) -> Optional[str]:
|
||||
return await self._channel.send(
|
||||
"createSelectorForTest", self._frame._timeout, dict(name=name)
|
||||
)
|
||||
|
||||
def as_element(self) -> Optional["ElementHandle"]:
|
||||
return self
|
||||
|
||||
async def owner_frame(self) -> Optional["Frame"]:
|
||||
return from_nullable_channel(await self._channel.send("ownerFrame", None))
|
||||
|
||||
async def content_frame(self) -> Optional["Frame"]:
|
||||
return from_nullable_channel(await self._channel.send("contentFrame", None))
|
||||
|
||||
async def get_attribute(self, name: str) -> Optional[str]:
|
||||
return await self._channel.send("getAttribute", None, dict(name=name))
|
||||
|
||||
async def text_content(self) -> Optional[str]:
|
||||
return await self._channel.send("textContent", None)
|
||||
|
||||
async def inner_text(self) -> str:
|
||||
return await self._channel.send("innerText", None)
|
||||
|
||||
async def inner_html(self) -> str:
|
||||
return await self._channel.send("innerHTML", None)
|
||||
|
||||
async def is_checked(self) -> bool:
|
||||
return await self._channel.send("isChecked", None)
|
||||
|
||||
async def is_disabled(self) -> bool:
|
||||
return await self._channel.send("isDisabled", None)
|
||||
|
||||
async def is_editable(self) -> bool:
|
||||
return await self._channel.send("isEditable", None)
|
||||
|
||||
async def is_enabled(self) -> bool:
|
||||
return await self._channel.send("isEnabled", None)
|
||||
|
||||
async def is_hidden(self) -> bool:
|
||||
return await self._channel.send("isHidden", None)
|
||||
|
||||
async def is_visible(self) -> bool:
|
||||
return await self._channel.send("isVisible", None)
|
||||
|
||||
async def dispatch_event(self, type: str, eventInit: Dict = None) -> None:
|
||||
await self._channel.send(
|
||||
"dispatchEvent",
|
||||
None,
|
||||
dict(type=type, eventInit=serialize_argument(eventInit)),
|
||||
)
|
||||
|
||||
async def scroll_into_view_if_needed(self, timeout: float = None) -> None:
|
||||
await self._channel.send(
|
||||
"scrollIntoViewIfNeeded", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def hover(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
force: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"hover", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def click(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
steps: int = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"click", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def dblclick(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
steps: int = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"dblclick", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def select_option(
|
||||
self,
|
||||
value: Union[str, Sequence[str]] = None,
|
||||
index: Union[int, Sequence[int]] = None,
|
||||
label: Union[str, Sequence[str]] = None,
|
||||
element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> List[str]:
|
||||
params = locals_to_params(
|
||||
dict(
|
||||
timeout=timeout,
|
||||
force=force,
|
||||
**convert_select_option_values(value, index, label, element),
|
||||
)
|
||||
)
|
||||
return await self._channel.send("selectOption", self._frame._timeout, params)
|
||||
|
||||
async def tap(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"tap", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def fill(
|
||||
self,
|
||||
value: str,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
force: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"fill", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def select_text(self, force: bool = None, timeout: float = None) -> None:
|
||||
await self._channel.send(
|
||||
"selectText", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def input_value(self, timeout: float = None) -> str:
|
||||
return await self._channel.send(
|
||||
"inputValue", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def set_input_files(
|
||||
self,
|
||||
files: Union[
|
||||
str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
|
||||
],
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
frame = await self.owner_frame()
|
||||
if not frame:
|
||||
raise Error("Cannot set input files to detached element")
|
||||
converted = await convert_input_files(files, frame.page.context)
|
||||
await self._channel.send(
|
||||
"setInputFiles",
|
||||
self._frame._timeout,
|
||||
{
|
||||
"timeout": timeout,
|
||||
**converted,
|
||||
},
|
||||
)
|
||||
|
||||
async def focus(self) -> None:
|
||||
await self._channel.send("focus", None)
|
||||
|
||||
async def type(
|
||||
self,
|
||||
text: str,
|
||||
delay: float = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"type", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def press(
|
||||
self,
|
||||
key: str,
|
||||
delay: float = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"press", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def set_checked(
|
||||
self,
|
||||
checked: bool,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
if checked:
|
||||
await self.check(
|
||||
position=position,
|
||||
timeout=timeout,
|
||||
force=force,
|
||||
trial=trial,
|
||||
)
|
||||
else:
|
||||
await self.uncheck(
|
||||
position=position,
|
||||
timeout=timeout,
|
||||
force=force,
|
||||
trial=trial,
|
||||
)
|
||||
|
||||
async def check(
|
||||
self,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"check", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def uncheck(
|
||||
self,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"uncheck", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def bounding_box(self) -> Optional[FloatRect]:
|
||||
return await self._channel.send("boundingBox", None)
|
||||
|
||||
async def screenshot(
|
||||
self,
|
||||
timeout: float = None,
|
||||
type: Literal["jpeg", "png"] = None,
|
||||
path: Union[str, Path] = None,
|
||||
quality: int = None,
|
||||
omitBackground: bool = None,
|
||||
animations: Literal["allow", "disabled"] = None,
|
||||
caret: Literal["hide", "initial"] = None,
|
||||
scale: Literal["css", "device"] = None,
|
||||
mask: Sequence["Locator"] = None,
|
||||
maskColor: str = None,
|
||||
style: str = None,
|
||||
) -> bytes:
|
||||
params = locals_to_params(locals())
|
||||
if "path" in params:
|
||||
if "type" not in params:
|
||||
params["type"] = determine_screenshot_type(params["path"])
|
||||
del params["path"]
|
||||
if "mask" in params:
|
||||
params["mask"] = list(
|
||||
map(
|
||||
lambda locator: (
|
||||
{
|
||||
"frame": locator._frame._channel,
|
||||
"selector": locator._selector,
|
||||
}
|
||||
),
|
||||
params["mask"],
|
||||
)
|
||||
)
|
||||
encoded_binary = await self._channel.send(
|
||||
"screenshot", self._frame._timeout, params
|
||||
)
|
||||
decoded_binary = base64.b64decode(encoded_binary)
|
||||
if path:
|
||||
make_dirs_for_file(path)
|
||||
await async_writefile(path, decoded_binary)
|
||||
return decoded_binary
|
||||
|
||||
async def query_selector(self, selector: str) -> Optional["ElementHandle"]:
|
||||
return from_nullable_channel(
|
||||
await self._channel.send("querySelector", None, dict(selector=selector))
|
||||
)
|
||||
|
||||
async def query_selector_all(self, selector: str) -> List["ElementHandle"]:
|
||||
return list(
|
||||
map(
|
||||
cast(Callable[[Any], Any], from_nullable_channel),
|
||||
await self._channel.send(
|
||||
"querySelectorAll", None, dict(selector=selector)
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def eval_on_selector(
|
||||
self,
|
||||
selector: str,
|
||||
expression: str,
|
||||
arg: Serializable = None,
|
||||
) -> Any:
|
||||
return parse_result(
|
||||
await self._channel.send(
|
||||
"evalOnSelector",
|
||||
None,
|
||||
dict(
|
||||
selector=selector,
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def eval_on_selector_all(
|
||||
self,
|
||||
selector: str,
|
||||
expression: str,
|
||||
arg: Serializable = None,
|
||||
) -> Any:
|
||||
return parse_result(
|
||||
await self._channel.send(
|
||||
"evalOnSelectorAll",
|
||||
None,
|
||||
dict(
|
||||
selector=selector,
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def wait_for_element_state(
|
||||
self,
|
||||
state: Literal[
|
||||
"disabled", "editable", "enabled", "hidden", "stable", "visible"
|
||||
],
|
||||
timeout: float = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"waitForElementState", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def wait_for_selector(
|
||||
self,
|
||||
selector: str,
|
||||
state: Literal["attached", "detached", "hidden", "visible"] = None,
|
||||
timeout: float = None,
|
||||
strict: bool = None,
|
||||
) -> Optional["ElementHandle"]:
|
||||
return from_nullable_channel(
|
||||
await self._channel.send(
|
||||
"waitForSelector", self._frame._timeout, locals_to_params(locals())
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def convert_select_option_values(
|
||||
value: Union[str, Sequence[str]] = None,
|
||||
index: Union[int, Sequence[int]] = None,
|
||||
label: Union[str, Sequence[str]] = None,
|
||||
element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
|
||||
) -> Any:
|
||||
if value is None and index is None and label is None and element is None:
|
||||
return {}
|
||||
|
||||
options: Any = None
|
||||
elements: Any = None
|
||||
if value is not None:
|
||||
if isinstance(value, str):
|
||||
value = [value]
|
||||
options = (options or []) + list(map(lambda e: dict(valueOrLabel=e), value))
|
||||
if index is not None:
|
||||
if isinstance(index, int):
|
||||
index = [index]
|
||||
options = (options or []) + list(map(lambda e: dict(index=e), index))
|
||||
if label is not None:
|
||||
if isinstance(label, str):
|
||||
label = [label]
|
||||
options = (options or []) + list(map(lambda e: dict(label=e), label))
|
||||
if element:
|
||||
if isinstance(element, ElementHandle):
|
||||
element = [element]
|
||||
elements = list(map(lambda e: e._channel, element))
|
||||
|
||||
return dict(options=options, elements=elements)
|
||||
|
||||
|
||||
def determine_screenshot_type(path: Union[str, Path]) -> Literal["jpeg", "png"]:
|
||||
mime_type, _ = mimetypes.guess_type(path)
|
||||
if mime_type == "image/png":
|
||||
return "png"
|
||||
if mime_type == "image/jpeg":
|
||||
return "jpeg"
|
||||
raise Error(f'Unsupported screenshot mime type for path "{path}": {mime_type}')
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
# 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.
|
||||
|
||||
# These are types that we use in the API. They are public and are a part of the
|
||||
# stable API.
|
||||
|
||||
|
||||
from typing import Optional
|
||||
|
||||
|
||||
def is_target_closed_error(error: Exception) -> bool:
|
||||
return isinstance(error, TargetClosedError)
|
||||
|
||||
|
||||
class Error(Exception):
|
||||
def __init__(self, message: str) -> None:
|
||||
self._message = message
|
||||
self._name: Optional[str] = None
|
||||
self._stack: Optional[str] = None
|
||||
super().__init__(message)
|
||||
|
||||
@property
|
||||
def message(self) -> str:
|
||||
return self._message
|
||||
|
||||
@property
|
||||
def name(self) -> Optional[str]:
|
||||
return self._name
|
||||
|
||||
@property
|
||||
def stack(self) -> Optional[str]:
|
||||
return self._stack
|
||||
|
||||
|
||||
class TimeoutError(Error):
|
||||
pass
|
||||
|
||||
|
||||
class TargetClosedError(Error):
|
||||
def __init__(self, message: str = None) -> None:
|
||||
super().__init__(message or "Target page, context or browser has been closed")
|
||||
|
||||
|
||||
def rewrite_error(error: Exception, message: str) -> Exception:
|
||||
rewritten_exc = type(error)(message)
|
||||
if isinstance(rewritten_exc, Error) and isinstance(error, Error):
|
||||
rewritten_exc._name = error.name
|
||||
rewritten_exc._stack = error.stack
|
||||
return rewritten_exc
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
# 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
|
||||
from typing import Any, Generic, TypeVar
|
||||
|
||||
T = TypeVar("T")
|
||||
|
||||
|
||||
class EventContextManagerImpl(Generic[T]):
|
||||
def __init__(self, future: asyncio.Future) -> None:
|
||||
self._future: asyncio.Future = future
|
||||
|
||||
@property
|
||||
def future(self) -> asyncio.Future:
|
||||
return self._future
|
||||
|
||||
async def __aenter__(self) -> asyncio.Future:
|
||||
return self._future
|
||||
|
||||
async def __aexit__(self, *args: Any) -> None:
|
||||
await self._future
|
||||
+555
@@ -0,0 +1,555 @@
|
||||
# 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 base64
|
||||
import json
|
||||
import pathlib
|
||||
import typing
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional, Union, cast
|
||||
|
||||
import playwright._impl._network as network
|
||||
from playwright._impl._api_structures import (
|
||||
ClientCertificate,
|
||||
FilePayload,
|
||||
FormField,
|
||||
Headers,
|
||||
HttpCredentials,
|
||||
ProxySettings,
|
||||
ServerFilePayload,
|
||||
StorageState,
|
||||
)
|
||||
from playwright._impl._connection import ChannelOwner, from_channel
|
||||
from playwright._impl._errors import is_target_closed_error
|
||||
from playwright._impl._helper import (
|
||||
Error,
|
||||
NameValue,
|
||||
TargetClosedError,
|
||||
TimeoutSettings,
|
||||
async_readfile,
|
||||
async_writefile,
|
||||
is_file_payload,
|
||||
locals_to_params,
|
||||
object_to_array,
|
||||
to_impl,
|
||||
)
|
||||
from playwright._impl._network import serialize_headers, to_client_certificates_protocol
|
||||
from playwright._impl._tracing import Tracing
|
||||
|
||||
if typing.TYPE_CHECKING:
|
||||
from playwright._impl._playwright import Playwright
|
||||
|
||||
|
||||
FormType = Dict[str, Union[bool, float, str]]
|
||||
DataType = Union[Any, bytes, str]
|
||||
MultipartType = Dict[str, Union[bytes, bool, float, str, FilePayload]]
|
||||
ParamsType = Union[Dict[str, Union[bool, float, str]], str]
|
||||
|
||||
|
||||
class APIRequest:
|
||||
def __init__(self, playwright: "Playwright") -> None:
|
||||
self.playwright = playwright
|
||||
self._loop = playwright._loop
|
||||
self._dispatcher_fiber = playwright._connection._dispatcher_fiber
|
||||
|
||||
async def new_context(
|
||||
self,
|
||||
baseURL: str = None,
|
||||
extraHTTPHeaders: Dict[str, str] = None,
|
||||
httpCredentials: HttpCredentials = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
proxy: ProxySettings = None,
|
||||
userAgent: str = None,
|
||||
timeout: float = None,
|
||||
storageState: Union[StorageState, str, Path] = None,
|
||||
clientCertificates: List[ClientCertificate] = None,
|
||||
failOnStatusCode: bool = None,
|
||||
maxRedirects: int = None,
|
||||
) -> "APIRequestContext":
|
||||
params = locals_to_params(locals())
|
||||
if "storageState" in params:
|
||||
storage_state = params["storageState"]
|
||||
if not isinstance(storage_state, dict) and storage_state:
|
||||
params["storageState"] = json.loads(
|
||||
(await async_readfile(storage_state)).decode()
|
||||
)
|
||||
if "extraHTTPHeaders" in params:
|
||||
params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
|
||||
params["clientCertificates"] = await to_client_certificates_protocol(
|
||||
params.get("clientCertificates")
|
||||
)
|
||||
context = cast(
|
||||
APIRequestContext,
|
||||
from_channel(
|
||||
await self.playwright._channel.send("newRequest", None, params)
|
||||
),
|
||||
)
|
||||
context._timeout_settings.set_default_timeout(timeout)
|
||||
return context
|
||||
|
||||
|
||||
class APIRequestContext(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self._tracing: Tracing = from_channel(initializer["tracing"])
|
||||
self._close_reason: Optional[str] = None
|
||||
self._timeout_settings = TimeoutSettings(None)
|
||||
|
||||
async def dispose(self, reason: str = None) -> None:
|
||||
self._close_reason = reason
|
||||
try:
|
||||
await self._channel.send("dispose", None, {"reason": reason})
|
||||
except Error as e:
|
||||
if is_target_closed_error(e):
|
||||
return
|
||||
raise e
|
||||
self._tracing._reset_stack_counter()
|
||||
|
||||
async def delete(
|
||||
self,
|
||||
url: str,
|
||||
params: ParamsType = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
form: FormType = None,
|
||||
multipart: MultipartType = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
return await self.fetch(
|
||||
url,
|
||||
method="DELETE",
|
||||
params=params,
|
||||
headers=headers,
|
||||
data=data,
|
||||
form=form,
|
||||
multipart=multipart,
|
||||
timeout=timeout,
|
||||
failOnStatusCode=failOnStatusCode,
|
||||
ignoreHTTPSErrors=ignoreHTTPSErrors,
|
||||
maxRedirects=maxRedirects,
|
||||
maxRetries=maxRetries,
|
||||
)
|
||||
|
||||
async def head(
|
||||
self,
|
||||
url: str,
|
||||
params: ParamsType = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
form: FormType = None,
|
||||
multipart: MultipartType = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
return await self.fetch(
|
||||
url,
|
||||
method="HEAD",
|
||||
params=params,
|
||||
headers=headers,
|
||||
data=data,
|
||||
form=form,
|
||||
multipart=multipart,
|
||||
timeout=timeout,
|
||||
failOnStatusCode=failOnStatusCode,
|
||||
ignoreHTTPSErrors=ignoreHTTPSErrors,
|
||||
maxRedirects=maxRedirects,
|
||||
maxRetries=maxRetries,
|
||||
)
|
||||
|
||||
async def get(
|
||||
self,
|
||||
url: str,
|
||||
params: ParamsType = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
form: FormType = None,
|
||||
multipart: MultipartType = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
return await self.fetch(
|
||||
url,
|
||||
method="GET",
|
||||
params=params,
|
||||
headers=headers,
|
||||
data=data,
|
||||
form=form,
|
||||
multipart=multipart,
|
||||
timeout=timeout,
|
||||
failOnStatusCode=failOnStatusCode,
|
||||
ignoreHTTPSErrors=ignoreHTTPSErrors,
|
||||
maxRedirects=maxRedirects,
|
||||
maxRetries=maxRetries,
|
||||
)
|
||||
|
||||
async def patch(
|
||||
self,
|
||||
url: str,
|
||||
params: ParamsType = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
form: FormType = None,
|
||||
multipart: Dict[str, Union[bytes, bool, float, str, FilePayload]] = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
return await self.fetch(
|
||||
url,
|
||||
method="PATCH",
|
||||
params=params,
|
||||
headers=headers,
|
||||
data=data,
|
||||
form=form,
|
||||
multipart=multipart,
|
||||
timeout=timeout,
|
||||
failOnStatusCode=failOnStatusCode,
|
||||
ignoreHTTPSErrors=ignoreHTTPSErrors,
|
||||
maxRedirects=maxRedirects,
|
||||
maxRetries=maxRetries,
|
||||
)
|
||||
|
||||
async def put(
|
||||
self,
|
||||
url: str,
|
||||
params: ParamsType = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
form: FormType = None,
|
||||
multipart: Dict[str, Union[bytes, bool, float, str, FilePayload]] = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
return await self.fetch(
|
||||
url,
|
||||
method="PUT",
|
||||
params=params,
|
||||
headers=headers,
|
||||
data=data,
|
||||
form=form,
|
||||
multipart=multipart,
|
||||
timeout=timeout,
|
||||
failOnStatusCode=failOnStatusCode,
|
||||
ignoreHTTPSErrors=ignoreHTTPSErrors,
|
||||
maxRedirects=maxRedirects,
|
||||
maxRetries=maxRetries,
|
||||
)
|
||||
|
||||
async def post(
|
||||
self,
|
||||
url: str,
|
||||
params: ParamsType = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
form: FormType = None,
|
||||
multipart: Dict[str, Union[bytes, bool, float, str, FilePayload]] = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
return await self.fetch(
|
||||
url,
|
||||
method="POST",
|
||||
params=params,
|
||||
headers=headers,
|
||||
data=data,
|
||||
form=form,
|
||||
multipart=multipart,
|
||||
timeout=timeout,
|
||||
failOnStatusCode=failOnStatusCode,
|
||||
ignoreHTTPSErrors=ignoreHTTPSErrors,
|
||||
maxRedirects=maxRedirects,
|
||||
maxRetries=maxRetries,
|
||||
)
|
||||
|
||||
async def fetch(
|
||||
self,
|
||||
urlOrRequest: Union[str, network.Request],
|
||||
params: ParamsType = None,
|
||||
method: str = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
form: FormType = None,
|
||||
multipart: Dict[str, Union[bytes, bool, float, str, FilePayload]] = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
url = urlOrRequest if isinstance(urlOrRequest, str) else None
|
||||
request = (
|
||||
cast(network.Request, to_impl(urlOrRequest))
|
||||
if isinstance(to_impl(urlOrRequest), network.Request)
|
||||
else None
|
||||
)
|
||||
assert request or isinstance(
|
||||
urlOrRequest, str
|
||||
), "First argument must be either URL string or Request"
|
||||
return await self._inner_fetch(
|
||||
request,
|
||||
url,
|
||||
method,
|
||||
headers,
|
||||
data,
|
||||
params,
|
||||
form,
|
||||
multipart,
|
||||
timeout,
|
||||
failOnStatusCode,
|
||||
ignoreHTTPSErrors,
|
||||
maxRedirects,
|
||||
maxRetries,
|
||||
)
|
||||
|
||||
async def _inner_fetch(
|
||||
self,
|
||||
request: Optional[network.Request],
|
||||
url: Optional[str],
|
||||
method: str = None,
|
||||
headers: Headers = None,
|
||||
data: DataType = None,
|
||||
params: ParamsType = None,
|
||||
form: FormType = None,
|
||||
multipart: Dict[str, Union[bytes, bool, float, str, FilePayload]] = None,
|
||||
timeout: float = None,
|
||||
failOnStatusCode: bool = None,
|
||||
ignoreHTTPSErrors: bool = None,
|
||||
maxRedirects: int = None,
|
||||
maxRetries: int = None,
|
||||
) -> "APIResponse":
|
||||
if self._close_reason:
|
||||
raise TargetClosedError(self._close_reason)
|
||||
assert (
|
||||
(1 if data else 0) + (1 if form else 0) + (1 if multipart else 0)
|
||||
) <= 1, "Only one of 'data', 'form' or 'multipart' can be specified"
|
||||
assert (
|
||||
maxRedirects is None or maxRedirects >= 0
|
||||
), "'max_redirects' must be greater than or equal to '0'"
|
||||
assert (
|
||||
maxRetries is None or maxRetries >= 0
|
||||
), "'max_retries' must be greater than or equal to '0'"
|
||||
url = url or (request.url if request else url)
|
||||
method = method or (request.method if request else "GET")
|
||||
# Cannot call allHeaders() here as the request may be paused inside route handler.
|
||||
headers_obj = headers or (request.headers if request else None)
|
||||
serialized_headers = serialize_headers(headers_obj) if headers_obj else None
|
||||
json_data: Any = None
|
||||
form_data: Optional[List[NameValue]] = None
|
||||
multipart_data: Optional[List[FormField]] = None
|
||||
post_data_buffer: Optional[bytes] = None
|
||||
if data is not None:
|
||||
if isinstance(data, str):
|
||||
if is_json_content_type(serialized_headers):
|
||||
json_data = data if is_json_parsable(data) else json.dumps(data)
|
||||
else:
|
||||
post_data_buffer = data.encode()
|
||||
elif isinstance(data, bytes):
|
||||
post_data_buffer = data
|
||||
elif isinstance(data, (dict, list, int, bool)):
|
||||
json_data = json.dumps(data)
|
||||
else:
|
||||
raise Error(f"Unsupported 'data' type: {type(data)}")
|
||||
elif form:
|
||||
form_data = object_to_array(form)
|
||||
elif multipart:
|
||||
multipart_data = []
|
||||
# Convert file-like values to ServerFilePayload structs.
|
||||
for name, value in multipart.items():
|
||||
if is_file_payload(value):
|
||||
payload = cast(FilePayload, value)
|
||||
assert isinstance(
|
||||
payload["buffer"], bytes
|
||||
), f"Unexpected buffer type of 'data.{name}'"
|
||||
multipart_data.append(
|
||||
FormField(name=name, file=file_payload_to_json(payload))
|
||||
)
|
||||
elif isinstance(value, str):
|
||||
multipart_data.append(FormField(name=name, value=value))
|
||||
if (
|
||||
post_data_buffer is None
|
||||
and json_data is None
|
||||
and form_data is None
|
||||
and multipart_data is None
|
||||
):
|
||||
post_data_buffer = request.post_data_buffer if request else None
|
||||
post_data = (
|
||||
base64.b64encode(post_data_buffer).decode() if post_data_buffer else None
|
||||
)
|
||||
|
||||
response = await self._channel.send(
|
||||
"fetch",
|
||||
self._timeout_settings.timeout,
|
||||
{
|
||||
"url": url,
|
||||
"timeout": timeout,
|
||||
"params": object_to_array(params) if isinstance(params, dict) else None,
|
||||
"encodedParams": params if isinstance(params, str) else None,
|
||||
"method": method,
|
||||
"headers": serialized_headers,
|
||||
"postData": post_data,
|
||||
"jsonData": json_data,
|
||||
"formData": form_data,
|
||||
"multipartData": multipart_data,
|
||||
"failOnStatusCode": failOnStatusCode,
|
||||
"ignoreHTTPSErrors": ignoreHTTPSErrors,
|
||||
"maxRedirects": maxRedirects,
|
||||
"maxRetries": maxRetries,
|
||||
},
|
||||
)
|
||||
return APIResponse(self, response)
|
||||
|
||||
async def storage_state(
|
||||
self,
|
||||
path: Union[pathlib.Path, str] = None,
|
||||
indexedDB: bool = None,
|
||||
) -> StorageState:
|
||||
result = await self._channel.send_return_as_dict(
|
||||
"storageState", None, {"indexedDB": indexedDB}
|
||||
)
|
||||
if path:
|
||||
await async_writefile(path, json.dumps(result))
|
||||
return result
|
||||
|
||||
|
||||
def file_payload_to_json(payload: FilePayload) -> ServerFilePayload:
|
||||
return ServerFilePayload(
|
||||
name=payload["name"],
|
||||
mimeType=payload["mimeType"],
|
||||
buffer=base64.b64encode(payload["buffer"]).decode(),
|
||||
)
|
||||
|
||||
|
||||
class APIResponse:
|
||||
def __init__(self, context: APIRequestContext, initializer: Dict) -> None:
|
||||
self._loop = context._loop
|
||||
self._dispatcher_fiber = context._connection._dispatcher_fiber
|
||||
self._request = context
|
||||
self._initializer = initializer
|
||||
self._headers = network.RawHeaders(initializer["headers"])
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<APIResponse url={self.url!r} status={self.status!r} status_text={self.status_text!r}>"
|
||||
|
||||
@property
|
||||
def ok(self) -> bool:
|
||||
return self.status >= 200 and self.status <= 299
|
||||
|
||||
@property
|
||||
def url(self) -> str:
|
||||
return self._initializer["url"]
|
||||
|
||||
@property
|
||||
def status(self) -> int:
|
||||
return self._initializer["status"]
|
||||
|
||||
@property
|
||||
def status_text(self) -> str:
|
||||
return self._initializer["statusText"]
|
||||
|
||||
@property
|
||||
def headers(self) -> Headers:
|
||||
return self._headers.headers()
|
||||
|
||||
@property
|
||||
def headers_array(self) -> network.HeadersArray:
|
||||
return self._headers.headers_array()
|
||||
|
||||
async def body(self) -> bytes:
|
||||
try:
|
||||
result = await self._request._connection.wrap_api_call(
|
||||
lambda: self._request._channel.send_return_as_dict(
|
||||
"fetchResponseBody",
|
||||
None,
|
||||
{
|
||||
"fetchUid": self._fetch_uid,
|
||||
},
|
||||
),
|
||||
True,
|
||||
)
|
||||
if result is None:
|
||||
raise Error("Response has been disposed")
|
||||
return base64.b64decode(result["binary"])
|
||||
except Error as exc:
|
||||
if is_target_closed_error(exc):
|
||||
raise Error("Response has been disposed")
|
||||
raise exc
|
||||
|
||||
async def text(self) -> str:
|
||||
content = await self.body()
|
||||
return content.decode()
|
||||
|
||||
async def json(self) -> Any:
|
||||
content = await self.text()
|
||||
return json.loads(content)
|
||||
|
||||
async def dispose(self) -> None:
|
||||
await self._request._channel.send(
|
||||
"disposeAPIResponse",
|
||||
None,
|
||||
{
|
||||
"fetchUid": self._fetch_uid,
|
||||
},
|
||||
)
|
||||
|
||||
@property
|
||||
def _fetch_uid(self) -> str:
|
||||
return self._initializer["fetchUid"]
|
||||
|
||||
async def _fetch_log(self) -> List[str]:
|
||||
return await self._request._channel.send(
|
||||
"fetchLog",
|
||||
None,
|
||||
{
|
||||
"fetchUid": self._fetch_uid,
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def is_json_content_type(headers: network.HeadersArray = None) -> bool:
|
||||
if not headers:
|
||||
return False
|
||||
for header in headers:
|
||||
if header["name"] == "Content-Type":
|
||||
return header["value"].startswith("application/json")
|
||||
return False
|
||||
|
||||
|
||||
def is_json_parsable(value: Any) -> bool:
|
||||
if not isinstance(value, str):
|
||||
return False
|
||||
try:
|
||||
json.loads(value)
|
||||
return True
|
||||
except json.JSONDecodeError:
|
||||
return False
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
# 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.
|
||||
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Sequence, Union
|
||||
|
||||
from playwright._impl._api_structures import FilePayload
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._element_handle import ElementHandle
|
||||
from playwright._impl._page import Page
|
||||
|
||||
|
||||
class FileChooser:
|
||||
def __init__(
|
||||
self, page: "Page", element_handle: "ElementHandle", is_multiple: bool
|
||||
) -> None:
|
||||
self._page = page
|
||||
self._loop = page._loop
|
||||
self._dispatcher_fiber = page._dispatcher_fiber
|
||||
self._element_handle = element_handle
|
||||
self._is_multiple = is_multiple
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<FileChooser page={self._page} element={self._element_handle}>"
|
||||
|
||||
@property
|
||||
def page(self) -> "Page":
|
||||
return self._page
|
||||
|
||||
@property
|
||||
def element(self) -> "ElementHandle":
|
||||
return self._element_handle
|
||||
|
||||
def is_multiple(self) -> bool:
|
||||
return self._is_multiple
|
||||
|
||||
async def set_files(
|
||||
self,
|
||||
files: Union[
|
||||
str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
|
||||
],
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
await self._element_handle.set_input_files(files, timeout, noWaitAfter)
|
||||
+915
@@ -0,0 +1,915 @@
|
||||
# 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
|
||||
from pathlib import Path
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Dict,
|
||||
List,
|
||||
Literal,
|
||||
Optional,
|
||||
Pattern,
|
||||
Sequence,
|
||||
Set,
|
||||
Union,
|
||||
cast,
|
||||
)
|
||||
|
||||
from pyee import EventEmitter
|
||||
|
||||
from playwright._impl._api_structures import (
|
||||
AriaRole,
|
||||
FilePayload,
|
||||
FrameExpectOptions,
|
||||
FrameExpectResult,
|
||||
Position,
|
||||
)
|
||||
from playwright._impl._connection import (
|
||||
ChannelOwner,
|
||||
from_channel,
|
||||
from_nullable_channel,
|
||||
)
|
||||
from playwright._impl._element_handle import ElementHandle, convert_select_option_values
|
||||
from playwright._impl._errors import Error
|
||||
from playwright._impl._event_context_manager import EventContextManagerImpl
|
||||
from playwright._impl._helper import (
|
||||
DocumentLoadState,
|
||||
FrameNavigatedEvent,
|
||||
KeyboardModifier,
|
||||
MouseButton,
|
||||
TimeoutSettings,
|
||||
URLMatch,
|
||||
async_readfile,
|
||||
locals_to_params,
|
||||
monotonic_time,
|
||||
url_matches,
|
||||
)
|
||||
from playwright._impl._js_handle import (
|
||||
JSHandle,
|
||||
Serializable,
|
||||
add_source_url_to_script,
|
||||
parse_result,
|
||||
parse_value,
|
||||
serialize_argument,
|
||||
)
|
||||
from playwright._impl._locator import (
|
||||
FrameLocator,
|
||||
Locator,
|
||||
get_by_alt_text_selector,
|
||||
get_by_label_selector,
|
||||
get_by_placeholder_selector,
|
||||
get_by_role_selector,
|
||||
get_by_test_id_selector,
|
||||
get_by_text_selector,
|
||||
get_by_title_selector,
|
||||
test_id_attribute_name,
|
||||
)
|
||||
from playwright._impl._network import Response
|
||||
from playwright._impl._set_input_files_helpers import convert_input_files
|
||||
from playwright._impl._waiter import Waiter
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._page import Page
|
||||
|
||||
|
||||
class Frame(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self._parent_frame = from_nullable_channel(initializer.get("parentFrame"))
|
||||
if self._parent_frame:
|
||||
self._parent_frame._child_frames.append(self)
|
||||
self._name = initializer["name"]
|
||||
self._url = initializer["url"]
|
||||
self._detached = False
|
||||
self._child_frames: List[Frame] = []
|
||||
self._page: Optional[Page] = None
|
||||
self._load_states: Set[str] = set(initializer["loadStates"])
|
||||
self._event_emitter = EventEmitter()
|
||||
self._channel.on(
|
||||
"loadstate",
|
||||
lambda params: self._on_load_state(params.get("add"), params.get("remove")),
|
||||
)
|
||||
self._channel.on(
|
||||
"navigated",
|
||||
lambda params: self._on_frame_navigated(params),
|
||||
)
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<Frame name={self.name} url={self.url!r}>"
|
||||
|
||||
def _on_load_state(
|
||||
self, add: DocumentLoadState = None, remove: DocumentLoadState = None
|
||||
) -> None:
|
||||
if add:
|
||||
self._load_states.add(add)
|
||||
self._event_emitter.emit("loadstate", add)
|
||||
elif remove and remove in self._load_states:
|
||||
self._load_states.remove(remove)
|
||||
if not self._parent_frame and add == "load" and self._page:
|
||||
self._page.emit("load", self._page)
|
||||
if not self._parent_frame and add == "domcontentloaded" and self._page:
|
||||
self._page.emit("domcontentloaded", self._page)
|
||||
|
||||
def _on_frame_navigated(self, event: FrameNavigatedEvent) -> None:
|
||||
self._url = event["url"]
|
||||
self._name = event["name"]
|
||||
self._event_emitter.emit("navigated", event)
|
||||
if "error" not in event and self._page:
|
||||
self._page.emit("framenavigated", self)
|
||||
|
||||
async def _query_count(self, selector: str) -> int:
|
||||
return await self._channel.send("queryCount", None, {"selector": selector})
|
||||
|
||||
@property
|
||||
def page(self) -> "Page":
|
||||
assert self._page
|
||||
return self._page
|
||||
|
||||
async def goto(
|
||||
self,
|
||||
url: str,
|
||||
timeout: float = None,
|
||||
waitUntil: DocumentLoadState = None,
|
||||
referer: str = None,
|
||||
) -> Optional[Response]:
|
||||
return cast(
|
||||
Optional[Response],
|
||||
from_nullable_channel(
|
||||
await self._channel.send(
|
||||
"goto", self._navigation_timeout, locals_to_params(locals())
|
||||
)
|
||||
),
|
||||
)
|
||||
|
||||
def _setup_navigation_waiter(self, wait_name: str, timeout: float = None) -> Waiter:
|
||||
assert self._page
|
||||
waiter = Waiter(self._page, f"frame.{wait_name}")
|
||||
waiter.reject_on_event(
|
||||
self._page,
|
||||
"close",
|
||||
lambda: cast("Page", self._page)._close_error_with_reason(),
|
||||
)
|
||||
waiter.reject_on_event(
|
||||
self._page, "crash", Error("Navigation failed because page crashed!")
|
||||
)
|
||||
waiter.reject_on_event(
|
||||
self._page,
|
||||
"framedetached",
|
||||
Error("Navigating frame was detached!"),
|
||||
lambda frame: frame == self,
|
||||
)
|
||||
timeout = self._page._timeout_settings.navigation_timeout(timeout)
|
||||
waiter.reject_on_timeout(timeout, f"Timeout {timeout}ms exceeded.")
|
||||
return waiter
|
||||
|
||||
async def _expect(
|
||||
self,
|
||||
selector: Optional[str],
|
||||
expression: str,
|
||||
options: FrameExpectOptions,
|
||||
title: str = None,
|
||||
) -> FrameExpectResult:
|
||||
if "expectedValue" in options:
|
||||
options["expectedValue"] = serialize_argument(options["expectedValue"])
|
||||
result = await self._channel.send_return_as_dict(
|
||||
"expect",
|
||||
self._timeout,
|
||||
{
|
||||
"selector": selector,
|
||||
"expression": expression,
|
||||
**options,
|
||||
},
|
||||
title=title,
|
||||
)
|
||||
if result.get("received"):
|
||||
result["received"] = parse_value(result["received"])
|
||||
return result
|
||||
|
||||
def expect_navigation(
|
||||
self,
|
||||
url: URLMatch = None,
|
||||
waitUntil: DocumentLoadState = None,
|
||||
timeout: float = None,
|
||||
) -> EventContextManagerImpl[Response]:
|
||||
assert self._page
|
||||
if not waitUntil:
|
||||
waitUntil = "load"
|
||||
|
||||
if timeout is None:
|
||||
timeout = self._page._timeout_settings.navigation_timeout()
|
||||
deadline = monotonic_time() + timeout
|
||||
waiter = self._setup_navigation_waiter("expect_navigation", timeout)
|
||||
|
||||
to_url = f' to "{url}"' if url else ""
|
||||
waiter.log(f"waiting for navigation{to_url} until '{waitUntil}'")
|
||||
|
||||
def predicate(event: Any) -> bool:
|
||||
# Any failed navigation results in a rejection.
|
||||
if event.get("error"):
|
||||
return True
|
||||
waiter.log(f' navigated to "{event["url"]}"')
|
||||
return url_matches(
|
||||
cast("Page", self._page)._browser_context._base_url,
|
||||
event["url"],
|
||||
url,
|
||||
)
|
||||
|
||||
waiter.wait_for_event(
|
||||
self._event_emitter,
|
||||
"navigated",
|
||||
predicate=predicate,
|
||||
)
|
||||
|
||||
async def continuation() -> Optional[Response]:
|
||||
event = await waiter.result()
|
||||
if "error" in event:
|
||||
raise Error(event["error"])
|
||||
if waitUntil not in self._load_states:
|
||||
t = deadline - monotonic_time()
|
||||
if t > 0:
|
||||
await self._wait_for_load_state_impl(state=waitUntil, timeout=t)
|
||||
if "newDocument" in event and "request" in event["newDocument"]:
|
||||
request = from_channel(event["newDocument"]["request"])
|
||||
return await request.response()
|
||||
return None
|
||||
|
||||
return EventContextManagerImpl(asyncio.create_task(continuation()))
|
||||
|
||||
async def wait_for_url(
|
||||
self,
|
||||
url: URLMatch,
|
||||
waitUntil: DocumentLoadState = None,
|
||||
timeout: float = None,
|
||||
) -> None:
|
||||
assert self._page
|
||||
if url_matches(self._page._browser_context._base_url, self.url, url):
|
||||
await self._wait_for_load_state_impl(state=waitUntil, timeout=timeout)
|
||||
return
|
||||
async with self.expect_navigation(
|
||||
url=url, waitUntil=waitUntil, timeout=timeout
|
||||
):
|
||||
pass
|
||||
|
||||
async def wait_for_load_state(
|
||||
self,
|
||||
state: Literal["domcontentloaded", "load", "networkidle"] = None,
|
||||
timeout: float = None,
|
||||
) -> None:
|
||||
return await self._wait_for_load_state_impl(state, timeout)
|
||||
|
||||
async def _wait_for_load_state_impl(
|
||||
self, state: DocumentLoadState = None, timeout: float = None
|
||||
) -> None:
|
||||
if not state:
|
||||
state = "load"
|
||||
if state not in ("load", "domcontentloaded", "networkidle", "commit"):
|
||||
raise Error(
|
||||
"state: expected one of (load|domcontentloaded|networkidle|commit)"
|
||||
)
|
||||
waiter = self._setup_navigation_waiter("wait_for_load_state", timeout)
|
||||
|
||||
if state in self._load_states:
|
||||
waiter.log(f' not waiting, "{state}" event already fired')
|
||||
# TODO: align with upstream
|
||||
waiter._fulfill(None)
|
||||
else:
|
||||
|
||||
def handle_load_state_event(actual_state: str) -> bool:
|
||||
waiter.log(f'"{actual_state}" event fired')
|
||||
return actual_state == state
|
||||
|
||||
waiter.wait_for_event(
|
||||
self._event_emitter,
|
||||
"loadstate",
|
||||
handle_load_state_event,
|
||||
)
|
||||
await waiter.result()
|
||||
|
||||
def _timeout(self, timeout: Optional[float]) -> float:
|
||||
timeout_settings = (
|
||||
self._page._timeout_settings if self._page else TimeoutSettings(None)
|
||||
)
|
||||
return timeout_settings.timeout(timeout)
|
||||
|
||||
def _navigation_timeout(self, timeout: Optional[float]) -> float:
|
||||
timeout_settings = (
|
||||
self._page._timeout_settings if self._page else TimeoutSettings(None)
|
||||
)
|
||||
return timeout_settings.navigation_timeout(timeout)
|
||||
|
||||
async def frame_element(self) -> ElementHandle:
|
||||
return from_channel(await self._channel.send("frameElement", None))
|
||||
|
||||
async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
|
||||
return parse_result(
|
||||
await self._channel.send(
|
||||
"evaluateExpression",
|
||||
None,
|
||||
dict(
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def evaluate_handle(
|
||||
self, expression: str, arg: Serializable = None
|
||||
) -> JSHandle:
|
||||
return from_channel(
|
||||
await self._channel.send(
|
||||
"evaluateExpressionHandle",
|
||||
None,
|
||||
dict(
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def query_selector(
|
||||
self, selector: str, strict: bool = None
|
||||
) -> Optional[ElementHandle]:
|
||||
return from_nullable_channel(
|
||||
await self._channel.send("querySelector", None, locals_to_params(locals()))
|
||||
)
|
||||
|
||||
async def query_selector_all(self, selector: str) -> List[ElementHandle]:
|
||||
return list(
|
||||
map(
|
||||
from_channel,
|
||||
await self._channel.send(
|
||||
"querySelectorAll", None, dict(selector=selector)
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def wait_for_selector(
|
||||
self,
|
||||
selector: str,
|
||||
strict: bool = None,
|
||||
timeout: float = None,
|
||||
state: Literal["attached", "detached", "hidden", "visible"] = None,
|
||||
) -> Optional[ElementHandle]:
|
||||
return from_nullable_channel(
|
||||
await self._channel.send(
|
||||
"waitForSelector", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
)
|
||||
|
||||
async def is_checked(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> bool:
|
||||
return await self._channel.send(
|
||||
"isChecked", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def is_disabled(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> bool:
|
||||
return await self._channel.send(
|
||||
"isDisabled", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def is_editable(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> bool:
|
||||
return await self._channel.send(
|
||||
"isEditable", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def is_enabled(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> bool:
|
||||
return await self._channel.send(
|
||||
"isEnabled", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def is_hidden(self, selector: str, strict: bool = None) -> bool:
|
||||
return await self._channel.send(
|
||||
"isHidden", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def is_visible(self, selector: str, strict: bool = None) -> bool:
|
||||
return await self._channel.send(
|
||||
"isVisible", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def dispatch_event(
|
||||
self,
|
||||
selector: str,
|
||||
type: str,
|
||||
eventInit: Dict = None,
|
||||
strict: bool = None,
|
||||
timeout: float = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"dispatchEvent",
|
||||
self._timeout,
|
||||
locals_to_params(
|
||||
dict(
|
||||
selector=selector,
|
||||
type=type,
|
||||
eventInit=serialize_argument(eventInit),
|
||||
strict=strict,
|
||||
timeout=timeout,
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
async def eval_on_selector(
|
||||
self,
|
||||
selector: str,
|
||||
expression: str,
|
||||
arg: Serializable = None,
|
||||
strict: bool = None,
|
||||
) -> Any:
|
||||
return parse_result(
|
||||
await self._channel.send(
|
||||
"evalOnSelector",
|
||||
None,
|
||||
locals_to_params(
|
||||
dict(
|
||||
selector=selector,
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
strict=strict,
|
||||
)
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def eval_on_selector_all(
|
||||
self,
|
||||
selector: str,
|
||||
expression: str,
|
||||
arg: Serializable = None,
|
||||
) -> Any:
|
||||
return parse_result(
|
||||
await self._channel.send(
|
||||
"evalOnSelectorAll",
|
||||
None,
|
||||
dict(
|
||||
selector=selector,
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def content(self) -> str:
|
||||
return await self._channel.send("content", None)
|
||||
|
||||
async def set_content(
|
||||
self,
|
||||
html: str,
|
||||
timeout: float = None,
|
||||
waitUntil: DocumentLoadState = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"setContent", self._navigation_timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
return self._name or ""
|
||||
|
||||
@property
|
||||
def url(self) -> str:
|
||||
return self._url or ""
|
||||
|
||||
@property
|
||||
def parent_frame(self) -> Optional["Frame"]:
|
||||
return self._parent_frame
|
||||
|
||||
@property
|
||||
def child_frames(self) -> List["Frame"]:
|
||||
return self._child_frames.copy()
|
||||
|
||||
def is_detached(self) -> bool:
|
||||
return self._detached
|
||||
|
||||
async def add_script_tag(
|
||||
self,
|
||||
url: str = None,
|
||||
path: Union[str, Path] = None,
|
||||
content: str = None,
|
||||
type: str = None,
|
||||
) -> ElementHandle:
|
||||
params = locals_to_params(locals())
|
||||
if path:
|
||||
params["content"] = add_source_url_to_script(
|
||||
(await async_readfile(path)).decode(), path
|
||||
)
|
||||
del params["path"]
|
||||
return from_channel(await self._channel.send("addScriptTag", None, params))
|
||||
|
||||
async def add_style_tag(
|
||||
self, url: str = None, path: Union[str, Path] = None, content: str = None
|
||||
) -> ElementHandle:
|
||||
params = locals_to_params(locals())
|
||||
if path:
|
||||
params["content"] = (
|
||||
(await async_readfile(path)).decode()
|
||||
+ "\n/*# sourceURL="
|
||||
+ str(Path(path))
|
||||
+ "*/"
|
||||
)
|
||||
del params["path"]
|
||||
return from_channel(await self._channel.send("addStyleTag", None, params))
|
||||
|
||||
async def click(
|
||||
self,
|
||||
selector: str,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._click(**locals_to_params(locals()))
|
||||
|
||||
async def _click(
|
||||
self,
|
||||
selector: str,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
steps: int = None,
|
||||
) -> None:
|
||||
await self._channel.send("click", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def dblclick(
|
||||
self,
|
||||
selector: str,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"dblclick", self._timeout, locals_to_params(locals()), title="Double click"
|
||||
)
|
||||
|
||||
async def tap(
|
||||
self,
|
||||
selector: str,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send("tap", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def fill(
|
||||
self,
|
||||
selector: str,
|
||||
value: str,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
force: bool = None,
|
||||
) -> None:
|
||||
await self._fill(**locals_to_params(locals()))
|
||||
|
||||
async def _fill(
|
||||
self,
|
||||
selector: str,
|
||||
value: str,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
force: bool = None,
|
||||
title: str = None,
|
||||
) -> None:
|
||||
await self._channel.send("fill", self._timeout, locals_to_params(locals()))
|
||||
|
||||
def locator(
|
||||
self,
|
||||
selector: str,
|
||||
hasText: Union[str, Pattern[str]] = None,
|
||||
hasNotText: Union[str, Pattern[str]] = None,
|
||||
has: Locator = None,
|
||||
hasNot: Locator = None,
|
||||
) -> Locator:
|
||||
return Locator(
|
||||
self,
|
||||
selector,
|
||||
has_text=hasText,
|
||||
has_not_text=hasNotText,
|
||||
has=has,
|
||||
has_not=hasNot,
|
||||
)
|
||||
|
||||
def get_by_alt_text(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_alt_text_selector(text, exact=exact))
|
||||
|
||||
def get_by_label(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_label_selector(text, exact=exact))
|
||||
|
||||
def get_by_placeholder(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_placeholder_selector(text, exact=exact))
|
||||
|
||||
def get_by_role(
|
||||
self,
|
||||
role: AriaRole,
|
||||
checked: bool = None,
|
||||
disabled: bool = None,
|
||||
expanded: bool = None,
|
||||
includeHidden: bool = None,
|
||||
level: int = None,
|
||||
name: Union[str, Pattern[str]] = None,
|
||||
pressed: bool = None,
|
||||
selected: bool = None,
|
||||
exact: bool = None,
|
||||
) -> "Locator":
|
||||
return self.locator(
|
||||
get_by_role_selector(
|
||||
role,
|
||||
checked=checked,
|
||||
disabled=disabled,
|
||||
expanded=expanded,
|
||||
includeHidden=includeHidden,
|
||||
level=level,
|
||||
name=name,
|
||||
pressed=pressed,
|
||||
selected=selected,
|
||||
exact=exact,
|
||||
)
|
||||
)
|
||||
|
||||
def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
|
||||
return self.locator(get_by_test_id_selector(test_id_attribute_name(), testId))
|
||||
|
||||
def get_by_text(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_text_selector(text, exact=exact))
|
||||
|
||||
def get_by_title(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_title_selector(text, exact=exact))
|
||||
|
||||
def frame_locator(self, selector: str) -> FrameLocator:
|
||||
return FrameLocator(self, selector)
|
||||
|
||||
async def focus(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> None:
|
||||
await self._channel.send("focus", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def text_content(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> Optional[str]:
|
||||
return await self._channel.send(
|
||||
"textContent", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def inner_text(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> str:
|
||||
return await self._channel.send(
|
||||
"innerText", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def inner_html(
|
||||
self, selector: str, strict: bool = None, timeout: float = None
|
||||
) -> str:
|
||||
return await self._channel.send(
|
||||
"innerHTML", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def get_attribute(
|
||||
self, selector: str, name: str, strict: bool = None, timeout: float = None
|
||||
) -> Optional[str]:
|
||||
return await self._channel.send(
|
||||
"getAttribute", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def hover(
|
||||
self,
|
||||
selector: str,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
force: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send("hover", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def drag_and_drop(
|
||||
self,
|
||||
source: str,
|
||||
target: str,
|
||||
sourcePosition: Position = None,
|
||||
targetPosition: Position = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
timeout: float = None,
|
||||
trial: bool = None,
|
||||
steps: int = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"dragAndDrop", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def select_option(
|
||||
self,
|
||||
selector: str,
|
||||
value: Union[str, Sequence[str]] = None,
|
||||
index: Union[int, Sequence[int]] = None,
|
||||
label: Union[str, Sequence[str]] = None,
|
||||
element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
force: bool = None,
|
||||
) -> List[str]:
|
||||
params = locals_to_params(
|
||||
dict(
|
||||
selector=selector,
|
||||
timeout=timeout,
|
||||
strict=strict,
|
||||
force=force,
|
||||
**convert_select_option_values(value, index, label, element),
|
||||
)
|
||||
)
|
||||
return await self._channel.send("selectOption", self._timeout, params)
|
||||
|
||||
async def input_value(
|
||||
self,
|
||||
selector: str,
|
||||
strict: bool = None,
|
||||
timeout: float = None,
|
||||
) -> str:
|
||||
return await self._channel.send(
|
||||
"inputValue", self._timeout, locals_to_params(locals())
|
||||
)
|
||||
|
||||
async def set_input_files(
|
||||
self,
|
||||
selector: str,
|
||||
files: Union[
|
||||
str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
|
||||
],
|
||||
strict: bool = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
converted = await convert_input_files(files, self.page.context)
|
||||
await self._channel.send(
|
||||
"setInputFiles",
|
||||
self._timeout,
|
||||
{
|
||||
"selector": selector,
|
||||
"strict": strict,
|
||||
"timeout": self._timeout(timeout),
|
||||
**converted,
|
||||
},
|
||||
)
|
||||
|
||||
async def type(
|
||||
self,
|
||||
selector: str,
|
||||
text: str,
|
||||
delay: float = None,
|
||||
strict: bool = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send("type", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def press(
|
||||
self,
|
||||
selector: str,
|
||||
key: str,
|
||||
delay: float = None,
|
||||
strict: bool = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send("press", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def check(
|
||||
self,
|
||||
selector: str,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send("check", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def uncheck(
|
||||
self,
|
||||
selector: str,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
await self._channel.send("uncheck", self._timeout, locals_to_params(locals()))
|
||||
|
||||
async def wait_for_timeout(self, timeout: float) -> None:
|
||||
await self._channel.send("waitForTimeout", None, {"waitTimeout": timeout})
|
||||
|
||||
async def wait_for_function(
|
||||
self,
|
||||
expression: str,
|
||||
arg: Serializable = None,
|
||||
timeout: float = None,
|
||||
polling: Union[float, Literal["raf"]] = None,
|
||||
) -> JSHandle:
|
||||
if isinstance(polling, str) and polling != "raf":
|
||||
raise Error(f"Unknown polling option: {polling}")
|
||||
params = locals_to_params(locals())
|
||||
params["arg"] = serialize_argument(arg)
|
||||
if polling is not None and polling != "raf":
|
||||
params["pollingInterval"] = polling
|
||||
return from_channel(
|
||||
await self._channel.send("waitForFunction", self._timeout, params)
|
||||
)
|
||||
|
||||
async def title(self) -> str:
|
||||
return await self._channel.send("title", None)
|
||||
|
||||
async def set_checked(
|
||||
self,
|
||||
selector: str,
|
||||
checked: bool,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
strict: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
if checked:
|
||||
await self.check(
|
||||
selector=selector,
|
||||
position=position,
|
||||
timeout=timeout,
|
||||
force=force,
|
||||
strict=strict,
|
||||
trial=trial,
|
||||
)
|
||||
else:
|
||||
await self.uncheck(
|
||||
selector=selector,
|
||||
position=position,
|
||||
timeout=timeout,
|
||||
force=force,
|
||||
strict=strict,
|
||||
trial=trial,
|
||||
)
|
||||
|
||||
async def _highlight(self, selector: str) -> None:
|
||||
await self._channel.send("highlight", None, {"selector": selector})
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
# 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.
|
||||
|
||||
# https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
|
||||
escaped_chars = {"$", "^", "+", ".", "*", "(", ")", "|", "\\", "?", "{", "}", "[", "]"}
|
||||
|
||||
|
||||
def glob_to_regex_pattern(glob: str) -> str:
|
||||
tokens = ["^"]
|
||||
in_group = False
|
||||
|
||||
i = 0
|
||||
while i < len(glob):
|
||||
c = glob[i]
|
||||
if c == "\\" and i + 1 < len(glob):
|
||||
char = glob[i + 1]
|
||||
tokens.append("\\" + char if char in escaped_chars else char)
|
||||
i += 1
|
||||
elif c == "*":
|
||||
char_before = glob[i - 1] if i > 0 else None
|
||||
star_count = 1
|
||||
while i + 1 < len(glob) and glob[i + 1] == "*":
|
||||
star_count += 1
|
||||
i += 1
|
||||
if star_count > 1:
|
||||
char_after = glob[i + 1] if i + 1 < len(glob) else None
|
||||
if char_after == "/":
|
||||
if char_before == "/":
|
||||
tokens.append("((.+/)|)")
|
||||
else:
|
||||
tokens.append("(.*/)")
|
||||
i += 1
|
||||
else:
|
||||
tokens.append("(.*)")
|
||||
else:
|
||||
tokens.append("([^/]*)")
|
||||
else:
|
||||
if c == "{":
|
||||
in_group = True
|
||||
tokens.append("(")
|
||||
elif c == "}":
|
||||
in_group = False
|
||||
tokens.append(")")
|
||||
elif c == ",":
|
||||
if in_group:
|
||||
tokens.append("|")
|
||||
else:
|
||||
tokens.append("\\" + c)
|
||||
else:
|
||||
tokens.append("\\" + c if c in escaped_chars else c)
|
||||
i += 1
|
||||
|
||||
tokens.append("$")
|
||||
return "".join(tokens)
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
# 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 Tuple
|
||||
|
||||
import greenlet
|
||||
|
||||
|
||||
def _greenlet_trace_callback(
|
||||
event: str, args: Tuple[greenlet.greenlet, greenlet.greenlet]
|
||||
) -> None:
|
||||
if event in ("switch", "throw"):
|
||||
origin, target = args
|
||||
print(f"Transfer from {origin} to {target} with {event}")
|
||||
|
||||
|
||||
if os.environ.get("INTERNAL_PW_GREENLET_DEBUG"):
|
||||
greenlet.settrace(_greenlet_trace_callback)
|
||||
|
||||
|
||||
class MainGreenlet(greenlet.greenlet):
|
||||
def __str__(self) -> str:
|
||||
return "<MainGreenlet>"
|
||||
|
||||
|
||||
class RouteGreenlet(greenlet.greenlet):
|
||||
def __str__(self) -> str:
|
||||
return "<RouteGreenlet>"
|
||||
|
||||
|
||||
class LocatorHandlerGreenlet(greenlet.greenlet):
|
||||
def __str__(self) -> str:
|
||||
return "<LocatorHandlerGreenlet>"
|
||||
|
||||
|
||||
class EventGreenlet(greenlet.greenlet):
|
||||
def __str__(self) -> str:
|
||||
return "<EventGreenlet>"
|
||||
+122
@@ -0,0 +1,122 @@
|
||||
# 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 base64
|
||||
from typing import TYPE_CHECKING, Optional, cast
|
||||
|
||||
from playwright._impl._api_structures import HeadersArray
|
||||
from playwright._impl._helper import (
|
||||
HarLookupResult,
|
||||
RouteFromHarNotFoundPolicy,
|
||||
URLMatch,
|
||||
)
|
||||
from playwright._impl._local_utils import LocalUtils
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._browser_context import BrowserContext
|
||||
from playwright._impl._network import Route
|
||||
from playwright._impl._page import Page
|
||||
|
||||
|
||||
class HarRouter:
|
||||
def __init__(
|
||||
self,
|
||||
local_utils: LocalUtils,
|
||||
har_id: str,
|
||||
not_found_action: RouteFromHarNotFoundPolicy,
|
||||
url_matcher: Optional[URLMatch] = None,
|
||||
) -> None:
|
||||
self._local_utils: LocalUtils = local_utils
|
||||
self._har_id: str = har_id
|
||||
self._not_found_action: RouteFromHarNotFoundPolicy = not_found_action
|
||||
self._options_url_match: Optional[URLMatch] = url_matcher
|
||||
|
||||
@staticmethod
|
||||
async def create(
|
||||
local_utils: LocalUtils,
|
||||
file: str,
|
||||
not_found_action: RouteFromHarNotFoundPolicy,
|
||||
url_matcher: Optional[URLMatch] = None,
|
||||
) -> "HarRouter":
|
||||
har_id = await local_utils._channel.send("harOpen", None, {"file": file})
|
||||
return HarRouter(
|
||||
local_utils=local_utils,
|
||||
har_id=har_id,
|
||||
not_found_action=not_found_action,
|
||||
url_matcher=url_matcher,
|
||||
)
|
||||
|
||||
async def _handle(self, route: "Route") -> None:
|
||||
request = route.request
|
||||
response: HarLookupResult = await self._local_utils.har_lookup(
|
||||
harId=self._har_id,
|
||||
url=request.url,
|
||||
method=request.method,
|
||||
headers=await request.headers_array(),
|
||||
postData=request.post_data_buffer,
|
||||
isNavigationRequest=request.is_navigation_request(),
|
||||
)
|
||||
action = response["action"]
|
||||
if action == "redirect":
|
||||
redirect_url = response["redirectURL"]
|
||||
assert redirect_url
|
||||
await route._redirected_navigation_request(redirect_url)
|
||||
return
|
||||
|
||||
if action == "fulfill":
|
||||
# If the response status is -1, the request was canceled or stalled, so we just stall it here.
|
||||
# See https://github.com/microsoft/playwright/issues/29311.
|
||||
# TODO: it'd be better to abort such requests, but then we likely need to respect the timing,
|
||||
# because the request might have been stalled for a long time until the very end of the
|
||||
# test when HAR was recorded but we'd abort it immediately.
|
||||
if response.get("status") == -1:
|
||||
return
|
||||
body = response["body"]
|
||||
assert body is not None
|
||||
await route.fulfill(
|
||||
status=response.get("status"),
|
||||
headers={
|
||||
v["name"]: v["value"]
|
||||
for v in cast(HeadersArray, response.get("headers", []))
|
||||
},
|
||||
body=base64.b64decode(body),
|
||||
)
|
||||
return
|
||||
|
||||
if action == "error":
|
||||
pass
|
||||
# Report the error, but fall through to the default handler.
|
||||
|
||||
if self._not_found_action == "abort":
|
||||
await route.abort()
|
||||
return
|
||||
|
||||
await route.fallback()
|
||||
|
||||
async def add_context_route(self, context: "BrowserContext") -> None:
|
||||
await context.route(
|
||||
url=self._options_url_match or "**/*",
|
||||
handler=lambda route, _: asyncio.create_task(self._handle(route)),
|
||||
)
|
||||
|
||||
async def add_page_route(self, page: "Page") -> None:
|
||||
await page.route(
|
||||
url=self._options_url_match or "**/*",
|
||||
handler=lambda route, _: asyncio.create_task(self._handle(route)),
|
||||
)
|
||||
|
||||
def dispose(self) -> None:
|
||||
asyncio.create_task(
|
||||
self._local_utils._channel.send("harClose", None, {"harId": self._har_id})
|
||||
)
|
||||
+571
@@ -0,0 +1,571 @@
|
||||
# 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 math
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
import traceback
|
||||
from pathlib import Path
|
||||
from types import TracebackType
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Callable,
|
||||
Dict,
|
||||
List,
|
||||
Literal,
|
||||
Optional,
|
||||
Pattern,
|
||||
Set,
|
||||
Tuple,
|
||||
TypedDict,
|
||||
TypeVar,
|
||||
Union,
|
||||
cast,
|
||||
)
|
||||
from urllib.parse import ParseResult, urljoin, urlparse, urlunparse
|
||||
|
||||
from playwright._impl._api_structures import NameValue
|
||||
from playwright._impl._errors import (
|
||||
Error,
|
||||
TargetClosedError,
|
||||
TimeoutError,
|
||||
is_target_closed_error,
|
||||
rewrite_error,
|
||||
)
|
||||
from playwright._impl._glob import glob_to_regex_pattern
|
||||
from playwright._impl._greenlets import RouteGreenlet
|
||||
from playwright._impl._str_utils import escape_regex_flags
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._api_structures import HeadersArray
|
||||
from playwright._impl._network import Request, Response, Route, WebSocketRoute
|
||||
|
||||
URLMatch = Union[str, Pattern[str], Callable[[str], bool]]
|
||||
URLMatchRequest = Union[str, Pattern[str], Callable[["Request"], bool]]
|
||||
URLMatchResponse = Union[str, Pattern[str], Callable[["Response"], bool]]
|
||||
RouteHandlerCallback = Union[
|
||||
Callable[["Route"], Any], Callable[["Route", "Request"], Any]
|
||||
]
|
||||
WebSocketRouteHandlerCallback = Callable[["WebSocketRoute"], Any]
|
||||
|
||||
ColorScheme = Literal["dark", "light", "no-preference", "null"]
|
||||
ForcedColors = Literal["active", "none", "null"]
|
||||
Contrast = Literal["more", "no-preference", "null"]
|
||||
ReducedMotion = Literal["no-preference", "null", "reduce"]
|
||||
DocumentLoadState = Literal["commit", "domcontentloaded", "load", "networkidle"]
|
||||
KeyboardModifier = Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]
|
||||
MouseButton = Literal["left", "middle", "right"]
|
||||
ServiceWorkersPolicy = Literal["allow", "block"]
|
||||
HarMode = Literal["full", "minimal"]
|
||||
HarContentPolicy = Literal["attach", "embed", "omit"]
|
||||
RouteFromHarNotFoundPolicy = Literal["abort", "fallback"]
|
||||
|
||||
|
||||
class ErrorPayload(TypedDict, total=False):
|
||||
message: str
|
||||
name: str
|
||||
stack: str
|
||||
value: Optional[Any]
|
||||
|
||||
|
||||
class HarRecordingMetadata(TypedDict, total=False):
|
||||
path: str
|
||||
content: Optional[HarContentPolicy]
|
||||
|
||||
|
||||
def prepare_record_har_options(params: Dict) -> Dict[str, Any]:
|
||||
out_params: Dict[str, Any] = {"path": str(params["recordHarPath"])}
|
||||
if "recordHarUrlFilter" in params:
|
||||
opt = params["recordHarUrlFilter"]
|
||||
if isinstance(opt, str):
|
||||
out_params["urlGlob"] = opt
|
||||
if isinstance(opt, Pattern):
|
||||
out_params["urlRegexSource"] = opt.pattern
|
||||
out_params["urlRegexFlags"] = escape_regex_flags(opt)
|
||||
del params["recordHarUrlFilter"]
|
||||
if "recordHarMode" in params:
|
||||
out_params["mode"] = params["recordHarMode"]
|
||||
del params["recordHarMode"]
|
||||
|
||||
new_content_api = None
|
||||
old_content_api = None
|
||||
if "recordHarContent" in params:
|
||||
new_content_api = params["recordHarContent"]
|
||||
del params["recordHarContent"]
|
||||
if "recordHarOmitContent" in params:
|
||||
old_content_api = params["recordHarOmitContent"]
|
||||
del params["recordHarOmitContent"]
|
||||
content = new_content_api or ("omit" if old_content_api else None)
|
||||
if content:
|
||||
out_params["content"] = content
|
||||
|
||||
return out_params
|
||||
|
||||
|
||||
class ParsedMessageParams(TypedDict):
|
||||
type: str
|
||||
guid: str
|
||||
initializer: Dict
|
||||
|
||||
|
||||
class ParsedMessagePayload(TypedDict, total=False):
|
||||
id: int
|
||||
guid: str
|
||||
method: str
|
||||
params: ParsedMessageParams
|
||||
result: Any
|
||||
error: ErrorPayload
|
||||
|
||||
|
||||
class Document(TypedDict):
|
||||
request: Optional[Any]
|
||||
|
||||
|
||||
class FrameNavigatedEvent(TypedDict):
|
||||
url: str
|
||||
name: str
|
||||
newDocument: Optional[Document]
|
||||
error: Optional[str]
|
||||
|
||||
|
||||
Env = Dict[str, Union[str, float, bool]]
|
||||
|
||||
|
||||
def url_matches(
|
||||
base_url: Optional[str],
|
||||
url_string: str,
|
||||
match: Optional[URLMatch],
|
||||
websocket_url: bool = None,
|
||||
) -> bool:
|
||||
if not match:
|
||||
return True
|
||||
if isinstance(match, str):
|
||||
match = re.compile(
|
||||
resolve_glob_to_regex_pattern(base_url, match, websocket_url)
|
||||
)
|
||||
if isinstance(match, Pattern):
|
||||
return bool(match.search(url_string))
|
||||
return match(url_string)
|
||||
|
||||
|
||||
def resolve_glob_to_regex_pattern(
|
||||
base_url: Optional[str], glob: str, websocket_url: bool = None
|
||||
) -> str:
|
||||
if websocket_url:
|
||||
base_url = to_websocket_base_url(base_url)
|
||||
glob = resolve_glob_base(base_url, glob)
|
||||
return glob_to_regex_pattern(glob)
|
||||
|
||||
|
||||
def to_websocket_base_url(base_url: Optional[str]) -> Optional[str]:
|
||||
if base_url is not None and re.match(r"^https?://", base_url):
|
||||
base_url = re.sub(r"^http", "ws", base_url)
|
||||
return base_url
|
||||
|
||||
|
||||
def resolve_glob_base(base_url: Optional[str], match: str) -> str:
|
||||
if match[0] == "*":
|
||||
return match
|
||||
|
||||
token_map: Dict[str, str] = {}
|
||||
|
||||
def map_token(original: str, replacement: str) -> str:
|
||||
if len(original) == 0:
|
||||
return ""
|
||||
token_map[replacement] = original
|
||||
return replacement
|
||||
|
||||
# Escaped `\\?` behaves the same as `?` in our glob patterns.
|
||||
match = match.replace(r"\\?", "?")
|
||||
# Special case about: URLs as they are not relative to base_url
|
||||
if (
|
||||
match.startswith("about:")
|
||||
or match.startswith("data:")
|
||||
or match.startswith("chrome:")
|
||||
or match.startswith("edge:")
|
||||
or match.startswith("file:")
|
||||
):
|
||||
# about: and data: URLs are not relative to base_url, so we return them as is.
|
||||
return match
|
||||
# Glob symbols may be escaped in the URL and some of them such as ? affect resolution,
|
||||
# so we replace them with safe components first.
|
||||
processed_parts = []
|
||||
for index, token in enumerate(match.split("/")):
|
||||
if token in (".", "..", ""):
|
||||
processed_parts.append(token)
|
||||
continue
|
||||
# Handle special case of http*://, note that the new schema has to be
|
||||
# a web schema so that slashes are properly inserted after domain.
|
||||
if index == 0 and token.endswith(":"):
|
||||
# Replace any pattern with http:
|
||||
if "*" in token or "{" in token:
|
||||
processed_parts.append(map_token(token, "http:"))
|
||||
else:
|
||||
# Preserve explicit schema as is as it may affect trailing slashes after domain.
|
||||
processed_parts.append(token)
|
||||
continue
|
||||
question_index = token.find("?")
|
||||
if question_index == -1:
|
||||
processed_parts.append(map_token(token, f"$_{index}_$"))
|
||||
else:
|
||||
new_prefix = map_token(token[:question_index], f"$_{index}_$")
|
||||
new_suffix = map_token(token[question_index:], f"?$_{index}_$")
|
||||
processed_parts.append(new_prefix + new_suffix)
|
||||
|
||||
relative_path = "/".join(processed_parts)
|
||||
resolved, case_insensitive_part = resolve_base_url(base_url, relative_path)
|
||||
|
||||
for token, original in token_map.items():
|
||||
normalize = case_insensitive_part and token in case_insensitive_part
|
||||
resolved = resolved.replace(
|
||||
token, original.lower() if normalize else original, 1
|
||||
)
|
||||
|
||||
return resolved
|
||||
|
||||
|
||||
def resolve_base_url(
|
||||
base_url: Optional[str], given_url: str
|
||||
) -> Tuple[str, Optional[str]]:
|
||||
try:
|
||||
url = nodelike_urlparse(
|
||||
urljoin(base_url if base_url is not None else "", given_url)
|
||||
)
|
||||
resolved = urlunparse(url)
|
||||
# Schema and domain are case-insensitive.
|
||||
hostname_port = (
|
||||
url.hostname or ""
|
||||
) # can't use parsed.netloc because it includes userinfo (username:password)
|
||||
if url.port:
|
||||
hostname_port += f":{url.port}"
|
||||
case_insensitive_prefix = f"{url.scheme}://{hostname_port}"
|
||||
return resolved, case_insensitive_prefix
|
||||
except Exception:
|
||||
return given_url, None
|
||||
|
||||
|
||||
def nodelike_urlparse(url: str) -> ParseResult:
|
||||
parsed = urlparse(url, allow_fragments=True)
|
||||
|
||||
# https://url.spec.whatwg.org/#special-scheme
|
||||
is_special_url = parsed.scheme in ["http", "https", "ws", "wss", "ftp", "file"]
|
||||
if is_special_url:
|
||||
# special urls have a list path, list paths are serialized as follows: https://url.spec.whatwg.org/#url-path-serializer
|
||||
# urllib diverges, so we patch it here
|
||||
if parsed.path == "":
|
||||
parsed = parsed._replace(path="/")
|
||||
|
||||
return parsed
|
||||
|
||||
|
||||
class HarLookupResult(TypedDict, total=False):
|
||||
action: Literal["error", "redirect", "fulfill", "noentry"]
|
||||
message: Optional[str]
|
||||
redirectURL: Optional[str]
|
||||
status: Optional[int]
|
||||
headers: Optional["HeadersArray"]
|
||||
body: Optional[str]
|
||||
|
||||
|
||||
DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS = 30000
|
||||
DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT_IN_MILLISECONDS = 180000
|
||||
PLAYWRIGHT_MAX_DEADLINE = 2147483647 # 2^31-1
|
||||
|
||||
|
||||
class TimeoutSettings:
|
||||
|
||||
@staticmethod
|
||||
def launch_timeout(timeout: Optional[float] = None) -> float:
|
||||
return (
|
||||
timeout
|
||||
if timeout is not None
|
||||
else DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT_IN_MILLISECONDS
|
||||
)
|
||||
|
||||
def __init__(self, parent: Optional["TimeoutSettings"]) -> None:
|
||||
self._parent = parent
|
||||
self._default_timeout: Optional[float] = None
|
||||
self._default_navigation_timeout: Optional[float] = None
|
||||
|
||||
def set_default_timeout(self, timeout: Optional[float]) -> None:
|
||||
self._default_timeout = timeout
|
||||
|
||||
def timeout(self, timeout: float = None) -> float:
|
||||
if timeout is not None:
|
||||
return timeout
|
||||
if self._default_timeout is not None:
|
||||
return self._default_timeout
|
||||
if self._parent:
|
||||
return self._parent.timeout()
|
||||
return DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS
|
||||
|
||||
def set_default_navigation_timeout(
|
||||
self, navigation_timeout: Optional[float]
|
||||
) -> None:
|
||||
self._default_navigation_timeout = navigation_timeout
|
||||
|
||||
def default_navigation_timeout(self) -> Optional[float]:
|
||||
return self._default_navigation_timeout
|
||||
|
||||
def default_timeout(self) -> Optional[float]:
|
||||
return self._default_timeout
|
||||
|
||||
def navigation_timeout(self, timeout: float = None) -> float:
|
||||
if timeout is not None:
|
||||
return timeout
|
||||
if self._default_navigation_timeout is not None:
|
||||
return self._default_navigation_timeout
|
||||
if self._default_timeout is not None:
|
||||
return self._default_timeout
|
||||
if self._parent:
|
||||
return self._parent.navigation_timeout()
|
||||
return DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS
|
||||
|
||||
|
||||
def serialize_error(ex: Exception, tb: Optional[TracebackType]) -> ErrorPayload:
|
||||
return ErrorPayload(
|
||||
message=str(ex), name="Error", stack="".join(traceback.format_tb(tb))
|
||||
)
|
||||
|
||||
|
||||
def parse_error(error: ErrorPayload, log: Optional[str] = None) -> Error:
|
||||
base_error_class = Error
|
||||
if error.get("name") == "TimeoutError":
|
||||
base_error_class = TimeoutError
|
||||
if error.get("name") == "TargetClosedError":
|
||||
base_error_class = TargetClosedError
|
||||
if not log:
|
||||
log = ""
|
||||
exc = base_error_class(patch_error_message(error["message"]) + log)
|
||||
exc._name = error["name"]
|
||||
exc._stack = error["stack"]
|
||||
return exc
|
||||
|
||||
|
||||
def patch_error_message(message: str) -> str:
|
||||
match = re.match(r"(\w+)(: expected .*)", message)
|
||||
if match:
|
||||
message = to_snake_case(match.group(1)) + match.group(2)
|
||||
message = message.replace(
|
||||
"Pass { acceptDownloads: true }", "Pass 'accept_downloads=True'"
|
||||
)
|
||||
return message
|
||||
|
||||
|
||||
def locals_to_params(args: Dict) -> Dict:
|
||||
copy = {}
|
||||
for key in args:
|
||||
if key == "self":
|
||||
continue
|
||||
if args[key] is not None:
|
||||
copy[key] = (
|
||||
args[key]
|
||||
if not isinstance(args[key], Dict)
|
||||
else locals_to_params(args[key])
|
||||
)
|
||||
return copy
|
||||
|
||||
|
||||
def monotonic_time() -> int:
|
||||
return math.floor(time.monotonic() * 1000)
|
||||
|
||||
|
||||
class RouteHandlerInvocation:
|
||||
complete: "asyncio.Future"
|
||||
route: "Route"
|
||||
|
||||
def __init__(self, complete: "asyncio.Future", route: "Route") -> None:
|
||||
self.complete = complete
|
||||
self.route = route
|
||||
|
||||
|
||||
class RouteHandler:
|
||||
def __init__(
|
||||
self,
|
||||
base_url: Optional[str],
|
||||
url: URLMatch,
|
||||
handler: RouteHandlerCallback,
|
||||
is_sync: bool,
|
||||
times: Optional[int] = None,
|
||||
):
|
||||
self._base_url = base_url
|
||||
self.url = url
|
||||
self.handler = handler
|
||||
self._times = times if times else math.inf
|
||||
self._handled_count = 0
|
||||
self._is_sync = is_sync
|
||||
self._ignore_exception = False
|
||||
self._active_invocations: Set[RouteHandlerInvocation] = set()
|
||||
|
||||
def matches(self, request_url: str) -> bool:
|
||||
return url_matches(self._base_url, request_url, self.url)
|
||||
|
||||
async def handle(self, route: "Route") -> bool:
|
||||
handler_invocation = RouteHandlerInvocation(
|
||||
asyncio.get_running_loop().create_future(), route
|
||||
)
|
||||
self._active_invocations.add(handler_invocation)
|
||||
try:
|
||||
return await self._handle_internal(route)
|
||||
except Exception as e:
|
||||
# If the handler was stopped (without waiting for completion), we ignore all exceptions.
|
||||
if self._ignore_exception:
|
||||
return False
|
||||
if is_target_closed_error(e):
|
||||
# We are failing in the handler because the target has closed.
|
||||
# Give user a hint!
|
||||
optional_async_prefix = "await " if not self._is_sync else ""
|
||||
raise rewrite_error(
|
||||
e,
|
||||
f"\"{str(e)}\" while running route callback.\nConsider awaiting `{optional_async_prefix}page.unroute_all(behavior='ignoreErrors')`\nbefore the end of the test to ignore remaining routes in flight.",
|
||||
)
|
||||
raise e
|
||||
finally:
|
||||
handler_invocation.complete.set_result(None)
|
||||
self._active_invocations.remove(handler_invocation)
|
||||
|
||||
async def _handle_internal(self, route: "Route") -> bool:
|
||||
handled_future = route._start_handling()
|
||||
|
||||
self._handled_count += 1
|
||||
if self._is_sync:
|
||||
handler_finished_future = route._loop.create_future()
|
||||
|
||||
def _handler() -> None:
|
||||
try:
|
||||
self.handler(route, route.request) # type: ignore
|
||||
handler_finished_future.set_result(None)
|
||||
except Exception as e:
|
||||
handler_finished_future.set_exception(e)
|
||||
|
||||
# As with event handlers, each route handler is a potentially blocking context
|
||||
# so it needs a fiber.
|
||||
g = RouteGreenlet(_handler)
|
||||
g.switch()
|
||||
await handler_finished_future
|
||||
else:
|
||||
coro_or_future = self.handler(route, route.request) # type: ignore
|
||||
if coro_or_future:
|
||||
# separate task so that we get a proper stack trace for exceptions / tracing api_name extraction
|
||||
await asyncio.ensure_future(coro_or_future)
|
||||
return await handled_future
|
||||
|
||||
async def stop(self, behavior: Literal["ignoreErrors", "wait"]) -> None:
|
||||
# When a handler is manually unrouted or its page/context is closed we either
|
||||
# - wait for the current handler invocations to finish
|
||||
# - or do not wait, if the user opted out of it, but swallow all exceptions
|
||||
# that happen after the unroute/close.
|
||||
if behavior == "ignoreErrors":
|
||||
self._ignore_exception = True
|
||||
else:
|
||||
tasks = []
|
||||
for activation in self._active_invocations:
|
||||
if not activation.route._did_throw:
|
||||
tasks.append(activation.complete)
|
||||
await asyncio.gather(*tasks)
|
||||
|
||||
@property
|
||||
def will_expire(self) -> bool:
|
||||
return self._handled_count + 1 >= self._times
|
||||
|
||||
@staticmethod
|
||||
def prepare_interception_patterns(
|
||||
handlers: List["RouteHandler"],
|
||||
) -> List[Dict[str, str]]:
|
||||
patterns = []
|
||||
all = False
|
||||
for handler in handlers:
|
||||
if isinstance(handler.url, str):
|
||||
patterns.append({"glob": handler.url})
|
||||
elif isinstance(handler.url, re.Pattern):
|
||||
patterns.append(
|
||||
{
|
||||
"regexSource": handler.url.pattern,
|
||||
"regexFlags": escape_regex_flags(handler.url),
|
||||
}
|
||||
)
|
||||
else:
|
||||
all = True
|
||||
if all:
|
||||
return [{"glob": "**/*"}]
|
||||
return patterns
|
||||
|
||||
|
||||
to_snake_case_regex = re.compile("((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))")
|
||||
|
||||
|
||||
def to_snake_case(name: str) -> str:
|
||||
return to_snake_case_regex.sub(r"_\1", name).lower()
|
||||
|
||||
|
||||
def make_dirs_for_file(path: Union[Path, str]) -> None:
|
||||
if not os.path.isabs(path):
|
||||
path = Path.cwd() / path
|
||||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||||
|
||||
|
||||
async def async_writefile(file: Union[str, Path], data: Union[str, bytes]) -> None:
|
||||
def inner() -> None:
|
||||
with open(file, "w" if isinstance(data, str) else "wb") as fh:
|
||||
fh.write(data)
|
||||
|
||||
loop = asyncio.get_running_loop()
|
||||
await loop.run_in_executor(None, inner)
|
||||
|
||||
|
||||
async def async_readfile(file: Union[str, Path]) -> bytes:
|
||||
def inner() -> bytes:
|
||||
with open(file, "rb") as fh:
|
||||
return fh.read()
|
||||
|
||||
loop = asyncio.get_running_loop()
|
||||
return await loop.run_in_executor(None, inner)
|
||||
|
||||
|
||||
T = TypeVar("T")
|
||||
|
||||
|
||||
def to_impl(obj: T) -> T:
|
||||
if hasattr(obj, "_impl_obj"):
|
||||
return cast(Any, obj)._impl_obj
|
||||
return obj
|
||||
|
||||
|
||||
def object_to_array(obj: Optional[Dict]) -> Optional[List[NameValue]]:
|
||||
if not obj:
|
||||
return None
|
||||
result = []
|
||||
for key, value in obj.items():
|
||||
result.append(NameValue(name=key, value=str(value)))
|
||||
return result
|
||||
|
||||
|
||||
def is_file_payload(value: Optional[Any]) -> bool:
|
||||
return (
|
||||
isinstance(value, dict)
|
||||
and "name" in value
|
||||
and "mimeType" in value
|
||||
and "buffer" in value
|
||||
)
|
||||
|
||||
|
||||
TEXTUAL_MIME_TYPE = re.compile(
|
||||
r"^(text\/.*?|application\/(json|(x-)?javascript|xml.*?|ecmascript|graphql|x-www-form-urlencoded)|image\/svg(\+xml)?|application\/.*?(\+json|\+xml))(;\s*charset=.*)?$"
|
||||
)
|
||||
|
||||
|
||||
def is_textual_mime_type(mime_type: str) -> bool:
|
||||
return bool(TEXTUAL_MIME_TYPE.match(mime_type))
|
||||
+142
@@ -0,0 +1,142 @@
|
||||
# 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 inspect
|
||||
from typing import Any, Callable, Dict, List, Optional, Sequence, Union
|
||||
|
||||
from playwright._impl._errors import Error
|
||||
from playwright._impl._map import Map
|
||||
|
||||
API_ATTR = "_pw_api_instance_"
|
||||
IMPL_ATTR = "_pw_impl_instance_"
|
||||
|
||||
|
||||
class ImplWrapper:
|
||||
def __init__(self, impl_obj: Any) -> None:
|
||||
self._impl_obj = impl_obj
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return self._impl_obj.__repr__()
|
||||
|
||||
|
||||
class ImplToApiMapping:
|
||||
def __init__(self) -> None:
|
||||
self._mapping: Dict[type, type] = {}
|
||||
|
||||
def register(self, impl_class: type, api_class: type) -> None:
|
||||
self._mapping[impl_class] = api_class
|
||||
|
||||
def from_maybe_impl(
|
||||
self, obj: Any, visited: Optional[Map[Any, Union[List, Dict]]] = None
|
||||
) -> Any:
|
||||
# Python does share default arguments between calls, so we need to
|
||||
# create a new map if it is not provided.
|
||||
if not visited:
|
||||
visited = Map()
|
||||
if not obj:
|
||||
return obj
|
||||
if isinstance(obj, dict):
|
||||
if obj in visited:
|
||||
return visited[obj]
|
||||
o: Dict = {}
|
||||
visited[obj] = o
|
||||
for name, value in obj.items():
|
||||
o[name] = self.from_maybe_impl(value, visited)
|
||||
return o
|
||||
if isinstance(obj, list):
|
||||
if obj in visited:
|
||||
return visited[obj]
|
||||
a: List = []
|
||||
visited[obj] = a
|
||||
for item in obj:
|
||||
a.append(self.from_maybe_impl(item, visited))
|
||||
return a
|
||||
api_class = self._mapping.get(type(obj))
|
||||
if api_class:
|
||||
api_instance = getattr(obj, API_ATTR, None)
|
||||
if not api_instance:
|
||||
api_instance = api_class(obj)
|
||||
setattr(obj, API_ATTR, api_instance)
|
||||
return api_instance
|
||||
else:
|
||||
return obj
|
||||
|
||||
def from_impl(self, obj: Any) -> Any:
|
||||
assert obj
|
||||
result = self.from_maybe_impl(obj)
|
||||
assert result
|
||||
return result
|
||||
|
||||
def from_impl_nullable(self, obj: Any = None) -> Optional[Any]:
|
||||
return self.from_impl(obj) if obj else None
|
||||
|
||||
def from_impl_list(self, items: Sequence[Any]) -> List[Any]:
|
||||
return list(map(lambda a: self.from_impl(a), items))
|
||||
|
||||
def from_impl_dict(self, map: Dict[str, Any]) -> Dict[str, Any]:
|
||||
return {name: self.from_impl(value) for name, value in map.items()}
|
||||
|
||||
def to_impl(
|
||||
self, obj: Any, visited: Optional[Map[Any, Union[List, Dict]]] = None
|
||||
) -> Any:
|
||||
if visited is None:
|
||||
visited = Map()
|
||||
try:
|
||||
if not obj:
|
||||
return obj
|
||||
if isinstance(obj, dict):
|
||||
if obj in visited:
|
||||
return visited[obj]
|
||||
o: Dict = {}
|
||||
visited[obj] = o
|
||||
for name, value in obj.items():
|
||||
o[name] = self.to_impl(value, visited)
|
||||
return o
|
||||
if isinstance(obj, list):
|
||||
if obj in visited:
|
||||
return visited[obj]
|
||||
a: List = []
|
||||
visited[obj] = a
|
||||
for item in obj:
|
||||
a.append(self.to_impl(item, visited))
|
||||
return a
|
||||
if isinstance(obj, ImplWrapper):
|
||||
return obj._impl_obj
|
||||
return obj
|
||||
except RecursionError:
|
||||
raise Error("Maximum argument depth exceeded")
|
||||
|
||||
def wrap_handler(self, handler: Callable[..., Any]) -> Callable[..., None]:
|
||||
def wrapper_func(*args: Any) -> Any:
|
||||
arg_count = len(inspect.signature(handler).parameters)
|
||||
return handler(
|
||||
*list(map(lambda a: self.from_maybe_impl(a), args))[:arg_count]
|
||||
)
|
||||
|
||||
if inspect.ismethod(handler):
|
||||
wrapper = getattr(handler.__self__, IMPL_ATTR + handler.__name__, None)
|
||||
if not wrapper:
|
||||
wrapper = wrapper_func
|
||||
setattr(
|
||||
handler.__self__,
|
||||
IMPL_ATTR + handler.__name__,
|
||||
wrapper,
|
||||
)
|
||||
return wrapper
|
||||
|
||||
wrapper = getattr(handler, IMPL_ATTR, None)
|
||||
if not wrapper:
|
||||
wrapper = wrapper_func
|
||||
setattr(handler, IMPL_ATTR, wrapper)
|
||||
return wrapper
|
||||
+111
@@ -0,0 +1,111 @@
|
||||
# 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.
|
||||
|
||||
from playwright._impl._connection import Channel
|
||||
from playwright._impl._helper import MouseButton, locals_to_params
|
||||
|
||||
|
||||
class Keyboard:
|
||||
def __init__(self, channel: Channel) -> None:
|
||||
self._channel = channel
|
||||
self._loop = channel._connection._loop
|
||||
self._dispatcher_fiber = channel._connection._dispatcher_fiber
|
||||
|
||||
async def down(self, key: str) -> None:
|
||||
await self._channel.send("keyboardDown", None, locals_to_params(locals()))
|
||||
|
||||
async def up(self, key: str) -> None:
|
||||
await self._channel.send("keyboardUp", None, locals_to_params(locals()))
|
||||
|
||||
async def insert_text(self, text: str) -> None:
|
||||
await self._channel.send("keyboardInsertText", None, locals_to_params(locals()))
|
||||
|
||||
async def type(self, text: str, delay: float = None) -> None:
|
||||
await self._channel.send("keyboardType", None, locals_to_params(locals()))
|
||||
|
||||
async def press(self, key: str, delay: float = None) -> None:
|
||||
await self._channel.send("keyboardPress", None, locals_to_params(locals()))
|
||||
|
||||
|
||||
class Mouse:
|
||||
def __init__(self, channel: Channel) -> None:
|
||||
self._channel = channel
|
||||
self._loop = channel._connection._loop
|
||||
self._dispatcher_fiber = channel._connection._dispatcher_fiber
|
||||
|
||||
async def move(self, x: float, y: float, steps: int = None) -> None:
|
||||
await self._channel.send("mouseMove", None, locals_to_params(locals()))
|
||||
|
||||
async def down(
|
||||
self,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
) -> None:
|
||||
await self._channel.send("mouseDown", None, locals_to_params(locals()))
|
||||
|
||||
async def up(
|
||||
self,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
) -> None:
|
||||
await self._channel.send("mouseUp", None, locals_to_params(locals()))
|
||||
|
||||
async def _click(
|
||||
self,
|
||||
x: float,
|
||||
y: float,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
title: str = None,
|
||||
) -> None:
|
||||
await self._channel.send(
|
||||
"mouseClick", None, locals_to_params(locals()), title=title
|
||||
)
|
||||
|
||||
async def click(
|
||||
self,
|
||||
x: float,
|
||||
y: float,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
) -> None:
|
||||
params = locals()
|
||||
del params["self"]
|
||||
await self._click(**params)
|
||||
|
||||
async def dblclick(
|
||||
self,
|
||||
x: float,
|
||||
y: float,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
) -> None:
|
||||
await self._click(
|
||||
x, y, delay=delay, button=button, clickCount=2, title="Double click"
|
||||
)
|
||||
|
||||
async def wheel(self, deltaX: float, deltaY: float) -> None:
|
||||
await self._channel.send("mouseWheel", None, locals_to_params(locals()))
|
||||
|
||||
|
||||
class Touchscreen:
|
||||
def __init__(self, channel: Channel) -> None:
|
||||
self._channel = channel
|
||||
self._loop = channel._connection._loop
|
||||
self._dispatcher_fiber = channel._connection._dispatcher_fiber
|
||||
|
||||
async def tap(self, x: float, y: float) -> None:
|
||||
await self._channel.send("touchscreenTap", None, locals_to_params(locals()))
|
||||
+336
@@ -0,0 +1,336 @@
|
||||
# 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 base64
|
||||
import collections.abc
|
||||
import datetime
|
||||
import math
|
||||
import struct
|
||||
import traceback
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
|
||||
from urllib.parse import ParseResult, urlparse, urlunparse
|
||||
|
||||
from playwright._impl._connection import Channel, ChannelOwner, from_channel
|
||||
from playwright._impl._errors import Error, is_target_closed_error
|
||||
from playwright._impl._map import Map
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._element_handle import ElementHandle
|
||||
|
||||
|
||||
Serializable = Any
|
||||
|
||||
|
||||
class VisitorInfo:
|
||||
visited: Map[Any, int]
|
||||
last_id: int
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.visited = Map()
|
||||
self.last_id = 0
|
||||
|
||||
def visit(self, obj: Any) -> int:
|
||||
assert obj not in self.visited
|
||||
self.last_id += 1
|
||||
self.visited[obj] = self.last_id
|
||||
return self.last_id
|
||||
|
||||
|
||||
class JSHandle(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self._preview = self._initializer["preview"]
|
||||
self._channel.on(
|
||||
"previewUpdated", lambda params: self._on_preview_updated(params["preview"])
|
||||
)
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<JSHandle preview={self._preview}>"
|
||||
|
||||
def __str__(self) -> str:
|
||||
return self._preview
|
||||
|
||||
def _on_preview_updated(self, preview: str) -> None:
|
||||
self._preview = preview
|
||||
|
||||
async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
|
||||
return parse_result(
|
||||
await self._channel.send(
|
||||
"evaluateExpression",
|
||||
None,
|
||||
dict(
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def evaluate_handle(
|
||||
self, expression: str, arg: Serializable = None
|
||||
) -> "JSHandle":
|
||||
return from_channel(
|
||||
await self._channel.send(
|
||||
"evaluateExpressionHandle",
|
||||
None,
|
||||
dict(
|
||||
expression=expression,
|
||||
arg=serialize_argument(arg),
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
async def get_property(self, propertyName: str) -> "JSHandle":
|
||||
return from_channel(
|
||||
await self._channel.send("getProperty", None, dict(name=propertyName))
|
||||
)
|
||||
|
||||
async def get_properties(self) -> Dict[str, "JSHandle"]:
|
||||
return {
|
||||
prop["name"]: from_channel(prop["value"])
|
||||
for prop in await self._channel.send(
|
||||
"getPropertyList",
|
||||
None,
|
||||
)
|
||||
}
|
||||
|
||||
def as_element(self) -> Optional["ElementHandle"]:
|
||||
return None
|
||||
|
||||
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 json_value(self) -> Any:
|
||||
return parse_result(
|
||||
await self._channel.send(
|
||||
"jsonValue",
|
||||
None,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def serialize_value(
|
||||
value: Any, handles: List[Channel], visitor_info: Optional[VisitorInfo] = None
|
||||
) -> Any:
|
||||
if visitor_info is None:
|
||||
visitor_info = VisitorInfo()
|
||||
if isinstance(value, JSHandle):
|
||||
h = len(handles)
|
||||
handles.append(value._channel)
|
||||
return dict(h=h)
|
||||
if value is None:
|
||||
return dict(v="null")
|
||||
if isinstance(value, float):
|
||||
if value == float("inf"):
|
||||
return dict(v="Infinity")
|
||||
if value == float("-inf"):
|
||||
return dict(v="-Infinity")
|
||||
if value == float("-0"):
|
||||
return dict(v="-0")
|
||||
if math.isnan(value):
|
||||
return dict(v="NaN")
|
||||
if isinstance(value, datetime.datetime):
|
||||
# Node.js Date objects are always in UTC.
|
||||
return {
|
||||
"d": datetime.datetime.strftime(
|
||||
value.astimezone(datetime.timezone.utc), "%Y-%m-%dT%H:%M:%S.%fZ"
|
||||
)
|
||||
}
|
||||
if isinstance(value, Exception):
|
||||
return {
|
||||
"e": {
|
||||
"m": str(value),
|
||||
"n": (
|
||||
(value.name or "")
|
||||
if isinstance(value, Error)
|
||||
else value.__class__.__name__
|
||||
),
|
||||
"s": (
|
||||
(value.stack or "")
|
||||
if isinstance(value, Error)
|
||||
else "".join(
|
||||
traceback.format_exception(type(value), value=value, tb=None)
|
||||
)
|
||||
),
|
||||
}
|
||||
}
|
||||
if isinstance(value, bool):
|
||||
return {"b": value}
|
||||
if isinstance(value, (int, float)):
|
||||
return {"n": value}
|
||||
if isinstance(value, str):
|
||||
return {"s": value}
|
||||
if isinstance(value, ParseResult):
|
||||
return {"u": urlunparse(value)}
|
||||
|
||||
if value in visitor_info.visited:
|
||||
return dict(ref=visitor_info.visited[value])
|
||||
|
||||
if isinstance(value, collections.abc.Sequence) and not isinstance(value, str):
|
||||
id = visitor_info.visit(value)
|
||||
a = []
|
||||
for e in value:
|
||||
a.append(serialize_value(e, handles, visitor_info))
|
||||
return dict(a=a, id=id)
|
||||
|
||||
if isinstance(value, dict):
|
||||
id = visitor_info.visit(value)
|
||||
o = []
|
||||
for name in value:
|
||||
o.append(
|
||||
{"k": name, "v": serialize_value(value[name], handles, visitor_info)}
|
||||
)
|
||||
return dict(o=o, id=id)
|
||||
return dict(v="undefined")
|
||||
|
||||
|
||||
def serialize_argument(arg: Serializable = None) -> Any:
|
||||
handles: List[Channel] = []
|
||||
value = serialize_value(arg, handles)
|
||||
return dict(value=value, handles=handles)
|
||||
|
||||
|
||||
def parse_value(value: Any, refs: Optional[Dict[int, Any]] = None) -> Any:
|
||||
if refs is None:
|
||||
refs = {}
|
||||
if value is None:
|
||||
return None
|
||||
if isinstance(value, dict):
|
||||
if "ref" in value:
|
||||
return refs[value["ref"]]
|
||||
|
||||
if "v" in value:
|
||||
v = value["v"]
|
||||
if v == "Infinity":
|
||||
return float("inf")
|
||||
if v == "-Infinity":
|
||||
return float("-inf")
|
||||
if v == "-0":
|
||||
return float("-0")
|
||||
if v == "NaN":
|
||||
return float("nan")
|
||||
if v == "undefined":
|
||||
return None
|
||||
if v == "null":
|
||||
return None
|
||||
return v
|
||||
|
||||
if "u" in value:
|
||||
return urlparse(value["u"])
|
||||
|
||||
if "bi" in value:
|
||||
return int(value["bi"])
|
||||
|
||||
if "e" in value:
|
||||
error = Error(value["e"]["m"])
|
||||
error._name = value["e"]["n"]
|
||||
error._stack = value["e"]["s"]
|
||||
return error
|
||||
|
||||
if "a" in value:
|
||||
a: List = []
|
||||
refs[value["id"]] = a
|
||||
for e in value["a"]:
|
||||
a.append(parse_value(e, refs))
|
||||
return a
|
||||
|
||||
if "d" in value:
|
||||
# Node.js Date objects are always in UTC.
|
||||
return datetime.datetime.strptime(
|
||||
value["d"], "%Y-%m-%dT%H:%M:%S.%fZ"
|
||||
).replace(tzinfo=datetime.timezone.utc)
|
||||
|
||||
if "o" in value:
|
||||
o: Dict = {}
|
||||
refs[value["id"]] = o
|
||||
for e in value["o"]:
|
||||
o[e["k"]] = parse_value(e["v"], refs)
|
||||
return o
|
||||
|
||||
if "n" in value:
|
||||
return value["n"]
|
||||
|
||||
if "s" in value:
|
||||
return value["s"]
|
||||
|
||||
if "b" in value:
|
||||
return value["b"]
|
||||
|
||||
if "ta" in value:
|
||||
encoded_bytes = value["ta"]["b"]
|
||||
decoded_bytes = base64.b64decode(encoded_bytes)
|
||||
array_type = value["ta"]["k"]
|
||||
if array_type == "i8":
|
||||
word_size = 1
|
||||
fmt = "b"
|
||||
elif array_type == "ui8" or array_type == "ui8c":
|
||||
word_size = 1
|
||||
fmt = "B"
|
||||
elif array_type == "i16":
|
||||
word_size = 2
|
||||
fmt = "h"
|
||||
elif array_type == "ui16":
|
||||
word_size = 2
|
||||
fmt = "H"
|
||||
elif array_type == "i32":
|
||||
word_size = 4
|
||||
fmt = "i"
|
||||
elif array_type == "ui32":
|
||||
word_size = 4
|
||||
fmt = "I"
|
||||
elif array_type == "f32":
|
||||
word_size = 4
|
||||
fmt = "f"
|
||||
elif array_type == "f64":
|
||||
word_size = 8
|
||||
fmt = "d"
|
||||
elif array_type == "bi64":
|
||||
word_size = 8
|
||||
fmt = "q"
|
||||
elif array_type == "bui64":
|
||||
word_size = 8
|
||||
fmt = "Q"
|
||||
else:
|
||||
raise ValueError(f"Unsupported array type: {array_type}")
|
||||
|
||||
byte_len = len(decoded_bytes)
|
||||
if byte_len % word_size != 0:
|
||||
raise ValueError(
|
||||
f"Decoded bytes length {byte_len} is not a multiple of word size {word_size}"
|
||||
)
|
||||
|
||||
if byte_len == 0:
|
||||
return []
|
||||
array_len = byte_len // word_size
|
||||
# "<" denotes little-endian
|
||||
format_string = f"<{array_len}{fmt}"
|
||||
return list(struct.unpack(format_string, decoded_bytes))
|
||||
return value
|
||||
|
||||
|
||||
def parse_result(result: Any) -> Any:
|
||||
return parse_value(result)
|
||||
|
||||
|
||||
def add_source_url_to_script(source: str, path: Union[str, Path]) -> str:
|
||||
return source + "\n//# sourceURL=" + str(path).replace("\n", "")
|
||||
+77
@@ -0,0 +1,77 @@
|
||||
# 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
|
||||
from typing import Dict, Optional, cast
|
||||
|
||||
from pyee.asyncio import AsyncIOEventEmitter
|
||||
|
||||
from playwright._impl._connection import Channel
|
||||
from playwright._impl._errors import TargetClosedError
|
||||
from playwright._impl._helper import Error, ParsedMessagePayload
|
||||
from playwright._impl._transport import Transport
|
||||
|
||||
|
||||
class JsonPipeTransport(AsyncIOEventEmitter, Transport):
|
||||
def __init__(
|
||||
self,
|
||||
loop: asyncio.AbstractEventLoop,
|
||||
pipe_channel: Channel,
|
||||
) -> None:
|
||||
super().__init__(loop)
|
||||
Transport.__init__(self, loop)
|
||||
self._stop_requested = False
|
||||
self._pipe_channel = pipe_channel
|
||||
|
||||
def request_stop(self) -> None:
|
||||
self._stop_requested = True
|
||||
self._pipe_channel.send_no_reply("close", None, {})
|
||||
|
||||
def dispose(self) -> None:
|
||||
self.on_error_future.cancel()
|
||||
self._stopped_future.cancel()
|
||||
|
||||
async def wait_until_stopped(self) -> None:
|
||||
await self._stopped_future
|
||||
|
||||
async def connect(self) -> None:
|
||||
self._stopped_future: asyncio.Future = asyncio.Future()
|
||||
|
||||
def handle_message(message: Dict) -> None:
|
||||
if self._stop_requested:
|
||||
return
|
||||
self.on_message(cast(ParsedMessagePayload, message))
|
||||
|
||||
def handle_closed(reason: Optional[str]) -> None:
|
||||
self.emit("close", reason)
|
||||
if reason:
|
||||
self.on_error_future.set_exception(TargetClosedError(reason))
|
||||
self._stopped_future.set_result(None)
|
||||
|
||||
self._pipe_channel.on(
|
||||
"message",
|
||||
lambda params: handle_message(params["message"]),
|
||||
)
|
||||
self._pipe_channel.on(
|
||||
"closed",
|
||||
lambda params: handle_closed(params.get("reason")),
|
||||
)
|
||||
|
||||
async def run(self) -> None:
|
||||
await self._stopped_future
|
||||
|
||||
def send(self, message: Dict) -> None:
|
||||
if self._stop_requested:
|
||||
raise Error("Playwright connection closed")
|
||||
self._pipe_channel.send_no_reply("send", None, {"message": message})
|
||||
+93
@@ -0,0 +1,93 @@
|
||||
# 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 base64
|
||||
from typing import Dict, List, Optional, cast
|
||||
|
||||
from playwright._impl._api_structures import HeadersArray
|
||||
from playwright._impl._connection import ChannelOwner, StackFrame
|
||||
from playwright._impl._helper import HarLookupResult, locals_to_params
|
||||
|
||||
|
||||
class LocalUtils(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
self.devices = {
|
||||
device["name"]: parse_device_descriptor(device["descriptor"])
|
||||
for device in initializer["deviceDescriptors"]
|
||||
}
|
||||
|
||||
async def zip(self, params: Dict) -> None:
|
||||
await self._channel.send("zip", None, params)
|
||||
|
||||
async def har_open(self, file: str) -> None:
|
||||
params = locals_to_params(locals())
|
||||
await self._channel.send("harOpen", None, params)
|
||||
|
||||
async def har_lookup(
|
||||
self,
|
||||
harId: str,
|
||||
url: str,
|
||||
method: str,
|
||||
headers: HeadersArray,
|
||||
isNavigationRequest: bool,
|
||||
postData: Optional[bytes] = None,
|
||||
) -> HarLookupResult:
|
||||
params = locals_to_params(locals())
|
||||
if "postData" in params:
|
||||
params["postData"] = base64.b64encode(params["postData"]).decode()
|
||||
return cast(
|
||||
HarLookupResult,
|
||||
await self._channel.send_return_as_dict("harLookup", None, params),
|
||||
)
|
||||
|
||||
async def har_close(self, harId: str) -> None:
|
||||
params = locals_to_params(locals())
|
||||
await self._channel.send("harClose", None, params)
|
||||
|
||||
async def har_unzip(self, zipFile: str, harFile: str) -> None:
|
||||
params = locals_to_params(locals())
|
||||
await self._channel.send("harUnzip", None, params)
|
||||
|
||||
async def tracing_started(self, tracesDir: Optional[str], traceName: str) -> str:
|
||||
params = locals_to_params(locals())
|
||||
return await self._channel.send("tracingStarted", None, params)
|
||||
|
||||
async def trace_discarded(self, stacks_id: str) -> None:
|
||||
return await self._channel.send("traceDiscarded", None, {"stacksId": stacks_id})
|
||||
|
||||
def add_stack_to_tracing_no_reply(self, id: int, frames: List[StackFrame]) -> None:
|
||||
self._channel.send_no_reply(
|
||||
"addStackToTracingNoReply",
|
||||
None,
|
||||
{
|
||||
"callData": {
|
||||
"stack": frames,
|
||||
"id": id,
|
||||
}
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def parse_device_descriptor(dict: Dict) -> Dict:
|
||||
return {
|
||||
"user_agent": dict["userAgent"],
|
||||
"viewport": dict["viewport"],
|
||||
"device_scale_factor": dict["deviceScaleFactor"],
|
||||
"is_mobile": dict["isMobile"],
|
||||
"has_touch": dict["hasTouch"],
|
||||
"default_browser_type": dict["defaultBrowserType"],
|
||||
}
|
||||
+952
@@ -0,0 +1,952 @@
|
||||
# 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 json
|
||||
import pathlib
|
||||
import re
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Awaitable,
|
||||
Callable,
|
||||
Dict,
|
||||
List,
|
||||
Literal,
|
||||
Optional,
|
||||
Pattern,
|
||||
Sequence,
|
||||
Tuple,
|
||||
TypeVar,
|
||||
Union,
|
||||
)
|
||||
|
||||
from playwright._impl._api_structures import (
|
||||
AriaRole,
|
||||
FilePayload,
|
||||
FloatRect,
|
||||
FrameExpectOptions,
|
||||
FrameExpectResult,
|
||||
Position,
|
||||
)
|
||||
from playwright._impl._element_handle import ElementHandle
|
||||
from playwright._impl._helper import (
|
||||
Error,
|
||||
KeyboardModifier,
|
||||
MouseButton,
|
||||
locals_to_params,
|
||||
monotonic_time,
|
||||
to_impl,
|
||||
)
|
||||
from playwright._impl._js_handle import Serializable
|
||||
from playwright._impl._str_utils import (
|
||||
escape_for_attribute_selector,
|
||||
escape_for_text_selector,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._frame import Frame
|
||||
from playwright._impl._js_handle import JSHandle
|
||||
from playwright._impl._page import Page
|
||||
|
||||
T = TypeVar("T")
|
||||
|
||||
|
||||
class Locator:
|
||||
def __init__(
|
||||
self,
|
||||
frame: "Frame",
|
||||
selector: str,
|
||||
has_text: Union[str, Pattern[str]] = None,
|
||||
has_not_text: Union[str, Pattern[str]] = None,
|
||||
has: "Locator" = None,
|
||||
has_not: "Locator" = None,
|
||||
visible: bool = None,
|
||||
) -> None:
|
||||
self._frame = frame
|
||||
self._selector = selector
|
||||
self._loop = frame._loop
|
||||
self._dispatcher_fiber = frame._connection._dispatcher_fiber
|
||||
|
||||
if has_text:
|
||||
self._selector += f" >> internal:has-text={escape_for_text_selector(has_text, exact=False)}"
|
||||
|
||||
if has:
|
||||
if has._frame != frame:
|
||||
raise Error('Inner "has" locator must belong to the same frame.')
|
||||
self._selector += " >> internal:has=" + json.dumps(
|
||||
has._selector, ensure_ascii=False
|
||||
)
|
||||
|
||||
if has_not_text:
|
||||
self._selector += f" >> internal:has-not-text={escape_for_text_selector(has_not_text, exact=False)}"
|
||||
|
||||
if has_not:
|
||||
locator = has_not
|
||||
if locator._frame != frame:
|
||||
raise Error('Inner "has_not" locator must belong to the same frame.')
|
||||
self._selector += " >> internal:has-not=" + json.dumps(locator._selector)
|
||||
|
||||
if visible is not None:
|
||||
self._selector += f" >> visible={bool_to_js_bool(visible)}"
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<Locator frame={self._frame!r} selector={self._selector!r}>"
|
||||
|
||||
async def _with_element(
|
||||
self,
|
||||
task: Callable[[ElementHandle, float], Awaitable[T]],
|
||||
timeout: float = None,
|
||||
) -> T:
|
||||
timeout = self._frame._timeout(timeout)
|
||||
deadline = (monotonic_time() + timeout) if timeout else 0
|
||||
handle = await self.element_handle(timeout=timeout)
|
||||
if not handle:
|
||||
raise Error(f"Could not resolve {self._selector} to DOM Element")
|
||||
try:
|
||||
return await task(
|
||||
handle,
|
||||
(deadline - monotonic_time()) if deadline else 0,
|
||||
)
|
||||
finally:
|
||||
await handle.dispose()
|
||||
|
||||
def _equals(self, locator: "Locator") -> bool:
|
||||
return self._frame == locator._frame and self._selector == locator._selector
|
||||
|
||||
@property
|
||||
def page(self) -> "Page":
|
||||
return self._frame.page
|
||||
|
||||
async def bounding_box(self, timeout: float = None) -> Optional[FloatRect]:
|
||||
return await self._with_element(
|
||||
lambda h, _: h.bounding_box(),
|
||||
timeout,
|
||||
)
|
||||
|
||||
async def check(
|
||||
self,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.check(self._selector, strict=True, **params)
|
||||
|
||||
async def click(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
clickCount: int = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
steps: int = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame._click(self._selector, strict=True, **params)
|
||||
|
||||
async def dblclick(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
delay: float = None,
|
||||
button: MouseButton = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
steps: int = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.dblclick(self._selector, strict=True, **params)
|
||||
|
||||
async def dispatch_event(
|
||||
self,
|
||||
type: str,
|
||||
eventInit: Dict = None,
|
||||
timeout: float = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.dispatch_event(self._selector, strict=True, **params)
|
||||
|
||||
async def evaluate(
|
||||
self, expression: str, arg: Serializable = None, timeout: float = None
|
||||
) -> Any:
|
||||
return await self._with_element(
|
||||
lambda h, _: h.evaluate(expression, arg),
|
||||
timeout,
|
||||
)
|
||||
|
||||
async def evaluate_all(self, expression: str, arg: Serializable = None) -> Any:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.eval_on_selector_all(self._selector, **params)
|
||||
|
||||
async def evaluate_handle(
|
||||
self, expression: str, arg: Serializable = None, timeout: float = None
|
||||
) -> "JSHandle":
|
||||
return await self._with_element(
|
||||
lambda h, _: h.evaluate_handle(expression, arg), timeout
|
||||
)
|
||||
|
||||
async def fill(
|
||||
self,
|
||||
value: str,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
force: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.fill(self._selector, strict=True, **params)
|
||||
|
||||
async def clear(
|
||||
self,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
force: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
await self._frame._fill(self._selector, value="", title="Clear", **params)
|
||||
|
||||
def locator(
|
||||
self,
|
||||
selectorOrLocator: Union[str, "Locator"],
|
||||
hasText: Union[str, Pattern[str]] = None,
|
||||
hasNotText: Union[str, Pattern[str]] = None,
|
||||
has: "Locator" = None,
|
||||
hasNot: "Locator" = None,
|
||||
) -> "Locator":
|
||||
if isinstance(selectorOrLocator, str):
|
||||
return Locator(
|
||||
self._frame,
|
||||
f"{self._selector} >> {selectorOrLocator}",
|
||||
has_text=hasText,
|
||||
has_not_text=hasNotText,
|
||||
has_not=hasNot,
|
||||
has=has,
|
||||
)
|
||||
selectorOrLocator = to_impl(selectorOrLocator)
|
||||
if selectorOrLocator._frame != self._frame:
|
||||
raise Error("Locators must belong to the same frame.")
|
||||
return Locator(
|
||||
self._frame,
|
||||
f"{self._selector} >> internal:chain={json.dumps(selectorOrLocator._selector)}",
|
||||
has_text=hasText,
|
||||
has_not_text=hasNotText,
|
||||
has_not=hasNot,
|
||||
has=has,
|
||||
)
|
||||
|
||||
def get_by_alt_text(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_alt_text_selector(text, exact=exact))
|
||||
|
||||
def get_by_label(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_label_selector(text, exact=exact))
|
||||
|
||||
def get_by_placeholder(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_placeholder_selector(text, exact=exact))
|
||||
|
||||
def get_by_role(
|
||||
self,
|
||||
role: AriaRole,
|
||||
checked: bool = None,
|
||||
disabled: bool = None,
|
||||
expanded: bool = None,
|
||||
includeHidden: bool = None,
|
||||
level: int = None,
|
||||
name: Union[str, Pattern[str]] = None,
|
||||
pressed: bool = None,
|
||||
selected: bool = None,
|
||||
exact: bool = None,
|
||||
) -> "Locator":
|
||||
return self.locator(
|
||||
get_by_role_selector(
|
||||
role,
|
||||
checked=checked,
|
||||
disabled=disabled,
|
||||
expanded=expanded,
|
||||
includeHidden=includeHidden,
|
||||
level=level,
|
||||
name=name,
|
||||
pressed=pressed,
|
||||
selected=selected,
|
||||
exact=exact,
|
||||
)
|
||||
)
|
||||
|
||||
def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
|
||||
return self.locator(get_by_test_id_selector(test_id_attribute_name(), testId))
|
||||
|
||||
def get_by_text(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_text_selector(text, exact=exact))
|
||||
|
||||
def get_by_title(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_title_selector(text, exact=exact))
|
||||
|
||||
def frame_locator(self, selector: str) -> "FrameLocator":
|
||||
return FrameLocator(self._frame, self._selector + " >> " + selector)
|
||||
|
||||
async def element_handle(
|
||||
self,
|
||||
timeout: float = None,
|
||||
) -> ElementHandle:
|
||||
params = locals_to_params(locals())
|
||||
handle = await self._frame.wait_for_selector(
|
||||
self._selector, strict=True, state="attached", **params
|
||||
)
|
||||
assert handle
|
||||
return handle
|
||||
|
||||
async def element_handles(self) -> List[ElementHandle]:
|
||||
return await self._frame.query_selector_all(self._selector)
|
||||
|
||||
@property
|
||||
def first(self) -> "Locator":
|
||||
return Locator(self._frame, f"{self._selector} >> nth=0")
|
||||
|
||||
@property
|
||||
def last(self) -> "Locator":
|
||||
return Locator(self._frame, f"{self._selector} >> nth=-1")
|
||||
|
||||
def nth(self, index: int) -> "Locator":
|
||||
return Locator(self._frame, f"{self._selector} >> nth={index}")
|
||||
|
||||
@property
|
||||
def content_frame(self) -> "FrameLocator":
|
||||
return FrameLocator(self._frame, self._selector)
|
||||
|
||||
def describe(self, description: str) -> "Locator":
|
||||
return Locator(
|
||||
self._frame,
|
||||
f"{self._selector} >> internal:describe={json.dumps(description)}",
|
||||
)
|
||||
|
||||
@property
|
||||
def description(self) -> Optional[str]:
|
||||
try:
|
||||
match = re.search(
|
||||
r' >> internal:describe=("(?:[^"\\]|\\.)*")$', self._selector
|
||||
)
|
||||
if match:
|
||||
description = json.loads(match.group(1))
|
||||
if isinstance(description, str):
|
||||
return description
|
||||
except (json.JSONDecodeError, ValueError):
|
||||
pass
|
||||
return None
|
||||
|
||||
def filter(
|
||||
self,
|
||||
hasText: Union[str, Pattern[str]] = None,
|
||||
hasNotText: Union[str, Pattern[str]] = None,
|
||||
has: "Locator" = None,
|
||||
hasNot: "Locator" = None,
|
||||
visible: bool = None,
|
||||
) -> "Locator":
|
||||
return Locator(
|
||||
self._frame,
|
||||
self._selector,
|
||||
has_text=hasText,
|
||||
has_not_text=hasNotText,
|
||||
has=has,
|
||||
has_not=hasNot,
|
||||
visible=visible,
|
||||
)
|
||||
|
||||
def or_(self, locator: "Locator") -> "Locator":
|
||||
if locator._frame != self._frame:
|
||||
raise Error("Locators must belong to the same frame.")
|
||||
return Locator(
|
||||
self._frame,
|
||||
self._selector + " >> internal:or=" + json.dumps(locator._selector),
|
||||
)
|
||||
|
||||
def and_(self, locator: "Locator") -> "Locator":
|
||||
if locator._frame != self._frame:
|
||||
raise Error("Locators must belong to the same frame.")
|
||||
return Locator(
|
||||
self._frame,
|
||||
self._selector + " >> internal:and=" + json.dumps(locator._selector),
|
||||
)
|
||||
|
||||
async def focus(self, timeout: float = None) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.focus(self._selector, strict=True, **params)
|
||||
|
||||
async def blur(self, timeout: float = None) -> None:
|
||||
await self._frame._channel.send(
|
||||
"blur",
|
||||
self._frame._timeout,
|
||||
{
|
||||
"selector": self._selector,
|
||||
"strict": True,
|
||||
**locals_to_params(locals()),
|
||||
},
|
||||
)
|
||||
|
||||
async def all(
|
||||
self,
|
||||
) -> List["Locator"]:
|
||||
result = []
|
||||
for index in range(await self.count()):
|
||||
result.append(self.nth(index))
|
||||
return result
|
||||
|
||||
async def count(
|
||||
self,
|
||||
) -> int:
|
||||
return await self._frame._query_count(self._selector)
|
||||
|
||||
async def drag_to(
|
||||
self,
|
||||
target: "Locator",
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
timeout: float = None,
|
||||
trial: bool = None,
|
||||
sourcePosition: Position = None,
|
||||
targetPosition: Position = None,
|
||||
steps: int = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
del params["target"]
|
||||
return await self._frame.drag_and_drop(
|
||||
self._selector, target._selector, strict=True, **params
|
||||
)
|
||||
|
||||
async def get_attribute(self, name: str, timeout: float = None) -> Optional[str]:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.get_attribute(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def hover(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
force: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.hover(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def inner_html(self, timeout: float = None) -> str:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.inner_html(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def inner_text(self, timeout: float = None) -> str:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.inner_text(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def input_value(self, timeout: float = None) -> str:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.input_value(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def is_checked(self, timeout: float = None) -> bool:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.is_checked(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def is_disabled(self, timeout: float = None) -> bool:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.is_disabled(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def is_editable(self, timeout: float = None) -> bool:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.is_editable(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def is_enabled(self, timeout: float = None) -> bool:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.is_enabled(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def is_hidden(self, timeout: float = None) -> bool:
|
||||
# timeout is deprecated and does nothing
|
||||
return await self._frame.is_hidden(
|
||||
self._selector,
|
||||
strict=True,
|
||||
)
|
||||
|
||||
async def is_visible(self, timeout: float = None) -> bool:
|
||||
# timeout is deprecated and does nothing
|
||||
return await self._frame.is_visible(
|
||||
self._selector,
|
||||
strict=True,
|
||||
)
|
||||
|
||||
async def press(
|
||||
self,
|
||||
key: str,
|
||||
delay: float = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.press(self._selector, strict=True, **params)
|
||||
|
||||
async def screenshot(
|
||||
self,
|
||||
timeout: float = None,
|
||||
type: Literal["jpeg", "png"] = None,
|
||||
path: Union[str, pathlib.Path] = None,
|
||||
quality: int = None,
|
||||
omitBackground: bool = None,
|
||||
animations: Literal["allow", "disabled"] = None,
|
||||
caret: Literal["hide", "initial"] = None,
|
||||
scale: Literal["css", "device"] = None,
|
||||
mask: Sequence["Locator"] = None,
|
||||
maskColor: str = None,
|
||||
style: str = None,
|
||||
) -> bytes:
|
||||
params = locals_to_params(locals())
|
||||
return await self._with_element(
|
||||
lambda h, timeout: h.screenshot(
|
||||
**{**params, "timeout": timeout},
|
||||
),
|
||||
)
|
||||
|
||||
async def aria_snapshot(self, timeout: float = None) -> str:
|
||||
return await self._frame._channel.send(
|
||||
"ariaSnapshot",
|
||||
self._frame._timeout,
|
||||
{
|
||||
"selector": self._selector,
|
||||
**locals_to_params(locals()),
|
||||
},
|
||||
)
|
||||
|
||||
async def scroll_into_view_if_needed(
|
||||
self,
|
||||
timeout: float = None,
|
||||
) -> None:
|
||||
return await self._with_element(
|
||||
lambda h, timeout: h.scroll_into_view_if_needed(timeout=timeout),
|
||||
timeout,
|
||||
)
|
||||
|
||||
async def select_option(
|
||||
self,
|
||||
value: Union[str, Sequence[str]] = None,
|
||||
index: Union[int, Sequence[int]] = None,
|
||||
label: Union[str, Sequence[str]] = None,
|
||||
element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
force: bool = None,
|
||||
) -> List[str]:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.select_option(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def select_text(self, force: bool = None, timeout: float = None) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._with_element(
|
||||
lambda h, timeout: h.select_text(**{**params, "timeout": timeout}),
|
||||
timeout,
|
||||
)
|
||||
|
||||
async def set_input_files(
|
||||
self,
|
||||
files: Union[
|
||||
str,
|
||||
pathlib.Path,
|
||||
FilePayload,
|
||||
Sequence[Union[str, pathlib.Path]],
|
||||
Sequence[FilePayload],
|
||||
],
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.set_input_files(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def tap(
|
||||
self,
|
||||
modifiers: Sequence[KeyboardModifier] = None,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.tap(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def text_content(self, timeout: float = None) -> Optional[str]:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.text_content(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def type(
|
||||
self,
|
||||
text: str,
|
||||
delay: float = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.type(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def press_sequentially(
|
||||
self,
|
||||
text: str,
|
||||
delay: float = None,
|
||||
timeout: float = None,
|
||||
noWaitAfter: bool = None,
|
||||
) -> None:
|
||||
await self.type(text, delay=delay, timeout=timeout)
|
||||
|
||||
async def uncheck(
|
||||
self,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
params = locals_to_params(locals())
|
||||
return await self._frame.uncheck(
|
||||
self._selector,
|
||||
strict=True,
|
||||
**params,
|
||||
)
|
||||
|
||||
async def all_inner_texts(
|
||||
self,
|
||||
) -> List[str]:
|
||||
return await self._frame.eval_on_selector_all(
|
||||
self._selector, "ee => ee.map(e => e.innerText)"
|
||||
)
|
||||
|
||||
async def all_text_contents(
|
||||
self,
|
||||
) -> List[str]:
|
||||
return await self._frame.eval_on_selector_all(
|
||||
self._selector, "ee => ee.map(e => e.textContent || '')"
|
||||
)
|
||||
|
||||
async def wait_for(
|
||||
self,
|
||||
timeout: float = None,
|
||||
state: Literal["attached", "detached", "hidden", "visible"] = None,
|
||||
) -> None:
|
||||
await self._frame.wait_for_selector(
|
||||
self._selector, strict=True, timeout=timeout, state=state
|
||||
)
|
||||
|
||||
async def set_checked(
|
||||
self,
|
||||
checked: bool,
|
||||
position: Position = None,
|
||||
timeout: float = None,
|
||||
force: bool = None,
|
||||
noWaitAfter: bool = None,
|
||||
trial: bool = None,
|
||||
) -> None:
|
||||
if checked:
|
||||
await self.check(
|
||||
position=position,
|
||||
timeout=timeout,
|
||||
force=force,
|
||||
trial=trial,
|
||||
)
|
||||
else:
|
||||
await self.uncheck(
|
||||
position=position,
|
||||
timeout=timeout,
|
||||
force=force,
|
||||
trial=trial,
|
||||
)
|
||||
|
||||
async def _expect(
|
||||
self,
|
||||
expression: str,
|
||||
options: FrameExpectOptions,
|
||||
title: str = None,
|
||||
) -> FrameExpectResult:
|
||||
return await self._frame._expect(self._selector, expression, options, title)
|
||||
|
||||
async def highlight(self) -> None:
|
||||
await self._frame._highlight(self._selector)
|
||||
|
||||
|
||||
class FrameLocator:
|
||||
def __init__(self, frame: "Frame", frame_selector: str) -> None:
|
||||
self._frame = frame
|
||||
self._loop = frame._loop
|
||||
self._dispatcher_fiber = frame._connection._dispatcher_fiber
|
||||
self._frame_selector = frame_selector
|
||||
|
||||
def locator(
|
||||
self,
|
||||
selectorOrLocator: Union["Locator", str],
|
||||
hasText: Union[str, Pattern[str]] = None,
|
||||
hasNotText: Union[str, Pattern[str]] = None,
|
||||
has: Locator = None,
|
||||
hasNot: Locator = None,
|
||||
) -> Locator:
|
||||
if isinstance(selectorOrLocator, str):
|
||||
return Locator(
|
||||
self._frame,
|
||||
f"{self._frame_selector} >> internal:control=enter-frame >> {selectorOrLocator}",
|
||||
has_text=hasText,
|
||||
has_not_text=hasNotText,
|
||||
has=has,
|
||||
has_not=hasNot,
|
||||
)
|
||||
selectorOrLocator = to_impl(selectorOrLocator)
|
||||
if selectorOrLocator._frame != self._frame:
|
||||
raise ValueError("Locators must belong to the same frame.")
|
||||
return Locator(
|
||||
self._frame,
|
||||
f"{self._frame_selector} >> internal:control=enter-frame >> {selectorOrLocator._selector}",
|
||||
has_text=hasText,
|
||||
has_not_text=hasNotText,
|
||||
has=has,
|
||||
has_not=hasNot,
|
||||
)
|
||||
|
||||
def get_by_alt_text(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_alt_text_selector(text, exact=exact))
|
||||
|
||||
def get_by_label(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_label_selector(text, exact=exact))
|
||||
|
||||
def get_by_placeholder(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_placeholder_selector(text, exact=exact))
|
||||
|
||||
def get_by_role(
|
||||
self,
|
||||
role: AriaRole,
|
||||
checked: bool = None,
|
||||
disabled: bool = None,
|
||||
expanded: bool = None,
|
||||
includeHidden: bool = None,
|
||||
level: int = None,
|
||||
name: Union[str, Pattern[str]] = None,
|
||||
pressed: bool = None,
|
||||
selected: bool = None,
|
||||
exact: bool = None,
|
||||
) -> "Locator":
|
||||
return self.locator(
|
||||
get_by_role_selector(
|
||||
role,
|
||||
checked=checked,
|
||||
disabled=disabled,
|
||||
expanded=expanded,
|
||||
includeHidden=includeHidden,
|
||||
level=level,
|
||||
name=name,
|
||||
pressed=pressed,
|
||||
selected=selected,
|
||||
exact=exact,
|
||||
)
|
||||
)
|
||||
|
||||
def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
|
||||
return self.locator(get_by_test_id_selector(test_id_attribute_name(), testId))
|
||||
|
||||
def get_by_text(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_text_selector(text, exact=exact))
|
||||
|
||||
def get_by_title(
|
||||
self, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> "Locator":
|
||||
return self.locator(get_by_title_selector(text, exact=exact))
|
||||
|
||||
def frame_locator(self, selector: str) -> "FrameLocator":
|
||||
return FrameLocator(
|
||||
self._frame,
|
||||
f"{self._frame_selector} >> internal:control=enter-frame >> {selector}",
|
||||
)
|
||||
|
||||
@property
|
||||
def first(self) -> "FrameLocator":
|
||||
return FrameLocator(self._frame, f"{self._frame_selector} >> nth=0")
|
||||
|
||||
@property
|
||||
def last(self) -> "FrameLocator":
|
||||
return FrameLocator(self._frame, f"{self._frame_selector} >> nth=-1")
|
||||
|
||||
@property
|
||||
def owner(self) -> "Locator":
|
||||
return Locator(self._frame, self._frame_selector)
|
||||
|
||||
def nth(self, index: int) -> "FrameLocator":
|
||||
return FrameLocator(self._frame, f"{self._frame_selector} >> nth={index}")
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<FrameLocator frame={self._frame!r} selector={self._frame_selector!r}>"
|
||||
|
||||
|
||||
_test_id_attribute_name: str = "data-testid"
|
||||
|
||||
|
||||
def test_id_attribute_name() -> str:
|
||||
return _test_id_attribute_name
|
||||
|
||||
|
||||
def set_test_id_attribute_name(attribute_name: str) -> None:
|
||||
global _test_id_attribute_name
|
||||
_test_id_attribute_name = attribute_name
|
||||
|
||||
|
||||
def get_by_test_id_selector(
|
||||
test_id_attribute_name: str, test_id: Union[str, Pattern[str]]
|
||||
) -> str:
|
||||
return f"internal:testid=[{test_id_attribute_name}={escape_for_attribute_selector(test_id, True)}]"
|
||||
|
||||
|
||||
def get_by_attribute_text_selector(
|
||||
attr_name: str, text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> str:
|
||||
return f"internal:attr=[{attr_name}={escape_for_attribute_selector(text, exact=exact)}]"
|
||||
|
||||
|
||||
def get_by_label_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
|
||||
return "internal:label=" + escape_for_text_selector(text, exact=exact)
|
||||
|
||||
|
||||
def get_by_alt_text_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
|
||||
return get_by_attribute_text_selector("alt", text, exact=exact)
|
||||
|
||||
|
||||
def get_by_title_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
|
||||
return get_by_attribute_text_selector("title", text, exact=exact)
|
||||
|
||||
|
||||
def get_by_placeholder_selector(
|
||||
text: Union[str, Pattern[str]], exact: bool = None
|
||||
) -> str:
|
||||
return get_by_attribute_text_selector("placeholder", text, exact=exact)
|
||||
|
||||
|
||||
def get_by_text_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
|
||||
return "internal:text=" + escape_for_text_selector(text, exact=exact)
|
||||
|
||||
|
||||
def bool_to_js_bool(value: bool) -> str:
|
||||
return "true" if value else "false"
|
||||
|
||||
|
||||
def get_by_role_selector(
|
||||
role: AriaRole,
|
||||
checked: bool = None,
|
||||
disabled: bool = None,
|
||||
expanded: bool = None,
|
||||
includeHidden: bool = None,
|
||||
level: int = None,
|
||||
name: Union[str, Pattern[str]] = None,
|
||||
pressed: bool = None,
|
||||
selected: bool = None,
|
||||
exact: bool = None,
|
||||
) -> str:
|
||||
props: List[Tuple[str, str]] = []
|
||||
if checked is not None:
|
||||
props.append(("checked", bool_to_js_bool(checked)))
|
||||
if disabled is not None:
|
||||
props.append(("disabled", bool_to_js_bool(disabled)))
|
||||
if selected is not None:
|
||||
props.append(("selected", bool_to_js_bool(selected)))
|
||||
if expanded is not None:
|
||||
props.append(("expanded", bool_to_js_bool(expanded)))
|
||||
if includeHidden is not None:
|
||||
props.append(("include-hidden", bool_to_js_bool(includeHidden)))
|
||||
if level is not None:
|
||||
props.append(("level", str(level)))
|
||||
if name is not None:
|
||||
props.append(
|
||||
(
|
||||
"name",
|
||||
escape_for_attribute_selector(name, exact=exact),
|
||||
)
|
||||
)
|
||||
if pressed is not None:
|
||||
props.append(("pressed", bool_to_js_bool(pressed)))
|
||||
props_str = "".join([f"[{t[0]}={t[1]}]" for t in props])
|
||||
return f"internal:role={role}{props_str}"
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
# 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.
|
||||
from typing import Dict, Generic, Tuple, TypeVar
|
||||
|
||||
K = TypeVar("K")
|
||||
V = TypeVar("V")
|
||||
|
||||
|
||||
class Map(Generic[K, V]):
|
||||
def __init__(self) -> None:
|
||||
self._entries: Dict[int, Tuple[K, V]] = {}
|
||||
|
||||
def __contains__(self, item: K) -> bool:
|
||||
return id(item) in self._entries
|
||||
|
||||
def __setitem__(self, idx: K, value: V) -> None:
|
||||
self._entries[id(idx)] = (idx, value)
|
||||
|
||||
def __getitem__(self, obj: K) -> V:
|
||||
return self._entries[id(obj)][1]
|
||||
+1036
File diff suppressed because it is too large
Load Diff
+102
@@ -0,0 +1,102 @@
|
||||
# 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.
|
||||
|
||||
from typing import Dict, cast
|
||||
|
||||
from playwright._impl._artifact import Artifact
|
||||
from playwright._impl._browser import Browser
|
||||
from playwright._impl._browser_context import BrowserContext
|
||||
from playwright._impl._browser_type import BrowserType
|
||||
from playwright._impl._cdp_session import CDPSession
|
||||
from playwright._impl._connection import ChannelOwner
|
||||
from playwright._impl._dialog import Dialog
|
||||
from playwright._impl._element_handle import ElementHandle
|
||||
from playwright._impl._fetch import APIRequestContext
|
||||
from playwright._impl._frame import Frame
|
||||
from playwright._impl._js_handle import JSHandle
|
||||
from playwright._impl._local_utils import LocalUtils
|
||||
from playwright._impl._network import (
|
||||
Request,
|
||||
Response,
|
||||
Route,
|
||||
WebSocket,
|
||||
WebSocketRoute,
|
||||
)
|
||||
from playwright._impl._page import BindingCall, Page, Worker
|
||||
from playwright._impl._playwright import Playwright
|
||||
from playwright._impl._stream import Stream
|
||||
from playwright._impl._tracing import Tracing
|
||||
from playwright._impl._writable_stream import WritableStream
|
||||
|
||||
|
||||
class DummyObject(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
|
||||
|
||||
def create_remote_object(
|
||||
parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> ChannelOwner:
|
||||
if type == "Artifact":
|
||||
return Artifact(parent, type, guid, initializer)
|
||||
if type == "APIRequestContext":
|
||||
return APIRequestContext(parent, type, guid, initializer)
|
||||
if type == "BindingCall":
|
||||
return BindingCall(parent, type, guid, initializer)
|
||||
if type == "Browser":
|
||||
return Browser(cast(BrowserType, parent), type, guid, initializer)
|
||||
if type == "BrowserType":
|
||||
return BrowserType(parent, type, guid, initializer)
|
||||
if type == "BrowserContext":
|
||||
return BrowserContext(parent, type, guid, initializer)
|
||||
if type == "CDPSession":
|
||||
return CDPSession(parent, type, guid, initializer)
|
||||
if type == "Dialog":
|
||||
return Dialog(parent, type, guid, initializer)
|
||||
if type == "ElementHandle":
|
||||
return ElementHandle(parent, type, guid, initializer)
|
||||
if type == "Frame":
|
||||
return Frame(parent, type, guid, initializer)
|
||||
if type == "JSHandle":
|
||||
return JSHandle(parent, type, guid, initializer)
|
||||
if type == "LocalUtils":
|
||||
local_utils = LocalUtils(parent, type, guid, initializer)
|
||||
if not local_utils._connection._local_utils:
|
||||
local_utils._connection._local_utils = local_utils
|
||||
return local_utils
|
||||
if type == "Page":
|
||||
return Page(parent, type, guid, initializer)
|
||||
if type == "Playwright":
|
||||
return Playwright(parent, type, guid, initializer)
|
||||
if type == "Request":
|
||||
return Request(parent, type, guid, initializer)
|
||||
if type == "Response":
|
||||
return Response(parent, type, guid, initializer)
|
||||
if type == "Route":
|
||||
return Route(parent, type, guid, initializer)
|
||||
if type == "Stream":
|
||||
return Stream(parent, type, guid, initializer)
|
||||
if type == "Tracing":
|
||||
return Tracing(parent, type, guid, initializer)
|
||||
if type == "WebSocket":
|
||||
return WebSocket(parent, type, guid, initializer)
|
||||
if type == "WebSocketRoute":
|
||||
return WebSocketRoute(parent, type, guid, initializer)
|
||||
if type == "Worker":
|
||||
return Worker(parent, type, guid, initializer)
|
||||
if type == "WritableStream":
|
||||
return WritableStream(parent, type, guid, initializer)
|
||||
return DummyObject(parent, type, guid, initializer)
|
||||
+1570
File diff suppressed because it is too large
Load Diff
+27
@@ -0,0 +1,27 @@
|
||||
# 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 inspect
|
||||
from pathlib import Path
|
||||
from types import FrameType
|
||||
from typing import cast
|
||||
|
||||
|
||||
def get_file_dirname() -> Path:
|
||||
"""Returns the callee (`__file__`) directory name"""
|
||||
frame = cast(FrameType, inspect.currentframe()).f_back
|
||||
module = inspect.getmodule(frame)
|
||||
assert module
|
||||
assert module.__file__
|
||||
return Path(module.__file__).parent.absolute()
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
# 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.
|
||||
|
||||
from typing import Dict
|
||||
|
||||
from playwright._impl._browser_type import BrowserType
|
||||
from playwright._impl._connection import ChannelOwner, from_channel
|
||||
from playwright._impl._fetch import APIRequest
|
||||
from playwright._impl._selectors import Selectors
|
||||
|
||||
|
||||
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)
|
||||
|
||||
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:
|
||||
self.selectors = selectors
|
||||
|
||||
async def stop(self) -> None:
|
||||
pass
|
||||
+67
@@ -0,0 +1,67 @@
|
||||
# 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
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional, Set, Union
|
||||
|
||||
from playwright._impl._browser_context import BrowserContext
|
||||
from playwright._impl._errors import Error
|
||||
from playwright._impl._helper import async_readfile
|
||||
from playwright._impl._locator import set_test_id_attribute_name
|
||||
|
||||
|
||||
class Selectors:
|
||||
def __init__(self, loop: asyncio.AbstractEventLoop, dispatcher_fiber: Any) -> None:
|
||||
self._loop = loop
|
||||
self._contexts_for_selectors: Set[BrowserContext] = set()
|
||||
self._selector_engines: List[Dict] = []
|
||||
self._dispatcher_fiber = dispatcher_fiber
|
||||
self._test_id_attribute_name: Optional[str] = None
|
||||
|
||||
async def register(
|
||||
self,
|
||||
name: str,
|
||||
script: str = None,
|
||||
path: Union[str, Path] = None,
|
||||
contentScript: bool = None,
|
||||
) -> None:
|
||||
if any(engine for engine in self._selector_engines if engine["name"] == name):
|
||||
raise Error(
|
||||
f'Selectors.register: "{name}" selector engine has been already registered'
|
||||
)
|
||||
if not script and not path:
|
||||
raise Error("Either source or path should be specified")
|
||||
if path:
|
||||
script = (await async_readfile(path)).decode()
|
||||
engine: Dict[str, Any] = dict(name=name, source=script)
|
||||
if contentScript:
|
||||
engine["contentScript"] = contentScript
|
||||
for context in self._contexts_for_selectors:
|
||||
await context._channel.send(
|
||||
"registerSelectorEngine",
|
||||
None,
|
||||
{"selectorEngine": engine},
|
||||
)
|
||||
self._selector_engines.append(engine)
|
||||
|
||||
def set_test_id_attribute(self, attributeName: str) -> None:
|
||||
set_test_id_attribute_name(attributeName)
|
||||
self._test_id_attribute_name = attributeName
|
||||
for context in self._contexts_for_selectors:
|
||||
context._channel.send_no_reply(
|
||||
"setTestIdAttributeName",
|
||||
None,
|
||||
{"testIdAttributeName": attributeName},
|
||||
)
|
||||
+158
@@ -0,0 +1,158 @@
|
||||
# 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 base64
|
||||
import collections.abc
|
||||
import os
|
||||
import stat
|
||||
from pathlib import Path
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Dict,
|
||||
List,
|
||||
Optional,
|
||||
Sequence,
|
||||
Tuple,
|
||||
TypedDict,
|
||||
Union,
|
||||
cast,
|
||||
)
|
||||
|
||||
from playwright._impl._connection import Channel, from_channel
|
||||
from playwright._impl._helper import Error
|
||||
from playwright._impl._writable_stream import WritableStream
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from playwright._impl._browser_context import BrowserContext
|
||||
|
||||
from playwright._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",
|
||||
None,
|
||||
{
|
||||
"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:
|
||||
item_stat = os.stat(item) # Raises FileNotFoundError if doesn't exist
|
||||
if stat.S_ISDIR(item_stat.st_mode):
|
||||
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)
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
# 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 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(r"[.*+?^>${}()|[\]\\]", "\\$&", text)
|
||||
|
||||
|
||||
def escape_regex_for_selector(text: Pattern) -> str:
|
||||
# Even number of backslashes followed by the quote -> insert a backslash.
|
||||
return (
|
||||
"/"
|
||||
+ re.sub(r'(^|[^\\])(\\\\)*(["\'`])', r"\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)
|
||||
# TODO: this should actually be
|
||||
# cssEscape(value).replace(/\\ /g, ' ')
|
||||
# However, our attribute selectors do not conform to CSS parsing spec,
|
||||
# so we escape them differently.
|
||||
return (
|
||||
'"'
|
||||
+ value.replace("\\", "\\\\").replace('"', '\\"')
|
||||
+ '"'
|
||||
+ ("s" if exact else "i")
|
||||
)
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
# 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 base64
|
||||
from pathlib import Path
|
||||
from typing import Dict, Union
|
||||
|
||||
from playwright._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", None, {"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", None, {"size": 1024 * 1024})
|
||||
if not chunk:
|
||||
break
|
||||
binary += base64.b64decode(chunk)
|
||||
return binary
|
||||
+151
@@ -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 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 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__", inspect.stack(0))
|
||||
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: ...
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
# 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 Dict, Optional, Union, cast
|
||||
|
||||
from playwright._impl._api_structures import TracingGroupLocation
|
||||
from playwright._impl._artifact import Artifact
|
||||
from playwright._impl._connection import ChannelOwner, from_nullable_channel
|
||||
from playwright._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._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", None, params)
|
||||
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
|
||||
)
|
||||
|
||||
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) -> None:
|
||||
await self._channel.send("tracingGroup", None, locals_to_params(locals()))
|
||||
|
||||
async def group_end(self) -> None:
|
||||
await self._channel.send(
|
||||
"tracingGroupEnd",
|
||||
None,
|
||||
)
|
||||
+178
@@ -0,0 +1,178 @@
|
||||
# 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
|
||||
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()
|
||||
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
|
||||
)
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
# 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, 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") -> None:
|
||||
self._loop = page._loop
|
||||
self._dispatcher_fiber = page._dispatcher_fiber
|
||||
self._page = page
|
||||
self._artifact_future = page._loop.create_future()
|
||||
if page.is_closed():
|
||||
self._page_closed()
|
||||
else:
|
||||
page.on("close", lambda page: self._page_closed())
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<Video page={self._page}>"
|
||||
|
||||
def _page_closed(self) -> None:
|
||||
if not self._artifact_future.done():
|
||||
self._artifact_future.set_exception(Error("Page closed"))
|
||||
|
||||
def _artifact_ready(self, artifact: Artifact) -> None:
|
||||
if not self._artifact_future.done():
|
||||
self._artifact_future.set_result(artifact)
|
||||
|
||||
async def path(self) -> pathlib.Path:
|
||||
if self._page._connection.is_remote:
|
||||
raise Error(
|
||||
"Path is not available when using browserType.connect(). Use save_as() to save a local copy."
|
||||
)
|
||||
artifact = await self._artifact_future
|
||||
if not artifact:
|
||||
raise Error("Page did not produce any video frames")
|
||||
return 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"
|
||||
)
|
||||
artifact = await self._artifact_future
|
||||
if not artifact:
|
||||
raise Error("Page did not produce any video frames")
|
||||
await artifact.save_as(path)
|
||||
|
||||
async def delete(self) -> None:
|
||||
artifact = await self._artifact_future
|
||||
if not artifact:
|
||||
raise Error("Page did not produce any video frames")
|
||||
await artifact.delete()
|
||||
+166
@@ -0,0 +1,166 @@
|
||||
# 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 math
|
||||
import uuid
|
||||
from asyncio.tasks import Task
|
||||
from typing import Any, Callable, List, Tuple, Union
|
||||
|
||||
from pyee import EventEmitter
|
||||
|
||||
from playwright._impl._connection import ChannelOwner
|
||||
from playwright._impl._errors import Error, TimeoutError
|
||||
|
||||
|
||||
class Waiter:
|
||||
def __init__(self, channel_owner: ChannelOwner, event: str) -> None:
|
||||
self._result: asyncio.Future = asyncio.Future()
|
||||
self._wait_id = uuid.uuid4().hex
|
||||
self._loop = channel_owner._loop
|
||||
self._pending_tasks: List[Task] = []
|
||||
self._channel = channel_owner._channel
|
||||
self._registered_listeners: List[Tuple[EventEmitter, str, Callable]] = []
|
||||
self._logs: List[str] = []
|
||||
self._wait_for_event_info_before(self._wait_id, event)
|
||||
|
||||
def _wait_for_event_info_before(self, wait_id: str, event: str) -> None:
|
||||
self._channel.send_no_reply(
|
||||
"waitForEventInfo",
|
||||
None,
|
||||
{
|
||||
"info": {
|
||||
"waitId": wait_id,
|
||||
"phase": "before",
|
||||
"event": event,
|
||||
}
|
||||
},
|
||||
)
|
||||
|
||||
def _wait_for_event_info_after(self, wait_id: str, error: Exception = None) -> None:
|
||||
self._channel._connection.wrap_api_call_sync(
|
||||
lambda: self._channel.send_no_reply(
|
||||
"waitForEventInfo",
|
||||
None,
|
||||
{
|
||||
"info": {
|
||||
"waitId": wait_id,
|
||||
"phase": "after",
|
||||
**({"error": str(error)} if error else {}),
|
||||
},
|
||||
},
|
||||
),
|
||||
True,
|
||||
)
|
||||
|
||||
def reject_on_event(
|
||||
self,
|
||||
emitter: EventEmitter,
|
||||
event: str,
|
||||
error: Union[Error, Callable[..., Error]],
|
||||
predicate: Callable = None,
|
||||
) -> None:
|
||||
def listener(event_data: Any = None) -> None:
|
||||
if not predicate or predicate(event_data):
|
||||
self._reject(error() if callable(error) else error)
|
||||
|
||||
emitter.on(event, listener)
|
||||
self._registered_listeners.append((emitter, event, listener))
|
||||
|
||||
def reject_on_timeout(self, timeout: float, message: str) -> None:
|
||||
if timeout == 0:
|
||||
return
|
||||
|
||||
async def reject() -> None:
|
||||
await asyncio.sleep(timeout / 1000)
|
||||
self._reject(TimeoutError(message))
|
||||
|
||||
self._pending_tasks.append(self._loop.create_task(reject()))
|
||||
|
||||
def _cleanup(self) -> None:
|
||||
for task in self._pending_tasks:
|
||||
if not task.done():
|
||||
task.cancel()
|
||||
for listener in self._registered_listeners:
|
||||
listener[0].remove_listener(listener[1], listener[2])
|
||||
|
||||
def _fulfill(self, result: Any) -> None:
|
||||
self._cleanup()
|
||||
if not self._result.done():
|
||||
self._result.set_result(result)
|
||||
self._wait_for_event_info_after(self._wait_id)
|
||||
|
||||
def _reject(self, exception: Exception) -> None:
|
||||
self._cleanup()
|
||||
if exception:
|
||||
base_class = TimeoutError if isinstance(exception, TimeoutError) else Error
|
||||
exception = base_class(str(exception) + format_log_recording(self._logs))
|
||||
if not self._result.done():
|
||||
self._result.set_exception(exception)
|
||||
self._wait_for_event_info_after(self._wait_id, exception)
|
||||
|
||||
def wait_for_event(
|
||||
self,
|
||||
emitter: EventEmitter,
|
||||
event: str,
|
||||
predicate: Callable = None,
|
||||
) -> None:
|
||||
def listener(event_data: Any = None) -> None:
|
||||
if not predicate or predicate(event_data):
|
||||
self._fulfill(event_data)
|
||||
|
||||
emitter.on(event, listener)
|
||||
self._registered_listeners.append((emitter, event, listener))
|
||||
|
||||
def result(self) -> asyncio.Future:
|
||||
return self._result
|
||||
|
||||
def log(self, message: str) -> None:
|
||||
self._logs.append(message)
|
||||
try:
|
||||
self._channel._connection.wrap_api_call_sync(
|
||||
lambda: self._channel.send_no_reply(
|
||||
"waitForEventInfo",
|
||||
None,
|
||||
{
|
||||
"info": {
|
||||
"waitId": self._wait_id,
|
||||
"phase": "log",
|
||||
"message": message,
|
||||
},
|
||||
},
|
||||
),
|
||||
True,
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
def throw_on_timeout(timeout: float, exception: Exception) -> asyncio.Task:
|
||||
async def throw() -> None:
|
||||
await asyncio.sleep(timeout / 1000)
|
||||
raise exception
|
||||
|
||||
return asyncio.create_task(throw())
|
||||
|
||||
|
||||
def format_log_recording(log: List[str]) -> str:
|
||||
if not log:
|
||||
return ""
|
||||
header = " logs "
|
||||
header_length = 60
|
||||
left_length = math.floor((header_length - len(header)) / 2)
|
||||
right_length = header_length - len(header) - left_length
|
||||
new_line = "\n"
|
||||
return f"{new_line}{'=' * left_length}{header}{'=' * right_length}{new_line}{new_line.join(log)}{new_line}{'=' * header_length}"
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
# 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.
|
||||
|
||||
from asyncio import AbstractEventLoop
|
||||
from typing import Any, Optional
|
||||
|
||||
from playwright._impl._helper import Error
|
||||
from playwright._impl._page import Page
|
||||
|
||||
|
||||
class WebError:
|
||||
def __init__(
|
||||
self,
|
||||
loop: AbstractEventLoop,
|
||||
dispatcher_fiber: Any,
|
||||
page: Optional[Page],
|
||||
error: Error,
|
||||
) -> None:
|
||||
self._loop = loop
|
||||
self._dispatcher_fiber = dispatcher_fiber
|
||||
self._page = page
|
||||
self._error = error
|
||||
|
||||
@property
|
||||
def page(self) -> Optional[Page]:
|
||||
return self._page
|
||||
|
||||
@property
|
||||
def error(self) -> Error:
|
||||
return self._error
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
# 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 base64
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Dict, Union
|
||||
|
||||
from playwright._impl._connection import ChannelOwner
|
||||
|
||||
# COPY_BUFSIZE is taken from shutil.py in the standard library
|
||||
_WINDOWS = os.name == "nt"
|
||||
COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 64 * 1024
|
||||
|
||||
|
||||
class WritableStream(ChannelOwner):
|
||||
def __init__(
|
||||
self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
|
||||
) -> None:
|
||||
super().__init__(parent, type, guid, initializer)
|
||||
|
||||
async def copy(self, path: Union[str, Path]) -> None:
|
||||
with open(path, "rb") as f:
|
||||
while True:
|
||||
data = f.read(COPY_BUFSIZE)
|
||||
if not data:
|
||||
break
|
||||
await self._channel.send(
|
||||
"write", None, {"binary": base64.b64encode(data).decode()}
|
||||
)
|
||||
await self._channel.send("close", None)
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
# file generated by setuptools-scm
|
||||
# don't change, don't track in version control
|
||||
|
||||
__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
|
||||
|
||||
TYPE_CHECKING = False
|
||||
if TYPE_CHECKING:
|
||||
from typing import Tuple
|
||||
from typing import Union
|
||||
|
||||
VERSION_TUPLE = Tuple[Union[int, str], ...]
|
||||
else:
|
||||
VERSION_TUPLE = object
|
||||
|
||||
version: str
|
||||
__version__: str
|
||||
__version_tuple__: VERSION_TUPLE
|
||||
version_tuple: VERSION_TUPLE
|
||||
|
||||
__version__ = version = '1.58.0'
|
||||
__version_tuple__ = version_tuple = (1, 58, 0)
|
||||
+198
@@ -0,0 +1,198 @@
|
||||
# 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.
|
||||
|
||||
"""
|
||||
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.
|
||||
"""
|
||||
|
||||
from typing import Any, Optional, Union, overload
|
||||
|
||||
import playwright._impl._api_structures
|
||||
import playwright._impl._errors
|
||||
import playwright.async_api._generated
|
||||
from playwright._impl._assertions import (
|
||||
APIResponseAssertions as APIResponseAssertionsImpl,
|
||||
)
|
||||
from playwright._impl._assertions import LocatorAssertions as LocatorAssertionsImpl
|
||||
from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
|
||||
from playwright.async_api._context_manager import PlaywrightContextManager
|
||||
from playwright.async_api._generated import (
|
||||
APIRequest,
|
||||
APIRequestContext,
|
||||
APIResponse,
|
||||
APIResponseAssertions,
|
||||
Browser,
|
||||
BrowserContext,
|
||||
BrowserType,
|
||||
CDPSession,
|
||||
ConsoleMessage,
|
||||
Dialog,
|
||||
Download,
|
||||
ElementHandle,
|
||||
FileChooser,
|
||||
Frame,
|
||||
FrameLocator,
|
||||
JSHandle,
|
||||
Keyboard,
|
||||
Locator,
|
||||
LocatorAssertions,
|
||||
Mouse,
|
||||
Page,
|
||||
PageAssertions,
|
||||
Playwright,
|
||||
Request,
|
||||
Response,
|
||||
Route,
|
||||
Selectors,
|
||||
Touchscreen,
|
||||
Video,
|
||||
WebError,
|
||||
WebSocket,
|
||||
WebSocketRoute,
|
||||
Worker,
|
||||
)
|
||||
|
||||
ChromiumBrowserContext = BrowserContext
|
||||
|
||||
Cookie = playwright._impl._api_structures.Cookie
|
||||
FilePayload = playwright._impl._api_structures.FilePayload
|
||||
FloatRect = playwright._impl._api_structures.FloatRect
|
||||
Geolocation = playwright._impl._api_structures.Geolocation
|
||||
HttpCredentials = playwright._impl._api_structures.HttpCredentials
|
||||
PdfMargins = playwright._impl._api_structures.PdfMargins
|
||||
Position = playwright._impl._api_structures.Position
|
||||
ProxySettings = playwright._impl._api_structures.ProxySettings
|
||||
ResourceTiming = playwright._impl._api_structures.ResourceTiming
|
||||
SourceLocation = playwright._impl._api_structures.SourceLocation
|
||||
StorageState = playwright._impl._api_structures.StorageState
|
||||
StorageStateCookie = playwright._impl._api_structures.StorageStateCookie
|
||||
ViewportSize = playwright._impl._api_structures.ViewportSize
|
||||
|
||||
Error = playwright._impl._errors.Error
|
||||
TimeoutError = playwright._impl._errors.TimeoutError
|
||||
|
||||
|
||||
def async_playwright() -> PlaywrightContextManager:
|
||||
return PlaywrightContextManager()
|
||||
|
||||
|
||||
class Expect:
|
||||
_unset: Any = object()
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._timeout: Optional[float] = None
|
||||
|
||||
def set_options(self, timeout: Optional[float] = _unset) -> None:
|
||||
"""
|
||||
This method sets global `expect()` options.
|
||||
|
||||
Args:
|
||||
timeout (float): Timeout value in milliseconds. Default to 5000 milliseconds.
|
||||
|
||||
Returns:
|
||||
None
|
||||
"""
|
||||
if timeout is not self._unset:
|
||||
self._timeout = timeout
|
||||
|
||||
@overload
|
||||
def __call__(
|
||||
self, actual: Page, message: Optional[str] = None
|
||||
) -> PageAssertions: ...
|
||||
|
||||
@overload
|
||||
def __call__(
|
||||
self, actual: Locator, message: Optional[str] = None
|
||||
) -> LocatorAssertions: ...
|
||||
|
||||
@overload
|
||||
def __call__(
|
||||
self, actual: APIResponse, message: Optional[str] = None
|
||||
) -> APIResponseAssertions: ...
|
||||
|
||||
def __call__(
|
||||
self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
|
||||
) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
|
||||
if isinstance(actual, Page):
|
||||
return PageAssertions(
|
||||
PageAssertionsImpl(actual._impl_obj, self._timeout, message=message)
|
||||
)
|
||||
elif isinstance(actual, Locator):
|
||||
return LocatorAssertions(
|
||||
LocatorAssertionsImpl(actual._impl_obj, self._timeout, message=message)
|
||||
)
|
||||
elif isinstance(actual, APIResponse):
|
||||
return APIResponseAssertions(
|
||||
APIResponseAssertionsImpl(
|
||||
actual._impl_obj, self._timeout, message=message
|
||||
)
|
||||
)
|
||||
raise ValueError(f"Unsupported type: {type(actual)}")
|
||||
|
||||
|
||||
expect = Expect()
|
||||
|
||||
|
||||
__all__ = [
|
||||
"expect",
|
||||
"async_playwright",
|
||||
"APIRequest",
|
||||
"APIRequestContext",
|
||||
"APIResponse",
|
||||
"Browser",
|
||||
"BrowserContext",
|
||||
"BrowserType",
|
||||
"CDPSession",
|
||||
"ChromiumBrowserContext",
|
||||
"ConsoleMessage",
|
||||
"Cookie",
|
||||
"Dialog",
|
||||
"Download",
|
||||
"ElementHandle",
|
||||
"Error",
|
||||
"FileChooser",
|
||||
"FilePayload",
|
||||
"FloatRect",
|
||||
"Frame",
|
||||
"FrameLocator",
|
||||
"Geolocation",
|
||||
"HttpCredentials",
|
||||
"JSHandle",
|
||||
"Keyboard",
|
||||
"Locator",
|
||||
"Mouse",
|
||||
"Page",
|
||||
"PdfMargins",
|
||||
"Position",
|
||||
"Playwright",
|
||||
"ProxySettings",
|
||||
"Request",
|
||||
"ResourceTiming",
|
||||
"Response",
|
||||
"Route",
|
||||
"Selectors",
|
||||
"SourceLocation",
|
||||
"StorageState",
|
||||
"StorageStateCookie",
|
||||
"TimeoutError",
|
||||
"Touchscreen",
|
||||
"Video",
|
||||
"ViewportSize",
|
||||
"WebError",
|
||||
"WebSocket",
|
||||
"WebSocketRoute",
|
||||
"Worker",
|
||||
]
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
# 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
|
||||
from typing import Any
|
||||
|
||||
from playwright._impl._connection import Connection
|
||||
from playwright._impl._object_factory import create_remote_object
|
||||
from playwright._impl._transport import PipeTransport
|
||||
from playwright.async_api._generated import Playwright as AsyncPlaywright
|
||||
|
||||
|
||||
class PlaywrightContextManager:
|
||||
def __init__(self) -> None:
|
||||
self._connection: Connection
|
||||
self._exit_was_called = False
|
||||
|
||||
async def __aenter__(self) -> AsyncPlaywright:
|
||||
loop = asyncio.get_running_loop()
|
||||
self._connection = Connection(
|
||||
None,
|
||||
create_remote_object,
|
||||
PipeTransport(loop),
|
||||
loop,
|
||||
)
|
||||
loop.create_task(self._connection.run())
|
||||
playwright_future = self._connection.playwright_future
|
||||
|
||||
done, _ = await asyncio.wait(
|
||||
{self._connection._transport.on_error_future, playwright_future},
|
||||
return_when=asyncio.FIRST_COMPLETED,
|
||||
)
|
||||
if not playwright_future.done():
|
||||
playwright_future.cancel()
|
||||
playwright = AsyncPlaywright(next(iter(done)).result())
|
||||
playwright.stop = self.__aexit__ # type: ignore
|
||||
return playwright
|
||||
|
||||
async def start(self) -> AsyncPlaywright:
|
||||
return await self.__aenter__()
|
||||
|
||||
async def __aexit__(self, *args: Any) -> None:
|
||||
if self._exit_was_called:
|
||||
return
|
||||
self._exit_was_called = True
|
||||
await self._connection.stop_async()
|
||||
+21007
File diff suppressed because it is too large
Load Diff
+2666
File diff suppressed because it is too large
Load Diff
+1
@@ -0,0 +1 @@
|
||||
win_amd64.whl driver package
|
||||
BIN
Binary file not shown.
+202
@@ -0,0 +1,202 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Portions Copyright (c) Microsoft Corporation.
|
||||
Portions Copyright 2017 Google Inc.
|
||||
|
||||
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.
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
Playwright
|
||||
Copyright (c) Microsoft Corporation
|
||||
|
||||
This software contains code derived from the Puppeteer project (https://github.com/puppeteer/puppeteer),
|
||||
available under the Apache 2.0 license (https://github.com/puppeteer/puppeteer/blob/master/LICENSE).
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
# playwright-core
|
||||
|
||||
This package contains the no-browser flavor of [Playwright](http://github.com/microsoft/playwright).
|
||||
+4076
File diff suppressed because it is too large
Load Diff
+1
File diff suppressed because one or more lines are too long
+5
@@ -0,0 +1,5 @@
|
||||
$osInfo = Get-WmiObject -Class Win32_OperatingSystem
|
||||
# check if running on Windows Server
|
||||
if ($osInfo.ProductType -eq 3) {
|
||||
Install-WindowsFeature Server-Media-Foundation
|
||||
}
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
|
||||
# This script sets up a WSL distribution that will be used to run WebKit.
|
||||
|
||||
$Distribution = "playwright"
|
||||
$Username = "pwuser"
|
||||
|
||||
$distributions = (wsl --list --quiet) -split "\r?\n"
|
||||
if ($distributions -contains $Distribution) {
|
||||
Write-Host "WSL distribution '$Distribution' already exists. Skipping installation."
|
||||
} else {
|
||||
Write-Host "Installing new WSL distribution '$Distribution'..."
|
||||
$VhdSize = "10GB"
|
||||
wsl --install -d Ubuntu-24.04 --name $Distribution --no-launch --vhd-size $VhdSize
|
||||
wsl -d $Distribution -u root adduser --gecos GECOS --disabled-password $Username
|
||||
}
|
||||
|
||||
$pwshDirname = (Resolve-Path -Path $PSScriptRoot).Path;
|
||||
$playwrightCoreRoot = Resolve-Path (Join-Path $pwshDirname "..")
|
||||
|
||||
$initScript = @"
|
||||
if [ ! -f "/home/$Username/node/bin/node" ]; then
|
||||
mkdir -p /home/$Username/node
|
||||
curl -fsSL https://nodejs.org/dist/v22.17.0/node-v22.17.0-linux-x64.tar.xz -o /home/$Username/node/node-v22.17.0-linux-x64.tar.xz
|
||||
tar -xJf /home/$Username/node/node-v22.17.0-linux-x64.tar.xz -C /home/$Username/node --strip-components=1
|
||||
sudo -u $Username echo 'export PATH=/home/$Username/node/bin:\`$PATH' >> /home/$Username/.profile
|
||||
fi
|
||||
/home/$Username/node/bin/node cli.js install-deps webkit
|
||||
sudo -u $Username PLAYWRIGHT_SKIP_BROWSER_GC=1 /home/$Username/node/bin/node cli.js install webkit
|
||||
"@ -replace "\r\n", "`n"
|
||||
|
||||
wsl -d $Distribution --cd $playwrightCoreRoot -u root -- bash -c "$initScript"
|
||||
Write-Host "Done!"
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
#!/usr/bin/env bash
|
||||
set -e
|
||||
set -x
|
||||
|
||||
if [[ $(arch) == "aarch64" ]]; then
|
||||
echo "ERROR: not supported on Linux Arm64"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
|
||||
if [[ ! -f "/etc/os-release" ]]; then
|
||||
echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
ID=$(bash -c 'source /etc/os-release && echo $ID')
|
||||
if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
|
||||
echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# 1. make sure to remove old beta if any.
|
||||
if dpkg --get-selections | grep -q "^google-chrome-beta[[:space:]]*install$" >/dev/null; then
|
||||
apt-get remove -y google-chrome-beta
|
||||
fi
|
||||
|
||||
# 2. Update apt lists (needed to install curl and chrome dependencies)
|
||||
apt-get update
|
||||
|
||||
# 3. Install curl to download chrome
|
||||
if ! command -v curl >/dev/null; then
|
||||
apt-get install -y curl
|
||||
fi
|
||||
|
||||
# 4. download chrome beta from dl.google.com and install it.
|
||||
cd /tmp
|
||||
curl -O https://dl.google.com/linux/direct/google-chrome-beta_current_amd64.deb
|
||||
apt-get install -y ./google-chrome-beta_current_amd64.deb
|
||||
rm -rf ./google-chrome-beta_current_amd64.deb
|
||||
cd -
|
||||
google-chrome-beta --version
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
#!/usr/bin/env bash
|
||||
set -e
|
||||
set -x
|
||||
|
||||
rm -rf "/Applications/Google Chrome Beta.app"
|
||||
cd /tmp
|
||||
curl --retry 3 -o ./googlechromebeta.dmg https://dl.google.com/chrome/mac/universal/beta/googlechromebeta.dmg
|
||||
hdiutil attach -nobrowse -quiet -noautofsck -noautoopen -mountpoint /Volumes/googlechromebeta.dmg ./googlechromebeta.dmg
|
||||
cp -pR "/Volumes/googlechromebeta.dmg/Google Chrome Beta.app" /Applications
|
||||
hdiutil detach /Volumes/googlechromebeta.dmg
|
||||
rm -rf /tmp/googlechromebeta.dmg
|
||||
|
||||
/Applications/Google\ Chrome\ Beta.app/Contents/MacOS/Google\ Chrome\ Beta --version
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
|
||||
$url = 'https://dl.google.com/tag/s/dl/chrome/install/beta/googlechromebetastandaloneenterprise64.msi'
|
||||
|
||||
Write-Host "Downloading Google Chrome Beta"
|
||||
$wc = New-Object net.webclient
|
||||
$msiInstaller = "$env:temp\google-chrome-beta.msi"
|
||||
$wc.Downloadfile($url, $msiInstaller)
|
||||
|
||||
Write-Host "Installing Google Chrome Beta"
|
||||
$arguments = "/i `"$msiInstaller`" /quiet"
|
||||
Start-Process msiexec.exe -ArgumentList $arguments -Wait
|
||||
Remove-Item $msiInstaller
|
||||
|
||||
$suffix = "\\Google\\Chrome Beta\\Application\\chrome.exe"
|
||||
if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
|
||||
} elseif (Test-Path "${env:ProgramFiles}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles}$suffix").VersionInfo
|
||||
} else {
|
||||
Write-Host "ERROR: Failed to install Google Chrome Beta."
|
||||
Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
|
||||
exit 1
|
||||
}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
#!/usr/bin/env bash
|
||||
set -e
|
||||
set -x
|
||||
|
||||
if [[ $(arch) == "aarch64" ]]; then
|
||||
echo "ERROR: not supported on Linux Arm64"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
|
||||
if [[ ! -f "/etc/os-release" ]]; then
|
||||
echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
ID=$(bash -c 'source /etc/os-release && echo $ID')
|
||||
if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
|
||||
echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# 1. make sure to remove old stable if any.
|
||||
if dpkg --get-selections | grep -q "^google-chrome[[:space:]]*install$" >/dev/null; then
|
||||
apt-get remove -y google-chrome
|
||||
fi
|
||||
|
||||
# 2. Update apt lists (needed to install curl and chrome dependencies)
|
||||
apt-get update
|
||||
|
||||
# 3. Install curl to download chrome
|
||||
if ! command -v curl >/dev/null; then
|
||||
apt-get install -y curl
|
||||
fi
|
||||
|
||||
# 4. download chrome stable from dl.google.com and install it.
|
||||
cd /tmp
|
||||
curl -O https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
|
||||
apt-get install -y ./google-chrome-stable_current_amd64.deb
|
||||
rm -rf ./google-chrome-stable_current_amd64.deb
|
||||
cd -
|
||||
google-chrome --version
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
#!/usr/bin/env bash
|
||||
set -e
|
||||
set -x
|
||||
|
||||
rm -rf "/Applications/Google Chrome.app"
|
||||
cd /tmp
|
||||
curl --retry 3 -o ./googlechrome.dmg https://dl.google.com/chrome/mac/universal/stable/GGRO/googlechrome.dmg
|
||||
hdiutil attach -nobrowse -quiet -noautofsck -noautoopen -mountpoint /Volumes/googlechrome.dmg ./googlechrome.dmg
|
||||
cp -pR "/Volumes/googlechrome.dmg/Google Chrome.app" /Applications
|
||||
hdiutil detach /Volumes/googlechrome.dmg
|
||||
rm -rf /tmp/googlechrome.dmg
|
||||
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --version
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$url = 'https://dl.google.com/tag/s/dl/chrome/install/googlechromestandaloneenterprise64.msi'
|
||||
|
||||
$wc = New-Object net.webclient
|
||||
$msiInstaller = "$env:temp\google-chrome.msi"
|
||||
Write-Host "Downloading Google Chrome"
|
||||
$wc.Downloadfile($url, $msiInstaller)
|
||||
|
||||
Write-Host "Installing Google Chrome"
|
||||
$arguments = "/i `"$msiInstaller`" /quiet"
|
||||
Start-Process msiexec.exe -ArgumentList $arguments -Wait
|
||||
Remove-Item $msiInstaller
|
||||
|
||||
|
||||
$suffix = "\\Google\\Chrome\\Application\\chrome.exe"
|
||||
if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
|
||||
} elseif (Test-Path "${env:ProgramFiles}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles}$suffix").VersionInfo
|
||||
} else {
|
||||
Write-Host "ERROR: Failed to install Google Chrome."
|
||||
Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
|
||||
exit 1
|
||||
}
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
set -e
|
||||
set -x
|
||||
|
||||
if [[ $(arch) == "aarch64" ]]; then
|
||||
echo "ERROR: not supported on Linux Arm64"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
|
||||
if [[ ! -f "/etc/os-release" ]]; then
|
||||
echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
ID=$(bash -c 'source /etc/os-release && echo $ID')
|
||||
if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
|
||||
echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# 1. make sure to remove old beta if any.
|
||||
if dpkg --get-selections | grep -q "^microsoft-edge-beta[[:space:]]*install$" >/dev/null; then
|
||||
apt-get remove -y microsoft-edge-beta
|
||||
fi
|
||||
|
||||
# 2. Install curl to download Microsoft gpg key
|
||||
if ! command -v curl >/dev/null; then
|
||||
apt-get update
|
||||
apt-get install -y curl
|
||||
fi
|
||||
|
||||
# GnuPG is not preinstalled in slim images
|
||||
if ! command -v gpg >/dev/null; then
|
||||
apt-get update
|
||||
apt-get install -y gpg
|
||||
fi
|
||||
|
||||
# 3. Add the GPG key, the apt repo, update the apt cache, and install the package
|
||||
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/microsoft.gpg
|
||||
install -o root -g root -m 644 /tmp/microsoft.gpg /etc/apt/trusted.gpg.d/
|
||||
sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-dev.list'
|
||||
rm /tmp/microsoft.gpg
|
||||
apt-get update && apt-get install -y microsoft-edge-beta
|
||||
|
||||
microsoft-edge-beta --version
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
#!/usr/bin/env bash
|
||||
set -e
|
||||
set -x
|
||||
|
||||
cd /tmp
|
||||
curl --retry 3 -o ./msedge_beta.pkg "$1"
|
||||
# Note: there's no way to uninstall previously installed MSEdge.
|
||||
# However, running PKG again seems to update installation.
|
||||
sudo installer -pkg /tmp/msedge_beta.pkg -target /
|
||||
rm -rf /tmp/msedge_beta.pkg
|
||||
/Applications/Microsoft\ Edge\ Beta.app/Contents/MacOS/Microsoft\ Edge\ Beta --version
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$url = $args[0]
|
||||
|
||||
Write-Host "Downloading Microsoft Edge Beta"
|
||||
$wc = New-Object net.webclient
|
||||
$msiInstaller = "$env:temp\microsoft-edge-beta.msi"
|
||||
$wc.Downloadfile($url, $msiInstaller)
|
||||
|
||||
Write-Host "Installing Microsoft Edge Beta"
|
||||
$arguments = "/i `"$msiInstaller`" /quiet"
|
||||
Start-Process msiexec.exe -ArgumentList $arguments -Wait
|
||||
Remove-Item $msiInstaller
|
||||
|
||||
$suffix = "\\Microsoft\\Edge Beta\\Application\\msedge.exe"
|
||||
if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
|
||||
} elseif (Test-Path "${env:ProgramFiles}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles}$suffix").VersionInfo
|
||||
} else {
|
||||
Write-Host "ERROR: Failed to install Microsoft Edge Beta."
|
||||
Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
|
||||
exit 1
|
||||
}
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
set -e
|
||||
set -x
|
||||
|
||||
if [[ $(arch) == "aarch64" ]]; then
|
||||
echo "ERROR: not supported on Linux Arm64"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
|
||||
if [[ ! -f "/etc/os-release" ]]; then
|
||||
echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
ID=$(bash -c 'source /etc/os-release && echo $ID')
|
||||
if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
|
||||
echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# 1. make sure to remove old dev if any.
|
||||
if dpkg --get-selections | grep -q "^microsoft-edge-dev[[:space:]]*install$" >/dev/null; then
|
||||
apt-get remove -y microsoft-edge-dev
|
||||
fi
|
||||
|
||||
# 2. Install curl to download Microsoft gpg key
|
||||
if ! command -v curl >/dev/null; then
|
||||
apt-get update
|
||||
apt-get install -y curl
|
||||
fi
|
||||
|
||||
# GnuPG is not preinstalled in slim images
|
||||
if ! command -v gpg >/dev/null; then
|
||||
apt-get update
|
||||
apt-get install -y gpg
|
||||
fi
|
||||
|
||||
# 3. Add the GPG key, the apt repo, update the apt cache, and install the package
|
||||
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/microsoft.gpg
|
||||
install -o root -g root -m 644 /tmp/microsoft.gpg /etc/apt/trusted.gpg.d/
|
||||
sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-dev.list'
|
||||
rm /tmp/microsoft.gpg
|
||||
apt-get update && apt-get install -y microsoft-edge-dev
|
||||
|
||||
microsoft-edge-dev --version
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
#!/usr/bin/env bash
|
||||
set -e
|
||||
set -x
|
||||
|
||||
cd /tmp
|
||||
curl --retry 3 -o ./msedge_dev.pkg "$1"
|
||||
# Note: there's no way to uninstall previously installed MSEdge.
|
||||
# However, running PKG again seems to update installation.
|
||||
sudo installer -pkg /tmp/msedge_dev.pkg -target /
|
||||
rm -rf /tmp/msedge_dev.pkg
|
||||
/Applications/Microsoft\ Edge\ Dev.app/Contents/MacOS/Microsoft\ Edge\ Dev --version
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$url = $args[0]
|
||||
|
||||
Write-Host "Downloading Microsoft Edge Dev"
|
||||
$wc = New-Object net.webclient
|
||||
$msiInstaller = "$env:temp\microsoft-edge-dev.msi"
|
||||
$wc.Downloadfile($url, $msiInstaller)
|
||||
|
||||
Write-Host "Installing Microsoft Edge Dev"
|
||||
$arguments = "/i `"$msiInstaller`" /quiet"
|
||||
Start-Process msiexec.exe -ArgumentList $arguments -Wait
|
||||
Remove-Item $msiInstaller
|
||||
|
||||
$suffix = "\\Microsoft\\Edge Dev\\Application\\msedge.exe"
|
||||
if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
|
||||
} elseif (Test-Path "${env:ProgramFiles}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles}$suffix").VersionInfo
|
||||
} else {
|
||||
Write-Host "ERROR: Failed to install Microsoft Edge Dev."
|
||||
Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
|
||||
exit 1
|
||||
}
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
set -e
|
||||
set -x
|
||||
|
||||
if [[ $(arch) == "aarch64" ]]; then
|
||||
echo "ERROR: not supported on Linux Arm64"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
|
||||
if [[ ! -f "/etc/os-release" ]]; then
|
||||
echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
ID=$(bash -c 'source /etc/os-release && echo $ID')
|
||||
if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
|
||||
echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# 1. make sure to remove old stable if any.
|
||||
if dpkg --get-selections | grep -q "^microsoft-edge-stable[[:space:]]*install$" >/dev/null; then
|
||||
apt-get remove -y microsoft-edge-stable
|
||||
fi
|
||||
|
||||
# 2. Install curl to download Microsoft gpg key
|
||||
if ! command -v curl >/dev/null; then
|
||||
apt-get update
|
||||
apt-get install -y curl
|
||||
fi
|
||||
|
||||
# GnuPG is not preinstalled in slim images
|
||||
if ! command -v gpg >/dev/null; then
|
||||
apt-get update
|
||||
apt-get install -y gpg
|
||||
fi
|
||||
|
||||
# 3. Add the GPG key, the apt repo, update the apt cache, and install the package
|
||||
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/microsoft.gpg
|
||||
install -o root -g root -m 644 /tmp/microsoft.gpg /etc/apt/trusted.gpg.d/
|
||||
sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-stable.list'
|
||||
rm /tmp/microsoft.gpg
|
||||
apt-get update && apt-get install -y microsoft-edge-stable
|
||||
|
||||
microsoft-edge-stable --version
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
#!/usr/bin/env bash
|
||||
set -e
|
||||
set -x
|
||||
|
||||
cd /tmp
|
||||
curl --retry 3 -o ./msedge_stable.pkg "$1"
|
||||
# Note: there's no way to uninstall previously installed MSEdge.
|
||||
# However, running PKG again seems to update installation.
|
||||
sudo installer -pkg /tmp/msedge_stable.pkg -target /
|
||||
rm -rf /tmp/msedge_stable.pkg
|
||||
/Applications/Microsoft\ Edge.app/Contents/MacOS/Microsoft\ Edge --version
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
|
||||
$url = $args[0]
|
||||
|
||||
Write-Host "Downloading Microsoft Edge"
|
||||
$wc = New-Object net.webclient
|
||||
$msiInstaller = "$env:temp\microsoft-edge-stable.msi"
|
||||
$wc.Downloadfile($url, $msiInstaller)
|
||||
|
||||
Write-Host "Installing Microsoft Edge"
|
||||
$arguments = "/i `"$msiInstaller`" /quiet"
|
||||
Start-Process msiexec.exe -ArgumentList $arguments -Wait
|
||||
Remove-Item $msiInstaller
|
||||
|
||||
$suffix = "\\Microsoft\\Edge\\Application\\msedge.exe"
|
||||
if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
|
||||
} elseif (Test-Path "${env:ProgramFiles}$suffix") {
|
||||
(Get-Item "${env:ProgramFiles}$suffix").VersionInfo
|
||||
} else {
|
||||
Write-Host "ERROR: Failed to install Microsoft Edge."
|
||||
Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
|
||||
exit 1
|
||||
}
|
||||
+79
@@ -0,0 +1,79 @@
|
||||
{
|
||||
"comment": "Do not edit this file, use utils/roll_browser.js",
|
||||
"browsers": [
|
||||
{
|
||||
"name": "chromium",
|
||||
"revision": "1208",
|
||||
"installByDefault": true,
|
||||
"browserVersion": "145.0.7632.6",
|
||||
"title": "Chrome for Testing"
|
||||
},
|
||||
{
|
||||
"name": "chromium-headless-shell",
|
||||
"revision": "1208",
|
||||
"installByDefault": true,
|
||||
"browserVersion": "145.0.7632.6",
|
||||
"title": "Chrome Headless Shell"
|
||||
},
|
||||
{
|
||||
"name": "chromium-tip-of-tree",
|
||||
"revision": "1401",
|
||||
"installByDefault": false,
|
||||
"browserVersion": "146.0.7644.0",
|
||||
"title": "Chrome Canary for Testing"
|
||||
},
|
||||
{
|
||||
"name": "chromium-tip-of-tree-headless-shell",
|
||||
"revision": "1401",
|
||||
"installByDefault": false,
|
||||
"browserVersion": "146.0.7644.0",
|
||||
"title": "Chrome Canary Headless Shell"
|
||||
},
|
||||
{
|
||||
"name": "firefox",
|
||||
"revision": "1509",
|
||||
"installByDefault": true,
|
||||
"browserVersion": "146.0.1",
|
||||
"title": "Firefox"
|
||||
},
|
||||
{
|
||||
"name": "firefox-beta",
|
||||
"revision": "1504",
|
||||
"installByDefault": false,
|
||||
"browserVersion": "146.0b8",
|
||||
"title": "Firefox Beta"
|
||||
},
|
||||
{
|
||||
"name": "webkit",
|
||||
"revision": "2248",
|
||||
"installByDefault": true,
|
||||
"revisionOverrides": {
|
||||
"debian11-x64": "2105",
|
||||
"debian11-arm64": "2105",
|
||||
"ubuntu20.04-x64": "2092",
|
||||
"ubuntu20.04-arm64": "2092"
|
||||
},
|
||||
"browserVersion": "26.0",
|
||||
"title": "WebKit"
|
||||
},
|
||||
{
|
||||
"name": "ffmpeg",
|
||||
"revision": "1011",
|
||||
"installByDefault": true,
|
||||
"revisionOverrides": {
|
||||
"mac12": "1010",
|
||||
"mac12-arm64": "1010"
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "winldd",
|
||||
"revision": "1007",
|
||||
"installByDefault": false
|
||||
},
|
||||
{
|
||||
"name": "android",
|
||||
"revision": "1001",
|
||||
"installByDefault": false
|
||||
}
|
||||
]
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
const { program } = require('./lib/cli/programWithTestStub');
|
||||
program.parse(process.argv);
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
export * from './types/types';
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
const minimumMajorNodeVersion = 18;
|
||||
const currentNodeVersion = process.versions.node;
|
||||
const semver = currentNodeVersion.split('.');
|
||||
const [major] = [+semver[0]];
|
||||
|
||||
if (major < minimumMajorNodeVersion) {
|
||||
console.error(
|
||||
'You are running Node.js ' +
|
||||
currentNodeVersion +
|
||||
'.\n' +
|
||||
`Playwright requires Node.js ${minimumMajorNodeVersion} or higher. \n` +
|
||||
'Please update your version of Node.js.'
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
module.exports = require('./lib/inprocess');
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
/**
|
||||
* 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 playwright from './index.js';
|
||||
|
||||
export const chromium = playwright.chromium;
|
||||
export const firefox = playwright.firefox;
|
||||
export const webkit = playwright.webkit;
|
||||
export const selectors = playwright.selectors;
|
||||
export const devices = playwright.devices;
|
||||
export const errors = playwright.errors;
|
||||
export const request = playwright.request;
|
||||
export const _electron = playwright._electron;
|
||||
export const _android = playwright._android;
|
||||
export default playwright;
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var androidServerImpl_exports = {};
|
||||
__export(androidServerImpl_exports, {
|
||||
AndroidServerLauncherImpl: () => AndroidServerLauncherImpl
|
||||
});
|
||||
module.exports = __toCommonJS(androidServerImpl_exports);
|
||||
var import_playwrightServer = require("./remote/playwrightServer");
|
||||
var import_playwright = require("./server/playwright");
|
||||
var import_crypto = require("./server/utils/crypto");
|
||||
var import_utilsBundle = require("./utilsBundle");
|
||||
var import_progress = require("./server/progress");
|
||||
class AndroidServerLauncherImpl {
|
||||
async launchServer(options = {}) {
|
||||
const playwright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
|
||||
const controller = new import_progress.ProgressController();
|
||||
let devices = await controller.run((progress) => playwright.android.devices(progress, {
|
||||
host: options.adbHost,
|
||||
port: options.adbPort,
|
||||
omitDriverInstall: options.omitDriverInstall
|
||||
}));
|
||||
if (devices.length === 0)
|
||||
throw new Error("No devices found");
|
||||
if (options.deviceSerialNumber) {
|
||||
devices = devices.filter((d) => d.serial === options.deviceSerialNumber);
|
||||
if (devices.length === 0)
|
||||
throw new Error(`No device with serial number '${options.deviceSerialNumber}' was found`);
|
||||
}
|
||||
if (devices.length > 1)
|
||||
throw new Error(`More than one device found. Please specify deviceSerialNumber`);
|
||||
const device = devices[0];
|
||||
const path = options.wsPath ? options.wsPath.startsWith("/") ? options.wsPath : `/${options.wsPath}` : `/${(0, import_crypto.createGuid)()}`;
|
||||
const server = new import_playwrightServer.PlaywrightServer({ mode: "launchServer", path, maxConnections: 1, preLaunchedAndroidDevice: device });
|
||||
const wsEndpoint = await server.listen(options.port, options.host);
|
||||
const browserServer = new import_utilsBundle.ws.EventEmitter();
|
||||
browserServer.wsEndpoint = () => wsEndpoint;
|
||||
browserServer.close = () => device.close();
|
||||
browserServer.kill = () => device.close();
|
||||
device.on("close", () => {
|
||||
server.close();
|
||||
browserServer.emit("close");
|
||||
});
|
||||
return browserServer;
|
||||
}
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
AndroidServerLauncherImpl
|
||||
});
|
||||
+120
@@ -0,0 +1,120 @@
|
||||
"use strict";
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var browserServerImpl_exports = {};
|
||||
__export(browserServerImpl_exports, {
|
||||
BrowserServerLauncherImpl: () => BrowserServerLauncherImpl
|
||||
});
|
||||
module.exports = __toCommonJS(browserServerImpl_exports);
|
||||
var import_playwrightServer = require("./remote/playwrightServer");
|
||||
var import_helper = require("./server/helper");
|
||||
var import_playwright = require("./server/playwright");
|
||||
var import_crypto = require("./server/utils/crypto");
|
||||
var import_debug = require("./server/utils/debug");
|
||||
var import_stackTrace = require("./utils/isomorphic/stackTrace");
|
||||
var import_time = require("./utils/isomorphic/time");
|
||||
var import_utilsBundle = require("./utilsBundle");
|
||||
var validatorPrimitives = __toESM(require("./protocol/validatorPrimitives"));
|
||||
var import_progress = require("./server/progress");
|
||||
class BrowserServerLauncherImpl {
|
||||
constructor(browserName) {
|
||||
this._browserName = browserName;
|
||||
}
|
||||
async launchServer(options = {}) {
|
||||
const playwright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
|
||||
const metadata = { id: "", startTime: 0, endTime: 0, type: "Internal", method: "", params: {}, log: [], internal: true };
|
||||
const validatorContext = {
|
||||
tChannelImpl: (names, arg, path2) => {
|
||||
throw new validatorPrimitives.ValidationError(`${path2}: channels are not expected in launchServer`);
|
||||
},
|
||||
binary: "buffer",
|
||||
isUnderTest: import_debug.isUnderTest
|
||||
};
|
||||
let launchOptions = {
|
||||
...options,
|
||||
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
|
||||
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
|
||||
env: options.env ? envObjectToArray(options.env) : void 0,
|
||||
timeout: options.timeout ?? import_time.DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT
|
||||
};
|
||||
let browser;
|
||||
try {
|
||||
const controller = new import_progress.ProgressController(metadata);
|
||||
browser = await controller.run(async (progress) => {
|
||||
if (options._userDataDir !== void 0) {
|
||||
const validator = validatorPrimitives.scheme["BrowserTypeLaunchPersistentContextParams"];
|
||||
launchOptions = validator({ ...launchOptions, userDataDir: options._userDataDir }, "", validatorContext);
|
||||
const context = await playwright[this._browserName].launchPersistentContext(progress, options._userDataDir, launchOptions);
|
||||
return context._browser;
|
||||
} else {
|
||||
const validator = validatorPrimitives.scheme["BrowserTypeLaunchParams"];
|
||||
launchOptions = validator(launchOptions, "", validatorContext);
|
||||
return await playwright[this._browserName].launch(progress, launchOptions, toProtocolLogger(options.logger));
|
||||
}
|
||||
});
|
||||
} catch (e) {
|
||||
const log = import_helper.helper.formatBrowserLogs(metadata.log);
|
||||
(0, import_stackTrace.rewriteErrorMessage)(e, `${e.message} Failed to launch browser.${log}`);
|
||||
throw e;
|
||||
}
|
||||
const path = options.wsPath ? options.wsPath.startsWith("/") ? options.wsPath : `/${options.wsPath}` : `/${(0, import_crypto.createGuid)()}`;
|
||||
const server = new import_playwrightServer.PlaywrightServer({ mode: options._sharedBrowser ? "launchServerShared" : "launchServer", path, maxConnections: Infinity, preLaunchedBrowser: browser });
|
||||
const wsEndpoint = await server.listen(options.port, options.host);
|
||||
const browserServer = new import_utilsBundle.ws.EventEmitter();
|
||||
browserServer.process = () => browser.options.browserProcess.process;
|
||||
browserServer.wsEndpoint = () => wsEndpoint;
|
||||
browserServer.close = () => browser.options.browserProcess.close();
|
||||
browserServer[Symbol.asyncDispose] = browserServer.close;
|
||||
browserServer.kill = () => browser.options.browserProcess.kill();
|
||||
browserServer._disconnectForTest = () => server.close();
|
||||
browserServer._userDataDirForTest = browser._userDataDirForTest;
|
||||
browser.options.browserProcess.onclose = (exitCode, signal) => {
|
||||
server.close();
|
||||
browserServer.emit("close", exitCode, signal);
|
||||
};
|
||||
return browserServer;
|
||||
}
|
||||
}
|
||||
function toProtocolLogger(logger) {
|
||||
return logger ? (direction, message) => {
|
||||
if (logger.isEnabled("protocol", "verbose"))
|
||||
logger.log("protocol", "verbose", (direction === "send" ? "SEND \u25BA " : "\u25C0 RECV ") + JSON.stringify(message), [], {});
|
||||
} : void 0;
|
||||
}
|
||||
function envObjectToArray(env) {
|
||||
const result = [];
|
||||
for (const name in env) {
|
||||
if (!Object.is(env[name], void 0))
|
||||
result.push({ name, value: String(env[name]) });
|
||||
}
|
||||
return result;
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
BrowserServerLauncherImpl
|
||||
});
|
||||
+97
@@ -0,0 +1,97 @@
|
||||
"use strict";
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var driver_exports = {};
|
||||
__export(driver_exports, {
|
||||
launchBrowserServer: () => launchBrowserServer,
|
||||
printApiJson: () => printApiJson,
|
||||
runDriver: () => runDriver,
|
||||
runServer: () => runServer
|
||||
});
|
||||
module.exports = __toCommonJS(driver_exports);
|
||||
var import_fs = __toESM(require("fs"));
|
||||
var playwright = __toESM(require("../.."));
|
||||
var import_pipeTransport = require("../server/utils/pipeTransport");
|
||||
var import_playwrightServer = require("../remote/playwrightServer");
|
||||
var import_server = require("../server");
|
||||
var import_processLauncher = require("../server/utils/processLauncher");
|
||||
function printApiJson() {
|
||||
console.log(JSON.stringify(require("../../api.json")));
|
||||
}
|
||||
function runDriver() {
|
||||
const dispatcherConnection = new import_server.DispatcherConnection();
|
||||
new import_server.RootDispatcher(dispatcherConnection, async (rootScope, { sdkLanguage }) => {
|
||||
const playwright2 = (0, import_server.createPlaywright)({ sdkLanguage });
|
||||
return new import_server.PlaywrightDispatcher(rootScope, playwright2);
|
||||
});
|
||||
const transport = new import_pipeTransport.PipeTransport(process.stdout, process.stdin);
|
||||
transport.onmessage = (message) => dispatcherConnection.dispatch(JSON.parse(message));
|
||||
const isJavaScriptLanguageBinding = !process.env.PW_LANG_NAME || process.env.PW_LANG_NAME === "javascript";
|
||||
const replacer = !isJavaScriptLanguageBinding && String.prototype.toWellFormed ? (key, value) => {
|
||||
if (typeof value === "string")
|
||||
return value.toWellFormed();
|
||||
return value;
|
||||
} : void 0;
|
||||
dispatcherConnection.onmessage = (message) => transport.send(JSON.stringify(message, replacer));
|
||||
transport.onclose = () => {
|
||||
dispatcherConnection.onmessage = () => {
|
||||
};
|
||||
(0, import_processLauncher.gracefullyProcessExitDoNotHang)(0);
|
||||
};
|
||||
process.on("SIGINT", () => {
|
||||
});
|
||||
}
|
||||
async function runServer(options) {
|
||||
const {
|
||||
port,
|
||||
host,
|
||||
path = "/",
|
||||
maxConnections = Infinity,
|
||||
extension
|
||||
} = options;
|
||||
const server = new import_playwrightServer.PlaywrightServer({ mode: extension ? "extension" : "default", path, maxConnections });
|
||||
const wsEndpoint = await server.listen(port, host);
|
||||
process.on("exit", () => server.close().catch(console.error));
|
||||
console.log("Listening on " + wsEndpoint);
|
||||
process.stdin.on("close", () => (0, import_processLauncher.gracefullyProcessExitDoNotHang)(0));
|
||||
}
|
||||
async function launchBrowserServer(browserName, configFile) {
|
||||
let options = {};
|
||||
if (configFile)
|
||||
options = JSON.parse(import_fs.default.readFileSync(configFile).toString());
|
||||
const browserType = playwright[browserName];
|
||||
const server = await browserType.launchServer(options);
|
||||
console.log(server.wsEndpoint());
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
launchBrowserServer,
|
||||
printApiJson,
|
||||
runDriver,
|
||||
runServer
|
||||
});
|
||||
+589
@@ -0,0 +1,589 @@
|
||||
"use strict";
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var program_exports = {};
|
||||
__export(program_exports, {
|
||||
program: () => import_utilsBundle2.program
|
||||
});
|
||||
module.exports = __toCommonJS(program_exports);
|
||||
var import_fs = __toESM(require("fs"));
|
||||
var import_os = __toESM(require("os"));
|
||||
var import_path = __toESM(require("path"));
|
||||
var playwright = __toESM(require("../.."));
|
||||
var import_driver = require("./driver");
|
||||
var import_server = require("../server");
|
||||
var import_utils = require("../utils");
|
||||
var import_traceViewer = require("../server/trace/viewer/traceViewer");
|
||||
var import_utils2 = require("../utils");
|
||||
var import_ascii = require("../server/utils/ascii");
|
||||
var import_utilsBundle = require("../utilsBundle");
|
||||
var import_utilsBundle2 = require("../utilsBundle");
|
||||
const packageJSON = require("../../package.json");
|
||||
import_utilsBundle.program.version("Version " + (process.env.PW_CLI_DISPLAY_VERSION || packageJSON.version)).name(buildBasePlaywrightCLICommand(process.env.PW_LANG_NAME));
|
||||
import_utilsBundle.program.command("mark-docker-image [dockerImageNameTemplate]", { hidden: true }).description("mark docker image").allowUnknownOption(true).action(function(dockerImageNameTemplate) {
|
||||
(0, import_utils2.assert)(dockerImageNameTemplate, "dockerImageNameTemplate is required");
|
||||
(0, import_server.writeDockerVersion)(dockerImageNameTemplate).catch(logErrorAndExit);
|
||||
});
|
||||
commandWithOpenOptions("open [url]", "open page in browser specified via -b, --browser", []).action(function(url, options) {
|
||||
open(options, url).catch(logErrorAndExit);
|
||||
}).addHelpText("afterAll", `
|
||||
Examples:
|
||||
|
||||
$ open
|
||||
$ open -b webkit https://example.com`);
|
||||
commandWithOpenOptions(
|
||||
"codegen [url]",
|
||||
"open page and generate code for user actions",
|
||||
[
|
||||
["-o, --output <file name>", "saves the generated script to a file"],
|
||||
["--target <language>", `language to generate, one of javascript, playwright-test, python, python-async, python-pytest, csharp, csharp-mstest, csharp-nunit, java, java-junit`, codegenId()],
|
||||
["--test-id-attribute <attributeName>", "use the specified attribute to generate data test ID selectors"]
|
||||
]
|
||||
).action(async function(url, options) {
|
||||
await codegen(options, url);
|
||||
}).addHelpText("afterAll", `
|
||||
Examples:
|
||||
|
||||
$ codegen
|
||||
$ codegen --target=python
|
||||
$ codegen -b webkit https://example.com`);
|
||||
function printInstalledBrowsers(browsers2) {
|
||||
const browserPaths = /* @__PURE__ */ new Set();
|
||||
for (const browser of browsers2)
|
||||
browserPaths.add(browser.browserPath);
|
||||
console.log(` Browsers:`);
|
||||
for (const browserPath of [...browserPaths].sort())
|
||||
console.log(` ${browserPath}`);
|
||||
console.log(` References:`);
|
||||
const references = /* @__PURE__ */ new Set();
|
||||
for (const browser of browsers2)
|
||||
references.add(browser.referenceDir);
|
||||
for (const reference of [...references].sort())
|
||||
console.log(` ${reference}`);
|
||||
}
|
||||
function printGroupedByPlaywrightVersion(browsers2) {
|
||||
const dirToVersion = /* @__PURE__ */ new Map();
|
||||
for (const browser of browsers2) {
|
||||
if (dirToVersion.has(browser.referenceDir))
|
||||
continue;
|
||||
const packageJSON2 = require(import_path.default.join(browser.referenceDir, "package.json"));
|
||||
const version = packageJSON2.version;
|
||||
dirToVersion.set(browser.referenceDir, version);
|
||||
}
|
||||
const groupedByPlaywrightMinorVersion = /* @__PURE__ */ new Map();
|
||||
for (const browser of browsers2) {
|
||||
const version = dirToVersion.get(browser.referenceDir);
|
||||
let entries = groupedByPlaywrightMinorVersion.get(version);
|
||||
if (!entries) {
|
||||
entries = [];
|
||||
groupedByPlaywrightMinorVersion.set(version, entries);
|
||||
}
|
||||
entries.push(browser);
|
||||
}
|
||||
const sortedVersions = [...groupedByPlaywrightMinorVersion.keys()].sort((a, b) => {
|
||||
const aComponents = a.split(".");
|
||||
const bComponents = b.split(".");
|
||||
const aMajor = parseInt(aComponents[0], 10);
|
||||
const bMajor = parseInt(bComponents[0], 10);
|
||||
if (aMajor !== bMajor)
|
||||
return aMajor - bMajor;
|
||||
const aMinor = parseInt(aComponents[1], 10);
|
||||
const bMinor = parseInt(bComponents[1], 10);
|
||||
if (aMinor !== bMinor)
|
||||
return aMinor - bMinor;
|
||||
return aComponents.slice(2).join(".").localeCompare(bComponents.slice(2).join("."));
|
||||
});
|
||||
for (const version of sortedVersions) {
|
||||
console.log(`
|
||||
Playwright version: ${version}`);
|
||||
printInstalledBrowsers(groupedByPlaywrightMinorVersion.get(version));
|
||||
}
|
||||
}
|
||||
import_utilsBundle.program.command("install [browser...]").description("ensure browsers necessary for this version of Playwright are installed").option("--with-deps", "install system dependencies for browsers").option("--dry-run", "do not execute installation, only print information").option("--list", "prints list of browsers from all playwright installations").option("--force", "force reinstall of already installed browsers").option("--only-shell", "only install headless shell when installing chromium").option("--no-shell", "do not install chromium headless shell").action(async function(args, options) {
|
||||
if ((0, import_utils.isLikelyNpxGlobal)()) {
|
||||
console.error((0, import_ascii.wrapInASCIIBox)([
|
||||
`WARNING: It looks like you are running 'npx playwright install' without first`,
|
||||
`installing your project's dependencies.`,
|
||||
``,
|
||||
`To avoid unexpected behavior, please install your dependencies first, and`,
|
||||
`then run Playwright's install command:`,
|
||||
``,
|
||||
` npm install`,
|
||||
` npx playwright install`,
|
||||
``,
|
||||
`If your project does not yet depend on Playwright, first install the`,
|
||||
`applicable npm package (most commonly @playwright/test), and`,
|
||||
`then run Playwright's install command to download the browsers:`,
|
||||
``,
|
||||
` npm install @playwright/test`,
|
||||
` npx playwright install`,
|
||||
``
|
||||
].join("\n"), 1));
|
||||
}
|
||||
try {
|
||||
if (options.shell === false && options.onlyShell)
|
||||
throw new Error(`Only one of --no-shell and --only-shell can be specified`);
|
||||
const shell = options.shell === false ? "no" : options.onlyShell ? "only" : void 0;
|
||||
const executables = import_server.registry.resolveBrowsers(args, { shell });
|
||||
if (options.withDeps)
|
||||
await import_server.registry.installDeps(executables, !!options.dryRun);
|
||||
if (options.dryRun && options.list)
|
||||
throw new Error(`Only one of --dry-run and --list can be specified`);
|
||||
if (options.dryRun) {
|
||||
for (const executable of executables) {
|
||||
console.log(import_server.registry.calculateDownloadTitle(executable));
|
||||
console.log(` Install location: ${executable.directory ?? "<system>"}`);
|
||||
if (executable.downloadURLs?.length) {
|
||||
const [url, ...fallbacks] = executable.downloadURLs;
|
||||
console.log(` Download url: ${url}`);
|
||||
for (let i = 0; i < fallbacks.length; ++i)
|
||||
console.log(` Download fallback ${i + 1}: ${fallbacks[i]}`);
|
||||
}
|
||||
console.log(``);
|
||||
}
|
||||
} else if (options.list) {
|
||||
const browsers2 = await import_server.registry.listInstalledBrowsers();
|
||||
printGroupedByPlaywrightVersion(browsers2);
|
||||
} else {
|
||||
await import_server.registry.install(executables, { force: options.force });
|
||||
await import_server.registry.validateHostRequirementsForExecutablesIfNeeded(executables, process.env.PW_LANG_NAME || "javascript").catch((e) => {
|
||||
e.name = "Playwright Host validation warning";
|
||||
console.error(e);
|
||||
});
|
||||
}
|
||||
} catch (e) {
|
||||
console.log(`Failed to install browsers
|
||||
${e}`);
|
||||
(0, import_utils.gracefullyProcessExitDoNotHang)(1);
|
||||
}
|
||||
}).addHelpText("afterAll", `
|
||||
|
||||
Examples:
|
||||
- $ install
|
||||
Install default browsers.
|
||||
|
||||
- $ install chrome firefox
|
||||
Install custom browsers, supports ${import_server.registry.suggestedBrowsersToInstall()}.`);
|
||||
import_utilsBundle.program.command("uninstall").description("Removes browsers used by this installation of Playwright from the system (chromium, firefox, webkit, ffmpeg). This does not include branded channels.").option("--all", "Removes all browsers used by any Playwright installation from the system.").action(async (options) => {
|
||||
delete process.env.PLAYWRIGHT_SKIP_BROWSER_GC;
|
||||
await import_server.registry.uninstall(!!options.all).then(({ numberOfBrowsersLeft }) => {
|
||||
if (!options.all && numberOfBrowsersLeft > 0) {
|
||||
console.log("Successfully uninstalled Playwright browsers for the current Playwright installation.");
|
||||
console.log(`There are still ${numberOfBrowsersLeft} browsers left, used by other Playwright installations.
|
||||
To uninstall Playwright browsers for all installations, re-run with --all flag.`);
|
||||
}
|
||||
}).catch(logErrorAndExit);
|
||||
});
|
||||
import_utilsBundle.program.command("install-deps [browser...]").description("install dependencies necessary to run browsers (will ask for sudo permissions)").option("--dry-run", "Do not execute installation commands, only print them").action(async function(args, options) {
|
||||
try {
|
||||
await import_server.registry.installDeps(import_server.registry.resolveBrowsers(args, {}), !!options.dryRun);
|
||||
} catch (e) {
|
||||
console.log(`Failed to install browser dependencies
|
||||
${e}`);
|
||||
(0, import_utils.gracefullyProcessExitDoNotHang)(1);
|
||||
}
|
||||
}).addHelpText("afterAll", `
|
||||
Examples:
|
||||
- $ install-deps
|
||||
Install dependencies for default browsers.
|
||||
|
||||
- $ install-deps chrome firefox
|
||||
Install dependencies for specific browsers, supports ${import_server.registry.suggestedBrowsersToInstall()}.`);
|
||||
const browsers = [
|
||||
{ alias: "cr", name: "Chromium", type: "chromium" },
|
||||
{ alias: "ff", name: "Firefox", type: "firefox" },
|
||||
{ alias: "wk", name: "WebKit", type: "webkit" }
|
||||
];
|
||||
for (const { alias, name, type } of browsers) {
|
||||
commandWithOpenOptions(`${alias} [url]`, `open page in ${name}`, []).action(function(url, options) {
|
||||
open({ ...options, browser: type }, url).catch(logErrorAndExit);
|
||||
}).addHelpText("afterAll", `
|
||||
Examples:
|
||||
|
||||
$ ${alias} https://example.com`);
|
||||
}
|
||||
commandWithOpenOptions(
|
||||
"screenshot <url> <filename>",
|
||||
"capture a page screenshot",
|
||||
[
|
||||
["--wait-for-selector <selector>", "wait for selector before taking a screenshot"],
|
||||
["--wait-for-timeout <timeout>", "wait for timeout in milliseconds before taking a screenshot"],
|
||||
["--full-page", "whether to take a full page screenshot (entire scrollable area)"]
|
||||
]
|
||||
).action(function(url, filename, command) {
|
||||
screenshot(command, command, url, filename).catch(logErrorAndExit);
|
||||
}).addHelpText("afterAll", `
|
||||
Examples:
|
||||
|
||||
$ screenshot -b webkit https://example.com example.png`);
|
||||
commandWithOpenOptions(
|
||||
"pdf <url> <filename>",
|
||||
"save page as pdf",
|
||||
[
|
||||
["--paper-format <format>", "paper format: Letter, Legal, Tabloid, Ledger, A0, A1, A2, A3, A4, A5, A6"],
|
||||
["--wait-for-selector <selector>", "wait for given selector before saving as pdf"],
|
||||
["--wait-for-timeout <timeout>", "wait for given timeout in milliseconds before saving as pdf"]
|
||||
]
|
||||
).action(function(url, filename, options) {
|
||||
pdf(options, options, url, filename).catch(logErrorAndExit);
|
||||
}).addHelpText("afterAll", `
|
||||
Examples:
|
||||
|
||||
$ pdf https://example.com example.pdf`);
|
||||
import_utilsBundle.program.command("run-driver", { hidden: true }).action(function(options) {
|
||||
(0, import_driver.runDriver)();
|
||||
});
|
||||
import_utilsBundle.program.command("run-server", { hidden: true }).option("--port <port>", "Server port").option("--host <host>", "Server host").option("--path <path>", "Endpoint Path", "/").option("--max-clients <maxClients>", "Maximum clients").option("--mode <mode>", 'Server mode, either "default" or "extension"').action(function(options) {
|
||||
(0, import_driver.runServer)({
|
||||
port: options.port ? +options.port : void 0,
|
||||
host: options.host,
|
||||
path: options.path,
|
||||
maxConnections: options.maxClients ? +options.maxClients : Infinity,
|
||||
extension: options.mode === "extension" || !!process.env.PW_EXTENSION_MODE
|
||||
}).catch(logErrorAndExit);
|
||||
});
|
||||
import_utilsBundle.program.command("print-api-json", { hidden: true }).action(function(options) {
|
||||
(0, import_driver.printApiJson)();
|
||||
});
|
||||
import_utilsBundle.program.command("launch-server", { hidden: true }).requiredOption("--browser <browserName>", 'Browser name, one of "chromium", "firefox" or "webkit"').option("--config <path-to-config-file>", "JSON file with launchServer options").action(function(options) {
|
||||
(0, import_driver.launchBrowserServer)(options.browser, options.config);
|
||||
});
|
||||
import_utilsBundle.program.command("show-trace [trace]").option("-b, --browser <browserType>", "browser to use, one of cr, chromium, ff, firefox, wk, webkit", "chromium").option("-h, --host <host>", "Host to serve trace on; specifying this option opens trace in a browser tab").option("-p, --port <port>", "Port to serve trace on, 0 for any free port; specifying this option opens trace in a browser tab").option("--stdin", "Accept trace URLs over stdin to update the viewer").description("show trace viewer").action(function(trace, options) {
|
||||
if (options.browser === "cr")
|
||||
options.browser = "chromium";
|
||||
if (options.browser === "ff")
|
||||
options.browser = "firefox";
|
||||
if (options.browser === "wk")
|
||||
options.browser = "webkit";
|
||||
const openOptions = {
|
||||
host: options.host,
|
||||
port: +options.port,
|
||||
isServer: !!options.stdin
|
||||
};
|
||||
if (options.port !== void 0 || options.host !== void 0)
|
||||
(0, import_traceViewer.runTraceInBrowser)(trace, openOptions).catch(logErrorAndExit);
|
||||
else
|
||||
(0, import_traceViewer.runTraceViewerApp)(trace, options.browser, openOptions, true).catch(logErrorAndExit);
|
||||
}).addHelpText("afterAll", `
|
||||
Examples:
|
||||
|
||||
$ show-trace
|
||||
$ show-trace https://example.com/trace.zip`);
|
||||
async function launchContext(options, extraOptions) {
|
||||
validateOptions(options);
|
||||
const browserType = lookupBrowserType(options);
|
||||
const launchOptions = extraOptions;
|
||||
if (options.channel)
|
||||
launchOptions.channel = options.channel;
|
||||
launchOptions.handleSIGINT = false;
|
||||
const contextOptions = (
|
||||
// Copy the device descriptor since we have to compare and modify the options.
|
||||
options.device ? { ...playwright.devices[options.device] } : {}
|
||||
);
|
||||
if (!extraOptions.headless)
|
||||
contextOptions.deviceScaleFactor = import_os.default.platform() === "darwin" ? 2 : 1;
|
||||
if (browserType.name() === "webkit" && process.platform === "linux") {
|
||||
delete contextOptions.hasTouch;
|
||||
delete contextOptions.isMobile;
|
||||
}
|
||||
if (contextOptions.isMobile && browserType.name() === "firefox")
|
||||
contextOptions.isMobile = void 0;
|
||||
if (options.blockServiceWorkers)
|
||||
contextOptions.serviceWorkers = "block";
|
||||
if (options.proxyServer) {
|
||||
launchOptions.proxy = {
|
||||
server: options.proxyServer
|
||||
};
|
||||
if (options.proxyBypass)
|
||||
launchOptions.proxy.bypass = options.proxyBypass;
|
||||
}
|
||||
if (options.viewportSize) {
|
||||
try {
|
||||
const [width, height] = options.viewportSize.split(",").map((n) => +n);
|
||||
if (isNaN(width) || isNaN(height))
|
||||
throw new Error("bad values");
|
||||
contextOptions.viewport = { width, height };
|
||||
} catch (e) {
|
||||
throw new Error('Invalid viewport size format: use "width,height", for example --viewport-size="800,600"');
|
||||
}
|
||||
}
|
||||
if (options.geolocation) {
|
||||
try {
|
||||
const [latitude, longitude] = options.geolocation.split(",").map((n) => parseFloat(n.trim()));
|
||||
contextOptions.geolocation = {
|
||||
latitude,
|
||||
longitude
|
||||
};
|
||||
} catch (e) {
|
||||
throw new Error('Invalid geolocation format, should be "lat,long". For example --geolocation="37.819722,-122.478611"');
|
||||
}
|
||||
contextOptions.permissions = ["geolocation"];
|
||||
}
|
||||
if (options.userAgent)
|
||||
contextOptions.userAgent = options.userAgent;
|
||||
if (options.lang)
|
||||
contextOptions.locale = options.lang;
|
||||
if (options.colorScheme)
|
||||
contextOptions.colorScheme = options.colorScheme;
|
||||
if (options.timezone)
|
||||
contextOptions.timezoneId = options.timezone;
|
||||
if (options.loadStorage)
|
||||
contextOptions.storageState = options.loadStorage;
|
||||
if (options.ignoreHttpsErrors)
|
||||
contextOptions.ignoreHTTPSErrors = true;
|
||||
if (options.saveHar) {
|
||||
contextOptions.recordHar = { path: import_path.default.resolve(process.cwd(), options.saveHar), mode: "minimal" };
|
||||
if (options.saveHarGlob)
|
||||
contextOptions.recordHar.urlFilter = options.saveHarGlob;
|
||||
contextOptions.serviceWorkers = "block";
|
||||
}
|
||||
let browser;
|
||||
let context;
|
||||
if (options.userDataDir) {
|
||||
context = await browserType.launchPersistentContext(options.userDataDir, { ...launchOptions, ...contextOptions });
|
||||
browser = context.browser();
|
||||
} else {
|
||||
browser = await browserType.launch(launchOptions);
|
||||
context = await browser.newContext(contextOptions);
|
||||
}
|
||||
let closingBrowser = false;
|
||||
async function closeBrowser() {
|
||||
if (closingBrowser)
|
||||
return;
|
||||
closingBrowser = true;
|
||||
if (options.saveStorage)
|
||||
await context.storageState({ path: options.saveStorage }).catch((e) => null);
|
||||
if (options.saveHar)
|
||||
await context.close();
|
||||
await browser.close();
|
||||
}
|
||||
context.on("page", (page) => {
|
||||
page.on("dialog", () => {
|
||||
});
|
||||
page.on("close", () => {
|
||||
const hasPage = browser.contexts().some((context2) => context2.pages().length > 0);
|
||||
if (hasPage)
|
||||
return;
|
||||
closeBrowser().catch(() => {
|
||||
});
|
||||
});
|
||||
});
|
||||
process.on("SIGINT", async () => {
|
||||
await closeBrowser();
|
||||
(0, import_utils.gracefullyProcessExitDoNotHang)(130);
|
||||
});
|
||||
const timeout = options.timeout ? parseInt(options.timeout, 10) : 0;
|
||||
context.setDefaultTimeout(timeout);
|
||||
context.setDefaultNavigationTimeout(timeout);
|
||||
delete launchOptions.headless;
|
||||
delete launchOptions.executablePath;
|
||||
delete launchOptions.handleSIGINT;
|
||||
delete contextOptions.deviceScaleFactor;
|
||||
return { browser, browserName: browserType.name(), context, contextOptions, launchOptions, closeBrowser };
|
||||
}
|
||||
async function openPage(context, url) {
|
||||
let page = context.pages()[0];
|
||||
if (!page)
|
||||
page = await context.newPage();
|
||||
if (url) {
|
||||
if (import_fs.default.existsSync(url))
|
||||
url = "file://" + import_path.default.resolve(url);
|
||||
else if (!url.startsWith("http") && !url.startsWith("file://") && !url.startsWith("about:") && !url.startsWith("data:"))
|
||||
url = "http://" + url;
|
||||
await page.goto(url);
|
||||
}
|
||||
return page;
|
||||
}
|
||||
async function open(options, url) {
|
||||
const { context } = await launchContext(options, { headless: !!process.env.PWTEST_CLI_HEADLESS, executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH });
|
||||
await context._exposeConsoleApi();
|
||||
await openPage(context, url);
|
||||
}
|
||||
async function codegen(options, url) {
|
||||
const { target: language, output: outputFile, testIdAttribute: testIdAttributeName } = options;
|
||||
const tracesDir = import_path.default.join(import_os.default.tmpdir(), `playwright-recorder-trace-${Date.now()}`);
|
||||
const { context, browser, launchOptions, contextOptions, closeBrowser } = await launchContext(options, {
|
||||
headless: !!process.env.PWTEST_CLI_HEADLESS,
|
||||
executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH,
|
||||
tracesDir
|
||||
});
|
||||
const donePromise = new import_utils.ManualPromise();
|
||||
maybeSetupTestHooks(browser, closeBrowser, donePromise);
|
||||
import_utilsBundle.dotenv.config({ path: "playwright.env" });
|
||||
await context._enableRecorder({
|
||||
language,
|
||||
launchOptions,
|
||||
contextOptions,
|
||||
device: options.device,
|
||||
saveStorage: options.saveStorage,
|
||||
mode: "recording",
|
||||
testIdAttributeName,
|
||||
outputFile: outputFile ? import_path.default.resolve(outputFile) : void 0,
|
||||
handleSIGINT: false
|
||||
});
|
||||
await openPage(context, url);
|
||||
donePromise.resolve();
|
||||
}
|
||||
async function maybeSetupTestHooks(browser, closeBrowser, donePromise) {
|
||||
if (!process.env.PWTEST_CLI_IS_UNDER_TEST)
|
||||
return;
|
||||
const logs = [];
|
||||
require("playwright-core/lib/utilsBundle").debug.log = (...args) => {
|
||||
const line = require("util").format(...args) + "\n";
|
||||
logs.push(line);
|
||||
process.stderr.write(line);
|
||||
};
|
||||
browser.on("disconnected", () => {
|
||||
const hasCrashLine = logs.some((line) => line.includes("process did exit:") && !line.includes("process did exit: exitCode=0, signal=null"));
|
||||
if (hasCrashLine) {
|
||||
process.stderr.write("Detected browser crash.\n");
|
||||
(0, import_utils.gracefullyProcessExitDoNotHang)(1);
|
||||
}
|
||||
});
|
||||
const close = async () => {
|
||||
await donePromise;
|
||||
await closeBrowser();
|
||||
};
|
||||
if (process.env.PWTEST_CLI_EXIT_AFTER_TIMEOUT) {
|
||||
setTimeout(close, +process.env.PWTEST_CLI_EXIT_AFTER_TIMEOUT);
|
||||
return;
|
||||
}
|
||||
let stdin = "";
|
||||
process.stdin.on("data", (data) => {
|
||||
stdin += data.toString();
|
||||
if (stdin.startsWith("exit")) {
|
||||
process.stdin.destroy();
|
||||
close();
|
||||
}
|
||||
});
|
||||
}
|
||||
async function waitForPage(page, captureOptions) {
|
||||
if (captureOptions.waitForSelector) {
|
||||
console.log(`Waiting for selector ${captureOptions.waitForSelector}...`);
|
||||
await page.waitForSelector(captureOptions.waitForSelector);
|
||||
}
|
||||
if (captureOptions.waitForTimeout) {
|
||||
console.log(`Waiting for timeout ${captureOptions.waitForTimeout}...`);
|
||||
await page.waitForTimeout(parseInt(captureOptions.waitForTimeout, 10));
|
||||
}
|
||||
}
|
||||
async function screenshot(options, captureOptions, url, path2) {
|
||||
const { context } = await launchContext(options, { headless: true });
|
||||
console.log("Navigating to " + url);
|
||||
const page = await openPage(context, url);
|
||||
await waitForPage(page, captureOptions);
|
||||
console.log("Capturing screenshot into " + path2);
|
||||
await page.screenshot({ path: path2, fullPage: !!captureOptions.fullPage });
|
||||
await page.close();
|
||||
}
|
||||
async function pdf(options, captureOptions, url, path2) {
|
||||
if (options.browser !== "chromium")
|
||||
throw new Error("PDF creation is only working with Chromium");
|
||||
const { context } = await launchContext({ ...options, browser: "chromium" }, { headless: true });
|
||||
console.log("Navigating to " + url);
|
||||
const page = await openPage(context, url);
|
||||
await waitForPage(page, captureOptions);
|
||||
console.log("Saving as pdf into " + path2);
|
||||
await page.pdf({ path: path2, format: captureOptions.paperFormat });
|
||||
await page.close();
|
||||
}
|
||||
function lookupBrowserType(options) {
|
||||
let name = options.browser;
|
||||
if (options.device) {
|
||||
const device = playwright.devices[options.device];
|
||||
name = device.defaultBrowserType;
|
||||
}
|
||||
let browserType;
|
||||
switch (name) {
|
||||
case "chromium":
|
||||
browserType = playwright.chromium;
|
||||
break;
|
||||
case "webkit":
|
||||
browserType = playwright.webkit;
|
||||
break;
|
||||
case "firefox":
|
||||
browserType = playwright.firefox;
|
||||
break;
|
||||
case "cr":
|
||||
browserType = playwright.chromium;
|
||||
break;
|
||||
case "wk":
|
||||
browserType = playwright.webkit;
|
||||
break;
|
||||
case "ff":
|
||||
browserType = playwright.firefox;
|
||||
break;
|
||||
}
|
||||
if (browserType)
|
||||
return browserType;
|
||||
import_utilsBundle.program.help();
|
||||
}
|
||||
function validateOptions(options) {
|
||||
if (options.device && !(options.device in playwright.devices)) {
|
||||
const lines = [`Device descriptor not found: '${options.device}', available devices are:`];
|
||||
for (const name in playwright.devices)
|
||||
lines.push(` "${name}"`);
|
||||
throw new Error(lines.join("\n"));
|
||||
}
|
||||
if (options.colorScheme && !["light", "dark"].includes(options.colorScheme))
|
||||
throw new Error('Invalid color scheme, should be one of "light", "dark"');
|
||||
}
|
||||
function logErrorAndExit(e) {
|
||||
if (process.env.PWDEBUGIMPL)
|
||||
console.error(e);
|
||||
else
|
||||
console.error(e.name + ": " + e.message);
|
||||
(0, import_utils.gracefullyProcessExitDoNotHang)(1);
|
||||
}
|
||||
function codegenId() {
|
||||
return process.env.PW_LANG_NAME || "playwright-test";
|
||||
}
|
||||
function commandWithOpenOptions(command, description, options) {
|
||||
let result = import_utilsBundle.program.command(command).description(description);
|
||||
for (const option of options)
|
||||
result = result.option(option[0], ...option.slice(1));
|
||||
return result.option("-b, --browser <browserType>", "browser to use, one of cr, chromium, ff, firefox, wk, webkit", "chromium").option("--block-service-workers", "block service workers").option("--channel <channel>", 'Chromium distribution channel, "chrome", "chrome-beta", "msedge-dev", etc').option("--color-scheme <scheme>", 'emulate preferred color scheme, "light" or "dark"').option("--device <deviceName>", 'emulate device, for example "iPhone 11"').option("--geolocation <coordinates>", 'specify geolocation coordinates, for example "37.819722,-122.478611"').option("--ignore-https-errors", "ignore https errors").option("--load-storage <filename>", "load context storage state from the file, previously saved with --save-storage").option("--lang <language>", 'specify language / locale, for example "en-GB"').option("--proxy-server <proxy>", 'specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"').option("--proxy-bypass <bypass>", 'comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"').option("--save-har <filename>", "save HAR file with all network activity at the end").option("--save-har-glob <glob pattern>", "filter entries in the HAR by matching url against this glob pattern").option("--save-storage <filename>", "save context storage state at the end, for later use with --load-storage").option("--timezone <time zone>", 'time zone to emulate, for example "Europe/Rome"').option("--timeout <timeout>", "timeout for Playwright actions in milliseconds, no timeout by default").option("--user-agent <ua string>", "specify user agent string").option("--user-data-dir <directory>", "use the specified user data directory instead of a new context").option("--viewport-size <size>", 'specify browser viewport size in pixels, for example "1280, 720"');
|
||||
}
|
||||
function buildBasePlaywrightCLICommand(cliTargetLang) {
|
||||
switch (cliTargetLang) {
|
||||
case "python":
|
||||
return `playwright`;
|
||||
case "java":
|
||||
return `mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="...options.."`;
|
||||
case "csharp":
|
||||
return `pwsh bin/Debug/netX/playwright.ps1`;
|
||||
default: {
|
||||
const packageManagerCommand = (0, import_utils2.getPackageManagerExecCommand)();
|
||||
return `${packageManagerCommand} playwright`;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
program
|
||||
});
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var programWithTestStub_exports = {};
|
||||
__export(programWithTestStub_exports, {
|
||||
program: () => import_program2.program
|
||||
});
|
||||
module.exports = __toCommonJS(programWithTestStub_exports);
|
||||
var import_processLauncher = require("../server/utils/processLauncher");
|
||||
var import_utils = require("../utils");
|
||||
var import_program = require("./program");
|
||||
var import_program2 = require("./program");
|
||||
function printPlaywrightTestError(command) {
|
||||
const packages = [];
|
||||
for (const pkg of ["playwright", "playwright-chromium", "playwright-firefox", "playwright-webkit"]) {
|
||||
try {
|
||||
require.resolve(pkg);
|
||||
packages.push(pkg);
|
||||
} catch (e) {
|
||||
}
|
||||
}
|
||||
if (!packages.length)
|
||||
packages.push("playwright");
|
||||
const packageManager = (0, import_utils.getPackageManager)();
|
||||
if (packageManager === "yarn") {
|
||||
console.error(`Please install @playwright/test package before running "yarn playwright ${command}"`);
|
||||
console.error(` yarn remove ${packages.join(" ")}`);
|
||||
console.error(" yarn add -D @playwright/test");
|
||||
} else if (packageManager === "pnpm") {
|
||||
console.error(`Please install @playwright/test package before running "pnpm exec playwright ${command}"`);
|
||||
console.error(` pnpm remove ${packages.join(" ")}`);
|
||||
console.error(" pnpm add -D @playwright/test");
|
||||
} else {
|
||||
console.error(`Please install @playwright/test package before running "npx playwright ${command}"`);
|
||||
console.error(` npm uninstall ${packages.join(" ")}`);
|
||||
console.error(" npm install -D @playwright/test");
|
||||
}
|
||||
}
|
||||
const kExternalPlaywrightTestCommands = [
|
||||
["test", "Run tests with Playwright Test."],
|
||||
["show-report", "Show Playwright Test HTML report."],
|
||||
["merge-reports", "Merge Playwright Test Blob reports"]
|
||||
];
|
||||
function addExternalPlaywrightTestCommands() {
|
||||
for (const [command, description] of kExternalPlaywrightTestCommands) {
|
||||
const playwrightTest = import_program.program.command(command).allowUnknownOption(true).allowExcessArguments(true);
|
||||
playwrightTest.description(`${description} Available in @playwright/test package.`);
|
||||
playwrightTest.action(async () => {
|
||||
printPlaywrightTestError(command);
|
||||
(0, import_processLauncher.gracefullyProcessExitDoNotHang)(1);
|
||||
});
|
||||
}
|
||||
}
|
||||
if (!process.env.PW_LANG_NAME)
|
||||
addExternalPlaywrightTestCommands();
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
program
|
||||
});
|
||||
+361
@@ -0,0 +1,361 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var android_exports = {};
|
||||
__export(android_exports, {
|
||||
Android: () => Android,
|
||||
AndroidDevice: () => AndroidDevice,
|
||||
AndroidInput: () => AndroidInput,
|
||||
AndroidSocket: () => AndroidSocket,
|
||||
AndroidWebView: () => AndroidWebView
|
||||
});
|
||||
module.exports = __toCommonJS(android_exports);
|
||||
var import_eventEmitter = require("./eventEmitter");
|
||||
var import_browserContext = require("./browserContext");
|
||||
var import_channelOwner = require("./channelOwner");
|
||||
var import_errors = require("./errors");
|
||||
var import_events = require("./events");
|
||||
var import_waiter = require("./waiter");
|
||||
var import_timeoutSettings = require("./timeoutSettings");
|
||||
var import_rtti = require("../utils/isomorphic/rtti");
|
||||
var import_time = require("../utils/isomorphic/time");
|
||||
var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
|
||||
var import_webSocket = require("./webSocket");
|
||||
class Android extends import_channelOwner.ChannelOwner {
|
||||
static from(android) {
|
||||
return android._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
|
||||
}
|
||||
setDefaultTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultTimeout(timeout);
|
||||
}
|
||||
async devices(options = {}) {
|
||||
const { devices } = await this._channel.devices(options);
|
||||
return devices.map((d) => AndroidDevice.from(d));
|
||||
}
|
||||
async launchServer(options = {}) {
|
||||
if (!this._serverLauncher)
|
||||
throw new Error("Launching server is not supported");
|
||||
return await this._serverLauncher.launchServer(options);
|
||||
}
|
||||
async connect(wsEndpoint, options = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
const deadline = options.timeout ? (0, import_time.monotonicTime)() + options.timeout : 0;
|
||||
const headers = { "x-playwright-browser": "android", ...options.headers };
|
||||
const connectParams = { wsEndpoint, headers, slowMo: options.slowMo, timeout: options.timeout || 0 };
|
||||
const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
|
||||
let device;
|
||||
connection.on("close", () => {
|
||||
device?._didClose();
|
||||
});
|
||||
const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
|
||||
const playwright = await connection.initializePlaywright();
|
||||
if (!playwright._initializer.preConnectedAndroidDevice) {
|
||||
connection.close();
|
||||
throw new Error("Malformed endpoint. Did you use Android.launchServer method?");
|
||||
}
|
||||
device = AndroidDevice.from(playwright._initializer.preConnectedAndroidDevice);
|
||||
device._shouldCloseConnectionOnClose = true;
|
||||
device.on(import_events.Events.AndroidDevice.Close, () => connection.close());
|
||||
return device;
|
||||
}, deadline);
|
||||
if (!result.timedOut) {
|
||||
return result.result;
|
||||
} else {
|
||||
connection.close();
|
||||
throw new Error(`Timeout ${options.timeout}ms exceeded`);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
class AndroidDevice extends import_channelOwner.ChannelOwner {
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._webViews = /* @__PURE__ */ new Map();
|
||||
this._shouldCloseConnectionOnClose = false;
|
||||
this._android = parent;
|
||||
this.input = new AndroidInput(this);
|
||||
this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, parent._timeoutSettings);
|
||||
this._channel.on("webViewAdded", ({ webView }) => this._onWebViewAdded(webView));
|
||||
this._channel.on("webViewRemoved", ({ socketName }) => this._onWebViewRemoved(socketName));
|
||||
this._channel.on("close", () => this._didClose());
|
||||
}
|
||||
static from(androidDevice) {
|
||||
return androidDevice._object;
|
||||
}
|
||||
_onWebViewAdded(webView) {
|
||||
const view = new AndroidWebView(this, webView);
|
||||
this._webViews.set(webView.socketName, view);
|
||||
this.emit(import_events.Events.AndroidDevice.WebView, view);
|
||||
}
|
||||
_onWebViewRemoved(socketName) {
|
||||
const view = this._webViews.get(socketName);
|
||||
this._webViews.delete(socketName);
|
||||
if (view)
|
||||
view.emit(import_events.Events.AndroidWebView.Close);
|
||||
}
|
||||
setDefaultTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultTimeout(timeout);
|
||||
}
|
||||
serial() {
|
||||
return this._initializer.serial;
|
||||
}
|
||||
model() {
|
||||
return this._initializer.model;
|
||||
}
|
||||
webViews() {
|
||||
return [...this._webViews.values()];
|
||||
}
|
||||
async webView(selector, options) {
|
||||
const predicate = (v) => {
|
||||
if (selector.pkg)
|
||||
return v.pkg() === selector.pkg;
|
||||
if (selector.socketName)
|
||||
return v._socketName() === selector.socketName;
|
||||
return false;
|
||||
};
|
||||
const webView = [...this._webViews.values()].find(predicate);
|
||||
if (webView)
|
||||
return webView;
|
||||
return await this.waitForEvent("webview", { ...options, predicate });
|
||||
}
|
||||
async wait(selector, options = {}) {
|
||||
await this._channel.wait({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async fill(selector, text, options = {}) {
|
||||
await this._channel.fill({ androidSelector: toSelectorChannel(selector), text, ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async press(selector, key, options = {}) {
|
||||
await this.tap(selector, options);
|
||||
await this.input.press(key);
|
||||
}
|
||||
async tap(selector, options = {}) {
|
||||
await this._channel.tap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async drag(selector, dest, options = {}) {
|
||||
await this._channel.drag({ androidSelector: toSelectorChannel(selector), dest, ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async fling(selector, direction, options = {}) {
|
||||
await this._channel.fling({ androidSelector: toSelectorChannel(selector), direction, ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async longTap(selector, options = {}) {
|
||||
await this._channel.longTap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async pinchClose(selector, percent, options = {}) {
|
||||
await this._channel.pinchClose({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async pinchOpen(selector, percent, options = {}) {
|
||||
await this._channel.pinchOpen({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async scroll(selector, direction, percent, options = {}) {
|
||||
await this._channel.scroll({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async swipe(selector, direction, percent, options = {}) {
|
||||
await this._channel.swipe({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) });
|
||||
}
|
||||
async info(selector) {
|
||||
return (await this._channel.info({ androidSelector: toSelectorChannel(selector) })).info;
|
||||
}
|
||||
async screenshot(options = {}) {
|
||||
const { binary } = await this._channel.screenshot();
|
||||
if (options.path)
|
||||
await this._platform.fs().promises.writeFile(options.path, binary);
|
||||
return binary;
|
||||
}
|
||||
async [Symbol.asyncDispose]() {
|
||||
await this.close();
|
||||
}
|
||||
async close() {
|
||||
try {
|
||||
if (this._shouldCloseConnectionOnClose)
|
||||
this._connection.close();
|
||||
else
|
||||
await this._channel.close();
|
||||
} catch (e) {
|
||||
if ((0, import_errors.isTargetClosedError)(e))
|
||||
return;
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
_didClose() {
|
||||
this.emit(import_events.Events.AndroidDevice.Close, this);
|
||||
}
|
||||
async shell(command) {
|
||||
const { result } = await this._channel.shell({ command });
|
||||
return result;
|
||||
}
|
||||
async open(command) {
|
||||
return AndroidSocket.from((await this._channel.open({ command })).socket);
|
||||
}
|
||||
async installApk(file, options) {
|
||||
await this._channel.installApk({ file: await loadFile(this._platform, file), args: options && options.args });
|
||||
}
|
||||
async push(file, path, options) {
|
||||
await this._channel.push({ file: await loadFile(this._platform, file), path, mode: options ? options.mode : void 0 });
|
||||
}
|
||||
async launchBrowser(options = {}) {
|
||||
const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
|
||||
const result = await this._channel.launchBrowser(contextOptions);
|
||||
const context = import_browserContext.BrowserContext.from(result.context);
|
||||
const selectors = this._android._playwright.selectors;
|
||||
selectors._contextsForSelectors.add(context);
|
||||
context.once(import_events.Events.BrowserContext.Close, () => selectors._contextsForSelectors.delete(context));
|
||||
await context._initializeHarFromOptions(options.recordHar);
|
||||
return context;
|
||||
}
|
||||
async waitForEvent(event, optionsOrPredicate = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
|
||||
const predicate = typeof optionsOrPredicate === "function" ? optionsOrPredicate : optionsOrPredicate.predicate;
|
||||
const waiter = import_waiter.Waiter.createForEvent(this, event);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
|
||||
if (event !== import_events.Events.AndroidDevice.Close)
|
||||
waiter.rejectOnEvent(this, import_events.Events.AndroidDevice.Close, () => new import_errors.TargetClosedError());
|
||||
const result = await waiter.waitForEvent(this, event, predicate);
|
||||
waiter.dispose();
|
||||
return result;
|
||||
});
|
||||
}
|
||||
}
|
||||
class AndroidSocket extends import_channelOwner.ChannelOwner {
|
||||
static from(androidDevice) {
|
||||
return androidDevice._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._channel.on("data", ({ data }) => this.emit(import_events.Events.AndroidSocket.Data, data));
|
||||
this._channel.on("close", () => this.emit(import_events.Events.AndroidSocket.Close));
|
||||
}
|
||||
async write(data) {
|
||||
await this._channel.write({ data });
|
||||
}
|
||||
async close() {
|
||||
await this._channel.close();
|
||||
}
|
||||
async [Symbol.asyncDispose]() {
|
||||
await this.close();
|
||||
}
|
||||
}
|
||||
async function loadFile(platform, file) {
|
||||
if ((0, import_rtti.isString)(file))
|
||||
return await platform.fs().promises.readFile(file);
|
||||
return file;
|
||||
}
|
||||
class AndroidInput {
|
||||
constructor(device) {
|
||||
this._device = device;
|
||||
}
|
||||
async type(text) {
|
||||
await this._device._channel.inputType({ text });
|
||||
}
|
||||
async press(key) {
|
||||
await this._device._channel.inputPress({ key });
|
||||
}
|
||||
async tap(point) {
|
||||
await this._device._channel.inputTap({ point });
|
||||
}
|
||||
async swipe(from, segments, steps) {
|
||||
await this._device._channel.inputSwipe({ segments, steps });
|
||||
}
|
||||
async drag(from, to, steps) {
|
||||
await this._device._channel.inputDrag({ from, to, steps });
|
||||
}
|
||||
}
|
||||
function toSelectorChannel(selector) {
|
||||
const {
|
||||
checkable,
|
||||
checked,
|
||||
clazz,
|
||||
clickable,
|
||||
depth,
|
||||
desc,
|
||||
enabled,
|
||||
focusable,
|
||||
focused,
|
||||
hasChild,
|
||||
hasDescendant,
|
||||
longClickable,
|
||||
pkg,
|
||||
res,
|
||||
scrollable,
|
||||
selected,
|
||||
text
|
||||
} = selector;
|
||||
const toRegex = (value) => {
|
||||
if (value === void 0)
|
||||
return void 0;
|
||||
if ((0, import_rtti.isRegExp)(value))
|
||||
return value.source;
|
||||
return "^" + value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d") + "$";
|
||||
};
|
||||
return {
|
||||
checkable,
|
||||
checked,
|
||||
clazz: toRegex(clazz),
|
||||
pkg: toRegex(pkg),
|
||||
desc: toRegex(desc),
|
||||
res: toRegex(res),
|
||||
text: toRegex(text),
|
||||
clickable,
|
||||
depth,
|
||||
enabled,
|
||||
focusable,
|
||||
focused,
|
||||
hasChild: hasChild ? { androidSelector: toSelectorChannel(hasChild.selector) } : void 0,
|
||||
hasDescendant: hasDescendant ? { androidSelector: toSelectorChannel(hasDescendant.selector), maxDepth: hasDescendant.maxDepth } : void 0,
|
||||
longClickable,
|
||||
scrollable,
|
||||
selected
|
||||
};
|
||||
}
|
||||
class AndroidWebView extends import_eventEmitter.EventEmitter {
|
||||
constructor(device, data) {
|
||||
super(device._platform);
|
||||
this._device = device;
|
||||
this._data = data;
|
||||
}
|
||||
pid() {
|
||||
return this._data.pid;
|
||||
}
|
||||
pkg() {
|
||||
return this._data.pkg;
|
||||
}
|
||||
_socketName() {
|
||||
return this._data.socketName;
|
||||
}
|
||||
async page() {
|
||||
if (!this._pagePromise)
|
||||
this._pagePromise = this._fetchPage();
|
||||
return await this._pagePromise;
|
||||
}
|
||||
async _fetchPage() {
|
||||
const { context } = await this._device._channel.connectToWebView({ socketName: this._data.socketName });
|
||||
return import_browserContext.BrowserContext.from(context).pages()[0];
|
||||
}
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
Android,
|
||||
AndroidDevice,
|
||||
AndroidInput,
|
||||
AndroidSocket,
|
||||
AndroidWebView
|
||||
});
|
||||
+137
@@ -0,0 +1,137 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var api_exports = {};
|
||||
__export(api_exports, {
|
||||
APIRequest: () => import_fetch.APIRequest,
|
||||
APIRequestContext: () => import_fetch.APIRequestContext,
|
||||
APIResponse: () => import_fetch.APIResponse,
|
||||
Android: () => import_android.Android,
|
||||
AndroidDevice: () => import_android.AndroidDevice,
|
||||
AndroidInput: () => import_android.AndroidInput,
|
||||
AndroidSocket: () => import_android.AndroidSocket,
|
||||
AndroidWebView: () => import_android.AndroidWebView,
|
||||
Browser: () => import_browser.Browser,
|
||||
BrowserContext: () => import_browserContext.BrowserContext,
|
||||
BrowserType: () => import_browserType.BrowserType,
|
||||
CDPSession: () => import_cdpSession.CDPSession,
|
||||
Clock: () => import_clock.Clock,
|
||||
ConsoleMessage: () => import_consoleMessage.ConsoleMessage,
|
||||
Coverage: () => import_coverage.Coverage,
|
||||
Dialog: () => import_dialog.Dialog,
|
||||
Download: () => import_download.Download,
|
||||
Electron: () => import_electron.Electron,
|
||||
ElectronApplication: () => import_electron.ElectronApplication,
|
||||
ElementHandle: () => import_elementHandle.ElementHandle,
|
||||
FileChooser: () => import_fileChooser.FileChooser,
|
||||
Frame: () => import_frame.Frame,
|
||||
FrameLocator: () => import_locator.FrameLocator,
|
||||
JSHandle: () => import_jsHandle.JSHandle,
|
||||
Keyboard: () => import_input.Keyboard,
|
||||
Locator: () => import_locator.Locator,
|
||||
Mouse: () => import_input.Mouse,
|
||||
Page: () => import_page.Page,
|
||||
PageAgent: () => import_pageAgent.PageAgent,
|
||||
Playwright: () => import_playwright.Playwright,
|
||||
Request: () => import_network.Request,
|
||||
Response: () => import_network.Response,
|
||||
Route: () => import_network.Route,
|
||||
Selectors: () => import_selectors.Selectors,
|
||||
TimeoutError: () => import_errors.TimeoutError,
|
||||
Touchscreen: () => import_input.Touchscreen,
|
||||
Tracing: () => import_tracing.Tracing,
|
||||
Video: () => import_video.Video,
|
||||
WebError: () => import_webError.WebError,
|
||||
WebSocket: () => import_network.WebSocket,
|
||||
WebSocketRoute: () => import_network.WebSocketRoute,
|
||||
Worker: () => import_worker.Worker
|
||||
});
|
||||
module.exports = __toCommonJS(api_exports);
|
||||
var import_android = require("./android");
|
||||
var import_browser = require("./browser");
|
||||
var import_browserContext = require("./browserContext");
|
||||
var import_browserType = require("./browserType");
|
||||
var import_clock = require("./clock");
|
||||
var import_consoleMessage = require("./consoleMessage");
|
||||
var import_coverage = require("./coverage");
|
||||
var import_dialog = require("./dialog");
|
||||
var import_download = require("./download");
|
||||
var import_electron = require("./electron");
|
||||
var import_locator = require("./locator");
|
||||
var import_elementHandle = require("./elementHandle");
|
||||
var import_fileChooser = require("./fileChooser");
|
||||
var import_errors = require("./errors");
|
||||
var import_frame = require("./frame");
|
||||
var import_input = require("./input");
|
||||
var import_jsHandle = require("./jsHandle");
|
||||
var import_network = require("./network");
|
||||
var import_fetch = require("./fetch");
|
||||
var import_page = require("./page");
|
||||
var import_pageAgent = require("./pageAgent");
|
||||
var import_selectors = require("./selectors");
|
||||
var import_tracing = require("./tracing");
|
||||
var import_video = require("./video");
|
||||
var import_worker = require("./worker");
|
||||
var import_cdpSession = require("./cdpSession");
|
||||
var import_playwright = require("./playwright");
|
||||
var import_webError = require("./webError");
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
APIRequest,
|
||||
APIRequestContext,
|
||||
APIResponse,
|
||||
Android,
|
||||
AndroidDevice,
|
||||
AndroidInput,
|
||||
AndroidSocket,
|
||||
AndroidWebView,
|
||||
Browser,
|
||||
BrowserContext,
|
||||
BrowserType,
|
||||
CDPSession,
|
||||
Clock,
|
||||
ConsoleMessage,
|
||||
Coverage,
|
||||
Dialog,
|
||||
Download,
|
||||
Electron,
|
||||
ElectronApplication,
|
||||
ElementHandle,
|
||||
FileChooser,
|
||||
Frame,
|
||||
FrameLocator,
|
||||
JSHandle,
|
||||
Keyboard,
|
||||
Locator,
|
||||
Mouse,
|
||||
Page,
|
||||
PageAgent,
|
||||
Playwright,
|
||||
Request,
|
||||
Response,
|
||||
Route,
|
||||
Selectors,
|
||||
TimeoutError,
|
||||
Touchscreen,
|
||||
Tracing,
|
||||
Video,
|
||||
WebError,
|
||||
WebSocket,
|
||||
WebSocketRoute,
|
||||
Worker
|
||||
});
|
||||
+79
@@ -0,0 +1,79 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var artifact_exports = {};
|
||||
__export(artifact_exports, {
|
||||
Artifact: () => Artifact
|
||||
});
|
||||
module.exports = __toCommonJS(artifact_exports);
|
||||
var import_channelOwner = require("./channelOwner");
|
||||
var import_stream = require("./stream");
|
||||
var import_fileUtils = require("./fileUtils");
|
||||
class Artifact extends import_channelOwner.ChannelOwner {
|
||||
static from(channel) {
|
||||
return channel._object;
|
||||
}
|
||||
async pathAfterFinished() {
|
||||
if (this._connection.isRemote())
|
||||
throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
|
||||
return (await this._channel.pathAfterFinished()).value;
|
||||
}
|
||||
async saveAs(path) {
|
||||
if (!this._connection.isRemote()) {
|
||||
await this._channel.saveAs({ path });
|
||||
return;
|
||||
}
|
||||
const result = await this._channel.saveAsStream();
|
||||
const stream = import_stream.Stream.from(result.stream);
|
||||
await (0, import_fileUtils.mkdirIfNeeded)(this._platform, path);
|
||||
await new Promise((resolve, reject) => {
|
||||
stream.stream().pipe(this._platform.fs().createWriteStream(path)).on("finish", resolve).on("error", reject);
|
||||
});
|
||||
}
|
||||
async failure() {
|
||||
return (await this._channel.failure()).error || null;
|
||||
}
|
||||
async createReadStream() {
|
||||
const result = await this._channel.stream();
|
||||
const stream = import_stream.Stream.from(result.stream);
|
||||
return stream.stream();
|
||||
}
|
||||
async readIntoBuffer() {
|
||||
const stream = await this.createReadStream();
|
||||
return await new Promise((resolve, reject) => {
|
||||
const chunks = [];
|
||||
stream.on("data", (chunk) => {
|
||||
chunks.push(chunk);
|
||||
});
|
||||
stream.on("end", () => {
|
||||
resolve(Buffer.concat(chunks));
|
||||
});
|
||||
stream.on("error", reject);
|
||||
});
|
||||
}
|
||||
async cancel() {
|
||||
return await this._channel.cancel();
|
||||
}
|
||||
async delete() {
|
||||
return await this._channel.delete();
|
||||
}
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
Artifact
|
||||
});
|
||||
+161
@@ -0,0 +1,161 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var browser_exports = {};
|
||||
__export(browser_exports, {
|
||||
Browser: () => Browser
|
||||
});
|
||||
module.exports = __toCommonJS(browser_exports);
|
||||
var import_artifact = require("./artifact");
|
||||
var import_browserContext = require("./browserContext");
|
||||
var import_cdpSession = require("./cdpSession");
|
||||
var import_channelOwner = require("./channelOwner");
|
||||
var import_errors = require("./errors");
|
||||
var import_events = require("./events");
|
||||
var import_fileUtils = require("./fileUtils");
|
||||
class Browser extends import_channelOwner.ChannelOwner {
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._contexts = /* @__PURE__ */ new Set();
|
||||
this._isConnected = true;
|
||||
this._shouldCloseConnectionOnClose = false;
|
||||
this._options = {};
|
||||
this._name = initializer.name;
|
||||
this._channel.on("context", ({ context }) => this._didCreateContext(import_browserContext.BrowserContext.from(context)));
|
||||
this._channel.on("close", () => this._didClose());
|
||||
this._closedPromise = new Promise((f) => this.once(import_events.Events.Browser.Disconnected, f));
|
||||
}
|
||||
static from(browser) {
|
||||
return browser._object;
|
||||
}
|
||||
browserType() {
|
||||
return this._browserType;
|
||||
}
|
||||
async newContext(options = {}) {
|
||||
return await this._innerNewContext(options, false);
|
||||
}
|
||||
async _newContextForReuse(options = {}) {
|
||||
return await this._innerNewContext(options, true);
|
||||
}
|
||||
async _disconnectFromReusedContext(reason) {
|
||||
const context = [...this._contexts].find((context2) => context2._forReuse);
|
||||
if (!context)
|
||||
return;
|
||||
await this._instrumentation.runBeforeCloseBrowserContext(context);
|
||||
for (const page of context.pages())
|
||||
page._onClose();
|
||||
context._onClose();
|
||||
await this._channel.disconnectFromReusedContext({ reason });
|
||||
}
|
||||
async _innerNewContext(userOptions = {}, forReuse) {
|
||||
const options = this._browserType._playwright.selectors._withSelectorOptions(userOptions);
|
||||
await this._instrumentation.runBeforeCreateBrowserContext(options);
|
||||
const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
|
||||
const response = forReuse ? await this._channel.newContextForReuse(contextOptions) : await this._channel.newContext(contextOptions);
|
||||
const context = import_browserContext.BrowserContext.from(response.context);
|
||||
if (forReuse)
|
||||
context._forReuse = true;
|
||||
if (options.logger)
|
||||
context._logger = options.logger;
|
||||
await context._initializeHarFromOptions(options.recordHar);
|
||||
await this._instrumentation.runAfterCreateBrowserContext(context);
|
||||
return context;
|
||||
}
|
||||
_connectToBrowserType(browserType, browserOptions, logger) {
|
||||
this._browserType = browserType;
|
||||
this._options = browserOptions;
|
||||
this._logger = logger;
|
||||
for (const context of this._contexts)
|
||||
this._setupBrowserContext(context);
|
||||
}
|
||||
_didCreateContext(context) {
|
||||
context._browser = this;
|
||||
this._contexts.add(context);
|
||||
if (this._browserType)
|
||||
this._setupBrowserContext(context);
|
||||
}
|
||||
_setupBrowserContext(context) {
|
||||
context._logger = this._logger;
|
||||
context.tracing._tracesDir = this._options.tracesDir;
|
||||
this._browserType._contexts.add(context);
|
||||
this._browserType._playwright.selectors._contextsForSelectors.add(context);
|
||||
context.setDefaultTimeout(this._browserType._playwright._defaultContextTimeout);
|
||||
context.setDefaultNavigationTimeout(this._browserType._playwright._defaultContextNavigationTimeout);
|
||||
}
|
||||
contexts() {
|
||||
return [...this._contexts];
|
||||
}
|
||||
version() {
|
||||
return this._initializer.version;
|
||||
}
|
||||
async newPage(options = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
const context = await this.newContext(options);
|
||||
const page = await context.newPage();
|
||||
page._ownedContext = context;
|
||||
context._ownerPage = page;
|
||||
return page;
|
||||
}, { title: "Create page" });
|
||||
}
|
||||
isConnected() {
|
||||
return this._isConnected;
|
||||
}
|
||||
async newBrowserCDPSession() {
|
||||
return import_cdpSession.CDPSession.from((await this._channel.newBrowserCDPSession()).session);
|
||||
}
|
||||
async startTracing(page, options = {}) {
|
||||
this._path = options.path;
|
||||
await this._channel.startTracing({ ...options, page: page ? page._channel : void 0 });
|
||||
}
|
||||
async stopTracing() {
|
||||
const artifact = import_artifact.Artifact.from((await this._channel.stopTracing()).artifact);
|
||||
const buffer = await artifact.readIntoBuffer();
|
||||
await artifact.delete();
|
||||
if (this._path) {
|
||||
await (0, import_fileUtils.mkdirIfNeeded)(this._platform, this._path);
|
||||
await this._platform.fs().promises.writeFile(this._path, buffer);
|
||||
this._path = void 0;
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
async [Symbol.asyncDispose]() {
|
||||
await this.close();
|
||||
}
|
||||
async close(options = {}) {
|
||||
this._closeReason = options.reason;
|
||||
try {
|
||||
if (this._shouldCloseConnectionOnClose)
|
||||
this._connection.close();
|
||||
else
|
||||
await this._channel.close(options);
|
||||
await this._closedPromise;
|
||||
} catch (e) {
|
||||
if ((0, import_errors.isTargetClosedError)(e))
|
||||
return;
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
_didClose() {
|
||||
this._isConnected = false;
|
||||
this.emit(import_events.Events.Browser.Disconnected, this);
|
||||
}
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
Browser
|
||||
});
|
||||
+582
@@ -0,0 +1,582 @@
|
||||
"use strict";
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var browserContext_exports = {};
|
||||
__export(browserContext_exports, {
|
||||
BrowserContext: () => BrowserContext,
|
||||
prepareBrowserContextParams: () => prepareBrowserContextParams,
|
||||
toClientCertificatesProtocol: () => toClientCertificatesProtocol
|
||||
});
|
||||
module.exports = __toCommonJS(browserContext_exports);
|
||||
var import_artifact = require("./artifact");
|
||||
var import_cdpSession = require("./cdpSession");
|
||||
var import_channelOwner = require("./channelOwner");
|
||||
var import_clientHelper = require("./clientHelper");
|
||||
var import_clock = require("./clock");
|
||||
var import_consoleMessage = require("./consoleMessage");
|
||||
var import_dialog = require("./dialog");
|
||||
var import_errors = require("./errors");
|
||||
var import_events = require("./events");
|
||||
var import_fetch = require("./fetch");
|
||||
var import_frame = require("./frame");
|
||||
var import_harRouter = require("./harRouter");
|
||||
var network = __toESM(require("./network"));
|
||||
var import_page = require("./page");
|
||||
var import_tracing = require("./tracing");
|
||||
var import_waiter = require("./waiter");
|
||||
var import_webError = require("./webError");
|
||||
var import_worker = require("./worker");
|
||||
var import_timeoutSettings = require("./timeoutSettings");
|
||||
var import_fileUtils = require("./fileUtils");
|
||||
var import_headers = require("../utils/isomorphic/headers");
|
||||
var import_urlMatch = require("../utils/isomorphic/urlMatch");
|
||||
var import_rtti = require("../utils/isomorphic/rtti");
|
||||
var import_stackTrace = require("../utils/isomorphic/stackTrace");
|
||||
class BrowserContext extends import_channelOwner.ChannelOwner {
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._pages = /* @__PURE__ */ new Set();
|
||||
this._routes = [];
|
||||
this._webSocketRoutes = [];
|
||||
// Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
|
||||
this._browser = null;
|
||||
this._bindings = /* @__PURE__ */ new Map();
|
||||
this._forReuse = false;
|
||||
this._serviceWorkers = /* @__PURE__ */ new Set();
|
||||
this._harRecorders = /* @__PURE__ */ new Map();
|
||||
this._closingStatus = "none";
|
||||
this._harRouters = [];
|
||||
this._options = initializer.options;
|
||||
this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
|
||||
this.tracing = import_tracing.Tracing.from(initializer.tracing);
|
||||
this.request = import_fetch.APIRequestContext.from(initializer.requestContext);
|
||||
this.request._timeoutSettings = this._timeoutSettings;
|
||||
this.request._checkUrlAllowed = (url) => this._checkUrlAllowed(url);
|
||||
this.clock = new import_clock.Clock(this);
|
||||
this._channel.on("bindingCall", ({ binding }) => this._onBinding(import_page.BindingCall.from(binding)));
|
||||
this._channel.on("close", () => this._onClose());
|
||||
this._channel.on("page", ({ page }) => this._onPage(import_page.Page.from(page)));
|
||||
this._channel.on("route", ({ route }) => this._onRoute(network.Route.from(route)));
|
||||
this._channel.on("webSocketRoute", ({ webSocketRoute }) => this._onWebSocketRoute(network.WebSocketRoute.from(webSocketRoute)));
|
||||
this._channel.on("serviceWorker", ({ worker }) => {
|
||||
const serviceWorker = import_worker.Worker.from(worker);
|
||||
serviceWorker._context = this;
|
||||
this._serviceWorkers.add(serviceWorker);
|
||||
this.emit(import_events.Events.BrowserContext.ServiceWorker, serviceWorker);
|
||||
});
|
||||
this._channel.on("console", (event) => {
|
||||
const worker = import_worker.Worker.fromNullable(event.worker);
|
||||
const page = import_page.Page.fromNullable(event.page);
|
||||
const consoleMessage = new import_consoleMessage.ConsoleMessage(this._platform, event, page, worker);
|
||||
worker?.emit(import_events.Events.Worker.Console, consoleMessage);
|
||||
page?.emit(import_events.Events.Page.Console, consoleMessage);
|
||||
if (worker && this._serviceWorkers.has(worker)) {
|
||||
const scope = this._serviceWorkerScope(worker);
|
||||
for (const page2 of this._pages) {
|
||||
if (scope && page2.url().startsWith(scope))
|
||||
page2.emit(import_events.Events.Page.Console, consoleMessage);
|
||||
}
|
||||
}
|
||||
this.emit(import_events.Events.BrowserContext.Console, consoleMessage);
|
||||
});
|
||||
this._channel.on("pageError", ({ error, page }) => {
|
||||
const pageObject = import_page.Page.from(page);
|
||||
const parsedError = (0, import_errors.parseError)(error);
|
||||
this.emit(import_events.Events.BrowserContext.WebError, new import_webError.WebError(pageObject, parsedError));
|
||||
if (pageObject)
|
||||
pageObject.emit(import_events.Events.Page.PageError, parsedError);
|
||||
});
|
||||
this._channel.on("dialog", ({ dialog }) => {
|
||||
const dialogObject = import_dialog.Dialog.from(dialog);
|
||||
let hasListeners = this.emit(import_events.Events.BrowserContext.Dialog, dialogObject);
|
||||
const page = dialogObject.page();
|
||||
if (page)
|
||||
hasListeners = page.emit(import_events.Events.Page.Dialog, dialogObject) || hasListeners;
|
||||
if (!hasListeners) {
|
||||
if (dialogObject.type() === "beforeunload")
|
||||
dialog.accept({}).catch(() => {
|
||||
});
|
||||
else
|
||||
dialog.dismiss().catch(() => {
|
||||
});
|
||||
}
|
||||
});
|
||||
this._channel.on("request", ({ request, page }) => this._onRequest(network.Request.from(request), import_page.Page.fromNullable(page)));
|
||||
this._channel.on("requestFailed", ({ request, failureText, responseEndTiming, page }) => this._onRequestFailed(network.Request.from(request), responseEndTiming, failureText, import_page.Page.fromNullable(page)));
|
||||
this._channel.on("requestFinished", (params) => this._onRequestFinished(params));
|
||||
this._channel.on("response", ({ response, page }) => this._onResponse(network.Response.from(response), import_page.Page.fromNullable(page)));
|
||||
this._channel.on("recorderEvent", ({ event, data, page, code }) => {
|
||||
if (event === "actionAdded")
|
||||
this._onRecorderEventSink?.actionAdded?.(import_page.Page.from(page), data, code);
|
||||
else if (event === "actionUpdated")
|
||||
this._onRecorderEventSink?.actionUpdated?.(import_page.Page.from(page), data, code);
|
||||
else if (event === "signalAdded")
|
||||
this._onRecorderEventSink?.signalAdded?.(import_page.Page.from(page), data);
|
||||
});
|
||||
this._closedPromise = new Promise((f) => this.once(import_events.Events.BrowserContext.Close, f));
|
||||
this._setEventToSubscriptionMapping(/* @__PURE__ */ new Map([
|
||||
[import_events.Events.BrowserContext.Console, "console"],
|
||||
[import_events.Events.BrowserContext.Dialog, "dialog"],
|
||||
[import_events.Events.BrowserContext.Request, "request"],
|
||||
[import_events.Events.BrowserContext.Response, "response"],
|
||||
[import_events.Events.BrowserContext.RequestFinished, "requestFinished"],
|
||||
[import_events.Events.BrowserContext.RequestFailed, "requestFailed"]
|
||||
]));
|
||||
}
|
||||
static from(context) {
|
||||
return context._object;
|
||||
}
|
||||
static fromNullable(context) {
|
||||
return context ? BrowserContext.from(context) : null;
|
||||
}
|
||||
async _initializeHarFromOptions(recordHar) {
|
||||
if (!recordHar)
|
||||
return;
|
||||
const defaultContent = recordHar.path.endsWith(".zip") ? "attach" : "embed";
|
||||
await this._recordIntoHAR(recordHar.path, null, {
|
||||
url: recordHar.urlFilter,
|
||||
updateContent: recordHar.content ?? (recordHar.omitContent ? "omit" : defaultContent),
|
||||
updateMode: recordHar.mode ?? "full"
|
||||
});
|
||||
}
|
||||
_onPage(page) {
|
||||
this._pages.add(page);
|
||||
this.emit(import_events.Events.BrowserContext.Page, page);
|
||||
if (page._opener && !page._opener.isClosed())
|
||||
page._opener.emit(import_events.Events.Page.Popup, page);
|
||||
}
|
||||
_onRequest(request, page) {
|
||||
this.emit(import_events.Events.BrowserContext.Request, request);
|
||||
if (page)
|
||||
page.emit(import_events.Events.Page.Request, request);
|
||||
}
|
||||
_onResponse(response, page) {
|
||||
this.emit(import_events.Events.BrowserContext.Response, response);
|
||||
if (page)
|
||||
page.emit(import_events.Events.Page.Response, response);
|
||||
}
|
||||
_onRequestFailed(request, responseEndTiming, failureText, page) {
|
||||
request._failureText = failureText || null;
|
||||
request._setResponseEndTiming(responseEndTiming);
|
||||
this.emit(import_events.Events.BrowserContext.RequestFailed, request);
|
||||
if (page)
|
||||
page.emit(import_events.Events.Page.RequestFailed, request);
|
||||
}
|
||||
_onRequestFinished(params) {
|
||||
const { responseEndTiming } = params;
|
||||
const request = network.Request.from(params.request);
|
||||
const response = network.Response.fromNullable(params.response);
|
||||
const page = import_page.Page.fromNullable(params.page);
|
||||
request._setResponseEndTiming(responseEndTiming);
|
||||
this.emit(import_events.Events.BrowserContext.RequestFinished, request);
|
||||
if (page)
|
||||
page.emit(import_events.Events.Page.RequestFinished, request);
|
||||
if (response)
|
||||
response._finishedPromise.resolve(null);
|
||||
}
|
||||
async _onRoute(route) {
|
||||
route._context = this;
|
||||
const page = route.request()._safePage();
|
||||
const routeHandlers = this._routes.slice();
|
||||
for (const routeHandler of routeHandlers) {
|
||||
if (page?._closeWasCalled || this._closingStatus !== "none")
|
||||
return;
|
||||
if (!routeHandler.matches(route.request().url()))
|
||||
continue;
|
||||
const index = this._routes.indexOf(routeHandler);
|
||||
if (index === -1)
|
||||
continue;
|
||||
if (routeHandler.willExpire())
|
||||
this._routes.splice(index, 1);
|
||||
const handled = await routeHandler.handle(route);
|
||||
if (!this._routes.length)
|
||||
this._updateInterceptionPatterns({ internal: true }).catch(() => {
|
||||
});
|
||||
if (handled)
|
||||
return;
|
||||
}
|
||||
await route._innerContinue(
|
||||
true
|
||||
/* isFallback */
|
||||
).catch(() => {
|
||||
});
|
||||
}
|
||||
async _onWebSocketRoute(webSocketRoute) {
|
||||
const routeHandler = this._webSocketRoutes.find((route) => route.matches(webSocketRoute.url()));
|
||||
if (routeHandler)
|
||||
await routeHandler.handle(webSocketRoute);
|
||||
else
|
||||
webSocketRoute.connectToServer();
|
||||
}
|
||||
async _onBinding(bindingCall) {
|
||||
const func = this._bindings.get(bindingCall._initializer.name);
|
||||
if (!func)
|
||||
return;
|
||||
await bindingCall.call(func);
|
||||
}
|
||||
_serviceWorkerScope(serviceWorker) {
|
||||
try {
|
||||
let url = new URL(".", serviceWorker.url()).href;
|
||||
if (!url.endsWith("/"))
|
||||
url += "/";
|
||||
return url;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
setDefaultNavigationTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultNavigationTimeout(timeout);
|
||||
}
|
||||
setDefaultTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultTimeout(timeout);
|
||||
}
|
||||
browser() {
|
||||
return this._browser;
|
||||
}
|
||||
pages() {
|
||||
return [...this._pages];
|
||||
}
|
||||
async newPage() {
|
||||
if (this._ownerPage)
|
||||
throw new Error("Please use browser.newContext()");
|
||||
return import_page.Page.from((await this._channel.newPage()).page);
|
||||
}
|
||||
async cookies(urls) {
|
||||
if (!urls)
|
||||
urls = [];
|
||||
if (urls && typeof urls === "string")
|
||||
urls = [urls];
|
||||
return (await this._channel.cookies({ urls })).cookies;
|
||||
}
|
||||
async addCookies(cookies) {
|
||||
await this._channel.addCookies({ cookies });
|
||||
}
|
||||
async clearCookies(options = {}) {
|
||||
await this._channel.clearCookies({
|
||||
name: (0, import_rtti.isString)(options.name) ? options.name : void 0,
|
||||
nameRegexSource: (0, import_rtti.isRegExp)(options.name) ? options.name.source : void 0,
|
||||
nameRegexFlags: (0, import_rtti.isRegExp)(options.name) ? options.name.flags : void 0,
|
||||
domain: (0, import_rtti.isString)(options.domain) ? options.domain : void 0,
|
||||
domainRegexSource: (0, import_rtti.isRegExp)(options.domain) ? options.domain.source : void 0,
|
||||
domainRegexFlags: (0, import_rtti.isRegExp)(options.domain) ? options.domain.flags : void 0,
|
||||
path: (0, import_rtti.isString)(options.path) ? options.path : void 0,
|
||||
pathRegexSource: (0, import_rtti.isRegExp)(options.path) ? options.path.source : void 0,
|
||||
pathRegexFlags: (0, import_rtti.isRegExp)(options.path) ? options.path.flags : void 0
|
||||
});
|
||||
}
|
||||
async grantPermissions(permissions, options) {
|
||||
await this._channel.grantPermissions({ permissions, ...options });
|
||||
}
|
||||
async clearPermissions() {
|
||||
await this._channel.clearPermissions();
|
||||
}
|
||||
async setGeolocation(geolocation) {
|
||||
await this._channel.setGeolocation({ geolocation: geolocation || void 0 });
|
||||
}
|
||||
async setExtraHTTPHeaders(headers) {
|
||||
network.validateHeaders(headers);
|
||||
await this._channel.setExtraHTTPHeaders({ headers: (0, import_headers.headersObjectToArray)(headers) });
|
||||
}
|
||||
async setOffline(offline) {
|
||||
await this._channel.setOffline({ offline });
|
||||
}
|
||||
async setHTTPCredentials(httpCredentials) {
|
||||
await this._channel.setHTTPCredentials({ httpCredentials: httpCredentials || void 0 });
|
||||
}
|
||||
async addInitScript(script, arg) {
|
||||
const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, arg);
|
||||
await this._channel.addInitScript({ source });
|
||||
}
|
||||
async exposeBinding(name, callback, options = {}) {
|
||||
await this._channel.exposeBinding({ name, needsHandle: options.handle });
|
||||
this._bindings.set(name, callback);
|
||||
}
|
||||
async exposeFunction(name, callback) {
|
||||
await this._channel.exposeBinding({ name });
|
||||
const binding = (source, ...args) => callback(...args);
|
||||
this._bindings.set(name, binding);
|
||||
}
|
||||
async route(url, handler, options = {}) {
|
||||
this._routes.unshift(new network.RouteHandler(this._platform, this._options.baseURL, url, handler, options.times));
|
||||
await this._updateInterceptionPatterns({ title: "Route requests" });
|
||||
}
|
||||
async routeWebSocket(url, handler) {
|
||||
this._webSocketRoutes.unshift(new network.WebSocketRouteHandler(this._options.baseURL, url, handler));
|
||||
await this._updateWebSocketInterceptionPatterns({ title: "Route WebSockets" });
|
||||
}
|
||||
async _recordIntoHAR(har, page, options = {}) {
|
||||
const { harId } = await this._channel.harStart({
|
||||
page: page?._channel,
|
||||
options: {
|
||||
zip: har.endsWith(".zip"),
|
||||
content: options.updateContent ?? "attach",
|
||||
urlGlob: (0, import_rtti.isString)(options.url) ? options.url : void 0,
|
||||
urlRegexSource: (0, import_rtti.isRegExp)(options.url) ? options.url.source : void 0,
|
||||
urlRegexFlags: (0, import_rtti.isRegExp)(options.url) ? options.url.flags : void 0,
|
||||
mode: options.updateMode ?? "minimal"
|
||||
}
|
||||
});
|
||||
this._harRecorders.set(harId, { path: har, content: options.updateContent ?? "attach" });
|
||||
}
|
||||
async routeFromHAR(har, options = {}) {
|
||||
const localUtils = this._connection.localUtils();
|
||||
if (!localUtils)
|
||||
throw new Error("Route from har is not supported in thin clients");
|
||||
if (options.update) {
|
||||
await this._recordIntoHAR(har, null, options);
|
||||
return;
|
||||
}
|
||||
const harRouter = await import_harRouter.HarRouter.create(localUtils, har, options.notFound || "abort", { urlMatch: options.url });
|
||||
this._harRouters.push(harRouter);
|
||||
await harRouter.addContextRoute(this);
|
||||
}
|
||||
_disposeHarRouters() {
|
||||
this._harRouters.forEach((router) => router.dispose());
|
||||
this._harRouters = [];
|
||||
}
|
||||
async unrouteAll(options) {
|
||||
await this._unrouteInternal(this._routes, [], options?.behavior);
|
||||
this._disposeHarRouters();
|
||||
}
|
||||
async unroute(url, handler) {
|
||||
const removed = [];
|
||||
const remaining = [];
|
||||
for (const route of this._routes) {
|
||||
if ((0, import_urlMatch.urlMatchesEqual)(route.url, url) && (!handler || route.handler === handler))
|
||||
removed.push(route);
|
||||
else
|
||||
remaining.push(route);
|
||||
}
|
||||
await this._unrouteInternal(removed, remaining, "default");
|
||||
}
|
||||
async _unrouteInternal(removed, remaining, behavior) {
|
||||
this._routes = remaining;
|
||||
if (behavior && behavior !== "default") {
|
||||
const promises = removed.map((routeHandler) => routeHandler.stop(behavior));
|
||||
await Promise.all(promises);
|
||||
}
|
||||
await this._updateInterceptionPatterns({ title: "Unroute requests" });
|
||||
}
|
||||
async _updateInterceptionPatterns(options) {
|
||||
const patterns = network.RouteHandler.prepareInterceptionPatterns(this._routes);
|
||||
await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }), options);
|
||||
}
|
||||
async _updateWebSocketInterceptionPatterns(options) {
|
||||
const patterns = network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
|
||||
await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }), options);
|
||||
}
|
||||
_effectiveCloseReason() {
|
||||
return this._closeReason || this._browser?._closeReason;
|
||||
}
|
||||
async waitForEvent(event, optionsOrPredicate = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
|
||||
const predicate = typeof optionsOrPredicate === "function" ? optionsOrPredicate : optionsOrPredicate.predicate;
|
||||
const waiter = import_waiter.Waiter.createForEvent(this, event);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
|
||||
if (event !== import_events.Events.BrowserContext.Close)
|
||||
waiter.rejectOnEvent(this, import_events.Events.BrowserContext.Close, () => new import_errors.TargetClosedError(this._effectiveCloseReason()));
|
||||
const result = await waiter.waitForEvent(this, event, predicate);
|
||||
waiter.dispose();
|
||||
return result;
|
||||
});
|
||||
}
|
||||
async storageState(options = {}) {
|
||||
const state = await this._channel.storageState({ indexedDB: options.indexedDB });
|
||||
if (options.path) {
|
||||
await (0, import_fileUtils.mkdirIfNeeded)(this._platform, options.path);
|
||||
await this._platform.fs().promises.writeFile(options.path, JSON.stringify(state, void 0, 2), "utf8");
|
||||
}
|
||||
return state;
|
||||
}
|
||||
backgroundPages() {
|
||||
return [];
|
||||
}
|
||||
serviceWorkers() {
|
||||
return [...this._serviceWorkers];
|
||||
}
|
||||
async newCDPSession(page) {
|
||||
if (!(page instanceof import_page.Page) && !(page instanceof import_frame.Frame))
|
||||
throw new Error("page: expected Page or Frame");
|
||||
const result = await this._channel.newCDPSession(page instanceof import_page.Page ? { page: page._channel } : { frame: page._channel });
|
||||
return import_cdpSession.CDPSession.from(result.session);
|
||||
}
|
||||
_onClose() {
|
||||
this._closingStatus = "closed";
|
||||
this._browser?._contexts.delete(this);
|
||||
this._browser?._browserType._contexts.delete(this);
|
||||
this._browser?._browserType._playwright.selectors._contextsForSelectors.delete(this);
|
||||
this._disposeHarRouters();
|
||||
this.tracing._resetStackCounter();
|
||||
this.emit(import_events.Events.BrowserContext.Close, this);
|
||||
}
|
||||
async [Symbol.asyncDispose]() {
|
||||
await this.close();
|
||||
}
|
||||
async close(options = {}) {
|
||||
if (this._closingStatus !== "none")
|
||||
return;
|
||||
this._closeReason = options.reason;
|
||||
this._closingStatus = "closing";
|
||||
await this.request.dispose(options);
|
||||
await this._instrumentation.runBeforeCloseBrowserContext(this);
|
||||
await this._wrapApiCall(async () => {
|
||||
for (const [harId, harParams] of this._harRecorders) {
|
||||
const har = await this._channel.harExport({ harId });
|
||||
const artifact = import_artifact.Artifact.from(har.artifact);
|
||||
const isCompressed = harParams.content === "attach" || harParams.path.endsWith(".zip");
|
||||
const needCompressed = harParams.path.endsWith(".zip");
|
||||
if (isCompressed && !needCompressed) {
|
||||
const localUtils = this._connection.localUtils();
|
||||
if (!localUtils)
|
||||
throw new Error("Uncompressed har is not supported in thin clients");
|
||||
await artifact.saveAs(harParams.path + ".tmp");
|
||||
await localUtils.harUnzip({ zipFile: harParams.path + ".tmp", harFile: harParams.path });
|
||||
} else {
|
||||
await artifact.saveAs(harParams.path);
|
||||
}
|
||||
await artifact.delete();
|
||||
}
|
||||
}, { internal: true });
|
||||
await this._channel.close(options);
|
||||
await this._closedPromise;
|
||||
}
|
||||
async _enableRecorder(params, eventSink) {
|
||||
if (eventSink)
|
||||
this._onRecorderEventSink = eventSink;
|
||||
await this._channel.enableRecorder(params);
|
||||
}
|
||||
async _disableRecorder() {
|
||||
this._onRecorderEventSink = void 0;
|
||||
await this._channel.disableRecorder();
|
||||
}
|
||||
async _exposeConsoleApi() {
|
||||
await this._channel.exposeConsoleApi();
|
||||
}
|
||||
_setAllowedProtocols(protocols) {
|
||||
this._allowedProtocols = protocols;
|
||||
}
|
||||
_checkUrlAllowed(url) {
|
||||
if (!this._allowedProtocols)
|
||||
return;
|
||||
let parsedURL;
|
||||
try {
|
||||
parsedURL = new URL(url);
|
||||
} catch (e) {
|
||||
throw new Error(`Access to ${url} is blocked. Invalid URL: ${e.message}`);
|
||||
}
|
||||
if (!this._allowedProtocols.includes(parsedURL.protocol))
|
||||
throw new Error(`Access to "${parsedURL.protocol}" URL is blocked. Allowed protocols: ${this._allowedProtocols.join(", ")}. Attempted URL: ${url}`);
|
||||
}
|
||||
_setAllowedDirectories(rootDirectories) {
|
||||
this._allowedDirectories = rootDirectories;
|
||||
}
|
||||
_checkFileAccess(filePath) {
|
||||
if (!this._allowedDirectories)
|
||||
return;
|
||||
const path = this._platform.path().resolve(filePath);
|
||||
const isInsideDir = (container, child) => {
|
||||
const path2 = this._platform.path();
|
||||
const rel = path2.relative(container, child);
|
||||
return !!rel && !rel.startsWith("..") && !path2.isAbsolute(rel);
|
||||
};
|
||||
if (this._allowedDirectories.some((root) => isInsideDir(root, path)))
|
||||
return;
|
||||
throw new Error(`File access denied: ${filePath} is outside allowed roots. Allowed roots: ${this._allowedDirectories.length ? this._allowedDirectories.join(", ") : "none"}`);
|
||||
}
|
||||
}
|
||||
async function prepareStorageState(platform, storageState) {
|
||||
if (typeof storageState !== "string")
|
||||
return storageState;
|
||||
try {
|
||||
return JSON.parse(await platform.fs().promises.readFile(storageState, "utf8"));
|
||||
} catch (e) {
|
||||
(0, import_stackTrace.rewriteErrorMessage)(e, `Error reading storage state from ${storageState}:
|
||||
` + e.message);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
async function prepareBrowserContextParams(platform, options) {
|
||||
if (options.videoSize && !options.videosPath)
|
||||
throw new Error(`"videoSize" option requires "videosPath" to be specified`);
|
||||
if (options.extraHTTPHeaders)
|
||||
network.validateHeaders(options.extraHTTPHeaders);
|
||||
const contextParams = {
|
||||
...options,
|
||||
viewport: options.viewport === null ? void 0 : options.viewport,
|
||||
noDefaultViewport: options.viewport === null,
|
||||
extraHTTPHeaders: options.extraHTTPHeaders ? (0, import_headers.headersObjectToArray)(options.extraHTTPHeaders) : void 0,
|
||||
storageState: options.storageState ? await prepareStorageState(platform, options.storageState) : void 0,
|
||||
serviceWorkers: options.serviceWorkers,
|
||||
colorScheme: options.colorScheme === null ? "no-override" : options.colorScheme,
|
||||
reducedMotion: options.reducedMotion === null ? "no-override" : options.reducedMotion,
|
||||
forcedColors: options.forcedColors === null ? "no-override" : options.forcedColors,
|
||||
contrast: options.contrast === null ? "no-override" : options.contrast,
|
||||
acceptDownloads: toAcceptDownloadsProtocol(options.acceptDownloads),
|
||||
clientCertificates: await toClientCertificatesProtocol(platform, options.clientCertificates)
|
||||
};
|
||||
if (!contextParams.recordVideo && options.videosPath) {
|
||||
contextParams.recordVideo = {
|
||||
dir: options.videosPath,
|
||||
size: options.videoSize
|
||||
};
|
||||
}
|
||||
if (contextParams.recordVideo && contextParams.recordVideo.dir)
|
||||
contextParams.recordVideo.dir = platform.path().resolve(contextParams.recordVideo.dir);
|
||||
return contextParams;
|
||||
}
|
||||
function toAcceptDownloadsProtocol(acceptDownloads) {
|
||||
if (acceptDownloads === void 0)
|
||||
return void 0;
|
||||
if (acceptDownloads)
|
||||
return "accept";
|
||||
return "deny";
|
||||
}
|
||||
async function toClientCertificatesProtocol(platform, certs) {
|
||||
if (!certs)
|
||||
return void 0;
|
||||
const bufferizeContent = async (value, path) => {
|
||||
if (value)
|
||||
return value;
|
||||
if (path)
|
||||
return await platform.fs().promises.readFile(path);
|
||||
};
|
||||
return await Promise.all(certs.map(async (cert) => ({
|
||||
origin: cert.origin,
|
||||
cert: await bufferizeContent(cert.cert, cert.certPath),
|
||||
key: await bufferizeContent(cert.key, cert.keyPath),
|
||||
pfx: await bufferizeContent(cert.pfx, cert.pfxPath),
|
||||
passphrase: cert.passphrase
|
||||
})));
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
BrowserContext,
|
||||
prepareBrowserContextParams,
|
||||
toClientCertificatesProtocol
|
||||
});
|
||||
+185
@@ -0,0 +1,185 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var browserType_exports = {};
|
||||
__export(browserType_exports, {
|
||||
BrowserType: () => BrowserType
|
||||
});
|
||||
module.exports = __toCommonJS(browserType_exports);
|
||||
var import_browser = require("./browser");
|
||||
var import_browserContext = require("./browserContext");
|
||||
var import_channelOwner = require("./channelOwner");
|
||||
var import_clientHelper = require("./clientHelper");
|
||||
var import_events = require("./events");
|
||||
var import_assert = require("../utils/isomorphic/assert");
|
||||
var import_headers = require("../utils/isomorphic/headers");
|
||||
var import_time = require("../utils/isomorphic/time");
|
||||
var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
|
||||
var import_webSocket = require("./webSocket");
|
||||
var import_timeoutSettings = require("./timeoutSettings");
|
||||
class BrowserType extends import_channelOwner.ChannelOwner {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._contexts = /* @__PURE__ */ new Set();
|
||||
}
|
||||
static from(browserType) {
|
||||
return browserType._object;
|
||||
}
|
||||
executablePath() {
|
||||
if (!this._initializer.executablePath)
|
||||
throw new Error("Browser is not supported on current platform");
|
||||
return this._initializer.executablePath;
|
||||
}
|
||||
name() {
|
||||
return this._initializer.name;
|
||||
}
|
||||
async launch(options = {}) {
|
||||
(0, import_assert.assert)(!options.userDataDir, "userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead");
|
||||
(0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
|
||||
const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
|
||||
options = { ...this._playwright._defaultLaunchOptions, ...options };
|
||||
const launchOptions = {
|
||||
...options,
|
||||
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
|
||||
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
|
||||
env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
|
||||
timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
|
||||
};
|
||||
return await this._wrapApiCall(async () => {
|
||||
const browser = import_browser.Browser.from((await this._channel.launch(launchOptions)).browser);
|
||||
browser._connectToBrowserType(this, options, logger);
|
||||
return browser;
|
||||
});
|
||||
}
|
||||
async launchServer(options = {}) {
|
||||
if (!this._serverLauncher)
|
||||
throw new Error("Launching server is not supported");
|
||||
options = { ...this._playwright._defaultLaunchOptions, ...options };
|
||||
return await this._serverLauncher.launchServer(options);
|
||||
}
|
||||
async launchPersistentContext(userDataDir, options = {}) {
|
||||
(0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
|
||||
options = this._playwright.selectors._withSelectorOptions({
|
||||
...this._playwright._defaultLaunchOptions,
|
||||
...options
|
||||
});
|
||||
await this._instrumentation.runBeforeCreateBrowserContext(options);
|
||||
const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
|
||||
const contextParams = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
|
||||
const persistentParams = {
|
||||
...contextParams,
|
||||
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
|
||||
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
|
||||
env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
|
||||
channel: options.channel,
|
||||
userDataDir: this._platform.path().isAbsolute(userDataDir) || !userDataDir ? userDataDir : this._platform.path().resolve(userDataDir),
|
||||
timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
|
||||
};
|
||||
const context = await this._wrapApiCall(async () => {
|
||||
const result = await this._channel.launchPersistentContext(persistentParams);
|
||||
const browser = import_browser.Browser.from(result.browser);
|
||||
browser._connectToBrowserType(this, options, logger);
|
||||
const context2 = import_browserContext.BrowserContext.from(result.context);
|
||||
await context2._initializeHarFromOptions(options.recordHar);
|
||||
return context2;
|
||||
});
|
||||
await this._instrumentation.runAfterCreateBrowserContext(context);
|
||||
return context;
|
||||
}
|
||||
async connect(optionsOrWsEndpoint, options) {
|
||||
if (typeof optionsOrWsEndpoint === "string")
|
||||
return await this._connect({ ...options, wsEndpoint: optionsOrWsEndpoint });
|
||||
(0, import_assert.assert)(optionsOrWsEndpoint.wsEndpoint, "options.wsEndpoint is required");
|
||||
return await this._connect(optionsOrWsEndpoint);
|
||||
}
|
||||
async _connect(params) {
|
||||
const logger = params.logger;
|
||||
return await this._wrapApiCall(async () => {
|
||||
const deadline = params.timeout ? (0, import_time.monotonicTime)() + params.timeout : 0;
|
||||
const headers = { "x-playwright-browser": this.name(), ...params.headers };
|
||||
const connectParams = {
|
||||
wsEndpoint: params.wsEndpoint,
|
||||
headers,
|
||||
exposeNetwork: params.exposeNetwork ?? params._exposeNetwork,
|
||||
slowMo: params.slowMo,
|
||||
timeout: params.timeout || 0
|
||||
};
|
||||
if (params.__testHookRedirectPortForwarding)
|
||||
connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
|
||||
const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
|
||||
let browser;
|
||||
connection.on("close", () => {
|
||||
for (const context of browser?.contexts() || []) {
|
||||
for (const page of context.pages())
|
||||
page._onClose();
|
||||
context._onClose();
|
||||
}
|
||||
setTimeout(() => browser?._didClose(), 0);
|
||||
});
|
||||
const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
|
||||
if (params.__testHookBeforeCreateBrowser)
|
||||
await params.__testHookBeforeCreateBrowser();
|
||||
const playwright = await connection.initializePlaywright();
|
||||
if (!playwright._initializer.preLaunchedBrowser) {
|
||||
connection.close();
|
||||
throw new Error("Malformed endpoint. Did you use BrowserType.launchServer method?");
|
||||
}
|
||||
playwright.selectors = this._playwright.selectors;
|
||||
browser = import_browser.Browser.from(playwright._initializer.preLaunchedBrowser);
|
||||
browser._connectToBrowserType(this, {}, logger);
|
||||
browser._shouldCloseConnectionOnClose = true;
|
||||
browser.on(import_events.Events.Browser.Disconnected, () => connection.close());
|
||||
return browser;
|
||||
}, deadline);
|
||||
if (!result.timedOut) {
|
||||
return result.result;
|
||||
} else {
|
||||
connection.close();
|
||||
throw new Error(`Timeout ${params.timeout}ms exceeded`);
|
||||
}
|
||||
});
|
||||
}
|
||||
async connectOverCDP(endpointURLOrOptions, options) {
|
||||
if (typeof endpointURLOrOptions === "string")
|
||||
return await this._connectOverCDP(endpointURLOrOptions, options);
|
||||
const endpointURL = "endpointURL" in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
|
||||
(0, import_assert.assert)(endpointURL, "Cannot connect over CDP without wsEndpoint.");
|
||||
return await this.connectOverCDP(endpointURL, endpointURLOrOptions);
|
||||
}
|
||||
async _connectOverCDP(endpointURL, params = {}) {
|
||||
if (this.name() !== "chromium")
|
||||
throw new Error("Connecting over CDP is only supported in Chromium.");
|
||||
const headers = params.headers ? (0, import_headers.headersObjectToArray)(params.headers) : void 0;
|
||||
const result = await this._channel.connectOverCDP({
|
||||
endpointURL,
|
||||
headers,
|
||||
slowMo: params.slowMo,
|
||||
timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params),
|
||||
isLocal: params.isLocal
|
||||
});
|
||||
const browser = import_browser.Browser.from(result.browser);
|
||||
browser._connectToBrowserType(this, {}, params.logger);
|
||||
if (result.defaultContext)
|
||||
await this._instrumentation.runAfterCreateBrowserContext(import_browserContext.BrowserContext.from(result.defaultContext));
|
||||
return browser;
|
||||
}
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
BrowserType
|
||||
});
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var cdpSession_exports = {};
|
||||
__export(cdpSession_exports, {
|
||||
CDPSession: () => CDPSession
|
||||
});
|
||||
module.exports = __toCommonJS(cdpSession_exports);
|
||||
var import_channelOwner = require("./channelOwner");
|
||||
class CDPSession extends import_channelOwner.ChannelOwner {
|
||||
static from(cdpSession) {
|
||||
return cdpSession._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._channel.on("event", ({ method, params }) => {
|
||||
this.emit(method, params);
|
||||
});
|
||||
this.on = super.on;
|
||||
this.addListener = super.addListener;
|
||||
this.off = super.removeListener;
|
||||
this.removeListener = super.removeListener;
|
||||
this.once = super.once;
|
||||
}
|
||||
async send(method, params) {
|
||||
const result = await this._channel.send({ method, params });
|
||||
return result.result;
|
||||
}
|
||||
async detach() {
|
||||
return await this._channel.detach();
|
||||
}
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
CDPSession
|
||||
});
|
||||
+194
@@ -0,0 +1,194 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var channelOwner_exports = {};
|
||||
__export(channelOwner_exports, {
|
||||
ChannelOwner: () => ChannelOwner
|
||||
});
|
||||
module.exports = __toCommonJS(channelOwner_exports);
|
||||
var import_eventEmitter = require("./eventEmitter");
|
||||
var import_validator = require("../protocol/validator");
|
||||
var import_protocolMetainfo = require("../utils/isomorphic/protocolMetainfo");
|
||||
var import_clientStackTrace = require("./clientStackTrace");
|
||||
var import_stackTrace = require("../utils/isomorphic/stackTrace");
|
||||
class ChannelOwner extends import_eventEmitter.EventEmitter {
|
||||
constructor(parent, type, guid, initializer) {
|
||||
const connection = parent instanceof ChannelOwner ? parent._connection : parent;
|
||||
super(connection._platform);
|
||||
this._objects = /* @__PURE__ */ new Map();
|
||||
this._eventToSubscriptionMapping = /* @__PURE__ */ new Map();
|
||||
this._wasCollected = false;
|
||||
this.setMaxListeners(0);
|
||||
this._connection = connection;
|
||||
this._type = type;
|
||||
this._guid = guid;
|
||||
this._parent = parent instanceof ChannelOwner ? parent : void 0;
|
||||
this._instrumentation = this._connection._instrumentation;
|
||||
this._connection._objects.set(guid, this);
|
||||
if (this._parent) {
|
||||
this._parent._objects.set(guid, this);
|
||||
this._logger = this._parent._logger;
|
||||
}
|
||||
this._channel = this._createChannel(new import_eventEmitter.EventEmitter(connection._platform));
|
||||
this._initializer = initializer;
|
||||
}
|
||||
_setEventToSubscriptionMapping(mapping) {
|
||||
this._eventToSubscriptionMapping = mapping;
|
||||
}
|
||||
_updateSubscription(event, enabled) {
|
||||
const protocolEvent = this._eventToSubscriptionMapping.get(String(event));
|
||||
if (protocolEvent)
|
||||
this._channel.updateSubscription({ event: protocolEvent, enabled }).catch(() => {
|
||||
});
|
||||
}
|
||||
on(event, listener) {
|
||||
if (!this.listenerCount(event))
|
||||
this._updateSubscription(event, true);
|
||||
super.on(event, listener);
|
||||
return this;
|
||||
}
|
||||
addListener(event, listener) {
|
||||
if (!this.listenerCount(event))
|
||||
this._updateSubscription(event, true);
|
||||
super.addListener(event, listener);
|
||||
return this;
|
||||
}
|
||||
prependListener(event, listener) {
|
||||
if (!this.listenerCount(event))
|
||||
this._updateSubscription(event, true);
|
||||
super.prependListener(event, listener);
|
||||
return this;
|
||||
}
|
||||
off(event, listener) {
|
||||
super.off(event, listener);
|
||||
if (!this.listenerCount(event))
|
||||
this._updateSubscription(event, false);
|
||||
return this;
|
||||
}
|
||||
removeListener(event, listener) {
|
||||
super.removeListener(event, listener);
|
||||
if (!this.listenerCount(event))
|
||||
this._updateSubscription(event, false);
|
||||
return this;
|
||||
}
|
||||
_adopt(child) {
|
||||
child._parent._objects.delete(child._guid);
|
||||
this._objects.set(child._guid, child);
|
||||
child._parent = this;
|
||||
}
|
||||
_dispose(reason) {
|
||||
if (this._parent)
|
||||
this._parent._objects.delete(this._guid);
|
||||
this._connection._objects.delete(this._guid);
|
||||
this._wasCollected = reason === "gc";
|
||||
for (const object of [...this._objects.values()])
|
||||
object._dispose(reason);
|
||||
this._objects.clear();
|
||||
}
|
||||
_debugScopeState() {
|
||||
return {
|
||||
_guid: this._guid,
|
||||
objects: Array.from(this._objects.values()).map((o) => o._debugScopeState())
|
||||
};
|
||||
}
|
||||
_validatorToWireContext() {
|
||||
return {
|
||||
tChannelImpl: tChannelImplToWire,
|
||||
binary: this._connection.rawBuffers() ? "buffer" : "toBase64",
|
||||
isUnderTest: () => this._platform.isUnderTest()
|
||||
};
|
||||
}
|
||||
_createChannel(base) {
|
||||
const channel = new Proxy(base, {
|
||||
get: (obj, prop) => {
|
||||
if (typeof prop === "string") {
|
||||
const validator = (0, import_validator.maybeFindValidator)(this._type, prop, "Params");
|
||||
const { internal } = import_protocolMetainfo.methodMetainfo.get(this._type + "." + prop) || {};
|
||||
if (validator) {
|
||||
return async (params) => {
|
||||
return await this._wrapApiCall(async (apiZone) => {
|
||||
const validatedParams = validator(params, "", this._validatorToWireContext());
|
||||
if (!apiZone.internal && !apiZone.reported) {
|
||||
apiZone.reported = true;
|
||||
this._instrumentation.onApiCallBegin(apiZone, { type: this._type, method: prop, params });
|
||||
logApiCall(this._platform, this._logger, `=> ${apiZone.apiName} started`);
|
||||
return await this._connection.sendMessageToServer(this, prop, validatedParams, apiZone);
|
||||
}
|
||||
return await this._connection.sendMessageToServer(this, prop, validatedParams, { internal: true });
|
||||
}, { internal });
|
||||
};
|
||||
}
|
||||
}
|
||||
return obj[prop];
|
||||
}
|
||||
});
|
||||
channel._object = this;
|
||||
return channel;
|
||||
}
|
||||
async _wrapApiCall(func, options) {
|
||||
const logger = this._logger;
|
||||
const existingApiZone = this._platform.zones.current().data();
|
||||
if (existingApiZone)
|
||||
return await func(existingApiZone);
|
||||
const stackTrace = (0, import_clientStackTrace.captureLibraryStackTrace)(this._platform);
|
||||
const apiZone = { title: options?.title, apiName: stackTrace.apiName, frames: stackTrace.frames, internal: options?.internal ?? false, reported: false, userData: void 0, stepId: void 0 };
|
||||
try {
|
||||
const result = await this._platform.zones.current().push(apiZone).run(async () => await func(apiZone));
|
||||
if (!options?.internal) {
|
||||
logApiCall(this._platform, logger, `<= ${apiZone.apiName} succeeded`);
|
||||
this._instrumentation.onApiCallEnd(apiZone);
|
||||
}
|
||||
return result;
|
||||
} catch (e) {
|
||||
const innerError = (this._platform.showInternalStackFrames() || this._platform.isUnderTest()) && e.stack ? "\n<inner error>\n" + e.stack : "";
|
||||
if (apiZone.apiName && !apiZone.apiName.includes("<anonymous>"))
|
||||
e.message = apiZone.apiName + ": " + e.message;
|
||||
const stackFrames = "\n" + (0, import_stackTrace.stringifyStackFrames)(stackTrace.frames).join("\n") + innerError;
|
||||
if (stackFrames.trim())
|
||||
e.stack = e.message + stackFrames;
|
||||
else
|
||||
e.stack = "";
|
||||
if (!options?.internal) {
|
||||
apiZone.error = e;
|
||||
logApiCall(this._platform, logger, `<= ${apiZone.apiName} failed`);
|
||||
this._instrumentation.onApiCallEnd(apiZone);
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
toJSON() {
|
||||
return {
|
||||
_type: this._type,
|
||||
_guid: this._guid
|
||||
};
|
||||
}
|
||||
}
|
||||
function logApiCall(platform, logger, message) {
|
||||
if (logger && logger.isEnabled("api", "info"))
|
||||
logger.log("api", "info", message, [], { color: "cyan" });
|
||||
platform.log("api", message);
|
||||
}
|
||||
function tChannelImplToWire(names, arg, path, context) {
|
||||
if (arg._object instanceof ChannelOwner && (names === "*" || names.includes(arg._object._type)))
|
||||
return { guid: arg._object._guid };
|
||||
throw new import_validator.ValidationError(`${path}: expected channel ${names.toString()}`);
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
ChannelOwner
|
||||
});
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user