fix sync variant

Author: mxschmitt

playwright/_impl/_browser_type.py

@@ -172,7 +172,9 @@ async def connect(
         slow_mo: float = None,
         headers: Dict[str, str] = None,
     ) -> Browser:
-        transport = WebSocketTransport(self._connection._loop, ws_endpoint, timeout, headers)
+        transport = WebSocketTransport(
+            self._connection._loop, ws_endpoint, timeout, headers
+        )
 
         connection = Connection(
             self._connection._dispatcher_fiber,
@@ -182,7 +184,7 @@ async def connect(
         connection._is_sync = self._connection._is_sync
         connection._loop = self._connection._loop
         connection._loop.create_task(connection.run())
-        await connection.wait_until_started()
+        await connection.initialize()
         playwright = await connection.wait_for_object_with_known_name("Playwright")
         self._connection._child_ws_connections.append(connection)
         pre_launched_browser = playwright._initializer.get("preLaunchedBrowser")

playwright/_impl/_connection.py

@@ -169,14 +169,14 @@ def __init__(
     async def run_as_sync(self) -> None:
         self._is_sync = True
         await self.run()
-        await self.wait_until_started()
+        await self.initialize()
 
     async def run(self) -> None:
         self._loop = asyncio.get_running_loop()
         self._root_object = RootChannelOwner(self)
         await self._transport.run()
 
-    async def wait_until_started(self) -> None:
+    async def initialize(self) -> None:
         await self._transport.wait_until_started
 
     def stop_sync(self) -> None:

playwright/_impl/_transport.py

@@ -87,7 +87,9 @@ def deserialize_message(self, data: bytes) -> Any:
 
 
 class PipeTransport(Transport):
-    def __init__(self, loop: asyncio.AbstractEventLoop, driver_executable: Path) -> None:
+    def __init__(
+        self, loop: asyncio.AbstractEventLoop, driver_executable: Path
+    ) -> None:
         super().__init__(loop)
         self._stopped = False
         self._driver_executable = driver_executable
@@ -114,14 +116,8 @@ async def run(self) -> None:
                 stderr=_get_stderr_fileno(),
                 limit=32768,
             )
-        except FileNotFoundError:
-            self._wait_until_started_set_exception(
-                Error(
-                    "playwright's driver is not found, You can read the contributing guide "
-                    "for some guidance on how to get everything setup for working on the code "
-                    "https://github.com/microsoft/playwright-python/blob/master/CONTRIBUTING.md"
-                )
-            )
+        except Exception as exc:
+            self._wait_until_started_set_exception(exc)
             return
 
         self._wait_until_started_set_success()
@@ -160,16 +156,19 @@ def send(self, message: Dict) -> None:
 
 class WebSocketTransport(AsyncIOEventEmitter, Transport):
     def __init__(
-        self, loop: asyncio.AbstractEventLoop, ws_endpoint: str, timeout: float = None, headers: Dict[str, str] = None
+        self,
+        loop: asyncio.AbstractEventLoop,
+        ws_endpoint: str,
+        timeout: float = None,
+        headers: Dict[str, str] = None,
     ) -> None:
-        super().__init__()
+        super().__init__(loop)
         Transport.__init__(self, loop)
 
         self._stopped = False
         self.ws_endpoint = ws_endpoint
-        self.timeout = timeout
+        self.timeout = timeout or 30000
         self.headers = headers
-        self._loop: asyncio.AbstractEventLoop
 
     def request_stop(self) -> None:
         self._stopped = True
@@ -189,7 +188,7 @@ async def run(self) -> None:
             options["close_timeout"] = self.timeout / 1000
             options["ping_timeout"] = self.timeout / 1000
 
-        if self.headers is not None:
+        if self.headers:
             options["extra_headers"] = self.headers
         try:
             self._connection = await websockets.connect(self.ws_endpoint, **options)

playwright/async_api/_context_manager.py

@@ -28,12 +28,14 @@ def __init__(self) -> None:
 
     async def __aenter__(self) -> AsyncPlaywright:
         self._connection = Connection(
-            None, create_remote_object, PipeTransport(asyncio.get_event_loop(), compute_driver_executable())
+            None,
+            create_remote_object,
+            PipeTransport(asyncio.get_event_loop(), compute_driver_executable()),
         )
         loop = asyncio.get_running_loop()
         self._connection._loop = loop
         loop.create_task(self._connection.run())
-        await self._connection.wait_until_started()
+        await self._connection.initialize()
         playwright = AsyncPlaywright(
             await self._connection.wait_for_object_with_known_name("Playwright")
         )