chore: move value serialization into a shared module

Author: pavelfeldman

playwright/_impl/_assertions.py

@@ -27,9 +27,9 @@
     FrameExpectOptions,
     FrameExpectResult,
 )
-from playwright._impl._js_handle import parse_value
 from playwright._impl._locator import Locator
 from playwright._impl._page import Page
+from playwright._impl._serializers import parse_value
 from playwright._impl._str_utils import escape_regex_flags
 
 _soft_errors: Optional[List[AssertionError]] = None

playwright/_impl/_frame.py

@@ -61,7 +61,6 @@
     Serializable,
     add_source_url_to_script,
     parse_result,
-    parse_value,
     serialize_argument,
 )
 from playwright._impl._locator import (
@@ -78,6 +77,7 @@
     test_id_attribute_name,
 )
 from playwright._impl._network import Response
+from playwright._impl._serializers import parse_value
 from playwright._impl._set_input_files_helpers import convert_input_files
 from playwright._impl._waiter import Waiter
 from playwright._impl._web_mcp import WebMCP

playwright/_impl/_js_handle.py

@@ -12,21 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import base64
-import collections.abc
-import datetime
-import math
-import re
-import struct
-import traceback
+# Upstream: packages/playwright-core/src/client/jsHandle.ts.
+
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Pattern, Union
-from urllib.parse import ParseResult, urlparse, urlunparse
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 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
-from playwright._impl._str_utils import escape_regex_flags, parse_regex_flags
+from playwright._impl._errors import is_target_closed_error
+from playwright._impl._serializers import parse_value, serialize_value
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._element_handle import ElementHandle
@@ -35,21 +28,6 @@
 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
@@ -131,214 +109,17 @@ async def json_value(self) -> Any:
         )
 
 
-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 == 0 and math.copysign(1.0, value) == -1.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 isinstance(value, Pattern):
-        if not isinstance(value.pattern, str):
-            raise Error("Only str patterns are supported.")
-        return {"r": {"p": value.pattern, "f": escape_regex_flags(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:
+    def serialize_handle(value: Any) -> Optional[Dict[str, Any]]:
+        if isinstance(value, JSHandle):
+            handles.append(value._channel)
+            return {"h": len(handles) - 1}
         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 "r" in value:
-            try:
-                return re.compile(value["r"]["p"], parse_regex_flags(value["r"]["f"]))
-            except re.error:
-                # JavaScript-only syntax, e.g. /(?<name>x)/, has no re equivalent.
-                return value
-
-        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
+    value = serialize_value(arg, serialize_handle)
+    return dict(value=value, handles=handles)
 
 
 def parse_result(result: Any) -> Any:

playwright/_impl/_protocol_check.py

@@ -15,6 +15,8 @@
 # Checks each message that the client sends against the protocol spec
 # (_protocol.py). The driver drops parameters that it does not know without an
 # error, so a wrong parameter name in the client is silent without this check.
+# The type checks follow the driver's validator,
+# packages/protocol/src/validatorPrimitives.ts.
 #
 # The check is on when PW_CHECK_PROTOCOL=1; the test suite sets it. It does not
 # raise: it records each violation, and the test suite fails the test that