robo_appian 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

robo_appian/components/DropdownUtils.py

@@ -2,176 +2,243 @@ 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.components.InputUtils import InputUtils
+from selenium.common.exceptions import NoSuchElementException
 
 
 class DropdownUtils:
     """
     Utility class for interacting with dropdown components in Appian UI.
-
-        Usage Example:
-
+    Usage Example:
         # Select a value from a dropdown
         from robo_appian.components.DropdownUtils import DropdownUtils
         DropdownUtils.selectDropdownValueByLabelText(wait, "Status", "Approved")
-
-        # Select a value from a search dropdown
-        from robo_appian.components.DropdownUtils import DropdownUtils
-        DropdownUtils.selectSearchDropdownValueByLabelText(wait, "Category", "Finance")
     """
 
     @staticmethod
-    def __findDropdownComponentsByXpath(wait: WebDriverWait, xpath: str):
+    def __findComboboxByPartialLabelText(wait: WebDriverWait, label: str):
+        """
+        Finds a combobox by its partial label text.
+
+        :param wait: Selenium WebDriverWait instance.
+        :param label: The partial label of the combobox to find.
+        :return: WebElement representing the combobox.
+        Example:
+            component = DropdownUtils.__findComboboxByPartialLabelText(wait, "Dropdown Label")
+        """
+        xpath = f'.//div[./div/span[contains(normalize-space(text()), "{label}")]]/div/div/div/div[@role="combobox" and not(@aria-disabled="true")]'  # noqa: E501
         try:
-            # Wait for at least one element to be present
-            try:
-                wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
-            except TimeoutError as e:
-                raise TimeoutError(
-                    f'No clickable dropdown component found for xpath "{xpath}": {str(e)}'
-                )
-            except Exception as e:
-                raise Exception(
-                    f'No clickable dropdown component found for xpath "{xpath}": {str(e)}'
-                )
+            component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        except Exception as e:
+            raise Exception(f'Could not find combobox with partial label "{label}" : {str(e)}')
 
-            # Find all matching elements
-            driver = wait._driver
-            components = driver.find_elements(By.XPATH, xpath)
+        return component
 
-            # Filter for clickable and displayed components
-            valid_components = []
-            for component in components:
-                try:
-                    if component.is_displayed() and component.is_enabled():
-                        valid_components.append(component)
-                except Exception:
-                    continue
+    @staticmethod
+    def __findComboboxByLabelText(wait: WebDriverWait, label: str):
+        """
+        Finds a combobox by its label text.
+
+        :param wait: Selenium WebDriverWait instance.
+        :param label: The label of the combobox to find.
+        :return: WebElement representing the combobox.
+        Example:
+            component = DropdownUtils.__findComboboxByLabelText(wait, "Dropdown Label")
+        """
+        xpath = f'.//div[./div/span[normalize-space(text())="{label}"]]/div/div/div/div[@role="combobox" and not(@aria-disabled="true")]'  # noqa: E501
+        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)}')
 
-            if not valid_components:
-                raise Exception(
-                    f'No valid dropdown components with xpath "{xpath}" found.'
-                )
+        return component
 
-            # Return single component if only one found, list if multiple
-            return valid_components
+    @staticmethod
+    def __clickCombobox(wait: WebDriverWait, combobox: WebElement):
+        """
+        Clicks the combobox to open the dropdown options.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param combobox: The combobox WebElement.
+        Example:
+            DropdownUtils.__clickCombobox(wait, combobox)
+        """
+        combobox.click()
 
-        except Exception as e:
-            raise Exception(
-                f'Dropdown component with xpath "{xpath}" not found: {str(e)}'
-            )
+    @staticmethod
+    def __findDropdownOptionId(wait: WebDriverWait, combobox: WebElement):
+        """
+        Finds the dropdown option id from the combobox.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param combobox: The combobox WebElement.
+        :return: The id of the dropdown options list.
+        Example:
+            dropdown_option_id = DropdownUtils.__findDropdownOptionId(wait, combobox)
+        """
+        dropdown_option_id = combobox.get_attribute("aria-controls")
+        if dropdown_option_id is None:
+            raise Exception('Dropdown component does not have a valid "aria-controls" attribute.')
+        return dropdown_option_id
 
     @staticmethod
