fix(sync): wrap route callback args in sync class

Author: mxschmitt

README.md

@@ -48,18 +48,15 @@ Playwright is built to automate the broad and growing set of web browser capabil
 This code snippet navigates to whatsmyuseragent.org in Chromium, Firefox and WebKit, and saves 3 screenshots.
 
 ```py
-import asyncio
 from playwright import chromium, firefox, webkit
 
-async def run():
-  for browser_type in [chromium, firefox, webkit]:
-    browser = await browser_type.launch()
-    page = await browser.newPage()
-    await page.goto('http://whatsmyuseragent.org/')
-    await page.screenshot(path=f'example-{browser_type.name}.png')
-    await browser.close()
 
-asyncio.get_event_loop().run_until_complete(run())
+for browser_type in [chromium, firefox, webkit]:
+    browser = browser_type.launch()
+    page = browser.newPage()
+    page.goto("http://whatsmyuseragent.org/")
+    page.screenshot(path=f"example-{browser_type.name}.png")
+    browser.close()
 ```
 
 #### Mobile and geolocation
@@ -96,24 +93,22 @@ asyncio.get_event_loop().run_until_complete(run())
 This code snippet navigates to example.com in Firefox, and executes a script in the page context.
 
 ```py
-import asyncio
 from playwright import firefox
 
-async def run():
-  browser = await firefox.launch()
-  page = await browser.newPage()
-  await page.goto('https://www.example.com/')
-  dimensions = await page.evaluate('''() => {
+browser = firefox.launch()
+page = browser.newPage()
+page.goto("https://www.example.com")
+dimensions = page.evaluate(
+    """() => {
     return {
-      width: document.documentElement.clientWidth,
-      height: document.documentElement.clientHeight,
-      deviceScaleFactor: window.devicePixelRatio
+        width: document.documentElement.clientWidth,
+        height: document.documentElement.clientHeight,
+        deviceScaleFactor: window.devicePixelRatio
     }
-  }''')
-  print(dimensions)
-  await browser.close()
-
-asyncio.get_event_loop().run_until_complete(run())
+}"""
+)
+print(dimensions)
+browser.close()
 ```
 
 #### Intercept network requests

playwright/helper.py

@@ -117,6 +117,21 @@ class FrameNavigatedEvent(TypedDict):
     error: Optional[str]
 
 
+Size = TypedDict("Size", {"width": int, "height": int})
+
+DeviceDescriptor = TypedDict(
+    "DeviceDescriptor",
+    {
+        "userAgent": str,
+        "viewport": Size,
+        "deviceScaleFactor": int,
+        "isMobile": bool,
+        "hasTouch": bool,
+    },
+)
+Devices = Dict[str, DeviceDescriptor]
+
+
 class URLMatcher:
     def __init__(self, match: URLMatch) -> None:
         self._callback: Optional[Callable[[str], bool]] = None

playwright/playwright.py

@@ -16,6 +16,7 @@
 
 from playwright.browser_type import BrowserType
 from playwright.connection import ChannelOwner, ConnectionScope, from_channel
+from playwright.helper import Devices
 from playwright.selectors import Selectors
 
 
@@ -24,7 +25,7 @@ class Playwright(ChannelOwner):
     firefox: BrowserType
     webkit: BrowserType
     selectors: Selectors
-    devices: Dict
+    devices: Devices
 
     def __init__(self, scope: ConnectionScope, guid: str, initializer: Dict) -> None:
         super().__init__(scope, guid, initializer)

playwright/sync.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import sys
+import types
 import typing
 
 from playwright.sync_base import EventContextManager, SyncBase, mapping
