chore: use fibers for the sync api (#100)

Author: pavelfeldman

.github/workflows/ci.yml

@@ -73,13 +73,7 @@ jobs:
     - name: Build package
       run: python build_package.py
     - name: Test
-      if: ${{ matrix.os == 'windows-latest' }}
-      # pytest-xdist does not exit on Windows
-      # https://github.com/pytest-dev/pytest-xdist/issues/60
       run: pytest -vv --browser=${{ matrix.browser }} --junitxml=junit/test-results-${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.browser }}.xml --cov=playwright --cov-report xml
-    - name: Test
-      if: ${{ matrix.os != 'windows-latest' }}
-      run: pytest -vv --browser=${{ matrix.browser }} -n auto --junitxml=junit/test-results-${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.browser }}.xml --cov=playwright --cov-report xml
     - name: Coveralls
       run: coveralls
       env:

README.md

@@ -48,97 +48,83 @@ 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())
+from playwright import sync_playwright
+
+with sync_playwright() as p:
+    for browser_type in [p.chromium, p.firefox, p.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
 
 This snippet emulates Mobile Safari on a device at a given geolocation, navigates to maps.google.com, performs action and takes a screenshot.
 
 ```py
-import asyncio
-from playwright import webkit, devices
-
-iphone_11 = devices['iPhone 11 Pro']
-print(iphone_11)
-
-async def run():
-  browser = await webkit.launch(headless=False)
-  context = await browser.newContext(
-    **iphone_11,
-    locale='en-US',
-    geolocation={ 'longitude': 12.492507, 'latitude': 41.889938 },
-    permissions=['geolocation']
-  )
-  page = await context.newPage()
-  await page.goto('https://maps.google.com')
-  await page.click('text="Your location"')
-  await page.waitForRequest('*preview/pwa')
-  await page.screenshot(path='colosseum-iphone.png')
-  await browser.close()
-
-asyncio.get_event_loop().run_until_complete(run())
+from playwright import sync_playwright
+
+with sync_playwright() as p:
+    iphone_11 = p.devices['iPhone 11 Pro']
+    browser = p.webkit.launch(headless=False)
+    context = browser.newContext(
+      **iphone_11,
+      locale='en-US',
+      geolocation={ 'longitude': 12.492507, 'latitude': 41.889938 },
+      permissions=['geolocation']
+    )
+    page = context.newPage()
+    page.goto('https://maps.google.com')
+    page.click('text="Your location"')
+    page.waitForRequest('*preview/pwa')
+    page.screenshot(path='colosseum-iphone.png')
+    browser.close()
 ```
 
 #### Evaluate in browser context
 
 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('''() => {
-    return {
-      width: document.documentElement.clientWidth,
-      height: document.documentElement.clientHeight,
-      deviceScaleFactor: window.devicePixelRatio
-    }
-  }''')
-  print(dimensions)
-  await browser.close()
-
-asyncio.get_event_loop().run_until_complete(run())
+from playwright import sync_playwright
+
+with sync_playwright() as p:
+    browser = p.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
+      }
+    }''')
+    print(dimensions)
+    browser.close()
 ```
 
 #### Intercept network requests
 
 This code snippet sets up request routing for a Chromium page to log all network requests.
 
 ```py
-import asyncio
-from playwright import chromium
+from playwright import sync_playwright
 
-async def run():
-  browser = await chromium.launch()
-  page = await browser.newPage()
+with sync_playwright() as p:
+    browser = p.chromium.launch()
+    page = browser.newPage()
 
-  def log_and_continue_request(route, request):
-    print(request.url)
-    await asyncio.create_task(route.continue_())
+    def log_and_continue_request(route, request):
+      print(request.url)
+      route.continue_()
 
-  # Log and continue all network requests
-  await page.route('**', lambda route, request: log_and_continue_request(route, request))
+    # Log and continue all network requests
+    page.route('**', lambda route, request: log_and_continue_request(route, request))
 
-  await page.goto('http://todomvc.com')
-  await browser.close()
-
-asyncio.get_event_loop().run_until_complete(run())
+    page.goto('http://todomvc.com')
+    browser.close()
 ```
 
 # Is Playwright for Python ready?

client.py

@@ -0,0 +1,92 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import playwright
+from playwright.sync_api import Playwright
+
+
+def main(playwright: Playwright) -> None:
+    browser = playwright.chromium.launch(headless=False)
+    page = browser.newPage(viewport=0)
+    page.setContent(
+        "<button id=button onclick=\"window.open('http://webkit.org', '_blank')\">Click me</input>"
+    )
+
+    with page.expect_popup() as popup_info:
+        page.click("#button")
+    print(popup_info.value)
+
+    print("Contexts in browser: %d" % len(browser.contexts))
+    print("Creating context...")
+    context = browser.newContext(viewport=0)
+    print("Contexts in browser: %d" % len(browser.contexts))
+    print("Pages in context: %d" % len(context.pages))
+
+    print("\nCreating page1...")
+    page1 = context.newPage()
+    print("Pages in context: %d" % len(context.pages))
+    page1.on("framenavigated", lambda frame: print("Frame navigated to %s" % frame.url))
+    page1.on("request", lambda request: print("Request %s" % request.url))
+    page1.on(
+        "requestFinished", lambda request: print("Request finished %s" % request.url)
+    )
+    page1.on(
+        "response",
+        lambda response: print(
+            "Response %s, request %s in frame %s"
+            % (response.url, response.request.url, response.frame.url)
+        ),
+    )
+    print("Navigating page1 to https://example.com...")
+    page1.goto("https://example.com")
+    print("Page1 main frame url: %s" % page1.mainFrame.url)
+    print("Page1 tile: %s" % page1.title())
+    print("Frames in page1: %d" % len(page1.frames))
+    page1.screenshot(path="example.png")
+
+    print("\nCreating page2...")
+    page2 = context.newPage()
+    page2.on("framenavigated", lambda frame: print("Frame navigated to %s" % frame.url))
+
+    print("Navigating page2 to https://webkit.org...")
+    page2.goto("https://webkit.org")
+    print("Page2 tile: %s" % page2.title())
+    print("Pages in context: %d" % len(context.pages))
+
+    print("\nQuerying body...")
+    body1 = page1.querySelector("body")
+    assert body1
+    print("Body text %s" % body1.textContent())
+
+    print("Closing page1...")
+    page1.close()
+    print("Pages in context: %d" % len(context.pages))
+
+    print("Navigating page2 to https://cnn.com...")
+    page2.goto("https://cnn.com")
+    print("Page2 main frame url: %s" % page2.mainFrame.url)
+    print("Page2 tile: %s" % page2.title())
+    print("Frames in page2: %d" % len(page2.frames))
+    print("Pages in context: %d" % len(context.pages))
+
+    print("Closing context...")
+    context.close()
+    print("Contexts in browser: %d" % len(browser.contexts))
+    print("Closing browser")
+    browser.close()
+
+
+if __name__ == "__main__":
+    with playwright.sync_playwright() as p:
+        main(p)

playwright/__init__.py

@@ -13,28 +13,23 @@
 # limitations under the License.
 
 import playwright.helper as helper
-from playwright._repo_version import version as __version__  # noqa:F401
-from playwright.async_api import Playwright as AsyncPlaywright
-from playwright.main import playwright_impl
-from playwright.sync_api import Playwright as SyncPlaywright
-
-playwright_sync = SyncPlaywright(playwright_impl)
-playwright_async = AsyncPlaywright(playwright_impl)
-
-chromium = playwright_async.chromium
-firefox = playwright_async.firefox
-webkit = playwright_async.webkit
-devices = playwright_async.devices
-selectors = playwright_async.selectors
+from playwright.main import AsyncPlaywrightContextManager, SyncPlaywrightContextManager
+
 Error = helper.Error
 TimeoutError = helper.TimeoutError
 
+
+def async_playwright() -> AsyncPlaywrightContextManager:
+    return AsyncPlaywrightContextManager()
+
+
+def sync_playwright() -> SyncPlaywrightContextManager:
+    return SyncPlaywrightContextManager()
+
+
 __all__ = [
-    "playwright_sync",
-    "firefox",
-    "webkit",
-    "devices",
-    "selectors",
+    "async_playwright",
+    "sync_playwright",
     "Error",
     "TimeoutError",
 ]

playwright/accessibility.py

@@ -55,6 +55,7 @@ def _ax_node_from_protocol(axNode: Dict[str, Any]) -> Dict[str, Any]:
 class Accessibility:
     def __init__(self, channel: Channel) -> None:
         self._channel = channel
+        self._loop = channel._scope._loop
 
     async def snapshot(
         self, interestingOnly: bool = True, root: ElementHandle = None

playwright/async_base.py

@@ -27,19 +27,19 @@
 class AsyncEventInfo(Generic[T]):
     def __init__(
         self,
-        sync_base: "AsyncBase",
+        async_base: "AsyncBase",
         event: str,
         predicate: Callable[[T], bool] = None,
         timeout: int = None,
     ) -> None:
         self._value: Optional[T] = None
 
-        wait_helper = WaitHelper()
+        wait_helper = WaitHelper(async_base._loop)
         wait_helper.reject_on_timeout(
             timeout or 30000, f'Timeout while waiting for event "${event}"'
         )
         self._future = asyncio.get_event_loop().create_task(
-            wait_helper.wait_for_event(sync_base._impl_obj, event, predicate)
+            wait_helper.wait_for_event(async_base._impl_obj, event, predicate)
         )
 
     @property
@@ -52,12 +52,12 @@ async def value(self) -> T:
 class AsyncEventContextManager(Generic[T]):
     def __init__(
         self,
-        sync_base: "AsyncBase",
+        async_base: "AsyncBase",
         event: str,
         predicate: Callable[[T], bool] = None,
         timeout: int = None,
     ) -> None:
-        self._event = AsyncEventInfo(sync_base, event, predicate, timeout)
+        self._event = AsyncEventInfo(async_base, event, predicate, timeout)
 
     async def __aenter__(self) -> AsyncEventInfo[T]:
         return self._event
@@ -69,6 +69,7 @@ async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
 class AsyncBase(ImplWrapper):
     def __init__(self, impl_obj: Any) -> None:
         super().__init__(impl_obj)
+        self._loop = impl_obj._loop
 
     def __str__(self) -> str:
         return self._impl_obj.__str__()

playwright/browser_context.py

@@ -185,7 +185,7 @@ async def waitForEvent(
     ) -> Any:
         if timeout is None:
             timeout = self._timeout_settings.timeout()
-        wait_helper = WaitHelper()
+        wait_helper = WaitHelper(self._loop)
         wait_helper.reject_on_timeout(
             timeout, f'Timeout while waiting for event "${event}"'
         )