-    def selectDropdownValueByComponent(wait, combobox, value):
-        dropdown_id = combobox.get_attribute("aria-controls")
-        combobox.click()
+    def __checkDropdownOptionValueExistsByDropdownOptionId(wait: WebDriverWait, dropdown_option_id: str, value: str):
+        """
+        Checks if a dropdown option value exists 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 check in the dropdown.
+        Example:
+            exists = DropdownUtils.checkDropdownOptionValueExistsByDropdownOptionId(wait, "dropdown_option_id", "Option Value")
+            if exists:
+                print("The value exists in the dropdown.")
+            else:
+                print("The value does not exist in the dropdown.")
+        """
+
+        xpath = f'.//div/ul[@id="{dropdown_option_id}"]/li[./div[normalize-space(text())="{value}"]]'
+        try:
+            wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+            return True
+        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)}')
 
-        option_xpath = f'.//div/ul[@id="{dropdown_id}"]/li[./div[normalize-space(text())="{value}"]]'
+    @staticmethod
+    def __selectDropdownValueByDropdownOptionId(wait: WebDriverWait, dropdown_option_id: str, value: str):
+        """
+        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")
+        """
+        option_xpath = f'.//div/ul[@id="{dropdown_option_id}"]/li[./div[normalize-space(text())="{value}"]]'
         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)))
-        except TimeoutError as e:
-            raise TimeoutError(
-                f'Could not find or click dropdown option "{value}" with xpath "{option_xpath}": {str(e)}'
-            )
+            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)))
+            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)}'
-            )
+            raise Exception(f'Could not find or click dropdown option "{value}" with xpath "{option_xpath}": {str(e)}')
         component.click()
 
     @staticmethod
-    def __selectDropdownValueByXpath(wait, xpath, value):
-        components = DropdownUtils.__findDropdownComponentsByXpath(wait, xpath)
-        for combobox in components:
-            if combobox.is_displayed() and combobox.is_enabled():
-                DropdownUtils.selectDropdownValueByComponent(wait, combobox, value)
+    def __selectDropdownValueByPartialLabelText(wait: WebDriverWait, label: str, value: str):
+        """
+        Selects a value from a dropdown by its label text.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param label: The label of the dropdown.
+        :param value: The value to select from the dropdown.
+        """
+        combobox = DropdownUtils.__findComboboxByPartialLabelText(wait, label)
+        DropdownUtils.__clickCombobox(wait, combobox)
+        dropdown_option_id = DropdownUtils.__findDropdownOptionId(wait, combobox)
+        DropdownUtils.__selectDropdownValueByDropdownOptionId(wait, dropdown_option_id, value)
 
     @staticmethod
-    def selectDropdownValueByLabelText(
-        wait: WebDriverWait, dropdown_label: str, value: str
-    ):
-        xpath = f'.//div[./div/span[normalize-space(text())="{dropdown_label}"]]/div/div/div/div[@role="combobox" and @tabindex="0"]'
-        DropdownUtils.__selectDropdownValueByXpath(wait, xpath, value)
+    def __selectDropdownValueByLabelText(wait: WebDriverWait, label: str, value: str):
+        """
+        Selects a value from a dropdown by its label text.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param label: The label of the dropdown.
+        :param value: The value to select from the dropdown.
+        """
+        combobox = DropdownUtils.__findComboboxByLabelText(wait, label)
+        DropdownUtils.__clickCombobox(wait, combobox)
+        dropdown_option_id = DropdownUtils.__findDropdownOptionId(wait, combobox)
+        DropdownUtils.__selectDropdownValueByDropdownOptionId(wait, dropdown_option_id, value)
 
     @staticmethod
