Merging PR_218 openai_rev package with new streamlit chat app

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,83 @@
+# 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 import utils
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
+from selenium.webdriver.remote.command import Command
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+
+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 not self.binary:
+            self.binary = FirefoxBinary()
+
+        if not HOST:
+            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 = f"http://{HOST}:{PORT}/hub"
+        super().__init__(_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(cls):
+        """Connects to an running browser and quit immediately."""
+        cls._request(f"{_URL}/extensions/firefox/quit")
+
+    @classmethod
+    def is_connectable(cls):
+        """Tries to connect to the extension but do not retrieve context."""
+        utils.is_connectable(cls.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,227 @@
+# 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 time
+from platform import system
+from subprocess import STDOUT
+from subprocess import Popen
+
+from selenium.common.exceptions import WebDriverException
+from selenium.webdriver.common import utils
+
+
+class FirefoxBinary:
+    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
+        self.platform = system().lower()
+        if not self._start_cmd:
+            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 self.platform == "linux":
+            self._modify_link_library_path()
+        command = [self._start_cmd, "-foreground"]
+        if self.command_line:
+            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():
+                # 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 "
+                    f"Dir: {self.profile.path} If you specified a log_file in the "
+                    "FirefoxBinary constructor, check it for details."
+                )
+            count += 1
+            time.sleep(1)
+        return True
+
+    def _find_exe_in_registry(self):
+        try:
+            from _winreg import HKEY_CURRENT_USER
+            from _winreg import HKEY_LOCAL_MACHINE
+            from _winreg import OpenKey
+            from _winreg import QueryValue
+        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 self.platform == "darwin":  # small darwin due to lower() in self.platform
+            ffname = "firefox"
+            start_cmd = self.which(ffname)
+            # use hardcoded path if nothing else was found by which()
+            if not start_cmd:
+                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 self.platform == "windows":  # same
+            start_cmd = self._find_exe_in_registry() or self._default_windows_location()
+        elif self.platform == "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:
+                    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, "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, 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,345 @@
+# 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 base64
+import copy
+import json
+import os
+import re
+import shutil
+import sys
+import tempfile
+import warnings
+import zipfile
+from io import BytesIO
+from xml.dom import minidom
+
+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:
+    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.
+        """
+        warnings.warn(
+            "firefox_profile has been deprecated, please use an Options object", DeprecationWarning, stacklevel=2
+        )
+        if not FirefoxProfile.DEFAULT_PREFERENCES:
+            with open(
+                os.path.join(os.path.dirname(__file__), WEBDRIVER_PREFERENCES), encoding="utf-8"
+            ) as default_prefs:
+                FirefoxProfile.DEFAULT_PREFERENCES = json.load(default_prefs)
+
+        self.default_preferences = copy.deepcopy(FirefoxProfile.DEFAULT_PREFERENCES["mutable"])
+        self.profile_dir = profile_directory
+        self.tempfolder = None
+        if not self.profile_dir:
+            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():
+            # Do not update key that is being set by the user using
+            # set_preference as users are unaware of the freeze properties
+            # and it leads to an inconsistent behavior
+            if key not in self.default_preferences:
+                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) -> None:
+        """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) -> None:
+        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) -> None:
+        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 encoded(self) -> str:
+        """A zipped, base64 encoded string of profile directory for use with
+        remote WebDriver JSON wire protocol."""
+        self.update_preferences()
+        fp = BytesIO()
+        with zipfile.ZipFile(fp, "w", zipfile.ZIP_DEFLATED) as zipped:
+            path_root = len(self.path) + 1  # account for trailing slash
+            for base, _, files in os.walk(self.path):
+                for fyle in files:
+                    filename = os.path.join(base, fyle)
+                    zipped.write(filename, filename[path_root:])
+        return base64.b64encode(fp.getvalue()).decode("UTF-8")
+
+    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", encoding="utf-8") as f:
+            for key, value in user_prefs.items():
+                f.write(f'user_pref("{key}", {json.dumps(value)});\n')
+
+    def _read_existing_userjs(self, userjs):
+        pref_pattern = re.compile(r'user_pref\("(.*)",\s(.*)\)')
+        try:
+            with open(userjs, encoding="utf-8") as f:
+                for usr in f:
+                    matches = pref_pattern.search(usr)
+                    try:
+                        self.default_preferences[matches.group(1)] = json.loads(matches.group(2))
+                    except Exception:
+                        warnings.warn(
+                            f"(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, f"The addon id could not be found: {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 OSError(f"Add-on path does not exist: {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.
+                # TODO: use with statement when Python 2.x is no longer supported
+                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, encoding="utf-8") as f:
+                        return parse_manifest_json(f.read())
+
+                with open(os.path.join(addon_path, "install.rdf"), encoding="utf-8") as f:
+                    manifest = f.read()
+            else:
+                raise OSError(f"Add-on path is neither an XPI nor a directory: {addon_path}")
+        except (OSError, 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 not description:
+                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:
+                    details.update({entry: get_text(node)})
+            if not details.get("id"):
+                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 not details.get("id"):
+            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,165 @@
+# 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 typing
+import warnings
+from typing import Union
+
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.common.options import ArgOptions
+from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
+from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
+
+
+class Log:
+    def __init__(self) -> None:
+        self.level = None
+
+    def to_capabilities(self) -> dict:
+        if self.level:
+            return {"log": {"level": self.level}}
+        return {}
+
+
+class Options(ArgOptions):
+    KEY = "moz:firefoxOptions"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._binary: typing.Optional[FirefoxBinary] = None
+        self._preferences: dict = {}
+        self._profile = None
+        self._proxy = None
+        self.log = Log()
+
+    @property
+    def binary(self) -> FirefoxBinary:
+        """Returns the FirefoxBinary instance."""
+        return self._binary
+
+    @binary.setter
+    def binary(self, new_binary: Union[str, FirefoxBinary]) -> None:
+        """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) -> str:
+        """
+        :Returns: The location of the binary.
+        """
+        return self.binary._start_cmd
+
+    @binary_location.setter  # noqa
+    def binary_location(self, value: str) -> None:
+        """Sets the location of the browser binary by string."""
+        self.binary = value
+
+    @property
+    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
+
+    @property
+    def profile(self) -> FirefoxProfile:
+        """
+        :Returns: The Firefox profile to use.
+        """
+        if self._profile:
+            warnings.warn("Getting a profile has been deprecated.", DeprecationWarning, stacklevel=2)
+        return self._profile
+
+    @profile.setter
+    def profile(self, new_profile: Union[str, FirefoxProfile]) -> None:
+        """Sets location of the browser profile to use, either by string or
+        ``FirefoxProfile``."""
+        warnings.warn(
+            "Setting a profile has been deprecated. Please use the set_preference and install_addons methods",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if not isinstance(new_profile, FirefoxProfile):
+            new_profile = FirefoxProfile(new_profile)
+        self._profile = new_profile
+
+    @property
+    def headless(self) -> bool:
+        """
+        :Returns: True if the headless argument is set, else False
+        """
+        warnings.warn(
+            "headless property is deprecated, instead check for '-headless' in arguments",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return "-headless" in self._arguments
+
+    @headless.setter
+    def headless(self, value: bool) -> None:
+        """Sets the headless argument.
+
+        Args:
+          value: boolean value indicating to set the headless option
+        """
+        warnings.warn(
+            "headless property is deprecated, instead use add_argument('-headless')", DeprecationWarning, stacklevel=2
+        )
+        if value:
+            self._arguments.append("-headless")
+        elif "-headless" in self._arguments:
+            self._arguments.remove("-headless")
+
+    def enable_mobile(self, android_package: str = "org.mozilla.firefox", android_activity=None, device_serial=None):
+        super().enable_mobile(android_package, android_activity, device_serial)
+
+    def to_capabilities(self) -> dict:
+        """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:
+            opts["binary"] = self._binary._start_cmd
+        if self._preferences:
+            opts["prefs"] = self._preferences
+        if self._proxy:
+            self._proxy.add_to_capabilities(caps)
+        if self._profile:
+            opts["profile"] = self._profile.encoded
+        if self._arguments:
+            opts["args"] = self._arguments
+        if self.mobile_options:
+            opts.update(self.mobile_options)
+
+        opts.update(self.log.to_capabilities())
+
+        if opts:
+            caps[Options.KEY] = opts
+
+        return caps
+
+    @property
+    def default_capabilities(self) -> dict:
+        return DesiredCapabilities.FIREFOX.copy()

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

@@ -0,0 +1,32 @@
+# 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.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+
+
+class FirefoxRemoteConnection(RemoteConnection):
+    browser_name = DesiredCapabilities.FIREFOX["browserName"]
+
+    def __init__(self, remote_server_addr, keep_alive=True, ignore_proxy=False) -> None:
+        super().__init__(remote_server_addr, keep_alive, ignore_proxy=ignore_proxy)
+
+        self._commands["GET_CONTEXT"] = ("GET", "/session/$sessionId/moz/context")
+        self._commands["SET_CONTEXT"] = ("POST", "/session/$sessionId/moz/context")
+        self._commands["INSTALL_ADDON"] = ("POST", "/session/$sessionId/moz/addon/install")
+        self._commands["UNINSTALL_ADDON"] = ("POST", "/session/$sessionId/moz/addon/uninstall")
+        self._commands["FULL_PAGE_SCREENSHOT"] = ("GET", "/session/$sessionId/moz/screenshot/full")

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

@@ -0,0 +1,65 @@
+# 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 typing
+from typing import List
+
+from selenium.webdriver.common import service
+from selenium.webdriver.common import utils
+
+DEFAULT_EXECUTABLE_PATH = "geckodriver"
+
+
+class Service(service.Service):
+    """A Service class that is responsible for the starting and stopping of
+    `geckodriver`.
+
+    :param executable_path: install path of the geckodriver executable, defaults to `geckodriver`.
+    :param port: Port for the service to run on, defaults to 0 where the operating system will decide.
+    :param service_args: (Optional) List of args to be passed to the subprocess when launching the executable.
+    :param log_path: (Optional) File path for the file to be opened and passed as the subprocess stdout/stderr handler,
+        defaults to `geckodriver.log`.
+    :param env: (Optional) Mapping of environment variables for the new process, defaults to `os.environ`.
+    """
+
+    def __init__(
+        self,
+        executable_path: str = DEFAULT_EXECUTABLE_PATH,
+        port: int = 0,
+        service_args: typing.Optional[typing.List[str]] = None,
+        log_path: typing.Optional[str] = None,
+        env: typing.Optional[typing.Mapping[str, str]] = None,
+        **kwargs,
+    ) -> None:
+        # Todo: This is vastly inconsistent, requires a follow up to standardise.
+        file = log_path or "geckodriver.log"
+        log_file = open(file, "a+", encoding="utf-8")
+        self.service_args = service_args or []
+        super().__init__(
+            executable=executable_path,
+            port=port,
+            log_file=log_file,
+            env=env,
+            **kwargs,
+        )
+
+        # Set a port for CDP
+        if "--connect-existing" not in self.service_args:
+            self.service_args.append("--websocket-port")
+            self.service_args.append(f"{utils.free_port()}")
+
+    def command_line_args(self) -> List[str]:
+        return ["--port", f"{self.port}"] + self.service_args

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

@@ -0,0 +1,375 @@
+# 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 base64
+import logging
+import os
+import warnings
+import zipfile
+from contextlib import contextmanager
+from io import BytesIO
+from shutil import rmtree
+
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.common.driver_finder import DriverFinder
+from selenium.webdriver.remote.webdriver import WebDriver as RemoteWebDriver
+
+from .firefox_binary import FirefoxBinary
+from .firefox_profile import FirefoxProfile
+from .options import Options
+from .remote_connection import FirefoxRemoteConnection
+from .service import DEFAULT_EXECUTABLE_PATH
+from .service import Service
+
+logger = logging.getLogger(__name__)
+
+# Default for log_path variable. To be deleted when deprecations for arguments are removed.
+DEFAULT_LOG_PATH = None
+DEFAULT_SERVICE_LOG_PATH = "geckodriver.log"
+
+
+class WebDriver(RemoteWebDriver):
+    CONTEXT_CHROME = "chrome"
+    CONTEXT_CONTENT = "content"
+
+    def __init__(
+        self,
+        firefox_profile=None,
+        firefox_binary=None,
+        capabilities=None,
+        proxy=None,
+        executable_path=DEFAULT_EXECUTABLE_PATH,
+        options=None,
+        service_log_path=DEFAULT_SERVICE_LOG_PATH,
+        service_args=None,
+        service=None,
+        desired_capabilities=None,
+        log_path=DEFAULT_LOG_PATH,
+        keep_alive=True,  # Todo: Why is this now unused?
+    ) -> None:
+        """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.  Similarly, if you had specified a
+        `capabilities["moz:firefoxOptions"]["profile"]` Base64 string,
+        this would rank below `options.profile`.
+
+        :param firefox_profile: Deprecated: 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: Deprecated: Instance of ``FirefoxBinary`` or full
+            path to the Firefox binary.  If undefined, the system default
+            Firefox installation will  be used.
+        :param capabilities: Deprecated: Dictionary of desired capabilities.
+        :param proxy: Deprecated: The proxy settings to use when communicating with
+            Firefox via the extension connection.
+        :param executable_path: Deprecated: 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: (Optional) service instance for managing the starting and stopping of the driver.
+        :param service_log_path: Deprecated: Where to log information from the driver.
+        :param service_args: Deprecated: List of args to pass to the driver service
+        :param desired_capabilities: Deprecated: alias of capabilities. In future
+            versions of this library, this will replace 'capabilities'.
+            This will make the signature consistent with RemoteWebDriver.
+        :param keep_alive: Whether to configure remote_connection.RemoteConnection to use
+             HTTP keep-alive.
+        """
+
+        if executable_path != DEFAULT_EXECUTABLE_PATH:
+            warnings.warn(
+                "executable_path has been deprecated, please pass in a Service object", DeprecationWarning, stacklevel=2
+            )
+        if capabilities or desired_capabilities:
+            warnings.warn(
+                "capabilities and desired_capabilities have been deprecated, please pass in a Service object",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if firefox_binary:
+            warnings.warn(
+                "firefox_binary has been deprecated, please pass in a Service object", DeprecationWarning, stacklevel=2
+            )
+        self.binary = None
+        if firefox_profile:
+            warnings.warn(
+                "firefox_profile has been deprecated, please pass in an Options object",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        self.profile = None
+
+        if log_path != DEFAULT_LOG_PATH:
+            warnings.warn(
+                "log_path has been deprecated, please pass in a Service object", DeprecationWarning, stacklevel=2
+            )
+
+        # Service Arguments being deprecated.
+        if service_log_path != DEFAULT_SERVICE_LOG_PATH:
+            warnings.warn(
+                "service_log_path has been deprecated, please pass in a Service object",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if service_args:
+            warnings.warn(
+                "service_args has been deprecated, please pass in a Service object", DeprecationWarning, stacklevel=2
+            )
+
+        self.service = service
+
+        # If desired capabilities is set, alias it to capabilities.
+        # If both are set ignore desired capabilities.
+        if not capabilities and desired_capabilities:
+            capabilities = desired_capabilities
+
+        if not capabilities:
+            capabilities = DesiredCapabilities.FIREFOX.copy()
+        if not options:
+            options = Options()
+
+        capabilities = dict(capabilities)
+
+        if capabilities.get("binary"):
+            options.binary = capabilities["binary"]
+
+        # options overrides capabilities
+        if options:
+            if options.binary:
+                self.binary = options.binary
+            if options.profile:
+                self.profile = options.profile
+
+        # firefox_binary and firefox_profile
+        # override options
+        if firefox_binary:
+            if isinstance(firefox_binary, str):
+                firefox_binary = FirefoxBinary(firefox_binary)
+            self.binary = firefox_binary
+            options.binary = firefox_binary
+        if firefox_profile:
+            if isinstance(firefox_profile, str):
+                firefox_profile = FirefoxProfile(firefox_profile)
+            self.profile = firefox_profile
+            options.profile = firefox_profile
+
+        if not capabilities.get("acceptInsecureCerts") or not options.accept_insecure_certs:
+            options.accept_insecure_certs = False
+
+        if not self.service:
+            self.service = Service(executable_path, service_args=service_args, log_path=service_log_path)
+        self.service.path = DriverFinder.get_path(self.service, options)
+        self.service.start()
+
+        executor = FirefoxRemoteConnection(
+            remote_server_addr=self.service.service_url, ignore_proxy=options._ignore_local_proxy
+        )
+        super().__init__(command_executor=executor, options=options, keep_alive=True)
+
+        self._is_remote = False
+
+    def quit(self) -> None:
+        """Quits the driver and close every associated window."""
+        try:
+            super().quit()
+        except Exception:
+            # We don't care about the message because something probably has gone wrong
+            pass
+
+        self.service.stop()
+
+        if self.profile:
+            try:
+                rmtree(self.profile.path)
+                if self.profile.tempfolder:
+                    rmtree(self.profile.tempfolder)
+            except Exception:
+                logger.exception("Unable to remove profile specific paths.")
+
+        self._close_binary_file_handle()
+
+    def _close_binary_file_handle(self) -> None:
+        """Attempts to close the underlying file handles for `FirefoxBinary`
+        instances if they are used and open.
+
+        To keep inline with other cleanup raising here is swallowed and
+        will not cause a runtime error.
+        """
+        try:
+            if isinstance(self.binary, FirefoxBinary):
+                if hasattr(self.binary._log_file, "close"):
+                    self.binary._log_file.close()
+        except Exception:
+            logger.exception("Unable to close open file handle for firefox binary log file.")
+
+    @property
+    def firefox_profile(self):
+        return self.profile
+
+    # Extension commands:
+
+    def set_context(self, context) -> None:
+        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=False) -> str:
+        """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')
+        """
+
+        if os.path.isdir(path):
+            fp = BytesIO()
+            path_root = len(path) + 1  # account for trailing slash
+            with zipfile.ZipFile(fp, "w", zipfile.ZIP_DEFLATED) as zipped:
+                for base, dirs, files in os.walk(path):
+                    for fyle in files:
+                        filename = os.path.join(base, fyle)
+                        zipped.write(filename, filename[path_root:])
+            addon = base64.b64encode(fp.getvalue()).decode("UTF-8")
+        else:
+            with open(path, "rb") as file:
+                addon = base64.b64encode(file.read()).decode("UTF-8")
+
+        payload = {"addon": addon, "temporary": temporary}
+        return self.execute("INSTALL_ADDON", payload)["value"]
+
+    def uninstall_addon(self, identifier) -> None:
+        """Uninstalls Firefox addon using its identifier.
+
+        :Usage:
+            ::
+
+                driver.uninstall_addon('addon@foo.com')
+        """
+        self.execute("UNINSTALL_ADDON", {"id": identifier})
+
+    def get_full_page_screenshot_as_file(self, filename) -> bool:
+        """Saves a full document screenshot of the current window to a PNG
+        image file. Returns False if there is any IOError, else returns True.
+        Use full paths in your filename.
+
+        :Args:
+         - filename: The full path you wish to save your screenshot to. This
+           should end with a `.png` extension.
+
+        :Usage:
+            ::
+
+                driver.get_full_page_screenshot_as_file('/Screenshots/foo.png')
+        """
+        if not filename.lower().endswith(".png"):
+            warnings.warn(
+                "name used for saved screenshot does not match file " "type. It should end with a `.png` extension",
+                UserWarning,
+            )
+        png = self.get_full_page_screenshot_as_png()
+        try:
+            with open(filename, "wb") as f:
+                f.write(png)
+        except OSError:
+            return False
+        finally:
+            del png
+        return True
+
+    def save_full_page_screenshot(self, filename) -> bool:
+        """Saves a full document screenshot of the current window to a PNG
+        image file. Returns False if there is any IOError, else returns True.
+        Use full paths in your filename.
+
+        :Args:
+         - filename: The full path you wish to save your screenshot to. This
+           should end with a `.png` extension.
+
+        :Usage:
+            ::
+
+                driver.save_full_page_screenshot('/Screenshots/foo.png')
+        """
+        return self.get_full_page_screenshot_as_file(filename)
+
+    def get_full_page_screenshot_as_png(self) -> bytes:
+        """Gets the full document screenshot of the current window as a binary
+        data.
+
+        :Usage:
+            ::
+
+                driver.get_full_page_screenshot_as_png()
+        """
+        return base64.b64decode(self.get_full_page_screenshot_as_base64().encode("ascii"))
+
+    def get_full_page_screenshot_as_base64(self) -> str:
+        """Gets the full document screenshot of the current window as a base64
+        encoded string which is useful in embedded images in HTML.
+
+        :Usage:
+            ::
+
+                driver.get_full_page_screenshot_as_base64()
+        """
+        return self.execute("FULL_PAGE_SCREENSHOT")["value"]

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
+  }
+}