Skip to content

Site Element

SiteElement class improves organization of site element parameters. The class methods faciltate easy manipulation of these elements

SiteElement

Defines site elements in a structured way and provides a convenient means for element manipulations (clicking, entering text, etc.)

Source code in cuahsi_base/site_element.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
class SiteElement:
    """Defines site elements in a structured way and provides a convenient
    means for element manipulations (clicking, entering text, etc.)
    """

    def __init__(self, by, locator):
        self.by = by
        self.locator = locator

    def loc_it(self, driver):
        """
        Identifies element on page, based on an element locator.
        Waits until an element becomes available & visible in DOM, and
        then until it becomes clickable.
        """
        wait = WebDriverWait(driver, 10)
        try:
            wait.until(EC.visibility_of_element_located((self.by, self.locator)))
            target_el = wait.until(EC.element_to_be_clickable((self.by, self.locator)))
        except TimeoutException as e:
            print(
                "\nUnable to locate element by {}, "
                "locator: '{}'".format(self.by, self.locator)
            )
            raise e

        return target_el

    def loc_hidden(self, driver, silent=False):
        """
        Identifies potentially hidden element on page, based on an element locator.
        """
        wait = WebDriverWait(driver, 10)
        try:
            target_el = wait.until(
                EC.presence_of_element_located((self.by, self.locator))
            )
        except TimeoutException as e:
            if not silent:
                print(
                    "\nUnable to locate element by {}, "
                    "locator: '{}'".format(self.by, self.locator)
                )
            raise e

        return target_el

    def exists(self, driver):
        """
        Checks if element is visible on the page.
        """
        wait = WebDriverWait(driver, 3)
        try:
            wait.until(EC.visibility_of_element_located((self.by, self.locator)))
            target_el = wait.until(EC.element_to_be_clickable((self.by, self.locator)))
            return True
        except TimeoutException:
            return False

    def exists_in_dom(self, driver):
        """
        Checks if element exists within the DOM.
        """
        wait = WebDriverWait(driver, 3)
        try:
            wait.until(EC.presence_of_element_located((self.by, self.locator)))
            return True
        except TimeoutException:
            return False

    def is_visible(self, driver):
        """
        Checks if element is visible on the page.
        """
        target_el = driver.find_element(self.by, self.locator)
        return target_el.is_displayed()

    def is_selected(self, driver):
        """
        Checks if element is visible on the page.
        """
        target_el = driver.find_element(self.by, self.locator)
        return target_el.is_selected()

    def click(self, driver):
        """Identifies an element on the page.  After identification
        the element is then clicked.
        """
        target_el = self.loc_it(driver)
        target_el.click()

    def double_click(self, driver):
        """
        Double click on element.
        """
        target_el = self.loc_it(driver)
        actionchains = ActionChains(driver)
        actionchains.double_click(target_el).perform()

    def javascript_click(self, driver):
        """
        Clicks an element using JavaScript
        """
        target_el = self.loc_it(driver)
        driver.execute_script("arguments[0].click();", target_el)

    def javascript_click_hidden(self, driver, silent=False):
        """
        Simulate click on a hidden element using JavaScript
        """
        target_el = self.loc_hidden(driver, silent)
        driver.execute_script("arguments[0].click();", target_el)

    def javascript_fill_hidden_text(self, driver, text):
        """
        Set text using JavaScript for a potentially hidden element
        """
        target_el = self.loc_hidden(driver)
        driver.execute_script(f'arguments[0].value="{text}";', target_el)

    def submit(self, driver):
        """Send ENTER to element, simulates submit"""
        target_el = self.loc_it(driver)
        target_el.send_keys(Keys.ENTER)

    def submit_hidden(self, driver):
        """Send ENTER to element that is perhaps hidden,
        simulates submit
        """
        actions = ActionChains(driver)
        actions.key_down(Keys.ENTER)
        actions.key_up(Keys.ENTER)
        actions.perform()

    def multi_click(self, driver):
        """Clicks an element while holding the control key, as to enable
        a multi-selection
        """
        target_el = self.loc_it(driver)
        actions = ActionChains(driver)
        actions.move_to_element(target_el)
        actions.key_down(Keys.LEFT_CONTROL)
        actions.click(target_el)
        actions.key_up(Keys.LEFT_CONTROL)
        actions.perform()

    def range_click(self, driver):
        """Clicks an element while holding the control key, as to enable
        a range selection
        """
        target_el = self.loc_it(driver)
        actions = ActionChains(driver)
        actions.move_to_element(target_el)
        actions.key_down(Keys.LEFT_SHIFT)
        actions.click(target_el)
        actions.key_up(Keys.LEFT_SHIFT)
        actions.perform()

    def passive_click(self, driver):
        """Identifies an element on the page.  After identification
        the element is then clicked, regardless if it is "interactable"
        or not
        """
        target_el = self.loc_it(driver)
        ActionChains(driver).move_to_element(target_el).click(target_el).perform()

    def clear_all_text(self, driver):
        """Uses the Ctrl+A keys combination to select all text before using
        BACKSPACE key to delete it
        """
        target_el = self.loc_it(driver)
        if platform.system() == "Darwin":  # MacOs
            ctrl_key = Keys.COMMAND
        else:
            ctrl_key = Keys.CONTROL
        ActionChains(driver).move_to_element(target_el).key_down(ctrl_key).send_keys(
            "a"
        ).key_up(ctrl_key).send_keys(Keys.BACKSPACE).perform()

    def clear_text(self, driver, size):
        """Uses backspace to clear text from a field"""
        target_el = self.loc_it(driver)
        target_el.send_keys(Keys.END)
        for i in range(0, size):
            target_el.send_keys(Keys.BACK_SPACE)

    def select_option(self, driver, select_choice):
        """Selects an option from a dropdown element"""
        target_el = self.loc_it(driver)
        select_el = Select(target_el)
        select_el.select_by_value(select_choice)

    def select_option_text(self, driver, select_choice):
        """Selects an option from dropdown given visible text"""
        target_el = self.loc_it(driver)
        select_el = Select(target_el)
        select_el.select_by_visible_text(select_choice)

    def scroll_to_hidden(self, driver):
        """After element identification, the window is scrolled
        such that the element becomes visible in the window
        """
        target_el = self.loc_hidden(driver)
        target_el.location_once_scrolled_into_view

    def scroll_to(self, driver):
        """After element identification, the window is scrolled
        such that the element becomes visible in the window
        """
        target_el = self.loc_it(driver)
        target_el.location_once_scrolled_into_view

    def scroll_right(self, driver):
        """Scroll right using Keys.ARROW_RIGHT
        and a hold of one second
        """
        target_el = self.loc_it(driver)
        actions = ActionChains(driver)
        actions.move_to_element(target_el)
        actions.key_down(Keys.ARROW_RIGHT)
        actions.perform()
        time.sleep(1)
        actions = ActionChains(driver)
        actions.key_up(Keys.ARROW_RIGHT)
        actions.perform()

    def inject_text(self, driver, field_text):
        """Enters text into a field or other input-capable html
        element using send keys
        """
        target_el = self.loc_it(driver)
        for i in range(0, len(field_text)):
            target_el.send_keys(field_text[i])

    def hidden_inject_text(self, driver, field_text):
        """Enters text into a field or other input-capable html
        element that is hidden using send keys
        """
        target_el = self.loc_hidden(driver)
        for i in range(0, len(field_text)):
            target_el.send_keys(field_text[i])

    def send_caps(self, driver, field_text):
        """Enters capitalized text into a field or other input-capable
        html element using send_keys_to_element
        """
        actionchains = ActionChains(driver)
        target_el = self.loc_it(driver)
        actionchains.key_down(Keys.SHIFT).send_keys_to_element(
            target_el, field_text
        ).key_up(Keys.SHIFT).perform()

    def set_path(self, driver, field_text):
        """Enters text into a field or other input-capable html
        element using send keys, best for setting path to files for upload
        """
        target_el = self.loc_it(driver)
        target_el.send_keys(field_text)

    def iframe_in(self, driver):
        """Switches driver focus to an iframe within a page"""
        target_el = self.loc_it(driver)
        driver.switch_to.frame(target_el)

    def iframe_out(self, driver):
        """Switches driver focus out of iframe and back to the
        main page
        """
        driver.switch_to.parent_frame()

    def get_attribute(self, driver, attribute):
        """Returns any attribute of website element"""
        target_el = self.loc_it(driver)
        return target_el.get_attribute(attribute)

    def get_attribute_hidden(self, driver, attribute):
        """Returns any attribute of website element"""
        target_el = self.loc_hidden(driver)
        return target_el.get_attribute(attribute)

    def get_text(self, driver):
        """Returns content text of website element"""
        target_el = self.loc_it(driver)
        return target_el.text

    def get_value(self, driver):
        """Returns content text of website element"""
        target_el = self.loc_it(driver)
        return target_el.get_attribute("value")

    def get_href(self, driver, base_url=None):
        """Returns element href link, with relative links expanded
        into an absolute link
        """
        target_el = self.loc_it(driver)
        target_href = target_el.get_attribute("href")
        if target_href[0] == "/":
            target_href = base_url + target_href
        return target_href

    def get_bag_url(self, driver, base_url=None):
        """Returns element href link, with relative links expanded
        into an absolute link
        """
        target_el = self.loc_it(driver)
        target_href = target_el.get_attribute("data-bag-url")
        if target_href[0] == "/":
            target_href = base_url + target_href
        return target_href

    def get_child_count(self, driver):
        """Returns the number of child elements, given a parent
        element specification
        """
        target_el = self.loc_it(driver)
        return len(target_el.find_elements_by_xpath(".//*"))

    def get_relatives_by_xpath(self, driver, xpath):
        """Returns the relatives by xpath, given a parent
        element specification
        """
        target_el = self.loc_hidden(driver)
        return target_el.find_elements_by_xpath(xpath)

    def get_texts_from_xpath(self, driver, xpath):
        """Returns the text in relatives matching xpath, given a parent
        element specification
        """
        web_elements = self.get_relatives_by_xpath(driver, xpath)
        keywords = []
        for el in web_elements:
            keywords.append(el.text)
        return keywords

    def get_parent(self, driver):
        """Returns the parent element"""
        target_el = self.loc_hidden(driver)
        return target_el.find_element_by_xpath("..")

    def get_immediate_child_count(self, driver):
        """Returns the number of immediate child elements, given a parent
        element specification
        """
        target_el = self.loc_it(driver)
        return len(target_el.find_elements_by_xpath("*"))

    def get_class(self, driver):
        target_el = self.loc_it(driver)
        target_class = target_el.get_attribute("class")
        return target_class

    def get_style(self, driver):
        target_el = self.loc_it(driver)
        target_style = target_el.get_attribute("style")
        return target_style

    def wait_on_visibility(self, driver, max_time):
        locator = self.by, self.locator
        WebDriverWait(driver, max_time).until(EC.visibility_of_element_located(locator))

    def right_click(self, driver):
        target_el = self.loc_it(driver)
        actions = ActionChains(driver)
        actions.context_click(target_el)
        actions.perform()

