Python Selenium Firefox geckodriver. Detach browser from terminal

Question

With Chrome (chromedriver) it's very simple:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_experimental_option('detach', True)

With Firefox (geckodriver) no:

from selenium import webdriver
from selenium.webdriver.firefox.options import Options
options = Options()
options.add_experimental_option('detach', True)  # Returns syntax error

What is the equivalent syntax for leaving the Firefox browser open even when the script ends?

Answer 1

The underlying structure of Chrome (chromedriver) and Firefox (geckodriver) are different.

For example the add_experimental_option exists in chromedriver

This add_experimental_option does not exist in geckodriver, so that is why you are getting an error.

I have looked through various geckodriver documents and haven't seen a reference similar to this one from chromedriver.

Please note the options_spec.rb code below is from the Ruby source code for selenium.

The code below is from the file options_spec.rb, which is part of the selenium source code for chromedriver. Note the detach: true in the dictionary.

opts = Options.new(browser_version: '75',
                   platform_name: 'win10',
                   accept_insecure_certs: false,
                   page_load_strategy: 'eager',
                   unhandled_prompt_behavior: 'accept',
                   strict_file_interactability: true,
                   timeouts: {script: 40000,
                              page_load: 400000,
                              implicit: 1},
                   set_window_rect: false,
                   args: %w[foo bar],
                   prefs: {foo: 'bar'},
                   binary: '/foo/bar',
                   extensions: ['foo.crx', 'bar.crx'],
                   encoded_extensions: ['encoded_foobar'],
                   foo: 'bar',
                   emulation: {device_name: :bar},
                   local_state: {foo: 'bar'},
                   detach: true,
                   debugger_address: '127.0.0.1:8181',
                   exclude_switches: %w[foobar barfoo],
                   minidump_path: 'linux/only',
                   perf_logging_prefs: {enable_network: true},
                   window_types: %w[normal devtools],
                   'custom:options': {foo: 'bar'})

The code below is from the file options_spec.rb, which is part of the selenium source code for geckodriver. Note there is no detach: true in the dictionary.

opts = Options.new(browser_version: '66',
                   platform_name: 'win10',
                   accept_insecure_certs: false,
                   page_load_strategy: 'eager',
                   unhandled_prompt_behavior: 'accept',
                   strict_file_interactability: true,
                   timeouts: {script: 40000,
                              page_load: 400000,
                              implicit: 1},
                   set_window_rect: false,
                   args: %w[foo bar],
                   binary: '/foo/bar',
                   prefs: {foo: 'bar'},
                   foo: 'bar',
                   profile: profile,
                   log_level: :debug,
                   'custom:options': {foo: 'bar'})

The code below is from the file options_spec.rb, which is part of the selenium source code for edgedriver. Note there is a detach: true in the dictionary.

opts = Options.new(browser_version: '75',
                   platform_name: 'win10',
                   accept_insecure_certs: false,
                   page_load_strategy: 'eager',
                   unhandled_prompt_behavior: 'accept',
                   strict_file_interactability: true,
                   timeouts: {script: 40000,
                              page_load: 400000,
                              implicit: 1},
                   set_window_rect: false,
                   args: %w[foo bar],
                   prefs: {foo: 'bar'},
                   binary: '/foo/bar',
                   extensions: ['foo.crx', 'bar.crx'],
                   encoded_extensions: ['encoded_foobar'],
                   foo: 'bar',
                   emulation: {device_name: :bar},
                   local_state: {foo: 'bar'},
                   detach: true,
                   debugger_address: '127.0.0.1:8181',
                   exclude_switches: %w[foobar barfoo],
                   minidump_path: 'linux/only',
                   perf_logging_prefs: {enable_network: true},
                   window_types: %w[normal devtools],
                   'custom:options': {foo: 'bar'})

Based on the dictionaries in these 3 option files, one would assume that {'detach': True} isn't an option in the geckodriver.

The options.py for the geckodriver in the Python selenium structure is different than the Ruby file options_spec.rb.

def preferences(self) -> dict:
       """:Returns: A dict of preferences."""
       return self._preferences

def set_preference(self, name: str, value: Union[str, int, bool]):
       """Sets a preference."""
       self._preferences[name] = value

When looking through the source code for the Python geckodriver in Mozilla's gecko-dev GitHub repository I saw that I could query pre-defined preferences and capabilities.

from selenium.webdriver.firefox.options import Options
firefox_options = Options()

print(firefox_options.arguments)
# output
['--test-type', '--ignore-certificate-errors', '--disable-infobars', '--disable-extensions', '--disable-popup-blocking']

print(firefox_options.capabilities)
# output
{'browserName': 'firefox', 'marionette': True, 'acceptInsecureCerts': True}

print(firefox_options.preferences)
# output
{'detach': True}

So {'detach': True} is an option in the geckodriver, so you should be able to set the option this way:

firefox_options.set_preference('detach', True)