@@ -35,6 +36,7 @@
 from playwright.frame import Frame as FrameAsync
 from playwright.helper import (
     ConsoleMessageLocation,
+    DeviceDescriptor,
     Error,
     FilePayload,
     SelectOption,
@@ -1884,6 +1886,8 @@ def route(
         url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
         handler: typing.Callable[["Route", "Request"], typing.Any],
     ) -> NoneType:
+        if isinstance(handler, types.FunctionType):
+            handler = self._map_event(handler)
         return self._sync(self._async_obj.route(url=url, handler=handler))
 
     def unroute(
@@ -2338,6 +2342,8 @@ def route(
         match: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
         handler: typing.Callable[["Route", "Request"], typing.Any],
     ) -> NoneType:
+        if isinstance(handler, types.FunctionType):
+            handler = self._map_event(handler)
         return self._sync(self._async_obj.route(match=match, handler=handler))
 
     def unroute(
@@ -2801,7 +2807,7 @@ def selectors(self) -> "Selectors":
         return Selectors._from_async(self._async_obj.selectors)
 
     @property
-    def devices(self) -> typing.Dict:
+    def devices(self) -> typing.Dict[str, DeviceDescriptor]:
         return self._async_obj.devices
 
 

playwright/sync_base.py

@@ -17,20 +17,20 @@
 
 from playwright.wait_helper import WaitHelper
 
-loop = asyncio.get_event_loop()
-
 
 class AsyncToSyncMapping:
     mapping: List[Tuple[type, type]] = []
 
     def register(self, async_class: type, sync_class: type) -> None:
         self.mapping.append((async_class, sync_class))
 
-    def get_sync_class(self, input_async_inst: object) -> Any:
+    def get_sync_value_nullabe(self, input_async_inst: object) -> Any:
+        if not input_async_inst:
+            return input_async_inst
         for (async_class, sync_class) in self.mapping:
             if isinstance(input_async_inst, async_class):
-                return sync_class
-        raise ValueError("should never happen")
+                return sync_class._from_async(input_async_inst)  # type: ignore
+        return input_async_inst
 
 
 mapping = AsyncToSyncMapping()
@@ -47,20 +47,21 @@ def __init__(
         timeout: int = None,
     ) -> None:
         self._value: Optional[T] = None
+        self._loop = asyncio.get_event_loop()
 
         wait_helper = WaitHelper()
         wait_helper.reject_on_timeout(
             timeout or 30000, f'Timeout while waiting for event "${event}"'
         )
-        self._future = loop.create_task(
+        self._future = self._loop.create_task(
             wait_helper.wait_for_event(sync_base._async_obj, event, predicate)
         )
 
     @property
     def value(self) -> T:
         if not self._value:
-            value = loop.run_until_complete(self._future)
-            self._value = mapping.get_sync_class(value)._from_async(value)
+            value = self._loop.run_until_complete(self._future)
+            self._value = mapping.get_sync_value_nullabe(value)
         return cast(T, self._value)
 
 
@@ -84,15 +85,19 @@ def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
 class SyncBase:
     def __init__(self, async_obj: Any) -> None:
         self._async_obj = async_obj
+        self._loop = asyncio.get_event_loop()
 
     def __str__(self) -> str:
         return self._async_obj.__str__()
 
     def _sync(self, future: asyncio.Future) -> Any:
-        return loop.run_until_complete(future)
+        return self._loop.run_until_complete(future)
 
     def _map_event(self, handler: Callable[[Any], None]) -> Callable[[Any], None]:
-        return lambda event: handler(mapping.get_sync_class(event)._from_async(event))
+        def _wrap_handler(*args: Any) -> None:
+            handler(*list(map(mapping.get_sync_value_nullabe, args)))
+
+        return _wrap_handler
 
     def on(self, event_name: str, handler: Any) -> None:
         self._async_obj.on(event_name, self._map_event(handler))

scripts/generate_sync_api.py

@@ -136,6 +136,12 @@ def return_value(value: Any) -> List[str]:
     return [f"{wrap_type}._from_async(", ")"]
 
 
+def wrap_input_parameters(class_name: str, method_name: str) -> None:
+    if class_name in ["Page", "BrowserContext"] and method_name == "route":
+        print("        if isinstance(handler, types.FunctionType):")
+        print("            handler = self._map_event(handler)")
+
+
 def generate(t: Any) -> None:
     print("")
     print(f"class {short_name(t)}(SyncBase):")
@@ -201,6 +207,7 @@ def generate(t: Any) -> None:
             print(
                 f"    def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
             )
+            wrap_input_parameters(short_name(t), name)
             [prefix, suffix] = return_value(get_type_hints(value, globals())["return"])
             prefix = "        return " + prefix + f"self._sync(self._async_obj.{name}("
             suffix = "))" + suffix
@@ -241,6 +248,7 @@ def main() -> None:
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import types
 import typing
 import sys
 from playwright.sync_base import EventContextManager, SyncBase, mapping
@@ -261,7 +269,7 @@ def main() -> None:
 from playwright.element_handle import ElementHandle as ElementHandleAsync
 from playwright.file_chooser import FileChooser as FileChooserAsync
 from playwright.frame import Frame as FrameAsync
-from playwright.helper import ConsoleMessageLocation, Error, FilePayload, SelectOption, Viewport
+from playwright.helper import ConsoleMessageLocation, Error, FilePayload, SelectOption, Viewport, DeviceDescriptor
 from playwright.input import Keyboard as KeyboardAsync, Mouse as MouseAsync
 from playwright.js_handle import JSHandle as JSHandleAsync
 from playwright.network import Request as RequestAsync, Response as ResponseAsync, Route as RouteAsync