clear_all_text(driver)

Uses the Ctrl+A keys combination to select all text before using BACKSPACE key to delete it

Source code in cuahsi_base/site_element.py 
184
185
186
187
188
189
190
191
192
193
194
195
def clear_all_text(self, driver):
    """Uses the Ctrl+A keys combination to select all text before using
    BACKSPACE key to delete it
    """
    target_el = self.loc_it(driver)
    if platform.system() == "Darwin":  # MacOs
        ctrl_key = Keys.COMMAND
    else:
        ctrl_key = Keys.CONTROL
    ActionChains(driver).move_to_element(target_el).key_down(ctrl_key).send_keys(
        "a"
    ).key_up(ctrl_key).send_keys(Keys.BACKSPACE).perform()

clear_text(driver, size)

Uses backspace to clear text from a field

Source code in cuahsi_base/site_element.py 
197
198
199
200
201
202
def clear_text(self, driver, size):
    """Uses backspace to clear text from a field"""
    target_el = self.loc_it(driver)
    target_el.send_keys(Keys.END)
    for i in range(0, size):
        target_el.send_keys(Keys.BACK_SPACE)

click(driver)

Identifies an element on the page. After identification the element is then clicked.

Source code in cuahsi_base/site_element.py 
102
103
104
105
106
107
def click(self, driver):
    """Identifies an element on the page.  After identification
    the element is then clicked.
    """
    target_el = self.loc_it(driver)
    target_el.click()

