selenium.webdriver.support.expected_conditions

Functions

alert_is_present()	An expectation for checking if an alert is currently present and switching to it.
all_of(*expected_conditions)	An expectation that all of multiple expected conditions is true.
any_of(*expected_conditions)	An expectation that any of multiple expected conditions is true.
element_attribute_to_include(locator, attribute_)	An expectation for checking if the given attribute is included in the specified element.
element_located_selection_state_to_be(...)	An expectation to locate an element and check if the selection state specified is in that state.
element_located_to_be_selected(locator)	An expectation for the element to be located is selected.
element_selection_state_to_be(element, ...)	An expectation for checking if the given element is selected.
element_to_be_clickable(mark)	An Expectation for checking an element is visible and enabled such that you can click it.
element_to_be_selected(element)	An expectation for checking the selection is selected.
frame_to_be_available_and_switch_to_it(locator)	An expectation for checking whether the given frame is available to switch to.
invisibility_of_element(element)	An Expectation for checking that an element is either invisible or not present on the DOM.
invisibility_of_element_located(locator)	An Expectation for checking that an element is either invisible or not present on the DOM.
new_window_is_opened(current_handles)	An expectation that a new window will be opened and have the number of windows handles increase.
none_of(*expected_conditions)	An expectation that none of 1 or multiple expected conditions is true.
number_of_windows_to_be(num_windows)	An expectation for the number of windows to be a certain value.
presence_of_all_elements_located(locator)	An expectation for checking that there is at least one element present on a web page.
presence_of_element_located(locator)	An expectation for checking that an element is present on the DOM of a page.
staleness_of(element)	Wait until an element is no longer attached to the DOM.
text_to_be_present_in_element(locator, text_)	An expectation for checking if the given text is present in the specified element.
text_to_be_present_in_element_attribute(...)	An expectation for checking if the given text is present in the element's attribute.
text_to_be_present_in_element_value(locator, ...)	An expectation for checking if the given text is present in the element's value.
title_contains(title)	An expectation for checking that the title contains a case-sensitive substring.
title_is(title)	An expectation for checking the title of a page.
url_changes(url)	An expectation for checking the current url is different than a given string.
url_contains(url)	An expectation for checking that the current url contains a case- sensitive substring.
url_matches(pattern)	An expectation for checking the current url.
url_to_be(url)	An expectation for checking the current url.
visibility_of(element)	An expectation for checking that an element, known to be present on the DOM of a page, is visible.
visibility_of_all_elements_located(locator)	An expectation for checking that all elements are present on the DOM of a page and visible.
visibility_of_any_elements_located(locator)	An expectation for checking that there is at least one element visible on a web page.
visibility_of_element_located(locator)	An expectation for checking that an element is present on the DOM of a page and visible.

selenium.webdriver.support.expected_conditions.title_is(title: str) → Callable[[WebDriver], bool]

An expectation for checking the title of a page.

Parameters:

titlestr

The expected title, which must be an exact match.

Returns:

boolean : True if the title matches, False otherwise.

selenium.webdriver.support.expected_conditions.title_contains(title: str) → Callable[[WebDriver], bool]

An expectation for checking that the title contains a case-sensitive substring.

Parameters:

titlestr

The fragment of title expected.

Returns:

boolean : True when the title matches, False otherwise.

selenium.webdriver.support.expected_conditions.presence_of_element_located(locator: Tuple[str, str]) → Callable[[WebDriver | WebElement], WebElement]

An expectation for checking that an element is present on the DOM of a page. This does not necessarily mean that the element is visible.

Parameters:

locatorTuple[str, str]

Used to find the element.

Returns:

WebElement : The WebElement once it is located.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> element = WebDriverWait(driver, 10).until(
... EC.presence_of_element_located((By.NAME, "q")))

selenium.webdriver.support.expected_conditions.url_contains(url: str) → Callable[[WebDriver], bool]

An expectation for checking that the current url contains a case- sensitive substring.

Parameters:

urlstr

The fragment of url expected.

Returns:

boolean : True when the url matches, False otherwise.

selenium.webdriver.support.expected_conditions.url_matches(pattern: str) → Callable[[WebDriver], bool]

An expectation for checking the current url.

Parameters:

patternstr

The pattern to match with the current url.

Returns:

boolean : True when the pattern matches, False otherwise.

Notes:

More powerful than url_contains, as it allows for regular expressions.

