robo_appian 0.0.27__py3-none-any.whl → 0.0.34__py3-none-any.whl

robo_appian/__init__.py

@@ -1,5 +1,6 @@
-from robo_appian.components.ButtonUtils import ButtonUtils
+from robo_appian.utils.RoboUtils import RoboUtils
 from robo_appian.utils.ComponentUtils import ComponentUtils
+from robo_appian.components.ButtonUtils import ButtonUtils
 from robo_appian.components.DateUtils import DateUtils
 from robo_appian.components.DropdownUtils import DropdownUtils
 from robo_appian.components.InputUtils import InputUtils
@@ -15,6 +16,7 @@ __version__ = ComponentUtils.get_version()
 
 __all__ = [
     "ButtonUtils",
+    "RoboUtils",
     "ComponentUtils",
     "DateUtils",
     "DropdownUtils",
@@ -25,5 +27,5 @@ __all__ = [
     "TableUtils",
     "TabUtils",
     "BrowserUtils",
-    "SearchInputUtils"
+    "SearchInputUtils",
 ]

robo_appian/components/ButtonUtils.py

@@ -1,23 +1,35 @@
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.remote.webelement import WebElement
 from robo_appian.utils.ComponentUtils import ComponentUtils
 
 
 class ButtonUtils:
     """
-    Utility class for interacting with button components in Appian UI.
-    Usage Example:
-        # Click a button by its label
-        from robo_appian.components.ButtonUtils import ButtonUtils
+    Click buttons, action links, and control components using visible text labels.
+
+    Find and interact with buttons by their user-visible text. All methods automatically
+    handle whitespace variations and work reliably with overlaid or animated elements.
+
+    All methods follow the wait-first pattern: pass WebDriverWait as the first argument.
+
+    Examples:
+        >>> from robo_appian import ButtonUtils
+
+        # Click by exact label match
         ButtonUtils.clickByLabelText(wait, "Submit")
-    """
+        ButtonUtils.clickByLabelText(wait, "Save Changes")
 
-    @staticmethod
-    def __click(wait: WebDriverWait, component: WebElement):
-        wait.until(EC.element_to_be_clickable(component))
-        component.click()
+        # Click by partial label match (useful for buttons with dynamic text)
+        ButtonUtils.clickByPartialLabelText(wait, "Save")
+
+        # Click by element ID (when labels are unavailable)
+        ButtonUtils.clickById(wait, "save_button_123")
+
+        # Check if button exists before clicking
+        if ButtonUtils.isButtonExistsByLabelText(wait, "Delete"):
+            ButtonUtils.clickByLabelText(wait, "Delete")
+    """
 
     @staticmethod
     def _findByPartialLabelText(wait: WebDriverWait, label: str):
@@ -27,7 +39,6 @@ class ButtonUtils:
         Parameters:
             wait: Selenium WebDriverWait instance.
             label: The label of the button to find.
-            label: The label of the button to find.
 
         Returns:
             WebElement representing the button.
@@ -36,26 +47,17 @@ class ButtonUtils:
             component = ButtonUtils._findByPartialLabelText(wait, "Submit")
         """
         xpath = f"//button[./span[contains(translate(normalize-space(.), '\u00a0', ' '), '{label}')]]"
-        try:
-            component = ComponentUtils.waitForComponentToBeVisibleByXpath(wait, xpath)
-        except Exception as e:
-            raise Exception(
-                f"Button with label '{label}' not found or not clickable."
-            ) from e
-        return component
+        return ComponentUtils.waitForComponentToBeVisibleByXpath(wait, xpath)
 
     @staticmethod
     def __findByLabelText(wait: WebDriverWait, label: str):
         xpath = f".//button[./span[normalize-space(.)='{label}']]"
-        try:
-            component = ComponentUtils.waitForComponentToBeVisibleByXpath(wait, xpath)
-        except Exception as e:
-            raise Exception(f"Button with label '{label}' not found.") from e
-        return component
+        return ComponentUtils.waitForComponentToBeVisibleByXpath(wait, xpath)
 
     @staticmethod
     def clickByPartialLabelText(wait: WebDriverWait, label: str):
-        """Finds a button by its partial label and clicks it.
+        """
+        Finds a button by its partial label and clicks it.
 
         Parameters:
             wait: Selenium WebDriverWait instance.
@@ -64,45 +66,73 @@ class ButtonUtils:
                 ButtonUtils.clickByPartialLabelText(wait, "Button Label")
         """
         component = ButtonUtils._findByPartialLabelText(wait, label)
-        ButtonUtils.__click(wait, component)
+
+        ComponentUtils.click(wait, component)
 
     @staticmethod
     def clickByLabelText(wait: WebDriverWait, label: str):
-        """Finds a button by its label and clicks it.
+        """
+        Click a button by its exact label text.
 
-        Parameters:
-            wait: Selenium WebDriverWait instance.
-            label: The label of the button to click.
-            Example:
-                ButtonUtils.clickByLabelText(wait, "Button Label")
+        Finds and clicks a button element containing the exact label text, handling whitespace
+        and NBSP characters reliably through normalized matching.
+
+        Args:
+            wait: WebDriverWait instance.
+            label: Exact button text (e.g., "Submit", "Save", "Cancel").
+
+        Raises:
+            TimeoutException: If button not found or not clickable within timeout.
+
+        Examples:
+            >>> ButtonUtils.clickByLabelText(wait, "Submit")
+            >>> ButtonUtils.clickByLabelText(wait, "Save Changes")
+            >>> ButtonUtils.clickByLabelText(wait, "Cancel")
         """
         component = ButtonUtils.__findByLabelText(wait, label)
-        ButtonUtils.__click(wait, component)
+
+        ComponentUtils.click(wait, component)
 
     @staticmethod
     def clickById(wait: WebDriverWait, id: str):
-        """
-        Finds and clicks an input button by its HTML id attribute.
+        """Click a button by its HTML id attribute.
 
-        Parameters:
-            wait: Selenium WebDriverWait instance.
-            id: The HTML id of the input button.
+        Finds and clicks a button using its HTML id. Use when label-based locators
+        are unavailable or unreliable.
 
-        Example:
-            ButtonUtils.clickById(wait, "button_id")
+        Args:
+            wait: WebDriverWait instance.
+            id: The HTML id of the button element.
 
-        """
-        try:
-            component = wait.until(EC.element_to_be_clickable((By.ID, id)))
-        except Exception as e:
-            raise Exception(
-                f"Input button with id '{id}' not found or not clickable."
-            ) from e
+        Raises:
+            TimeoutException: If button not found or not clickable within timeout.
 
-        ButtonUtils.__click(wait, component)
+        Examples:
+            >>> ButtonUtils.clickById(wait, "save_button")
+            >>> ButtonUtils.clickById(wait, "submit_btn_123")
+        """
+        component = wait.until(EC.element_to_be_clickable((By.ID, id)))
+        ComponentUtils.click(wait, component)
 
     @staticmethod
     def isButtonExistsByLabelText(wait: WebDriverWait, label: str):
+        """
+        Check if a button exists by exact label match.
+
+        Searches for a button with the exact label text and returns True if found.
+        Does not raise exceptions; returns boolean result.
+
+        Args:
+            wait: WebDriverWait instance.
+            label: Exact button label text to match.
+
+        Returns:
+            bool: True if button found, False otherwise.
+
+        Examples:
+            >>> if ButtonUtils.isButtonExistsByLabelText(wait, "Delete"):
+            ...     ButtonUtils.clickByLabelText(wait, "Delete")
+        """
         xpath = f".//button[./span[normalize-space(.)='{label}']]"
         try:
             ComponentUtils.findComponentByXPath(wait, xpath)
@@ -112,6 +142,19 @@ class ButtonUtils:
 
     @staticmethod
     def isButtonExistsByPartialLabelText(wait: WebDriverWait, label: str):
+        """
+        Check if a button exists by partial label match.
+
+        Searches for a button containing the partial label text. Returns True if found, False otherwise.
+        Does not raise exceptions.
+
+        Args:
+            wait: WebDriverWait instance.
+            label: Partial button label text to match.
+
+        Returns:
+            bool: True if button found, False otherwise.
+        """
         xpath = f".//button[./span[contains(translate(normalize-space(.), '\u00a0', ' '), '{label}')]]"
         try:
             ComponentUtils.findComponentByXPath(wait, xpath)
@@ -121,17 +164,47 @@ class ButtonUtils:
 
     @staticmethod
     def isButtonExistsByPartialLabelTextAfterLoad(wait: WebDriverWait, label: str):
+        """
+        Check if a button exists by partial label match after page load.
+
+        Validates button presence after page reloads or dynamic content loading.
+        Returns True if found, False otherwise.
+
+        Args:
+            wait: WebDriverWait instance.
+            label: Partial button label text to match.
+
+        Returns:
+            bool: True if button found and visible, False otherwise.
+        """
+        xpath = f".//button[./span[contains(translate(normalize-space(.), '\u00a0', ' '), '{label}')]]"
         try:
-            ButtonUtils._findByPartialLabelText(wait, label)
+            ComponentUtils.waitForComponentToBeVisibleByXpath(wait, xpath)
+            return True
         except Exception:
             return False
-        return True
 
     @staticmethod
     def waitForButtonToBeVisibleByPartialLabelText(wait: WebDriverWait, label: str):
+        """
+        Wait for a button to be visible by partial label match.
+
+        Blocks until a button containing the partial label text becomes visible
+        or timeout occurs.
+
+        Args:
+            wait: WebDriverWait instance.
+            label: Partial button label text to match.
+
+        Returns:
+            WebElement: The visible button element.
+
+        Raises:
+            TimeoutException: If button not visible within timeout.
+
+        Examples:
+            >>> ButtonUtils.waitForButtonToBeVisibleByPartialLabelText(wait, "Submit")
+            >>> ButtonUtils.clickByPartialLabelText(wait, "Submit")
+        """
         xpath = f".//button[./span[contains(translate(normalize-space(.), '\u00a0', ' '), '{label}')]]"
-        try:
-            component = ComponentUtils.waitForComponentToBeVisibleByXpath(wait, xpath)
-        except Exception as e:
-            raise Exception(f"Button with partial label '{label}' not visible.") from e
-        return component
+        return ComponentUtils.waitForComponentToBeVisibleByXpath(wait, xpath)

robo_appian/components/DateUtils.py

@@ -3,15 +3,37 @@ from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
 
 from robo_appian.components.InputUtils import InputUtils
+from robo_appian.utils.ComponentUtils import ComponentUtils
 
 
 class DateUtils:
     """
-    Utility class for interacting with date components in Appian UI.
-    Usage Example:
-        # Set a date value in a date component
-        from robo_appian.components.DateUtils import DateUtils
-        DateUtils.setValueByLabelText(wait, "Start Date", "2023-10-01")
+    Fill date picker components by label or interact with date input fields.
+
+    Set dates in Appian date picker components by their associated label. Handles both
+    text-based date entry and date picker interaction. Automatically waits for clickability
+    and formats dates according to Appian's expected format.
+
+    All methods follow the wait-first pattern: pass WebDriverWait as the first argument.
+
+    Examples:
+        >>> from robo_appian import DateUtils, ComponentUtils
+
+        # Set a date value
+        DateUtils.setValueByLabelText(wait, "Start Date", "01/15/2024")
+        DateUtils.setValueByLabelText(wait, "End Date", "12/31/2024")
+
+        # Use helper functions for common dates
+        DateUtils.setValueByLabelText(wait, "Today", ComponentUtils.today())
+        DateUtils.setValueByLabelText(wait, "Yesterday", ComponentUtils.yesterday())
+
+        # Click to open date picker
+        DateUtils.clickByLabelText(wait, "Event Date")
+
+    Note:
+        - Date format is typically MM/DD/YYYY for Appian
+        - Waits for clickability before interacting with date fields
+        - ComponentUtils.today() returns today's date as MM/DD/YYYY
     """
 
     @staticmethod
@@ -25,25 +47,36 @@ class DateUtils:
             DateUtils.__findComponent(wait, "Start Date")
         """
 
-        xpath = f'.//div[./div/label[text()="{label}"]]/div/div/div/input'
-        try:
-            component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
-        except Exception as e:
-            raise Exception(
-                f"Could not find clickable date component with label '{label}': {e}"
-            )
+        xpath = f'.//div[./div/label[normalize-space(translate(., "\u00a0", " "))="{label}"]]/div/div/div/input'
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
         return component
 
     @staticmethod
     def setValueByLabelText(wait: WebDriverWait, label: str, value: str):
         """
-        Sets the value of a date component.
-        :param wait: WebDriverWait instance to wait for elements.
-        :param label: The label of the date component.
-        :param value: The value to set in the date component.
-        :return: The WebElement representing the date component.
-        Example:
-            DateUtils.setValueByLabelText(wait, "Start Date", "2023-10-01")
+        Set a date in a date picker component by label.
+
+        Finds the date input by its associated label, waits for clickability, clears any
+        existing date, and enters the new date value.
+
+        Args:
+            wait: WebDriverWait instance.
+            label: Exact label text of the date component (e.g., "Start Date").
+            value: Date string in MM/DD/YYYY format (e.g., "01/15/2024").
+
+        Returns:
+            WebElement: The date input component (for chaining if needed).
+
+        Raises:
+            ValueError: If label has no 'for' attribute.
+            TimeoutException: If date input not found or not clickable within timeout.
+
+        Examples:
+            >>> DateUtils.setValueByLabelText(wait, "Start Date", "01/15/2024")
+            >>> DateUtils.setValueByLabelText(wait, "End Date", "12/31/2024")
+            >>> # Using helper for today's date
+            >>> from robo_appian.utils.ComponentUtils import ComponentUtils
+            >>> DateUtils.setValueByLabelText(wait, "Date", ComponentUtils.today())
         """
         component = DateUtils.__findComponent(wait, label)
         InputUtils._setValueByComponent(wait, component, value)
@@ -60,5 +93,6 @@ class DateUtils:
             DateUtils.clickByLabelText(wait, "Start Date")
         """
         component = DateUtils.__findComponent(wait, label)
-        component.click()
+
+        ComponentUtils.click(wait, component)
         return component

robo_appian/components/DropdownUtils.py

@@ -1,4 +1,5 @@
 import time
+from robo_appian.utils.ComponentUtils import ComponentUtils
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
@@ -8,11 +9,10 @@ from selenium.common.exceptions import NoSuchElementException
 
 class DropdownUtils:
     """
-    Utility class for interacting with dropdown components in Appian UI.
-    Usage Example:
-        # Select a value from a dropdown
-        from robo_appian.components.DropdownUtils import DropdownUtils
-        DropdownUtils.selectDropdownValueByLabelText(wait, "Status", "Approved")
+    Utility class for interacting with dropdown components in a web application.
+    Provides methods to select values, check statuses, and retrieve options from dropdowns.
+    Example:
+        DropdownUtils.selectDropdownValueByLabelText(wait, "Dropdown Label", "Option Value")
     """
 
     @staticmethod
@@ -22,26 +22,20 @@ class DropdownUtils:
         """
         Finds the combobox element by its label text.
         :param wait: WebDriverWait instance to wait for elements.
-        :param label: The label of the combobox.
+        :param label: The label of the dropdown.
         :param isPartialText: Whether to use partial text matching for the label.
         :return: The combobox WebElement.
         Example:
-            combobox = DropdownUtils.__findComboboxByLabelText(wait, "Dropdown Label", isPartialText=False)
-            combobox = DropdownUtils.__findComboboxByLabelText(wait, "Dropdown Label", isPartialText=True)
             combobox = DropdownUtils.__findComboboxByLabelText(wait, "Dropdown Label")
+            combobox = DropdownUtils.__findComboboxByLabelText(wait, "Dropdown Label", isPartialText=True)
         """
 
         if isPartialText:
-            xpath = f'//span[contains(normalize-space(.), "{label}")]/ancestor::div[@role="presentation"][1]//div[@aria-labelledby=//span[contains(normalize-space(.), "{label}")]/@id and @role="combobox" and not(@aria-disabled="true")]'
+            xpath = f'//span[contains(normalize-space(.), "{label}")]/ancestor::div[@role="presentation"][1]//div[@role="combobox" and not(@aria-disabled="true")]'
         else:
-            xpath = f'//span[normalize-space(.)="{label}"]/ancestor::div[@role="presentation"][1]//div[@aria-labelledby=//span[normalize-space(.)="{label}"]/@id and @role="combobox" and not(@aria-disabled="true")]'
+            xpath = f'//span[text()="{label}"]/ancestor::div[@role="presentation"][1]//div[@role="combobox" and not(@aria-disabled="true")]'
 
-        try:
-            component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
-        except Exception as e:
-            raise Exception(f'Could not find combobox with label "{label}" : {str(e)}')
-
-        return component
+        return wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
 
     @staticmethod
     def __clickCombobox(wait: WebDriverWait, combobox: WebElement):
@@ -53,12 +47,11 @@ class DropdownUtils:
         Example:
             DropdownUtils.__clickCombobox(wait, combobox)
         """
-        try:
-            wait.until(EC.element_to_be_clickable(combobox))
-            combobox.click()
-
-        except Exception as e:
-            raise Exception(f"Could not click combobox: {str(e)}")
+        component_id = combobox.get_attribute("id")
+        if not component_id:
+            raise ValueError("Combobox element does not have an 'id' attribute.")
+        element = wait.until(EC.element_to_be_clickable((By.ID, component_id)))
+        ComponentUtils.click(wait, element)
 
     @staticmethod
     def __findDropdownOptionId(combobox: WebElement):
@@ -103,9 +96,7 @@ class DropdownUtils:
         except NoSuchElementException:
             return False
         except Exception as e:
-            raise Exception(
-                f'Could not find dropdown option "{value}" with dropdown option id "{dropdown_option_id}": {str(e)}'
-            )
+            raise
 
     @staticmethod
     def __selectDropdownValueByDropdownOptionId(
@@ -113,31 +104,15 @@ class DropdownUtils:
     ):
         """
         Selects a value from a dropdown by its option id and value.
-
         :param wait: WebDriverWait instance to wait for elements.
         :param dropdown_option_id: The id of the dropdown options list.
         :param value: The value to select from the dropdown.
         Example:
-            DropdownUtils.selectDropdownValueByDropdownOptionId(wait, "dropdown_option_id", "Option Value")
+            DropdownUtils.__selectDropdownValueByDropdownOptionId(wait, "dropdown_option_id", "Option Value")
         """
         option_xpath = f'.//div/ul[@id="{dropdown_option_id}"]/li[./div[normalize-space(.)="{value}"]]'
-        try:
-            try:
-                component = wait.until(
-                    EC.presence_of_element_located((By.XPATH, option_xpath))
-                )
-                component = wait.until(
-                    EC.element_to_be_clickable((By.XPATH, option_xpath))
-                )
-                component.click()
-            except Exception as e:
-                raise Exception(
-                    f'Could not locate or click dropdown option "{value}" with dropdown option id "{dropdown_option_id}": {str(e)}'  # noqa: E501
-                )
-        except Exception as e:
-            raise Exception(
-                f'Could not find or click dropdown option "{value}" with xpath "{option_xpath}": {str(e)}'
-            )
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, option_xpath)))
+        component.click()
 
     @staticmethod
     def __selectDropdownValueByPartialLabelText(
@@ -176,27 +151,26 @@ class DropdownUtils:
     @staticmethod
     def checkReadOnlyStatusByLabelText(wait: WebDriverWait, label: str):
         """
-        Checks if a dropdown is read-only by its label text.
-
+        Checks if a dropdown is read-only (disabled) by its label text.
         :param wait: WebDriverWait instance to wait for elements.
         :param label: The label of the dropdown.
-        :return: True if the dropdown is read-only, False otherwise.
+        :return: True if the dropdown is read-only, False if editable.
         Example:
-            is_read_only = DropdownUtils.checkReadOnlyStatusByLabelText(wait, "Dropdown Label")
-            if is_read_only:
+            is_readonly = DropdownUtils.checkReadOnlyStatusByLabelText(wait, "Dropdown Label")
+            if is_readonly:
                 print("The dropdown is read-only.")
             else:
                 print("The dropdown is editable.")
         """
-        # xpath = f'.//div[./div/span[normalize-space(.)="{label}"]]/div/div/p[text()]'
+        # xpath = f'.//div[./div/span[normalize-space(.)="{label}"]]/div/div/p[normalize-space(translate(., "\u00a0", " "))]'
         xpath = f'//span[normalize-space(.)="{label}"]/ancestor::div[@role="presentation"][1]//div[@aria-labelledby=//span[normalize-space(.)="{label}"]/@id and not(@role="combobox")]'
         try:
             wait._driver.find_element(By.XPATH, xpath)
             return True
         except NoSuchElementException:
             return False
-        except Exception:
-            raise Exception(f'Error checking read-only status for label "{label}"')
+        except Exception as e:
+            raise
 
     @staticmethod
     def checkEditableStatusByLabelText(wait: WebDriverWait, label: str):
@@ -213,21 +187,34 @@ class DropdownUtils:
             else:
                 print("The dropdown is disabled.")
         """
-        xpath = f'//span[text()="{label}"]/ancestor::div[@role="presentation"][1]//div[@aria-labelledby=//span[normalize-space(.)="{label}"]/@id and @role="combobox" and not(@aria-disabled="true")]'
+        xpath = f'//span[normalize-space(translate(., "\u00a0", " "))="{label}"]/ancestor::div[@role="presentation"][1]//div[@aria-labelledby=//span[normalize-space(.)="{label}"]/@id and @role="combobox" and not(@aria-disabled="true")]'
         try:
             wait._driver.find_element(By.XPATH, xpath)
             return True  # If disabled element is found, dropdown is not editable
         except NoSuchElementException:
             return False  # If disabled element is not found, dropdown is editable
-        except Exception:
-            raise Exception(f'Error checking editable status for label "{label}"')
+        except Exception as e:
+            raise
 
     @staticmethod
     def waitForDropdownToBeEnabled(
         wait: WebDriverWait, label: str, wait_interval: float = 0.5, timeout: int = 2
     ):
+        """
+        Waits for a dropdown to become enabled (editable) by its label text.
+        :param wait: WebDriverWait instance to wait for elements.
+        :param label: The label of the dropdown.
+        :param wait_interval: The interval (in seconds) to wait between checks.
+        :param timeout: The maximum time (in seconds) to wait for the dropdown to become enabled.
+        :return: True if the dropdown becomes enabled within the timeout, False otherwise.
+        Example:
+            is_enabled = DropdownUtils.waitForDropdownToBeEnabled(wait, "Dropdown Label")
+            if is_enabled:
+                print("The dropdown is enabled.")
+            else:
+                print("The dropdown is still disabled.")
+        """
         elapsed_time = 0
-        status = False
 
         while elapsed_time < timeout:
             status = DropdownUtils.checkEditableStatusByLabelText(wait, label)
@@ -359,9 +346,7 @@ class DropdownUtils:
             DropdownUtils.__clickCombobox(wait, combobox)
             return option_texts
         except Exception as e:
-            raise Exception(
-                f'Could not get dropdown option values for label "{dropdown_label}": {str(e)}'
-            )
+            raise
 
     @staticmethod
     def waitForDropdownValuesToBeChanged(
@@ -371,10 +356,25 @@ class DropdownUtils:
         poll_frequency: float = 0.5,
         timeout: int = 2,
     ):
+        """
+        Waits for the values of a dropdown to change from the initial values.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param dropdown_label: The label of the dropdown.
+        :param initial_values: The initial values of the dropdown.
+        :param poll_frequency: The interval (in seconds) to wait between checks.
+        :param timeout: The maximum time (in seconds) to wait for the dropdown values to change.
+        :return: True if the dropdown values change within the timeout, False otherwise.
+        Example:
+            initial_values = DropdownUtils.getDropdownOptionValues(wait, "Dropdown Label")
+            is_changed = DropdownUtils.waitForDropdownValuesToBeChanged(wait, "Dropdown Label", initial_values)
+            if is_changed:
+                print("The dropdown values have changed.")
+            else:
+                print("The dropdown values have not changed within the timeout.")
+        """
 
         elapsed_time = 0
-        poll_frequency = 0.5
-        timeout = 4  # seconds
         while elapsed_time < timeout:
 
             current_values: list[str] = DropdownUtils.getDropdownOptionValues(