-    def selectDropdownValueByPartialLabelText(
-        wait: WebDriverWait, dropdown_label: str, value: str
-    ):
-        xpath = f'.//div[./div/span[contains(normalize-space(text()), "{dropdown_label}")]]/div/div/div/div[@role="combobox" and @tabindex="0"]'
-        DropdownUtils.__selectDropdownValueByXpath(wait, xpath, value)
+    def checkReadOnlyStatusByLabelText(wait: WebDriverWait, label: str):
+        """
+        Checks if a dropdown is read-only 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.
+        Example:
+            is_read_only = DropdownUtils.checkReadOnlyStatusByLabelText(wait, "Dropdown Label")
+            if is_read_only:
+                print("The dropdown is read-only.")
+            else:
+                print("The dropdown is editable.")
+        """
+        xpath = f'.//div[./div/span[normalize-space(text())="{label}"]]/div/div/p[text()]'
+        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}"')
 
     @staticmethod
-    def __selectSearchDropdownValueByXpath(wait, xpath, value):
-        components = DropdownUtils.__findDropdownComponentsByXpath(wait, xpath)
-
-        for component in components:
-            if component.is_displayed() and component.is_enabled():
-                component_id = component.get_attribute("aria-labelledby")  # type: ignore[reportUnknownMemberType]
-                dropdown_id = component.get_attribute("aria-controls")  # type: ignore[reportUnknownMemberType]
-                component.click()
-
-                input_component_id = str(component_id) + "_searchInput"
-                try:
-                    input_component = wait.until(
-                        EC.element_to_be_clickable((By.ID, input_component_id))
-                    )
-                except TimeoutError as e:
-                    raise TimeoutError(
-                        f'Could not find or click search input component with id "{input_component_id}": {str(e)}'
-                    )
-                except Exception as e:
-                    raise Exception(
-                        f'Could not find or click search input component with id "{input_component_id}": {str(e)}'
-                    )
-                InputUtils._setComponentValue(input_component, value)
-
-                xpath = f'.//ul[@id="{dropdown_id}"]/li[./div[normalize-space(text())="{value}"]][1]'
-                try:
-                    component = wait.until(
-                        EC.element_to_be_clickable((By.XPATH, xpath))
-                    )
-                except TimeoutError as e:
-                    raise TimeoutError(
-                        f'Could not find or click search dropdown option "{value}" with xpath "{xpath}": {str(e)}'
-                    )
-                except Exception as e:
-                    raise Exception(
-                        f'Could not find or click search dropdown option "{value}" with xpath "{xpath}": {str(e)}'
-                    )
-                component.click()
+    def selectDropdownValueByComboboxComponent(wait: WebDriverWait, combobox: WebElement, value: str):
+        """
+        Selects a value from a dropdown using the combobox component.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param combobox: The combobox WebElement.
+        :param value: The value to select from the dropdown.
+        Example:
+            DropdownUtils.selectDropdownValueByComboboxComponent(wait, combobox, "Option Value")
+        """
+        dropdown_option_id = DropdownUtils.__findDropdownOptionId(wait, combobox)
+        DropdownUtils.__clickCombobox(wait, combobox)
+        DropdownUtils.__selectDropdownValueByDropdownOptionId(wait, dropdown_option_id, value)
 
     @staticmethod
-    def selectSearchDropdownValueByLabelText(
-        wait: WebDriverWait, dropdown_label: str, value: str
-    ):
-        xpath = f'.//div[./div/span[normalize-space(text())="{dropdown_label}"]]/div/div/div/div[@role="combobox" and @tabindex="0"]'
-        DropdownUtils.__selectSearchDropdownValueByXpath(wait, xpath, value)
+    def selectDropdownValueByLabelText(wait: WebDriverWait, dropdown_label: str, value: str):
+        """
+        Selects a value from a dropdown by its label text.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param dropdown_label: The label of the dropdown.
+        :param value: The value to select from the dropdown.
+        Example:
+            DropdownUtils.selectDropdownValueByLabelText(wait, "Dropdown Label", "Option Value")
+        """
+        DropdownUtils.__selectDropdownValueByLabelText(wait, dropdown_label, value)
 
     @staticmethod
