wcp-library 1.6.7__tar.gz → 1.6.8__tar.gz

{wcp_library-1.6.7 → wcp_library-1.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wcp-library
-Version: 1.6.7
+Version: 1.6.8
 Summary: Common utilites for internal development at WCP
 Author: Mitch-Petersen
 Author-email: mitch.petersen@wcap.ca

{wcp_library-1.6.7 → wcp_library-1.6.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wcp-library"
-version = "1.6.7"
+version = "1.6.8"
 description = "Common utilites for internal development at WCP"
 authors = [{name="Mitch-Petersen", email="mitch.petersen@wcap.ca"}]
 readme = "README.md"

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/__init__.py

@@ -5,7 +5,7 @@ import sys
 import time
 from functools import wraps
 from pathlib import Path
-from typing import Callable, Generator, Optional, Type
+from typing import Callable, Generator, Optional, Type, Union
 
 # PyInstaller import
 import pip_system_certs.wrapt_requests

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/browser_automation/browser.py

@@ -21,9 +21,12 @@ Usage:
 """
 
 import logging
+import time
+import inspect
 from typing import Dict, Optional
 
 from selenium import webdriver
+import selenium.common.exceptions as selenium_exceptions
 from selenium.webdriver.chrome.options import Options as ChromeOptions
 from selenium.webdriver.firefox.options import Options as FirefoxOptions
 from selenium.webdriver.edge.options import Options as EdgeOptions
@@ -33,39 +36,6 @@ from wcp_library.browser_automation.interactions import UIInteractions, WEIntera
 
 logger = logging.getLogger(__name__)
 
-# +--------------------------------------------------------------------------------------------------------------------------------------------------------+
-# |                                                    ===  Browser options and usage  ===                                                                 |
-# +--------------+--------------------------------------------+-----------------------------------------------+--------------------------------------------+
-# | Browser      | Description                                | JSON Configuration                            | Possible Permutations                      |
-# +--------------+--------------------------------------------+-----------------------------------------------+--------------------------------------------+
-# | All Browsers | Set browser timeouts (in ms)               | {"timeouts": {"implicit": 5000, ...}}         | implicit, pageLoad, script                 |
-# | All Browsers | Name of the browser (e.g., 'chrome', ...)  | {"browserName": "chrome"}                     | chrome, firefox, edge, safari              |
-# | All Browsers | Specific version of the browser to use.    | {"browserVersion": "latest"}                  | latest, 91.0, 90.0                         |
-# | All Browsers | OS platform (e.g., 'Windows 10', 'Linux')  | {"platformName": "Windows 10"}                | Windows 10, Linux, macOS                   |
-# | All Browsers | Strategy for page loads: normal, eager...  | {"pageLoadStrategy": "normal"}                | normal, eager, none                        |
-# | All Browsers | Accept self-signed or invalid certs        | {"acceptInsecureCerts": true}                 | true, false                                |
-# | Chrome       | Run browser in headless mode               | {"args": ["--headless"]}                      | --headless                                 |
-# | Chrome       | Disable GPU acceleration                   | {"args": ["--disable-gpu"]}                   | --disable-gpu                              |
-# | Chrome       | Set experimental options                   | {"prefs": {"download.default_directory":...}} | profile.default_content_settings.popups... |
-# | Chrome       | Set path to Chrome binary                  | {"binary": "/path/to/chrome"}                 | /path/to/chrome                            |
-# | Chrome       | Set Chrome extensions                      | {"extensions": ["/path/to/extension"]}        | /path/to/extension                         |
-# | Chrome       | Exclude switches                           | {"excludeSwitches": ["enable-automation"]}    | enable-automation                          |
-# | Chrome       | Use automation extension                   | {"useAutomationExtension": false}             | true, false                                |
-# | Firefox      | Set download folder list                   | {"prefs": {"browser.download.folderList": 2}} | 1(Download folder), 2(User set directory)  |
-# | Firefox      | Set download directory                     | {"prefs": {"browser.download.dir": "/tmp"}}   | /tmp                                       |
-# | Firefox      | Run Firefox in headless mode               | {"args": ["-headless"]}                       | -headless                                  |
-# | Firefox      | Set Firefox log level                      | {"log": {"level": "trace"}}                   | trace, debug, info, warn, error            |
-# | Firefox      | Set Firefox profile                        | {"profile": "/path/to/profile"}               | /path/to/profile                           |
-# | Firefox      | Set path to Firefox binary                 | {"binary": "/path/to/firefox"}                | /path/to/firefox                           |
-# | Edge         | Run Edge in headless mode                  | {"args": ["--headless"]}                      | --headless                                 |
-# | Edge         | Set path to Edge binary                    | {"binary": "/path/to/edge"}                   | /path/to/edge                              |
-# | Edge         | Use Chromium-based Edge                    | {"useChromium": true}                         | true, false                                |
-# | Edge         | Set Edge Chromium driver                   | {"edgeChromiumDriver": "/path/to/driver"}     | /path/to/driver                            |
-# | Chrome/Edge  | Set initial window size                    | {"args": ["--window-size=1920,1080"]}         | --window-size=int,int                      |
-# | Firefox      | Launch in private browsing mode            | {"args": ["-private"]}                        | -private                                   |
-# +--------------+--------------------------------------------+-----------------------------------------------+--------------------------------------------+
-
-
 class BaseSelenium(UIInteractions, WEInteractions):
     """
     Base class for Selenium-based browser automation.
@@ -77,6 +47,15 @@ class BaseSelenium(UIInteractions, WEInteractions):
     :param driver: Selenium WebDriver instance (optional, defaults to None).
     """
 
+    class SeleniumExceptions:
+        """Dynamically collect all Selenium exception classes."""
+
+        ALL = tuple(
+            obj
+            for _, obj in inspect.getmembers(selenium_exceptions)
+            if inspect.isclass(obj) and issubclass(obj, Exception)
+        )
+
     def __init__(self, browser_options: dict = None):
         self.browser_options = browser_options or {}
         self.driver = None
@@ -88,7 +67,12 @@ class BaseSelenium(UIInteractions, WEInteractions):
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         if exc_type:
-            logger.error(f"Exception occurred: {exc_type.__name__}: {exc_val}\nTraceback: {exc_tb}")
+            logger.error(
+                "Exception occurred: %s: %s\nTraceback: %s",
+                exc_type.__name__ if exc_type else None,
+                exc_val,
+                exc_tb,
+            )
         if self.driver:
             self.driver.quit()
 
@@ -147,6 +131,17 @@ class BaseSelenium(UIInteractions, WEInteractions):
                 }
                 options.add_experimental_option("prefs", prefs)
 
+    def refresh_page(self) -> None:
+        """Refresh the current page.
+
+        :raises RuntimeError: If the WebDriver is not initialized.
+        """
+
+        if self.driver:
+            self.driver.refresh()
+        else:
+            raise RuntimeError("WebDriver is not initialized.")
+
     def go_to(self, url: str | URL):
         """Navigate to the specified URL.
 
@@ -181,6 +176,14 @@ class BaseSelenium(UIInteractions, WEInteractions):
             return self.driver.title
         raise RuntimeError("WebDriver is not initialized.")
 
+    def force_wait(self, wait_time: int) -> None:
+        """Forces the browser to wait for the specified time.
+
+        :param wait_time: The amount of time to wait.
+        :return: None
+        """
+        time.sleep(wait_time)
+
     def switch_to_window(
         self, window_handle: Optional[str] = None
     ) -> Optional[Dict[str, list]]:
@@ -191,8 +194,10 @@ class BaseSelenium(UIInteractions, WEInteractions):
         Otherwise, it will attempt to switch to a newly opened window that is different
         from the current one.
 
-        :param window_handle: The handle of the window to switch to. If None, the method will search for a new window handle.
-        :return: A dictionary containing the original window handle, the new window handle, and a list of all window handles at the time of switching.
+        :param window_handle: The handle of the window to switch to.
+        If None, the method will search for a new window handle.
+        :return: A dictionary containing the original window handle, the new window handle,
+        and a list of all window handles at the time of switching.
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
@@ -211,61 +216,21 @@ class BaseSelenium(UIInteractions, WEInteractions):
                     "new_window": new_window,
                     "all_windows": all_windows,
                 }
+        self.force_wait(1)
         return None
 
     def close_window(self, window_handle: Optional[str] = None) -> None:
         """
-        Closes the specified browser window.
-
-        If a window handle is provided, that window will be closed.
-        Otherwise, the currently active window will be closed.
-
-        :param window_handle: The handle of the window to close. If None, the current window will be closed.
+        Closes a browser window. If a specific window handle is provided, the driver
+        will close that window. Otherwise, the current window will be closed.
+        :param window_handle: The handle of the window to close.
+        If None, the current window will be closed.
+        :return: None
         """
-
-        self.driver.close(window_handle or self.driver.current_window_handle)
-
-
-class Firefox(BaseSelenium):
-    """
-    Class for Firefox browser automation using Selenium.
-
-    This class extends the BaseSelenium class and provides functionality for creating
-    and managing Firefox WebDriver instances.
-    """
-
-    def create_driver(self) -> webdriver.Firefox:
-        options = FirefoxOptions()
-        self._add_options(options)
-        return webdriver.Firefox(options=options)
-
-
-class Edge(BaseSelenium):
-    """
-    Class for Edge browser automation using Selenium.
-
-    This class extends the BaseSelenium class and provides functionality for creating
-    and managing Edge WebDriver instances.
-    """
-
-    def create_driver(self) -> webdriver.Edge:
-        options = EdgeOptions()
-        self._add_options(options)
-        return webdriver.Edge(options=options)
-
-
-class Chrome(BaseSelenium):
-    """
-    Class for Chrome browser automation using Selenium.
-
-    This class extends the BaseSelenium class and provides functionality for creating
-    and managing Chrome WebDriver instances.
-    """
-
-    def create_driver(self) -> webdriver.Chrome:
-        options = ChromeOptions()
-        self._add_options(options)
-        return webdriver.Chrome(options=options)
+        if window_handle:
+            current_window = self.driver.current_window_handle
+            self.switch_to_window(current_window)
+        self.driver.close()
 
 
 class Browser(BaseSelenium):
@@ -294,6 +259,53 @@ class Browser(BaseSelenium):
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         if exc_type:
-            logger.error(f"Exception occurred: {exc_type.__name__}: {exc_val}\nTraceback: {exc_tb}")
+            logger.error(
+                "Exception occurred: %s: %s\nTraceback: %s",
+                exc_type.__name__ if exc_type else None,
+                exc_val,
+                exc_tb,
+            )
         if self.browser_instance and self.browser_instance.driver:
             self.browser_instance.driver.quit()
+
+    class Firefox(BaseSelenium):
+        """
+        Class for Firefox browser automation using Selenium.
+
+        This class extends the BaseSelenium class and provides functionality for creating
+        and managing Firefox WebDriver instances.
+        """
+
+        def create_driver(self) -> webdriver.Firefox:
+            """Create a Firefox WebDriver instance with specified options."""
+            options = FirefoxOptions()
+            self._add_options(options)
+            return webdriver.Firefox(options=options)
+
+    class Edge(BaseSelenium):
+        """
+        Class for Edge browser automation using Selenium.
+
+        This class extends the BaseSelenium class and provides functionality for creating
+        and managing Edge WebDriver instances.
+        """
+
+        def create_driver(self) -> webdriver.Edge:
+            """Create an Edge WebDriver instance with specified options."""
+            options = EdgeOptions()
+            self._add_options(options)
+            return webdriver.Edge(options=options)
+
+    class Chrome(BaseSelenium):
+        """
+        Class for Chrome browser automation using Selenium.
+
+        This class extends the BaseSelenium class and provides functionality for creating
+        and managing Chrome WebDriver instances.
+        """
+
+        def create_driver(self) -> webdriver.Chrome:
+            """Create a Chrome WebDriver instance with specified options."""
+            options = ChromeOptions()
+            self._add_options(options)
+            return webdriver.Chrome(options=options)

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/browser_automation/interactions.py

@@ -10,6 +10,7 @@ Each class provides methods for performing various web interactions such as navi
 taking screenshots, waiting for elements, clicking buttons, entering text, and more.
 """
 
+import time
 import logging
 from datetime import datetime
 from io import StringIO
@@ -29,6 +30,12 @@ from selenium.webdriver.support.ui import Select, WebDriverWait
 EXECUTION_ERROR_SCREENSHOT_FOLDER = "P:/Python/RPA/Execution Error Screenshots"
 
 
+class BrowserInteractionError(Exception):
+    """
+    Exception raised when an Seemium interaction with the browser fails.
+    """
+
+
 class Interactions:
     """Class for interacting with web elements using Selenium WebDriver.
 
@@ -88,7 +95,7 @@ class Interactions:
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
-        return (
+        return int(
             wait_time
             or (
                 getattr(self, "browser_options", {})
@@ -180,19 +187,10 @@ class UIInteractions(Interactions):
                     (self._get_locator(locator), element_value)
                 )
             )
-        except TimeoutException as exc:
-            self._take_error_screenshot()
-            raise TimeoutException(
-                f"Timeout exception for element with locator {locator} and value {element_value}"
-            ) from exc
-        except NoSuchElementException as exc:
-            self._take_error_screenshot()
-            raise NoSuchElementException(
-                f"Element with locator {locator} and value {element_value} not found."
-            ) from exc
-        except WebDriverException as exc:
+
+        except WebDriverException:
             self._take_error_screenshot()
-            raise WebDriverException(f"WebDriverException occurred: {exc}") from exc
+            raise
 
     def get_multiple_elements(
         self,
@@ -224,25 +222,52 @@ class UIInteractions(Interactions):
                     (self._get_locator(locator), element_value)
                 )
             )
-        except TimeoutException as exc:
+        except WebDriverException:
             self._take_error_screenshot()
-            raise TimeoutException(
-                f"Timeout exception for element with locator {locator} and value {element_value} not found."
-            ) from exc
-        except NoSuchElementException as exc:
-            self._take_error_screenshot()
-            raise NoSuchElementException(
-                f"Element with locator {locator} and value {element_value} not found."
-            ) from exc
-        except WebDriverException as exc:
-            self._take_error_screenshot()
-            raise WebDriverException(f"WebDriverException occurred: {exc}") from exc
+            raise
+
+    def get_first_element(
+        self,
+        elements: list[dict],
+        wait_time: Optional[float] = 0,
+    ) -> None:
+        """Get the first available WebElement from a list of element dictionaries.
+
+        Each dictionary can contain:
+            - "element": the element value (required)
+            - "locator": the locator type (optional, defaults to "css")
+            - "expected_condition": the condition to wait for (optional, defaults to "clickable")
+
+        :param elements: List of dictionaries defining elements.
+        :param wait_time: The wait time in milliseconds.
+        :raises RuntimeError: If the WebDriver is not initialized.
+        """
+
+        # Normalize each dictionary to (value, locator, condition)
+        normalized = []
+        for item in elements:
+            element_value = item.get("element")
+            if not element_value:
+                raise ValueError(f"Missing 'element' key in: {item}")
+            locator = item.get("locator") or "css"
+            condition = item.get("expected_condition") or "clickable"
+            normalized.append((element_value, locator, condition))
+
+        end_time = time.time() + self._get_wait_time(wait_time)
+        while time.time() < end_time:
+            for element_value, locator, condition in normalized:
+                try:
+                    return self.get_element(element_value, locator, condition)
+                except WebDriverException:
+                    continue
+        raise TimeoutException("No element became clickable within the timeout.")
 
     def get_text(
         self,
         element_value: str,
         locator: Optional[str] = None,
         expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
     ) -> str:
         """Get the text of the WebElement based on the locator and expected condition.
 
@@ -253,17 +278,21 @@ class UIInteractions(Interactions):
         :param expected_condition: The expected condition type.
             Options: 'clickable'(Default), 'present', 'visible',
             'selected', 'frame_available'
+        :param wait_time: Time to wait for the condition.
         :return: The text of the located WebElement.
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
-        return self.get_element(element_value, locator, expected_condition).text
+        return self.get_element(
+            element_value, locator, expected_condition, wait_time
+        ).text
 
     def get_table(
         self,
         element_value: str,
         locator: Optional[str] = None,
         expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
     ) -> pd.DataFrame:
         """Get the data from a table element.
 
@@ -274,11 +303,14 @@ class UIInteractions(Interactions):
         :param expected_condition: The expected condition type.
             Options: 'clickable'(Default), 'present', 'visible',
             'selected', 'frame_available'
+        :param wait_time: Time to wait for the condition.
         :return: The data from the table element.
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
-        element = self.get_element(element_value, locator, expected_condition)
+        element = self.get_element(
+            element_value, locator, expected_condition, wait_time
+        )
         return pd.read_html(StringIO(element.get_attribute("outerHTML")))[0]
 
     def get_value(
@@ -286,6 +318,7 @@ class UIInteractions(Interactions):
         element_value: str,
         locator: Optional[str] = None,
         expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
     ) -> str:
         """Get the value attribute of the WebElement based on the locator and expected condition.
 
@@ -296,12 +329,13 @@ class UIInteractions(Interactions):
         :param expected_condition: The expected condition type.
             Options: 'clickable'(Default), 'present', 'visible',
             'selected', 'frame_available'
+        :param wait_time: Time to wait for the condition.
         :return: The value of the located WebElement.
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
         return self.get_element(
-            element_value, locator, expected_condition
+            element_value, locator, expected_condition, wait_time
         ).get_attribute("value")
 
     def press_button(
@@ -309,6 +343,7 @@ class UIInteractions(Interactions):
         element_value: str,
         locator: Optional[str] = None,
         expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
     ) -> None:
         """Click on the WebElement based on the locator and expected condition.
 
@@ -319,11 +354,14 @@ class UIInteractions(Interactions):
         :param expected_condition: The expected condition type.
             Options: 'clickable'(Default), 'present', 'visible',
             'selected', 'frame_available'
+        :param wait_time: Time to wait for the condition.
         :return:
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
-        element = self.get_element(element_value, locator, expected_condition)
+        element = self.get_element(
+            element_value, locator, expected_condition, wait_time
+        )
         element.click()
 
     def enter_text(
@@ -332,6 +370,7 @@ class UIInteractions(Interactions):
         element_value: str,
         locator: Optional[str] = None,
         expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
     ) -> None:
         """Populate the text field with the provided text.
 
@@ -343,13 +382,19 @@ class UIInteractions(Interactions):
         :param expected_condition: The expected condition type.
             Options: 'clickable'(Default), 'present', 'visible',
             'selected', 'frame_available'
+        :param wait_time: Time to wait for the condition.
         :return:
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
-        element = self.get_element(element_value, locator, expected_condition)
-        element.clear()
-        element.send_keys(text)
+        element = self.get_element(
+            element_value, locator, expected_condition, wait_time
+        )
+        try:
+            element.clear()
+        except WebDriverException:
+            pass
+        element.send_keys(str(text))
 
     def set_checkbox_state(
         self,
@@ -357,6 +402,7 @@ class UIInteractions(Interactions):
         element_value: str,
         locator: Optional[str] = None,
         expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
     ) -> None:
         """Set the state of a checkbox.
 
@@ -368,11 +414,14 @@ class UIInteractions(Interactions):
         :param expected_condition: The expected condition type.
             Options: 'clickable'(Default), 'present', 'visible',
             'selected', 'frame_available'
+        :param wait_time: Time to wait for the condition.
         :return:
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
-        element = self.get_element(element_value, locator, expected_condition)
+        element = self.get_element(
+            element_value, locator, expected_condition, wait_time
+        )
         if element.is_selected() != state:
             element.click()
 
@@ -383,23 +432,28 @@ class UIInteractions(Interactions):
         select_type: str = None,
         locator: Optional[str] = None,
         expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
     ) -> None:
         """Select an option from a dropdown.
 
         :param option: The option to select. This can be the visible text,
         :param element_value: The value used to identify the element.
         :param select_type: The type of selection to perform.
+            Options: 'value'(Default), 'index', 'visible_text'
         :param locator: The locator type.
             Options: 'css'(Default), 'id', 'name', 'class', 'tag',
             'xpath', 'link_text', 'partial_link_text'
         :param expected_condition: The expected condition type.
             Options: 'clickable'(Default), 'present', 'visible',
             'selected', 'frame_available'
+        :param wait_time: Time to wait for the condition.
         :return:
         :raises RuntimeError: If the WebDriver is not initialized.
         """
 
