robo_appian 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

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()

robo_appian/components/LinkUtils.py

@@ -5,14 +5,16 @@ from selenium.webdriver.support.ui import WebDriverWait
 
 class LinkUtils:
     """
-    Utility class for interacting with link components in Appian UI.
-
-        Usage Example:
-
-        # Click a link with a specific label
+    Utility class for handling link operations in Selenium WebDriver.
+    Example usage:
+        from selenium import webdriver
+        from selenium.webdriver.support.ui import WebDriverWait
         from robo_appian.components.LinkUtils import LinkUtils
-        LinkUtils.click(wait, "Learn More")
 
+        driver = webdriver.Chrome()
+        wait = WebDriverWait(driver, 10)
+        LinkUtils.click(wait, "Learn More")
+        driver.quit()
     """
 
     @staticmethod
@@ -21,9 +23,7 @@ class LinkUtils:
         try:
             component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
         except TimeoutError as e:
-            raise TimeoutError(
-                f"Could not find clickable link with label '{label}': {e}"
-            )
+            raise TimeoutError(f"Could not find clickable link with label '{label}': {e}")
         except Exception as e:
             raise Exception(f"Could not find clickable link with label '{label}': {e}")
         return component

robo_appian/components/SearchDropdownUtils.py

@@ -20,7 +20,7 @@ class SearchDropdownUtils:
             input_component = wait.until(EC.element_to_be_clickable((By.ID, input_component_id)))
         except Exception as e:
             raise RuntimeError(f"Failed to locate or click input component with ID '{input_component_id}': {e}")
-        InputUtils._setComponentValue(input_component, value)
+        InputUtils._setValueByComponent(input_component, value)
 
         xpath = f'.//ul[@id="{dropdown_option_id}"]/li[./div[normalize-space(text())="{value}"]][1]'
         try:

robo_appian/components/SearchInputUtils.py

@@ -6,22 +6,31 @@ from robo_appian.utils.ComponentUtils import ComponentUtils
 
 
 class SearchInputUtils:
+    """
+    Utility class for handling search input operations in Selenium WebDriver.
+    Example usage:
+        from selenium import webdriver
+        from selenium.webdriver.support.ui import WebDriverWait
+        from robo_appian.components.SearchInputUtils import SearchInputUtils
+
+        driver = webdriver.Chrome()
+        wait = WebDriverWait(driver, 10)
+        SearchInputUtils.selectSearchDropdownByLabelText(wait, "Search Label", "Value")
+        driver.quit()
+    """
+
     @staticmethod
-    def __findSearchInputComponentsByLabelPathAndSelectValue(
-        wait: WebDriverWait, xpath: str, value: str
-    ):
+    def __findSearchInputComponentsByLabelPathAndSelectValue(wait: WebDriverWait, xpath: str, value: str):
         search_input_components = ComponentUtils.findComponentsByXPath(wait, xpath)
         input_components = []
         for search_input_component in search_input_components:
             attribute: str = "aria-controls"
             dropdown_list_id = search_input_component.get_attribute(attribute)
             if dropdown_list_id:
-                InputUtils._setComponentValue(search_input_component, value)
+                InputUtils._setValueByComponent(search_input_component, value)
                 xpath = f".//ul[@id='{dropdown_list_id}' and @role='listbox' ]/li[@role='option']/div/div/div/div/div/div/p[text()='{value}'][1]"
                 try:
-                    drop_down_item = wait.until(
-                        EC.element_to_be_clickable((By.XPATH, xpath))
-                    )
+                    drop_down_item = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
                 except TimeoutError as e:
                     raise TimeoutError(
                         f"Dropdown item with value '{value}' not found for component '{search_input_component.text}'."
@@ -39,33 +48,19 @@ class SearchInputUtils:
         return input_components
 
     @staticmethod
-    def __selectSearchInputComponentsByPartialLabelText(
-        wait: WebDriverWait, label: str, value: str
-    ):
+    def __selectSearchInputComponentsByPartialLabelText(wait: WebDriverWait, label: str, value: str):
         xpath = f".//div[./div/span[contains(normalize-space(text())='{label}']]/div/div/div/input[@role='combobox']"
-        SearchInputUtils.__findSearchInputComponentsByLabelPathAndSelectValue(
-            wait, xpath, value
-        )
+        SearchInputUtils.__findSearchInputComponentsByLabelPathAndSelectValue(wait, xpath, value)
 
     @staticmethod
-    def __selectSearchInputComponentsByLabelText(
-        wait: WebDriverWait, label: str, value: str
-    ):
-        xpath = (
-            f".//div[./div/span[text()='{label}']]/div/div/div/input[@role='combobox']"
-        )
-        SearchInputUtils.__findSearchInputComponentsByLabelPathAndSelectValue(
-            wait, xpath, value
-        )
+    def __selectSearchInputComponentsByLabelText(wait: WebDriverWait, label: str, value: str):
+        xpath = f".//div[./div/span[text()='{label}']]/div/div/div/input[@role='combobox']"
+        SearchInputUtils.__findSearchInputComponentsByLabelPathAndSelectValue(wait, xpath, value)
 
     @staticmethod
     def selectSearchDropdownByLabelText(wait: WebDriverWait, label: str, value: str):
         SearchInputUtils.__selectSearchInputComponentsByLabelText(wait, label, value)
 
     @staticmethod
-    def selectSearchDropdownByPartialLabelText(
-        wait: WebDriverWait, label: str, value: str
-    ):
-        SearchInputUtils.__selectSearchInputComponentsByPartialLabelText(
-            wait, label, value
-        )
+    def selectSearchDropdownByPartialLabelText(wait: WebDriverWait, label: str, value: str):
+        SearchInputUtils.__selectSearchInputComponentsByPartialLabelText(wait, label, value)

robo_appian/components/TabUtils.py

@@ -4,36 +4,35 @@ from selenium.webdriver.support import expected_conditions as EC
 
 class TabUtils:
     """
-    Utility class for interacting with tab components in Appian UI.
+    Utility class for handling tab components in a web application using Selenium.
+    Example usage:
+        from selenium import webdriver
+        from selenium.webdriver.support.ui import WebDriverWait
+        from robo_appian.components.TabUtils import TabUtils
 
-    Usage Example:
+        driver = webdriver.Chrome()
+        wait = WebDriverWait(driver, 10)
 
-        # Select a tab by its label
-        from robo_appian.components.TabUtils import TabUtils
-        TabUtils.selectInactiveTab(wait, "Settings")
+        # Find a selected tab by its label
+        selected_tab = TabUtils.findSelectedTabByLabelText(wait, "Tab Label")
 
-        # Find the currently selected tab by its label
-        from robo_appian.components.TabUtils import TabUtils
-        selected_tab = TabUtils.findSelectedTab(wait, "Settings")
+        # Select an inactive tab by its label
+        TabUtils.selectInactiveTabByLabelText(wait, "Inactive Tab Label")
+
+        driver.quit()
     """
 
     @staticmethod
-    def findSelectedTab(wait, label):
+    def findSelectedTabByLabelText(wait, label):
         """
         Finds the currently selected tab by its label.
 
-        Parameters:
-        wait: Selenium WebDriverWait instance.
-            label: The visible text label of the tab.
-
-        Returns:
-            The Selenium WebElement for the selected tab.
-
+        :param wait: Selenium WebDriverWait instance.
+        :param label: The label of the tab to find.
+        :return: WebElement representing the selected tab.
         Example:
-            TabUtils.findSelectedTab(wait, "Settings")
+            component = TabUtils.findSelectedTabByLabelText(wait, "Tab Label")
         """
-        # This method locates a tab that is currently selected and contains the specified label.
-
         xpath = f".//div[./div[./div/div/div/div/div/p/strong[normalize-space(text())='{label}']]/span[text()='Selected Tab.']]/div[@role='link']"
         try:
             component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
@@ -44,21 +43,17 @@ class TabUtils:
         return component
 
     @staticmethod
-    def selectInactiveTab(wait, label):
+    def selectInactiveTabByLabelText(wait, label):
         """
-        Selects a tab by its label.
-
-        Parameters:
-            wait: Selenium WebDriverWait instance.
-            label: The visible text label of the tab to select.
+        Selects an inactive tab by its label.
 
+        :param wait: Selenium WebDriverWait instance.
+        :param label: The label of the tab to select.
+        :return: None
         Example:
-            TabUtils.selectInactiveTab(wait, "Settings")
+            TabUtils.selectInactiveTabByLabelText(wait, "Tab Label")
         """
-        # This method locates a tab that contains a label with the specified text.
-
         xpath = f".//div[@role='link']/div/div/div/div/div[./p/span[text()='{label}']]"
-        # xpath=f".//div[./div[./div/div/div/div/div/p/strong[normalize-space(text())='{label}']]/span[text()='Selected Tab.']]/div[@role='link']"
         try:
             component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
         except TimeoutError as e:

robo_appian/components/TableUtils.py

@@ -5,98 +5,77 @@ from selenium.webdriver.support.ui import WebDriverWait
 
 class TableUtils:
     """
-    Utility class for interacting with table components in Appian UI.
-
-        Usage Example:
-
-        # Find a table using a column name
+    Utility class for handling table operations in Selenium WebDriver.
+    Example usage:
+        from selenium import webdriver
+        from selenium.webdriver.support.ui import WebDriverWait
         from robo_appian.components.TableUtils import TableUtils
+
+        driver = webdriver.Chrome()
+        wait = WebDriverWait(driver, 10)
         table = TableUtils.findTableByColumnName(wait, "Status")
+        row_count = TableUtils.rowCount(table)
+        component = TableUtils.findComponentFromTableCell(wait, 1, "Status")
+        driver.quit()
 
     """
 
     @staticmethod
     def findTableByColumnName(wait: WebDriverWait, columnName: str):
         """
-        Finds a table component that contains a column with the specified name.
-
-        Parameters:
-            wait: Selenium WebDriverWait instance.
-            columnName: The name of the column to search for in the table.
-
-        Returns:
-            The Selenium WebElement for the table component.
+        Finds a table component by its column name.
 
+        :param wait: Selenium WebDriverWait instance.
+        :param columnName: The name of the column to search for.
+        :return: WebElement representing the table.
         Example:
-            table = TableUtils.findTableByColumnName(wait, "Status")
-
+            component = TableUtils.findTableByColumnName(wait, "Status")
         """
-        # This method locates a table that contains a header cell with the specified column name.
-        # It uses XPath to find the table element that has a header cell with the specified 'columnName'.
-        # The 'abbr' attribute is used to match the column name, which is a common practice in Appian UI tables.
 
-        # xpath = f".//table[./thead/tr/th[@abbr='{columnName}']]"
         xpath = f'.//table[./thead/tr/th[@abbr="{columnName}"]]'
         try:
             component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
         except TimeoutError as e:
-            raise TimeoutError(
-                f"Could not find table with column name '{columnName}': {e}"
-            )
+            raise TimeoutError(f"Could not find table with column name '{columnName}': {e}")
         except Exception as e:
-            raise RuntimeError(
-                f"Could not find table with column name '{columnName}': {e}"
-            )
+            raise RuntimeError(f"Could not find table with column name '{columnName}': {e}")
         return component
 
     @staticmethod
     def rowCount(tableObject):
         """
-        Returns the number of rows in a table, excluding empty grid messages.
-
-        Parameters:
-            tableObject: The Selenium WebElement representing the table.
-
-        Returns:
-            The number of rows in the table.
+        Counts the number of rows in a table.
 
+        :param tableObject: The Selenium WebElement representing the table.
+        :return: The number of rows in the table.
         Example:
-            count = TableUtils.rowCount(table)
-
+            row_count = TableUtils.rowCount(table)
         """
-        # This method counts the number of rows in a table by finding all the table row elements
-        # that do not have the 'data-empty-grid-message' attribute.
 
         xpath = "./tbody/tr[./td[not (@data-empty-grid-message)]]"
-        rows = tableObject.find_elements(By.XPATH, xpath)
+        try:
+            rows = tableObject.find_elements(By.XPATH, xpath)
+        except Exception as e:
+            raise RuntimeError(f"Could not count rows in table: {e}")
         return len(rows)
 
     @staticmethod
-    def findColumNumberByColumnName(tableObject, columnName):
+    def __findColumNumberByColumnName(tableObject, columnName):
         """
-        Finds the column number in a table based on the column name.
-
-        Parameters:
-            tableObject: The Selenium WebElement representing the table.
-            columnName: The name of the column to find.
-
-        Returns:
-            The index of the column (0-based).
+        Finds the column number in a table by its column name.
 
+        :param tableObject: The Selenium WebElement representing the table.
+        :param columnName: The name of the column to search for.
+        :return: The index of the column (0-based).
         Example:
-            column_number = TableUtils.findColumNumberByColumnName(table, "Status")
-
+            column_number = TableUtils.__findColumNumberByColumnName(table, "Status")
         """
-        # This method locates the column header cell with the specified column name
-        # and extracts the column index from its class attribute.
 
         xpath = f'./thead/tr/th[@scope="col" and @abbr="{columnName}"]'
         component = tableObject.find_element(By.XPATH, xpath)
 
         if component is None:
-            raise ValueError(
-                f"Could not find a column with abbr '{columnName}' in the table header."
-            )
+            raise ValueError(f"Could not find a column with abbr '{columnName}' in the table header.")
 
         class_string = component.get_attribute("class")
         partial_string = "headCell_"
@@ -108,9 +87,7 @@ class TableUtils:
                 selected_word = word
 
         if selected_word is None:
-            raise ValueError(
-                f"Could not find a class containing '{partial_string}' in the column header for '{columnName}'."
-            )
+            raise ValueError(f"Could not find a class containing '{partial_string}' in the column header for '{columnName}'.")
 
         data = selected_word.split("_")
         return int(data[1])
@@ -118,26 +95,18 @@ class TableUtils:
     @staticmethod
     def findComponentFromTableCell(wait, rowNumber, columnName):
         """
-        Finds a component within a specific table cell based on the row number and column name.
-
-        Parameters:
-            wait: Selenium WebDriverWait instance.
-            rowNumber: The row number (0-based index) where the component is located.
-            columnName: The name of the column where the component is located.
-
-        Returns:
-            The Selenium WebElement for the component within the specified table cell.
+        Finds a component within a specific cell of a table by row number and column name.
 
+        :param wait: Selenium WebDriverWait instance.
+        :param rowNumber: The row number (0-based index).
+        :param columnName: The name of the column to search in.
+        :return: WebElement representing the component in the specified cell.
         Example:
-            component = TableUtils.findComponentFromTableCell(wait, 2, "Status")
-
+            component = TableUtils.findComponentFromTableCell(wait, 1, "Status")
         """
-        # This method locates a specific component within a table cell based on the provided row number
-        # and column name. It constructs an XPath that targets the table cell containing the specified column
-        # and row, and then retrieves the component within that cell.
 
         tableObject = TableUtils.findTableByColumnName(wait, columnName)
-        columnNumber = TableUtils.findColumNumberByColumnName(tableObject, columnName)
+        columnNumber = TableUtils.__findColumNumberByColumnName(tableObject, columnName)
         # xpath=f'./tbody/tr[@data-dnd-name="row {rowNumber+1}"]/td[not (@data-empty-grid-message)][{columnNumber}]'
         # component = tableObject.find_elements(By.XPATH, xpath)
         rowNumber = rowNumber + 1
@@ -146,12 +115,8 @@ class TableUtils:
         try:
             component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
         except TimeoutError as e:
-            raise TimeoutError(
-                f"Could not find component in cell at row {rowNumber}, column '{columnName}': {e}"
-            )
+            raise TimeoutError(f"Could not find component in cell at row {rowNumber}, column '{columnName}': {e}")
         except Exception as e:
-            raise RuntimeError(
-                f"Could not find component in cell at row {rowNumber}, column '{columnName}': {e}"
-            )
+            raise RuntimeError(f"Could not find component in cell at row {rowNumber}, column '{columnName}': {e}")
         # childComponent=component.find_element(By.xpath("./*"))
         return component