Java's FluentWait in Python

Question

In java selenium-webdriver package, there is a FluentWait class:

Each FluentWait instance defines the maximum amount of time to wait for a condition, as well as the frequency with which to check the condition. Furthermore, the user may configure the wait to ignore specific types of exceptions whilst waiting, such as NoSuchElementExceptions when searching for an element on the page.

In other words, it is something more than implicit and explicit wait, gives you more control for waiting for an element. It can be very handy and definitely has use cases.

Is there anything similar in python selenium package, or should I implement it myself?

(I've looked through documentation for Waits - nothing there).

Answer 1

I believe you can do this with Python, however it isn't packaged as simply as a FluentWait class. Some of this was covered in the documentation you provided by not extensively.

The WebDriverWait class has optional arguments for timeout, poll_frequency, and ignored_exceptions. So you could supply it there. Then combine it with an Expected Condition to wait for elements for appear, be clickable, etc... Here is an example:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import *

driver = webdriver.Firefox()
# Load some webpage
wait = WebDriverWait(driver, 10, poll_frequency=1, ignored_exceptions=[ElementNotVisibleException, ElementNotSelectableException])
element = wait.until(EC.element_to_be_clickable((By.XPATH, "//div")))

Obviously you can combine the wait/element into one statement but I figured this way you can see where this is implemented.

Answer 2

iChar's answer covers how to use WebDriverWait in Python to do what FluentWait does in Java. Some aspects of the question were left unaddressed though:

In other words, [FluentWait] is something more than implicit and explicit wait

No. As of version 2.42.x of Selenium, there are only two kinds of waits that Selenium implements: implicit and explicit. FluentWait is not something additional to these two kinds of wait. It is just an explicit wait.

Is there anything similar in python selenium package, or should I implement it myself?

The only thing I can think of that is missing from Python's WebDriverWait implementation that FluentWait (and WebDriverWait, by extension) has, is this:

[FluentWait (and, by extension, WebDriverWait)] may have its timeout and polling interval configured on the fly.

[Quoted from this.]

The WebDriverWait class in Python is designed in such a way that its configuration values are set once and for all when it is created. FluentWait allows its configuration to be changed after creation. So a single FluentWait object (or any WebDriverWait in Java) could be reused to wait for different conditions with different polling frequencies. In Python, you'd have to create a new WebDriverWait object to use a different polling frequency.

So there is something the Python implementation does not provide but I would not consider this significant enough to warrant an implementation.

Answer 3

The above implementation didn’t work well in my use case so I would share my implementation as well. For fluent wait, it is also nice to check some other criteria when polling, for example, we can check if there an attribute of an element has changed. So, in my condition the page should be refreshed. Below is the code [it is adjusted for 30 seconds(6 times the loop and 5 times for each second)]:

element = None
i = 6
while element is None:
    try:
        wait = WebDriverWait(driver, 5, poll_frequency=1)
        element = wait.until(expected_conditions.visibility_of_element_located(el))
    except:
        driver.refresh()
        i = i - 1
        print(i)
        if i < 0:
            raise Exception('Element not found')