double_click(driver)

Double click on element.

Source code in cuahsi_base/site_element.py 
109
110
111
112
113
114
115
def double_click(self, driver):
    """
    Double click on element.
    """
    target_el = self.loc_it(driver)
    actionchains = ActionChains(driver)
    actionchains.double_click(target_el).perform()

exists(driver)

Checks if element is visible on the page.

Source code in cuahsi_base/site_element.py 
65
66
67
68
69
70
71
72
73
74
75
def exists(self, driver):
    """
    Checks if element is visible on the page.
    """
    wait = WebDriverWait(driver, 3)
    try:
        wait.until(EC.visibility_of_element_located((self.by, self.locator)))
        target_el = wait.until(EC.element_to_be_clickable((self.by, self.locator)))
        return True
    except TimeoutException:
        return False

exists_in_dom(driver)

Checks if element exists within the DOM.

Source code in cuahsi_base/site_element.py 
77
78
79
80
81
82
83
84
85
86
def exists_in_dom(self, driver):
    """
    Checks if element exists within the DOM.
    """
    wait = WebDriverWait(driver, 3)
    try:
        wait.until(EC.presence_of_element_located((self.by, self.locator)))
        return True
    except TimeoutException:
        return False

get_attribute(driver, attribute)

Returns any attribute of website element