-        element = self.get_element(element_value, locator, expected_condition)
+        element = self.get_element(
+            element_value, locator, expected_condition, wait_time
+        )
         select = Select(element)
         if select_type == "index":
             select.select_by_index(int(option))
@@ -431,47 +485,15 @@ class UIInteractions(Interactions):
         or an exception occurs.
         :raises RuntimeError: If the WebDriver is not initialized.
         """
-
         try:
-            return self.get_element(
-                element_value, locator, expected_condition, wait_time
+            return WebDriverWait(self.driver, self._get_wait_time(wait_time)).until(
+                self._get_expected_condition(expected_condition)(
+                    (self._get_locator(locator), element_value)
+                )
             )
-        except (TimeoutException, NoSuchElementException):
+        except WebDriverException:
             return False
 
-    def text_is_present(
-        self,
-        text: str,
-        element_value: str,
-        locator: Optional[str] = None,
-        text_location: Optional[str] = None,
-        wait_time: Optional[float] = 0,
-    ) -> bool:
-        """
-        Checks whether the specified text is present within a web element.
-
-        :param text: The text to verify within the element.
-        :param element_value: The value used to identify the element.
-        :param locator: The locator type.
-            Options: 'css'(Default), 'id', 'name', 'class', 'tag',
-            'xpath', 'link_text', 'partial_link_text'
-        :param text_location: Where in the element to look for the text.
-            Options: 'anywhere'(Default), 'attribute', 'value'
-        :param wait_time: Time to wait for the condition.
-        :return: True if the text is found within the element, False otherwise.
-        :raises RuntimeError: If the WebDriver is not initialized.
-        """
-
-        expected_condition = EC.text_to_be_present_in_element
-        if text_location == "attribute":
-            expected_condition = EC.text_to_be_present_in_element_attribute
-        elif text_location == "value":
-            expected_condition = EC.text_to_be_present_in_element_value
-
-        return WebDriverWait(self.driver, self._get_wait_time(wait_time)).until(
-            expected_condition((self._get_locator(locator), element_value), text)
-        )
-
     def wait_for_element(
         self,
         element_value: str,
@@ -498,6 +520,39 @@ class UIInteractions(Interactions):
             element_value, locator, expected_condition, self._get_wait_time(wait_time)
         )
 
+    def text_is_present(
+            self,
+            text: str,
+            element_value: str,
+            locator: Optional[str] = None,
+            text_location: Optional[str] = None,
+            wait_time: Optional[float] = 0,
+        ) -> bool:
+            """
+            Checks whether the specified text is present within a web element.
+
+            :param text: The text to verify within the element.
+            :param element_value: The value used to identify the element.
+            :param locator: The locator type.
+                Options: 'css'(Default), 'id', 'name', 'class', 'tag',
+                'xpath', 'link_text', 'partial_link_text'
+            :param text_location: Where in the element to look for the text.
+                Options: 'anywhere'(Default), 'attribute', 'value'
+            :param wait_time: Time to wait for the condition.
+            :return: True if the text is found within the element, False otherwise.
+            :raises RuntimeError: If the WebDriver is not initialized.
+            """
+
+            expected_condition = EC.text_to_be_present_in_element
+            if text_location == "attribute":
+                expected_condition = EC.text_to_be_present_in_element_attribute
+            elif text_location == "value":
+                expected_condition = EC.text_to_be_present_in_element_value
+
+            return WebDriverWait(self.driver, self._get_wait_time(wait_time)).until(
+                expected_condition((self._get_locator(locator), element_value), text)
+            )
+
 
 class WEInteractions(Interactions):
     """Class for interacting with web elements directly using WebElement instances."""
@@ -525,29 +580,6 @@ class WEInteractions(Interactions):
                 expected_condition = EC.element_to_be_clickable
         return expected_condition
 
-    def wait_for_element_we(
-        self,
-        web_element: WebElement,
-        expected_condition: Optional[str] = None,
-        wait_time: Optional[float] = 0,
-    ) -> WebElement:
-        """
-        Wait for an element to be present directly using WebElement and expected condition.
-
-        :param web_element: The WebElement to wait for.
-        :param expected_condition: The expected condition type.
-            Options: 'clickable'(Default), 'visible', 'selected', 'staleness'
-        :param wait_time: Time to wait for the element.
-        :return: The WebElement if it meets the expected condition.
-        :raises RuntimeError: If the WebDriver is not initialized.
-        """
-
-        condition = self._get_expected_condition_we(expected_condition)
-        WebDriverWait(self.driver, self._get_wait_time(wait_time)).until(
-            condition(web_element)
-        )
-        return web_element
-
     def get_text_we(
         self,
         web_element: WebElement,
@@ -737,3 +769,26 @@ class WEInteractions(Interactions):
             )
         except (TimeoutException, NoSuchElementException):
             return False
+
+    def wait_for_element_we(
+        self,
+        web_element: WebElement,
+        expected_condition: Optional[str] = None,
+        wait_time: Optional[float] = 0,
+    ) -> WebElement:
+        """
+        Wait for an element to be present directly using WebElement and expected condition.
+
+        :param web_element: The WebElement to wait for.
+        :param expected_condition: The expected condition type.
+            Options: 'clickable'(Default), 'visible', 'selected', 'staleness'
+        :param wait_time: Time to wait for the element.
+        :return: The WebElement if it meets the expected condition.
+        :raises RuntimeError: If the WebDriver is not initialized.
+        """
+
+        condition = self._get_expected_condition_we(expected_condition)
+        WebDriverWait(self.driver, self._get_wait_time(wait_time)).until(
+            condition(web_element)
+        )
+        return web_element

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/credentials/_credential_manager_asynchronous.py

@@ -10,9 +10,9 @@ logger = logging.getLogger(__name__)
 
 
 class AsyncCredentialManager(ABC):
-    def __init__(self, passwordState_api_key: str, password_list_id: int):
+    def __init__(self, api_key: str, password_list_id: int):
         self.password_url = URL("https://vault.wcap.ca/api/passwords/")
-        self.api_key = passwordState_api_key
+        self.api_key = api_key
         self.headers = {"APIKey": self.api_key, 'Reason': 'Python Script Access'}
         self._password_list_id = password_list_id
 
@@ -23,7 +23,7 @@ class AsyncCredentialManager(ABC):
         :return:
         """
 
