How to use test_click_a_partially_obscured_button method in Playwright Python

1. You can see the actual wheel list at the "Download files" tab: https://pypi.org/project/playwright/1.25.2/#files
   There you will see that unfortunately no wheels were built for linux 32bit

2. pytest-playwright try to install playwright but failes because it doesnt find any (same issue as the first)

When you visit the page, playwright/chrome will need to send a network request to retrieve the PDF you're looking at. Just intercept that request, and grab the response body as a buffer.

If you are just navigating directly to the PDF, I think something like this would work:

response = page.goto(url)
print(response.status)
body = response.body()

# Open file in binary write mode
pdf_file = open('file.pdf', 'wb')

# Write bytes to file
pdf_file.write(body)

# Close file
pdf_file.close()

I would suggest write that returned HTML content to a file and use this to scrape local file using:

import scrapy
import os

LOCAL_FILENAME = 'example.html'
LOCAL_FOLDER = 'html_files'
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


class ExampleSpider(scrapy.Spider):
    name = "example"
    start_urls = [
        f"file://{BASE_DIR}/{LOCAL_FOLDER}/{LOCAL_FILENAME}"
    ]

Functions assigned to events (in any module) can't return value and you may need to use global variable for this. But lambda can't use global and can't assign value to variable so it needs normal function

url = ""

def on_response(response):
    global url  # inform functio to use external variable (instead of local variable) when you use `=` to assign value
    
    if ".m3u8" in response.url:
        url = response.url

page.on("response", on_response) 

I solved my problem. In fact my docker container (frontend) is called "app" which is also domain name of fronend application. My application is running locally on http. Chromium and geko drivers force httpS connection for some domain names one of which is "app". So i have to change name for my docker container wich contains frontend application.

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

Your locator should look like this. Replace ":" with ">>"

div[class="some-class"]>>nth=3

Heroku's filesystem is both ephemeral and dyno-local. Any changes made to it are lost when the dyno restarts. More importantly at the moment, when you run something like heroku run bash you don't connect to a running dyno. Instead, you get a separate one-off dyno.

Installing Chromium (or making any other filesystem changes) in such an environment will never affect what is available in your other dynos.

It looks like Playwright really wants to manage its own browser binaries. Your best bet might be to run playwright install near the beginning of your script, e.g. something like this:

import subprocess
from playwright.sync_api import sync_playwright

subprocess.run(["playwright", "install"])

with sync_playwright() as playwright:
    # ...

This should make sure that the required binaries are always available at runtime.

Try Firefox browser like this:

from playwright.sync_api import sync_playwright

chromium = playwright.firefox
browser = chromium.launch(headless=False)
page = browser.new_page()
page.goto(url)