selenium.webdriver.support.expected_conditions.url_to_be(url: str) → Callable[[WebDriver], bool]

An expectation for checking the current url.

Parameters:

urlstr

The expected url, which must be an exact match.

Returns:

boolean : True when the url matches, False otherwise.

selenium.webdriver.support.expected_conditions.url_changes(url: str) → Callable[[WebDriver], bool]

An expectation for checking the current url is different than a given string.

Parameters:

urlstr

The expected url, which must not be an exact match.

Returns:

boolean : True when the url does not match, False otherwise

selenium.webdriver.support.expected_conditions.visibility_of_element_located(locator: Tuple[str, str]) → Callable[[WebDriver | WebElement], Literal[False] | WebElement]

An expectation for checking that an element is present on the DOM of a page and visible. Visibility means that the element is not only displayed but also has a height and width that is greater than 0.

Parameters:

locatorTuple[str, str]

Used to find the element.

Returns:

WebElement : The WebElement once it is located and visible.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> element = WebDriverWait(driver, 10).until(
... EC.visibility_of_element_located((By.NAME, "q")))

selenium.webdriver.support.expected_conditions.visibility_of(element: WebElement) → Callable[[Any], Literal[False] | WebElement]

An expectation for checking that an element, known to be present on the DOM of a page, is visible.

Parameters:

elementWebElement

The WebElement to check.

Returns:

WebElement : The WebElement once it is visible.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> element = WebDriverWait(driver, 10).until(
... EC.visibility_of(driver.find_element(By.NAME, "q")))

Notes:

Visibility means that the element is not only displayed but also has a height and width that is greater than 0. element is the WebElement returns the (same) WebElement once it is visible

selenium.webdriver.support.expected_conditions.presence_of_all_elements_located(locator: Tuple[str, str]) → Callable[[WebDriver | WebElement], List[WebElement]]

An expectation for checking that there is at least one element present on a web page.

Parameters:

locatorTuple[str, str]

Used to find the element.

Returns:

List[WebElement] : The list of WebElements once they are located.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> elements = WebDriverWait(driver, 10).until(
... EC.presence_of_all_elements_located((By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.visibility_of_any_elements_located(locator: Tuple[str, str]) → Callable[[WebDriver | WebElement], List[WebElement]]

An expectation for checking that there is at least one element visible on a web page.

Parameters:

locatorTuple[str, str]

Used to find the element.

Returns:

List[WebElement] : The list of WebElements once they are located and visible.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> elements = WebDriverWait(driver, 10).until(
... EC.visibility_of_any_elements_located((By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.visibility_of_all_elements_located(locator: Tuple[str, str]) → Callable[[WebDriver | WebElement], List[WebElement] | Literal[False]]

An expectation for checking that all elements are present on the DOM of a page and visible. Visibility means that the elements are not only displayed but also has a height and width that is greater than 0.

Parameters:

locatorTuple[str, str]

Used to find the elements.

Returns:

List[WebElement] : The list of WebElements once they are located and visible.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> elements = WebDriverWait(driver, 10).until(
... EC.visibility_of_all_elements_located((By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.text_to_be_present_in_element(locator: Tuple[str, str], text_: str) → Callable[[WebDriver | WebElement], bool]

An expectation for checking if the given text is present in the specified element.

Parameters:

locatorTuple[str, str]

Used to find the element.

text_str

The text to be present in the element.

Returns:

boolean : True when the text is present, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_text_in_element = WebDriverWait(driver, 10).until(
... EC.text_to_be_present_in_element((By.CLASS_NAME, "foo"), "bar"))

selenium.webdriver.support.expected_conditions.text_to_be_present_in_element_value(locator: Tuple[str, str], text_: str) → Callable[[WebDriver | WebElement], bool]

An expectation for checking if the given text is present in the element’s value.

Parameters:

locatorTuple[str, str]

Used to find the element.

text_str

The text to be present in the element’s value.

Returns:

boolean : True when the text is present, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_text_in_element_value = WebDriverWait(driver, 10).until(
... EC.text_to_be_present_in_element_value((By.CLASS_NAME, "foo"), "bar"))

selenium.webdriver.support.expected_conditions.text_to_be_present_in_element_attribute(locator: Tuple[str, str], attribute_: str, text_: str) → Callable[[WebDriver | WebElement], bool]

An expectation for checking if the given text is present in the element’s attribute.

Parameters:

locatorTuple[str, str]

Used to find the element.

attribute_str

The attribute to check the text in.

text_str

The text to be present in the element’s attribute.

Returns:

boolean : True when the text is present, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_text_in_element_attribute = WebDriverWait(driver, 10).until(
... EC.text_to_be_present_in_element_attribute((By.CLASS_NAME, "foo"),
... "bar", "baz"))

selenium.webdriver.support.expected_conditions.frame_to_be_available_and_switch_to_it(locator: Tuple[str, str] | str) → Callable[[WebDriver], bool]

An expectation for checking whether the given frame is available to switch to.

Parameters:

locatorUnion[Tuple[str, str], str]

Used to find the frame.

Returns:

boolean : True when the frame is available, False otherwise.

Example:

>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> WebDriverWait(driver, 10).until(
... EC.frame_to_be_available_and_switch_to_it("frame_name"))

Notes:

If the frame is available it switches the given driver to the specified frame.

selenium.webdriver.support.expected_conditions.invisibility_of_element_located(locator: WebElement | Tuple[str, str]) → Callable[[WebDriver | WebElement], WebElement | bool]

An Expectation for checking that an element is either invisible or not present on the DOM.

Parameters:

locatorUnion[WebElement, Tuple[str, str]]

Used to find the element.

Returns:

boolean : True when the element is invisible or not present, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_invisible = WebDriverWait(driver, 10).until(
... EC.invisibility_of_element_located((By.CLASS_NAME, "foo")))

Notes:

• In the case of NoSuchElement, returns true because the element is not

present in DOM. The try block checks if the element is present but is invisible. - In the case of StaleElementReference, returns true because stale element reference implies that element is no longer visible.

selenium.webdriver.support.expected_conditions.invisibility_of_element(element: WebElement | Tuple[str, str]) → Callable[[WebDriver | WebElement], WebElement | bool]

An Expectation for checking that an element is either invisible or not present on the DOM.

Parameters:

elementUnion[WebElement, Tuple[str, str]]

Used to find the element.

Returns:

boolean : True when the element is invisible or not present, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_invisible_or_not_present = WebDriverWait(driver, 10).until(
... EC.invisibility_of_element(driver.find_element(By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.element_to_be_clickable(mark: WebElement | Tuple[str, str]) → Callable[[WebDriver | WebElement], Literal[False] | WebElement]

An Expectation for checking an element is visible and enabled such that you can click it.

Parameters:

markUnion[WebElement, Tuple[str, str]]

Used to find the element.

Returns:

WebElement : The WebElement once it is located and clickable.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> element = WebDriverWait(driver, 10).until(
... EC.element_to_be_clickable((By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.staleness_of(element: WebElement) → Callable[[Any], bool]

Wait until an element is no longer attached to the DOM.

Parameters:

elementWebElement

The element to wait for.

Returns:

boolean : False if the element is still attached to the DOM, true otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_element_stale = WebDriverWait(driver, 10).until(
... EC.staleness_of(driver.find_element(By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.element_to_be_selected(element: WebElement) → Callable[[Any], bool]

An expectation for checking the selection is selected.

Parameters:

elementWebElement

The WebElement to check.

Returns:

boolean : True if the element is selected, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_selected = WebDriverWait(driver, 10).until(
... EC.element_to_be_selected(driver.find_element(By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.element_located_to_be_selected(locator: Tuple[str, str]) → Callable[[WebDriver | WebElement], bool]

An expectation for the element to be located is selected.

Parameters:

locatorTuple[str, str]

Used to find the element.

Returns:

boolean : True if the element is selected, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_selected = WebDriverWait(driver, 10).until(
... EC.element_located_to_be_selected((By.CLASS_NAME, "foo")))

selenium.webdriver.support.expected_conditions.element_selection_state_to_be(element: WebElement, is_selected: bool) → Callable[[Any], bool]

An expectation for checking if the given element is selected.

Parameters:

elementWebElement

The WebElement to check.

is_selected : bool

Returns:

boolean : True if the element’s selection state is the same as is_selected

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_selected = WebDriverWait(driver, 10).until(
... EC.element_selection_state_to_be(driver.find_element(By.CLASS_NAME, "foo"), True))

selenium.webdriver.support.expected_conditions.element_located_selection_state_to_be(locator: Tuple[str, str], is_selected: bool) → Callable[[WebDriver | WebElement], bool]

An expectation to locate an element and check if the selection state specified is in that state.

Parameters:

locatorTuple[str, str]

Used to find the element.

is_selected : bool

Returns:

boolean : True if the element’s selection state is the same as is_selected

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_selected = WebDriverWait(driver, 10).until(
... EC.element_located_selection_state_to_be((By.CLASS_NAME, "foo"), True))

selenium.webdriver.support.expected_conditions.number_of_windows_to_be(num_windows: int) → Callable[[WebDriver], bool]

An expectation for the number of windows to be a certain value.

Parameters:

num_windowsint

The expected number of windows.

Returns:

boolean : True when the number of windows matches, False otherwise.

Example:

>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_number_of_windows = WebDriverWait(driver, 10).until(
... EC.number_of_windows_to_be(2))

selenium.webdriver.support.expected_conditions.new_window_is_opened(current_handles: List[str]) → Callable[[WebDriver], bool]

An expectation that a new window will be opened and have the number of windows handles increase.

Parameters:

current_handlesList[str]

The current window handles.

Returns:

boolean : True when a new window is opened, False otherwise.

Example:

>>> from selenium.webdriver.support.ui import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_new_window_opened = WebDriverWait(driver, 10).until(
... EC.new_window_is_opened(driver.window_handles))

selenium.webdriver.support.expected_conditions.alert_is_present() → Callable[[WebDriver], Alert | Literal[False]]

An expectation for checking if an alert is currently present and switching to it.

Returns:

Alert : The Alert once it is located.

Example:

>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> alert = WebDriverWait(driver, 10).until(EC.alert_is_present())

Notes:

If the alert is present it switches the given driver to it.

selenium.webdriver.support.expected_conditions.element_attribute_to_include(locator: Tuple[str, str], attribute_: str) → Callable[[WebDriver | WebElement], bool]

An expectation for checking if the given attribute is included in the specified element.

Parameters:

locatorTuple[str, str]

Used to find the element.

attribute_str

The attribute to check.

Returns:

boolean : True when the attribute is included, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> is_attribute_in_element = WebDriverWait(driver, 10).until(
... EC.element_attribute_to_include((By.CLASS_NAME, "foo"), "bar"))

selenium.webdriver.support.expected_conditions.any_of(*expected_conditions: Callable[[D], T]) → Callable[[D], Literal[False] | T]

An expectation that any of multiple expected conditions is true.

Parameters:

expected_conditionsCallable[[D], T]

The list of expected conditions to check.

Returns:

T : The result of the first matching condition, or False if none do.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> element = WebDriverWait(driver, 10).until(
... EC.any_of(EC.presence_of_element_located((By.NAME, "q"),
... EC.visibility_of_element_located((By.NAME, "q"))))

Notes:

Equivalent to a logical ‘OR’. Returns results of the first matching condition, or False if none do.

selenium.webdriver.support.expected_conditions.all_of(*expected_conditions: Callable[[D], Literal[False] | T]) → Callable[[D], List[T] | Literal[False]]

An expectation that all of multiple expected conditions is true.

Parameters:

expected_conditionsCallable[[D], Union[T, Literal[False]]]

The list of expected conditions to check.

Returns:

List[T] : The results of all the matching conditions, or False if any do not.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> elements = WebDriverWait(driver, 10).until(
... EC.all_of(EC.presence_of_element_located((By.NAME, "q"),
... EC.visibility_of_element_located((By.NAME, "q"))))

Notes:

Equivalent to a logical ‘AND’. Returns: When any ExpectedCondition is not met: False. When all ExpectedConditions are met: A List with each ExpectedCondition’s return value.

selenium.webdriver.support.expected_conditions.none_of(*expected_conditions: Callable[[D], Any]) → Callable[[D], bool]

An expectation that none of 1 or multiple expected conditions is true.

Parameters:

expected_conditionsCallable[[D], Any]

The list of expected conditions to check.

Returns:

boolean : True if none of the conditions are true, False otherwise.

Example:

>>> from selenium.webdriver.common.by import By
>>> from selenium.webdriver.support.ui import WebDriverWait
>>> from selenium.webdriver.support import expected_conditions as EC
>>> element = WebDriverWait(driver, 10).until(
... EC.none_of(EC.presence_of_element_located((By.NAME, "q"),
... EC.visibility_of_element_located((By.NAME, "q"))))

Notes:

Equivalent to a logical ‘NOT-OR’. Returns a Boolean