Source code in cuahsi_base/site_element.py 
288
289
290
291
def get_attribute(self, driver, attribute):
    """Returns any attribute of website element"""
    target_el = self.loc_it(driver)
    return target_el.get_attribute(attribute)

get_attribute_hidden(driver, attribute)

Returns any attribute of website element

Source code in cuahsi_base/site_element.py 
293
294
295
296
def get_attribute_hidden(self, driver, attribute):
    """Returns any attribute of website element"""
    target_el = self.loc_hidden(driver)
    return target_el.get_attribute(attribute)

get_bag_url(driver, base_url=None)

Returns element href link, with relative links expanded into an absolute link

Source code in cuahsi_base/site_element.py 
318
319
320
321
322
323
324
325
326
def get_bag_url(self, driver, base_url=None):
    """Returns element href link, with relative links expanded
    into an absolute link
    """
    target_el = self.loc_it(driver)
    target_href = target_el.get_attribute("data-bag-url")
    if target_href[0] == "/":
        target_href = base_url + target_href
    return target_href

get_child_count(driver)

Returns the number of child elements, given a parent element specification

Source code in cuahsi_base/site_element.py 
328
329
330
331
332
333
def get_child_count(self, driver):
    """Returns the number of child elements, given a parent
    element specification
    """
    target_el = self.loc_it(driver)
    return len(target_el.find_elements_by_xpath(".//*"))

get_href(driver, base_url=None)

Returns element href link, with relative links expanded into an absolute link

Source code in cuahsi_base/site_element.py 
308
309
310
311
312
313
314
315
316
def get_href(self, driver, base_url=None):
    """Returns element href link, with relative links expanded
    into an absolute link
    """
    target_el = self.loc_it(driver)
    target_href = target_el.get_attribute("href")
    if target_href[0] == "/":
        target_href = base_url + target_href
    return target_href

get_immediate_child_count(driver)

Returns the number of immediate child elements, given a parent element specification

Source code in cuahsi_base/site_element.py 
357
358
359
360
361
362
def get_immediate_child_count(self, driver):
    """Returns the number of immediate child elements, given a parent
    element specification
    """
    target_el = self.loc_it(driver)
    return len(target_el.find_elements_by_xpath("*"))

get_parent(driver)

Returns the parent element

Source code in cuahsi_base/site_element.py 
352
353
354
355
def get_parent(self, driver):
    """Returns the parent element"""
    target_el = self.loc_hidden(driver)
    return target_el.find_element_by_xpath("..")

get_relatives_by_xpath(driver, xpath)

Returns the relatives by xpath, given a parent element specification

