class WebDriver(RemoteWebDriver):
# There is no native event support on Mac
NATIVE_EVENTS_ALLOWED = sys.platform != "darwin"
CONTEXT_CHROME = "chrome"
CONTEXT_CONTENT = "content"
_web_element_cls = FirefoxWebElement
def __init__(self,
firefox_profile=None,
firefox_binary=None,
timeout=30,
capabilities=None,
proxy=None,
executable_path="geckodriver",
options=None,
service_log_path="geckodriver.log",
firefox_options=None,
service_args=None,
desired_capabilities=None,
log_path=None,
keep_alive=True):
"""Starts a new local session of Firefox.
Based on the combination and specificity of the various keyword
arguments, a capabilities dictionary will be constructed that
is passed to the remote end.
The keyword arguments given to this constructor are helpers to
more easily allow Firefox WebDriver sessions to be customised
with different options. They are mapped on to a capabilities
dictionary that is passed on to the remote end.
As some of the options, such as `firefox_profile` and
`options.profile` are mutually exclusive, precedence is
given from how specific the setting is. `capabilities` is the
least specific keyword argument, followed by `options`,
followed by `firefox_binary` and `firefox_profile`.
In practice this means that if `firefox_profile` and
`options.profile` are both set, the selected profile
instance will always come from the most specific variable.
In this case that would be `firefox_profile`. This will result in
`options.profile` to be ignored because it is considered
a less specific setting than the top-level `firefox_profile`
keyword argument. Similarily, if you had specified a
`capabilities["moz:firefoxOptions"]["profile"]` Base64 string,
this would rank below `options.profile`.
:param firefox_profile: Instance of ``FirefoxProfile`` object
or a string. If undefined, a fresh profile will be created
in a temporary location on the system.
:param firefox_binary: Instance of ``FirefoxBinary`` or full
path to the Firefox binary. If undefined, the system default
Firefox installation will be used.
:param timeout: Time to wait for Firefox to launch when using
the extension connection.
:param capabilities: Dictionary of desired capabilities.
:param proxy: The proxy settings to us when communicating with
Firefox via the extension connection.
:param executable_path: Full path to override which geckodriver
binary to use for Firefox 47.0.1 and greater, which
defaults to picking up the binary from the system path.
:param options: Instance of ``options.Options``.
:param service_log_path: Where to log information from the driver.
:param firefox_options: Deprecated argument for options
:param service_args: List of args to pass to the driver service
:param desired_capabilities: alias of capabilities. In future
versions of this library, this will replace 'capabilities'.
This will make the signature consistent with RemoteWebDriver.
:param log_path: Deprecated argument for service_log_path
:param keep_alive: Whether to configure remote_connection.RemoteConnection to use
HTTP keep-alive.
"""
if log_path:
warnings.warn('use service_log_path instead of log_path',
DeprecationWarning,
stacklevel=2)
service_log_path = log_path
if firefox_options:
warnings.warn('use options instead of firefox_options',
DeprecationWarning,
stacklevel=2)
options = firefox_options
self.binary = None
self.profile = None
self.service = None
# If desired capabilities is set, alias it to capabilities.
# If both are set ignore desired capabilities.
if capabilities is None and desired_capabilities:
capabilities = desired_capabilities
if capabilities is None:
capabilities = DesiredCapabilities.FIREFOX.copy()
if options is None:
options = Options()
capabilities = dict(capabilities)
if capabilities.get("binary"):
self.binary = capabilities["binary"]
# options overrides capabilities
if options is not None:
if options.binary is not None:
self.binary = options.binary
if options.profile is not None:
self.profile = options.profile
# firefox_binary and firefox_profile
# override options
if firefox_binary is not None:
if isinstance(firefox_binary, basestring):
firefox_binary = FirefoxBinary(firefox_binary)
self.binary = firefox_binary
options.binary = firefox_binary
if firefox_profile is not None:
if isinstance(firefox_profile, basestring):
firefox_profile = FirefoxProfile(firefox_profile)
self.profile = firefox_profile
options.profile = firefox_profile
# W3C remote
# TODO(ato): Perform conformance negotiation
if capabilities.get("marionette"):
capabilities.pop("marionette")
self.service = Service(executable_path,
service_args=service_args,
log_path=service_log_path)
self.service.start()
capabilities.update(options.to_capabilities())
executor = FirefoxRemoteConnection(
remote_server_addr=self.service.service_url)
RemoteWebDriver.__init__(self,
command_executor=executor,
desired_capabilities=capabilities,
keep_alive=True)
# Selenium remote
else:
if self.binary is None:
self.binary = FirefoxBinary()
if self.profile is None:
self.profile = FirefoxProfile()
# disable native events if globally disabled
self.profile.native_events_enabled = (
self.NATIVE_EVENTS_ALLOWED
and self.profile.native_events_enabled)
if proxy is not None:
proxy.add_to_capabilities(capabilities)
executor = ExtensionConnection("127.0.0.1", self.profile,
self.binary, timeout)
RemoteWebDriver.__init__(self,
command_executor=executor,
desired_capabilities=capabilities,
keep_alive=keep_alive)
self._is_remote = False
def quit(self):
"""Quits the driver and close every associated window."""
try:
RemoteWebDriver.quit(self)
except Exception:
# We don't care about the message because something probably has gone wrong
pass
if self.w3c:
self.service.stop()
else:
self.binary.kill()
if self.profile is not None:
try:
shutil.rmtree(self.profile.path)
if self.profile.tempfolder is not None:
shutil.rmtree(self.profile.tempfolder)
except Exception as e:
print(str(e))
@property
def firefox_profile(self):
return self.profile
# Extension commands:
def set_context(self, context):
self.execute("SET_CONTEXT", {"context": context})
@contextmanager
def context(self, context):
"""Sets the context that Selenium commands are running in using
a `with` statement. The state of the context on the server is
saved before entering the block, and restored upon exiting it.
:param context: Context, may be one of the class properties
`CONTEXT_CHROME` or `CONTEXT_CONTENT`.
Usage example::
with selenium.context(selenium.CONTEXT_CHROME):
# chrome scope
... do stuff ...
"""
initial_context = self.execute('GET_CONTEXT').pop('value')
self.set_context(context)
try:
yield
finally:
self.set_context(initial_context)
def install_addon(self, path, temporary=None):
"""
Installs Firefox addon.
Returns identifier of installed addon. This identifier can later
be used to uninstall addon.
:param path: Absolute path to the addon that will be installed.
:Usage:
driver.install_addon('/path/to/firebug.xpi')
"""
payload = {"path": path}
if temporary is not None:
payload["temporary"] = temporary
return self.execute("INSTALL_ADDON", payload)["value"]
def uninstall_addon(self, identifier):
"""
Uninstalls Firefox addon using its identifier.
:Usage:
driver.uninstall_addon('*****@*****.**')
"""
self.execute("UNINSTALL_ADDON", {"id": identifier})
class TorBrowser:
'''
Refactoring for 2020 12 version of Tor Browser Bundle
'''
def __init__(self,
browser_path,
binary_path=None,
profile_path=None,
executable_path=None,
socks_port=9050,
control_port=9051,
extensions=None,
capabilities=None,
headless=False,
capture_screen=False,
url=None):
assert browser_path is not None
self.browser_path = browser_path
self.binary_path = binary_path
self.profile_path = profile_path
self.executable_path = executable_path
self.socks_port = socks_port
self.control_port = control_port
self.extensions = extensions
self.capabilities = capabilities
self.headless = headless
self.capture_screen = capture_screen
self.url = url
self.profile = None
self.binary = None # firefox
self.options = None
self.webdriver = None
self.tor_controller = TorController() # Start tor process..
self._initialize()
def _initialize(self):
self._init_browser()
self.profile = FirefoxProfile(self.profile_path)
self._init_profile()
self._init_extensions()
self._init_capabilities()
self._init_binary()
self._init_options()
self._init_webdriver()
def _init_browser(self):
if self.binary_path is None:
# tor-browser_en-US/Browser/firefox
self.binary_path = os.path.join(self.browser_path,
os.path.join('Browser', 'firefox'))
if self.profile_path is None:
# tor-browser_en-US/Browser/TorBrowser/Data/Browser/profile.default
self.profile_path = os.path.join(
self.browser_path,
os.path.join(
'Browser',
os.path.join(
'TorBrowser',
os.path.join(
'Data', os.path.join('Browser',
'profile.default')))))
def _init_profile(self):
self.profile.set_preference('browser.cache.disk.enable', False)
self.profile.set_preference('browser.cache.memory.enable', False)
self.profile.set_preference('browser.cache.offline.enable', False)
self.profile.set_preference('browser.startup.page', '0')
self.profile.set_preference('browser.startup.homepage', 'about:newtab')
self.profile.set_preference('network.http.use-cache', False)
self.profile.set_preference('network.proxy.type', 1)
self.profile.set_preference('network.proxy.socks', '127.0.0.1')
self.profile.set_preference('network.proxy.socks_port',
self.socks_port)
self.profile.set_preference('extensions.torlauncher.promp_at_startup',
0)
self.profile.set_preference('network.http.use-cache', False)
self.profile.set_preference('webdriver.load.strategy', 'conservative')
self.profile.set_preference('extensions.torlauncher.start_tor', False)
self.profile.set_preference(
'extensions.torbutton.versioncheck_enabled', False)
self.profile.set_preference('permissions.memory_only', False)
# update_preference('webdriver.load.strategy', 'normal')
# update_preference('app.update.enabled', False)
# update_preference('extensions.torbutton.versioncheck_enabled', False)
# update_preference('extensions.torbutton.prompted_language', True)
# update_preference('extensions.torbutton.socks_port', self.socks_port)
# update_preference('extensions.torlauncher.control_port', self.control_port)
# update_preference('extensions.torlauncher.start_tor', True)
# update_preference('extensions.torbutton.block_dis', False)
# update_preference('extensions.torbutton.custom.socks_host', '127.0.0.1')
# update_preference('extensions.torbutton.custom.socks_port', self.socks_port)
# update_preference('extensions.torbutton.inserted_button', True)
# update_preference('extensions.torbutton.launch_warning', False)
# update_preference('privacy.spoof_english', 2)
# update_preference('extensions.torbutton.loglevel', 2)
# update_preference('extensions.torbutton.logmethod', 0)
# update_preference('extensions.torbutton.settings_method', 'custom')
# update_preference('extensions.torbutton.use_privoxy', False)
# update_preference('extensions.torlauncher.control_port', self.control_port)
# update_preference('extensions.torlauncher.loglevel', 2)
# update_preference('extensions.torlauncher.logmethod', 0)
# update_preference('extensions.torlauncher.prompt_at_startup', False)
self.profile.update_preferences()
def _init_extensions(self):
if self.extensions is not None:
for extension in self.extensions:
self.profile.add_extension(extension)
def _init_capabilities(self):
if self.capabilities is None:
self.capabilities = DesiredCapabilities.FIREFOX
self.capabilities.update({
'handlesAlerts': True,
'databaseEnabled': True,
'javascriptEnabled': True,
'browserConnectionEnabled': True
})
def _init_binary(self):
self.binary = FirefoxBinary(firefox_path=self.binary_path)
self.binary.add_command_line_options('--class', '"Tor Browser"')
def _init_options(self):
if self.headless is True:
self.options = Options()
self.options.headless = self.headless
def _init_webdriver(self):
self.webdriver = webdriver.Firefox(
firefox_profile=self.profile,
firefox_binary=self.binary,
timeout=60,
capabilities=self.capabilities,
executable_path=self.executable_path,
options=self.options)
def connect_url(self, url):
self.webdriver.get(url)
WebDriverWait(self.webdriver, timeout=30).until(
expected_conditions.presence_of_element_located(
(By.TAG_NAME, 'body')))
def close(self):
try:
self.tor_controller.stop()
self.webdriver.quit()
except CannotSendRequest:
logger.error('CannotSendRequest while quitting TorBrowserDriver')
self.binary.kill()
except Exception as e:
logger.error('Exception while quitting TorBrowserDriver', e)
def init_canvas_permission(self, url):
'''
Create a permission DB and add exception for the canvas image extraction.
Otherwise screenshots taken by Selenium will be just blank images due to
canvas fingerprinting defense in Tor Browser Bundle.
'''
import sqlite3
from tld import get_tld
connection = sqlite3.connect
permission_db = connection(
os.path.join(self.profile_path, 'permissions.sqlite'))
cursor = permission_db.cursor()
# http://mxr.mozilla.org/mozilla-esr31/source/build/automation.py.in
cursor.execute("PRAGMA user_version=3")
cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts (
id INTEGER PRIMARY KEY,
host TEXT,
type TEXT,
permission INTEGER,
expireType INTEGER,
expireTime INTEGER,
appId INTEGER,
isInBrowserElement INTEGER)""")
domain = get_tld(url)
logger.debug('Adding canvas/extractData permission for %s' % domain)
query = """INSERT INTO 'moz_hosts' VALUES (NULL, '%s', 'canvas/extractData', 1, 0, 0, 0, 0);""" % domain
cursor.execute(query)
permission_db.commit()
cursor.close()
def take_screenshot(self, save_path):
if save_path is not None:
save_path = os.path.join(save_path, 'screenshot.png')
else:
save_path = 'screenshot.png'
self.webdriver.get_screenshot_as_file(save_path)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
