Context

class selenium_driverless.types.context.Context(base_target, driver, context_id=None, loop=None, is_incognito=False, max_ws_size=1048576)

Allows you to drive the browser without chromedriver.

async set_download_behaviour(behavior, path=None)

set the download behaviour

Parameters:

• behavior (Literal['deny', 'allow', 'allowAndName', 'default']) – the behaviour to set the downloading to

• path (Optional[str]) – the path to the default download directory

Warning

setting behaviour=allow instead of allowAndName can cause some bugs

property downloads_dir

the current downloads directory

async wait_download(timeout=30)

wait for a download on the current tab

returns something like

{
    "frameId": "2D543B5E8B14945B280C537A4882A695",
    "guid": "c91df4d5-9b45-4962-84df-3749bd3f926d",
    "url": "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
    "suggestedFilename": "dummy.pdf",

    # only if options.downloads_dir specified
    "guid_file": "D:\System\AppData\PyCharm\scratches\downloads\c91df4d5-9b45-4962-84df-3749bd3f926d"
}

Parameters:

timeout (float) – time in seconds to wait for a download

Return type:

dict

Warning

downloads from iframes not supported yet

async get(url, referrer=None, wait_load=True, timeout=30)

Loads a web page in the current Target

Parameters:

• url (str) – the url to load.

• referrer (Optional[str]) – the referrer to load the page with

• wait_load (bool) – whether to wait for the webpage to load

• timeout (float) – the maximum time in seconds for waiting on load

Return type:

dict

returns the same as Target.wait_download if the url initiates a download

property title: str

Returns the title of the current target

property current_pointer: Pointer

the Pointer for the current target

async send_keys(text)

send text & keys to the current target

Parameters:

text (str) – the text to send

async execute_raw_script(script, *args, await_res=False, serialization=None, max_depth=None, timeout=2, execution_context_id=None, unique_context=True)

example: script= “function(…arguments){obj.click()}” “const obj” will be the Object according to obj_id

async execute_script(script, *args, max_depth=2, serialization=None, timeout=2, execution_context_id=None, unique_context=True)

executes JavaScript synchronously on GlobalThis such as

return document

see Target.execute_raw_script for argument descriptions

async execute_async_script(script, *args, max_depth=2, serialization=None, timeout=2, execution_context_id=None, unique_context=True)

executes JavaScript asynchronously on GlobalThis such as

Warning

using execute_async_script is not recommended as it doesn’t handle exceptions correctly. Use Chrome.eval_async

resolve = arguments[arguments.length-1]

see Target.execute_raw_script for argument descriptions

async eval_async(script, *args, max_depth=2, serialization=None, timeout=2, execution_context_id=None, unique_context=True)

executes JavaScript asynchronously on GlobalThis such as

res = await fetch("https://httpbin.org/get");
// mind CORS!
json = await res.json()
return json

see Target.execute_raw_script for argument descriptions

property current_url: str

Gets the URL of the current page.

Usage:

target.current_url

property page_source: str

Gets the docs_source of the current page.

Usage:

target.page_source

async close(timeout=2)

Closes the current window.

Usage:

target.close()

Return type:

None

async quit(timeout=30, start_monotonic=None)

Quits the target and closes every associated window.

Usage:

target.quit()

Return type:

None

property current_window_handle: str

Returns the current target_id

property window_handles: List[TargetInfo]

Returns the handles of all windows within the current session.

async new_window(type_hint='tab', url='', activate=False, focus=True, background=True)

creates a new tab or window

Parameters:

• type_hint (Literal['tab', 'window']) – what kind of target to create

• url – url to start the target at

• activate (bool) – whether to bring the target to the front

• focus (bool) – whether to emulate focus on the target

• background (bool) – whether to start the target in the background

Return type:

Target

async maximize_window()

Maximizes the current window that webdriver is using.

Return type:

None

async fullscreen_window()

Invokes the window manager-specific ‘full screen’ operation.

Return type:

None

async minimize_window()

Invokes the window manager-specific ‘minimize’ operation.

Return type:

None

async print_page()

Takes PDF of the current page.

The target makes the best effort to return a PDF based on the provided parameters.

Return type:

str

property switch_to: SwitchTo

Returns:

• SwitchTo: an object containing all options to switch focus into

Usage:

element = target.switch_to.active_element
alert = target.switch_to.alert
target.switch_to.default_content()
target.switch_to.frame('frame_name')
target.switch_to.frame(1)
target.switch_to.frame(target.find_elements(By.TAG_NAME, "iframe")[0])
target.switch_to.parent_frame()
target.switch_to.window('main')

async back()

Goes one step backward in the browser history.

Return type:

None

async forward()

Goes one step forward in the browser history.

Return type:

None

async refresh()

Refreshes the current page

Return type:

None

async get_cookies()

Returns a set of dictionaries, corresponding to cookies visible in the current target.

Return type:

List[dict]

async get_cookie(name)

Get a single cookie by name. Returns the cookie if found, None if not.

Return type:

Optional[Dict]

async delete_cookie(name, url=None, domain=None, path=None)

Deletes a single cookie with the given name.

Return type:

None

async delete_all_cookies()

Delete all cookies in the scope of the session.

Return type:

None

async add_cookie(cookie_dict)

Adds a cookie to your current session.

Parameters:

cookie_dict (dict) – A dictionary object, with required keys - “name” and “value”; optional keys - “path”, “domain”, “secure”, “httpOnly”, “expiry”, “sameSite”

Usage:

target.add_cookie({'name' : 'foo', 'value' : 'bar'})
target.add_cookie({'name' : 'foo', 'value' : 'bar', 'path' : '/'})
target.add_cookie({'name' : 'foo', 'value' : 'bar', 'path' : '/', 'secure' : True})
target.add_cookie({'name' : 'foo', 'value' : 'bar', 'sameSite' : 'Strict'})

