playwright-browserstack 1.62.0__py3-none-win_amd64.whl

playwright/_impl/_impl_to_api_mapping.py

@@ -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 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:
+            parameters = inspect.signature(handler).parameters
+            has_varargs = any(
+                parameter.kind == inspect.Parameter.VAR_POSITIONAL
+                for parameter in parameters.values()
+            )
+            arg_count = (
+                len(args)
+                if has_varargs
+                else sum(
+                    parameter.kind
+                    in (
+                        inspect.Parameter.POSITIONAL_ONLY,
+                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    )
+                    for parameter in parameters.values()
+                )
+            )
+            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

playwright/_impl/_input.py

@@ -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()))

playwright/_impl/_js_handle.py

@@ -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", "")

playwright/_impl/_json_pipe.py

@@ -0,0 +1,97 @@
+# 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 logging
+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
+
+_logger = logging.getLogger(__name__)
+
+
+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:
+            # Set the close error before notifying listeners, so a listener
+            # that raises cannot stop callers from observing the reason.
+            if reason and not self.on_error_future.done():
+                self.on_error_future.set_exception(TargetClosedError(reason))
+            try:
+                self.emit("close", reason)
+            except Exception:
+                # Never propagate a listener's exception into _stopped_future:
+                # run() and wait_until_stopped() await it, and
+                # Connection.stop_async() awaits it *before* cleanup(), so
+                # resolving it with an exception would skip cleanup entirely
+                # and surface as an unretrieved exception from the bare
+                # create_task(connection.run()).
+                _logger.exception("Error in JsonPipeTransport close listener")
+            finally:
+                # Guarded because "closed" can arrive more than once (e.g. a
+                # server-initiated close racing request_stop()); an
+                # unguarded set_result raised InvalidStateError, leaving
+                # run() awaiting a future nothing would ever resolve.
+                if not self._stopped_future.done():
+                    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})