Source code in cuahsi_base/site_element.py 
335
336
337
338
339
340
def get_relatives_by_xpath(self, driver, xpath):
    """Returns the relatives by xpath, given a parent
    element specification
    """
    target_el = self.loc_hidden(driver)
    return target_el.find_elements_by_xpath(xpath)

get_text(driver)

Returns content text of website element

Source code in cuahsi_base/site_element.py 
298
299
300
301
def get_text(self, driver):
    """Returns content text of website element"""
    target_el = self.loc_it(driver)
    return target_el.text

get_texts_from_xpath(driver, xpath)

Returns the text in relatives matching xpath, given a parent element specification

Source code in cuahsi_base/site_element.py 
342
343
344
345
346
347
348
349
350
def get_texts_from_xpath(self, driver, xpath):
    """Returns the text in relatives matching xpath, given a parent
    element specification
    """
    web_elements = self.get_relatives_by_xpath(driver, xpath)
    keywords = []
    for el in web_elements:
        keywords.append(el.text)
    return keywords

get_value(driver)

Returns content text of website element

Source code in cuahsi_base/site_element.py 
303
304
305
306
def get_value(self, driver):
    """Returns content text of website element"""
    target_el = self.loc_it(driver)
    return target_el.get_attribute("value")

hidden_inject_text(driver, field_text)

Enters text into a field or other input-capable html element that is hidden using send keys

Source code in cuahsi_base/site_element.py 
252
253
254
255
256
257
258
def hidden_inject_text(self, driver, field_text):
    """Enters text into a field or other input-capable html
    element that is hidden using send keys
    """
    target_el = self.loc_hidden(driver)
    for i in range(0, len(field_text)):
        target_el.send_keys(field_text[i])

iframe_in(driver)

Switches driver focus to an iframe within a page

Source code in cuahsi_base/site_element.py 
277
278
279
280
def iframe_in(self, driver):
    """Switches driver focus to an iframe within a page"""
    target_el = self.loc_it(driver)
    driver.switch_to.frame(target_el)

iframe_out(driver)

Switches driver focus out of iframe and back to the main page

Source code in cuahsi_base/site_element.py 
282
283
284
285
286
def iframe_out(self, driver):
    """Switches driver focus out of iframe and back to the
    main page
    """
    driver.switch_to.parent_frame()

inject_text(driver, field_text)

Enters text into a field or other input-capable html element using send keys

Source code in cuahsi_base/site_element.py 
244
245
246
247
248
249
250
def inject_text(self, driver, field_text):
    """Enters text into a field or other input-capable html
    element using send keys
    """
    target_el = self.loc_it(driver)
    for i in range(0, len(field_text)):
        target_el.send_keys(field_text[i])

is_selected(driver)

Checks if element is visible on the page.

Source code in cuahsi_base/site_element.py 
 95
 96
 97
 98
 99
100
def is_selected(self, driver):
    """
    Checks if element is visible on the page.
    """
    target_el = driver.find_element(self.by, self.locator)
    return target_el.is_selected()

is_visible(driver)

Checks if element is visible on the page.

Source code in cuahsi_base/site_element.py 
88
89
90
91
92
93
def is_visible(self, driver):
    """
    Checks if element is visible on the page.
    """
    target_el = driver.find_element(self.by, self.locator)
    return target_el.is_displayed()

javascript_click(driver)

Clicks an element using JavaScript

Source code in cuahsi_base/site_element.py 
117
118
119
120
121
122
def javascript_click(self, driver):
    """
    Clicks an element using JavaScript
    """
    target_el = self.loc_it(driver)
    driver.execute_script("arguments[0].click();", target_el)

javascript_click_hidden(driver, silent=False)

Simulate click on a hidden element using JavaScript

Source code in cuahsi_base/site_element.py 
124
125
126
127
128
129
def javascript_click_hidden(self, driver, silent=False):
    """
    Simulate click on a hidden element using JavaScript
    """
    target_el = self.loc_hidden(driver, silent)
    driver.execute_script("arguments[0].click();", target_el)

javascript_fill_hidden_text(driver, text)

Set text using JavaScript for a potentially hidden element

Source code in cuahsi_base/site_element.py 
131
132
133
134
135
136
def javascript_fill_hidden_text(self, driver, text):
    """
    Set text using JavaScript for a potentially hidden element
    """
    target_el = self.loc_hidden(driver)
    driver.execute_script(f'arguments[0].value="{text}";', target_el)

