Updated script that can be controled by Nodejs web app

lib/python3.13/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.

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

@@ -0,0 +1,231 @@
+# 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 DEVNULL
+from subprocess import STDOUT
+from subprocess import Popen
+
+from typing_extensions import deprecated
+
+from selenium.common.exceptions import WebDriverException
+from selenium.webdriver.common import utils
+
+
+@deprecated("Use binary_location property in Firefox Options to set location")
+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 DEVNULL
+        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"
+            # 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

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

@@ -0,0 +1,328 @@
+# 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 typing_extensions import deprecated
+
+from selenium.common.exceptions import WebDriverException
+
+WEBDRIVER_PREFERENCES = "webdriver_prefs.json"
+
+
+@deprecated("Addons must be added after starting the session")
+class AddonFormatError(Exception):
+    """Exception for not well-formed add-on manifest files."""
+
+
+class FirefoxProfile:
+    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.
+        """
+        self._desired_preferences = {}
+        if profile_directory:
+            newprof = os.path.join(tempfile.mkdtemp(), "webdriver-py-profilecopy")
+            shutil.copytree(
+                profile_directory, newprof, ignore=shutil.ignore_patterns("parent.lock", "lock", ".parentlock")
+            )
+            self._profile_dir = newprof
+            os.chmod(self._profile_dir, 0o755)
+        else:
+            self._profile_dir = tempfile.mkdtemp()
+            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._desired_preferences = copy.deepcopy(FirefoxProfile.DEFAULT_PREFERENCES["mutable"])
+            for key, value in FirefoxProfile.DEFAULT_PREFERENCES["frozen"].items():
+                self._desired_preferences[key] = value
+
+    # Public Methods
+    def set_preference(self, key, value):
+        """Sets the preference that we want in the profile."""
+        self._desired_preferences[key] = value
+
+    @deprecated("Addons must be added after starting the session")
+    def add_extension(self, extension=None):
+        self._install_extension(extension)
+
+    def update_preferences(self):
+        """Writes the desired user prefs to disk."""
+        user_prefs = os.path.join(self._profile_dir, "user.js")
+        if os.path.isfile(user_prefs):
+            os.chmod(user_prefs, 0o644)
+            self._read_existing_userjs(user_prefs)
+        with open(user_prefs, "w", encoding="utf-8") as f:
+            for key, value in self._desired_preferences.items():
+                f.write(f'user_pref("{key}", {json.dumps(value)});\n')
+
+    # Properties
+
+    @property
+    def path(self):
+        """Gets the profile directory that is currently being used."""
+        return self._profile_dir
+
+    @property
+    @deprecated("The port is stored in the Service class")
+    def port(self):
+        """Gets the port that WebDriver is working on."""
+        return self._port
+
+    @port.setter
+    @deprecated("The port is stored in the Service class")
+    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
+    @deprecated("Allowing untrusted certs is toggled in the Options class")
+    def accept_untrusted_certs(self):
+        return self._desired_preferences["webdriver_accept_untrusted_certs"]
+
+    @accept_untrusted_certs.setter
+    @deprecated("Allowing untrusted certs is toggled in the Options class")
+    def accept_untrusted_certs(self, value) -> None:
+        if not isinstance(value, bool):
+            raise WebDriverException("Please pass in a Boolean to this call")
+        self.set_preference("webdriver_accept_untrusted_certs", value)
+
+    @property
+    @deprecated("Allowing untrusted certs is toggled in the Options class")
+    def assume_untrusted_cert_issuer(self):
+        return self._desired_preferences["webdriver_assume_untrusted_issuer"]
+
+    @assume_untrusted_cert_issuer.setter
+    @deprecated("Allowing untrusted certs is toggled in the Options class")
+    def assume_untrusted_cert_issuer(self, value) -> None:
+        if not isinstance(value, bool):
+            raise WebDriverException("Please pass in a Boolean to this call")
+
+        self.set_preference("webdriver_assume_untrusted_issuer", value)
+
+    @property
+    def encoded(self) -> str:
+        """Updates preferences and creates a zipped, base64 encoded string of
+        profile directory."""
+        if self._desired_preferences:
+            self.update_preferences()
+        fp = BytesIO()
+        with zipfile.ZipFile(fp, "w", zipfile.ZIP_DEFLATED, strict_timestamps=False) 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 _read_existing_userjs(self, userjs):
+        """Reads existing preferences and adds them to desired preference
+        dictionary."""
+        pref_pattern = re.compile(r'user_pref\("(.*)",\s(.*)\)')
+        with open(userjs, encoding="utf-8") as f:
+            for usr in f:
+                matches = pref_pattern.search(usr)
+                try:
+                    self._desired_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)}"
+                    )
+
+    @deprecated("Addons must be added after starting the session")
+    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
+        """
+        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
+        extensions_dir = os.path.join(self._profile_dir, "extensions")
+        addon_path = os.path.join(extensions_dir, addon_id)
+        if not unpack and not addon_details["unpack"] and xpifile:
+            if not os.path.exists(extensions_dir):
+                os.makedirs(extensions_dir)
+                os.chmod(extensions_dir, 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)
+
+    @deprecated("Addons must be added after starting the session")
+    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):
+                with zipfile.ZipFile(addon_path, "r") as compressed_file:
+                    if "manifest.json" in compressed_file.namelist():
+                        return parse_manifest_json(compressed_file.read("manifest.json"))
+
+                    manifest = compressed_file.read("install.rdf")
+            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

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

