├── .gitignore
├── Components
    ├── BasicComponent.py
    ├── Common
    │   ├── Button.py
    │   ├── FileUpload.py
    │   └── TextInput.py
    └── PerspectiveComponents
    │   ├── Charts
    │       ├── Pie.py
    │       ├── PowerChart.py
    │       ├── TimeSeriesChart.py
    │       └── XYChart.py
    │   ├── Common
    │       ├── Checkbox.py
    │       ├── ComponentModal.py
    │       ├── DateRangeSelector.py
    │       ├── DateTimePicker.py
    │       ├── Dropdown.py
    │       ├── Icon.py
    │       ├── Table.py
    │       ├── TablePieces
    │       │   ├── Body.py
    │       │   ├── Filter.py
    │       │   ├── HeaderAndFooter.py
    │       │   └── Pager.py
    │       ├── TagBrowseTree.py
    │       └── Tree.py
    │   ├── Containers
    │       ├── Column.py
    │       ├── Coordinate.py
    │       ├── Split.py
    │       └── Tab.py
    │   ├── Displays
    │       ├── AlarmTable.py
    │       ├── Audio.py
    │       ├── Barcode.py
    │       ├── CylindricalTank.py
    │       ├── Dashboard.py
    │       ├── EquipmentSchedule.py
    │       ├── GoogleMap.py
    │       ├── Icon.py
    │       ├── Image.py
    │       ├── InlineFrame.py
    │       ├── LEDDisplay.py
    │       ├── Label.py
    │       ├── LinearScale.py
    │       ├── Map.py
    │       ├── Markdown.py
    │       ├── Progress.py
    │       ├── Table.py
    │       ├── TagBrowseTree.py
    │       ├── Thermometer.py
    │       ├── Tree.py
    │       └── VideoPlayer.py
    │   ├── Embedding
    │       ├── Accordion.py
    │       ├── Carousel.py
    │       ├── EmbeddedView.py
    │       ├── FlexRepeater.py
    │       └── ViewCanvas.py
    │   ├── Inputs
    │       ├── BarcodeScanner.py
    │       ├── Button.py
    │       ├── Checkbox.py
    │       ├── DateTime.py
    │       ├── Dropdown.py
    │       ├── FileUpload.py
    │       ├── MultiStateButton.py
    │       ├── NumericEntryField.py
    │       ├── OneShotButton.py
    │       ├── PasswordField.py
    │       ├── RadioGroup.py
    │       ├── SignaturePad.py
    │       ├── Slider.py
    │       ├── TextArea.py
    │       ├── TextField.py
    │       └── ToggleSwitch.py
    │   ├── Navigation
    │       ├── HorizontalMenu.py
    │       ├── Link.py
    │       └── MenuTree.py
    │   ├── Reporting
    │       └── ReportViewer.py
    │   ├── Symbols
    │       └── Symbol.py
    │   └── Tooltip.py
├── Helpers
    ├── CSSEnumerations.py
    ├── Filtering.py
    ├── Formatting.py
    ├── GeographicPoint.py
    ├── IAAssert.py
    ├── IAExpectedConditions
    │   └── IAExpectedConditions.py
    ├── IASelenium.py
    ├── Ignition
    │   ├── Alarm.py
    │   ├── AlarmEvent.py
    │   ├── QualifiedValue.py
    │   └── Tag.py
    ├── PerspectiveAlarm.py
    ├── PerspectivePages
    │   ├── AuthChallengeHelper.py
    │   ├── DockedViewHelper.py
    │   ├── LoginHelper.py
    │   ├── NotificationHelper.py
    │   ├── PopupHelper.py
    │   ├── Quality.py
    │   └── QualityOverlayHelper.py
    └── Point.py
├── LICENSE
├── Pages
    ├── BasicPageObject.py
    ├── IgnitionPageObject.py
    ├── PagePiece.py
    ├── Perspective
    │   ├── AppBar.py
    │   ├── DockedView.py
    │   ├── Popup.py
    │   ├── PrintPreviewPage.py
    │   ├── TerminalStates
    │   │   ├── Forbidden.py
    │   │   ├── LoggedOut.py
    │   │   ├── MobileLicense.py
    │   │   ├── PageClosed.py
    │   │   ├── ProjectNotFound.py
    │   │   ├── ProjectNotRunnable.py
    │   │   ├── SessionClosed.py
    │   │   └── TerminalStatePageObject.py
    │   ├── View.py
    │   ├── ViewCanvasInstancedView.py
    │   └── Widget.py
    └── PerspectivePageObject.py
├── README.md
└── requirements.txt


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Pycharm files
  2 | .idea/
  3 | 
  4 | # Byte-compiled / optimized / DLL files
  5 | __pycache__/
  6 | *.py[cod]
  7 | *$py.class
  8 | 
  9 | # C extensions
 10 | *.so
 11 | 
 12 | # Distribution / packaging
 13 | .Python
 14 | build/
 15 | develop-eggs/
 16 | dist/
 17 | downloads/
 18 | eggs/
 19 | .eggs/
 20 | lib64/
 21 | parts/
 22 | sdist/
 23 | var/
 24 | wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .coverage
 44 | .coverage.*
 45 | .cache
 46 | nosetests.xml
 47 | coverage.xml
 48 | *.cover
 49 | .hypothesis/
 50 | .pytest_cache/
 51 | 
 52 | # Translations
 53 | *.mo
 54 | *.pot
 55 | 
 56 | # Django stuff:
 57 | *.log
 58 | local_settings.py
 59 | db.sqlite3
 60 | 
 61 | # Flask stuff:
 62 | instance/
 63 | .webassets-cache
 64 | 
 65 | # Scrapy stuff:
 66 | .scrapy
 67 | 
 68 | # Sphinx documentation
 69 | docs/_build/
 70 | 
 71 | # PyBuilder
 72 | target/
 73 | 
 74 | # Jupyter Notebook
 75 | .ipynb_checkpoints
 76 | 
 77 | # pyenv
 78 | .python-version
 79 | 
 80 | # celery beat schedule file
 81 | celerybeat-schedule
 82 | 
 83 | # SageMath parsed files
 84 | *.sage.py
 85 | 
 86 | # Environments
 87 | .env
 88 | .venv
 89 | env/
 90 | venv/
 91 | ENV/
 92 | env.bak/
 93 | venv.bak/
 94 | 
 95 | # Spyder project settings
 96 | .spyderproject
 97 | .spyproject
 98 | 
 99 | # Rope project settings
100 | .ropeproject
101 | 
102 | # mkdocs documentation
103 | /site
104 | 
105 | # mypy
106 | .mypy_cache/
107 | 


--------------------------------------------------------------------------------
/Components/Common/Button.py:
--------------------------------------------------------------------------------
  1 | from typing import Tuple, List, Optional, Union
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import ComponentPiece
  8 | from Components.PerspectiveComponents.Common.Icon import CommonIcon
  9 | from Helpers.CSSEnumerations import CSSPropertyValue
 10 | from Helpers.Point import Point
 11 | 
 12 | 
 13 | class CommonButton(ComponentPiece):
 14 |     """
 15 |     A common button, exposing common functions which EVERY button in Perspective can use. This includes buttons within
 16 |     other components, like the Acknowledge button found inside the Alarm Status Table component.
 17 |     """
 18 |     _INTERNAL_BUTTON_LOCATOR = (By.CSS_SELECTOR, 'button')
 19 |     _INTERNAL_ICON_LOCATOR = (By.TAG_NAME, "svg")
 20 |     _INTERNAL_TEXT_LOCATOR = (By.CSS_SELECTOR, "div.text")
 21 |     _INTERNAL_IMAGE_LOCATOR = (By.TAG_NAME, "img")
 22 |     PRIMARY_CLASS = 'ia_button--primary'
 23 |     SECONDARY_CLASS = 'ia_button--secondary'
 24 | 
 25 |     def __init__(
 26 |             self,
 27 |             locator: Tuple[By, str],
 28 |             driver: WebDriver,
 29 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 30 |             wait_timeout: float = 10,
 31 |             description: Optional[str] = None,
 32 |             poll_freq: float = 0.5):
 33 |         super().__init__(
 34 |             locator=locator,
 35 |             driver=driver,
 36 |             parent_locator_list=parent_locator_list,
 37 |             wait_timeout=wait_timeout,
 38 |             description=description,
 39 |             poll_freq=poll_freq)
 40 |         self._internal_button = ComponentPiece(
 41 |             locator=self._INTERNAL_BUTTON_LOCATOR,
 42 |             driver=self.driver,
 43 |             parent_locator_list=self.locator_list,
 44 |             description="The internal HTML <button> element of the Button.",
 45 |             poll_freq=poll_freq)
 46 |         self._internal_icon = CommonIcon(
 47 |             locator=self._INTERNAL_ICON_LOCATOR,
 48 |             driver=driver,
 49 |             parent_locator_list=self.locator_list,
 50 |             wait_timeout=1,
 51 |             description="The icon in use by the Button.",
 52 |             poll_freq=poll_freq)
 53 |         self._internal_text = ComponentPiece(
 54 |             locator=self._INTERNAL_TEXT_LOCATOR,
 55 |             driver=driver,
 56 |             parent_locator_list=self.locator_list,
 57 |             wait_timeout=1,
 58 |             description="The container in which the text of the Button resides.",
 59 |             poll_freq=poll_freq)
 60 |         self._internal_image = ComponentPiece(
 61 |             locator=self._INTERNAL_IMAGE_LOCATOR,
 62 |             driver=driver,
 63 |             parent_locator_list=self.locator_list,
 64 |             wait_timeout=1,
 65 |             description="The image within the Button.",
 66 |             poll_freq=poll_freq)
 67 | 
 68 |     def click(self, wait_timeout=None, binding_wait_time: float = 0.5) -> None:
 69 |         """
 70 |         Click the button.
 71 |         """
 72 |         _button = self._get_html_button()
 73 |         if _button == self:
 74 |             super().click(wait_timeout=wait_timeout, binding_wait_time=binding_wait_time)
 75 |         else:
 76 |             _button.click(wait_timeout=wait_timeout, binding_wait_time=binding_wait_time)
 77 | 
 78 |     def get_css_property_of_icon(self, property_name: Union[CSSPropertyValue, str]) -> str:
 79 |         """
 80 |         Get some CSS property value of the icon within the button.
 81 |         """
 82 |         return self._internal_icon.get_css_property(property_name=property_name)
 83 | 
 84 |     def get_origin_of_icon(self) -> Optional[Point]:
 85 |         """
 86 |         Obtain the origin of the icon contained within this Button.
 87 | 
 88 |         :returns: A Point which marks the upper-left corner of the icon contained within this button, or None if no icon
 89 |             is present within the Button.
 90 |         """
 91 |         try:
 92 |             return self._internal_icon.get_origin()
 93 |         except TimeoutException:
 94 |             return None
 95 | 
 96 |     def get_origin_of_text(self) -> Optional[Point]:
 97 |         """
 98 |         Obtain the origin of the text of this Button.
 99 | 
100 |         :returns: A Point which marks the upper-left corner of the text contained within this button, or None if no text
101 |             is present within the Button.
102 |         """
103 |         try:
104 |             return self._internal_text.get_origin()
105 |         except TimeoutException:
106 |             return None
107 | 
108 |     def icon_is_present_in_button(self) -> bool:
109 |         """
110 |         Determine if the Button contains an icon. This is not the same as :func:`icon_is_displayed_in_button`, which
111 |         determines VISIBILITY of any such icon.
112 | 
113 |         :returns: True, if an image is currently present inside the button - False otherwise.
114 |         """
115 |         try:
116 |             return self._internal_icon.find() is not None
117 |         except TimeoutException:
118 |             return False
119 | 
120 |     def icon_is_displayed_in_button(self) -> bool:
121 |         """
122 |         Determine if the Button is displaying an internal icon.
123 | 
124 |         :returns: True, if an icon is currently displayed inside the button - False otherwise.
125 |         """
126 |         try:
127 |             return self._internal_icon.find().is_displayed()
128 |         except TimeoutException:
129 |             return False
130 | 
131 |     def image_is_displayed_in_button(self) -> bool:
132 |         """
133 |         Determine if the Button is displaying an internal image.
134 | 
135 |         :returns: True, if an image is currently displayed inside the button - False otherwise.
136 |         """
137 |         try:
138 |             return self._internal_image.find().is_displayed()
139 |         except TimeoutException:
140 |             return False
141 | 
142 |     def is_enabled(self) -> bool:
143 |         """
144 |         Determine if this Button is enabled.
145 | 
146 |         :returns: True, if the Button is currently enabled - False otherwise.
147 |         """
148 |         return self._get_html_button().find().is_enabled()
149 | 
150 |     def is_primary(self) -> bool:
151 |         """
152 |         Determine if this button is currently displaying as a Primary Button.
153 | 
154 |         :returns: True, if this button is currently displaying as a Primary Button - False otherwise.
155 |         """
156 |         clazz = self.find().get_attribute("class")
157 |         return (self.PRIMARY_CLASS in clazz) and (self.SECONDARY_CLASS not in clazz)
158 | 
159 |     def is_secondary(self) -> bool:
160 |         """
161 |         Determine if this button is currently displaying as a Secondary Button.
162 | 
163 |         :returns: True, if this button is currently displaying as a Secondary Button - False otherwise.
164 |         """
165 |         clazz = self.find().get_attribute("class")
166 |         return (self.SECONDARY_CLASS in clazz) and (self.PRIMARY_CLASS not in clazz)
167 | 
168 |     def _get_html_button(self) -> ComponentPiece:
169 |         """
170 |         Obtain the true button of this component.
171 | 
172 |         :returns: A ComponentPiece which may be used as a <button>.
173 |         """
174 |         if self.find().tag_name != 'button':
175 |             return self._internal_button
176 |         else:
177 |             return self
178 | 


--------------------------------------------------------------------------------
/Components/Common/FileUpload.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicComponent, ComponentPiece
 7 | 
 8 | 
 9 | class FileUpload(BasicComponent):
10 |     """
11 |     A Common/shared implementation of a File upload, used both within Perspective and the gateway.
12 |     """
13 |     _BUTTON_LOCATOR = (By.TAG_NAME, f"button.primary")
14 |     _INPUT_LOCATOR = (By.CSS_SELECTOR, "input")
15 | 
16 |     def __init__(
17 |             self,
18 |             locator: Tuple[By, str],
19 |             driver: WebDriver,
20 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
21 |             wait_timeout: float = 10,
22 |             description: Optional[str] = None,
23 |             poll_freq: float = 0.5):
24 |         super().__init__(
25 |             locator=locator,
26 |             driver=driver,
27 |             parent_locator_list=parent_locator_list,
28 |             wait_timeout=wait_timeout,
29 |             description=description,
30 |             poll_freq=poll_freq)
31 |         self._button = ComponentPiece(
32 |             locator=self._BUTTON_LOCATOR,
33 |             driver=driver,
34 |             parent_locator_list=self.locator_list,
35 |             description="The button within the File Upload which actually opens the OS dialog.",
36 |             poll_freq=poll_freq)
37 |         self._input = ComponentPiece(
38 |             locator=self._INPUT_LOCATOR,
39 |             driver=driver,
40 |             parent_locator_list=self.locator_list,
41 |             description="The hidden input within the File Upload which can be used to specify file paths.")
42 | 
43 |     def get_button_text(self) -> str:
44 |         """
45 |         Obtain the text displayed within the button of the File Upload.
46 | 
47 |         :returns: The text displayed to the user within the button of the File Upload.
48 | 
49 |         :raises TimeoutException: If the File Upload is rendering in a manner which does not include a button.
50 |         """
51 |         return self._button.get_text()
52 | 
53 |     def is_enabled(self) -> bool:
54 |         """
55 |         Determine if the File Upload is enabled.
56 | 
57 |         :returns: True, if the File Upload is currently enabled - False otherwise.
58 | 
59 |         :raises TimeoutException: If the File Upload is rendering in a manner which does not include a button.
60 |         """
61 |         return "disabled" not in self._button.find().get_attribute("class")
62 | 
63 |     def upload_file_by_path(self, normalized_file_path: str) -> None:
64 |         """
65 |         Supply the location of a file to be uploaded.
66 | 
67 |         :param normalized_file_path: The normalized (OS-agnostic) path to the file to be uploaded.
68 |         """
69 |         self._input.find().send_keys(normalized_file_path)
70 | 


--------------------------------------------------------------------------------
/Components/Common/TextInput.py:
--------------------------------------------------------------------------------
  1 | from typing import Optional, Union, Tuple, List
  2 | 
  3 | from selenium.common.exceptions import ElementClickInterceptedException
  4 | from selenium.webdriver import ActionChains
  5 | from selenium.webdriver.common.by import By
  6 | from selenium.webdriver.common.keys import Keys
  7 | from selenium.webdriver.remote.webdriver import WebDriver
  8 | 
  9 | from Components.BasicComponent import ComponentPiece
 10 | from Helpers.IAAssert import IAAssert
 11 | from Helpers.IAExpectedConditions.IAExpectedConditions import TextCondition
 12 | 
 13 | 
 14 | class CommonTextInput(ComponentPiece):
 15 |     """A common-use input field."""
 16 |     _INTERNAL_INPUT_LOCATOR = (By.TAG_NAME, "input")
 17 | 
 18 |     def __init__(
 19 |             self,
 20 |             locator: Tuple[By, str],
 21 |             driver: WebDriver,
 22 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 23 |             wait_timeout: float = 2,
 24 |             description: Optional[str] = None,
 25 |             poll_freq: float = 0.5):
 26 |         super().__init__(
 27 |             locator=locator,
 28 |             driver=driver,
 29 |             parent_locator_list=parent_locator_list,
 30 |             wait_timeout=wait_timeout,
 31 |             description=description,
 32 |             poll_freq=poll_freq)
 33 |         # The internal input piece is important for when our component has a quality overlay because any reference
 34 |         # made using something like an id would now refer to the <div> level instead.
 35 |         self._internal_input = ComponentPiece(
 36 |             locator=self._INTERNAL_INPUT_LOCATOR,
 37 |             driver=self.driver,
 38 |             wait_timeout=0,
 39 |             parent_locator_list=self.locator_list,
 40 |             description="The internal <input> element, used primarily for Text Fields, or when the component contains "
 41 |                         "a quality overlay.",
 42 |             poll_freq=poll_freq)
 43 | 
 44 |     def get_placeholder_text(self) -> str:
 45 |         """
 46 |         Obtain the text in use as a placeholder for this component.
 47 | 
 48 |         :returns: The text a user sees within this component when no value has been supplied.
 49 |         """
 50 |         return self.find().get_attribute("placeholder")
 51 | 
 52 |     def get_text(self) -> str:
 53 |         """
 54 |         Obtain the text contained within this component.
 55 | 
 56 |         :returns: The text contents of the component via the `value` attribute.
 57 |         """
 58 |         input_component = self._internal_input if self._needs_to_get_input_element() else self
 59 |         return input_component.find().get_attribute("value")
 60 | 
 61 |     def placeholder_text_exists(self) -> bool:
 62 |         """
 63 |         Determine if a component is currently displaying placeholder text.
 64 | 
 65 |         :returns: True, if a component is currently displaying placeholder text - False otherwise.
 66 |         """
 67 |         return (self.find().get_attribute("placeholder") is not None) and (self.find().get_attribute("value") is None)
 68 | 
 69 |     def set_text(
 70 |             self,
 71 |             text: Union[float, str],
 72 |             release_focus: bool = True,
 73 |             binding_wait_time: float = 0) -> None:
 74 |         """
 75 |         Set the value of this component.
 76 | 
 77 |         :param text: The text to type into the field.
 78 |         :param release_focus: Dictates whether a blur() event is invoked for the component after typing the supplied
 79 |             text.
 80 |         :param binding_wait_time: The amount of time (in seconds) to wait after typing the supplied text before allowing
 81 |             code to continue.
 82 |         """
 83 |         text = str(text)
 84 |         # strip special characters (ESC, ENTER) while leaving spaces and punctuation
 85 |         expected_text = text.encode("ascii", "ignore").decode()
 86 |         if text is None or text == '':
 87 |             text = ' ' + Keys.BACKSPACE
 88 |         self.wait_on_text_condition(text_to_compare="", condition=TextCondition.DOES_NOT_EQUAL, wait_timeout=0.5)
 89 |         current_text = self.get_text()  # Do NOT wait on matching text to be in place
 90 |         keys_to_send = ''.join([Keys.ARROW_RIGHT for _ in current_text] +
 91 |                                [Keys.BACKSPACE for _ in current_text] +
 92 |                                [text])
 93 |         self.scroll_to_element()
 94 |         input_object = self
 95 |         if self._needs_to_get_input_element():
 96 |             input_object = self._internal_input
 97 |         try:
 98 |             input_object.click()
 99 |         except ElementClickInterceptedException:
100 |             # quality overlay interference
101 |             ActionChains(driver=self.driver) \
102 |                 .move_to_element_with_offset(to_element=input_object.find(), xoffset=5, yoffset=5) \
103 |                 .click() \
104 |                 .perform()
105 |         input_object.find().send_keys(keys_to_send)
106 |         if release_focus:
107 |             self.release_focus()
108 |         IAAssert.is_equal_to(
109 |             actual_value=self.wait_on_text_condition(
110 |                 text_to_compare=expected_text, condition=TextCondition.EQUALS, wait_timeout=binding_wait_time + 0.5),
111 |             expected_value=expected_text,
112 |             failure_msg="Failed to set the value of the input.")
113 |         self.wait_on_binding(time_to_wait=binding_wait_time)
114 | 
115 |     def _needs_to_get_input_element(self) -> bool:
116 |         """
117 |         Determine if the Component IS the <input>, or if we should instead query for the internal <input>.
118 | 
119 |         :returns: True, if the current component definition would fail to operate as an <input> - False otherwise.
120 |         """
121 |         return self.find().tag_name not in ['input', 'textarea']
122 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Charts/Pie.py:
--------------------------------------------------------------------------------
  1 | from typing import Tuple, Optional, List
  2 | 
  3 | from selenium.common.exceptions import TimeoutException, NoSuchElementException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
  8 | 
  9 | 
 10 | class Pie(BasicPerspectiveComponent):
 11 |     """A Perspective Pie Chart Component."""
 12 |     LOGGER = "PIE"
 13 |     _SECTION_LOCATOR = (By.CSS_SELECTOR, 'g[role="menu-item"]')
 14 |     _CHECKBOX_LOCATOR = (By.CSS_SELECTOR, 'g[role="switch"]')
 15 |     _CHECKBOX_LABEL_LOCATOR = (By.CSS_SELECTOR, "tspan")
 16 |     _TITLE_LOCATOR = (By.CSS_SELECTOR, "svg > g > g > g > g > g > g > text > tspan")
 17 |     _LEGEND_CONTAINER_LOCATOR = (By.CSS_SELECTOR, 'g[aria-label="Legend"]')
 18 | 
 19 |     def __init__(
 20 |             self,
 21 |             locator: Tuple[By, str],
 22 |             driver: WebDriver,
 23 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 24 |             wait_timeout: float = 10,
 25 |             description: Optional[str] = None,
 26 |             poll_freq: float = 0.5):
 27 |         super().__init__(
 28 |             locator=locator,
 29 |             driver=driver,
 30 |             parent_locator_list=parent_locator_list,
 31 |             wait_timeout=wait_timeout,
 32 |             description=description,
 33 |             poll_freq=poll_freq)
 34 |         self._sections = ComponentPiece(
 35 |             locator=self._SECTION_LOCATOR,
 36 |             driver=driver,
 37 |             parent_locator_list=self.locator_list,
 38 |             wait_timeout=1,
 39 |             description="The actual slices of the Pie.",
 40 |             poll_freq=poll_freq)
 41 |         self._title = ComponentPiece(
 42 |             locator=self._TITLE_LOCATOR,
 43 |             driver=driver,
 44 |             parent_locator_list=self.locator_list,
 45 |             wait_timeout=1,
 46 |             description="The title of the Pie Chart.",
 47 |             poll_freq=poll_freq)
 48 |         self._legend_container = ComponentPiece(
 49 |             locator=self._LEGEND_CONTAINER_LOCATOR,
 50 |             driver=driver,
 51 |             parent_locator_list=self.locator_list,
 52 |             wait_timeout=1,
 53 |             description="The Legend of the Pie Chart.",
 54 |             poll_freq=poll_freq)
 55 |         self._checkboxes = ComponentPiece(
 56 |             locator=self._CHECKBOX_LOCATOR,
 57 |             driver=driver,
 58 |             parent_locator_list=self._legend_container.locator_list,
 59 |             wait_timeout=1,
 60 |             description="The checkboxes within the legend of the Pie Chart.",
 61 |             poll_freq=poll_freq)
 62 | 
 63 |     def get_chart_title(self) -> str:
 64 |         """
 65 |         Obtain the title of the Pie Chart.
 66 | 
 67 |         :returns: The title of the Pie Chart as it is displayed to the user.
 68 | 
 69 |         :raises TimeoutException: If the Pie CHart is not displaying a title.
 70 |         """
 71 |         try:
 72 |             return self._title.get_text()
 73 |         except TimeoutException as toe:
 74 |             raise TimeoutException(msg="No title is present for the Pie Chart.") from toe
 75 | 
 76 |     def get_legend_checkbox_count(self) -> int:
 77 |         """
 78 |         Obtain a count of displayed checkboxes from the legend.
 79 | 
 80 |         :returns: A count of all checkboxes displayed as part of legend of the Pie Chart.
 81 |         """
 82 |         try:
 83 |             return len(self._checkboxes.find_all())
 84 |         except TimeoutException:
 85 |             return 0
 86 | 
 87 |     def get_legend_checkbox_labels(self) -> List[str]:
 88 |         """
 89 |         Obtain all labels for checkboxes in the legend of the Pie Chart.
 90 | 
 91 |         :returns: A list which contains the text of all displayed labels belonging to checkboxes in the legend.
 92 | 
 93 |         :raises TimeoutException: If no checkboxes (or labels) are displayed,
 94 |         """
 95 |         # checkboxes have multiple <tspan> children, and we want ONLY the first one.
 96 |         try:
 97 |             return [
 98 |                 checkbox.find_element(*self._CHECKBOX_LABEL_LOCATOR).text for checkbox in self._checkboxes.find_all()]
 99 |         except TimeoutException as toe:
100 |             raise TimeoutException(msg="No checkbox labels are present.") from toe
101 | 
102 |     def get_pie_slice_count(self) -> int:
103 |         """
104 |         Obtain a count of displayed pie slices.
105 | 
106 |         :returns: A count of pie slices displayed to the user.
107 |         """
108 |         try:
109 |             return len(self._sections.find_all())
110 |         except TimeoutException:
111 |             return 0
112 | 
113 |     def has_title(self) -> bool:
114 |         """
115 |         Determine if the Pie Chart is displaying a title.
116 | 
117 |         :returns: True, if the Pie Chart is currently displaying a title - False otherwise.
118 |         """
119 |         try:
120 |             return self._title.find() is not None
121 |         except TimeoutException:
122 |             return False
123 | 
124 |     def legend_is_displayed(self) -> bool:
125 |         """
126 |         Determine if the Pie Chart is displaying a legend.
127 | 
128 |         :returns: True, if the Pie Chart is currently displaying a legend - False otherwise.
129 |         """
130 |         try:
131 |             return self._legend_container.find().is_displayed()
132 |         except TimeoutException:
133 |             return False
134 | 
135 |     def pie_slice_labels_are_displayed(self) -> bool:
136 |         """
137 |         Determine if pie slices are displaying labels.
138 | 
139 |         :returns: True, if pie slices are currently displaying labels - False otherwise.
140 |         """
141 |         # We can't follow the normal pattern here because we specifically need the 0th instance of the 5th child.
142 |         sections = ComponentPiece(
143 |             locator=(By.CSS_SELECTOR, 'g[aria-label="Series"] > g > g:nth-child(5)'),
144 |             driver=self.driver,
145 |             parent_locator_list=self.locator_list,
146 |             wait_timeout=1,
147 |             poll_freq=self.poll_freq)
148 |         try:
149 |             return len(sections.find_all()[0].find_elements(By.CSS_SELECTOR, 'tspan')) > 0
150 |         except TimeoutException:
151 |             return False
152 |         except NoSuchElementException:
153 |             return False
154 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Charts/TimeSeriesChart.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 7 | 
 8 | 
 9 | class TimeSeriesChart(BasicPerspectiveComponent):