Return type:

None

async find_element(by, value, timeout=None)

find an element in the current target

Parameters:

• by (str) – one of the locators at By

• value (str) – the actual query to find the element by

• timeout (Optional[float]) – how long to wait for the element to exist

Return type:

WebElement

async find_elements(by, value, timeout=3)

find multiple elements in the current target

Parameters:

• by (str) – one of the locators at By

• value (str) – the actual query to find the elements by

• timeout (float) – how long to wait for not being in a page reload loop in seconds

Return type:

List[WebElement]

async search_elements(query)

query:str | Plain text or query selector or XPath search query.

Return type:

List[WebElement]

async get_screenshot_as_file(filename)

Saves a screenshot of the current window to a PNG image file.

Parameters:

filename (str) – The full path you wish to save your screenshot to. This should end with a .png extension.

Return type:

None

async save_screenshot(filename)

alias to :func: driver.get_screenshot_as_file <selenium_driverless.webdriver.Chrome.get_screenshot_as_file>

Return type:

None

async get_screenshot_as_png()

Gets the screenshot of the current window as a binary data.

Usage:

target.get_screenshot_as_png()

Return type:

bytes

async snapshot()

gets the current snapshot as mhtml

Return type:

str

async save_snapshot(filename)

Saves a snapshot of the current window to a MHTML file.

Parameters:

filename (str) – The full path you wish to save your snapshot to. This should end with a .mhtml extension.

await driver.get_snapshot('snapshot.mhtml')

async set_window_size(width, height, windowHandle='current')

Sets the width and height of the current window. (window.resizeTo)

Args:

• width: the width in pixels to set the window to

• height: the height in pixels to set the window to

Usage:

target.set_window_size(800,600)

Return type:

None

async get_window_size()

Gets the width and height of the current window.

Return type:

dict

async set_window_position(x, y, windowHandle='current')

Sets the x,y position of the current window. (window.moveTo)

Args:

• x: the x-coordinate in pixels to set the window position

• y: the y-coordinate in pixels to set the window position

Usage:

target.set_window_position(0,0)

Return type:

dict

async get_window_position(windowHandle='current')

Gets the x,y position of the current window.

Usage:

target.get_window_position()

Return type:

dict

async get_window_rect()

Gets the x, y coordinates of the window as well as height and width of the current window.

Usage:

target.get_window_rect()

Return type:

dict

async set_window_rect(x=None, y=None, width=None, height=None)

Sets the x, y coordinates of the window as well as height and width of the current window. This method is only supported for W3C compatible browsers; other browsers should use set_window_position and set_window_size.

Usage:

target.set_window_rect(x=10, y=10)
target.set_window_rect(width=100, height=200)
target.set_window_rect(x=10, y=10, width=100, height=200)

Return type:

dict

async get_network_conditions()

Gets Chromium network emulation settings.

Returns:

A dict. For example: {‘latency’: 4, ‘download_throughput’: 2, ‘upload_throughput’: 2, ‘offline’: False}

async set_network_conditions(offline, latency, download_throughput, upload_throughput, connection_type)

Sets Chromium network emulation settings.

Args:

• network_conditions: A dict with conditions specification.

Usage:

target.set_network_conditions(
    offline=False,
    latency=5,  # additional latency (ms)
    download_throughput=500 * 1024,  # maximal throughput
    upload_throughput=500 * 1024,  # maximal throughput
    connection_type="wifi")

Note: ‘throughput’ can be used to set both (for download and upload).

Return type:

None

async delete_network_conditions()

Resets Chromium network emulation settings.

Return type:

None

async set_permissions(name, value, origin=None)

Sets Applicable Permission.

Args:

• name: The item to set the permission on.

• value: The value to set on the item

Usage:

target.set_permissions('clipboard-read', 'denied')

Return type:

None

async wait_for_cdp(event, timeout=None)

wait for an event on the current target see Target.wait_for_cdp for reference

Return type:

dict

async add_cdp_listener(event, callback)

add a listener for a CDP event on the current target see Target.add_cdp_listener for reference

async remove_cdp_listener(event, callback)

remove a listener for a CDP event on the current target see Target.remove_cdp_listener for reference

async get_cdp_event_iter(event)

iterate over CDP events on the current target see Target.get_cdp_event_iter for reference

Return type:

AsyncIterable[dict]

async execute_cdp_cmd(cmd, cmd_args=None, timeout=10)

Execute Chrome Devtools Protocol command on the current target executes it on Target.execute_cdp_cmd if message:'Not allowed' received see Target.execute_cdp_cmd for reference

Return type:

dict

async fetch(*args, **kwargs)

executes a JS fetch request within the current target see Target.fetch for reference

Return type:

dict

async xhr(*args, **kwargs)

executes a JS XMLHttpRequest request within the current target see Target.fetch for reference

Return type:

dict

async get_sinks()

Returns:

A list of sinks available for Cast.

Return type:

list

async get_issue_message()

Returns:

An error message when there is any issue in a Cast session.

async set_sink_to_use(sink_name)

Sets a specific sink, using its name, as a Cast session receiver target.

Args:

• sink_name: Name of the sink to use as the target.

Return type:

dict

async start_desktop_mirroring(sink_name)

Starts a desktop mirroring session on a specific receiver target.

Args:

• sink_name: Name of the sink to use as the target.

Return type:

dict

async start_tab_mirroring(sink_name)

Starts a tab mirroring session on a specific receiver target.

Args:

• sink_name: Name of the sink to use as the target.

Return type:

dict

async stop_casting(sink_name)

Stops the existing Cast session on a specific receiver target.

Args:

• sink_name: Name of the sink to stop the Cast session.

Return type:

dict