How to use test_locators_get_attribute_should_work method in Playwright Python

Solved with:

context=firefox.new_context(ignore_https_errors=True)

Instead of:

page.once("dialog", lambda dialog: asyncio.create_task(dialog.accept()))

It should apparently be just:

page.once("dialog", lambda dialog: dialog.accept())

This was basically a lucky guess, so take it with a grain of salt. I can't find a good source to back it up.

At the time of writing, the documentation for the Python version of Playwright doesn't seem to mention page.once() at all.

In the original JavaScript version of Playwright, page.once() is documented as part of the standard Node.js EventEmitter class, from which Page is derived. Nothing like EventEmitter exists in the Python standard library, though.

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

If you know that the click will take a while, you can set a timeout:

page.locator("text=Download").click(timeout=60000)

The main problem:

context.new_page() calls before variable declaration(context = ...)

Should works fine:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False, slow_mo=50)
    context = browser.new_context(storage_state="website1.json")
    page = context.new_page()
    page.goto('https://demo.opencart.com/admin')
    page.fill("input#input-username", "demo")
    page.fill("input#input-password", "demo")
    page.click("button[type=submit]")

Also you can use Persistent authentication:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    user_data_dir = 'FULL_PATH_TO_BROWSER_PROFILE'
    browser = p.chromium.launch_persistent_context(user_data_dir, headless=False)
    # login only 1 time...

JFYI: opencart uses user_token in GET parameters and validates it. playwright(storage_state, user_data_dir etc) should works fine. Example:

# run docker container with playwright
docker rm -fv example && docker run --name example -it mcr.microsoft.com/playwright/python:v1.27.1-focal bash
# create empty state
echo {} >> /tmp/state.json
# run python in interactive mode
python
# Python 3.8.10 (default, Jun 22 2022, 20:18:18) 
# [GCC 9.4.0] on linux
# Type "help", "copyright", "credits" or "license" for more information.

Paste the next script:

from time import sleep
from urllib.parse import parse_qs

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    # login
    browser = p.chromium.launch()
    context = browser.new_context(storage_state='/tmp/state.json')
    page = context.new_page()
    page.goto('https://demo.opencart.com/admin')
    page.fill('input#input-username', 'demo')
    page.fill('input#input-password', 'demo')
    page.click('button[type=submit]')
    sleep(5)  # just wait for redirect - you can wait for a element...
    page.context.storage_state(path='/tmp/state.json')
    page.screenshot(path='/tmp/after_state_init.png')
    # parse user_token for GET requests
    parsed_url = parse_qs(page.url)
    user_token = parsed_url['user_token'][0]
    print(f'user token {user_token}')
    page.close()
    browser.close()


with sync_playwright() as p:
    # open admin dashboard without login... 
    browser = p.chromium.launch()
    context = browser.new_context()
    page = browser.new_page(storage_state='/tmp/state.json')
    page.goto(f'https://demo.opencart.com/admin/index.php?route=common/dashboard&user_token={user_token}')
    sleep(5)
    page.screenshot(path='/tmp/open_using_saved_state.png')
    page.close()
    browser.close()

Now open a new terminal and copy screens from docker container:

docker cp example:/tmp/after_state_init.png ./
docker cp example:/tmp/open_using_saved_state.png ./

You'll see that they are the same - admin dashboard works without login.

You are supposed to use sync_playwright as a context managers:

from playwright.sync_api import sync_playwright
print('debug1')

with sync_playwright() as p:
    print('debug2')
    browser = p.firefox.launch(headless=False)
    print('debug3')
    page = browser.new_page()
    page.goto("http://whatsmyuseragent.org/")
    page.screenshot(path="example.png")
    browser.close()

Output

debug1
debug2
debug3

See playwright documentation for python here

Edit (specific to OP)

As a last ditch effort, try these steps in order:

1. Run pip install -U pip
2. Run pip uninstall plawyright
3. Run pip cache remove playwright
4. Run pip install playwright

Keep in mind that if you have installed multiple versions of python, use the PATH variable defined for pip for the version of python you want to install playwright in. Lastly, try changing the browser you use with playwright. So instead of browser = p.firefox.launch(headless=False), use browser = p.chromium.launch(headless=False)

I was doing similar thing using playwright Python API. All you need to do is store your authentication as a json file. Then you have to use the file using your account. You need some knowledge about HTML and CSS. You can easily get the needed information using beautifulsoup module.

https://www.piwheels.org is where wheels for Raspberry Pi are published, not PyPI. This is the list of wheels for "playwright": https://www.piwheels.org/project/playwright/ . Version 0.162.2 is the latest available release (click on "Show more releases").

To install from PyPI try to install from both PyPI and PiWheels:

pip install --index-url=https://pypi.org/simple/ --extra-index-url=https://www.piwheels.org/simple/ playwright

There is no direct way to achieve this, but there are workarounds you can use to achieve the same results using routing. Basically, after you no longer require the proxy, you route all requests playwright makes to a handler, which subsequently bypasses proxies and forwards the response back to playwright. However, this approach will only work with async version of playwright (otherwise executing a blocking call from a route handler will block further network traffic too). Consider the below code:

import aiohttp, asyncio
import playwright


def no_proxy_route(session):
    """
    Bypasses any proxy and routes request directly. It's a factory function to store value of session so we don't need
    to create a new one every time.
    """

    async def route_handler(route: playwright.async_api.Route):

        request = route.request

        try:
            body, status, headers = await fetch(session, request)

        # Abort route in case of error
        except (aiohttp.ClientConnectionError, asyncio.TimeoutError):
            await route.abort()
            return

        # If no error, fulfill route with the given body and headers
        await route.fulfill(status=status, headers=headers, body=body)

    return route_handler


async def fetch(session, request, timeout=5000):
    """
    Fetch the given request using aiohttp
    """

    assert timeout > 0, "timeout must be positive"
    try:
        async with session.request(request.method, request.url, headers=request.headers,
                                   data=request.post_data, timeout=timeout) as response:
            body = await response.read()
            status = response.status
            headers = response.headers

    except Exception:
        raise

    else:
        return body, status, headers

Now if you want to conditionally disable proxies for some requests, you simply create a matching pattern and route all those requests through no_proxy_route. An example is given below:

### All your previous code
# .
# .
# .
# .
### which required a proxy

# Create an aiohttp session with a dummy cookie jar. This is because we will be passing the cookies
# explicitly and don't want previous requests/responses cookies to persist and interfere
session = aiohttp.ClientSession(cookie_jar=aiohttp.DummyCookieJar())

# Create a route to our handler with an appropriate pattern. The below pattern will route ALL subsequent requests to 
# handler. Remember that you can use regex for patterns as well.
await page.route('**/*', no_proxy_route(session))

After this is done, all requests that match the pattern, with which you created the route, will not use a proxy, even if the context has one set. But again, this is only useful if you are using the async API for playwright.