10 |     """A Perspective Time Series Chart."""
11 |     _DATE_TIME_CONTAINER_LOCATOR = (By.CSS_SELECTOR, ".date-time-container:nth-of-type(1)")
12 |     _DATE_CONTAINER_LOCATOR = (By.CSS_SELECTOR, ".date-container")
13 |     _TIME_CONTAINER_LOCATOR = (By.CSS_SELECTOR, ".time-container")
14 |     _TIME_AXIS_LABEL_LOCATOR = (By.CSS_SELECTOR, "text.ia_timeSeriesChartComponent__timeAxis__values")
15 | 
16 |     def __init__(
17 |             self,
18 |             locator: Tuple[By, str],
19 |             driver: WebDriver,
20 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
21 |             wait_timeout: float = 5,
22 |             description: Optional[str] = None,
23 |             poll_freq: float = 0.5):
24 |         super().__init__(
25 |             locator=locator,
26 |             driver=driver,
27 |             parent_locator_list=parent_locator_list,
28 |             wait_timeout=wait_timeout,
29 |             description=description,
30 |             poll_freq=poll_freq)
31 |         self._date_time_container = ComponentPiece(
32 |             locator=self._DATE_TIME_CONTAINER_LOCATOR,
33 |             driver=driver,
34 |             parent_locator_list=self.locator_list,
35 |             wait_timeout=1,
36 |             description="The container for the date/time labels.",
37 |             poll_freq=poll_freq)
38 |         self._date_container = ComponentPiece(
39 |             locator=self._DATE_CONTAINER_LOCATOR,
40 |             driver=driver,
41 |             parent_locator_list=self._date_time_container.locator_list,
42 |             wait_timeout=1,
43 |             description="The container which contains only the date information.",
44 |             poll_freq=poll_freq)
45 |         self._time_container = ComponentPiece(
46 |             locator=self._TIME_CONTAINER_LOCATOR,
47 |             driver=driver,
48 |             parent_locator_list=self._date_time_container.locator_list,
49 |             wait_timeout=1,
50 |             description="The container which contains only the time information.",
51 |             poll_freq=poll_freq)
52 |         self._time_axis_label = ComponentPiece(
53 |             locator=self._TIME_AXIS_LABEL_LOCATOR,
54 |             driver=driver,
55 |             parent_locator_list=self.locator_list,
56 |             wait_timeout=1,
57 |             description="The label which contains the text of the time axis of the Time Series Chart.",
58 |             poll_freq=poll_freq)
59 | 
60 |     def get_date_range_text(self) -> str:
61 |         """
62 |         Obtain the text which describes the date range of the graphed data.
63 | 
64 |         :returns: The text visible to a user which describes the date range of the graphed data.
65 | 
66 |         :raises TimeoutException: If the date is not present.
67 |         """
68 |         return self._date_container.get_text()
69 | 
70 |     def get_text_of_last_time_meridian(self) -> str:
71 |         """
72 |         Obtain the text of the last displayed time meridian (am/pm) of the chart.
73 | 
74 |         :returns: The text of the last displayed time meridian.
75 | 
76 |         :raises TimeoutException: If the time range is not present.
77 |         """
78 |         return self._time_container.get_text().split(" ")[-1]
79 | 
80 |     def get_time_axis_label(self, zero_based_index: int) -> str:
81 |         """
82 |         Obtain the text of a time axis label as it is displayed to the user.
83 |         
84 |         :param zero_based_index: The zero-based index of the label to obtain.
85 |         
86 |         :returns: The text of a time axis (x axis) label.
87 | 
88 |         :raises IndexError: If the supplied index is invalid based o the number of labels displayed.
89 |         :raises TimeoutException: If no time axis labels are present.
90 |         """
91 |         return self._time_axis_label.find_all()[zero_based_index].text
92 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Charts/XYChart.py:
--------------------------------------------------------------------------------
  1 | from enum import Enum
  2 | from typing import Optional, Union, Tuple, List
  3 | 
  4 | from selenium.common.exceptions import TimeoutException
  5 | from selenium.webdriver.common.by import By
  6 | from selenium.webdriver.remote.webdriver import WebDriver
  7 | from selenium.webdriver.remote.webelement import WebElement
  8 | 
  9 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 10 | from Helpers.IASelenium import IASelenium
 11 | 
 12 | 
 13 | class RenderType(Enum):
 14 |     """An enumeration of available render types for the Perspective XY Chart Component."""
 15 |     CANDLESTICK = "candlestick"
 16 |     COLUMN = "column"
 17 |     LINE = "line"
 18 |     STEP_LINE = "step line"
 19 | 
 20 | 
 21 | class XYChart(BasicPerspectiveComponent):
 22 |     """A Perspective XY Chart Component."""
 23 | 
 24 |     def __init__(
 25 |             self,
 26 |             locator: Tuple[By, str],
 27 |             driver: WebDriver,
 28 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 29 |             wait_timeout: float = 5,
 30 |             description: Optional[str] = None,
 31 |             poll_freq: float = 0.5):
 32 |         super().__init__(
 33 |             locator=locator,
 34 |             driver=driver,
 35 |             parent_locator_list=parent_locator_list,
 36 |             wait_timeout=wait_timeout,
 37 |             description=description,
 38 |             poll_freq=poll_freq)
 39 |         self._bar_coll = {}
 40 |         self._series_coll = {}
 41 | 
 42 |     def click(self, wait_timeout: Optional[Union[int, float]] = None, binding_wait_time: float = 0) -> None:
 43 |         """
 44 |         Please do not blindly click the XY Chart; no good will come of it.
 45 | 
 46 |         :raises NotImplementedError: Because you shouldn't do it.
 47 |         """
 48 |         raise NotImplementedError("Please don't blindly click the XYChart.")
 49 | 
 50 |     def click_series_label_in_legend_by_text(self, label_text: str, binding_wait_time: float = 0) -> None:
 51 |         """
 52 |         Click the label of a series within the legend of the XY Chart.
 53 | 
 54 |         :param label_text: The text of the label to click. This should be the name of the series.
 55 |         :param binding_wait_time: How long to wait after the click before allowing code to continue.
 56 | 
 57 |         :raises TimeoutException: If no label with the provided text is present.
 58 |         :raises NoSuchElementException: If unable to locate the click target of the label.
 59 |         """
 60 |         self._get_series_label_from_legend(label_text=label_text).find_element(*(By.TAG_NAME, "rect")).click()
 61 |         self.wait_on_binding(time_to_wait=binding_wait_time)
 62 | 
 63 |     def get_count_of_bars_in_series(self, series_label: str) -> int:
 64 |         """
 65 |         Obtain a count of bars displayed for a given series.
 66 | 
 67 |         :param series_label: The name of the series for which we will obtain a count of bars.
 68 | 
 69 |         :returns: The count of displayed bars for the provided series.
 70 |         """
 71 |         try:
 72 |             return len(self._get_paths_for_series(series_label=series_label).find_all())
 73 |         except TimeoutException:
 74 |             return 0
 75 | 
 76 |     def hover_over_bar_of_series(self, bar_index: int, series_label: str) -> None:
 77 |         """
 78 |         Hover over a specific bar for a given series.
 79 | 
 80 |         :param bar_index: The zero-based index of the bar you would like to hover over.
 81 |         :param series_label: The name of the series to target.
 82 | 
 83 |         :raises IndexError: If the supplied index is invalid based on the number of displayed bars.
 84 |         :raises TimeoutException: If no bars exist for the provided series.
 85 |         """
 86 |         IASelenium(driver=self.driver).hover_over_web_element(
 87 |             web_element=self._get_paths_for_series(series_label=series_label).find_all()[bar_index])
 88 | 
 89 |     def series_label_is_displayed_in_legend(self, label_text: str) -> bool:
 90 |         """
 91 |         Determine if a series is displayed in the legend of the XY Chart.
 92 | 
 93 |         :param label_text: The name of the series.
 94 | 
 95 |         :returns: True, if the provided series is listed in the legend - False otherwise.
 96 |         """
 97 |         try:
 98 |             return self._get_series_label_from_legend(label_text=label_text).is_displayed()
 99 |         except IndexError:
100 |             return False
101 | 
102 |     def series_is_displayed_in_chart_body(self, series_name: str) -> bool:
103 |         """
104 |         Determine if a series is displayed in the body (graph) of the XY Chart.
105 | 
106 |         :param series_name: The name of the series to look for in the body of the XY Chart.
107 | 
108 |         :returns: True, if the provided series is graphed in some manner - False otherwise.
109 |         """
110 |         return self._get_top_level_series_element(series_label=series_name).find().is_displayed()
111 | 
112 |     def _get_series_label_from_legend(self, label_text: str) -> WebElement:
113 |         """
114 |         Obtain the WebElement which is the label for a series in the legend of the XY Chart.
115 | 
116 |         :param label_text: The text of the label to query for.
117 | 
118 |         :returns: A WebElement which is the label of the provided series within the legend of the XY Chart.
119 | 
120 |         :raises IndexError: If no label with the provided text is present.
121 |         :raises NoSuchElementException: If no labels are found at all.
122 |         """
123 |         return list(
124 |             filter(
125 |                 lambda e: e.text == label_text,
126 |                 self.driver.find_elements(
127 |                     *ComponentPiece(
128 |                         locator=(By.CSS_SELECTOR, 'g[focusable="true"]'),
129 |                         driver=self.driver,
130 |                         parent_locator_list=self.locator_list).get_full_css_locator())))[0]
131 | 
132 |     def _get_paths_for_series(self, series_label: str) -> ComponentPiece:
133 |         """
134 |         Obtain the Component Piece which describes the paths for a given series.
135 | 
136 |         :param series_label: The name of the series we would like the paths for.
137 | 
138 |         :returns: A Component piece which can be used to describe ALL <paths> for a series.
139 |         """
140 |         bar = self._bar_coll.get(series_label)
141 |         if not bar:
142 |             bar = ComponentPiece(
143 |                 locator=(By.CSS_SELECTOR, 'path'),
144 |                 driver=self.driver,
145 |                 parent_locator_list=self._get_top_level_series_element(series_label=series_label).locator_list,
146 |                 description="The <path> elements which define the lines drawn for the series.")
147 |             self._bar_coll[series_label] = bar
148 |         return bar
149 | 
150 |     def _get_top_level_series_element(self, series_label: str) -> ComponentPiece:
151 |         """
152 |         Obtain a ComponentPiece which describes a series in the body of the XY Chart.
153 | 
154 |         :param series_label: The name of the series we would like the graph overview of.
155 | 
156 |         :returns: A Component piece which can be used to describe the series in the body of the XY Chart.
157 |         """
158 |         series = self._series_coll.get(series_label)
159 |         if not series:
160 |             series = ComponentPiece(
161 |                 locator=(By.CSS_SELECTOR, f'g[aria-label="{series_label}"]'),
162 |                 driver=self.driver,
163 |                 parent_locator_list=self.locator_list,
164 |                 description=f"The label for the '{series_label}' series.")
165 |             self._series_coll[series_label] = series
166 |         return series
167 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Common/Checkbox.py:
--------------------------------------------------------------------------------
  1 | from typing import Optional, Tuple, List
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import ComponentPiece
  8 | from Components.PerspectiveComponents.Common.Icon import CommonIcon
  9 | from Helpers.IAAssert import IAAssert
 10 | from Helpers.IAExpectedConditions import IAExpectedConditions as IAec
 11 | 
 12 | 
 13 | class CommonCheckbox(ComponentPiece):
 14 |     """
 15 |     A Common Checkbox, as might be used within a larger component.
 16 | 
 17 |     Important terminology:
 18 |     "selected": Used to refer to the checked state of the checkbox. While most often a True/False value, this may
 19 |         occasionally be None when dealing with Indeterminate Checkboxes.
 20 |     """
 21 |     _DISABLED_CLASS = "ia_checkbox--disabled"
 22 |     _CLICK_TARGET_LOCATOR = (By.CSS_SELECTOR, "label.ia_checkbox")
 23 |     _LABEL_TEXT_LOCATOR = (By.CSS_SELECTOR, "label.checkbox-input-label")
 24 |     _ICON_LOCATOR = (By.TAG_NAME, "svg")
 25 |     _INPUT_LOCATOR = (By.TAG_NAME, "input")
 26 |     _STATE_MAP = {
 27 |         "indeterminate": None,
 28 |         "checked": True
 29 |     }
 30 | 
 31 |     def __init__(
 32 |             self,
 33 |             locator: Tuple[By, str],
 34 |             driver: WebDriver,
 35 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 36 |             wait_timeout: float = 3,
 37 |             description: Optional[str] = None,
 38 |             poll_freq: float = 0.5):
 39 |         super().__init__(
 40 |             locator=locator,
 41 |             driver=driver,
 42 |             parent_locator_list=parent_locator_list,
 43 |             wait_timeout=wait_timeout,
 44 |             description=description,
 45 |             poll_freq=poll_freq)
 46 |         self._click_target = ComponentPiece(
 47 |             locator=self._CLICK_TARGET_LOCATOR,
 48 |             driver=driver,
 49 |             parent_locator_list=self.locator_list,
 50 |             poll_freq=poll_freq,
 51 |             description="The actual visible checkbox a user would click.")
 52 |         self._text_label = ComponentPiece(
 53 |             locator=self._LABEL_TEXT_LOCATOR,
 54 |             driver=driver,
 55 |             parent_locator_list=self.locator_list,
 56 |             poll_freq=poll_freq,
 57 |             description="The actual text a user should see for the Checkbox.")
 58 |         self._icon = CommonIcon(
 59 |             locator=self._ICON_LOCATOR,
 60 |             driver=driver,
 61 |             parent_locator_list=self.locator_list,
 62 |             poll_freq=poll_freq,
 63 |             description="The actual text a user should see for the Checkbox.")
 64 |         self._input = ComponentPiece(
 65 |             locator=self._INPUT_LOCATOR,
 66 |             driver=driver,
 67 |             parent_locator_list=self.locator_list,
 68 |             poll_freq=poll_freq)
 69 | 
 70 |     def click(self, wait_timeout: Optional[float] = None, binding_wait_time: float = 0) -> None:
 71 |         """
 72 |         Click the Checkbox.
 73 | 
 74 |         If attempting to set the checkbox to a known state, :func:`set_state` is preferred.
 75 | 
 76 |         :param wait_timeout: The amount of time you are willing to wait for the checkbox to appear before attempting
 77 |             to perform the click. Overrides the component's original wait.
 78 |         :param binding_wait_time: The amount of time after the click occurs before allowing code to continue.
 79 |         """
 80 |         self._click_target.click(wait_timeout=wait_timeout, binding_wait_time=binding_wait_time)
 81 | 
 82 |     def get_direction_of_label_text(self) -> str:
 83 |         """
 84 |         Obtain the direction of the text as a string. This value describes the location of the text relative to the
 85 |         Checkbox.
 86 |         """
 87 |         return self._text_label.find().get_attribute("class").split("--")[-1]
 88 | 
 89 |     def get_label_text(self) -> str:
 90 |         """Obtain the text of the label of the checkbox."""
 91 |         return self._text_label.find().text
 92 | 
 93 |     def get_path_of_icon(self) -> str:
 94 |         """
 95 |         Obtain a slash-delimited path of the icon currently in use for the checkbox.
 96 |         """
 97 |         return self._icon.get_icon_name()
 98 | 
 99 |     def is_enabled(self) -> bool:
100 |         """
101 |         Determine if the Checkbox is currently enabled.
102 | 
103 |         :returns: True, if the Checkbox is enabled - False otherwise.
104 |         """
105 |         try:
106 |             return self.wait.until(IAec.function_returns_true(
107 |                 custom_function=self._is_enabled, function_args={}))
108 |         except TimeoutException:
109 |             return False
110 | 
111 |     def is_selected(self) -> Optional[bool]:
112 |         """
113 |         Obtain the state of the checkbox.
114 | 
115 |         :returns: True, if checked. False, if un-checked. None, if indeterminate (tri-state).
116 |         """
117 |         return self._STATE_MAP.get(self._icon.find().get_attribute("data-state"), False)
118 | 
119 |     def set_state(self, should_be_selected: Optional[bool], binding_wait_time: float = 0) -> None:
120 |         """
121 |         Set the checkbox to a specified state.
122 |         :param binding_wait_time: How long to wait before allowing the code to continue.
123 |         :param should_be_selected: True if the Checkbox should be selected, False if it should not be selected, or None
124 |             if the checkbox is a tri-state checkbox and should be 'indeterminate'.
125 |         """
126 |         self._set_state(should_be_selected=should_be_selected, binding_wait_time=binding_wait_time)
127 | 
128 |     def _is_enabled(self) -> bool:
129 |         """Determine if the checkbox is enabled."""
130 |         return self._input.find().is_enabled() and (
131 |                 self._DISABLED_CLASS not in self._click_target.find().get_attribute("class"))
132 | 
133 |     def _set_state(
134 |             self,
135 |             should_be_selected: Optional[bool],
136 |             already_clicked_once: bool = False,
137 |             binding_wait_time: float = 0) -> None:
138 |         """
139 |         Set the checkbox to a specified selection state.
140 |         :param should_be_selected: True if the Checkbox should be selected, False if it should not be selected, or None
141 |             if the checkbox is a tri-state checkbox and should be 'indeterminate'.
142 |         :param already_clicked_once: Used to prevent possible recursion by preventing additional calls. In theory, we
143 |             should only ever need to call this function twice in a row, in order to swap between the three states.
144 |         """
145 |         if self.is_selected() != should_be_selected:
146 |             self.click(binding_wait_time=binding_wait_time)
147 |             # could potentially need to click again (checked/unchecked/indeterminate)
148 |             if not already_clicked_once:
149 |                 # prevent possible recursion issues
150 |                 self._set_state(should_be_selected=should_be_selected, already_clicked_once=True)
151 |         IAAssert.is_equal_to(
152 |             actual_value=self.is_selected(),
153 |             expected_value=should_be_selected,
154 |             failure_msg="Failed to set the state of a checkbox.")
155 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Common/ComponentModal.py:
--------------------------------------------------------------------------------
 1 | from typing import Union, Optional
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import ComponentPiece
 7 | 
 8 | 
 9 | class ComponentModal(ComponentPiece):
10 |     """
11 |     A Perspective Component Modal, unique from the modal in use by Perspective Popups. The Component Modal is often
12 |     used by Dropdowns and interactive menus to display available options.
13 |     """
14 |     _LOCATOR = (By.CSS_SELECTOR, 'div.ia_componentModal')
15 | 
16 |     def __init__(
17 |             self,
18 |             driver: WebDriver,
19 |             wait_timeout: Union[float, int] = 2,
20 |             description: Optional[str] = None,
21 |             poll_freq: float = 0.5):
22 |         super().__init__(
23 |             locator=self._LOCATOR,
24 |             driver=driver,
25 |             wait_timeout=wait_timeout,
26 |             description=description,
27 |             poll_freq=poll_freq)
28 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Common/Icon.py:
--------------------------------------------------------------------------------
  1 | from typing import Tuple, Optional, List
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import ComponentPiece
  8 | from Helpers.CSSEnumerations import CSS
  9 | 
 10 | 
 11 | class CommonIcon(ComponentPiece):
 12 |     """An Icon which could be used anywhere within Perspective, including within other components."""
 13 |     # This list will grow over time, until Dev takes this on as a unit test for their Icon strip-and-zip
 14 |     _KNOWN_EXTRANEOUS_D_ATTRIBUTE_LIST = [
 15 |         'M24 24H0V0h24v24z',
 16 |         'M0,0h24v24H0V0z',
 17 |         'M0,0h24 M24,24H0'
 18 |     ]
 19 | 
 20 |     def __init__(
 21 |             self,
 22 |             locator: Tuple[By, str],
 23 |             driver: WebDriver,
 24 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 25 |             wait_timeout: float = 2,
 26 |             description: Optional[str] = None,
 27 |             poll_freq: float = 0.5):
 28 |         super().__init__(
 29 |             locator=locator,
 30 |             driver=driver,
 31 |             parent_locator_list=parent_locator_list,
 32 |             wait_timeout=wait_timeout,
 33 |             description=description,
 34 |             poll_freq=poll_freq)
 35 |         self._children = ComponentPiece(
 36 |             locator=(By.CSS_SELECTOR, "g > *"),
 37 |             driver=driver,
 38 |             parent_locator_list=self.locator_list,
 39 |             poll_freq=poll_freq)
 40 |         self._bad_borders = [
 41 |             ComponentPiece(
 42 |                 locator=(By.CSS_SELECTOR, f'path[d="{bad_border}"]'),
 43 |                 driver=driver,
 44 |                 parent_locator_list=self.locator_list,
 45 |                 poll_freq=poll_freq) for bad_border in self._KNOWN_EXTRANEOUS_D_ATTRIBUTE_LIST
 46 |         ]
 47 |         self._internal_g = ComponentPiece(
 48 |             locator=(By.CSS_SELECTOR, "g > g"),
 49 |             driver=driver,
 50 |             parent_locator_list=self.locator_list,
 51 |             poll_freq=poll_freq)
 52 | 
 53 |     def get_fill_color(self) -> str:
 54 |         """
 55 |         Obtain the fill in use by the Icon. In the event any children (internal <g> elements) of the Icon have a
 56 |         different fill, return that value instead.
 57 | 
 58 |         :returns: The fill color in use by the Icon. As a way to verify any potential children of the icon are
 59 |             displaying the same expected color, this function will return any mismatched child color instead.
 60 |         """
 61 |         local_fill = self.get_css_property(property_name=CSS.FILL)
 62 |         try:
 63 |             for child in self._children.find_all(wait_timeout=1):
 64 |                 child_fill = child.value_of_css_property("fill")  # WebElement (WE), so have to use WE function
 65 |                 if child_fill != local_fill and child_fill != 'none':  # ignore 'none' because we have 0 control over it
 66 |                     return child_fill
 67 |         except TimeoutException:
 68 |             pass
 69 |         return local_fill
 70 | 
 71 |     def get_icon_name(self) -> str:
 72 |         """
 73 |         Obtain the library and id of the Icon as a slash-delimited string.
 74 | 
 75 |         Example: material/perm_identity denotes the 'perm_identity' svg from the 'material' library.
 76 | 
 77 |         :returns: The library and id of the svg in use by the Icon Component as a slash-delimited string.
 78 | 
 79 |         raises: ValueError if the internal <g> element claims to be using a different id than the top-level
 80 |         component declares.
 81 |         """
 82 |         library_and_name = self.find().get_attribute("data-icon")
 83 |         name_in_use = self._internal_g.find().get_attribute("id")
 84 |         if name_in_use != library_and_name.split("/")[1]:
 85 |             raise ValueError(f"The icon declared a library:name combo of {library_and_name} but is actually "
 86 |                              f"using {name_in_use} within the <g> element.")
 87 |         return library_and_name
 88 | 
 89 |     def get_stroke_color(self) -> str:
 90 |         """
 91 |         Obtain the stroke in use by the Icon. In the event any children (internal <g> elements) of the Icon have a
 92 |         different stroke, return that value instead.
 93 | 
 94 |         :returns: The stroke color in use by the Icon. As a way to verify any potential children of the icon are
 95 |             displaying the same expected color, this function will return any mismatched child color instead.
 96 |         """
 97 |         local_stroke = self.get_css_property(property_name=CSS.STROKE)
 98 |         try:
 99 |             for child in self._children.find_all(wait_timeout=1):