-    def selectSearchDropdownValueByPartialLabelText(
-        wait: WebDriverWait, dropdown_label: str, value: str
-    ):
-        xpath = f'.//div[./div/span[contains(normalize-space(text()), "{dropdown_label}")]]/div/div/div/div[@role="combobox" and @tabindex="0"]'
-        DropdownUtils.__selectSearchDropdownValueByXpath(wait, xpath, value)
+    def selectDropdownValueByPartialLabelText(wait: WebDriverWait, dropdown_label: str, value: str):
+        """
+        Selects a value from a dropdown by its partial label text.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param dropdown_label: The partial label of the dropdown.
+        :param value: The value to select from the dropdown.
+        Example:
+            DropdownUtils.selectDropdownValueByPartialLabelText(wait, "Dropdown Label", "Option Value")
+        """
+        DropdownUtils.__selectDropdownValueByPartialLabelText(wait, dropdown_label, value)
 
     @staticmethod
-    def selectValueByDropdownWrapperComponent(
-        wait: WebDriverWait, component: WebElement, value: str
-    ):
-        xpath = './div/div[@role="combobox" and @tabindex="0"]'
-        try:
-            combobox = component.find_element(By.XPATH, xpath)
-        except TimeoutError as e:
-            raise TimeoutError(
-                f'Could not find combobox element with xpath "{xpath}" in the provided component: {str(e)}'
-            )
-        except Exception as e:
-            raise Exception(
-                f'Could not find combobox element with xpath "{xpath}" in the provided component: {str(e)}'
-            )
-        DropdownUtils.selectDropdownValueByComponent(wait, combobox, value)
-        return combobox
+    def checkDropdownOptionValueExists(wait: WebDriverWait, dropdown_label: str, value: str):
+        """
+        Checks if a dropdown option value exists by its label text.
+
+        :param wait: WebDriverWait instance to wait for elements.
+        :param dropdown_label: The label of the dropdown.
+        :param value: The value to check in the dropdown.
+        :return: True if the value exists, False otherwise.
+        Example:
+            exists = DropdownUtils.checkDropdownOptionValueExists(wait, "Dropdown Label", "Option Value")
+            if exists:
+                print("The value exists in the dropdown.")
+            else:
+                print("The value does not exist in the dropdown.")
+        """
+        combobox = DropdownUtils.__findComboboxByLabelText(wait, dropdown_label)
+        DropdownUtils.__clickCombobox(wait, combobox)
+        dropdown_option_id = DropdownUtils.__findDropdownOptionId(wait, combobox)
+        return DropdownUtils.__checkDropdownOptionValueExistsByDropdownOptionId(wait, dropdown_option_id, value)

robo_appian/components/InputUtils.py

@@ -1,6 +1,5 @@
 from robo_appian.utils.ComponentUtils import ComponentUtils
 from selenium.webdriver.common.by import By
-from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.remote.webelement import WebElement
@@ -9,44 +8,31 @@ from selenium.webdriver.remote.webelement import WebElement
 class InputUtils:
     """
     Utility class for interacting with input components in Appian UI.
-
-        Usage Example:
-
-        # Set a value in an input field
+    Usage Example:
         from robo_appian.components.InputUtils import InputUtils
+
+        # Set a value in an input component by its label
         InputUtils.setValueByLabelText(wait, "Username", "test_user")
 
+        # Set a value in an input component by its ID
+        InputUtils.setValueById(wait, "inputComponentId", "test_value")
     """
 
     @staticmethod