-        logger.debug("Getting credentials from PasswordState")
+        logger.debug("Getting credentials from Vault")
         url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
         async with aiohttp.ClientSession() as session:
             async with session.get(str(url), headers=self.headers) as response:
@@ -118,7 +118,7 @@ class AsyncCredentialManager(ABC):
 
     async def update_credential(self, credentials_dict: dict) -> bool:
         """
-        Update username and password in PasswordState
+        Update username and password in Vault
 
         Credentials dictionary must the same keys as the original dictionary from the get_credentials method
 

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/credentials/_credential_manager_synchronous.py

@@ -10,9 +10,9 @@ logger = logging.getLogger(__name__)
 
 
 class CredentialManager(ABC):
-    def __init__(self, passwordState_api_key: str, password_list_id: int):
+    def __init__(self, api_key: str, password_list_id: int):
         self.password_url = URL("https://vault.wcap.ca/api/passwords/")
-        self.api_key = passwordState_api_key
+        self.api_key = api_key
         self.headers = {"APIKey": self.api_key, 'Reason': 'Python Script Access'}
         self._password_list_id = password_list_id
 
@@ -23,7 +23,7 @@ class CredentialManager(ABC):
         :return: Dictionary of credentials
         """
 
-        logger.debug("Getting credentials from PasswordState")
+        logger.debug("Getting credentials from Vault")
         url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
         passwords = requests.get(str(url), headers=self.headers).json()
 

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/credentials/api.py