loc_hidden(driver, silent=False)

Identifies potentially hidden element on page, based on an element locator.

Source code in cuahsi_base/site_element.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def loc_hidden(self, driver, silent=False):
    """
    Identifies potentially hidden element on page, based on an element locator.
    """
    wait = WebDriverWait(driver, 10)
    try:
        target_el = wait.until(
            EC.presence_of_element_located((self.by, self.locator))
        )
    except TimeoutException as e:
        if not silent:
            print(
                "\nUnable to locate element by {}, "
                "locator: '{}'".format(self.by, self.locator)
            )
        raise e

    return target_el

loc_it(driver)

Identifies element on page, based on an element locator. Waits until an element becomes available & visible in DOM, and then until it becomes clickable.

Source code in cuahsi_base/site_element.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def loc_it(self, driver):
    """
    Identifies element on page, based on an element locator.
    Waits until an element becomes available & visible in DOM, and
    then until it becomes clickable.
    """
    wait = WebDriverWait(driver, 10)
    try:
        wait.until(EC.visibility_of_element_located((self.by, self.locator)))
        target_el = wait.until(EC.element_to_be_clickable((self.by, self.locator)))
    except TimeoutException as e:
        print(
            "\nUnable to locate element by {}, "
            "locator: '{}'".format(self.by, self.locator)
        )
        raise e

    return target_el

multi_click(driver)

Clicks an element while holding the control key, as to enable a multi-selection

Source code in cuahsi_base/site_element.py 
152
153
154
155
156
157
158
159
160
161
162
def multi_click(self, driver):
    """Clicks an element while holding the control key, as to enable
    a multi-selection
    """
    target_el = self.loc_it(driver)
    actions = ActionChains(driver)
    actions.move_to_element(target_el)
    actions.key_down(Keys.LEFT_CONTROL)
    actions.click(target_el)
    actions.key_up(Keys.LEFT_CONTROL)
    actions.perform()

passive_click(driver)

Identifies an element on the page. After identification the element is then clicked, regardless if it is "interactable" or not

Source code in cuahsi_base/site_element.py 
176
177
178
179
180
181
182
def passive_click(self, driver):
    """Identifies an element on the page.  After identification
    the element is then clicked, regardless if it is "interactable"
    or not
    """
    target_el = self.loc_it(driver)
    ActionChains(driver).move_to_element(target_el).click(target_el).perform()

range_click(driver)

Clicks an element while holding the control key, as to enable a range selection

Source code in cuahsi_base/site_element.py 
164
165
166
167
168
169
170
171
172
173
174
def range_click(self, driver):
    """Clicks an element while holding the control key, as to enable
    a range selection
    """
    target_el = self.loc_it(driver)
    actions = ActionChains(driver)
    actions.move_to_element(target_el)
    actions.key_down(Keys.LEFT_SHIFT)
    actions.click(target_el)
    actions.key_up(Keys.LEFT_SHIFT)
    actions.perform()

scroll_right(driver)

Scroll right using Keys.ARROW_RIGHT and a hold of one second

Source code in cuahsi_base/site_element.py 
230
231
232
233
234
235
236
237
238
239
240
241
242
def scroll_right(self, driver):
    """Scroll right using Keys.ARROW_RIGHT
    and a hold of one second
    """
    target_el = self.loc_it(driver)
    actions = ActionChains(driver)
    actions.move_to_element(target_el)
    actions.key_down(Keys.ARROW_RIGHT)
    actions.perform()
    time.sleep(1)
    actions = ActionChains(driver)
    actions.key_up(Keys.ARROW_RIGHT)
    actions.perform()

scroll_to(driver)

After element identification, the window is scrolled such that the element becomes visible in the window

Source code in cuahsi_base/site_element.py 
223
224
225
226
227
228
def scroll_to(self, driver):
    """After element identification, the window is scrolled
    such that the element becomes visible in the window
    """
    target_el = self.loc_it(driver)
    target_el.location_once_scrolled_into_view

scroll_to_hidden(driver)

