How to use test_fill_should_fill_date_input_after_clicking method in Playwright Python

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}"
    ]

Version 1.22

iframe = page.frame_locator("YOUR_SELECTOR_HERE")

https://playwright.dev/python/docs/api/class-framelocator

At the end of each iteration of "y" you issue a mouse up event. However, you dont issue a mouse move event to the start of the new line before putting the mouse down again.

Try the below code:

    for y in range(100, 1000, 100):
        # Generate mouse points
        points = []
        wm(start_point, y, x, y, M_0=15, D_0=12, move_mouse=lambda x, y: points.append([x, y]))

        page.mouse.up()
        # Move mouse to start of new line
        page.mouse.move(points[0][0], points[0][1])
        # Mouse back down
        page.mouse.down()
        #Iterate the remaining points
        for point in points[1:]:
            page.mouse.move(point[0], point[1])
        page.mouse.up()

Absent seeing the actual site, a traditional selection and get_attribute should be sufficient:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.set_content("""
    <iframe title="IFRAME_NAME" src="https://www.data_I_want_TO_get.com"></iframe>
    """)
    src = page.get_attribute('iframe[title="IFRAME_NAME"]', "src")
    print(src)  # => https://www.data_I_want_TO_get.com
    browser.close()

If the frame isn't immediately visible you can wait for it by replacing the src = line with

src = (
    page.wait_for_selector('iframe[title="IFRAME_NAME"]')
        .get_attribute("src")
)

Try this:

if (page.is_visible(XPATH)):
    page.click(XPATH)

Or you can make the code cleaner like this:

try:
    page.click(XPATH)
except:
    pass

For Typescript/Javascript there is playwright-dompath which you can install with:

npm install playwright-dompath

Basically you just call the xPath function with the element you selected, and you get back the full xPath. Under the hood, it uses the same functions from Chrome DevTools.

The download.path() in playwright is just a random GUID (globally unique identifier). It's designed to validate the download works - not to keep the file.

Playwright is a testing tool and imagine running tests across every major browser on every code change - any downloads would quickly take up a lot of space and it would hack people off if you need to manually clear them out.

Good news is you are very close - If you want to keep the file you just need to give the file a name in the save_as.

instead of this:

   download.save_as(path)

use this:

   download.save_as(download.suggested_filename)

That saves the file in the same location as the script.

You can use the Playwright APIRequestContext feature.

response = await api_request_context.post(...)

I found that it's possible to use Page in context of exposed function, as long as:

1. You use async Playwright (as per @hardkoded suggestion)
2. Don't navigate away (as per @Charchit suggestion)

from playwright.async_api import  Page, async_playwright
import asyncio
from functools import partial
import time


async def handle_title(page: Page, title: str):
    # page = page_var.get()
    print(page)
    await page.locator("#searchInput").type(f"{title}")
    return "hello world"


async def main():
     async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context(viewport={ 'width': 1920, 'height': 1024 })
        page = await context.new_page()
        await page.goto(f"https://wikipedia.org")
        await context.expose_function("handle_title", partial(handle_title, page))
        await page.evaluate("window.onload = () => handle_title(document.title)")
        while True:
            await asyncio.sleep(1)



asyncio.run(main())