-    def setValueAndSubmitByComponent(component: WebElement, value: str):
+    def __findInputComponentsByXpath(wait: WebDriverWait, xpath: str):
         """
-        Sets a value in an input component and submits it using the provided component element.
+        Finds input components by their XPath.
 
         Parameters:
-            component: The Selenium WebElement for the input component.
-            value: The value to set in the input field.
+            wait: Selenium WebDriverWait instance.
+            xpath: The XPath expression to locate the input components.
 
         Returns:
-            The Selenium WebElement for the input component after setting the value and submitting.
+            A list of Selenium WebElement representing the input components.
 
         Example:
-            InputUtils.setValueAndSubmitByComponent(component, "test_user")
-
+            InputUtils.__findInputComponentsByXpath(wait, './/div/label[normalize-space(text())="Username"]')
         """
-        # This method assumes that the component is already found and passed as an argument.
-
-        if not component.is_displayed():
-            raise Exception(
-                f"Component with label '{component.text}' is not displayed."
-            )
-
-        component = InputUtils._setComponentValue(component, value)
-        component.send_keys(Keys.ENTER)
-        return component
-
-    @staticmethod
-    def __findInputComponentsByXpath(wait: WebDriverWait, xpath: str):
         label_components = ComponentUtils.findComponentsByXPath(wait, xpath)
         input_components = []
         for label_component in label_components:
@@ -54,34 +40,62 @@ class InputUtils:
             component_id = label_component.get_attribute(attribute)  # type: ignore[reportUnknownMemberType]
             if component_id:
                 try:
-                    component = wait.until(
-                        EC.element_to_be_clickable((By.ID, component_id))
-                    )
+                    component = wait.until(EC.element_to_be_clickable((By.ID, component_id)))
                     input_components.append(component)
-                except TimeoutError as e:
-                    raise TimeoutError(
-                        f"Timeout or error finding input component with id '{component_id}': {e}"
-                    )
                 except Exception as e:
-                    raise Exception(
-                        f"Timeout or error finding input component with id '{component_id}': {e}"
-                    )
+                    raise Exception(f"Could not find clickable input component with id '{component_id}': {e}")
+            else:
+                raise ValueError(f"Input component with label '{label_component.text}' does not have 'for' attribute.")
         return input_components
 
     @staticmethod
     def __findInputComponentsByPartialLabel(wait: WebDriverWait, label: str):
+        """Finds input components by their label text, allowing for partial matches.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the input component, allowing for partial matches.
+
+        Returns:
+            A list of Selenium WebElement representing the input components.
+
+        Example:
+            InputUtils.__findInputComponentsByPartialLabel(wait, "Username")
+        """
         xpath = f'.//div/label[contains(normalize-space(text()), "{label}")]'
         components = InputUtils.__findInputComponentsByXpath(wait, xpath)
         return components
 
     @staticmethod
-    def __findInputComponentsByLabel(wait: WebDriverWait, label: str):
+    def __findComponentsByLabel(wait: WebDriverWait, label: str):
+        """Finds input components by their label text.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the input component.
+
+        Returns:
+            A list of Selenium WebElement representing the input components.
+
+        Example:
+            InputUtils.__findComponentsByLabel(wait, "Username")
+        """
         xpath = f'.//div/label[normalize-space(text())="{label}"]'
         components = InputUtils.__findInputComponentsByXpath(wait, xpath)
         return components
 
     @staticmethod
-    def _setComponentValue(component: WebElement, value: str):
+    def _setValueByComponent(component: WebElement, value: str):
+        """
+        Sets a value in an input component.
+        Parameters:
+            component: The Selenium WebElement for the input component.
+            value: The value to set in the input field.
+        Returns:
+            The Selenium WebElement for the input component after setting the value.
+        Example:
+            InputUtils._setValueByComponent(component, "test_value")
+        """
         component.clear()
         component.send_keys(value)
         return component