After element identification, the window is scrolled such that the element becomes visible in the window

Source code in cuahsi_base/site_element.py 
216
217
218
219
220
221
def scroll_to_hidden(self, driver):
    """After element identification, the window is scrolled
    such that the element becomes visible in the window
    """
    target_el = self.loc_hidden(driver)
    target_el.location_once_scrolled_into_view

select_option(driver, select_choice)

Selects an option from a dropdown element

Source code in cuahsi_base/site_element.py 
204
205
206
207
208
def select_option(self, driver, select_choice):
    """Selects an option from a dropdown element"""
    target_el = self.loc_it(driver)
    select_el = Select(target_el)
    select_el.select_by_value(select_choice)

select_option_text(driver, select_choice)

Selects an option from dropdown given visible text

Source code in cuahsi_base/site_element.py 
210
211
212
213
214
def select_option_text(self, driver, select_choice):
    """Selects an option from dropdown given visible text"""
    target_el = self.loc_it(driver)
    select_el = Select(target_el)
    select_el.select_by_visible_text(select_choice)

send_caps(driver, field_text)

Enters capitalized text into a field or other input-capable html element using send_keys_to_element

Source code in cuahsi_base/site_element.py 
260
261
262
263
264
265
266
267
268
def send_caps(self, driver, field_text):
    """Enters capitalized text into a field or other input-capable
    html element using send_keys_to_element
    """
    actionchains = ActionChains(driver)
    target_el = self.loc_it(driver)
    actionchains.key_down(Keys.SHIFT).send_keys_to_element(
        target_el, field_text
    ).key_up(Keys.SHIFT).perform()

set_path(driver, field_text)

Enters text into a field or other input-capable html element using send keys, best for setting path to files for upload

Source code in cuahsi_base/site_element.py 
270
271
272
273
274
275
def set_path(self, driver, field_text):
    """Enters text into a field or other input-capable html
    element using send keys, best for setting path to files for upload
    """
    target_el = self.loc_it(driver)
    target_el.send_keys(field_text)

submit(driver)

Send ENTER to element, simulates submit

Source code in cuahsi_base/site_element.py 
138
139
140
141
def submit(self, driver):
    """Send ENTER to element, simulates submit"""
    target_el = self.loc_it(driver)
    target_el.send_keys(Keys.ENTER)

submit_hidden(driver)

Send ENTER to element that is perhaps hidden, simulates submit

Source code in cuahsi_base/site_element.py 
143
144
145
146
147
148
149
150
def submit_hidden(self, driver):
    """Send ENTER to element that is perhaps hidden,
    simulates submit
    """
    actions = ActionChains(driver)
    actions.key_down(Keys.ENTER)
    actions.key_up(Keys.ENTER)
    actions.perform()

SiteElementsCollection

Provides a way to locate all page elements which are identified by a common locator.

Source code in cuahsi_base/site_element.py 
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
class SiteElementsCollection:
    """
    Provides a way to locate all page elements which are identified by a
    common locator.
    """

    def __init__(self, by, locator):
        self.by = by
        self.locator = locator

    def loc_them(self, driver):
        """
        Finds all elements on a page that match a given locator.
        Waits until all elements become visible in a DOM.
        """
        wait = WebDriverWait(driver, 30)
        try:
            elements = wait.until(
                EC.visibility_of_all_elements_located((self.by, self.locator))
            )
        except TimeoutException as e:
            print(
                "\nUnable to locate elements by {}, "
                "locator: '{}'".format(self.by, self.locator)
            )
            raise e

        return elements

    def items(self, driver):
        return self.loc_them(driver)

loc_them(driver)

Finds all elements on a page that match a given locator. Waits until all elements become visible in a DOM.

Source code in cuahsi_base/site_element.py 
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
def loc_them(self, driver):
    """
    Finds all elements on a page that match a given locator.
    Waits until all elements become visible in a DOM.
    """
    wait = WebDriverWait(driver, 30)
    try:
        elements = wait.until(
            EC.visibility_of_all_elements_located((self.by, self.locator))
        )
    except TimeoutException as e:
        print(
            "\nUnable to locate elements by {}, "
            "locator: '{}'".format(self.by, self.locator)
        )
        raise e

    return elements