100 |                 child_stroke = child.value_of_css_property("stroke")  # WebElement (WE), so have to use WE function
101 |                 if child_stroke != local_stroke:
102 |                     return child_stroke
103 |         except TimeoutException:
104 |             pass
105 |         return local_stroke
106 | 
107 |     def get_viewbox_as_dict(self) -> dict:
108 |         """
109 |         Get the viewbox of the Icon as a Python dictionary.
110 | 
111 |         returns: A dictionary with the following keys: 'x', 'y', 'width', and 'height'.
112 |         """
113 |         viewbox_pieces = self.driver.execute_script(
114 |             'return arguments[0].getAttribute("viewBox")', self.find()).split(" ")
115 |         viewbox_as_dict = dict()
116 |         viewbox_as_dict['x'] = viewbox_pieces[0]
117 |         viewbox_as_dict['y'] = viewbox_pieces[1]
118 |         viewbox_as_dict['width'] = viewbox_pieces[2]
119 |         viewbox_as_dict['height'] = viewbox_pieces[3]
120 |         return viewbox_as_dict
121 | 
122 |     def has_extraneous_border(self) -> bool:
123 |         """
124 |         Determine if this Icon has any unexpected border. Used internally to verify packaged Icons have no
125 |         borders which would interfere with styling.
126 | 
127 |         :returns: True, if any internal border is found for the Icon - False otherwise.
128 |         """
129 |         for bad_border in self._bad_borders:
130 |             try:
131 |                 return bad_border.find(wait_timeout=0) is not None
132 |             except TimeoutException:
133 |                 pass
134 |         return False
135 | 
136 |     def is_rendered(self) -> bool:
137 |         """
138 |         Determine if this Icon is actually rendered/displayed.
139 | 
140 |         :returns: True, if rendered - False otherwise.
141 |         """
142 |         try:
143 |             return self._internal_g.find(wait_timeout=0.5) is not None
144 |         except TimeoutException:
145 |             return False
146 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Common/TablePieces/Filter.py:
--------------------------------------------------------------------------------
  1 | from typing import List, Tuple, Optional
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.common.keys import Keys
  6 | from selenium.webdriver.remote.webdriver import WebDriver
  7 | from selenium.webdriver.support import expected_conditions as ec
  8 | 
  9 | from Components.BasicComponent import ComponentPiece
 10 | from Components.Common.TextInput import CommonTextInput
 11 | from Helpers.IAAssert import IAAssert
 12 | from Helpers.IAExpectedConditions.IAExpectedConditions import TextCondition
 13 | 
 14 | 
 15 | class Filter(ComponentPiece):
 16 |     """
 17 |     The text filter available above the header of Table components.
 18 |     """
 19 |     _FILTER_LOCATOR = (By.CSS_SELECTOR, '.filterCommon input')
 20 |     _RESULTS_LABEL_LOCATOR = (By.CSS_SELECTOR, "div.filterResults")
 21 | 
 22 |     def __init__(
 23 |             self,
 24 |             driver: WebDriver,
 25 |             parent_locator_list: List[Tuple[By, str]] = None,
 26 |             wait_timeout: float = 1,
 27 |             description: Optional[str] = None,
 28 |             poll_freq: float = 0.5):
 29 |         super().__init__(
 30 |             locator=(By.CSS_SELECTOR, 'div[class*="Filter"]'),
 31 |             driver=driver,
 32 |             parent_locator_list=parent_locator_list,
 33 |             wait_timeout=wait_timeout,
 34 |             description=description,
 35 |             poll_freq=poll_freq)
 36 |         self._filter_input = CommonTextInput(
 37 |             locator=self._FILTER_LOCATOR,
 38 |             driver=driver,
 39 |             parent_locator_list=self.locator_list,
 40 |             wait_timeout=wait_timeout,
 41 |             poll_freq=poll_freq)
 42 |         self._results_label = ComponentPiece(
 43 |             locator=self._RESULTS_LABEL_LOCATOR,
 44 |             driver=driver,
 45 |             parent_locator_list=self.locator_list,
 46 |             wait_timeout=wait_timeout,
 47 |             poll_freq=poll_freq)
 48 | 
 49 |     def get_results_text(self) -> str:
 50 |         """
 51 |         Obtain the text of the label which provides feedback on the results of the filter.
 52 | 
 53 |         :raises TimeoutException: If the feedback filter is not present.
 54 |         """
 55 |         return self._results_label.get_text()
 56 | 
 57 |     def is_present(self) -> bool:
 58 |         """
 59 |         Determine if the filter for the table exists.
 60 | 
 61 |         :returns: True, if the filter for the table exists - False otherwise. This function makes no claims about
 62 |             visibility.
 63 |         """
 64 |         try:
 65 |             return self._filter_input.find() is not None
 66 |         except TimeoutException:
 67 |             return False
 68 | 
 69 |     def results_text_content_is_displayed(self) -> bool:
 70 |         """
 71 |         Determine if information about filtered results is present.
 72 | 
 73 |         :returns: True, if a breakdown regarding filtered results is displayed.
 74 |         """
 75 |         try:
 76 |             return len(self.get_results_text()) > 0
 77 |         except TimeoutException:
 78 |             return False
 79 | 
 80 |     def set_filter_text(self, text: str, binding_wait_time: float = 0) -> None:
 81 |         """
 82 |         Set the text filter to contain some text.
 83 | 
 84 |         :param text: The text you want to supply to the filter of the Table.
 85 |         :param binding_wait_time: how long (in seconds) after applying the text to the filter you would like to wait
 86 |             before allowing code to continue.
 87 | 
 88 |         :raises TimeoutException: If the filter input is not present.
 89 |         :raises AssertionError: If the supplied text is not successfully applied to the filter.
 90 |         """
 91 |         if self._filter_input.get_text() != text:
 92 |             self.wait.until(ec.element_to_be_clickable(self._filter_input.get_full_css_locator()))
 93 |             text_accounting_for_empty_str = Keys.SPACE + Keys.BACK_SPACE + Keys.ENTER if text == '' else text
 94 |             self._filter_input.set_text(
 95 |                 text=text_accounting_for_empty_str,
 96 |                 binding_wait_time=binding_wait_time)
 97 |         IAAssert.is_equal_to(
 98 |             actual_value=self._filter_input.wait_on_text_condition(
 99 |                 text_to_compare=text, condition=TextCondition.EQUALS),
100 |             expected_value=text,
101 |             as_type=str,
102 |             failure_msg="We failed to apply the supplied text to the filter of the Table.")
103 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Common/TagBrowseTree.py:
--------------------------------------------------------------------------------
  1 | from typing import List, Optional, Tuple
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
  8 | from Components.PerspectiveComponents.Common.Icon import CommonIcon
  9 | from Components.PerspectiveComponents.Common.Tree import CommonTree
 10 | from Components.Common.TextInput import CommonTextInput
 11 | 
 12 | 
 13 | class CommonTagBrowseTree(CommonTree, BasicPerspectiveComponent):
 14 |     _TAG_BROWSER_NO_RESULTS_FOUND_LOCATOR = (By.CSS_SELECTOR, 'span.ia_tagBrowser__noResultsDisplay__message')
 15 |     _TAG_BROWSER_RELOAD_ICON_LOCATOR = (By.CSS_SELECTOR, '.reload-icon svg')
 16 |     _TAG_BROWSER_FILTER_TEXT_FIELD_LOCATOR = (By.CSS_SELECTOR, '.filter-bar')
 17 | 
 18 |     def __init__(
 19 |             self,
 20 |             locator: Tuple[By, str],
 21 |             driver: WebDriver,
 22 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 23 |             wait_timeout: float = 3,
 24 |             description: Optional[str] = None,
 25 |             poll_freq: float = 0.5):
 26 |         CommonTree.__init__(
 27 |             self, locator=locator, driver=driver, parent_locator_list=parent_locator_list, poll_freq=poll_freq)
 28 |         BasicPerspectiveComponent.__init__(
 29 |             self,
 30 |             locator=locator,
 31 |             driver=driver,
 32 |             parent_locator_list=parent_locator_list,
 33 |             wait_timeout=wait_timeout,
 34 |             description=description,
 35 |             poll_freq=poll_freq)
 36 |         self._no_results = ComponentPiece(
 37 |             locator=self._TAG_BROWSER_NO_RESULTS_FOUND_LOCATOR,
 38 |             driver=driver,
 39 |             parent_locator_list=self.locator_list,
 40 |             poll_freq=poll_freq)
 41 |         self._reload_icon = CommonIcon(
 42 |             locator=self._TAG_BROWSER_RELOAD_ICON_LOCATOR,
 43 |             driver=driver,
 44 |             parent_locator_list=self.locator_list,
 45 |             poll_freq=poll_freq)
 46 |         self._filter_tf = CommonTextInput(
 47 |             locator=self._TAG_BROWSER_FILTER_TEXT_FIELD_LOCATOR,
 48 |             driver=driver,
 49 |             parent_locator_list=self.locator_list,
 50 |             poll_freq=poll_freq
 51 |         )
 52 | 
 53 |     def click_refresh_icon(self, binding_wait_time=5) -> None:
 54 |         """
 55 |         Click the refresh icon of the Tag Browse Tree.
 56 | 
 57 |         :raises TimeoutException: If the refresh icon is not present.
 58 |         """
 59 |         self._reload_icon.click(binding_wait_time=binding_wait_time)
 60 | 
 61 |     def get_refresh_icon_path(self) -> str:
 62 |         """
 63 |         Get a slash-delimited path of the refresh icon.
 64 | 
 65 |         :returns: The path in use by the svg in a slash-delimited format.
 66 |         """
 67 |         return self._reload_icon.get_icon_name()
 68 | 
 69 |     def no_results_message_is_displayed(self, wait_timeout=5) -> bool:
 70 |         """
 71 |         Determine if the Tag Browse Tree is currently displaying a message conveying that no results are found for the
 72 |         configured provider.
 73 | 
 74 |         :param wait_timeout: The amount of time (in seconds) to wait for the message to appear.
 75 | 
 76 |         :returns: True, if the message is displayed - False otherwise.
 77 |         """
 78 |         try:
 79 |             return self._no_results.find(wait_timeout=wait_timeout).is_displayed()
 80 |         except TimeoutException:
 81 |             return False
 82 | 
 83 |     def refresh_icon_is_displayed(self, wait_timeout=5) -> bool:
 84 |         """
 85 |         Determine if the refresh icon is currently displayed.
 86 | 
 87 |         :param wait_timeout: The amount of time (in seconds) to wait for the icon to appear.
 88 | 
 89 |         :returns: True, if the icon is displayed - False otherwise.
 90 |         """
 91 |         try:
 92 |             return self._reload_icon.find(wait_timeout=wait_timeout).is_displayed()
 93 |         except TimeoutException:
 94 |             return False
 95 | 
 96 |     def set_filter_text(self, filter_text: str) -> None:
 97 |         """
 98 |         Set the text of Tag Tree Browser Filter text field.
 99 | 
100 |         :param filter_text: The text we input to filter the tags.
101 |         """
102 |         self._filter_tf.set_text(text=filter_text, binding_wait_time=0.5)
103 | 
104 |     def filter_text_field_is_displayed(self) -> bool:
105 |         """
106 |         Determine if the Tag Browse Tree filter field is currently displayed.
107 | 
108 |         :returns: True, if the Filter text field is displayed - False otherwise.
109 |         """
110 |         try:
111 |             return self._filter_tf.find(wait_timeout=0).is_displayed()
112 |         except TimeoutException:
113 |             return False
114 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Containers/Column.py:
--------------------------------------------------------------------------------
  1 | from typing import Tuple, List, Optional
  2 | 
  3 | from selenium.common.exceptions import NoSuchElementException, TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
  8 | 
  9 | 
 10 | class Column(BasicPerspectiveComponent):
 11 |     """A Perspective Column Container."""
 12 |     _ROW_CONTAINER_LOCATOR = (By.CSS_SELECTOR, "div.inner-container")
 13 |     _ROW_LOCATOR = (By.CSS_SELECTOR, f"{_ROW_CONTAINER_LOCATOR[1]} > div.row")
 14 | 
 15 |     def __init__(
 16 |             self,
 17 |             locator: Tuple[By, str],
 18 |             driver: WebDriver,
 19 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 20 |             wait_timeout: float = 5,
 21 |             description: Optional[str] = None,
 22 |             poll_freq: float = 0.5):
 23 |         super().__init__(
 24 |             locator=locator,
 25 |             driver=driver,
 26 |             parent_locator_list=parent_locator_list,
 27 |             wait_timeout=wait_timeout,
 28 |             description=description,
 29 |             poll_freq=poll_freq)
 30 |         self._rows = ComponentPiece(
 31 |             locator=self._ROW_LOCATOR,
 32 |             driver=driver,
 33 |             parent_locator_list=self.locator_list,
 34 |             wait_timeout=2,
 35 |             poll_freq=poll_freq)
 36 |         self._indexed_rows_dict = {}
 37 | 
 38 |     def element_with_locator_is_in_row_by_index(
 39 |             self, element_locator: Tuple[By, str], zero_based_row_index: int) -> bool:
 40 |         """
 41 |         Determine if the supplied locator exists within a specified row.
 42 | 
 43 |         :param element_locator: The Tuple locator of the element to search for in the specified row.
 44 |         :param zero_based_row_index: The zero-based index of the row we will search for the provided locator.
 45 | 
 46 |         :returns: True, if the supplied locator is found within the specified row - False otherwise.
 47 |         """
 48 |         try:
 49 |             return self._get_row_by_index(index=zero_based_row_index).find().find_element(*element_locator) is not None
 50 |         except NoSuchElementException:
 51 |             return False
 52 |         except TimeoutException:
 53 |             return False
 54 | 
 55 |     def get_count_of_web_elements_in_row_by_locator(self, zero_based_row_index: int, locator: Tuple[By, str]) -> int:
 56 |         """
 57 |         Obtain a count of the number of instances which match the supplied locator within a specified row.
 58 | 
 59 |         :param zero_based_row_index: The zero-based index of the row within which we will search for the supplied
 60 |             locator.
 61 |         :param locator: The Tuple locator we will search for within the specified row.
 62 | 
 63 |         :returns: The number of times the supplied locator is found within the specified row.
 64 | 
 65 |         :raises TimeoutException: If the supplied row index is not present.
 66 |         """
 67 |         try:
 68 |             # allow TimeoutException to be raised if row does not exist.
 69 |             return len(self._get_row_by_index(index=zero_based_row_index).find().find_elements(*locator))
 70 |         except NoSuchElementException:
 71 |             # return 0 if no element with locator is found.
 72 |             return 0
 73 | 
 74 |     def get_row_of_component_by_locator(self, element_locator: Tuple[By, str]) -> Optional[int]:
 75 |         """
 76 |         Obtain the row index of the row which contains the supplied locator.
 77 | 
 78 |         :param element_locator: The Tuple locator which describes an element located within the Column Container.
 79 | 
 80 |         :returns: The zero-based index of the row which contains the supplied locator, or None if no row contains the
 81 |             locator.
 82 |         """
 83 |         for row in self._rows.find_all():
 84 |             try:
 85 |                 if row.find_element(*element_locator) is not None:
 86 |                     return int(row.get_attribute("data-row-index"))
 87 |             except NoSuchElementException:
 88 |                 pass
 89 |         return None
 90 | 
 91 |     def _get_row_by_index(self, index: int) -> ComponentPiece:
 92 |         """
 93 |         Obtain a Component Piece which defines a singular row within the Column Container.
 94 | 
 95 |         :returns: A ComponentPiece which defines a singular row within the Column Container.
 96 |         """
 97 |         row = self._indexed_rows_dict.get(index)
 98 |         if not row:
 99 |             row = ComponentPiece(
100 |                 locator=(By.CSS_SELECTOR, f'{self._ROW_CONTAINER_LOCATOR[1]} div[data-row-index="{index}"]'),
101 |                 driver=self.driver,
102 |                 parent_locator_list=self.locator_list,
103 |                 wait_timeout=2,
104 |                 poll_freq=self.poll_freq)
105 |             self._indexed_rows_dict[index] = row
106 |         return row
107 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Containers/Coordinate.py:
--------------------------------------------------------------------------------
1 | from Components.BasicComponent import BasicPerspectiveComponent
2 | 
3 | 
4 | class Coordinate(BasicPerspectiveComponent):
5 |     pass
6 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Audio.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.common.exceptions import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | 
 7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 8 | 
 9 | 
