Ausgabe der neuen DB Einträge

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/__init__.py

@@ -0,0 +1,16 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/extension_connection.py

@@ -0,0 +1,84 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import logging
+import time
+
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.common import utils
+from selenium.webdriver.remote.command import Command
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
+
+LOGGER = logging.getLogger(__name__)
+PORT = 0
+HOST = None
+_URL = ""
+
+
+class ExtensionConnection(RemoteConnection):
+    def __init__(self, host, firefox_profile, firefox_binary=None, timeout=30):
+        self.profile = firefox_profile
+        self.binary = firefox_binary
+        HOST = host
+        timeout = int(timeout)
+
+        if self.binary is None:
+            self.binary = FirefoxBinary()
+
+        if HOST is None:
+            HOST = "127.0.0.1"
+
+        PORT = utils.free_port()
+        self.profile.port = PORT
+        self.profile.update_preferences()
+
+        self.profile.add_extension()
+
+        self.binary.launch_browser(self.profile, timeout=timeout)
+        _URL = "http://%s:%d/hub" % (HOST, PORT)
+        RemoteConnection.__init__(
+            self, _URL, keep_alive=True)
+
+    def quit(self, sessionId=None):
+        self.execute(Command.QUIT, {'sessionId': sessionId})
+        while self.is_connectable():
+            LOGGER.info("waiting to quit")
+            time.sleep(1)
+
+    def connect(self):
+        """Connects to the extension and retrieves the session id."""
+        return self.execute(Command.NEW_SESSION,
+                            {'desiredCapabilities': DesiredCapabilities.FIREFOX})
+
+    @classmethod
+    def connect_and_quit(self):
+        """Connects to an running browser and quit immediately."""
+        self._request('%s/extensions/firefox/quit' % _URL)
+
+    @classmethod
+    def is_connectable(self):
+        """Trys to connect to the extension but do not retrieve context."""
+        utils.is_connectable(self.profile.port)
+
+
+class ExtensionConnectionError(Exception):
+    """An internal error occurred int the extension.
+
+    Might be caused by bad input or bugs in webdriver
+    """
+    pass

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/firefox_binary.py