@@ -0,0 +1,136 @@
+# 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 typing import Any
+from typing import Dict
+from typing import Optional
+from typing import Union
+
+from typing_extensions import deprecated
+
+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_location = ""
+        self._preferences: dict = {}
+        # Firefox 129 onwards the CDP protocol will not be enabled by default. Setting this preference will enable it.
+        # https://fxdx.dev/deprecating-cdp-support-in-firefox-embracing-the-future-with-webdriver-bidi/.
+        self._preferences["remote.active-protocols"] = 3
+        self._profile: Optional[FirefoxProfile] = None
+        self.log = Log()
+
+    @property
+    @deprecated("use binary_location instead")
+    def binary(self) -> FirefoxBinary:
+        """Returns the FirefoxBinary instance."""
+        return FirefoxBinary(self._binary_location)
+
+    @binary.setter
+    @deprecated("use binary_location instead")
+    def binary(self, new_binary: Union[str, FirefoxBinary]) -> None:
+        """Sets location of the browser binary, either by string or
+        ``FirefoxBinary`` instance."""
+        if isinstance(new_binary, FirefoxBinary):
+            new_binary = new_binary._start_cmd
+        self.binary_location = str(new_binary)
+
+    @property
+    def binary_location(self) -> str:
+        """:Returns: The location of the binary."""
+        return self._binary_location
+
+    @binary_location.setter  # noqa
+    def binary_location(self, value: str) -> None:
+        """Sets the location of the browser binary by string."""
+        if not isinstance(value, str):
+            raise TypeError(self.BINARY_LOCATION_ERROR)
+        self._binary_location = 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) -> Optional[FirefoxProfile]:
+        """:Returns: The Firefox profile to use."""
+        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``."""
+        if not isinstance(new_profile, FirefoxProfile):
+            new_profile = FirefoxProfile(new_profile)
+        self._profile = new_profile
+
+    def enable_mobile(
+        self, android_package: Optional[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: Dict[str, Any] = {}
+
+        if self._binary_location:
+            opts["binary"] = self._binary_location
+        if self._preferences:
+            opts["prefs"] = self._preferences
+        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()

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

@@ -0,0 +1,47 @@
+# 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 typing import Optional
+
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+from selenium.webdriver.remote.client_config import ClientConfig
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+
+
+class FirefoxRemoteConnection(RemoteConnection):
+    browser_name = DesiredCapabilities.FIREFOX["browserName"]
+
+    def __init__(
+        self,
+        remote_server_addr: str,
+        keep_alive: bool = True,
+        ignore_proxy: Optional[bool] = False,
+        client_config: Optional[ClientConfig] = None,
+    ) -> None:
+        client_config = client_config or ClientConfig(
+            remote_server_addr=remote_server_addr, keep_alive=keep_alive, timeout=120
+        )
+        super().__init__(
+            ignore_proxy=ignore_proxy,
+            client_config=client_config,
+        )
+
+        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")

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

@@ -0,0 +1,64 @@
+# 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.types import SubprocessStdAlias
+from selenium.webdriver.common import service
+from selenium.webdriver.common import utils
+
+
+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_output: (Optional) int representation of STDOUT/DEVNULL, any IO instance or String path to file.
+    :param env: (Optional) Mapping of environment variables for the new process, defaults to `os.environ`.
+    """
+
+    def __init__(
+        self,
+        executable_path: str = None,
+        port: int = 0,
+        service_args: typing.Optional[typing.List[str]] = None,
+        log_output: SubprocessStdAlias = None,
+        env: typing.Optional[typing.Mapping[str, str]] = None,
+        driver_path_env_key: str = None,
+        **kwargs,
+    ) -> None:
+        self.service_args = service_args or []
+        driver_path_env_key = driver_path_env_key or "SE_GECKODRIVER"
+
+        super().__init__(
+            executable_path=executable_path,
+            port=port,
+            log_output=log_output,
+            env=env,
+            driver_path_env_key=driver_path_env_key,
+            **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

lib/python3.13/site-packages/selenium/webdriver/firefox/webdriver.py

@@ -0,0 +1,222 @@
+# 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 os
+import warnings
+import zipfile
+from contextlib import contextmanager
+from io import BytesIO
+
+from selenium.webdriver.common.driver_finder import DriverFinder
+from selenium.webdriver.remote.webdriver import WebDriver as RemoteWebDriver
+
+from .options import Options
+from .remote_connection import FirefoxRemoteConnection
+from .service import Service
+
+
+class WebDriver(RemoteWebDriver):
+    """Controls the GeckoDriver and allows you to drive the browser."""
+
+    CONTEXT_CHROME = "chrome"
+    CONTEXT_CONTENT = "content"
+
+    def __init__(
+        self,
+        options: Options = None,
+        service: Service = None,
+        keep_alive: bool = True,
+    ) -> None:
+        """Creates a new instance of the Firefox driver. Starts the service and
+        then creates new instance of Firefox driver.
+
+        :Args:
+         - options - Instance of ``options.Options``.
+         - service - (Optional) service instance for managing the starting and stopping of the driver.
+         - keep_alive - Whether to configure remote_connection.RemoteConnection to use HTTP keep-alive.
+        """
+
+        self.service = service if service else Service()
+        options = options if options else Options()
+
+        finder = DriverFinder(self.service, options)
+        if finder.get_browser_path():
+            options.binary_location = finder.get_browser_path()
+            options.browser_version = None
+
+        self.service.path = self.service.env_path() or finder.get_driver_path()
+        self.service.start()
+
+        executor = FirefoxRemoteConnection(
+            remote_server_addr=self.service.service_url,
+            keep_alive=keep_alive,
+            ignore_proxy=options._ignore_local_proxy,
+        )
+
+        try:
+            super().__init__(command_executor=executor, options=options)
+        except Exception:
+            self.quit()
+            raise
+
+        self._is_remote = False
+
+    def quit(self) -> None:
+        """Closes the browser and shuts down the GeckoDriver executable."""
+        try:
+            super().quit()
+        except Exception:
+            # We don't care about the message because something probably has gone wrong
+            pass
+        finally:
+            self.service.stop()
+
+    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 temporary: allows you to load browser extensions temporarily during a session
+        :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()
+            # filter all trailing slash found in path
+            path = os.path.normpath(path)
+            # account for trailing slash that will be added by os.walk()
+            path_root = len(path) + 1
+            with zipfile.ZipFile(fp, "w", zipfile.ZIP_DEFLATED) as zipped:
+                for base, _, 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"]

lib/python3.13/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
+  }
+}