Adding config.disable_asyncio_subprocess to allow to use WindowsSelectorEventLoopPolicy on Windows (#117)

* feat: adding disable_asyncio_subprocess to use subprocess.Popen instead (for better support on Windows)

* test and document with WindowsSelectorEventLoopPolicy

* update changelogs

* disable_asyncio_subprocess defaults to True on Windows

* using subprocess.Popen for all platforms

* apply format

Author: nathanfallet

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - Fixing tests so that they can run on Windows (and still run on Linux like before) @nathanfallet
+- Disable asyncio subprocesses for better compatibility on Windows @nathanfallet
 - Adding a missing Chrome Canary path for Windows @nathanfallet
 - Adding a flag to re-enable `--load-extension` (disabled by default in Chrome 136+) @nathanfallet
 

docs/quickstart.md

@@ -93,7 +93,16 @@ config.user_data_dir="/path/to/existing/profile",  # by specifying it, it won't
 config.browser_executable_path="/path/to/some/other/browser",
 config.browser_args=['--some-browser-arg=true', '--some-other-option'],
 config.lang="en-US"   # this could set iso-language-code in navigator, not recommended to change
-)
+```
+
+On Windows, we recommend using `WindowsSelectorEventLoopPolicy` for better compatibility with asyncio:
+
+```python
+import asyncio
+import sys
+
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 ```
 
 A more concrete example, which can be found in the ./example/ folder,

tests/conftest.py

@@ -1,6 +1,8 @@
+import asyncio
 import logging
 import os
 import signal
+import sys
 from contextlib import AbstractAsyncContextManager
 from enum import Enum
 from threading import Event
@@ -83,6 +85,9 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
 
 @pytest.fixture
 def create_browser() -> type[CreateBrowser]:
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())  # type: ignore
+
     return CreateBrowser
 
 

zendriver/core/browser.py

@@ -10,6 +10,7 @@
 import pickle
 import re
 import shutil
+import subprocess
 import urllib.parse
 import urllib.request
 import warnings
@@ -54,7 +55,7 @@ class Browser:
 
     """
 
-    _process: asyncio.subprocess.Process | None
+    _process: subprocess.Popen | None
     _process_pid: int | None
     _http: HTTPApi | None = None
     _cookies: CookieJar | None = None
@@ -354,18 +355,7 @@ async def start(self) -> Browser:
             "starting\n\texecutable :%s\n\narguments:\n%s", exe, "\n\t".join(params)
         )
         if not connect_existing:
-            self._process: asyncio.subprocess.Process = (
-                await asyncio.create_subprocess_exec(
-                    # self.config.browser_executable_path,
-                    # *cmdparams,
-                    exe,
-                    *params,
-                    stdin=asyncio.subprocess.PIPE,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                    close_fds=is_posix,
-                )
-            )
+            self._process = util._start_process(exe, params, is_posix)
             self._process_pid = self._process.pid
 
         self._http = HTTPApi((self.config.host, self.config.port))
@@ -619,7 +609,7 @@ async def stop(self):
                     self._process.kill()
                     logger.debug("killed browser process")
 
-                await self._process.wait()
+                await asyncio.to_thread(self._process.wait)
 
             except ProcessLookupError:
                 # ignore this well known race condition because it only means that

zendriver/core/util.py

@@ -2,8 +2,10 @@
 
 import asyncio
 import logging
+import subprocess
 import types
 import typing
+from pathlib import Path
 from typing import Any, Callable, List, Optional, Set, Union
 
 from deprecated import deprecated
@@ -328,19 +330,41 @@ def cdp_get_module(domain: Union[str, types.ModuleType]):
     return domain_mod
 
 
-async def _read_process_stderr(
-    process: asyncio.subprocess.Process, n: int = 2**16
-) -> str:
+def _start_process(
+    exe: str | Path, params: List[str], is_posix: bool
+) -> subprocess.Popen:
+    """
+    Start a subprocess with the given executable and parameters.
+
+    :param exe: The executable to run.
+    :param params: List of parameters to pass to the executable.
+    :param is_posix: Boolean indicating if the system is POSIX compliant.
+
+    :return: An instance of `subprocess.Popen`.
+    """
+    return subprocess.Popen(
+        [str(exe)] + params,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        close_fds=is_posix,
+    )
+
+
+async def _read_process_stderr(process: subprocess.Popen, n: int = 2**16) -> str:
     """
     Read the given number of bytes from the stderr of the given process.
 
     Read bytes are automatically decoded to utf-8.
     """
-    if process.stderr is None:
-        raise ValueError("Process has no stderr")
+
+    async def read_stderr() -> bytes:
+        if process.stderr is None:
+            raise ValueError("Process has no stderr")
+        return await asyncio.to_thread(process.stderr.read, n)
 
     try:
-        return (await asyncio.wait_for(process.stderr.read(n), 0.25)).decode("utf-8")
+        return (await asyncio.wait_for(read_stderr(), 0.25)).decode("utf-8")
     except asyncio.TimeoutError:
         logger.debug("Timeout reading process stderr")
         return ""