@@ -0,0 +1,217 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+import os
+import platform
+from subprocess import Popen, STDOUT
+from selenium.common.exceptions import WebDriverException
+from selenium.webdriver.common import utils
+import time
+
+
+class FirefoxBinary(object):
+
+    NO_FOCUS_LIBRARY_NAME = "x_ignore_nofocus.so"
+
+    def __init__(self, firefox_path=None, log_file=None):
+        """
+        Creates a new instance of Firefox binary.
+
+        :Args:
+         - firefox_path - Path to the Firefox executable. By default, it will be detected from the standard locations.
+         - log_file - A file object to redirect the firefox process output to. It can be sys.stdout.
+                      Please note that with parallel run the output won't be synchronous.
+                      By default, it will be redirected to /dev/null.
+        """
+        self._start_cmd = firefox_path
+        # We used to default to subprocess.PIPE instead of /dev/null, but after
+        # a while the pipe would fill up and Firefox would freeze.
+        self._log_file = log_file or open(os.devnull, "wb")
+        self.command_line = None
+        if self._start_cmd is None:
+            self._start_cmd = self._get_firefox_start_cmd()
+        if not self._start_cmd.strip():
+            raise WebDriverException(
+                "Failed to find firefox binary. You can set it by specifying "
+                "the path to 'firefox_binary':\n\nfrom "
+                "selenium.webdriver.firefox.firefox_binary import "
+                "FirefoxBinary\n\nbinary = "
+                "FirefoxBinary('/path/to/binary')\ndriver = "
+                "webdriver.Firefox(firefox_binary=binary)")
+        # Rather than modifying the environment of the calling Python process
+        # copy it and modify as needed.
+        self._firefox_env = os.environ.copy()
+        self._firefox_env["MOZ_CRASHREPORTER_DISABLE"] = "1"
+        self._firefox_env["MOZ_NO_REMOTE"] = "1"
+        self._firefox_env["NO_EM_RESTART"] = "1"
+
+    def add_command_line_options(self, *args):
+        self.command_line = args
+
+    def launch_browser(self, profile, timeout=30):
+        """Launches the browser for the given profile name.
+        It is assumed the profile already exists.
+        """
+        self.profile = profile
+
+        self._start_from_profile_path(self.profile.path)
+        self._wait_until_connectable(timeout=timeout)
+
+    def kill(self):
+        """Kill the browser.
+
+        This is useful when the browser is stuck.
+        """
+        if self.process:
+            self.process.kill()
+            self.process.wait()
+
+    def _start_from_profile_path(self, path):
+        self._firefox_env["XRE_PROFILE_PATH"] = path
+
+        if platform.system().lower() == 'linux':
+            self._modify_link_library_path()
+        command = [self._start_cmd, "-foreground"]
+        if self.command_line is not None:
+            for cli in self.command_line:
+                command.append(cli)
+        self.process = Popen(
+            command, stdout=self._log_file, stderr=STDOUT,
+            env=self._firefox_env)
+
+    def _wait_until_connectable(self, timeout=30):
+        """Blocks until the extension is connectable in the firefox."""
+        count = 0
+        while not utils.is_connectable(self.profile.port):
+            if self.process.poll() is not None:
+                # Browser has exited
+                raise WebDriverException(
+                    "The browser appears to have exited "
+                    "before we could connect. If you specified a log_file in "
+                    "the FirefoxBinary constructor, check it for details.")
+            if count >= timeout:
+                self.kill()
+                raise WebDriverException(
+                    "Can't load the profile. Possible firefox version mismatch. "
+                    "You must use GeckoDriver instead for Firefox 48+. Profile "
+                    "Dir: %s If you specified a log_file in the "
+                    "FirefoxBinary constructor, check it for details."
+                    % (self.profile.path))
+            count += 1
+            time.sleep(1)
+        return True
+
+    def _find_exe_in_registry(self):
+        try:
+            from _winreg import OpenKey, QueryValue, HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER
+        except ImportError:
+            from winreg import OpenKey, QueryValue, HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER
+        import shlex
+        keys = (r"SOFTWARE\Classes\FirefoxHTML\shell\open\command",
+                r"SOFTWARE\Classes\Applications\firefox.exe\shell\open\command")
+        command = ""
+        for path in keys:
+            try:
+                key = OpenKey(HKEY_LOCAL_MACHINE, path)
+                command = QueryValue(key, "")
+                break
+            except OSError:
+                try:
+                    key = OpenKey(HKEY_CURRENT_USER, path)
+                    command = QueryValue(key, "")
+                    break
+                except OSError:
+                    pass
+        else:
+            return ""
+
+        if not command:
+            return ""
+
+        return shlex.split(command)[0]
+
+    def _get_firefox_start_cmd(self):
+        """Return the command to start firefox."""
+        start_cmd = ""
+        if platform.system() == "Darwin":
+            start_cmd = "/Applications/Firefox.app/Contents/MacOS/firefox-bin"
+            # fallback to homebrew installation for mac users
+            if not os.path.exists(start_cmd):
+                start_cmd = os.path.expanduser("~") + start_cmd
+        elif platform.system() == "Windows":
+            start_cmd = (self._find_exe_in_registry() or self._default_windows_location())
+        elif platform.system() == 'Java' and os._name == 'nt':
+            start_cmd = self._default_windows_location()
+        else:
+            for ffname in ["firefox", "iceweasel"]:
+                start_cmd = self.which(ffname)
+                if start_cmd is not None:
+                    break
+            else:
+                # couldn't find firefox on the system path
+                raise RuntimeError(
+                    "Could not find firefox in your system PATH." +
+                    " Please specify the firefox binary location or install firefox")
+        return start_cmd
+
+    def _default_windows_location(self):
+        program_files = [os.getenv("PROGRAMFILES", r"C:\Program Files"),
+                         os.getenv("PROGRAMFILES(X86)", r"C:\Program Files (x86)")]
+        for path in program_files:
+            binary_path = os.path.join(path, r"Mozilla Firefox\firefox.exe")
+            if os.access(binary_path, os.X_OK):
+                return binary_path
+        return ""
+
+    def _modify_link_library_path(self):
+        existing_ld_lib_path = os.environ.get('LD_LIBRARY_PATH', '')
+
+        new_ld_lib_path = self._extract_and_check(
+            self.profile, self.NO_FOCUS_LIBRARY_NAME, "x86", "amd64")
+
+        new_ld_lib_path += existing_ld_lib_path
+
+        self._firefox_env["LD_LIBRARY_PATH"] = new_ld_lib_path
+        self._firefox_env['LD_PRELOAD'] = self.NO_FOCUS_LIBRARY_NAME
+
+    def _extract_and_check(self, profile, no_focus_so_name, x86, amd64):
+
+        paths = [x86, amd64]
+        built_path = ""
+        for path in paths:
+            library_path = os.path.join(profile.path, path)
+            if not os.path.exists(library_path):
+                os.makedirs(library_path)
+            import shutil
+            shutil.copy(os.path.join(
+                os.path.dirname(__file__),
+                path,
+                self.NO_FOCUS_LIBRARY_NAME),
+                library_path)
+            built_path += library_path + ":"
+
+        return built_path
+
+    def which(self, fname):
+        """Returns the fully qualified path by searching Path of the given
+        name"""
+        for pe in os.environ['PATH'].split(os.pathsep):
+            checkname = os.path.join(pe, fname)
+            if os.access(checkname, os.X_OK) and not os.path.isdir(checkname):
+                return checkname
+        return None

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/firefox_profile.py