@@ -7,8 +7,8 @@ logger = logging.getLogger(__name__)
 
 
 class APICredentialManager(CredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 214)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 214)
 
     def new_credentials(self, credentials_dict: dict) -> bool:
         """
@@ -41,8 +41,8 @@ class APICredentialManager(CredentialManager):
 
 
 class AsyncAPICredentialManager(AsyncCredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 214)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 214)
 
     async def new_credentials(self, credentials_dict: dict) -> bool:
         """

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/credentials/ftp.py

@@ -7,8 +7,8 @@ logger = logging.getLogger(__name__)
 
 
 class FTPCredentialManager(CredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 208)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 208)
 
     def new_credentials(self, credentials_dict: dict) -> bool:
         """
@@ -40,8 +40,8 @@ class FTPCredentialManager(CredentialManager):
 
 
 class AsyncFTPCredentialManager(AsyncCredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 208)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 208)
 
     async def new_credentials(self, credentials_dict: dict) -> bool:
         """

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/credentials/internet.py

@@ -7,8 +7,8 @@ logger = logging.getLogger(__name__)
 
 
 class InternetCredentialManager(CredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 93)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 93)
 
     def new_credentials(self, credentials_dict: dict) -> bool:
         """
@@ -37,8 +37,8 @@ class InternetCredentialManager(CredentialManager):
 
 
 class AsyncInternetCredentialManager(AsyncCredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 93)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 93)
 
     async def new_credentials(self, credentials_dict: dict) -> bool:
         """

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/credentials/oracle.py

@@ -9,8 +9,8 @@ logger = logging.getLogger(__name__)
 
 
 class OracleCredentialManager(CredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 207)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 207)
 
     def new_credentials(self, credentials_dict: dict) -> bool:
         """
@@ -43,8 +43,8 @@ class OracleCredentialManager(CredentialManager):
 
 
 class AsyncOracleCredentialManager(AsyncCredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 207)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 207)
 
     async def new_credentials(self, credentials_dict: dict) -> bool:
         """

{wcp_library-1.6.7 → wcp_library-1.6.8}/wcp_library/credentials/postgres.py

@@ -7,8 +7,8 @@ logger = logging.getLogger(__name__)
 
 
 class PostgresCredentialManager(CredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 210)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 210)
 
     def new_credentials(self, credentials_dict: dict) -> bool:
         """
@@ -40,8 +40,8 @@ class PostgresCredentialManager(CredentialManager):
 
 
 class AsyncPostgresCredentialManager(AsyncCredentialManager):
-    def __init__(self, passwordState_api_key: str):
-        super().__init__(passwordState_api_key, 210)
+    def __init__(self, api_key: str):
+        super().__init__(api_key, 210)
 
     async def new_credentials(self, credentials_dict: dict) -> bool:
         """