microsoft · mxschmitt · Sep 1, 2021 · Aug 30, 2021 · Aug 31, 2021 · Sep 1, 2021
diff --git a/playwright/_impl/_api_structures.py b/playwright/_impl/_api_structures.py
@@ -104,6 +104,14 @@ class ResourceTiming(TypedDict):
     responseEnd: float
 
 
+class RequestSizes(TypedDict):
+    requestBodySize: int
+    requestHeadersSize: int
+    responseBodySize: int
+    responseHeadersSize: int
+    responseTransferSize: int
+
+
 class ViewportSize(TypedDict):
     width: int
     height: int

diff --git a/playwright/_impl/_browser_context.py b/playwright/_impl/_browser_context.py
@@ -19,7 +19,12 @@
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Union, cast
 
-from playwright._impl._api_structures import Cookie, Geolocation, StorageState
+from playwright._impl._api_structures import (
+    Cookie,
+    Geolocation,
+    RequestSizes,
+    StorageState,
+)
 from playwright._impl._api_types import Error
 from playwright._impl._artifact import Artifact
 from playwright._impl._cdp_session import CDPSession
@@ -121,7 +126,7 @@ def __init__(
             lambda params: self._on_request_failed(
                 from_channel(params["request"]),
                 params["responseEndTiming"],
-                params["failureText"],
+                params.get("failureText"),
                 from_nullable_channel(params.get("page")),
             ),
         )
@@ -131,6 +136,7 @@ def __init__(
                 from_channel(params["request"]),
                 params["responseEndTiming"],
                 from_nullable_channel(params.get("page")),
+                params["requestSizes"],
             ),
         )
         self._closed_future: asyncio.Future = asyncio.Future()
@@ -358,10 +364,15 @@ def _on_request_failed(
             page.emit(Page.Events.RequestFailed, request)
 
     def _on_request_finished(
-        self, request: Request, response_end_timing: float, page: Optional[Page]
+        self,
+        request: Request,
+        response_end_timing: float,
+        page: Optional[Page],
+        request_sizes: RequestSizes,
     ) -> None:
         if request._timing:
             request._timing["responseEnd"] = response_end_timing
+        request._sizes = request_sizes
         self.emit(BrowserContext.Events.RequestFinished, request)
         if page:
             page.emit(Page.Events.RequestFinished, request)

diff --git a/playwright/_impl/_connection.py b/playwright/_impl/_connection.py
@@ -241,8 +241,9 @@ def _dispatch(self, msg: ParsedMessagePayload) -> None:
 
         guid = msg["guid"]
         method = msg.get("method")
-        params = msg["params"]
+        params = msg.get("params")
         if method == "__create__":
+            assert params
             parent = self._objects[guid]
             self._create_remote_object(
                 parent, params["type"], params["guid"], params["initializer"]
@@ -251,7 +252,6 @@ def _dispatch(self, msg: ParsedMessagePayload) -> None:
         if method == "__dispose__":
             self._objects[guid]._dispose()
             return
-
         object = self._objects[guid]
         try:
             if self._is_sync:

diff --git a/playwright/_impl/_element_handle.py b/playwright/_impl/_element_handle.py
@@ -213,6 +213,33 @@ async def press(
     ) -> None:
         await self._channel.send("press", locals_to_params(locals()))
 
+    async def set_checked(
+        self,
+        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(
+                position=position,
+                timeout=timeout,
+                force=force,
+                noWaitAfter=noWaitAfter,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                position=position,
+                timeout=timeout,
+                force=force,
+                noWaitAfter=noWaitAfter,
+                trial=trial,
+            )
+
     async def check(
         self,
         position: Position = None,

diff --git a/playwright/_impl/_frame.py b/playwright/_impl/_frame.py
@@ -649,3 +649,35 @@ async def wait_for_function(
 
     async def title(self) -> str:
         return await self._channel.send("title")
+
+    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,
+                noWaitAfter=noWaitAfter,
+                strict=strict,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                noWaitAfter=noWaitAfter,
+                strict=strict,
+                trial=trial,
+            )
diff --git a/playwright/_impl/_locator.py b/playwright/_impl/_locator.py
@@ -438,3 +438,30 @@ async def all_text_contents(
         return await self._frame.eval_on_selector_all(
             self._selector, "ee => ee.map(e => e.textContent || '')"
         )
+
+    async def set_checked(
+        self,
+        checked: bool,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        strict: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+    ) -> None:
+        if checked:
+            await self.check(
+                position=position,
+                timeout=timeout,
+                force=force,
+                noWaitAfter=noWaitAfter,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                position=position,
+                timeout=timeout,
+                force=force,
+                noWaitAfter=noWaitAfter,
+                trial=trial,
+            )
diff --git a/playwright/_impl/_network.py b/playwright/_impl/_network.py
@@ -20,7 +20,12 @@
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union, cast
 from urllib import parse
 
-from playwright._impl._api_structures import RemoteAddr, ResourceTiming, SecurityDetails
+from playwright._impl._api_structures import (
+    RemoteAddr,
+    RequestSizes,
+    ResourceTiming,
+    SecurityDetails,
+)
 from playwright._impl._api_types import Error
 from playwright._impl._connection import (
     ChannelOwner,
@@ -58,6 +63,13 @@ def __init__(
             "responseStart": -1,
             "responseEnd": -1,
         }
+        self._sizes: RequestSizes = {
+            "requestBodySize": 0,
+            "requestHeadersSize": 0,
+            "responseBodySize": 0,
+            "responseHeadersSize": 0,
+            "responseTransferSize": 0,
+        }
         self._headers: Dict[str, str] = parse_headers(self._initializer["headers"])
 
     def __repr__(self) -> str:
@@ -75,6 +87,10 @@ def resource_type(self) -> str:
     def method(self) -> str:
         return self._initializer["method"]
 
+    @property
+    def sizes(self) -> RequestSizes:
+        return self._sizes
+
     @property
     def post_data(self) -> Optional[str]:
         data = self.post_data_buffer

diff --git a/playwright/_impl/_page.py b/playwright/_impl/_page.py
@@ -994,6 +994,38 @@ def expect_worker(
     ) -> EventContextManagerImpl["Worker"]:
         return self.expect_event("worker", predicate, timeout)
 
+    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,
+                noWaitAfter=noWaitAfter,
+                strict=strict,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                noWaitAfter=noWaitAfter,
+                strict=strict,
+                trial=trial,
+            )
+
 
 class Worker(ChannelOwner):
     Events = SimpleNamespace(Close="close")