@@ -0,0 +1,408 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import with_statement
+
+import base64
+import copy
+import json
+import os
+import re
+import shutil
+import sys
+import tempfile
+import zipfile
+
+try:
+    from cStringIO import StringIO as BytesIO
+except ImportError:
+    from io import BytesIO
+
+from xml.dom import minidom
+from selenium.webdriver.common.proxy import ProxyType
+from selenium.common.exceptions import WebDriverException
+
+
+WEBDRIVER_EXT = "webdriver.xpi"
+WEBDRIVER_PREFERENCES = "webdriver_prefs.json"
+EXTENSION_NAME = "fxdriver@googlecode.com"
+
+
+class AddonFormatError(Exception):
+    """Exception for not well-formed add-on manifest files"""
+
+
+class FirefoxProfile(object):
+    ANONYMOUS_PROFILE_NAME = "WEBDRIVER_ANONYMOUS_PROFILE"
+    DEFAULT_PREFERENCES = None
+
+    def __init__(self, profile_directory=None):
+        """
+        Initialises a new instance of a Firefox Profile
+
+        :args:
+         - profile_directory: Directory of profile that you want to use. If a
+           directory is passed in it will be cloned and the cloned directory
+           will be used by the driver when instantiated.
+           This defaults to None and will create a new
+           directory when object is created.
+        """
+        if not FirefoxProfile.DEFAULT_PREFERENCES:
+            with open(os.path.join(os.path.dirname(__file__),
+                                   WEBDRIVER_PREFERENCES)) as default_prefs:
+                FirefoxProfile.DEFAULT_PREFERENCES = json.load(default_prefs)
+
+        self.default_preferences = copy.deepcopy(
+            FirefoxProfile.DEFAULT_PREFERENCES['mutable'])
+        self.native_events_enabled = True
+        self.profile_dir = profile_directory
+        self.tempfolder = None
+        if self.profile_dir is None:
+            self.profile_dir = self._create_tempfolder()
+        else:
+            self.tempfolder = tempfile.mkdtemp()
+            newprof = os.path.join(self.tempfolder, "webdriver-py-profilecopy")
+            shutil.copytree(self.profile_dir, newprof,
+                            ignore=shutil.ignore_patterns("parent.lock", "lock", ".parentlock"))
+            self.profile_dir = newprof
+            os.chmod(self.profile_dir, 0o755)
+            self._read_existing_userjs(os.path.join(self.profile_dir, "user.js"))
+        self.extensionsDir = os.path.join(self.profile_dir, "extensions")
+        self.userPrefs = os.path.join(self.profile_dir, "user.js")
+        if os.path.isfile(self.userPrefs):
+            os.chmod(self.userPrefs, 0o644)
+
+    # Public Methods
+    def set_preference(self, key, value):
+        """
+        sets the preference that we want in the profile.
+        """
+        self.default_preferences[key] = value
+
+    def add_extension(self, extension=WEBDRIVER_EXT):
+        self._install_extension(extension)
+
+    def update_preferences(self):
+        for key, value in FirefoxProfile.DEFAULT_PREFERENCES['frozen'].items():
+            self.default_preferences[key] = value
+        self._write_user_prefs(self.default_preferences)
+
+    # Properties
+
+    @property
+    def path(self):
+        """
+        Gets the profile directory that is currently being used
+        """
+        return self.profile_dir
+
+    @property
+    def port(self):
+        """
+        Gets the port that WebDriver is working on
+        """
+        return self._port
+
+    @port.setter
+    def port(self, port):
+        """
+        Sets the port that WebDriver will be running on
+        """
+        if not isinstance(port, int):
+            raise WebDriverException("Port needs to be an integer")
+        try:
+            port = int(port)
+            if port < 1 or port > 65535:
+                raise WebDriverException("Port number must be in the range 1..65535")
+        except (ValueError, TypeError):
+            raise WebDriverException("Port needs to be an integer")
+        self._port = port
+        self.set_preference("webdriver_firefox_port", self._port)
+
+    @property
+    def accept_untrusted_certs(self):
+        return self.default_preferences["webdriver_accept_untrusted_certs"]
+
+    @accept_untrusted_certs.setter
+    def accept_untrusted_certs(self, value):
+        if value not in [True, False]:
+            raise WebDriverException("Please pass in a Boolean to this call")
+        self.set_preference("webdriver_accept_untrusted_certs", value)
+
+    @property
+    def assume_untrusted_cert_issuer(self):
+        return self.default_preferences["webdriver_assume_untrusted_issuer"]
+
+    @assume_untrusted_cert_issuer.setter
+    def assume_untrusted_cert_issuer(self, value):
+        if value not in [True, False]:
+            raise WebDriverException("Please pass in a Boolean to this call")
+
+        self.set_preference("webdriver_assume_untrusted_issuer", value)
+
+    @property
+    def native_events_enabled(self):
+        return self.default_preferences['webdriver_enable_native_events']
+
+    @native_events_enabled.setter
+    def native_events_enabled(self, value):
+        if value not in [True, False]:
+            raise WebDriverException("Please pass in a Boolean to this call")
+        self.set_preference("webdriver_enable_native_events", value)
+
+    @property
+    def encoded(self):
+        """
+        A zipped, base64 encoded string of profile directory
+        for use with remote WebDriver JSON wire protocol
+        """
+        self.update_preferences()
+        fp = BytesIO()
+        zipped = zipfile.ZipFile(fp, 'w', zipfile.ZIP_DEFLATED)
+        path_root = len(self.path) + 1  # account for trailing slash
+        for base, dirs, files in os.walk(self.path):
+            for fyle in files:
+                filename = os.path.join(base, fyle)
+                zipped.write(filename, filename[path_root:])
+        zipped.close()
+        return base64.b64encode(fp.getvalue()).decode('UTF-8')
+
+    def set_proxy(self, proxy):
+        import warnings
+
+        warnings.warn(
+            "This method has been deprecated. Please pass in the proxy object to the Driver Object",
+            DeprecationWarning, stacklevel=2)
+        if proxy is None:
+            raise ValueError("proxy can not be None")
+
+        if proxy.proxy_type is ProxyType.UNSPECIFIED:
+            return
+
+        self.set_preference("network.proxy.type", proxy.proxy_type['ff_value'])
+
+        if proxy.proxy_type is ProxyType.MANUAL:
+            self.set_preference("network.proxy.no_proxies_on", proxy.no_proxy)
+            self._set_manual_proxy_preference("ftp", proxy.ftp_proxy)
+            self._set_manual_proxy_preference("http", proxy.http_proxy)
+            self._set_manual_proxy_preference("ssl", proxy.ssl_proxy)
+            self._set_manual_proxy_preference("socks", proxy.socks_proxy)
+        elif proxy.proxy_type is ProxyType.PAC:
+            self.set_preference("network.proxy.autoconfig_url", proxy.proxy_autoconfig_url)
+
+    def _set_manual_proxy_preference(self, key, setting):
+        if setting is None or setting is '':
+            return
+
+        host_details = setting.split(":")
+        self.set_preference("network.proxy.%s" % key, host_details[0])
+        if len(host_details) > 1:
+            self.set_preference("network.proxy.%s_port" % key, int(host_details[1]))
+
+    def _create_tempfolder(self):
+        """
+        Creates a temp folder to store User.js and the extension
+        """
+        return tempfile.mkdtemp()
+
+    def _write_user_prefs(self, user_prefs):
+        """
+        writes the current user prefs dictionary to disk
+        """
+        with open(self.userPrefs, "w") as f:
+            for key, value in user_prefs.items():
+                f.write('user_pref("%s", %s);\n' % (key, json.dumps(value)))
+
+    def _read_existing_userjs(self, userjs):
+        import warnings
+
+        PREF_RE = re.compile(r'user_pref\("(.*)",\s(.*)\)')
+        try:
+            with open(userjs) as f:
+                for usr in f:
+                    matches = re.search(PREF_RE, usr)
+                    try:
+                        self.default_preferences[matches.group(1)] = json.loads(matches.group(2))
+                    except Exception:
+                        warnings.warn("(skipping) failed to json.loads existing preference: " +
+                                      matches.group(1) + matches.group(2))
+        except Exception:
+            # The profile given hasn't had any changes made, i.e no users.js
+            pass
+
+    def _install_extension(self, addon, unpack=True):
+        """
+            Installs addon from a filepath, url
+            or directory of addons in the profile.
+            - path: url, absolute path to .xpi, or directory of addons
+            - unpack: whether to unpack unless specified otherwise in the install.rdf
+        """
+        if addon == WEBDRIVER_EXT:
+            addon = os.path.join(os.path.dirname(__file__), WEBDRIVER_EXT)
+
+        tmpdir = None
+        xpifile = None
+        if addon.endswith('.xpi'):
+            tmpdir = tempfile.mkdtemp(suffix='.' + os.path.split(addon)[-1])
+            compressed_file = zipfile.ZipFile(addon, 'r')
+            for name in compressed_file.namelist():
+                if name.endswith('/'):
+                    if not os.path.isdir(os.path.join(tmpdir, name)):
+                        os.makedirs(os.path.join(tmpdir, name))
+                else:
+                    if not os.path.isdir(os.path.dirname(os.path.join(tmpdir, name))):
+                        os.makedirs(os.path.dirname(os.path.join(tmpdir, name)))
+                    data = compressed_file.read(name)
+                    with open(os.path.join(tmpdir, name), 'wb') as f:
+                        f.write(data)
+            xpifile = addon
+            addon = tmpdir
+
+        # determine the addon id
+        addon_details = self._addon_details(addon)
+        addon_id = addon_details.get('id')
+        assert addon_id, 'The addon id could not be found: %s' % addon
+
+        # copy the addon to the profile
+        addon_path = os.path.join(self.extensionsDir, addon_id)
+        if not unpack and not addon_details['unpack'] and xpifile:
+            if not os.path.exists(self.extensionsDir):
+                os.makedirs(self.extensionsDir)
+                os.chmod(self.extensionsDir, 0o755)
+            shutil.copy(xpifile, addon_path + '.xpi')
+        else:
+            if not os.path.exists(addon_path):
+                shutil.copytree(addon, addon_path, symlinks=True)
+
+        # remove the temporary directory, if any
+        if tmpdir:
+            shutil.rmtree(tmpdir)
+
+    def _addon_details(self, addon_path):
+        """
+        Returns a dictionary of details about the addon.
+
+        :param addon_path: path to the add-on directory or XPI
+
+        Returns::
+
+            {'id':      u'rainbow@colors.org', # id of the addon
+             'version': u'1.4',                # version of the addon
+             'name':    u'Rainbow',            # name of the addon
+             'unpack':  False }                # whether to unpack the addon
+        """
+
+        details = {
+            'id': None,
+            'unpack': False,
+            'name': None,
+            'version': None
+        }
+
+        def get_namespace_id(doc, url):
+            attributes = doc.documentElement.attributes
+            namespace = ""
+            for i in range(attributes.length):
+                if attributes.item(i).value == url:
+                    if ":" in attributes.item(i).name:
+                        # If the namespace is not the default one remove 'xlmns:'
+                        namespace = attributes.item(i).name.split(':')[1] + ":"
+                        break
+            return namespace
+
+        def get_text(element):
+            """Retrieve the text value of a given node"""
+            rc = []
+            for node in element.childNodes:
+                if node.nodeType == node.TEXT_NODE:
+                    rc.append(node.data)
+            return ''.join(rc).strip()
+
+        def parse_manifest_json(content):
+            """Extracts the details from the contents of a WebExtensions `manifest.json` file."""
+            manifest = json.loads(content)
+            try:
+                id = manifest['applications']['gecko']['id']
+            except KeyError:
+                id = manifest['name'].replace(" ", "") + "@" + manifest['version']
+            return {
+                'id': id,
+                'version': manifest['version'],
+                'name': manifest['version'],
+                'unpack': False,
+            }
+
+        if not os.path.exists(addon_path):
+            raise IOError('Add-on path does not exist: %s' % addon_path)
+
+        try:
+            if zipfile.is_zipfile(addon_path):
+                # Bug 944361 - We cannot use 'with' together with zipFile because
+                # it will cause an exception thrown in Python 2.6.
+                try:
+                    compressed_file = zipfile.ZipFile(addon_path, 'r')
+                    if 'manifest.json' in compressed_file.namelist():
+                        return parse_manifest_json(compressed_file.read('manifest.json'))
+
+                    manifest = compressed_file.read('install.rdf')
+                finally:
+                    compressed_file.close()
+            elif os.path.isdir(addon_path):
+                manifest_json_filename = os.path.join(addon_path, 'manifest.json')
+                if os.path.exists(manifest_json_filename):
+                    with open(manifest_json_filename, 'r') as f:
+                        return parse_manifest_json(f.read())
+
+                with open(os.path.join(addon_path, 'install.rdf'), 'r') as f:
+                    manifest = f.read()
+            else:
+                raise IOError('Add-on path is neither an XPI nor a directory: %s' % addon_path)
+        except (IOError, KeyError) as e:
+            raise AddonFormatError(str(e), sys.exc_info()[2])
+
+        try:
+            doc = minidom.parseString(manifest)
+
+            # Get the namespaces abbreviations
+            em = get_namespace_id(doc, 'http://www.mozilla.org/2004/em-rdf#')
+            rdf = get_namespace_id(doc, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
+
+            description = doc.getElementsByTagName(rdf + 'Description').item(0)
+            if description is None:
+                description = doc.getElementsByTagName('Description').item(0)
+            for node in description.childNodes:
+                # Remove the namespace prefix from the tag for comparison
+                entry = node.nodeName.replace(em, "")
+                if entry in details.keys():
+                    details.update({entry: get_text(node)})
+            if details.get('id') is None:
+                for i in range(description.attributes.length):
+                    attribute = description.attributes.item(i)
+                    if attribute.name == em + 'id':
+                        details.update({'id': attribute.value})
+        except Exception as e:
+            raise AddonFormatError(str(e), sys.exc_info()[2])
+
+        # turn unpack into a true/false value
+        if isinstance(details['unpack'], str):
+            details['unpack'] = details['unpack'].lower() == 'true'
+
+        # If no ID is set, the add-on is invalid
+        if details.get('id') is None:
+            raise AddonFormatError('Add-on id could not be found.')
+
+        return details

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/options.py

@@ -0,0 +1,189 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import warnings
+
+from selenium.common.exceptions import InvalidArgumentException
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.common.proxy import Proxy
+from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
+from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
+
+
+class Log(object):
+    def __init__(self):
+        self.level = None
+
+    def to_capabilities(self):
+        if self.level is not None:
+            return {"log": {"level": self.level}}
+        return {}
+
+
+class Options(object):
+    KEY = "moz:firefoxOptions"
+
+    def __init__(self):
+        self._binary = None
+        self._preferences = {}
+        self._profile = None
+        self._proxy = None
+        self._caps = DesiredCapabilities.FIREFOX.copy()
+        self._arguments = []
+        self.log = Log()
+
+    @property
+    def binary(self):
+        """Returns the FirefoxBinary instance"""
+        return self._binary
+
+    @binary.setter
+    def binary(self, new_binary):
+        """Sets location of the browser binary, either by string or
+        ``FirefoxBinary`` instance.
+
+        """
+        if not isinstance(new_binary, FirefoxBinary):
+            new_binary = FirefoxBinary(new_binary)
+        self._binary = new_binary
+
+    @property
+    def binary_location(self):
+        """Returns the location of the binary."""
+        return self.binary._start_cmd
+
+    @binary_location.setter  # noqa
+    def binary_location(self, value):
+        """ Sets the location of the browser binary by string """
+        self.binary = value
+
+    @property
+    def accept_insecure_certs(self):
+        return self._caps.get('acceptInsecureCerts')
+
+    @accept_insecure_certs.setter
+    def accept_insecure_certs(self, value):
+        self._caps['acceptInsecureCerts'] = value
+
+    @property
+    def capabilities(self):
+        return self._caps
+
+    def set_capability(self, name, value):
+        """Sets a capability."""
+        self._caps[name] = value
+
+    @property
+    def preferences(self):
+        """Returns a dict of preferences."""
+        return self._preferences
+
+    def set_preference(self, name, value):
+        """Sets a preference."""
+        self._preferences[name] = value
+
+    @property
+    def proxy(self):
+        """ returns Proxy if set otherwise None."""
+        return self._proxy
+
+    @proxy.setter
+    def proxy(self, value):
+        if not isinstance(value, Proxy):
+            raise InvalidArgumentException("Only Proxy objects can be passed in.")
+        self._proxy = value
+
+    @property
+    def profile(self):
+        """Returns the Firefox profile to use."""
+        return self._profile
+
+    @profile.setter
+    def profile(self, new_profile):
+        """Sets location of the browser profile to use, either by string
+        or ``FirefoxProfile``.
+
+        """
+        if not isinstance(new_profile, FirefoxProfile):
+            new_profile = FirefoxProfile(new_profile)
+        self._profile = new_profile
+
+    @property
+    def arguments(self):
+        """Returns a list of browser process arguments."""
+        return self._arguments
+
+    def add_argument(self, argument):
+        """Add argument to be used for the browser process."""
+        if argument is None:
+            raise ValueError()
+        self._arguments.append(argument)
+
+    @property
+    def headless(self):
+        """
+        Returns whether or not the headless argument is set
+        """
+        return '-headless' in self._arguments
+
+    @headless.setter
+    def headless(self, value):
+        """
+        Sets the headless argument
+
+        Args:
+          value: boolean value indicating to set the headless option
+        """
+        if value is True:
+            self._arguments.append('-headless')
+        elif '-headless' in self._arguments:
+            self._arguments.remove('-headless')
+
+    def set_headless(self, headless=True):
+        """ Deprecated, options.headless = True """
+        warnings.warn('use setter for headless property instead of set_headless',
+                      DeprecationWarning, stacklevel=2)
+        self.headless = headless
+
+    def to_capabilities(self):
+        """Marshals the Firefox options to a `moz:firefoxOptions`
+        object.
+
+        """
+        # This intentionally looks at the internal properties
+        # so if a binary or profile has _not_ been set,
+        # it will defer to geckodriver to find the system Firefox
+        # and generate a fresh profile.
+        caps = self._caps
+        opts = {}
+
+        if self._binary is not None:
+            opts["binary"] = self._binary._start_cmd
+        if len(self._preferences) > 0:
+            opts["prefs"] = self._preferences
+        if self._proxy is not None:
+            self._proxy.add_to_capabilities(opts)
+        if self._profile is not None:
+            opts["profile"] = self._profile.encoded
+        if len(self._arguments) > 0:
+            opts["args"] = self._arguments
+
+        opts.update(self.log.to_capabilities())
+
+        if len(opts) > 0:
+            caps[Options.KEY] = opts
+
+        return caps

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/remote_connection.py

@@ -0,0 +1,34 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+
+
+class FirefoxRemoteConnection(RemoteConnection):
+    def __init__(self, remote_server_addr, keep_alive=True):
+        RemoteConnection.__init__(self, remote_server_addr, keep_alive)
+
+        self._commands["GET_CONTEXT"] = ('GET', '/session/$sessionId/moz/context')
+        self._commands["SET_CONTEXT"] = ("POST", "/session/$sessionId/moz/context")
+        self._commands["ELEMENT_GET_ANONYMOUS_CHILDREN"] = \
+            ("POST", "/session/$sessionId/moz/xbl/$id/anonymous_children")
+        self._commands["ELEMENT_FIND_ANONYMOUS_ELEMENTS_BY_ATTRIBUTE"] = \
+            ("POST", "/session/$sessionId/moz/xbl/$id/anonymous_by_attribute")
+        self._commands["INSTALL_ADDON"] = \
+            ("POST", "/session/$sessionId/moz/addon/install")
+        self._commands["UNINSTALL_ADDON"] = \
+            ("POST", "/session/$sessionId/moz/addon/uninstall")

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/service.py

@@ -0,0 +1,54 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from selenium.webdriver.common import service
+
+
+class Service(service.Service):
+    """Object that manages the starting and stopping of the
+    GeckoDriver."""
+
+    def __init__(self, executable_path, port=0, service_args=None,
+                 log_path="geckodriver.log", env=None):
+        """Creates a new instance of the GeckoDriver remote service proxy.
+
+        GeckoDriver provides a HTTP interface speaking the W3C WebDriver
+        protocol to Marionette.
+
+        :param executable_path: Path to the GeckoDriver binary.
+        :param port: Run the remote service on a specified port.
+            Defaults to 0, which binds to a random open port of the
+            system's choosing.
+        :param service_args: Optional list of arguments to pass to the
+            GeckoDriver binary.
+        :param log_path: Optional path for the GeckoDriver to log to.
+            Defaults to _geckodriver.log_ in the current working directory.
+        :param env: Optional dictionary of output variables to expose
+            in the services' environment.
+
+        """
+        log_file = open(log_path, "a+") if log_path is not None and log_path != "" else None
+
+        service.Service.__init__(
+            self, executable_path, port=port, log_file=log_file, env=env)
+        self.service_args = service_args or []
+
+    def command_line_args(self):
+        return ["--port", "%d" % self.port] + self.service_args
+
+    def send_remote_shutdown_command(self):
+        pass

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/webdriver.py

@@ -0,0 +1,276 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import warnings
+
+try:
+    basestring
+except NameError:  # Python 3.x
+    basestring = str
+
+import shutil
+import sys
+from contextlib import contextmanager
+
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.remote.webdriver import WebDriver as RemoteWebDriver
+
+from .extension_connection import ExtensionConnection
+from .firefox_binary import FirefoxBinary
+from .firefox_profile import FirefoxProfile
+from .options import Options
+from .remote_connection import FirefoxRemoteConnection
+from .service import Service
+from .webelement import FirefoxWebElement
+
+
+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('addon@foo.com')
+        """
+        self.execute("UNINSTALL_ADDON", {"id": identifier})

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/webdriver_prefs.json

@@ -0,0 +1,69 @@
+{
+  "frozen": {
+    "app.update.auto": false,
+    "app.update.enabled": false,
+    "browser.displayedE10SNotice": 4,
+    "browser.download.manager.showWhenStarting": false,
+    "browser.EULA.override": true,
+    "browser.EULA.3.accepted": true,
+    "browser.link.open_external": 2,
+    "browser.link.open_newwindow": 2,
+    "browser.offline": false,
+    "browser.reader.detectedFirstArticle": true,
+    "browser.safebrowsing.enabled": false,
+    "browser.safebrowsing.malware.enabled": false,
+    "browser.search.update": false,
+    "browser.selfsupport.url" : "",
+    "browser.sessionstore.resume_from_crash": false,
+    "browser.shell.checkDefaultBrowser": false,
+    "browser.tabs.warnOnClose": false,
+    "browser.tabs.warnOnOpen": false,
+    "datareporting.healthreport.service.enabled": false,
+    "datareporting.healthreport.uploadEnabled": false,
+    "datareporting.healthreport.service.firstRun": false,
+    "datareporting.healthreport.logging.consoleEnabled": false,
+    "datareporting.policy.dataSubmissionEnabled": false,
+    "datareporting.policy.dataSubmissionPolicyAccepted": false,
+    "devtools.errorconsole.enabled": true,
+    "dom.disable_open_during_load": false,
+    "extensions.autoDisableScopes": 10,
+    "extensions.blocklist.enabled": false,
+    "extensions.checkCompatibility.nightly": false,
+    "extensions.update.enabled": false,
+    "extensions.update.notifyUser": false,
+    "javascript.enabled": true,
+    "network.manage-offline-status": false,
+    "network.http.phishy-userpass-length": 255,
+    "offline-apps.allow_by_default": true,
+    "prompts.tab_modal.enabled": false,
+    "security.fileuri.origin_policy": 3,
+    "security.fileuri.strict_origin_policy": false,
+    "signon.rememberSignons": false,
+    "toolkit.networkmanager.disable": true,
+    "toolkit.telemetry.prompted": 2,
+    "toolkit.telemetry.enabled": false,
+    "toolkit.telemetry.rejected": true,
+    "xpinstall.signatures.required": false,
+    "xpinstall.whitelist.required": false
+  },
+  "mutable": {
+    "browser.dom.window.dump.enabled": true,
+    "browser.laterrun.enabled": false,
+    "browser.newtab.url": "about:blank",
+    "browser.newtabpage.enabled": false,
+    "browser.startup.page": 0,
+    "browser.startup.homepage": "about:blank",
+    "browser.startup.homepage_override.mstone": "ignore",
+    "browser.usedOnWindows10.introURL": "about:blank",
+    "dom.max_chrome_script_run_time": 30,
+    "dom.max_script_run_time": 30,
+    "dom.report_all_js_exceptions": true,
+    "javascript.options.showInConsole": true,
+    "network.captive-portal-service.enabled": false,
+    "security.csp.enable": false,
+    "startup.homepage_welcome_url": "about:blank",
+    "startup.homepage_welcome_url.additional": "about:blank",
+    "webdriver_accept_untrusted_certs": true,
+    "webdriver_assume_untrusted_issuer": true
+  }
+}

venv/lib/python3.9/site-packages/selenium/webdriver/firefox/webelement.py

@@ -0,0 +1,49 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from selenium.webdriver.remote.webelement import WebElement as RemoteWebElement
+
+
+class FirefoxWebElement(RemoteWebElement):
+
+    @property
+    def anonymous_children(self):
+        """Retrieve the anonymous children of this element in an XBL
+        context.  This is only available in chrome context.
+
+        See the  `anonymous content documentation
+        <https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XBL/XBL_1.0_Reference/Anonymous_Content>`_
+        on MDN for more information.
+
+        """
+        return self._execute(
+            "ELEMENT_GET_ANONYMOUS_CHILDREN",
+            {"value": None})
+
+    def find_anonymous_element_by_attribute(self, name, value):
+        """Retrieve an anonymous descendant with a specified attribute
+        value.  Typically used with an (arbitrary) anonid attribute to
+        retrieve a specific anonymous child in an XBL binding.
+
+        See the  `anonymous content documentation
+        <https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XBL/XBL_1.0_Reference/Anonymous_Content>`_
+        on MDN for more information.
+
+        """
+        return self._execute(
+            "ELEMENT_FIND_ANONYMOUS_ELEMENTS_BY_ATTRIBUTE",
+            {"name": name, "value": value})["value"]