10 | class Audio(BasicPerspectiveComponent):
11 |     """A Perspective Audio Component."""
12 |     _AUDIO_LOCATOR = (By.TAG_NAME, "audio")
13 | 
14 |     def __init__(
15 |             self,
16 |             locator: Tuple[By, str],
17 |             driver: WebDriver,
18 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         super().__init__(
22 |             locator=locator,
23 |             driver=driver,
24 |             parent_locator_list=parent_locator_list,
25 |             description=description,
26 |             poll_freq=poll_freq)
27 |         self._audio = ComponentPiece(
28 |             locator=self._AUDIO_LOCATOR,
29 |             driver=driver,
30 |             parent_locator_list=self.locator_list,
31 |             poll_freq=poll_freq)
32 | 
33 |     def get_source(self) -> str:
34 |         """
35 |         Obtain the path of the file currently in use by the Audio Component.
36 | 
37 |         :returns: The path of the file currently in use by the component, as a slash-delimited string.
38 | 
39 |         :raises TimeoutException: If unable to locate the internal <audio> element.
40 |         """
41 |         try:
42 |             return self._audio.find().get_attribute("src")
43 |         except TimeoutException as toe:
44 |             raise TimeoutException(msg="Unable to locate the inner <audio> piece of the Audio Component.") from toe
45 | 
46 |     def is_displayed(self) -> bool:
47 |         """
48 |         Determine if the Audio Component is currently displayed. The Audio Component has a complicated set of display
49 |         logic, and so even if the Audio Component is displayed, it may not be visible. Double-check expected states
50 |         by using the :func:`is_visible` function.
51 | 
52 |         :returns: True, if the component is currently displayed - False otherwise.
53 | 
54 |         :raises TimeoutException: If unable to locate the internal <audio> element.
55 |         """
56 |         try:
57 |             return self._audio.find().is_displayed()
58 |         except TimeoutException as toe:
59 |             raise TimeoutException(msg="Unable to locate the inner <audio> piece of the Audio Component.") from toe
60 | 
61 |     def is_visible(self) -> bool:
62 |         """
63 |         Determine if the Audio Component is currently visible. The Audio Component has a complicated set of display
64 |         logic, and so even if the Audio Component is visible, it may not be displayed. Double-check expected states
65 |         by using the :func:`is_displayed` function.
66 | 
67 |         :returns: True, if the component is currently visible - False otherwise.
68 | 
69 |         :raises TimeoutException: If unable to locate the Audio Component.
70 |         """
71 |         try:
72 |             return self.get_css_property(property_name="visibility") != "hidden"
73 |         except TimeoutException as toe:
74 |             raise TimeoutException(msg="Unable to locate the Audio Component as defined by its locator.") from toe
75 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Barcode.py:
--------------------------------------------------------------------------------
  1 | from typing import List, Optional, Tuple
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
  8 | 
  9 | 
 10 | class Barcode(BasicPerspectiveComponent):
 11 |     """A Perspective Barcode Component."""
 12 |     _INNER_WRAPPER_LOCATOR = (By.CSS_SELECTOR, 'div.barcode')
 13 |     _VALUE_LOCATOR = (By.CSS_SELECTOR, 'div.barcode-value')
 14 |     _CANVAS_LOCATOR = (By.CSS_SELECTOR, 'canvas')
 15 |     _ERROR_STATE_LOCATOR = (By.CSS_SELECTOR, 'div.barcode-error')
 16 | 
 17 |     def __init__(
 18 |             self,
 19 |             locator: Tuple[By, str],
 20 |             driver: WebDriver,
 21 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 22 |             wait_timeout: float = 2,
 23 |             description: Optional[str] = None,
 24 |             poll_freq: float = 0.5):
 25 |         super().__init__(
 26 |             locator=locator,
 27 |             driver=driver,
 28 |             parent_locator_list=parent_locator_list,
 29 |             wait_timeout=wait_timeout,
 30 |             description=description,
 31 |             poll_freq=poll_freq)
 32 |         self._barcode_value = ComponentPiece(
 33 |             locator=self._VALUE_LOCATOR,
 34 |             driver=driver,
 35 |             parent_locator_list=self.locator_list,
 36 |             poll_freq=poll_freq)
 37 |         self._barcode_wrapper = ComponentPiece(
 38 |             locator=self._INNER_WRAPPER_LOCATOR,
 39 |             driver=driver,
 40 |             parent_locator_list=self.locator_list,
 41 |             poll_freq=poll_freq)
 42 |         self._barcode_canvas = ComponentPiece(
 43 |             locator=self._CANVAS_LOCATOR,
 44 |             driver=driver,
 45 |             parent_locator_list=self.locator_list,
 46 |             poll_freq=poll_freq)
 47 |         self._barcode_error_state = ComponentPiece(
 48 |             locator=self._ERROR_STATE_LOCATOR,
 49 |             driver=driver,
 50 |             parent_locator_list=self.locator_list,
 51 |             poll_freq=poll_freq)
 52 | 
 53 |     def barcode_is_displaying_value(self) -> bool:
 54 |         """
 55 |         Determine if the Barcode Component is currently displaying a value.
 56 | 
 57 |         :returns: True, if the Barcode Component is currently displaying any value - False otherwise.
 58 |         """
 59 |         try:
 60 |             return self._barcode_value.find(wait_timeout=0) is not None
 61 |         except TimeoutException:
 62 |             return False
 63 | 
 64 |     def get_barcode_value(self) -> str:
 65 |         """
 66 |         Obtain the displayed text of the Barcode Component.
 67 | 
 68 |         :returns: The text currently displayed by the Barcode component.
 69 | 
 70 |         :raises TimeoutException: If no value is displayed.
 71 |         """
 72 |         try:
 73 |             return self._barcode_value.get_text()
 74 |         except TimeoutException as toe:
 75 |             raise TimeoutException(msg="Unable to locate the value container of the Barcode Component.") from toe
 76 | 
 77 |     def is_in_error_state(self) -> bool:
 78 |         """
 79 |         Determine if the Barcode Component is currently in an error state.
 80 | 
 81 |         :returns: True, if the Barcode Component is currently in an error state - False otherwise.
 82 |         """
 83 |         try:
 84 |             return self._barcode_error_state.find(wait_timeout=0) is not None
 85 |         except TimeoutException:
 86 |             return False
 87 | 
 88 |     def get_error_message(self) -> str:
 89 |         """
 90 |         Obtain the error message displayed in the Barcode Component.
 91 | 
 92 |         :returns: The displayed text of the error message currently displayed in the Barcode Component.
 93 |         """
 94 |         try:
 95 |             return self._barcode_error_state.get_text()
 96 |         except TimeoutException as toe:
 97 |             raise TimeoutException(msg="Unable to locate the error state of the Barcode Component.") from toe
 98 | 
 99 |     def value_displayed_below(self) -> bool:
100 |         """
101 |         Determine if the value of the Barcode Component is currently displayed below the canvas (visual barcode).
102 | 
103 |         :returns: True, if the text is below the barcode.
104 | 
105 |         :raises TimeoutException: If unable to locate the value or canvas.
106 |         """
107 |         try:
108 |             return self._barcode_value.get_origin().Y > self._barcode_canvas.get_origin().Y
109 |         except TimeoutException as toe:
110 |             raise TimeoutException(msg="Unable to locate either the value container or the barcode canvas.") from toe
111 | 
112 |     def get_barcode_as_data_url(self) -> str:
113 |         """
114 |         Obtain the shape of the Barcode as a string. Useful only for validating differences in values.
115 | 
116 |         :returns: A gibberish string which represents the shape of the displayed barcode as a string.
117 |         """
118 |         try:
119 |             return self.driver.execute_script('return arguments[0].toDataURL()', self._barcode_canvas.find())
120 |         except TimeoutException as toe:
121 |             raise TimeoutException(msg="Unable to locate the canvas of the barcode Component.") from toe
122 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/CylindricalTank.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple
 2 | 
 3 | from selenium.common.exceptions import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | 
 7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 8 | from Helpers.CSSEnumerations import CSS, CSSPropertyValue
 9 | 
10 | 
11 | class CylindricalTank(BasicPerspectiveComponent):
12 |     """A Perspective Cylindrical Tank Component."""
13 |     _TANK_LOCATOR = (By.CSS_SELECTOR, 'path.ia_cylindricalTankComponent__tank')
14 |     _LIQUID_LOCATOR = (By.CSS_SELECTOR, 'path.ia_cylindricalTankComponent__liquid')
15 |     _VALUE_DISPLAY_LOCATOR = (By.CSS_SELECTOR, 'text.ia_cylindricalTankComponent__valueDisplay')
16 |     _POTENTIAL_SYMBOLS_TO_OMIT_FROM_NUMERIC_VALUES = ["$", "%"]
17 | 
18 |     def __init__(
19 |             self,
20 |             locator: Tuple[By, str],
21 |             driver: WebDriver,
22 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
23 |             wait_timeout: float = 2,
24 |             description: Optional[str] = None,
25 |             poll_freq: float = 0.5):
26 |         super().__init__(
27 |             locator=locator,
28 |             driver=driver,
29 |             parent_locator_list=parent_locator_list,
30 |             wait_timeout=wait_timeout,
31 |             description=description,
32 |             poll_freq=poll_freq)
33 |         self._tank = ComponentPiece(locator=self._TANK_LOCATOR, driver=driver, wait_timeout=0, poll_freq=poll_freq)
34 |         self._tank_liquid = ComponentPiece(
35 |             locator=self._LIQUID_LOCATOR,
36 |             driver=driver,
37 |             wait_timeout=0,
38 |             poll_freq=poll_freq)
39 |         self._tank_value = ComponentPiece(
40 |             locator=self._VALUE_DISPLAY_LOCATOR,
41 |             driver=driver,
42 |             wait_timeout=0,
43 |             poll_freq=poll_freq)
44 | 
45 |     def get_liquid_property(self, property_name: CSSPropertyValue) -> str:
46 |         """
47 |         Obtain the value of some CSS property from the liquid within the Cylindrical Tank.
48 | 
49 |         :param property_name: The CSS property from which you would like the value.
50 | 
51 |         :returns: The value of the supplied CSS property as is in use by the liquid of the Cylindrical Tank.
52 | 
53 |         :raises TimeoutException: If the liquid of the Cylindrical Tank is not present.
54 |         """
55 |         try:
56 |             return self._tank_liquid.get_css_property(property_name=property_name)
57 |         except TimeoutException as toe:
58 |             raise TimeoutException(msg="Unable to locate the liquid of the Cylindrical Tank") from toe
59 | 
60 |     def get_tank_color(self) -> str:
61 |         """
62 |         Obtain the color in use for the actual tank portion of the Cylindrical Tank.
63 | 
64 |         :returns: The color in use for the container portion of the Cylindrical Tank as a string. Note that different
65 |             browsers may return this value in different formats (RGB vs hex).
66 | 
67 |         :raises TimeoutException: If the tank of the Cylindrical Tank is not present.
68 |         """
69 |         try:
70 |             return self._tank.get_css_property(property_name=CSS.FILL)
71 |         except TimeoutException as toe:
72 |             raise TimeoutException(msg="Unable to locate the tank portion of the Cylindrical Tank") from toe
73 | 
74 |     def get_text(self) -> str:
75 |         """
76 |         Obtain the displayed text of the Cylindrical Tank, including any displayed units.
77 | 
78 |         :returns: The displayed value and units of the Cylindrical Tank, as a string.
79 |         """
80 |         return self._tank_value.get_text()
81 | 
82 |     def value_is_displayed(self) -> bool:
83 |         """
84 |         Determine if the Cylindrical Tank is displaying a value and/or units.
85 | 
86 |         :returns True, if the Cylindrical Tank is currently displaying a value and/or units - False otherwise.
87 |         """
88 |         try:
89 |             return self._tank_value.find() is not None
90 |         except TimeoutException:
91 |             return False
92 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Icon.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent
 7 | from Components.PerspectiveComponents.Common.Icon import CommonIcon
 8 | 
 9 | 
10 | class Icon(BasicPerspectiveComponent, CommonIcon):
11 |     """A Perspective Icon component."""
12 | 
13 |     def __init__(
14 |             self,
15 |             locator: Tuple[By, str],
16 |             driver: WebDriver,
17 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
18 |             wait_timeout: float = 2,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         CommonIcon.__init__(
22 |             self,
23 |             locator=locator,
24 |             driver=driver,
25 |             parent_locator_list=parent_locator_list,
26 |             wait_timeout=wait_timeout,
27 |             description=description,
28 |             poll_freq=poll_freq)
29 |         BasicPerspectiveComponent.__init__(
30 |             self,
31 |             locator=locator,
32 |             driver=driver,
33 |             parent_locator_list=parent_locator_list,
34 |             wait_timeout=wait_timeout,
35 |             description=description,
36 |             poll_freq=poll_freq)
37 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Image.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple, Union
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 7 | from Helpers.CSSEnumerations import CSS, CSSPropertyValue
 8 | 
 9 | 
10 | class Image(BasicPerspectiveComponent):
11 |     """A Perspective Image Component."""
12 |     _INTERNAL_IMAGE_LOCATOR = (By.TAG_NAME, "img")
13 | 
14 |     def __init__(
15 |             self,
16 |             locator: Tuple[By, str],
17 |             driver: WebDriver,
18 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
19 |             wait_timeout: float = 5,
20 |             description: Optional[str] = None,
21 |             poll_freq: float = 0.5):
22 |         super().__init__(
23 |             locator=locator,
24 |             driver=driver,
25 |             parent_locator_list=parent_locator_list,
26 |             wait_timeout=wait_timeout,
27 |             description=description,
28 |             poll_freq=poll_freq)
29 |         self._internal_img = ComponentPiece(
30 |             locator=self._INTERNAL_IMAGE_LOCATOR,
31 |             parent_locator_list=self.locator_list,
32 |             driver=driver,
33 |             poll_freq=poll_freq)
34 | 
35 |     def get_source(self) -> str:
36 |         """
37 |         Obtain the source (src) in use by the Image Component. This function works unless the component has no applied
38 |         source. In that instance, Chrome and Firefox will return a blank String, whereas only Edge of all browsers will
39 |         return the correct expected value, which is the url of the current page.
40 | 
41 |         :returns: The source (src) of the <img> element.
42 |         """
43 |         return self._internal_img.find().get_attribute('src')
44 | 
45 |     def get_alt_text(self) -> str:
46 |         """
47 |         Obtain the Alt Text (alt) in use by the Image Component. This function will return an empty string ("") if no
48 |         alt text is configured to the Image component.
49 | 
50 |         :returns: The Alt Text (alt HTML attribute) of the <img> element.
51 |         """
52 |         return self._internal_img.find().get_attribute('alt')
53 | 
54 |     def get_css_property_value_of_internal_image(self, css_property: Union[CSSPropertyValue, str]) -> str:
55 |         """
56 |         Obtain the value of the specified CSS property for the internal image reference.
57 | 
58 |         :param css_property: Supply the name of the CSS property that will be obtained.
59 | 
60 |         :returns: The style property value of the <img> element.
61 |         """
62 |         return self._internal_img.get_css_property(property_name=css_property)
63 | 
64 |     def get_height_of_internal_image(self, include_units: bool = False) -> str:
65 |         """
66 |         Obtain the height value of the internal image (<img> element).
67 | 
68 |         :param include_units: If set to True, the units of the height value will be supplied to the value. Otherwise,
69 |             only the numeric value will be given.
70 | 
71 |         :returns: The height value of the internal image (<img> element).
72 |         """
73 |         return self._internal_img.get_computed_height(include_units=include_units)
74 | 
75 |     def get_width_of_internal_image(self, include_units: bool = False) -> str:
76 |         """
77 |         Obtain the width value of the internal image (<img> element).
78 | 
79 |         :param include_units: If set to True, the units of the width value will be supplied to the value. Otherwise,
80 |             only the numeric value will be given.
81 | 
82 |         :returns: The width value of the internal image (<img> element).
83 |         """
84 |         return self._internal_img.get_computed_width(include_units=include_units)
85 | 
86 |     def is_scroll_enabled(self) -> bool:
87 |         """
88 |         Obtain the value of the scroll property in the Image component. The Image component's overflow value
89 |         determines if scroll is enabled or not. When overflow is set to auto, scrolling is enabled. Otherwise, the
90 |         value of overflow is set to hidden.
91 | 
92 |         :returns: A value of True when overflow is set to "auto"; False otherwise.
93 |         """
94 |         return self.get_css_property(property_name=CSS.OVERFLOW) == 'auto'
95 | 
96 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/InlineFrame.py:
--------------------------------------------------------------------------------
 1 | from typing import Tuple, Optional, List
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 7 | 
 8 | 
 9 | class InlineFrame(BasicPerspectiveComponent):
10 |     """A Perspective Inline Frame (iframe) Component"""
11 |     _IFRAME_LOCATOR = (By.TAG_NAME, "iframe")
12 | 
13 |     def __init__(
14 |             self,
15 |             locator: Tuple[By, str],
16 |             driver: WebDriver,
17 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
18 |             wait_timeout: float = 2,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         super().__init__(
22 |             locator=locator,
23 |             driver=driver,
24 |             parent_locator_list=parent_locator_list,
25 |             wait_timeout=wait_timeout,
26 |             description=description,
27 |             poll_freq=poll_freq)
28 |         self._iframe = ComponentPiece(locator=self._IFRAME_LOCATOR, driver=driver, poll_freq=poll_freq)
29 | 
30 |     def get_source(self) -> str:
31 |         """
32 |         Obtain the source in use by the Inline Frame component. The source is essentially the URl of the website
33 |         embedded into the iframe.
34 | 
35 |         :returns: The URl of the website embedded into the Inline Frame Component.
36 |         """
37 |         return self._iframe.find().get_attribute('src')
38 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Label.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent
 7 | 
 8 | 
 9 | class Label(BasicPerspectiveComponent):
10 |     """A Perspective Label Component."""
11 | 
12 |     def __init__(
13 |             self,
14 |             locator: Tuple[By, str],
15 |             driver: WebDriver,
16 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
17 |             wait_timeout: float = 2,
18 |             description: Optional[str] = None,
19 |             poll_freq: float = 0.5):
20 |         super().__init__(
21 |             locator=locator,
22 |             driver=driver,
23 |             parent_locator_list=parent_locator_list,
24 |             wait_timeout=wait_timeout,
25 |             description=description,
26 |             poll_freq=poll_freq)
27 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/LinearScale.py:
--------------------------------------------------------------------------------
 1 | from typing import Tuple, Optional, List
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 7 | 
 8 | 
 9 | class LinearScale(BasicPerspectiveComponent):
10 |     """A Perspective Linear Scale Component."""
11 |     _TRANSFORM_ELEMENT_LOCATOR = (By.CSS_SELECTOR, 'svg > g')
12 | 
13 |     def __init__(
14 |             self,
15 |             locator: Tuple[By, str],
16 |             driver: WebDriver,
17 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
18 |             wait_timeout: float = 5,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         super().__init__(
22 |             locator=locator,
23 |             driver=driver,
24 |             parent_locator_list=parent_locator_list,
25 |             wait_timeout=wait_timeout,
26 |             description=description,
27 |             poll_freq=poll_freq
28 |         )
29 |         self._transform_element = ComponentPiece(
30 |             locator=self._TRANSFORM_ELEMENT_LOCATOR,
31 |             driver=driver,
32 |             parent_locator_list=self.locator_list,
33 |             wait_timeout=1,
34 |             poll_freq=poll_freq)
35 | 
36 |     def is_horizontal(self) -> bool:
37 |         """
38 |         Determine if the Linear Scale is currently in a horizontal layout.
39 | 
40 |         :returns: True, if the Linear Scale is currently rendering in a horizontal manner - False otherwise.
41 |         """
42 |         return 'rotate(90)' in self._transform_element.find().get_attribute('transform')
43 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Markdown.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 7 | 
 8 | 
 9 | class Markdown(BasicPerspectiveComponent):
10 |     _TEXT_CONTAINER_LOCATOR = (By.TAG_NAME, "p")
11 | 
12 |     def __init__(
13 |             self,
14 |             locator: Tuple[By, str],
15 |             driver: WebDriver,
16 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
17 |             wait_timeout: float = 2,
18 |             description: Optional[str] = None,
19 |             poll_freq: float = 0.5):
20 |         super().__init__(
21 |             locator=locator,
22 |             driver=driver,
23 |             parent_locator_list=parent_locator_list,
24 |             wait_timeout=wait_timeout,
25 |             description=description,
26 |             poll_freq=poll_freq)
27 |         self._text_container = ComponentPiece(
28 |             locator=self._TEXT_CONTAINER_LOCATOR,
29 |             driver=driver,
30 |             parent_locator_list=self.locator_list,
31 |             poll_freq=poll_freq)
32 | 
33 |     def get_text(self) -> str:
34 |         """
35 |         Obtain the text of the Markdown Component.
36 | 
37 |         :returns: The text of the Markdown Component.
38 |         """
39 |         return self._text_container.get_text()
40 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Progress.py:
--------------------------------------------------------------------------------
  1 | from enum import Enum
  2 | from typing import Optional, List, Tuple
  3 | 
  4 | from selenium.common.exceptions import TimeoutException
  5 | from selenium.webdriver.common.by import By
  6 | from selenium.webdriver.remote.webdriver import WebDriver
  7 | 
  8 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
  9 | from Helpers.CSSEnumerations import CSS
 10 | 
 11 | 
 12 | class Mode(Enum):
 13 |     """The modes available to the Progress Component."""
 14 |     DETERMINATE = "determinate"
 15 |     INDETERMINATE = "indeterminate"
 16 | 
 17 | 
 18 | class Progress(BasicPerspectiveComponent):
 19 |     """A Perspective Progress Component."""
 20 |     _TRACK_CLASS = 'ia_progressBar__track'
 21 |     _DETERMINATE_CLASS = f'{_TRACK_CLASS}--determinate'
 22 |     _INDETERMINATE_CLASS = f'{_TRACK_CLASS}--indeterminate'
 23 |     _VALUE_DISPLAY_LOCATOR = (By.CSS_SELECTOR, "span.ia_progressBar__displayValue")
 24 |     _BAR_LOCATOR = (By.CSS_SELECTOR, "div.ia_progressBar__bar")
 25 | 
 26 |     def __init__(
 27 |             self,
 28 |             locator: Tuple[By, str],
 29 |             driver: WebDriver,
 30 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 31 |             wait_timeout: float = 2,
 32 |             description: Optional[str] = None,
 33 |             poll_freq: float = 0.5):
 34 |         super().__init__(
 35 |             locator=locator,
 36 |             driver=driver,
 37 |             parent_locator_list=parent_locator_list,
 38 |             wait_timeout=wait_timeout,
 39 |             description=description,
 40 |             poll_freq=poll_freq)
 41 |         self._track = ComponentPiece(
 42 |             locator=(By.CSS_SELECTOR, "div"), driver=driver, parent_locator_list=self.locator_list)
 43 |         self._bar = ComponentPiece(
 44 |             locator=self._BAR_LOCATOR, driver=driver, parent_locator_list=self._track.locator_list)
 45 |         self._value_display = ComponentPiece(
 46 |             locator=self._VALUE_DISPLAY_LOCATOR,
 47 |             driver=driver,
 48 |             parent_locator_list=self.locator_list,
 49 |             poll_freq=poll_freq)
 50 | 
 51 |     def get_bar_color(self) -> str:
 52 |         """
 53 |         Obtain the color of the bar piece of the Progress Component.
 54 | 
 55 |         :returns: The color of the bar of the Progress Component, as a string. Note that different browsers may return
 56 |             this color in different formats (RGB vs hex).
 57 |         """
 58 |         return self._bar.get_css_property(property_name=CSS.BACKGROUND_COLOR)
 59 | 
 60 |     def get_displayed_percentage(self) -> float:
 61 |         """
 62 |         Obtain the current visual percentage of the Progress Component. This is not a check against the Label, but is an
 63 |         actual calculation of the volume of the bar of the Progress Component.
 64 | 
 65 |         :returns: The visual percentage of the Progress Component, as a user would see it.
 66 |         """
 67 |         progress_origin_x = float(self.get_origin().X)
 68 |         progress_width = float(self.get_computed_width())
 69 |         return ((float(self._bar.get_termination().X) - progress_origin_x) * 100) / progress_width
 70 | 
 71 |     def get_max(self) -> float:
 72 |         """
 73 |         Obtain the current maximum value the Progress Component may display.
 74 | 
 75 |         :returns: The 'max' attribute of the Progress Bar.
 76 |         """
 77 |         return float(self._track.find().get_attribute('data-max'))
 78 | 
 79 |     def get_min(self):
 80 |         """
 81 |         Obtain the current minimum value the Progress Component may display.
 82 | 
 83 |         :returns: The 'min' attribute of the Progress Bar.
 84 |         """
 85 |         return float(self._track.find().get_attribute('data-min'))
 86 | 
 87 |     def get_text(self) -> Optional[str]:
 88 |         """
 89 |         Obtain the displayed label text of the Progress Component.
 90 | 
 91 |         :returns: The text of the label for the Progress Component, or None if the component is not configured to
 92 |             display a value.
 93 |         """
 94 |         try:
 95 |             return self._value_display.get_text()
 96 |         except TimeoutException:
 97 |             return None
 98 | 
 99 |     def get_track_color(self) -> str:
100 |         """
101 |         Obtain the color of the track piece of the Progress Component.
102 | 
103 |         :returns: The color of the track of the Progress Component, as a string. Note that different browsers may return
104 |             this color in different formats (RGB vs hex).
105 |         """
106 |         return self._track.get_css_property(property_name=CSS.BACKGROUND_COLOR)
107 | 
108 |     def get_value(self) -> float:
109 |         """
110 |         Obtain the value of the Progress Component.
111 | 
112 |         :returns: The 'value' attribute of the Progress Bar.
113 |         """
114 |         return float(self._track.find().get_attribute('data-value'))
115 | 
116 |     def is_indeterminate_progress_bar(self) -> bool:
117 |         """
118 |         Determine if the Progress Component is currently displaying as indeterminate.
119 | 
120 |         :returns: True if the Progress Bar is in "indeterminate" mode, False otherwise.
121 |         """
122 |         variant = self._track.find().get_attribute('data-variant')
123 |         return variant is not None and variant == Mode.INDETERMINATE.value
124 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/TagBrowseTree.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent
 7 | from Components.PerspectiveComponents.Common.TagBrowseTree import CommonTagBrowseTree
 8 | 
 9 | 
10 | class TagBrowseTree(CommonTagBrowseTree, BasicPerspectiveComponent):
11 |     """A Perspective Tag Browse Tree Component."""
12 | 
13 |     def __init__(
14 |             self,
15 |             locator: Tuple[By, str],
16 |             driver: WebDriver,
17 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
18 |             wait_timeout: float = 3,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         CommonTagBrowseTree.__init__(
22 |             self,
23 |             locator=locator,
24 |             driver=driver,
25 |             parent_locator_list=parent_locator_list,
26 |             description=description,
27 |             poll_freq=poll_freq)
28 |         BasicPerspectiveComponent.__init__(
29 |             self,
30 |             locator=locator,
31 |             driver=driver,
32 |             parent_locator_list=parent_locator_list,
33 |             wait_timeout=wait_timeout,
34 |             poll_freq=poll_freq)
35 | 
36 |     def multi_select_tags(self, tag_name_list: [str], inclusive_multi_selection: bool, wait_timeout: int = 5) -> None:
37 |         """
38 |         Select multiple tags within the Tag Browse Tree.
39 | 
40 |         :param tag_name_list: A list of tag names to be selected. If multiple tags with the same name are visible, only
41 |             the first of each such tag will be selected.
42 |         :param inclusive_multi_selection: A True value specifies that all tags between the supplied tags should also be
43 |             selected, and so SHIFT will be held. A False value specifies that ONLY the supplied tags should be selected,
44 |             and so CONTROL will be held.
45 |         :param wait_timeout: The amount of time to wait (in seconds) for each tag to become visible.
46 | 
47 |         :raises TimeoutException: If any of the supplied tags did not exist.
48 |         """
49 |         self.multi_select_items(
50 |             item_labels=tag_name_list, inclusive_multi_selection=inclusive_multi_selection, wait_timeout=wait_timeout)
51 | 
52 |     def select_tag_from_tree(self, tag_name: str, wait_timeout: int = 5) -> None:
53 |         """
54 |         Select a tag from the Tag Browse Tree.
55 | 
56 |         :param tag_name: The name of the tag to select. If multiple tags with the same name are displayed, the first
57 |             tag with this name will be selected.
58 |         :param wait_timeout: The amount of time (in seconds) to wait for the supplied tag to appear.
59 | 
60 |         :raises TimeoutException: If no such tag exists.
61 |         """
62 |         self.select_item_in_tree(item_label=tag_name, wait_timeout=wait_timeout)
63 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Displays/Tree.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.common.exceptions import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | 
 7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 8 | from Components.PerspectiveComponents.Common.Tree import CommonTree
 9 | from Helpers.IASelenium import IASelenium
10 | 
11 | 
12 | class Tree(CommonTree, BasicPerspectiveComponent):
13 |     """A Perspective Tree Component."""
14 | 
15 |     def __init__(
16 |             self,
17 |             locator: Tuple[By, str],
18 |             driver: WebDriver,
19 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
20 |             wait_timeout: float = 3,
21 |             description: Optional[str] = None,
22 |             poll_freq: float = 0.5):
23 |         CommonTree.__init__(
24 |             self,
25 |             locator=locator,
26 |             driver=driver,
27 |             parent_locator_list=parent_locator_list,
28 |             wait_timeout=wait_timeout,
29 |             description=description,
30 |             poll_freq=poll_freq)
31 |         BasicPerspectiveComponent.__init__(
32 |             self,
33 |             locator=locator,
34 |             driver=driver,
35 |             parent_locator_list=parent_locator_list,
36 |             wait_timeout=wait_timeout,
37 |             description=description,
38 |             poll_freq=poll_freq)
39 |         self._items_by_path = {}
40 | 
41 |     def item_exists_in_tree(self, item_path: str, item_label: str, wait_timeout: int = 2) -> bool:
42 |         """
43 |         Determine if an item exists in the Tree.
44 | 
45 |         :param item_path: The zero-indexed path of the item. A value of 0/0/1 translates to 'The 1th grandchild of the
46 |             0th child of the 0th top-level node.'
47 |         :param item_label: The label text of the item to verify the presence of.
48 |         :param wait_timeout: The amount of time (in seconds) to wait for the item with the supplied path to appear.
49 | 
50 |         :returns: True, if an item with the supplied text exists at the specified location - False otherwise.
51 |         """
52 |         try:
53 |             return self._get_item_by_path(
54 |                 path=item_path, wait_timeout=wait_timeout).get_text() == item_label
55 |         except TimeoutException:
56 |             return False
57 | 
58 |     def right_click(self, **kwargs) -> None:
59 |         """
60 |         Right-click the Tree. As individual items do not allow for their own events, this click will always target the
61 |         0th top-level item (if one exists).
62 |         """
63 |         try:
64 |             IASelenium(driver=self.driver).right_click(
65 |                 web_element=self._get_item_by_path(path="0", wait_timeout=1).find())
66 |         except TimeoutException:
67 |             super().right_click()
68 | 
69 |     def _get_item_by_path(self, path: str, wait_timeout: int = 2) -> ComponentPiece:
70 |         """Obtain a specific item based on its zero-indexed path."""
71 |         item_component = self._items_by_path.get(path)
72 |         if not item_component:
73 |             item_component = ComponentPiece(
74 |                 locator=(By.CSS_SELECTOR, f'div[data-item-path="{path}"]'),
75 |                 driver=self.driver,
76 |                 parent_locator_list=self.locator_list,
77 |                 wait_timeout=wait_timeout,
78 |                 poll_freq=self.poll_freq)
79 |             self._items_by_path[path] = item_component
80 |         return item_component
81 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Embedding/EmbeddedView.py:
--------------------------------------------------------------------------------
  1 | from typing import Tuple, List, Optional
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
  8 | from Helpers.CSSEnumerations import CSS
  9 | 
 10 | 
 11 | class EmbeddedView(BasicPerspectiveComponent):
 12 |     """A Perspective Embedded View Component."""
 13 |     _PRIMARY_MESSAGE_LOCATOR = (By.CSS_SELECTOR, 'div.message-primary')
 14 |     _SECONDARY_MESSAGE_LOCATOR = (By.CSS_SELECTOR, 'div.message-secondary')
 15 |     _STATE_DISPLAY_LOCATOR = (By.CSS_SELECTOR, "div.view-state-display")
 16 | 
 17 |     def __init__(
 18 |             self,
 19 |             locator: Tuple[By, str],
 20 |             driver: WebDriver,
 21 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 22 |             wait_timeout: float = 2,
 23 |             description: Optional[str] = None,
 24 |             poll_freq: float = 0.5):
 25 |         super().__init__(
 26 |             locator=locator,
 27 |             driver=driver,
 28 |             parent_locator_list=parent_locator_list,
 29 |             wait_timeout=wait_timeout,
 30 |             description=description,
 31 |             poll_freq=poll_freq)
 32 |         self._primary_message = ComponentPiece(
 33 |             locator=self._PRIMARY_MESSAGE_LOCATOR,
 34 |             driver=driver,
 35 |             parent_locator_list=self.locator_list,
 36 |             wait_timeout=1,
 37 |             poll_freq=poll_freq)
 38 |         self._secondary_message = ComponentPiece(
 39 |             locator=self._SECONDARY_MESSAGE_LOCATOR,
 40 |             driver=driver,
 41 |             parent_locator_list=self.locator_list,
 42 |             wait_timeout=1,
 43 |             poll_freq=poll_freq)
 44 |         self._state_display = ComponentPiece(
 45 |             locator=self._STATE_DISPLAY_LOCATOR,
 46 |             driver=driver,
 47 |             parent_locator_list=self.locator_list,
 48 |             wait_timeout=1,
 49 |             poll_freq=poll_freq)
 50 | 
 51 |     def get_primary_message(self) -> str:
 52 |         """
 53 |         Obtain the primary message of the Embedded View. This is the message seen when a View is not properly
 54 |         configured.
 55 | 
 56 |         :raises TimeoutException: If a View is properly configured - and therefore not displaying a config error message
 57 |             - or the Embedded View is not found.
 58 |         """
 59 |         return self._primary_message.get_text()
 60 | 
 61 |     def get_secondary_message(self) -> str:
 62 |         """
 63 |         Obtain the secondary message of the Embedded View. This is the message seen when a View is not properly
 64 |         configured.
 65 | 
 66 |         :raises TimeoutException: If a View is properly configured - and therefore not displaying a config error message
 67 |             - or the Embedded View is not found.
 68 |         """
 69 |         return self._secondary_message.get_text()
 70 | 
 71 |     def get_state_display_background(self) -> str:
 72 |         """
 73 |         Obtain the background color of the Embedded View. Usually only useful when a View is not properly configured.
 74 |         """
 75 |         return self._state_display.get_css_property(property_name=CSS.BACKGROUND_COLOR)
 76 | 
 77 |     def view_path_is_invalid(self) -> bool:
 78 |         """
 79 |         Determine if the currently applied View path is INVALID.
 80 | 
 81 |         :returns: True, if the currently applied View path is invalid - False if the currently applied View path is
 82 |             valid.
 83 |         """
 84 |         try:
 85 |             self._primary_message.find()
 86 |             self._secondary_message.find()
 87 |             return True
 88 |         except TimeoutException:
 89 |             return False
 90 | 
 91 |     def view_path_is_blank(self) -> bool:
 92 |         """
 93 |         Determine if the currently applied View path is an empty string. This function is non-conclusive, as it only
 94 |         verifies the Embedded View contains no text. There is still a possibility that the embedded View could be valid
 95 |         and rendered, but contain no text.
 96 | 
 97 |         :returns: True, if the Embedded View contains no text content - False otherwise.
 98 |         """
 99 |         return self.get_text() == ''
100 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Embedding/FlexRepeater.py:
--------------------------------------------------------------------------------
 1 | from typing import Tuple, List, Optional
 2 | 
 3 | from selenium.common.exceptions import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | 
 7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 8 | 
 9 | 
10 | class FlexRepeater(BasicPerspectiveComponent):
11 |     """
12 |     A Perspective Flex Repeater Component.
13 |     """
14 |     _DIRECT_CHILD_LOCATOR = (By.CSS_SELECTOR, '>div')
15 | 
16 |     def __init__(
17 |             self,
18 |             locator: Tuple[By, str],
19 |             driver: WebDriver,
20 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
21 |             description: Optional[str] = None,
22 |             poll_freq: float = 0.5):
23 |         super().__init__(
24 |             locator=locator,
25 |             driver=driver,
26 |             parent_locator_list=parent_locator_list,
27 |             description=description,
28 |             poll_freq=poll_freq)
29 |         self._children = ComponentPiece(
30 |             locator=self._DIRECT_CHILD_LOCATOR, driver=driver, parent_locator_list=self.locator_list)
31 | 
32 |     def get_count_of_instances(self) -> int:
33 |         """Obtain a count of instances within the Flex Repeater."""
34 |         try:
35 |             return len(self._children.find_all())
36 |         except TimeoutException:
37 |             return 0
38 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Embedding/ViewCanvas.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple
 2 | 
 3 | from selenium.common.exceptions import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | 
 7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 8 | from Helpers.CSSEnumerations import CSS
 9 | 
10 | 
11 | class ViewCanvas(BasicPerspectiveComponent):
12 |     """
13 |     A Perspective View Canvas Component.
14 | 
15 |     Functions for this class only provide insight into the View Canvas, and not the Views instanced by the View Canvas.
16 |     """
17 |     _CHILD_VIEW_LOCATOR = (By.CSS_SELECTOR, "> div")
18 | 
19 |     def __init__(
20 |             self,
21 |             locator: Tuple[By, str],
22 |             driver: WebDriver,
23 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
24 |             wait_timeout: float = 5,
25 |             description: Optional[str] = None,
26 |             poll_freq: float = 0.5):
27 |         super().__init__(
28 |             locator=locator,
29 |             driver=driver,
30 |             parent_locator_list=parent_locator_list,
31 |             wait_timeout=wait_timeout,
32 |             description=description,
33 |             poll_freq=poll_freq)
34 |         self._children = ComponentPiece(
35 |             locator=self._CHILD_VIEW_LOCATOR,
36 |             driver=driver,
37 |             parent_locator_list=self.locator_list,
38 |             wait_timeout=1,
39 |             poll_freq=poll_freq)
40 | 
41 |     def get_count_of_instanced_views(self) -> int:
42 |         """
43 |         Obtain a count of the Views instanced by this View Canvas.
44 |         """
45 |         try:
46 |             return len(self._children.find_all())
47 |         except TimeoutException:
48 |             return 0
49 | 
50 |     def get_transition_duration(self) -> str:
51 |         """
52 |         Obtain the transition duration for the View Canvas.
53 | 
54 |         :raises TimeoutException: If no Views are currently instanced by this View Canvas.
55 |         """
56 |         return self._children.get_css_property(property_name=CSS.TRANSITION_DURATION)
57 | 
58 |     def get_transition_timing_function(self) -> str:
59 |         """
60 |         Obtain the transition timing function for the View Canvas.
61 | 
62 |         :raises TimeoutException: If no Views are currently instanced by this View Canvas.
63 |         """
64 |         return self._children.get_css_property(property_name=CSS.TRANSITION_TIMING_FUNCTION)
65 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/BarcodeScanner.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.common.exceptions import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | 
 7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 8 | 
 9 | 
10 | class BarcodeScanner(BasicPerspectiveComponent):
11 |     """A Perspective Barcode Scanner Component."""
12 |     _LABEL_LOCATOR = (By.CSS_SELECTOR, 'li')
13 | 
14 |     def __init__(
15 |             self,
16 |             locator: Tuple[By, str],
17 |             driver: WebDriver,
18 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
19 |             wait_timeout: float = 2,
20 |             description: Optional[str] = None,
21 |             poll_freq: float = 0.5):
22 |         super().__init__(
23 |             locator=locator,
24 |             driver=driver,
25 |             parent_locator_list=parent_locator_list,
26 |             wait_timeout=wait_timeout,
27 |             description=description,
28 |             poll_freq=poll_freq)
29 |         self._label = ComponentPiece(locator=self._LABEL_LOCATOR, driver=driver, wait_timeout=1, poll_freq=poll_freq)
30 | 
31 |     def is_displaying_value(self) -> bool:
32 |         """
33 |         Determine if the component is displaying any value.
34 | 
35 |         :returns: True, if any text content is displayed by the component - False otherwise.
36 |         """
37 |         try:
38 |             return self._label.find().is_displayed() and (len(self._label.get_text()) > 0)
39 |         except TimeoutException:
40 |             return False
41 | 
42 |     def get_text(self, **kwargs) -> Optional[str]:
43 |         """
44 |         Retrieve text content that is displaying in the component.
45 | 
46 |         :returns: The text content that is displayed by the component. If no text is displayed by the component, it
47 |             will return a 'None'.
48 |         """
49 |         try:
50 |             return self._label.get_text()
51 |         except TimeoutException:
52 |             return None
53 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/Button.py:
--------------------------------------------------------------------------------
 1 | from typing import Tuple, List, Optional
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent
 7 | from Components.Common.Button import CommonButton
 8 | 
 9 | 
10 | class Button(CommonButton, BasicPerspectiveComponent):
11 |     """A Perspective Button Component."""
12 | 
13 |     def __init__(
14 |             self,
15 |             locator: Tuple[By, str],
16 |             driver: WebDriver,
17 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
18 |             wait_timeout: float = 3,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         CommonButton.__init__(
22 |             self,
23 |             locator=locator,
24 |             driver=driver,
25 |             parent_locator_list=parent_locator_list,
26 |             wait_timeout=wait_timeout,
27 |             description=description,
28 |             poll_freq=poll_freq)
29 |         BasicPerspectiveComponent.__init__(
30 |             self,
31 |             locator=locator,
32 |             driver=driver,
33 |             parent_locator_list=parent_locator_list,
34 |             wait_timeout=wait_timeout,
35 |             description=description,
36 |             poll_freq=poll_freq)
37 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/Checkbox.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent
 7 | from Components.PerspectiveComponents.Common.Checkbox import CommonCheckbox
 8 | 
 9 | 
10 | class Checkbox(CommonCheckbox, BasicPerspectiveComponent):
11 |     """A Perspective Checkbox Component."""
12 | 
13 |     def __init__(
14 |             self,
15 |             locator: Tuple[By, str],
16 |             driver: WebDriver,
17 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
18 |             wait_timeout: float = 3,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         CommonCheckbox.__init__(
22 |             self, locator=locator,
23 |             driver=driver,
24 |             parent_locator_list=parent_locator_list,
25 |             wait_timeout=wait_timeout,
26 |             description=description,
27 |             poll_freq=poll_freq)
28 |         BasicPerspectiveComponent.__init__(
29 |             self, locator=locator,
30 |             driver=driver,
31 |             parent_locator_list=parent_locator_list,
32 |             wait_timeout=wait_timeout,
33 |             description=description,
34 |             poll_freq=poll_freq)
35 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/MultiStateButton.py:
--------------------------------------------------------------------------------
  1 | from typing import List, Optional, Union, Tuple
  2 | 
  3 | from selenium.webdriver.common.by import By
  4 | from selenium.webdriver.remote.webdriver import WebDriver
  5 | from selenium.webdriver.support.color import Color
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
  8 | from Components.Common.Button import CommonButton
  9 | from Helpers.CSSEnumerations import CSSPropertyValue, CSS
 10 | from Helpers.IAAssert import IAAssert
 11 | 
 12 | 
 13 | class MultiStateButton(BasicPerspectiveComponent):
 14 |     """A Perspective Multi-State Button Component."""
 15 |     _GENERAL_BUTTON_LOCATOR = (By.TAG_NAME, "button")
 16 |     _DEFAULT_INACTIVE_BACKGROUND_COLOR = '#FAFAFA'
 17 | 
 18 |     def __init__(
 19 |             self,
 20 |             locator: Tuple[By, str],
 21 |             driver: WebDriver,
 22 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 23 |             wait_timeout: float = 3,
 24 |             description: Optional[str] = None,
 25 |             poll_freq: float = 0.5):
 26 |         super().__init__(
 27 |             locator=locator,
 28 |             driver=driver,
 29 |             parent_locator_list=parent_locator_list,
 30 |             wait_timeout=wait_timeout,
 31 |             description=description,
 32 |             poll_freq=poll_freq)
 33 |         self._generic_button = ComponentPiece(
 34 |             locator=self._GENERAL_BUTTON_LOCATOR,
 35 |             driver=driver,
 36 |             parent_locator_list=self.locator_list,
 37 |             poll_freq=poll_freq)
 38 |         self._buttons = {}
 39 | 
 40 |     def click(self, **kwargs) -> None:
 41 |         """
 42 |         Multi-State Buttons should not be blindly clicked because the 0th button would always receive the click.
 43 | 
 44 |         :raises NotImplementedError:
 45 |         """
 46 |         raise NotImplementedError
 47 | 
 48 |     def click_button_by_text(self, button_text: str, wait_timeout: float = 0.5, binding_wait_time: float = 0.5) -> None:
 49 |         """
 50 |         Click one of the Multi-State Buttons by text. If multiple buttons share the same text only the first match will
 51 |         be clicked.
 52 | 
 53 |         :param button_text: The text of the button you would like to click.
 54 |         :param wait_timeout: The amount of time to wait until a button with the specified text becomes visible.
 55 |         :param binding_wait_time: The amount of time after the click event to wait before allowing code to continue.
 56 | 
 57 |         :raises TimeoutException: If no button with the specified text is found.
 58 |         """
 59 |         self._get_button_by_text(button_text=button_text).click(
 60 |             wait_timeout=wait_timeout, binding_wait_time=binding_wait_time)
 61 | 
 62 |     def get_css_property_value_of_button_by_text(
 63 |             self,
 64 |             button_text: str,
 65 |             property_name: Union[CSSPropertyValue, str]) -> str:
 66 |         """
 67 |         Obtain the value of a CSS property for a button of the Multi-State Button based on the text of the button.
 68 | 
 69 |         :param button_text: The text of the button from which you would like a CSS property value
 70 |         :param property_name: The CSS property value you would like to obtain.
 71 | 
 72 |         :raises TimeoutException: If no button with the specified text is found.
 73 |         """
 74 |         return self._get_button_by_text(button_text=button_text).get_css_property(property_name=property_name)
 75 | 
 76 |     def get_button_count(self, wait_timeout: float = 0.5) -> int:
 77 |         """Obtain a count of all states contained within this Multi-State Button."""
 78 |         return len(self._generic_button.find_all(wait_timeout=wait_timeout))
 79 | 
 80 |     def get_button_gap(self) -> float:
 81 |         """Obtain the current gap between each button."""
 82 |         return float(self._generic_button.get_css_property(
 83 |             property_name=CSS.MARGIN_BOTTOM if self.is_column_oriented() else CSS.MARGIN_RIGHT).split("px")[0])
 84 | 
 85 |     def get_current_indicator_button_text(self) -> Optional[str]:
 86 |         """
 87 |         Get the text of the button which is currently displaying as selected/active. This function assumes that all
 88 |         buttons in the Multi-State Button are using their default appearance. If any button is NOT using the default
 89 |         appearance, it is possible that button text would be erroneously returned.
 90 |         """
 91 |         for button in self._generic_button.find_all():
 92 |             try:
 93 |                 IAAssert.is_equal_to(
 94 |                     actual_value=button.value_of_css_property(
 95 |                         CSS.BACKGROUND_COLOR.value),
 96 |                     expected_value=self._DEFAULT_INACTIVE_BACKGROUND_COLOR,
 97 |                     failure_msg="Button does not have default background color, so it must be selected.",
 98 |                     as_type=Color)
 99 |             except AssertionError:
100 |                 return button.text
101 |         return None
102 | 
103 |     def hover_over_button_by_text(self, button_text: str) -> None:
104 |         """
105 |         Hover over the button of the Multi-State Button which has the supplied text.
106 | 
107 |         :raises TimeoutException: If no button matches the supplied text.
108 |         """
109 |         self._get_button_by_text(button_text=button_text).hover()
110 | 
111 |     def is_column_oriented(self) -> bool:
112 |         """
113 |         Determine if the Multi-State Button is rendered in a column layout, as opposed to a row.
114 | 
115 |         :returns: True if the Multi-State Button is rendered as a column.
116 |         """
117 |         return self._generic_button.find().get_attribute(name="data-button-orientation") == "column"
118 | 
119 |     def _get_button_by_text(self, button_text: str) -> CommonButton:
120 |         """Obtain the underlying CommonButton component from the Multi-State Button based on its text."""
121 |         button = self._buttons.get(button_text)
122 |         if not button:
123 |             button = CommonButton(
124 |                 locator=(By.CSS_SELECTOR, f'{self._GENERAL_BUTTON_LOCATOR[1]}[data-label="{button_text}"]'),
125 |                 driver=self.driver,
126 |                 parent_locator_list=self.locator_list,
127 |                 poll_freq=self.poll_freq)
128 |             self._buttons[button_text] = button
129 |         return button
130 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/OneShotButton.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Tuple
 2 | 
 3 | from selenium.common.exceptions import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | 
 7 | from Components.BasicComponent import ComponentPiece
 8 | from Components.PerspectiveComponents.Common.ComponentModal import ComponentModal
 9 | from Components.PerspectiveComponents.Common.Icon import CommonIcon
10 | from Components.PerspectiveComponents.Inputs.Button import Button
11 | 
12 | 
13 | class OneShotButton(Button):
14 |     """A Perspective One-Shot Button Component"""
15 |     _CANCEL_BUTTON_LOCATOR = (By.CSS_SELECTOR, 'button[data-button-type="cancel"]')
16 |     _CONFIRM_BUTTON_LOCATOR = (By.CSS_SELECTOR, 'button[data-button-type="confirm"]')
17 |     _MODAL_MESSAGE_LOCATOR = (By.CSS_SELECTOR, "div.ia_oneShotButtonComponent__confirmModal__message")
18 |     _ICON_LOCATOR = (By.TAG_NAME, "svg")
19 | 
20 |     def __init__(
21 |             self,
22 |             locator: Tuple[By, str],
23 |             driver: WebDriver,
24 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
25 |             wait_timeout: float = 3,
26 |             description: Optional[str] = None,
27 |             poll_freq: float = 0.5):
28 |         super().__init__(
29 |             locator=locator,
30 |             driver=driver,
31 |             parent_locator_list=parent_locator_list,
32 |             wait_timeout=wait_timeout,
33 |             description=description,
34 |             poll_freq=poll_freq)
35 |         self._modal = ComponentModal(driver=driver, poll_freq=poll_freq)
36 |         self._cancel_button = Button(
37 |             locator=self._CANCEL_BUTTON_LOCATOR,
38 |             driver=driver,
39 |             parent_locator_list=self._modal.locator_list,
40 |             poll_freq=poll_freq)
41 |         self._confirm_button = Button(
42 |             locator=self._CONFIRM_BUTTON_LOCATOR,
43 |             driver=driver,
44 |             parent_locator_list=self._modal.locator_list,
45 |             poll_freq=poll_freq)
46 |         self._modal_message = ComponentPiece(
47 |             locator=self._MODAL_MESSAGE_LOCATOR,
48 |             driver=driver,
49 |             parent_locator_list=self._modal.locator_list,
50 |             poll_freq=poll_freq)
51 |         self._local_icon = CommonIcon(
52 |             locator=self._ICON_LOCATOR,
53 |             driver=driver,
54 |             parent_locator_list=self.locator_list,
55 |             poll_freq=poll_freq)
56 | 
57 |     def click_cancel_in_modal(self) -> None:
58 |         """
59 |         Click the Cancel button, available when confirmation is enabled.
60 | 
61 |         :raises TimeoutException: If the Cancel button is not present.
62 |         """
63 |         self._cancel_button.click()
64 | 
65 |     def click_confirm_in_modal(self) -> None:
66 |         """
67 |         Click the Confirm button, available when confirmation is enabled.
68 | 
69 |         :raises TimeoutException: If the Confirm button is not present.
70 |         """
71 |         self._confirm_button.click()
72 | 
73 |     def confirmation_modal_is_displayed(self) -> bool:
74 |         """
75 |         Determine if the confirmation modal is currently displayed.
76 | 
77 |         :returns: True, if the confirmation modal is present - False otherwise.
78 |         """
79 |         try:
80 |             return self._modal.find(wait_timeout=0.5) is not None and self._confirm_button.find(0.5) is not None
81 |         except TimeoutException:
82 |             return False
83 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/PasswordField.py:
--------------------------------------------------------------------------------
  1 | from typing import Optional, Union, List, Tuple
  2 | 
  3 | from selenium.webdriver.common.by import By
  4 | from selenium.webdriver.common.keys import Keys
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent
  8 | from Components.Common.TextInput import CommonTextInput
  9 | from Components.PerspectiveComponents.Common.Icon import CommonIcon
 10 | 
 11 | 
 12 | class PasswordField(BasicPerspectiveComponent):
 13 |     """A Perspective Password Field Component."""
 14 |     _SHOW_PASSWORD_ICON_LOCATOR = (By.CSS_SELECTOR, 'a.ia_passwordFieldComponent__visibilityLink')
 15 | 
 16 |     def __init__(
 17 |             self,
 18 |             locator: Tuple[By, str],
 19 |             driver: WebDriver,
 20 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 21 |             wait_timeout: float = 10,
 22 |             description: Optional[str] = None,
 23 |             poll_freq: float = 0.5):
 24 |         super().__init__(
 25 |             locator=locator,
 26 |             driver=driver,
 27 |             parent_locator_list=parent_locator_list,
 28 |             wait_timeout=wait_timeout,
 29 |             description=description,
 30 |             poll_freq=poll_freq)
 31 |         self._internal_input = CommonTextInput(
 32 |             locator=(By.TAG_NAME, "input"),
 33 |             driver=driver,
 34 |             parent_locator_list=self.locator_list,
 35 |             wait_timeout=2,
 36 |             poll_freq=poll_freq)
 37 |         self._icon = CommonIcon(
 38 |             locator=self._SHOW_PASSWORD_ICON_LOCATOR,
 39 |             driver=driver,
 40 |             parent_locator_list=self.locator_list,
 41 |             wait_timeout=1,
 42 |             poll_freq=poll_freq)
 43 | 
 44 |     def display_password(self, should_be_displayed: bool) -> None:
 45 |         """
 46 |         Activate the visibility toggle for the field so that the text is displayed.
 47 | 
 48 |         :raises TimeoutException: If the ability to toggle visibility is not enabled for the component.
 49 |         """
 50 |         if self.password_is_displayed() != should_be_displayed:
 51 |             self._icon.click()
 52 | 
 53 |     def get_displayed_text(self) -> str:
 54 |         """
 55 |         Get the human-readable text from the Password Field. Note that due rules applied to the underlying HTML element
 56 |         this function should only ever return an empty string.
 57 | 
 58 |         :returns: An empty string if the component is working as expected, because the 'visible' text is not actually
 59 |             present in the DOM.
 60 |         """
 61 |         # We must NOT use TextField's get_text() method as it actually pulls the value - as opposed
 62 |         # to the visible text. That being said, even grabbing the WebElement's text should only ever
 63 |         # give us an empty String for the Password Field.
 64 |         return self._internal_input.find().text
 65 | 
 66 |     def get_placeholder_text(self) -> str:
 67 |         """
 68 |         Obtain the placeholder text of the component. Note that this value is returned even when the Password Field is
 69 |         not currently displaying the placeholder text.
 70 | 
 71 |         :returns: The text the Password Field would use as placeholder text, regardless of whether or not this text is
 72 |             currently being used.
 73 |         """
 74 |         return self._internal_input.find().get_attribute("placeholder")
 75 | 
 76 |     def password_is_displayed(self) -> bool:
 77 |         """
 78 |         Determine if the content supplied as a password is currently being displayed to the user.
 79 | 
 80 |         :returns: True, if the user may currently see the password content as text - False if the user is seeing the
 81 |             masked (asterisks) content.
 82 |         """
 83 |         return self._internal_input.find().get_attribute("type") == "text"
 84 | 
 85 |     def placeholder_text_exists(self) -> bool:
 86 |         """
 87 |         Determine if placeholder text is currently configured for the Password Field. Does not reflect current use.
 88 | 
 89 |         :returns: True, if placeholder text is configured, regardless of current use - False if not placeholder text is
 90 |             configured.
 91 |         """
 92 |         return self.get_placeholder_text() is not None
 93 | 
 94 |     def set_text(
 95 |             self,
 96 |             text: Union[int, float, str],
 97 |             release_focus: bool = True,
 98 |             binding_wait_time: float = 0) -> None:
 99 |         """
100 |         Set the text content of the Password Field.
101 | 
102 |         :param text: The text content you would like to set the Password Field to contain.
103 |         :param release_focus: Dictates whether the ENTER Key is supplied as a means to commit the value.
104 |         :param binding_wait_time: The amount of time to wait after applying the supplied text before we allow code to
105 |             continue.
106 |         """
107 |         self._internal_input.find().clear()
108 |         text = text + Keys.ENTER if release_focus else text
109 |         self._internal_input.find().send_keys(text)
110 |         self.wait_on_binding(time_to_wait=binding_wait_time)
111 | 
112 |     def show_password_icon_is_visible(self) -> bool:
113 |         """
114 |         Determine if the Password Field is currently displaying the icon used to toggle content visibility.
115 | 
116 |         :returns: True, if the icon is visible - False otherwise.
117 |         """
118 |         return self._icon.is_rendered() and self._icon.find().is_displayed()
119 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/SignaturePad.py:
--------------------------------------------------------------------------------
  1 | from enum import Enum
  2 | from typing import Tuple, List, Optional
  3 | 
  4 | from selenium.webdriver import ActionChains
  5 | from selenium.webdriver.common.by import By
  6 | from selenium.webdriver.remote.webdriver import WebDriver
  7 | 
  8 | from Components.BasicComponent import ComponentPiece, BasicPerspectiveComponent
  9 | from Components.PerspectiveComponents.Inputs.Button import Button
 10 | 
 11 | 
 12 | class Orientation(Enum):
 13 |     """
 14 |     Orientation describes the relative positioning of the action bar of the Signature Pad in relation to the canvas
 15 |     of the Component, where the action bar contains the Clear and Submit buttons.
 16 |     """
 17 |     TOP = "column-reverse"
 18 |     BOTTOM = "column"
 19 |     RIGHT = "row"
 20 |     LEFT = "row-reverse"
 21 | 
 22 | 
 23 | class SignaturePad(BasicPerspectiveComponent):
 24 |     """A Perspective Signature Pad Component."""
 25 |     _SIG_PAD_LOCATOR = (By.CSS_SELECTOR, 'div.ia-signature-pad-canvas-wrapper')
 26 |     _SIG_PAD_BAR_LOCATOR = (By.CSS_SELECTOR, 'div.ia-signature-pad-action-bar')
 27 |     _CLEAR_BUTTON_LOCATOR = (By.CSS_SELECTOR, f'button[data-button-type="clear"]')
 28 |     _SUBMIT_BUTTON_LOCATOR = (By.CSS_SELECTOR, f'button[data-button-type="submit"]')
 29 | 
 30 |     def __init__(
 31 |             self,
 32 |             locator: Tuple[By, str],
 33 |             driver: WebDriver,
 34 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 35 |             wait_timeout: float = 10,
 36 |             description: Optional[str] = None,
 37 |             poll_freq: float = 0.5):
 38 |         super().__init__(
 39 |             locator=locator,
 40 |             driver=driver,
 41 |             parent_locator_list=parent_locator_list,
 42 |             wait_timeout=wait_timeout,
 43 |             description=description,
 44 |             poll_freq=poll_freq)
 45 |         self._action_bar = ComponentPiece(
 46 |             locator=self._SIG_PAD_BAR_LOCATOR,
 47 |             driver=driver,
 48 |             parent_locator_list=self.locator_list,
 49 |             poll_freq=poll_freq)
 50 |         self._clear_button = Button(
 51 |             locator=self._CLEAR_BUTTON_LOCATOR,
 52 |             driver=driver,
 53 |             parent_locator_list=self._action_bar.locator_list,
 54 |             poll_freq=poll_freq)
 55 |         self._submit_button = Button(
 56 |             locator=self._SUBMIT_BUTTON_LOCATOR,
 57 |             driver=driver,
 58 |             parent_locator_list=self._action_bar.locator_list,
 59 |             poll_freq=poll_freq)
 60 |         self._signature_pad = ComponentPiece(
 61 |             locator=self._SIG_PAD_LOCATOR, driver=driver, parent_locator_list=self.locator_list, poll_freq=poll_freq)
 62 | 
 63 |     def action_bar_has_orientation(self, expected_orientation: Orientation) -> bool:
 64 |         """
 65 |         Determine the orientation of the action bar of the Signature Pad.
 66 | 
 67 |         :returns: True, if the action bar has the supplied Orientation - False otherwise.
 68 |         """
 69 |         return expected_orientation.value.lower() == self.find().value_of_css_property("flex-direction").lower()
 70 | 
 71 |     def clear_button_is_enabled(self) -> bool:
 72 |         """
 73 |         Determine if the Clear button is currently enabled for the Signature Pad.
 74 | 
 75 |         :returns: True, if the Clear button is enabled - False otherwise.
 76 |         """
 77 |         return self._clear_button.is_enabled()
 78 | 
 79 |     def clear_button_is_primary(self) -> bool:
 80 |         """
 81 |         Determine if the Clear button is currently declaring as a Primary button type.
 82 | 
 83 |         :returns: True, if the Clear button is a Primary button - False otherwise.
 84 | 
 85 |         :raises TimeoutException: If the Clear button is not currently displayed.
 86 |         """
 87 |         return self._clear_button.is_primary()
 88 | 
 89 |     def clear_button_is_secondary(self) -> bool:
 90 |         """
 91 |         Determine if the Clear button is currently declaring as a Secondary button type.
 92 | 
 93 |         :returns: True, if the Clear button is a Secondary button - False otherwise.
 94 | 
 95 |         :raises TimeoutException: If the Clear button is not currently displayed.
 96 |         """
 97 |         return self._clear_button.is_secondary()
 98 | 
 99 |     def click_clear_button(self) -> None:
100 |         """
101 |         Click the Clear button.
102 | 
103 |         :raises TimeoutException: If the Clear button is not currently displayed.
104 |         """
105 |         self._clear_button.click()
106 | 
107 |     def click_submit_button(self) -> None:
108 |         """
109 |         Click the Submit button.
110 | 
111 |         :raises TimeoutException: If the Clear button is not currently displayed.
112 |         """
113 |         self._submit_button.click()
114 | 
115 |     def draw_on_canvas(self) -> None:
116 |         """
117 |         Make a small mark on the canvas of the Signature Pad. Useful for mocking a signature.
118 |         """
119 |         ActionChains(driver=self.driver)\
120 |             .click_and_hold(on_element=self._signature_pad.find())\
121 |             .move_by_offset(xoffset=10, yoffset=10)\
122 |             .release()\
123 |             .perform()
124 | 
125 |     def get_text_of_clear_button(self) -> str:
126 |         """
127 |         Obtain the text currently displayed for the Clear button.
128 | 
129 |         :raises TimeoutException: If the Clear button is not currently displayed.
130 |         """
131 |         return self._clear_button.get_text()
132 | 
133 |     def get_text_of_submit_button(self) -> str:
134 |         """
135 |         Obtain the text currently displayed for the Submit button.
136 | 
137 |         :raises TimeoutException: If the Submit button is not currently displayed.
138 |         """
139 |         return self._submit_button.get_text()
140 | 
141 |     def submit_button_is_enabled(self) -> bool:
142 |         """
143 |         Determine if the Submit button is currently enabled.
144 |         """
145 |         return self._submit_button.is_enabled()
146 | 
147 |     def submit_button_is_primary(self) -> bool:
148 |         """
149 |         Determine if the Submit button is currently declaring as a Primary button type.
150 | 
151 |         :raises TimeoutException: If the Submit button is not currently displayed.
152 |         """
153 |         return self._submit_button.is_primary()
154 | 
155 |     def submit_button_is_secondary(self) -> bool:
156 |         """
157 |         Determine if the Submit button is currently declaring as a Secondary button type.
158 | 
159 |         :raises TimeoutException: If the Submit button is not currently displayed.
160 |         """
161 |         return self._submit_button.is_secondary()
162 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/TextArea.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent
 7 | from Components.Common.TextInput import CommonTextInput
 8 | 
 9 | 
10 | class TextArea(BasicPerspectiveComponent, CommonTextInput):
11 |     """A Perspective Text Area Component."""
12 | 
13 |     def __init__(
14 |             self,
15 |             locator: Tuple[By, str],
16 |             driver: WebDriver,
17 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
18 |             wait_timeout: float = 10,
19 |             description: Optional[str] = None,
20 |             poll_freq: float = 0.5):
21 |         BasicPerspectiveComponent.__init__(
22 |             self,
23 |             locator=locator,
24 |             driver=driver,
25 |             parent_locator_list=parent_locator_list,
26 |             wait_timeout=wait_timeout,
27 |             description=description,
28 |             poll_freq=poll_freq)
29 |         CommonTextInput.__init__(
30 |             self,
31 |             locator=locator,
32 |             driver=driver,
33 |             parent_locator_list=parent_locator_list,
34 |             wait_timeout=wait_timeout,
35 |             description=description,
36 |             poll_freq=poll_freq)
37 | 
38 |     def _needs_to_get_input_element(self):
39 |         return False
40 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/TextField.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, List, Tuple
 2 | 
 3 | from selenium.common import TimeoutException
 4 | from selenium.webdriver.common.by import By
 5 | from selenium.webdriver.remote.webdriver import WebDriver
 6 | from selenium.webdriver.support.wait import WebDriverWait
 7 | 
 8 | from Components.BasicComponent import BasicPerspectiveComponent
 9 | from Components.Common.TextInput import CommonTextInput
10 | 
11 | 
12 | class TextField(BasicPerspectiveComponent, CommonTextInput):
13 |     """A Perspective Text Field Component."""
14 | 
15 |     def __init__(
16 |             self,
17 |             locator: Tuple[By, str],
18 |             driver: WebDriver,
19 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
20 |             wait_timeout: float = 10,
21 |             description: Optional[str] = None,
22 |             poll_freq: float = 0.5):
23 |         BasicPerspectiveComponent.__init__(
24 |             self,
25 |             locator=locator,
26 |             driver=driver,
27 |             parent_locator_list=parent_locator_list,
28 |             wait_timeout=wait_timeout,
29 |             description=description,
30 |             poll_freq=poll_freq)
31 |         CommonTextInput.__init__(
32 |             self,
33 |             locator=locator,
34 |             driver=driver,
35 |             parent_locator_list=parent_locator_list,
36 |             wait_timeout=wait_timeout,
37 |             description=description,
38 |             poll_freq=poll_freq)
39 |         self.no_wait_text_input = CommonTextInput(
40 |             locator=self._locator,
41 |             driver=self.driver,
42 |             parent_locator_list=self._parent_locator_list,
43 |             wait_timeout=0)
44 | 
45 |     def get_text(self) -> str:
46 |         self.find()
47 |         original_wait = self.wait
48 |         try:
49 |             # Wait no time here so that a TOE is immediate.
50 |             self.wait = WebDriverWait(self.driver, timeout=0)
51 |             text = CommonTextInput.get_text(self)
52 |         except TimeoutException:
53 |             # We've hit a TOE (which MUST be because the overlay has been removed), so try again and allow any
54 |             # potential TOE to be raised.
55 |             text = CommonTextInput.get_text(self)
56 |         finally:
57 |             # Regardless of exception state, we need to reset the original 'wait'.
58 |             self.wait = original_wait
59 |         return text
60 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Inputs/ToggleSwitch.py:
--------------------------------------------------------------------------------
  1 | from typing import Tuple, List, Optional
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | from selenium.webdriver.support.wait import WebDriverWait
  7 | 
  8 | from Components.BasicComponent import ComponentPiece, BasicPerspectiveComponent
  9 | from Helpers.CSSEnumerations import CSS
 10 | from Helpers.IAAssert import IAAssert
 11 | from Helpers.IAExpectedConditions import IAExpectedConditions as IAec
 12 | 
 13 | 
 14 | class ToggleSwitch(BasicPerspectiveComponent):
 15 |     """
 16 |     A Perspective Toggle Switch Component.
 17 | 
 18 |     The preferred term for referencing the state of the Toggle Switch is "selected", instead of "on", "active", or
 19 |     "True".
 20 |     """
 21 |     _TS_THUMB_LOCATOR = (By.CSS_SELECTOR, 'div.ia_toggleSwitch__thumb')
 22 |     _TS_TRACK_LOCATOR = (By.CSS_SELECTOR, 'div.ia_toggleSwitch__track')
 23 |     _TS_SELECTED_CLASS = 'ia_toggleSwitch__thumb--selected'
 24 |     _TS_DISABLED_CLASS = 'ia_toggleSwitch__thumb--disabled'
 25 | 
 26 |     def __init__(
 27 |             self,
 28 |             locator: Tuple[By, str],
 29 |             driver: WebDriver,
 30 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
 31 |             wait_timeout: float = 10,
 32 |             description: Optional[str] = None,
 33 |             poll_freq: float = 0.5):
 34 |         super().__init__(
 35 |             locator=locator,
 36 |             driver=driver,
 37 |             parent_locator_list=parent_locator_list,
 38 |             wait_timeout=wait_timeout,
 39 |             description=description,
 40 |             poll_freq=poll_freq)
 41 |         self.ts_thumb = ComponentPiece(
 42 |             locator=self._TS_THUMB_LOCATOR,
 43 |             driver=self.driver,
 44 |             parent_locator_list=self.locator_list,
 45 |             description="The circle piece of the Toggle Switch, which slides back and forth within the track.",
 46 |             poll_freq=poll_freq)
 47 |         self.ts_track = ComponentPiece(
 48 |             locator=self._TS_TRACK_LOCATOR,
 49 |             driver=self.driver,
 50 |             parent_locator_list=self.locator_list,
 51 |             description="The horizontal oval in which the 'thumb' of the Toggle Switch slides back-and-forth.",
 52 |             poll_freq=poll_freq)
 53 | 
 54 |     def get_track_color(self) -> str:
 55 |         """
 56 |         Obtain the color of the track as a string. Note that different browsers may return this color in different
 57 |         formats (RGB vs hex).
 58 | 
 59 |         :returns: The color of the track of the Toggle Switch as a string.
 60 |         """
 61 |         return self.ts_track.get_css_property(property_name=CSS.BACKGROUND_COLOR)
 62 | 
 63 |     def is_enabled(self) -> bool:
 64 |         """Determine if the Toggle Switch is currently enabled."""
 65 |         return self._TS_DISABLED_CLASS not in self.ts_thumb.find().get_attribute('class')
 66 | 
 67 |     def is_selected(self) -> bool:
 68 |         """
 69 |         Determine if the Toggle Switch is currently selected (on/True/active).
 70 | 
 71 |         :return: True, if the Toggle Switch is currently selected (on/True/active) - False otherwise.
 72 |         """
 73 |         return self._TS_SELECTED_CLASS in self.ts_thumb.find(wait_timeout=0).get_attribute('class')
 74 | 
 75 |     def set_switch(self, should_be_selected: bool = True, binding_wait_time: float = 0.5) -> None:
 76 |         """
 77 |         Set the state of the Toggle Switch. Takes no action if the Toggle Switch already has the specified state.
 78 | 
 79 |         :param should_be_selected: The desired state of the Toggle Switch.
 80 |         :param binding_wait_time: The amount of time to wait after any click action is taken before continuing.
 81 | 
 82 |         :raises AssertionError: If unsuccessful in applying the desired state to the Toggle Switch.
 83 |         """
 84 |         if not self.wait_on_selection_state(expected_selection_state=should_be_selected):
 85 |             self.click(binding_wait_time=binding_wait_time)
 86 |         IAAssert.is_true(
 87 |             value=self.wait_on_selection_state(expected_selection_state=should_be_selected),
 88 |             failure_msg=f"Failed to set the state of a Toggle Switch to {should_be_selected}.")
 89 | 
 90 |     def wait_on_selection_state(self, expected_selection_state: bool, wait_timeout: float = 1) -> bool:
 91 |         """
 92 |         Determine whether the Toggle Switch has the supplied state. Preferable to is_selected because has_state works
 93 |         for both active/inactive states.
 94 | 
 95 |         :param expected_selection_state: The state you want to wait for the Toggle Switch to take, where True is
 96 |             selected, and False is unselected.
 97 |         :param wait_timeout: The amount of time (in seconds) you are willing to wait for the Toggle Switch to take the
 98 |             specified state.
 99 | 
100 |         :returns: True, if the Toggle Switch has the specified selection state - False otherwise.
101 |         """
102 |         try:
103 |             if not expected_selection_state:  # False
104 |                 # We are forced to wait a moment here, because Toggle Switches enter the DOM as inactive; attempts to
105 |                 # verify if they are False too early will almost always return True because the front-end has not caught
106 |                 # up to the backend. This is most prevalent when dealing with a Toggle Switch immediately after it has
107 |                 # entered the DOM, like when Popups are opened.
108 |                 self.wait_on_binding(0.25)
109 |             return WebDriverWait(driver=self.driver, timeout=wait_timeout).until(
110 |                 IAec.function_returns_true(
111 |                     custom_function=self._has_selection_state,
112 |                     function_args={'expected_selection_state': expected_selection_state}))
113 |         except TimeoutException:
114 |             return False
115 | 
116 |     def _has_selection_state(self, expected_selection_state: bool) -> bool:
117 |         """Determine whether the Toggle Switch has the supplied state."""
118 |         return self.is_selected() == expected_selection_state
119 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Navigation/Link.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional, Tuple, List
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Components.BasicComponent import BasicPerspectiveComponent, ComponentPiece
 7 | 
 8 | 
 9 | class Link(BasicPerspectiveComponent):
10 |     """A Perspective Link Component."""
11 | 
12 |     def __init__(
13 |             self,
14 |             locator: Tuple[By, str],
15 |             driver: WebDriver,
16 |             parent_locator_list: Optional[List[Tuple[By, str]]] = None,
17 |             wait_timeout: int = 2,
18 |             description: Optional[str] = None,
19 |             poll_freq: float = 0.5):
20 |         super().__init__(
21 |             locator=locator,
22 |             driver=driver,
23 |             parent_locator_list=parent_locator_list,
24 |             wait_timeout=wait_timeout,
25 |             description=description,
26 |             poll_freq=poll_freq)
27 |         self._anchor = ComponentPiece(
28 |             locator=(By.TAG_NAME, "a"),
29 |             driver=driver,
30 |             parent_locator_list=self.locator_list,
31 |             poll_freq=poll_freq)
32 | 
33 |     def get_link_href(self) -> str:
34 |         """
35 |         Obtain the destination URL of the Link component. Returned values which begin with a slash are Perspective
36 |         page URLs which would be appended to the Gateway address (including port) to fashion a full URL, though
37 |         the actual navigation is done internally instead of through an HTTP GET request.
38 |         """
39 |         return self._anchor.find().get_attribute('href')
40 | 
41 |     def get_target(self) -> str:
42 |         """
43 |         Obtain the browser target of the link.
44 | 
45 |         _blank - The destination specified within the href attribute will be opened in a new browser tab.
46 |         All other values would open in the same browser tab.
47 |         """
48 |         return self._anchor.find().get_attribute('target')
49 | 


--------------------------------------------------------------------------------
/Components/PerspectiveComponents/Tooltip.py:
--------------------------------------------------------------------------------
  1 | from typing import Union, Optional
  2 | 
  3 | from selenium.common.exceptions import TimeoutException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | from selenium.webdriver.support.wait import WebDriverWait
  7 | 
  8 | from Components.BasicComponent import ComponentPiece
  9 | from Helpers.CSSEnumerations import CSS
 10 | from Helpers.IAExpectedConditions import IAExpectedConditions as IAec
 11 | from Helpers.Point import Point
 12 | 
 13 | 
 14 | class Tooltip(ComponentPiece):
 15 |     """
 16 |     A Tooltip for a Perspective Component, driven by the META category within props. Note that tooltips defined by
 17 |     properties outside of META will not work with this class.
 18 | 
 19 |     Also, tooltips do not provide insight into their originating component, so all functions contained within this class
 20 |     will report on or interact with any tooltip which is displayed.
 21 |     """
 22 |     _COMPONENT_TOOLTIP_LOCATOR = (By.CSS_SELECTOR, 'div.component-tooltip')
 23 |     _TAIL_LOCATOR = (By.CSS_SELECTOR, 'div.tail')
 24 | 
 25 |     def __init__(
 26 |             self,
 27 |             driver: WebDriver,
 28 |             wait_timeout: Union[int, float] = 2,
 29 |             description: Optional[str] = None,
 30 |             poll_freq: float = 0.5):
 31 |         super().__init__(
 32 |             locator=self._COMPONENT_TOOLTIP_LOCATOR,
 33 |             driver=driver,
 34 |             parent_locator_list=None,
 35 |             wait_timeout=wait_timeout,
 36 |             description=description,
 37 |             poll_freq=poll_freq)
 38 |         self._tail = ComponentPiece(
 39 |             locator=self._TAIL_LOCATOR,
 40 |             driver=driver,
 41 |             parent_locator_list=self.locator_list,
 42 |             wait_timeout=wait_timeout,
 43 |             poll_freq=poll_freq)
 44 | 
 45 |     def any_component_tooltip_is_displayed(self) -> bool:
 46 |         """
 47 |         Determine if any tooltips is displayed for any component.
 48 | 
 49 |         :returns: True, if any tooltip is displayed for any component.
 50 |         """
 51 |         try:
 52 |             return self.find() is not None
 53 |         except TimeoutException:
 54 |             return False
 55 | 
 56 |     def component_tooltip_has_tail(self) -> bool:
 57 |         """
 58 |         Determine if the displayed tooltip is rendering a tail as part of its appearance.
 59 | 
 60 |         :returns: True, if the displayed tooltip is currently rendering a tail.
 61 |         """
 62 |         try:
 63 |             return self._tail.find() is not None
 64 |         except TimeoutException:
 65 |             return False
 66 | 
 67 |     def get_count_of_tooltips(
 68 |             self, expected_count: int = 1, wait_timeout: Union[int, float] = 5, poll_frequency: float = 0.5) -> int:
 69 |         """
 70 |         Obtain a count of all displayed tooltips.
 71 | 
 72 |         :param expected_count: If supplied, we will attempt to wait until this many tooltips are displayed before
 73 |             returning a value.
 74 |         :param wait_timeout: The amount of time (in seconds) to wait for any tooltips to appear. Use this when tooltips
 75 |             contain any configured delay.
 76 |         :param poll_frequency: How often to poll the DOM as we wait for an expected count of tooltips.
 77 | 
 78 |         :returns: A count of displayed tooltips.
 79 |         """
 80 |         try:
 81 |             WebDriverWait(driver=self.driver, timeout=wait_timeout, poll_frequency=poll_frequency).until(
 82 |                 IAec.function_returns_true(
 83 |                     custom_function=self._expected_number_of_tooltips_displayed,
 84 |                     function_args={'expected_count': expected_count}))
 85 |             return expected_count
 86 |         except TimeoutException:
 87 |             pass
 88 |         try:
 89 |             return len(self.find_all(wait_timeout=1))
 90 |         except TimeoutException:
 91 |             return 0
 92 | 
 93 |     def _get_origin_of_component_tooltip(self) -> Point:
 94 |         """
 95 |         Obtain the origin (upper-left corner) of a tooltip. If multiple tooltips are present, this will return the
 96 |         origin of the tooltip which was rendered first.
 97 | 
 98 |         :returns: A two-dimensional point which represents the upper-left corner of the tooltip.
 99 | 
100 |         :raises TimeoutException: If no tooltips are rendered.
101 |         """
102 |         return self.get_origin()
103 | 
104 |     def get_height_of_component_tooltip(self, include_units: bool = False) -> str:
105 |         """
106 |         Obtain the height of a tooltip, with or without units (usually px). If multiple tooltips are present, this will
107 |         return the height of the tooltip which was rendered first.
108 | 
109 |         :param include_units: Dictates whether the returned value contains units of measurement (almost always 'px').
110 | 
111 |         :returns: The height of the first rendered tooltip - with or without units.
112 | 
113 |         :raises TimeoutException: If no tooltips are rendered.
114 |         """
115 |         return self.get_computed_height(include_units=include_units)
116 | 
117 |     def get_tail_color(self) -> str:
118 |         """
119 |         Obtain the color in use for the tail of a tooltip as a string.
120 | 
121 |         :returns: The color in use for the tail of a tooltip. Note that the format of this value will change based on
122 |             the browser in use.
123 | 
124 |         :raises TimeoutException: If no tooltips are rendered.
125 |         """
126 |         return self._tail.get_css_property(property_name=CSS.BORDER_TOP_COLOR)
127 | 
128 |     def get_width_of_component_tooltip(self, include_units: bool = False) -> str:
129 |         """
130 |         Obtain the width of a tooltip, with or without units (usually px). If multiple tooltips are present, this will
131 |         return the width of the tooltip which was rendered first.
132 | 
133 |         :param include_units: Dictates whether the returned value contains units of measurement (almost always 'px').
134 | 
135 |         :returns: The width of the first rendered tooltip - with or without units.
136 | 
137 |         :raises TimeoutException: If no tooltips are rendered.
138 |         """
139 |         return self.get_computed_width(include_units=include_units)
140 | 
141 |     def get_text_of_tooltip(self) -> str:
142 |         """
143 |         Obtain the text present within the tooltip.
144 | 
145 |         :returns: The currently rendered text of the tooltip. If multiple tooltips are present, this will return the
146 |             text of the tooltip which was rendered first.
147 | 
148 |         :raises TimeoutException: If no tooltips are rendered.
149 |         """
150 |         return self.get_text()
151 | 
152 |     def _expected_number_of_tooltips_displayed(self, expected_count: int) -> bool:
153 |         """
154 |         Determine if a specific number of tooltips are displayed.
155 | 
156 |         :param expected_count: The count of tooltips you expect to be rendered.
157 | 
158 |         :returns: True, if the currently rendered count of tooltips matches the supplied expected_count value - False
159 |             otherwise.
160 |         """
161 |         try:
162 |             return len(self.find_all(wait_timeout=0)) == expected_count
163 |         except TimeoutException:
164 |             return False
165 | 


--------------------------------------------------------------------------------
/Helpers/CSSEnumerations.py:
--------------------------------------------------------------------------------
 1 | class CSSPropertyValue:
 2 |     """
 3 |     The CSSPropertyValue class serves two purposes:
 4 |     1. It allows for some areas of code to specify a type other than string, which would otherwise be confusing.
 5 |     2. It provides an avenue to reduce potential typos.
 6 | 
 7 |     Consider the following example:
 8 |     self._component.get_css_property_value('full') == ""
 9 | 
10 |     Such a statement would always return True, because the minor typo prevents the 'fill' value from being queried. By
11 |     providing and requiring an enumerated value we remove any chance of such a typo.
12 |     """
13 |     value = None
14 | 
15 |     def __init__(self, value: str):
16 |         self.value = value
17 | 
18 |     def __str__(self):
19 |         return self.value
20 | 
21 | 
22 | class CSS:
23 |     """
24 |     An ever-expanding enumeration of sorts which contains common CSS properties. For properties which are themselves
25 |     enumerations, we provide those enumerated values.
26 |     """
27 | 
28 |     class AlignItems:
29 |         CENTER = CSSPropertyValue("center")
30 |         END = CSSPropertyValue("end")
31 |         FLEX_END = CSSPropertyValue("flex-end")
32 |         FLEX_START = CSSPropertyValue("flex-start")
33 |         NORMAL = CSSPropertyValue("normal")
34 |         START = CSSPropertyValue("start")
35 |         STRETCH = CSSPropertyValue("stretch")
36 | 
37 |     BACKGROUND_COLOR = CSSPropertyValue("background-color")
38 |     BORDER_TOP_COLOR = CSSPropertyValue("border-top-color")
39 |     BORDER_TOP_LEFT_RADIUS = CSSPropertyValue("border-top-left-radius")
40 |     BORDER_TOP_RIGHT_RADIUS = CSSPropertyValue("border-top-right-radius")
41 |     BORDER_TOP_STYLE = CSSPropertyValue("border-top-style")
42 |     BOTTOM = CSSPropertyValue("bottom")
43 |     COLOR = CSSPropertyValue("color")
44 | 
45 |     class Cursor:
46 |         GRAB = CSSPropertyValue("grab")
47 |         NOT_ALLOWED = CSSPropertyValue("not-allowed")
48 |         POINTER = CSSPropertyValue("pointer")
49 |         WAIT = CSSPropertyValue("wait")
50 | 
51 |     class Display:
52 |         """
53 |         Display has loads of options and can take multiple arguments, but these are the basic/common options.
54 |         """
55 |         BLOCK = CSSPropertyValue("block")
56 |         FLEX = CSSPropertyValue("flex")
57 |         INLINE = CSSPropertyValue("inline")
58 | 
59 |     FILL = CSSPropertyValue("fill")
60 |     FILL_OPACITY = CSSPropertyValue("fill-opacity")
61 | 
62 |     class FlexFlow:
63 |         """
64 |         This class currently only contains values supported by the Flex Container for direction.
65 |         """
66 |         COLUMN = CSSPropertyValue("column")
67 |         COLUMN_REVERSE = CSSPropertyValue("column-reverse")
68 |         ROW = CSSPropertyValue("row")
69 |         ROW_REVERSE = CSSPropertyValue("row-reverse")
70 | 
71 |     FONT_SIZE = CSSPropertyValue("font-size")
72 |     HEIGHT = CSSPropertyValue("height")
73 |     JUSTIFY_CONTENT = CSSPropertyValue('justify-content')
74 |     MARGIN_BOTTOM = CSSPropertyValue("margin-bottom")
75 |     MARGIN_LEFT = CSSPropertyValue("margin-left")
76 |     MARGIN_RIGHT = CSSPropertyValue("margin-right")
77 |     MARGIN_TOP = CSSPropertyValue("margin-top")
78 |     MAX_WIDTH = CSSPropertyValue("max-width")
79 |     OBJECT_FIT = CSSPropertyValue("object-fit")
80 |     OPACITY = CSSPropertyValue("opacity")
81 |     OVERFLOW = CSSPropertyValue("overflow")
82 |     POSITION = CSSPropertyValue("position")
83 |     STROKE = CSSPropertyValue("stroke")
84 |     STROKE_DASHARRAY = CSSPropertyValue("stroke-dasharray")
85 |     STROKE_WIDTH = CSSPropertyValue("stroke-width")
86 |     TEXT_ALIGN = CSSPropertyValue('text-align')
87 |     TRANSITION = CSSPropertyValue("transition")
88 |     TRANSITION_DURATION = CSSPropertyValue("transition-duration")
89 |     TRANSITION_TIMING_FUNCTION = CSSPropertyValue("transition-timing-function")
90 |     WIDTH = CSSPropertyValue("width")
91 |     Z_INDEX = CSSPropertyValue("z-index")
92 |     


--------------------------------------------------------------------------------
/Helpers/Filtering.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Iterable
 2 | 
 3 | 
 4 | class Items:
 5 |     """
 6 |     This helper allows for defining some iterable collection of items so that they can then be filtered by some
 7 |     function.
 8 |     """
 9 | 
10 |     def __init__(self, items: Iterable):
11 |         self._items = items
12 | 
13 |     def filter(self, filtering_function) -> List:
14 |         """
15 |         Filter this Items object based on whether each item results in a truthy evaluation when run through the
16 |         supplied function.
17 | 
18 |         Example:
19 |             items (constructor) = "apple"
20 |             filtering_function = lambda e: e in "laptop"
21 |             In this example, every item (character) within the iterable supplied within the constructor (our string
22 |             "apple") will be evaluated to see if it (e) is in the string "laptop". The returned list after evaluation
23 |             will be ["a", "p", "p", "l"].
24 | 
25 |         :param filtering_function: A function (usually a lambda) which accepts one argument and performs some sort of
26 |             evaluation of that argument. As each item in this Items object is evaluated as the argument of the function,
27 |             a truthy evaluation will result in the item being evaluated remaining in the returned list, while a falsy
28 |             evaluation will result in the item being omitted from the returned list.
29 | 
30 |         :returns: A list, where each item in the list was evaluated by the supplied function and resulted in a truthy
31 |             evaluation.
32 |         """
33 |         return list(filter(filtering_function, self._items))
34 | 


--------------------------------------------------------------------------------
/Helpers/Formatting.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from pathlib import Path
 3 | 
 4 | 
 5 | class FilePathFormatting:
 6 |     """
 7 |     The functions contained within this class are intended to operate on string file paths and make them
 8 |     platform-agnostic, so that they can be used regardless of Operating System.
 9 |     """
10 | 
11 |     @staticmethod
12 |     def system_safe_file_path(exec_dir: str, file_path: str) -> str:
13 |         """
14 |         Attempts to take a standard string file path and make it work across any operating system.
15 | 
16 |         :param exec_dir: The execution directory to be used in constructing the file path.
17 |         :param file_path: The path of the file.
18 | 
19 |         :returns: A platform-agnostic path to a file.
20 |         """
21 |         return str(Path(os.path.join(exec_dir, file_path)).resolve())
22 | 
23 |     @staticmethod
24 |     def create_incremented_file_path(file_path: str) -> str:
25 |         """
26 |         Given a desired file path, create a unique file name by incrementing on the supplied path.
27 | 
28 |         Example:
29 |             file_path = "something/myPicture.jpeg"
30 |             If a file with that name already exists on the operating system, you will receive a new file path:
31 |             "something/myPicture_1.jpeg". Had the file not already existed, you would receive the same file path you
32 |             had supplied.
33 | 
34 |         :param file_path: A File path to look for on the operating system.
35 | 
36 |         :returns: A unique and unused file path built from the supplied file_path.
37 |         """
38 |         add = 1
39 |         final_file_path = file_path
40 |         while os.path.isfile(final_file_path):
41 |             split = file_path.split('.')
42 |             part_1 = split[0] + "_" + str(add)
43 |             final_file_path = '.'.join([part_1, split[1]])
44 |             add += 1
45 |         return final_file_path
46 | 


--------------------------------------------------------------------------------
/Helpers/GeographicPoint.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | 
 4 | class GeographicPoint:
 5 |     """
 6 |     A standard two-dimensional point representing a geographical location on Earth, consisting of both latitude and
 7 |     longitude values represented as floats.
 8 |     """
 9 | 
10 |     def __init__(self, latitude: float, longitude: float):
11 |         self.latitude = latitude
12 |         self.longitude = longitude
13 |         self._current_index = 0
14 |         self._items = [latitude, longitude]
15 | 
16 |     def __getitem__(self, index):
17 |         try:
18 |             return self._items[index]
19 |         except IndexError:
20 |             raise IndexError("GeographicPoint only have two coordinates; supply an index in this range: -2<=N<=1.")
21 | 
22 |     def __iter__(self):
23 |         return self
24 | 
25 |     def __next__(self):
26 |         if self._current_index < 2:
27 |             coordinate_value = self._items[self._current_index]
28 |             self._current_index += 1
29 |             return coordinate_value
30 |         raise StopIteration
31 | 
32 |     def __repr__(self):
33 |         return f'{self.__class__.__name__}(latitude: {self.latitude}, longitude: {self.longitude})'
34 | 
35 |     def __eq__(self, other):
36 |         return (math.isclose(self.latitude, other.latitude, abs_tol=1e-08, rel_tol=0) and
37 |                 math.isclose(self.longitude, other.longitude, abs_tol=1e-08, rel_tol=0))
38 | 


--------------------------------------------------------------------------------
/Helpers/Ignition/Alarm.py:
--------------------------------------------------------------------------------
  1 | import copy
  2 | import json
  3 | import re
  4 | from enum import Enum
  5 | from typing import Dict, List, Optional
  6 | 
  7 | 
  8 | class AlarmState(Enum):
  9 |     """
 10 |     An enumeration of the possible states an alarm could have. Each state here should have a matching event type in
 11 |     Ignition's Alarm Journal.
 12 |     """
 13 |     ACKNOWLEDGED = 'Acknowledged'
 14 |     ACTIVE = 'Active'
 15 |     CLEARED = 'Cleared'
 16 |     UNACKNOWLEDGED = 'Unacknowledged'
 17 |     SYSTEM = 'System'
 18 |     ENABLED = 'Enabled'
 19 |     DISABLED = 'Disabled'
 20 | 
 21 | 
 22 | class AlarmStatusTableAlarmState(Enum):
 23 |     """
 24 |     The Alarm Status Table has its own unique set of states, built out of intersections of basic Alarm States.
 25 |     """
 26 |     ACTIVE_ACKNOWLEDGED = ", ".join([AlarmState.ACTIVE.value, AlarmState.ACKNOWLEDGED.value])
 27 |     ACTIVE_UNACKNOWLEDGED = ", ".join([AlarmState.ACTIVE.value, AlarmState.UNACKNOWLEDGED.value])
 28 |     CLEARED_ACKNOWLEDGED = ", ".join([AlarmState.CLEARED.value, AlarmState.ACKNOWLEDGED.value])
 29 |     CLEARED_UNACKNOWLEDGED = ", ".join([AlarmState.CLEARED.value, AlarmState.UNACKNOWLEDGED.value])
 30 | 
 31 | 
 32 | class AlarmPriority(Enum):
 33 |     """
 34 |     An enumeration of the possible priorities an alarm could have.
 35 |     """
 36 |     CRITICAL = 'Critical'
 37 |     DIAGNOSTIC = 'Diagnostic'
 38 |     HIGH = 'High'
 39 |     LOW = 'Low'
 40 |     MEDIUM = 'Medium'
 41 | 
 42 | 
 43 | class AlarmMode(Enum):
 44 |     EQUALITY = 'Equality'
 45 |     INEQUALITY = 'Inequality'
 46 |     ABOVE_VALUE = 'AboveValue'
 47 |     BELOW_VALUE = 'BelowValue'
 48 |     BETWEEN_VALUES = 'BetweenValues'
 49 |     OUTSIDE_VALUES = 'OutsideValues'
 50 |     OUT_OF_ENG_RANGE = 'OutOfEngRange'
 51 |     BAD_QUALITY = 'BadQuality'
 52 |     ANY_CHANGE = 'AnyChange'
 53 |     BIT = 'Bit'
 54 |     ON_CONDITION = 'OnCondition'
 55 | 
 56 | 
 57 | class AlarmDefinition(object):
 58 | 
 59 |     def __init__(self, name: str):
 60 |         self._name = name
 61 |         self.ack_mode = None
 62 |         self.ack_notes_reqd = None
 63 |         self.ack_pipeline = None
 64 |         self.active_pipeline = None
 65 |         self.clear_pipeline = None
 66 |         self.deadband = None
 67 |         self.deadband_eval_mode = None
 68 |         self.display_path = None
 69 |         self.enabled = None
 70 |         self.label = None
 71 |         self.notes = None
 72 |         self.notify_initial_event = None
 73 |         self.pipeline_project = None
 74 |         self.priority: Optional[AlarmPriority] = None
 75 |         self.shelving_allowed = None
 76 |         self.time_off_delay_seconds = None
 77 |         self.time_on_delay_seconds = None
 78 |         self.timestamp_source = None
 79 |         self.source = None
 80 | 
 81 |         # Alarm Mode Settings
 82 |         self.active_condition = None
 83 |         self.any_change = None
 84 |         self.bit_on_zero = None
 85 |         self.bit_position = None
 86 |         self.display_name = None
 87 |         self.inclusive_a = None
 88 |         self.inclusive_b = None
 89 |         self.mode: Optional[AlarmMode] = None
 90 |         self.on_each_evaluation = None
 91 |         self.setpoint_a = None
 92 |         self.setpoint_b = None
 93 | 
 94 |     def get_name(self) -> str:
 95 |         return self._name
 96 | 
 97 |     def to_dict(self) -> Dict:
 98 |         local_alarm = self.duplicate()
 99 |         special_case = ['_name']
100 |         ignore_list = ['source']
101 |         # Get set attributes of the Tag Object
102 |         attrs = vars(local_alarm)
103 |         alarm_dict = {}
104 |         for item in special_case:
105 |             new_item = item.replace('_', '')
106 |             attrs[new_item] = attrs[item]
107 |             del attrs[item]
108 |         for attr in attrs:
109 |             ignition_key = self._to_camel_case(attr)
110 |             if getattr(local_alarm, attr) is not None and attr not in ignore_list:
111 |                 if isinstance(getattr(local_alarm, attr), Enum):
112 |                     alarm_dict[ignition_key] = getattr(local_alarm, attr).value
113 |                 else:
114 |                     alarm_dict[ignition_key] = getattr(local_alarm, attr)
115 |         return alarm_dict
116 | 
117 |     def duplicate(self):
118 |         return copy.deepcopy(self)
119 | 
120 |     @staticmethod
121 |     def _to_camel_case(name) -> str:
122 |         init, *temp = name.split('_')
123 |         return ''.join([init.lower(), *map(str.title, temp)])
124 | 
125 | 
126 | class AlarmHelper:
127 |     @staticmethod
128 |     def build_alarm_from_string(dict_as_string: str) -> AlarmDefinition:
129 |         """Creates an AlarmDefinition object from a string representation of a python dict
130 |         Used for converting alarm definitions the Ignition Gateway provides into Objects"""
131 |         response_json = json.loads(
132 |             dict_as_string)
133 |         if 'error' not in response_json:
134 |             if isinstance(
135 |                     response_json,
136 |                     list):
137 |                 response_json = response_json[0]
138 |             name = response_json.get('name')
139 |             alarm = AlarmDefinition(
140 |                     name=name)
141 |             for key in response_json.keys():
142 |                 alarm = AlarmHelper._process_key(
143 |                     alarm,
144 |                     key,
145 |                     response_json[key])
146 |             return alarm
147 | 
148 |     @staticmethod
149 |     def convert_alarmdefs_to_config_dicts(alarm_list: List[AlarmDefinition]) -> List[Dict]:
150 |         """Take a list of AlarmDefinition objects and convert them into a list of dicts """
151 |         alarms = []
152 |         for alarm in alarm_list:
153 |             alarms.append(
154 |                 alarm.to_dict())
155 |         return alarms
156 | 
157 |     @staticmethod
158 |     def _process_path(path_parts: json):
159 |         path_parts.pop()
160 |         return '/'.join(
161 |             path_parts)
162 | 
163 |     @staticmethod
164 |     def _process_key(alarm: AlarmDefinition, key: str, value: object):
165 |         excluded_types = ['path', 'name']
166 |         if key not in excluded_types:
167 |             mapped_key = AlarmHelper._to_snake_case(
168 |                 key)
169 |             setattr(
170 |                 alarm,
171 |                 mapped_key,
172 |                 value)
173 |         return alarm
174 | 
175 |     @staticmethod
176 |     def _to_snake_case(name):
177 |         name = re.sub(
178 |             '(.)([A-Z][a-z]+)',
179 |             r'\1_\2',
180 |             name)
181 |         name = re.sub(
182 |             '__([A-Z])',
183 |             r'_\1',
184 |             name)
185 |         name = re.sub(
186 |             '([a-z0-9])([A-Z])',
187 |             r'\1_\2',
188 |             name)
189 |         return name.lower()
190 | 


--------------------------------------------------------------------------------
/Helpers/Ignition/AlarmEvent.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional
 2 | 
 3 | 
 4 | class AlarmEvent:
 5 | 
 6 |     def __init__(self, name: Optional[str] = None):
 7 |         self.attr_name = name
 8 |         self.dict_name = name
 9 |         self.attr_acked = None
10 |         self.attr_ack_data = None
11 |         self.attr_activeData = None
12 |         self.attr_cleared = None
13 |         self.attr_clearedData = None
14 |         self.attr_count = None
15 |         self.attr_displayPath = None
16 |         self.attr_displayPathOrSource = None
17 |         self.attr_extension = None
18 |         self.attr_getAckData = None
19 |         self.attr_getActiveData = None
20 |         self.attr_getClearedData = None
21 |         self.attr_getCount = None
22 |         self.attr_getDisplayPath = None
23 |         self.attr_getDisplayPathOrSource = None
24 |         self.attr_getExtension = None
25 |         self.attr_getId = None
26 |         self.attr_getLabel = None
27 |         self.attr_getLastEventState = None
28 |         self.attr_getName = None
29 |         self.attr_getNotes = None
30 |         self.attr_getPriority = None
31 |         self.attr_getProperties = None
32 |         self.attr_getSource = None
33 |         self.attr_getState = None
34 |         self.attr_getValues = None
35 |         self.attr_hashCode = None
36 |         self.attr_id = None
37 |         self.attr_isAcked = None
38 |         self.attr_isCleared = None
39 |         self.attr_isExtended = None
40 |         self.attr_isInherited = None
41 |         self.attr_isShelved = None
42 |         self.attr_label = None
43 |         self.attr_lastEventState = None
44 |         self.attr_name = None
45 |         self.attr_notes = None
46 |         self.attr_notify = None
47 |         self.attr_notifyAll = None
48 |         self.attr_priority = None
49 |         self.attr_properties = None
50 |         self.attr_shelved = None
51 |         self.attr_source = None
52 |         self.attr_sourceEvent = None
53 |         self.attr_state = None
54 |         self.attr_values = None
55 |         self.dict_event_id = None
56 |         self.dict_event_state = None
57 |         self.dict_is_acked = None
58 |         self.dict_is_cleared = None
59 |         self.dict_is_shelved = None
60 |         self.dict_ack_data = None
61 |         self.dict_acked = None
62 |         self.dict_cleared = None
63 |         self.dict_cleared_data = None
64 |         self.dict_count = None
65 |         self.dict_display_path = None
66 |         self.dict_display_path_or_source = None
67 |         self.dict_extension = None
68 |         self.dict_id = None
69 |         self.dict_label = None
70 |         self.dict_last_event_state = None
71 |         self.dict_name = None
72 |         self.dict_notes = None
73 |         self.dict_priority = None
74 |         self.dict_properties = None
75 |         self.dict_property_values = None
76 |         self.dict_shelved = None
77 |         self.dict_source = None
78 |         self.dict_state = None
79 |         self.event_time = None
80 |         self.func_active_data = None
81 |         self.func_ack_data = None
82 |         self.func_cleared_data = None
83 |         self.func_count = None
84 |         self.func_display_path = None
85 |         self.func_label = None
86 |         self.func_last_event_state = None
87 |         self.func_priority = None
88 |         self.func_state = None
89 |         self.func_is_acked = None
90 |         self.func_is_cleared = None
91 |         self.func_is_shelved = None
92 | 
93 |     def __str__(self):
94 |         return str(self.__dict__)
95 | 


--------------------------------------------------------------------------------
/Helpers/Ignition/QualifiedValue.py:
--------------------------------------------------------------------------------
 1 | from datetime import datetime
 2 | from enum import Enum
 3 | from typing import Optional, Any
 4 | 
 5 | 
 6 | class LegacyQualityCode(Enum):
 7 |     GOOD_UNSPECIFIED = 0
 8 |     GOOD_WRITEPENDING = 2
 9 |     GOOD = 192
10 |     GOOD_PROVISIONAL = 200
11 |     GOOD_INITIAL = 201
12 |     GOOD_OVERLOAD = 202
13 |     GOOD_BACKFILL = 203
14 |     UNCERTAIN = 256
15 |     UNCERTAIN_LASTKNOWNVALUE = 257
16 |     UNCERTAIN_INITIALVALUE = 258
17 |     UNCERTAIN_DATASUBNORMAL = 259
18 |     UNCERTAIN_ENGINEERINGUNITSEXCEEDED = 260
19 |     UNCERTAIN_INCOMPLETEOPERATION = 261
20 |     BAD = 512
21 |     BAD_UNAUTHORIZED = 513
22 |     BAD_ACCESSDENIED = 514
23 |     BAD_DISABLED = 515
24 |     BAD_STALE = 516
25 |     BAD_TRIALEXPIRED = 517
26 |     BAD_LICENSEEXCEEDED = 518
27 |     BAD_NOTFOUND = 519
28 |     BAD_REFERENCENOTFOUND = 520
29 |     BAD_AGGREGATENOTFOUND = 521
30 |     BAD_NOTCONNECTED = 522
31 |     BAD_GATEWAYCOMMOFF = 523
32 |     BAD_OUTOFRANGE = 524
33 |     BAD_DATABASENOTCONNECTED = 525
34 |     BAD_READONLY = 526
35 |     BAD_FAILURE = 527
36 |     BAD_UNSUPPORTED = 528
37 |     ERROR = 768
38 |     ERROR_CONFIGURATION = 769
39 |     ERROR_EXPRESSIONEVAL = 770
40 |     ERROR_TAGEXECUTION = 771
41 |     ERROR_TYPECONVERSION = 772
42 |     ERROR_DATABASEQUERY = 773
43 |     ERROR_IO = 774
44 |     ERROR_TIMEOUTEXPIRED = 775
45 |     ERROR_EXCEPTION = 776
46 |     ERROR_INVALIDPATHSYNTAX = 777
47 |     ERROR_FORMATTING = 778
48 |     ERROR_SCRIPTEVAL = 779
49 |     ERROR_CYCLEDETECTED = 780
50 | 
51 | 
52 | class QualifiedValue:
53 |     """
54 |     The QualifiedValue class is provided as a way to store Qualified Value objects with easy to reference attributes.
55 |     """
56 | 
57 |     def __init__(
58 |             self,
59 |             value: Optional[Any] = None,
60 |             quality: LegacyQualityCode = LegacyQualityCode.UNCERTAIN,
61 |             timestamp: datetime = datetime.now()):
62 |         self.value = value
63 |         self.quality = quality
64 |         self.timestamp = timestamp
65 | 


--------------------------------------------------------------------------------
/Helpers/PerspectiveAlarm.py:
--------------------------------------------------------------------------------
 1 | from Helpers.Ignition.Alarm import AlarmDefinition
 2 | 
 3 | 
 4 | class PerspectiveAlarm(object):
 5 |     """
 6 |     Defines the configuration of an Ignition alarm, and is not intended to be used for storing information
 7 |     about the state of an alarm over a period of time. Specifically, this class stores information about the
 8 |     important configuration attributes Perspective could have need of while interacting with the Alarm Tables, where
 9 |     information like `source_path` is required while working with shelved alarms.
10 |     """
11 | 
12 |     def __init__(self, name: str, display_path: str, priority: str, label: str,
13 |                  source_path: str, tag_path: str, notes: str = None):
14 |         self.name = name
15 |         self.display_path = display_path
16 |         self.priority = priority
17 |         self.label = label
18 |         self.notes = notes
19 |         self.source_path = source_path
20 |         self.tag_path = tag_path
21 |         self.notes = notes
22 | 
23 |     def get_alarm_definition(self) -> AlarmDefinition:
24 |         definition = AlarmDefinition(name=self.name)
25 |         definition.display_path = self.display_path
26 |         definition.priority = self.priority
27 |         definition.label = self.label
28 |         definition.notes = self.notes
29 |         definition.source = self.source_path
30 |         definition.tag_path = self.tag_path
31 |         definition.notes = self.notes
32 |         return definition
33 | 


--------------------------------------------------------------------------------
/Helpers/PerspectivePages/AuthChallengeHelper.py:
--------------------------------------------------------------------------------
 1 | from selenium.common.exceptions import TimeoutException
 2 | from selenium.webdriver.common.by import By
 3 | from selenium.webdriver.remote.webdriver import WebDriver
 4 | from selenium.webdriver.support import expected_conditions as ec
 5 | 
 6 | from Helpers.IASelenium import IASelenium
 7 | from Helpers.PerspectivePages.LoginHelper import LoginHelper as LoginHelper
 8 | from Pages.PagePiece import PagePiece
 9 | 
10 | 
11 | class AuthChallengeHelper(PagePiece):
12 |     _AC_EMBEDDED_FRAME_POPUP_LOCATOR = (By.CSS_SELECTOR, 'div.popup-header')
13 | 
14 |     def __init__(self, driver: WebDriver):
15 |         super().__init__(driver=driver)
16 |         self._selenium = IASelenium(driver=self.driver)
17 |         self.perspective_login_helper = LoginHelper(driver=driver)
18 | 
19 |     def authenticate_with_ignition_idp_within_iframe(self, username: str, password: str) -> None:
20 |         self.switch_driver_to_embedded_frame()
21 |         try:
22 |             self.perspective_login_helper.log_in_through_login_page(username=username, password=password)
23 |         except AssertionError:
24 |             pass
25 |         self.switch_driver_back_to_page()
26 | 
27 |     def authenticate_with_ignition_idp_on_new_tab(self, username: str, password: str) -> None:
28 |         self._selenium.switch_to_tab_by_index(zero_based_index=1)
29 |         try:
30 |             self.perspective_login_helper.log_in_through_login_page(username=username, password=password)
31 |         except AssertionError:
32 |             pass
33 |         self._selenium.switch_to_tab_by_index(zero_based_index=0)
34 | 
35 |     def embedded_ac_login_popup_is_displayed(self) -> bool:
36 |         try:
37 |             return self.wait.until(ec.text_to_be_present_in_element(self._AC_EMBEDDED_FRAME_POPUP_LOCATOR, 'Login'))
38 |         except TimeoutException:
39 |             return False
40 | 
41 |     def switch_driver_to_embedded_frame(self, iframe_index: int = 0) -> None:
42 |         """
43 |         Point the webdriver to the content of the embedded iframe in order to interact with it.
44 |         """
45 |         self.driver.switch_to.frame(self.driver.find_elements(By.TAG_NAME, "iframe")[iframe_index])
46 | 
47 |     def switch_driver_back_to_page(self) -> None:
48 |         """
49 |         Point the driver back to the main page after switching to an iframe to authenticate.
50 |         """
51 |         self.driver.switch_to.default_content()
52 | 
53 |     def switch_driver_back_to_project_tab(self) -> None:
54 |         """
55 |         Point the driver back to the main project tab after switching toa new tab to authenticate.
56 |         """
57 |         self._selenium.switch_to_tab_by_index(zero_based_index=0)
58 | 


--------------------------------------------------------------------------------
/Helpers/PerspectivePages/PopupHelper.py:
--------------------------------------------------------------------------------
 1 | from selenium.common.exceptions import TimeoutException, NoSuchElementException
 2 | from selenium.webdriver.common.by import By
 3 | from selenium.webdriver.remote.webdriver import WebDriver
 4 | 
 5 | from Components.BasicComponent import ComponentPiece
 6 | from Helpers.CSSEnumerations import CSS
 7 | from Helpers.IAAssert import IAAssert
 8 | 
 9 | 
10 | class PopupHelper:
11 |     """
12 |     This helper is intended to help with Popups in a generalized capacity. It does not work for interacting with
13 |     or determining the state of specific Popups.
14 |     """
15 |     _CLOSE_ICON_LOCATOR = (By.CSS_SELECTOR, "svg.close-icon")
16 |     _GENERIC_POPUP_LOCATOR = (By.CSS_SELECTOR, "div.popup")
17 |     _MODAL_LOCATOR = (By.CSS_SELECTOR, "div.modal")
18 | 
19 |     def __init__(self, driver: WebDriver):
20 |         self.driver = driver
21 |         self._generic_popup = ComponentPiece(
22 |             locator=self._GENERIC_POPUP_LOCATOR,
23 |             driver=driver,
24 |             description="A generic definition of a Popup.",
25 |             wait_timeout=0)  # no parent
26 |         self._modal = ComponentPiece(
27 |             locator=self._MODAL_LOCATOR, driver=driver, parent_locator_list=None, wait_timeout=0)
28 | 
29 |     def close_all_popups(self) -> None:
30 |         """
31 |         Make an attempt to close all open Popups. This approach requires that each open Popup be configured to display
32 |         a close icon.
33 | 
34 |         :raises NoSuchElementException: If any of the open Popups does not have a close icon.
35 |         """
36 |         # find all popups
37 |         try:
38 |             list_of_popups = self._generic_popup.find_all(wait_timeout=1)
39 |             # now sort them so the "highest" is first.
40 |             popups_sorted_by_z_index = sorted(
41 |                 list_of_popups, key=lambda e: e.value_of_css_property(CSS.Z_INDEX.value), reverse=True)
42 |             # click the close icon for each popup
43 |             [popup.find_element(*self._CLOSE_ICON_LOCATOR).click() for popup in popups_sorted_by_z_index]
44 |         except NoSuchElementException as nsee:
45 |             raise NoSuchElementException(msg="Unable to close a Popup because it had no close icon present.") from nsee
46 |         except TimeoutException:
47 |             pass
48 |         IAAssert.is_equal_to(
49 |             actual_value=self.get_count_of_all_open_popups(),
50 |             expected_value=0,
51 |             failure_msg="We failed to close all open Popups.")
52 | 
53 |     def get_count_of_all_open_popups(self) -> int:
54 |         """
55 |         Obtain a count of how many Popups are currently displayed.
56 | 
57 |         :returns: A count of how many Popups are currently displayed.
58 |         """
59 |         try:
60 |             return len(self._generic_popup.find_all(wait_timeout=0))
61 |         except TimeoutException:
62 |             return 0
63 | 
64 |     def overlay_is_present(self) -> bool:
65 |         """
66 |         Determine if an overlay is present.
67 | 
68 |         :returns: True, if any Popup is displaying as a modal - False otherwise.
69 |         """
70 |         try:
71 |             return self._modal.find(wait_timeout=0) is not None
72 |         except TimeoutException:
73 |             return False
74 | 


--------------------------------------------------------------------------------
/Helpers/PerspectivePages/Quality.py:
--------------------------------------------------------------------------------
 1 | from enum import Enum
 2 | 
 3 | 
 4 | class PerspectiveQuality(Enum):
 5 |     """
 6 |     These "qualities" are representative of Perspective's handling of Ignition Quality Codes, and differ slightly
 7 |     from the normal wording (ie: "unknown" vs "uncertain"). These qualities are intended only to be used within the
 8 |     context of Perspective Pages, in order to assist with areas which must address or reference Qualities in
 9 |     Perspective or the Quality Overlays of Perspective Components.
10 |     """
11 |     ERROR = 'error'
12 |     UNKNOWN = 'unknown'
13 |     PENDING = 'pending'
14 | 


--------------------------------------------------------------------------------
/Helpers/Point.py:
--------------------------------------------------------------------------------
 1 | class Point:
 2 |     """
 3 |     A standard two-dimensional point within the DOM, consisting of both an X and Y coordinate. This location is
 4 |     understood to be pixels measured from the top-left corner of the Viewport of the browser.
 5 |     """
 6 | 
 7 |     def __init__(self, x: float, y: float):
 8 |         self.X = x
 9 |         self.Y = y
10 |         self._current_index = 0
11 |         self._items = [x, y]
12 | 
13 |     def __getitem__(self, index):
14 |         try:
15 |             return self._items[index]
16 |         except IndexError:
17 |             raise IndexError("Points only have two coordinates; supply an index in this range: -2<=N<=1.")
18 | 
19 |     def __iter__(self):
20 |         return self
21 | 
22 |     def __next__(self):
23 |         if self._current_index < 2:
24 |             coordinate_value = self._items[self._current_index]
25 |             self._current_index += 1
26 |             return coordinate_value
27 |         raise StopIteration
28 | 


--------------------------------------------------------------------------------
/Pages/BasicPageObject.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | from time import sleep
  3 | from typing import Tuple, Union
  4 | 
  5 | from selenium.common.exceptions import NoSuchElementException, TimeoutException, WebDriverException
  6 | from selenium.webdriver.common.by import By
  7 | from selenium.webdriver.remote.webdriver import WebDriver
  8 | from selenium.webdriver.support import expected_conditions as ec
  9 | from selenium.webdriver.support.ui import WebDriverWait
 10 | 
 11 | from Helpers.IAExpectedConditions import IAExpectedConditions as IAec
 12 | from Pages.PagePiece import PagePiece
 13 | 
 14 | 
 15 | class BasicPageObject(PagePiece):
 16 |     """
 17 |     This Page Object may be used to interact with any page outside of Ignition.
 18 |     """
 19 | 
 20 |     def __init__(
 21 |             self,
 22 |             driver: WebDriver,
 23 |             url: str,
 24 |             wait_timeout: float = 10,
 25 |             primary_locator: Tuple[Union[By, str], str] = None):
 26 |         """
 27 |         :param driver: The WebDriver in use for the browser window.
 28 |         :param url: The URL of this page.
 29 |         :param wait_timeout: The amount of time (in seconds) to implicitly wait.
 30 |         :param primary_locator: A Tuple which describes how to locate a unique element on the page, if there is one.
 31 |         """
 32 |         PagePiece.__init__(
 33 |             self,
 34 |             driver=driver,
 35 |             wait_timeout=wait_timeout,
 36 |             primary_locator=primary_locator)
 37 |         self.url = url
 38 |         self._navigation_string = f'Navigated to {self.url}'
 39 | 
 40 |     def navigate_to(self, force: bool = False) -> None:
 41 |         """
 42 |         Navigate to this page in the browser.
 43 | 
 44 |         :param force: Dictates whether the navigation should happen even if you are already on the page. Potentially
 45 |             forces a pseudo-refresh.
 46 |         """
 47 |         self._wait_on_driver()
 48 |         if force or not self.is_current_page():
 49 |             try:
 50 |                 for i in range(3):
 51 |                     self.driver.get(self.url)
 52 |                     if self.is_current_page():
 53 |                         break
 54 |             except WebDriverException as wde:
 55 |                 logging.error(f'Encountered a WebDriverException while attempting to navigate to {self.url} .\n'
 56 |                               f'The error was ignored and we are going to continue.\n'
 57 |                               f'{wde.msg}')
 58 |             self._log_navigation()
 59 |             self._wait_for_page()
 60 | 
 61 |     def get_page_url(self) -> str:
 62 |         """
 63 |         Obtain the configured URL of this page. To obtain the URL currently in use by the browser, use self.driver.url.
 64 | 
 65 |         :return: The URL configured for this Page resource.
 66 |         """
 67 |         return self.url
 68 | 
 69 |     def is_current_page(self) -> bool:
 70 |         """
 71 |         Determine if this Page is the page currently displayed in your browser tab.
 72 | 
 73 |         :return: True if the PageObject's URL matches the current URL, without any parameters. If the
 74 |             Page being checked has also specified a primary locator, this value also implies that the locator
 75 |             is present.
 76 |         """
 77 |         try:
 78 |             return WebDriverWait(driver=self.driver, timeout=3).until(IAec.function_returns_true(
 79 |                 custom_function=self._is_current_page,
 80 |                 function_args={}))
 81 |         except TimeoutException:
 82 |             return False
 83 | 
 84 |     def _is_current_page(self) -> bool:
 85 |         """
 86 |         Determine if the URL configured for this page resource matches the URL in use in the browser, sans any URL
 87 |             parameters.
 88 | 
 89 |         :return: True, if the PageObject's URL matches the current URL, without any parameters - False otherwise. If the
 90 |             Page being checked has also specified a primary locator, this value also implies that the locator
 91 |             is present.
 92 |         """
 93 |         # Home pages may or may not have a trailing slash, so naively strip any trailing slash
 94 |         page_url = self.url.rstrip('/')
 95 |         displayed_url = self.driver.current_url.split('?')[0].rstrip('/')
 96 |         # if no primary locator is supplied, naively assume that portion as succeeding
 97 |         primary_locator_check = self.primary_locator is None
 98 |         try:
 99 |             # if a primary locator WAS supplied, we must check it is present
100 |             if self.primary_locator is not None:
101 |                 primary_locator_check = self.driver.find_element(*self.primary_locator) is not None
102 |         except NoSuchElementException:
103 |             primary_locator_check = False
104 |         except WebDriverException:
105 |             primary_locator_check = False
106 |         return (page_url == displayed_url) and primary_locator_check
107 | 
108 |     def _log_navigation(self) -> None:
109 |         self.py_logger.info(msg=self._navigation_string)
110 | 
111 |     def _wait_for_page(self) -> None:
112 |         """
113 |         It's the responsibility of the inheriting class to Override this method if a better approach is available.
114 |         """
115 |         if self.primary_locator is not None:
116 |             try:
117 |                 self.wait.until(ec.presence_of_element_located(self.primary_locator))
118 |             except TimeoutException:
119 |                 pass
120 |             except WebDriverException:
121 |                 pass
122 |         else:
123 |             msg = f'This class ({self.__class__.__name__}) is using the default \'_wait_for_page\' ' \
124 |                   f'method in {BasicPageObject.__name__}.\n' \
125 |                   f'Check to see if there is a better way to wait for the page to load.'
126 |             logging.warning(msg)
127 |             sleep(3)  # hard-coded wait to be used when no primary locator is supplied.
128 | 
129 |     def _wait_on_driver(self, time_to_wait=3) -> None:
130 |         """
131 |         Wait for the webdriver to know about itself.
132 | 
133 |         :raise TimeoutException: If the driver takes too long to become usable.
134 |         """
135 |         try:
136 |             WebDriverWait(self.driver, time_to_wait).until(IAec.driver_is_ready(driver=self.driver))
137 |         except TimeoutException as toe:
138 |             raise TimeoutException(msg="The driver did not respond in a timely manner.") from toe
139 | 


--------------------------------------------------------------------------------
/Pages/IgnitionPageObject.py:
--------------------------------------------------------------------------------
 1 | from typing import Tuple
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Pages.BasicPageObject import BasicPageObject
 7 | 
 8 | 
 9 | class IgnitionPageObject(BasicPageObject):
10 |     """
11 |     The Ignition Page Object is intended to encompass the final pieces shared among all Pages which would belong to an
12 |     Ignition instance.
13 |     """
14 | 
15 |     def __init__(
16 |             self,
17 |             driver: WebDriver,
18 |             gateway_address: str,
19 |             destination_path: str,
20 |             wait_timeout: float = 10,
21 |             primary_locator: Tuple[By, str] = None):
22 |         """
23 |         :param driver: The WebDriver being used to control the browser.
24 |         :param gateway_address: The address (including port) of your Gateway. Expects scheme, all domains, and port.
25 |         :param destination_path: The "subdirectory" and "path" pieces of the URL of this page resource, including a
26 |             leading slash - eg: "/path/to/my/page"
27 |         :param wait_timeout: The amount of time (in seconds) this page resource should implicitly wait when needed.
28 |         :param primary_locator: A locator which describes an HTML element unique to this page.
29 |         """
30 |         self._PATH = destination_path
31 |         self.url = gateway_address + destination_path
32 |         BasicPageObject.__init__(
33 |             self, driver=driver, url=self.url, wait_timeout=wait_timeout, primary_locator=primary_locator)
34 | 


--------------------------------------------------------------------------------
/Pages/PagePiece.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | from typing import Tuple, Union
 3 | 
 4 | from selenium.common.exceptions import NoSuchElementException
 5 | from selenium.webdriver.common.by import By
 6 | from selenium.webdriver.remote.webdriver import WebDriver
 7 | from selenium.webdriver.support.ui import WebDriverWait
 8 | 
 9 | from Helpers.IASelenium import IASelenium
10 | 
11 | 
12 | class PagePiece(object):
13 |     """
14 |     A PagePiece is the smallest, most basic concept of any browser page. While pages in general are free to specify
15 |     any number of unique locators/Component/WebElements, Page Pieces are understood to build out collections of shared
16 |     structure which may be re-used across various scopes. Even Pages may be considered "Page Pieces" as they are a
17 |     collection of shared structures or pieces which are re-used.
18 |     """
19 | 
20 |     def __init__(
21 |             self,
22 |             driver: WebDriver,
23 |             wait_timeout: float = 10,
24 |             primary_locator: Tuple[Union[By, str], str] = None):
25 |         """
26 |         :param driver: The WebDriver instance which is controlling the browser.
27 |         :param wait_timeout: The amount of time this page should implicitly wait when using functions which would wait.
28 |         :param primary_locator: The locator which defines a known unique element within this content.
29 |         """
30 |         self.driver = driver
31 |         self._wait_timeout = wait_timeout
32 |         self.wait = WebDriverWait(self.driver, self._wait_timeout)
33 |         self.primary_locator = primary_locator
34 |         self.selenium = IASelenium(driver=self.driver)
35 |         self.py_logger = logging.getLogger(self.__class__.__name__)
36 | 
37 |     def is_present(self) -> bool:
38 |         """
39 |         Determine if this Page Piece is currently located within the Document Object Model (DOM).
40 | 
41 |         :return: True, if the Page Piece could be located - False otherwise.
42 | 
43 |         :raises AssertionError: If no primary locator was supplied for the Page Piece. A locator is required for
44 |             checking for the presence of the Page Piece.
45 |         """
46 |         assert self.primary_locator is not None, "Unable to check presence of view without a primary locator."
47 |         try:
48 |             return self.driver.find_element(*self.primary_locator) is not None
49 |         except NoSuchElementException:
50 |             return False
51 | 


--------------------------------------------------------------------------------
/Pages/Perspective/PrintPreviewPage.py:
--------------------------------------------------------------------------------
 1 | from selenium.common.exceptions import TimeoutException
 2 | from selenium.webdriver.common.by import By
 3 | from selenium.webdriver.remote.webdriver import WebDriver
 4 | 
 5 | from Components.BasicComponent import ComponentPiece
 6 | 
 7 | 
 8 | class ChromePrintPreviewPage:
 9 |     """Interface for the print preview page implemented in Chrome."""
10 |     CANCEL_BUTTON_LOCATOR = (By.CSS_SELECTOR, 'div.controls > cr-button.cancel-button')
11 |     PRINT_PREVIEW_APP_LOCATOR = (By.CSS_SELECTOR, 'print-preview-app')
12 |     PRINT_PREVIEW_BUTTON_STRIP_LOCATOR = (By.CSS_SELECTOR, 'print-preview-button-strip')
13 |     SIDE_BAR_LOCATOR = (By.ID, 'sidebar')
14 | 
15 |     def __init__(self, driver: WebDriver):
16 |         self._driver = driver
17 |         self._print_preview_app = ComponentPiece(
18 |             locator=self.PRINT_PREVIEW_APP_LOCATOR,
19 |             driver=driver,
20 |             parent_locator_list=None,
21 |             wait_timeout=1,
22 |             poll_freq=0)
23 | 
24 |     def click_cancel_button(self, wait_timeout: float = 1) -> None:
25 |         """
26 |         Closes the print preview page.
27 |         When the page is closed, the print preview's window handle will be invalid.
28 |         This resource does not attempt to manage driver windows, so they will need to be handled elsewhere.
29 | 
30 |         :param wait_timeout: The amount of time (in seconds) to wait for the print preview tag to appear before
31 |             returning.
32 | 
33 |         """
34 |         self._print_preview_app.find(wait_timeout=wait_timeout).shadow_root.find_element(*self.SIDE_BAR_LOCATOR) \
35 |             .shadow_root.find_element(*self.PRINT_PREVIEW_BUTTON_STRIP_LOCATOR).shadow_root \
36 |             .find_element(*self.CANCEL_BUTTON_LOCATOR).click()
37 | 
38 |     def print_preview_page_is_open(self, wait_timeout: float = 1) -> bool:
39 |         """
40 |         Checks if the print preview page is open by attempting to find the print-preview-app tag in the DOM.
41 | 
42 |         :param wait_timeout: The amount of time (in seconds) to wait for the print preview tag to appear
43 |             before returning.
44 | 
45 |         :returns: True, if the print-preview-app tag can be located within the timeout window - False otherwise.
46 |         """
47 |         try:
48 |             return self._print_preview_app.find(wait_timeout=wait_timeout) is not None
49 |         except TimeoutException:
50 |             return False
51 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/Forbidden.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.common.by import By
 2 | from selenium.webdriver.remote.webdriver import WebDriver
 3 | from selenium.webdriver.support import expected_conditions as ec
 4 | 
 5 | from Pages.Perspective.TerminalStates.TerminalStatePageObject import TerminalStatePageObject
 6 | 
 7 | 
 8 | class Forbidden(TerminalStatePageObject):
 9 |     """
10 |     The Forbidden Terminal State Page is to be expected when a user does not have the Security Level required by a
11 |     project.
12 |     """
13 |     _SIGN_OUT_BUTTON_LOCATOR = (By.CSS_SELECTOR, 'a.terminal-state-link-inverted')
14 | 
15 |     def __init__(self, driver: WebDriver):
16 |         super().__init__(
17 |             driver=driver,
18 |             expected_page_header_text='Forbidden')
19 | 
20 |     def click_sign_out(self) -> None:
21 |         """
22 |         Click the Sign Out button.
23 |         """
24 |         self.wait.until(
25 |             ec.presence_of_element_located(
26 |                 self._SIGN_OUT_BUTTON_LOCATOR)).click()
27 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/LoggedOut.py:
--------------------------------------------------------------------------------
 1 | from selenium.common.exceptions import TimeoutException
 2 | from selenium.webdriver.common.by import By
 3 | from selenium.webdriver.remote.webdriver import WebDriver
 4 | from selenium.webdriver.support import expected_conditions as ec
 5 | 
 6 | from Pages.Perspective.TerminalStates.TerminalStatePageObject import TerminalStatePageObject
 7 | 
 8 | 
 9 | class LoggedOut(TerminalStatePageObject):
10 |     """
11 |     The Logged Out Terminal State Page is expected when a user has logged out of a project and that project requires
12 |     Authentication. Projects which do not require authentication typically log the user out but leave them on
13 |     whichever page they were on before having been logged out.
14 |     """
15 |     _LOGGER_NAME = 'LoggedOutTerminalStatePage'
16 |     _BACK_BUTTON_LOCATOR = (By.CSS_SELECTOR, 'a.terminal-state-link')
17 | 
18 |     def __init__(self, driver: WebDriver):
19 |         super().__init__(
20 |             driver=driver,
21 |             expected_page_header_text='Logged Out')
22 | 
23 |     def click_back_button(self) -> None:
24 |         """
25 |         Click the BACK button. This should take the user to the interstitial "Continue to log in" Page.
26 |         """
27 |         self.wait.until(
28 |             ec.presence_of_element_located(
29 |                 self._BACK_BUTTON_LOCATOR)).click()
30 |         try:
31 |             self.wait.until(ec.invisibility_of_element_located(self._BACK_BUTTON_LOCATOR))
32 |         except TimeoutException:
33 |             pass
34 | 
35 |     def click_launch_gateway(self) -> None:
36 |         """
37 |         :raise NotImplementedError: The LoggedOut Terminal State Page does not have a Launch Gateway button.
38 |         """
39 |         raise NotImplementedError("The LoggedOut Page does not have a Launch Gateway button.")
40 | 
41 |     def get_launch_gateway_button_text(self) -> str:
42 |         """
43 |         :raise NotImplementedError: The LoggedOut Terminal State Page does not have a Launch Gateway button.
44 |         """
45 |         raise NotImplementedError("The LoggedOut Page does not have a Launch Gateway button.")
46 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/MobileLicense.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.common.by import By
 2 | from selenium.webdriver.remote.webdriver import WebDriver
 3 | 
 4 | from Pages.Perspective.TerminalStates.TerminalStatePageObject import TerminalStatePageObject
 5 | 
 6 | 
 7 | class MobileLicense(TerminalStatePageObject):
 8 |     """
 9 |     The MobileLicense Page is to be expected when the applied license of the Gateway only allows for Perspective to be
10 |     accessed via mobile device.
11 |     """
12 |     _SIGN_OUT_BUTTON_LOCATOR = (By.CSS_SELECTOR, 'a.terminal-state-link-inverted')
13 |     _MESSAGE_LOCATOR = (By.CSS_SELECTOR, 'section.new-trial p')
14 | 
15 |     def __init__(self, driver: WebDriver):
16 |         super().__init__(
17 |             driver=driver,
18 |             expected_page_header_text='Mobile License Only')
19 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/PageClosed.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.remote.webdriver import WebDriver
 2 | 
 3 | from Pages.Perspective.TerminalStates.TerminalStatePageObject import TerminalStatePageObject
 4 | 
 5 | 
 6 | class PageClosed(TerminalStatePageObject):
 7 |     """
 8 |     The PageClosed Terminal State Page is to be expected when a PerspectivePage has been forcibly closed by the
 9 |     Gateway.
10 |     """
11 | 
12 |     def __init__(self, driver: WebDriver):
13 |         super().__init__(
14 |             driver=driver,
15 |             expected_page_header_text='Page Closed')
16 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/ProjectNotFound.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.remote.webdriver import WebDriver
 2 | 
 3 | from Pages.Perspective.TerminalStates.TerminalStatePageObject import TerminalStatePageObject
 4 | 
 5 | 
 6 | class ProjectNotFound(TerminalStatePageObject):
 7 |     """
 8 |     The ProjectNotFound Terminal State Page is only expected to be present when a project is deleted from the Gateway
 9 |     while an active Perspective Session was using a Page from the deleted project. In general, attempts to visit a
10 |     project which does not exist will instead encounter a generic 404 page.
11 |     """
12 | 
13 |     def __init__(self, driver: WebDriver):
14 |         super().__init__(
15 |             driver=driver,
16 |             expected_page_header_text='Project Not Found')
17 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/ProjectNotRunnable.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.remote.webdriver import WebDriver
 2 | 
 3 | from Pages.Perspective.TerminalStates.TerminalStatePageObject import TerminalStatePageObject
 4 | 
 5 | 
 6 | class ProjectNotRunnable(TerminalStatePageObject):
 7 |     """
 8 |     The ProjectNotRunnable Terminal State Page is to be expected when a user attempts to visit any path which would
 9 |     belong to a project that is configured as not runnable (inheritable, or disabled).
10 |     """
11 | 
12 |     def __init__(self, driver: WebDriver):
13 |         super().__init__(
14 |             driver=driver,
15 |             expected_page_header_text='Project Not Runnable')
16 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/SessionClosed.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.remote.webdriver import WebDriver
 2 | 
 3 | from Pages.Perspective.TerminalStates.TerminalStatePageObject import TerminalStatePageObject
 4 | 
 5 | 
 6 | class SessionClosed(TerminalStatePageObject):
 7 |     """
 8 |     The SessionClosed Terminal State Page is to be expected when the Gateway has forcibly closed an entire Session.
 9 |     """
10 | 
11 |     def __init__(self, driver: WebDriver):
12 |         super().__init__(
13 |             driver=driver,
14 |             expected_page_header_text='Session Closed')
15 | 


--------------------------------------------------------------------------------
/Pages/Perspective/TerminalStates/TerminalStatePageObject.py:
--------------------------------------------------------------------------------
  1 | from typing import Union
  2 | 
  3 | from selenium.common.exceptions import TimeoutException, NoSuchElementException
  4 | from selenium.webdriver.common.by import By
  5 | from selenium.webdriver.remote.webdriver import WebDriver
  6 | from selenium.webdriver.support import expected_conditions as ec
  7 | 
  8 | from Components.BasicComponent import BasicComponent, ComponentPiece
  9 | from Helpers.CSSEnumerations import CSS, CSSPropertyValue
 10 | from Pages.PagePiece import PagePiece
 11 | 
 12 | 
 13 | class TerminalStatePageObject(PagePiece):
 14 |     """
 15 |     The over-arching ancestor of all Terminal State Pages.
 16 |     """
 17 |     _HEADER_LOCATOR = (By.CSS_SELECTOR, 'h1.terminal-state-header')
 18 |     _MESSAGE_LOCATOR = (By.CSS_SELECTOR, 'section.terminal-state-section p')
 19 |     _LAUNCH_GATEWAY_ANCHOR_LOCATOR = (By.CSS_SELECTOR, 'a.terminal-state-link')
 20 | 
 21 |     def __init__(
 22 |             self,
 23 |             driver: WebDriver,
 24 |             expected_page_header_text: str):
 25 |         PagePiece.__init__(
 26 |             self,
 27 |             driver=driver,
 28 |             primary_locator=self._HEADER_LOCATOR)
 29 |         self._expected_page_header_text = expected_page_header_text
 30 |         self._main_body = ComponentPiece(
 31 |             locator=(By.CSS_SELECTOR, "div.terminal-state-page"),
 32 |             driver=driver)
 33 |         self._launch_gateway_button = BasicComponent(
 34 |             locator=self._LAUNCH_GATEWAY_ANCHOR_LOCATOR,
 35 |             driver=driver)
 36 | 
 37 |     def click_launch_gateway(self) -> None:
 38 |         """
 39 |         Click the Launch Gateway button.
 40 |         """
 41 |         self._launch_gateway_button.click()
 42 | 
 43 |     def get_background(self) -> str:
 44 |         """
 45 |         Obtain the background in use for this Terminal State Page.
 46 | 
 47 |         :return: While using Branding Customization, this returns a hex color (as a string) - otherwise a path to the
 48 |             gradient image.
 49 |         """
 50 |         return self._main_body.get_css_property(property_name=CSS.BACKGROUND_COLOR)
 51 | 
 52 |     def get_launch_gateway_css_property(self, property_name: Union[CSSPropertyValue, str]) -> str:
 53 |         """
 54 |         Obtain some CSS property of the Launch Gateway button.
 55 | 
 56 |         :param property_name: The name of the CSS property you would like the value of.
 57 | 
 58 |         :return: The value of the specified CSS property as applied to the Launch Gateway button.
 59 |         """
 60 |         return self._launch_gateway_button.get_css_property(property_name=property_name)
 61 | 
 62 |     def get_message(self) -> str:
 63 |         """
 64 |         Obtain the message displayed for this Terminal State Page.
 65 | 
 66 |         :return: The message displayed by this Terminal State Page.
 67 |         """
 68 |         return self.wait.until(
 69 |             method=ec.presence_of_element_located(self._MESSAGE_LOCATOR),
 70 |             message="No message found on Terminal State page.").text
 71 | 
 72 |     def get_header_text(self) -> str:
 73 |         """
 74 |         Obtain the header text displayed for this Terminal State Page.
 75 | 
 76 |         :return: The header text displayed by this Terminal State Page.
 77 |         """
 78 |         return self.wait.until(
 79 |             method=ec.presence_of_element_located(self._HEADER_LOCATOR),
 80 |             message="No header found on Terminal State page.").text.strip()
 81 | 
 82 |     def get_launch_gateway_button_text(self) -> str:
 83 |         """
 84 |         Obtain the text of the Launch Gateway button.
 85 | 
 86 |         :return: The text of the Launch Gateway button.
 87 |         """
 88 |         return self._launch_gateway_button.find().text.strip()
 89 | 
 90 |     def get_text_color(self) -> str:
 91 |         """
 92 |         Obtain the color in use for the text of the body of this Terminal State Page.
 93 | 
 94 |         :return: The color in use for the text of the body of this Terminal State Page.
 95 |         """
 96 |         return self._main_body.get_css_property(property_name=CSS.COLOR)
 97 | 
 98 |     def launch_gateway_button_is_present(self) -> bool:
 99 |         """
100 |         Determine if this page contains a Launch Gateway button.
101 | 
102 |         :return: True, if the Launch Gateway button is present - False otherwise.
103 |         """
104 |         try:
105 |             return self.driver.find_element(*self._LAUNCH_GATEWAY_ANCHOR_LOCATOR) is not None
106 |         except NoSuchElementException:
107 |             return False
108 | 
109 |     def wait_for_terminal_state_page(self) -> bool:
110 |         """
111 |         Wait for the Terminal State Page to load, but allow code to continue in the event the page does not load.
112 |         """
113 |         try:
114 |             return self.wait.until(method=ec.presence_of_element_located(self._HEADER_LOCATOR)) is not None
115 |         except TimeoutException:
116 |             return False
117 | 
118 |     def is_current_page(self) -> bool:
119 |         """
120 |         Determine if this Terminal State Page is the currently displayed page.
121 | 
122 |         :return: True, if the header text of this page is what we would expect to find - False otherwise.
123 |         """
124 |         try:
125 |             return self.driver.find_element(*self.primary_locator).text == self._expected_page_header_text
126 |         except NoSuchElementException:
127 |             return False
128 | 


--------------------------------------------------------------------------------
/Pages/Perspective/View.py:
--------------------------------------------------------------------------------
 1 | from typing import Tuple, Optional
 2 | 
 3 | from selenium.webdriver.common.by import By
 4 | from selenium.webdriver.remote.webdriver import WebDriver
 5 | 
 6 | from Pages.PagePiece import PagePiece
 7 | 
 8 | 
 9 | class View(PagePiece):
10 |     """
11 |     "View" is a Perspective concept of a displayed container which does NOT have to be a page.
12 |     Views can have components and properties, but they MUST NEVER have a URL path. Headers and Footers are examples
13 |     of "Docked" Views, as they are anchored to a location and are visible (potentially across many pages),
14 |     yet you can never visit a header/footer by navigating to it via URL. Views are essentially identical to
15 |     PageComponents, and are only used instead of PageComponents for clarity.
16 |     """
17 | 
18 |     def __init__(
19 |             self,
20 |             driver: WebDriver,
21 |             primary_locator: Tuple[By, str] = None,
22 |             view_resource_path: Optional[str] = None,
23 |             wait_timeout: float = 10):
24 |         """
25 |         :param driver: The WebDriver in use for the browser window.
26 |         :param primary_locator: The primary locator used to identify a component of the View. This will be the same as
27 |             the `root_id` in most cases.
28 |         :param view_resource_path: The path to the View within the Designer, after `Perspective/Views`.
29 |         :param wait_timeout: The amount of time this resource should implicitly wait when querying.
30 |         """
31 |         PagePiece.__init__(
32 |             self,
33 |             driver=driver,
34 |             primary_locator=primary_locator,
35 |             wait_timeout=wait_timeout)
36 |         self._view_resource_path = view_resource_path
37 | 
38 |     def get_view_resource_path(self) -> Optional[str]:
39 |         return self._view_resource_path
40 | 


--------------------------------------------------------------------------------
/Pages/Perspective/ViewCanvasInstancedView.py:
--------------------------------------------------------------------------------
  1 | from typing import Tuple
  2 | 
  3 | from selenium.webdriver.common.by import By
  4 | from selenium.webdriver.remote.webdriver import WebDriver
  5 | from selenium.webdriver.remote.webelement import WebElement
  6 | 
  7 | from Components.BasicComponent import BasicPerspectiveComponent
  8 | from Helpers.CSSEnumerations import CSS
  9 | from Helpers.Point import Point
 10 | from Pages.Perspective.View import View
 11 | 
 12 | 
 13 | class ViewCanvasInstancedView(View):
 14 |     """
 15 |     View Canvas Instanced Views are extremely similar to regular Views except the expectation is that each Instanced
 16 |     View have a unique locator at the root node and that each instance may have different positioning attributes
 17 |     applied.
 18 |     """
 19 | 
 20 |     def __init__(
 21 |             self,
 22 |             driver: WebDriver,
 23 |             root_locator: Tuple,
 24 |             view_resource_path: str = None):
 25 |         """
 26 |         :param driver: The WebDriver in use for the browser window.
 27 |         :param root_locator: The CSS locator of the root node of the View. XPATH is not allowed.
 28 |         :param view_resource_path: The path to the View within the Designer, after `Perspective/Views`.
 29 |         """
 30 |         View.__init__(
 31 |             self,
 32 |             driver=driver,
 33 |             primary_locator=root_locator,
 34 |             view_resource_path=view_resource_path)
 35 |         self._root = BasicPerspectiveComponent(
 36 |             locator=root_locator,
 37 |             driver=driver)
 38 | 
 39 |     def get_z_index(self) -> int:
 40 |         """
 41 |         Obtain the z-index in use by this instance of the View.
 42 | 
 43 |         :returns: The z-index in use by this Instanced View.
 44 |         
 45 |         :raises TimeoutException: If the root node (and therefore the View) is not found in the DOM.
 46 |         """
 47 |         return int(self._get_wrapper_div().value_of_css_property(property_name=CSS.Z_INDEX.value))
 48 | 
 49 |     def get_height(self, include_units: bool = False) -> str:
 50 |         """
 51 |         Get the computed height of the root node. Must return as a string because of the possibility of included units.
 52 | 
 53 |         :param include_units: Include the units of height (typically "px") if True, otherwise return only the numeric
 54 |             value (as a str).
 55 | 
 56 |         :returns: The computed height of the root node as a string.
 57 | 
 58 |         :raises TimeoutException: If the root node (and therefore the View) is not found in the DOM.
 59 |         """
 60 |         return self._root.get_computed_height(include_units=include_units)
 61 | 
 62 |     def get_width(self, include_units: bool = False) -> str:
 63 |         """
 64 |         Get the computed width of the root node. Must return as a string because of the possibility of included units.
 65 | 
 66 |         :param include_units: Include the units of width (typically "px") if True, otherwise return only the numeric
 67 |             value (as a str).
 68 | 
 69 |         :returns: The computed width of the root node as a string.
 70 | 
 71 |         :raises TimeoutException: If the root node (and therefore the View) is not found in the DOM.
 72 |         """
 73 |         return self._root.get_computed_width(include_units=include_units)
 74 | 
 75 |     def get_origin(self) -> Point:
 76 |         """
 77 |         Get the Cartesian Coordinate of the upper-left corner of the root node, measured from the
 78 |         top-left of the viewport.
 79 | 
 80 |         :returns: The Cartesian Coordinate of the upper-left corner of the root node, measured from the
 81 |             top-left of the viewport.
 82 | 
 83 |         :raises TimeoutException: If the root node (and therefore the View) is not found in the DOM.
 84 |         """
 85 |         return self._root.get_origin()
 86 | 
 87 |     def is_using_absolute_position(self) -> bool:
 88 |         """
 89 |         Determine if this instance of the View is using absolute positioning (as opposed to relative).
 90 | 
 91 |         :returns: True, if this instance of the View is using absolute positioning - False otherwise.
 92 | 
 93 |         :raises TimeoutException: If the root node (and therefore the View) is not found in the DOM.
 94 |         """
 95 |         return self._get_wrapper_div().value_of_css_property(property_name=CSS.POSITION.value) == 'absolute'
 96 | 
 97 |     def _get_wrapper_div(self) -> WebElement:
 98 |         """
 99 |         Obtain the wrapper <div> as a WebElement.
100 | 
101 |         :returns: The actual WebElement which is the wrapper of the `root` node.
102 | 
103 |         :raises TimeoutException: If the root node (and therefore the View) is not found in the DOM.
104 |         """
105 |         return self._root.find().find_element(By.XPATH, '..')
106 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Perspective Project Automation
 2 | The content located in this repo is intended to assist with automated testing of Perspective Sessions. It consists of 
 3 | various libraries used to interact with all levels of Sessions - from Components to Pages and any pieces of those pages.
 4 | This content is NOT supported as part of any Inductive Automation support plan, and so the Inductive Automation Support 
 5 | team will not be able to assist you with any questions. If you do have questions, the Inductive Automation 
 6 | [forums](https://forum.inductiveautomation.com/c/automated-testing/) are your best option.
 7 | 
 8 | ## Components:
 9 | This repository contains a near 1:1 collection of Perspective components, excluding only those components for which no 
10 | benefit would be gained from automated testing.
11 | 
12 | Reasons for component or feature exclusion:
13 | - Pure `<svg>` components or features are impossible to extrapolate data from.
14 | - 3rd party libraries leveraged for some components do not expose/emit their calculated data.
15 | 
16 | Omitted components:
17 | 1. Chart Range Selector
18 | 2. Gauge
19 | 3. Simple Gauge
20 | 4. Breakpoint (Container)
21 | 5. Flex (Container)
22 | 6. Moving Analog Indicator
23 | 7. PDF Viewer
24 | 8. Sparkline
25 | 
26 | ## Helpers:
27 | The Helpers contained in this repository allow for specialized interaction in the following areas of your testing:
28 | - Selenium
29 | - Perspective Components
30 | - Standardized assertions
31 | 
32 | Noteworthy Helpers:
33 | - IAAssert: A standardized way to assert conditions throughout your framework.
34 | - IASelenium: Specialized handling of common Selenium interactions within Perspective.
35 | - PerspectivePages/*: Specialized handling of Perspective Page content, like Docked Views, Popups, and Login.
36 | 
37 | ## Pages:
38 | These page objects should be used as parent classes for any pages/resources you create.
39 | 
40 | Some important terminology:
41 | - Page: Some web resource which may be visited via URL.
42 | - View: A Perspective View
43 | - Page Piece: Some small portion of a page which has a defined structure and may be independently referenced across 
44 | multiple pages.
45 | 
46 | There *is* a slight disconnect between how Views and Pages are defined in automation projects and the Ignition Designer, 
47 | and so the recommended approach is as follows...
48 | 
49 | When creating a new resource for automation, create it with a View parent class. In the event you are defining a 
50 | Perspective Page, import the previously defined View resource, then initialize the View within the PerspectivePage 
51 | `__init__()` step, and then supply the `super().__init__()` call with the relevant information of the View.
52 | 
53 | Additionally, it is impossible to implement a navigation paradigm that works across all projects, so navigation has 
54 | intentionally not been implemented. We highly advise against using Selenium's built-in `get(url)` function as this 
55 | results in an HTTP request being made; Perspective is a Single Page Application, and HTTP requests will actually result 
56 | in a new Page being created for the Session, instead of allowing Perspective to perform the navigation on the back-end.
57 | When implementing your own navigation, instead of thinking about this process as "How do I get to PageX?", think of the 
58 | navigation as "How does PageA navigate me to PageX?" The answer is that you should use whatever mechanisms a human user
59 | of the Session would use. If the user would click a link, then you should use that same link. If they would use a Horizontal
60 | menu, then your Page (PageA) should use that same mechanism to perform the navigation. Instead of something like
61 | `self.page_x.navigate_to()`, you'll have something like `self.page_a.navigate_to(self.page_x)` - where PageA understands 
62 | what needs to be done to navigate to the supplied page.
63 | 
64 | Your first steps when beginning to use this content should be to provide your own file and class which will be your
65 | internal wrapper for PerspectivePageObject. Your class should inherit from PerspectivePageObject and provide an avenue
66 | for supplying the superclass PerspectivePageObject with a path built from the project name and the configured URL
67 | for the page: `/<project_name>/some/path/to/page`
68 | 
69 | ## General rules this content attempts to follow:
70 | 1. Getters - Functions which would be used to obtain information about a page or component should begin with `get_`, and they should wait only long enough to locate the target before immediately returning the state or value. There are two exceptions to this: `wait_` functions, which will actually wait for some condition to be met before returning; and `is_` functions, which return information about some boolean state. While it is true that the `is_` functions could be written as something like `get_state`, that approach falls apart when used to check against something like the expansion state of a Dropdown; `is_expanded()` is superior to `get_expansion_state()`.
71 | 2. Setters - Functions which interact with a session or component in some way (`set_`) do not return any value. Still, there is an expectation that setting some value should always take, and so nearly all setter functions will raise an `AssertionError` if they fail to apply some value or state. The only instances which do not raise an `AssertionError` are those instances for which it would be impossible to determine the expected state or value (like some Date component functions). For instances where you expect a setter to encounter some value other than what you have supplied (due to translations, permissions, or formatting) you should wrap the setter in a try/except block and capture the `AssertionError`, then ignore it.
72 | 3. Waits - Functions which should wait for some condition to be met before returning (`wait_on_xxxxx`) will wait up to some period of time for that condition to be met before returning the current value. In the event the condition is not met before the waiting period has elapsed, the function will still return the current value or state so that you can compare the expected to the actual.


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | selenium==4.10.0
2 | 


--------------------------------------------------------------------------------