How to use test_workers_should_report_network_activity method in Playwright Python

Please refer this stack overflow link for more details. hope this will help to solve your issue

Try this:

# Needed libs
from playwright.sync_api import Playwright, sync_playwright, expect

with sync_playwright() as p:
    #We define the browser, the context and the page
    browser = p.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    # Go to URL for this example
    page.goto("https://demoqa.com/browser-windows")

    # With the current context we wait for a new page, and we do whatever we have to do inside for opening that new page (tab)
    with context.expect_page() as new_page_info:
        # Needed actions for opening the new tab, in my case clicling a button
        page.locator('#tabButton').click()  # Opens a new tab
    # Now we have the new page
    new_page = new_page_info.value
    # We do whatever we want with our new page, in my case it is only taking a text from an element and printing it out
    text_of_h1_from_new_page = new_page.locator('#sampleHeading').inner_text()
    print(text_of_h1_from_new_page)
    # Close the context and browser
    context.close()
    browser.close()

More info here: https://playwright.dev/python/docs/pages#handling-new-pages

You can select it by attribute:

self.page.locator('[id=\'#A/BC\']').click()

afaik, playwright uses a virtual keyboard and does not exactly send the same signal as a real keyboard to the browser application.

consider going native and using something closer to kernel like pyautogui, after you've focused you window:

import pyautogui
pyautogui.press('f5')

You can use Playwright's codegen tool and open the webkit browser

playwright codegen -b webkit

You have to use inner_text for this:

email = page.locator.inner_text("#cphMain_hlOrgInboundEmail")
print(email)

Not sure about Colab, but in a normal Jupyter notebook you do:

import nest_asyncio
nest_asyncio.apply()

Install with pip install nest-asyncio, and then you can run async stuff in a notebook.

Edit: You are also trying to run a GUI instance of Chrome, with that headless=False - change that to headless=True, Colab doens't run with a GUI.

I am not used to use async and I am not sure of your question, but I think this is what you want:

import asyncio
from playwright.async_api import async_playwright


async def main():
    async with async_playwright() as p:
        for browser_type in [p.chromium, p.firefox, p.webkit]:
            browser = await browser_type.launch(headless=False)
            page = await browser.new_page()


            # Now, we gonna expect a request, but that request we have to expect it after doing something, in my example is the navigation to google, in your example could be clicking a button or something else.
            async with page.expect_request("https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png") as first:
                await page.goto("https://google.com")
            first_request = await first.value
            print(f"The method of the request was: {first_request.method}")
            print(f"The url of the request was: {first_request.url}")
            print()
            print("And the headers:")
            # You can use this first_request.all_headers() as a Json
            print(await first_request.all_headers())

            await asyncio.sleep(5)

asyncio.run(main())

I did it with google, you should do it with your own page and knowing what should be the request url.

Here some doc: https://playwright.dev/python/docs/api/class-page#page-wait-for-request

You can use the API request feature:

browser = playwright.chromium.launch()
context = browser.new_context(base_url="https://api.github.com")
api_request_context = context.request
page = context.new_page()

response = api_request_context.post(
  "/user/repos",
  headers={
      "Accept": "application/vnd.github.v3+json",
      "Authorization": f"token {API_TOKEN}",
  },
  data={"name": REPO},
)