@@ -101,7 +115,7 @@ class InputUtils:
         """
 
         for component in input_components:
-            InputUtils._setComponentValue(component, value)
+            InputUtils._setValueByComponent(component, value)
 
     @staticmethod
     def setValueByPartialLabelText(wait: WebDriverWait, label: str, value: str):
@@ -110,20 +124,42 @@ class InputUtils:
 
     @staticmethod
     def setValueByLabelText(wait: WebDriverWait, label: str, value: str):
-        input_components = InputUtils.__findInputComponentsByLabel(wait, label)
+        """
+        Sets a value in an input component identified by its label text.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the input component.
+            value: The value to set in the input field.
+
+        Returns:
+            None
+
+        Example:
+            InputUtils.setValueByLabelText(wait, "Username", "test_user")
+        """
+        input_components = InputUtils.__findComponentsByLabel(wait, label)
         InputUtils.__setValueByComponents(wait, input_components, value)
 
     @staticmethod
     def setValueById(wait: WebDriverWait, component_id: str, value: str):
+        """
+        Sets a value in an input component identified by its ID.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            component_id: The ID of the input component.
+            value: The value to set in the input field.
+
+        Returns:
+            The Selenium WebElement for the input component after setting the value.
+
+        Example:
+            InputUtils.setValueById(wait, "inputComponentId", "test_value")
+        """
         try:
             component = wait.until(EC.element_to_be_clickable((By.ID, component_id)))
-        except TimeoutError as e:
-            raise TimeoutError(
-                f"Timeout or error finding input component with id '{component_id}': {e}"
-            )
         except Exception as e:
-            raise Exception(
-                f"Timeout or error finding input component with id '{component_id}': {e}"
-            )
-        InputUtils._setComponentValue(component, value)
+            raise Exception(f"Timeout or error finding input component with id '{component_id}': {e}")
+        InputUtils._setValueByComponent(component, value)
         return component

robo_appian/components/LabelUtils.py

@@ -6,49 +6,41 @@ from selenium.webdriver.support.ui import WebDriverWait
 class LabelUtils:
     """
     Utility class for interacting with label components in Appian UI.
-
-        Usage Example:
-
-        # Find a label component
-        from robo_appian.components.LabelUtils import LabelUtils
-        label_component = LabelUtils.find(wait, "Username")
-
+    Usage Example:
+        # Find a label by its text
+        component = LabelUtils.findByLabelText(wait, "Submit")
+        # Click a label by its text
+        LabelUtils.clickByLabelText(wait, "Submit")
     """
 
     @staticmethod
-    def find(wait: WebDriverWait, label: str):
+    def findByLabelText(wait: WebDriverWait, label: str):
         """
-        Finds a label component by its text.
-
-        Parameters:
-            wait: Selenium WebDriverWait instance.
-            label: The visible text label of the component.
-
-        Returns:
-            The Selenium WebElement for the label component.
+        Finds a label element by its text.
 
+        :param wait: Selenium WebDriverWait instance.
+        :param label: The text of the label to find.
+        :return: WebElement representing the label.
         Example:
-            LabelUtils.find(wait, "Username")
-
+            component = LabelUtils.findByLabelText(wait, "Submit")
         """
-        # This method locates a label component that contains the specified text.
-        # It uses XPath to find the element that matches the text.
-
         xpath = f".//*[normalize-space(text())='{label}']"
         try:
             component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
-        except TimeoutError as e:
-            raise TimeoutError(
-                f"Label '{label}' not found within the timeout period."
-            ) from e
         except Exception as e:
-            raise Exception(
-                f"Label '{label}' not found within the timeout period."
-            ) from e
+            raise RuntimeError(f"Label with text '{label}' not found.") from e
 
         return component
 
     @staticmethod
-    def click(wait: WebDriverWait, label: str):
-        component = LabelUtils.find(wait, label)
+    def clickByLabelText(wait: WebDriverWait, label: str):
+        """
+        Clicks a label element identified by its text.
+
+        :param wait: Selenium WebDriverWait instance.
+        :param label: The text of the label to click.
+        Example:
+            LabelUtils.clickByLabelText(wait, "Submit")
+        """
+        component = LabelUtils.findByLabelText(wait, label)
         component.click()