seleniumbase 4.33.4__py3-none-any.whl → 4.34.2__py3-none-any.whl

seleniumbase/core/browser_launcher.py

@@ -1,6 +1,7 @@
 import fasteners
 import logging
 import os
+import platform
 import re
 import shutil
 import subprocess
@@ -64,6 +65,7 @@ LOCAL_EDGEDRIVER = None
 LOCAL_IEDRIVER = None
 LOCAL_HEADLESS_IEDRIVER = None
 LOCAL_UC_DRIVER = None
+ARCH = platform.architecture()[0]
 IS_ARM_MAC = shared_utils.is_arm_mac()
 IS_MAC = shared_utils.is_mac()
 IS_LINUX = shared_utils.is_linux()
@@ -97,26 +99,12 @@ def log_d(message):
         print(message)
 
 
-def make_writable(file_path):
-    # Set permissions to: "If you can read it, you can write it."
-    mode = os.stat(file_path).st_mode
-    mode |= (mode & 0o444) >> 1  # copy R bits to W
-    os.chmod(file_path, mode)
-
-
-def make_executable(file_path):
-    # Set permissions to: "If you can read it, you can execute it."
-    mode = os.stat(file_path).st_mode
-    mode |= (mode & 0o444) >> 2  # copy R bits to X
-    os.chmod(file_path, mode)
-
-
 def make_driver_executable_if_not(driver_path):
     # Verify driver has executable permissions. If not, add them.
     permissions = oct(os.stat(driver_path)[0])[-3:]
     if "4" in permissions or "6" in permissions:
         # We want at least a '5' or '7' to make sure it's executable
-        make_executable(driver_path)
+        shared_utils.make_executable(driver_path)
 
 
 def extend_driver(driver):
@@ -547,10 +535,26 @@ def uc_open_with_cdp_mode(driver, url=None):
     if url_protocol not in ["about", "data", "chrome"]:
         safe_url = False
 
+    headless = False
+    headed = None
+    xvfb = None
+    if hasattr(sb_config, "headless"):
+        headless = sb_config.headless
+    if hasattr(sb_config, "headed"):
+        headed = sb_config.headed
+    if hasattr(sb_config, "xvfb"):
+        xvfb = sb_config.xvfb
+
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     driver.cdp_base = loop.run_until_complete(
-        cdp_util.start(host=cdp_host, port=cdp_port)
+        cdp_util.start(
+            host=cdp_host,
+            port=cdp_port,
+            headless=headless,
+            headed=headed,
+            xvfb=xvfb,
+        )
     )
     loop.run_until_complete(driver.cdp_base.wait(0))
 
@@ -566,6 +570,10 @@ def uc_open_with_cdp_mode(driver, url=None):
         for tab in driver.cdp_base.tabs[-1::-1]:
             if "chrome-extension://" not in str(tab):
                 with gui_lock:
+                    with suppress(Exception):
+                        shared_utils.make_writable(
+                            constants.MultiBrowser.PYAUTOGUILOCK
+                        )
                     loop.run_until_complete(tab.activate())
                 break
 
@@ -580,11 +588,17 @@ def uc_open_with_cdp_mode(driver, url=None):
         if page_tab:
             loop.run_until_complete(page_tab.aopen())
             with gui_lock:
+                with suppress(Exception):
+                    shared_utils.make_writable(
+                        constants.MultiBrowser.PYAUTOGUILOCK
+                    )
                 loop.run_until_complete(page_tab.activate())
 
     loop.run_until_complete(driver.cdp_base.update_targets())
     page = loop.run_until_complete(driver.cdp_base.get(url))
     with gui_lock:
+        with suppress(Exception):
+            shared_utils.make_writable(constants.MultiBrowser.PYAUTOGUILOCK)
         loop.run_until_complete(page.activate())
     loop.run_until_complete(page.wait())
     if not safe_url:
@@ -604,6 +618,7 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.find_element = CDPM.find_element
     cdp.find = CDPM.find_element
     cdp.locator = CDPM.find_element
+    cdp.find_element_by_text = CDPM.find_element_by_text
     cdp.find_all = CDPM.find_all
     cdp.find_elements_by_text = CDPM.find_elements_by_text
     cdp.select = CDPM.select
@@ -662,6 +677,7 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.get_window = CDPM.get_window
     cdp.get_element_attributes = CDPM.get_element_attributes
     cdp.get_element_attribute = CDPM.get_element_attribute
+    cdp.get_attribute = CDPM.get_attribute
     cdp.get_element_html = CDPM.get_element_html
     cdp.get_element_rect = CDPM.get_element_rect
     cdp.get_element_size = CDPM.get_element_size
@@ -817,6 +833,72 @@ def verify_pyautogui_has_a_headed_browser(driver):
         )
 
 
+def __install_pyautogui_if_missing():
+    try:
+        import pyautogui
+        with suppress(Exception):
+            use_pyautogui_ver = constants.PyAutoGUI.VER
+            if pyautogui.__version__ != use_pyautogui_ver:
+                del pyautogui
+                shared_utils.pip_install(
+                    "pyautogui", version=use_pyautogui_ver
+                )
+                import pyautogui
+    except Exception:
+        print("\nPyAutoGUI required! Installing now...")
+        shared_utils.pip_install(
+            "pyautogui", version=constants.PyAutoGUI.VER
+        )
+        try:
+            import pyautogui
+        except Exception:
+            if (
+                IS_LINUX
+                and hasattr(sb_config, "xvfb")
+                and hasattr(sb_config, "headed")
+                and hasattr(sb_config, "headless")
+                and hasattr(sb_config, "headless2")
+                and (not sb_config.headed or sb_config.xvfb)
+                and not (sb_config.headless or sb_config.headless2)
+            ):
+                from sbvirtualdisplay import Display
+                xvfb_width = 1366
+                xvfb_height = 768
+                if (
+                    hasattr(sb_config, "_xvfb_width")
+                    and sb_config._xvfb_width
+                    and isinstance(sb_config._xvfb_width, int)
+                    and hasattr(sb_config, "_xvfb_height")
+                    and sb_config._xvfb_height
+                    and isinstance(sb_config._xvfb_height, int)
+                ):
+                    xvfb_width = sb_config._xvfb_width
+                    xvfb_height = sb_config._xvfb_height
+                    if xvfb_width < 1024:
+                        xvfb_width = 1024
+                    sb_config._xvfb_width = xvfb_width
+                    if xvfb_height < 768:
+                        xvfb_height = 768
+                    sb_config._xvfb_height = xvfb_height
+                with suppress(Exception):
+                    _xvfb_display = Display(
+                        visible=True,
+                        size=(xvfb_width, xvfb_height),
+                        backend="xvfb",
+                        use_xauth=True,
+                    )
+                    _xvfb_display.start()
+                    sb_config._virtual_display = _xvfb_display
+                    sb_config.headless_active = True
+                    if (
+                        hasattr(sb_config, "reuse_session")
+                        and sb_config.reuse_session
+                        and hasattr(sb_config, "_vd_list")
+                        and isinstance(sb_config._vd_list, list)
+                    ):
+                        sb_config._vd_list.append(_xvfb_display)
+
+
 def install_pyautogui_if_missing(driver):
     verify_pyautogui_has_a_headed_browser(driver)
     pip_find_lock = fasteners.InterProcessLock(
@@ -826,64 +908,13 @@ def install_pyautogui_if_missing(driver):
         with pip_find_lock:
             pass
     except Exception:
-        # Need write permissions
-        with suppress(Exception):
-            make_writable(constants.PipInstall.FINDLOCK)
+        # Since missing permissions, skip the locks
+        __install_pyautogui_if_missing()
+        return
     with pip_find_lock:  # Prevent issues with multiple processes
-        try:
-            import pyautogui
-            with suppress(Exception):
-                use_pyautogui_ver = constants.PyAutoGUI.VER
-                if pyautogui.__version__ != use_pyautogui_ver:
-                    del pyautogui
-                    shared_utils.pip_install(
-                        "pyautogui", version=use_pyautogui_ver
-                    )
-                    import pyautogui
-        except Exception:
-            print("\nPyAutoGUI required! Installing now...")
-            shared_utils.pip_install(
-                "pyautogui", version=constants.PyAutoGUI.VER
-            )
-            try:
-                import pyautogui
-            except Exception:
-                if (
-                    IS_LINUX
-                    and hasattr(sb_config, "xvfb")
-                    and hasattr(sb_config, "headed")
-                    and hasattr(sb_config, "headless")
-                    and hasattr(sb_config, "headless2")
-                    and (not sb_config.headed or sb_config.xvfb)
-                    and not (sb_config.headless or sb_config.headless2)
-                ):
-                    from sbvirtualdisplay import Display
-                    xvfb_width = 1366
-                    xvfb_height = 768
-                    if (
-                        hasattr(sb_config, "_xvfb_width")
-                        and sb_config._xvfb_width
-                        and isinstance(sb_config._xvfb_width, int)
-                        and hasattr(sb_config, "_xvfb_height")
-                        and sb_config._xvfb_height
-                        and isinstance(sb_config._xvfb_height, int)
-                    ):
-                        xvfb_width = sb_config._xvfb_width
-                        xvfb_height = sb_config._xvfb_height
-                        if xvfb_width < 1024:
-                            xvfb_width = 1024
-                        sb_config._xvfb_width = xvfb_width
-                        if xvfb_height < 768:
-                            xvfb_height = 768
-                        sb_config._xvfb_height = xvfb_height
-                    with suppress(Exception):
-                        xvfb_display = Display(
-                            visible=True,
-                            size=(xvfb_width, xvfb_height),
-                            backend="xvfb",
-                            use_xauth=True,
-                        )
-                        xvfb_display.start()
+        with suppress(Exception):
+            shared_utils.make_writable(constants.PipInstall.FINDLOCK)
+        __install_pyautogui_if_missing()
 
 
 def get_configured_pyautogui(pyautogui_copy):
@@ -1195,6 +1226,13 @@ def _uc_gui_click_captcha(
                     and driver.is_element_present("#challenge-form div > div")
                 ):
                     frame = "#challenge-form div > div"
+                elif (
+                    driver.is_element_present('[name*="cf-turnstile-"]')
+                    and driver.is_element_present(
+                        '[style="display: grid;"] div div'
+                    )
+                ):
+                    frame = '[style="display: grid;"] div div'
                 elif (
                     driver.is_element_present('[name*="cf-turnstile-"]')
                     and driver.is_element_present("[class*=spacer] + div div")
@@ -1411,7 +1449,7 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
             ctype = "cf_t"
         else:
             return
-    if not driver.is_connected():
+    if not driver.is_connected() and not __is_cdp_swap_needed(driver):
         driver.connect()
         time.sleep(2)
     install_pyautogui_if_missing(driver)
@@ -1423,7 +1461,10 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
     )
     with gui_lock:  # Prevent issues with multiple processes
         needs_switch = False
-        is_in_frame = js_utils.is_in_frame(driver)
+        if not __is_cdp_swap_needed(driver):
+            is_in_frame = js_utils.is_in_frame(driver)
+        else:
+            is_in_frame = False
         selector = "#challenge-stage"
         if ctype == "g_rc":
             selector = "#recaptcha-token"
@@ -1431,7 +1472,7 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
             driver.switch_to.parent_frame()
             needs_switch = True
             is_in_frame = js_utils.is_in_frame(driver)
-        if not is_in_frame:
+        if not is_in_frame and not __is_cdp_swap_needed(driver):
             # Make sure the window is on top
             page_actions.switch_to_window(
                 driver, driver.current_window_handle, 2, uc_lock=False
@@ -1498,17 +1539,18 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
                 and frame == "iframe"
             ):
                 frame = 'iframe[title="reCAPTCHA"]'
-        if not is_in_frame or needs_switch:
-            # Currently not in frame (or nested frame outside CF one)
-            try:
-                if visible_iframe or ctype == "g_rc":
-                    driver.switch_to_frame(frame)
-            except Exception:
-                if visible_iframe or ctype == "g_rc":
-                    if driver.is_element_present("iframe"):
-                        driver.switch_to_frame("iframe")
-                    else:
-                        return
+        if not __is_cdp_swap_needed(driver):
+            if not is_in_frame or needs_switch:
+                # Currently not in frame (or nested frame outside CF one)
+                try:
+                    if visible_iframe or ctype == "g_rc":
+                        driver.switch_to_frame(frame)
+                except Exception:
+                    if visible_iframe or ctype == "g_rc":
+                        if driver.is_element_present("iframe"):
+                            driver.switch_to_frame("iframe")
+                        else:
+                            return
         try:
             selector = "div.cf-turnstile"
             if ctype == "g_rc":
@@ -1518,17 +1560,20 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
                 for i in range(10):
                     pyautogui.hotkey("shift", "tab")
                     time.sleep(0.027)
+                    if ctype == "g_rc":
+                        if js_utils.get_active_element_css(driver) == "body":
+                            break
             tab_count = 0
             for i in range(34):
                 pyautogui.press("\t")
                 tab_count += 1
                 time.sleep(0.027)
                 active_element_css = js_utils.get_active_element_css(driver)
-                print(active_element_css)
                 if (
                     active_element_css.startswith(selector)
                     or active_element_css.endswith(" > div" * 2)
                     or (special_form and active_element_css.endswith(" div"))
+                    or (ctype == "g_rc" and "frame[name" in active_element_css)
                 ):
                     found_checkbox = True
                     sb_config._saved_cf_tab_count = tab_count
@@ -1548,6 +1593,7 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
             )
             and hasattr(sb_config, "_saved_cf_tab_count")
             and sb_config._saved_cf_tab_count
+            and not __is_cdp_swap_needed(driver)
         ):
             driver.uc_open_with_disconnect(driver.current_url, 3.8)
             with suppress(Exception):
@@ -1762,22 +1808,34 @@ def _add_chrome_proxy_extension(
     ):
         # Single-threaded
         if zip_it:
-            proxy_helper.create_proxy_ext(
-                proxy_string, proxy_user, proxy_pass, bypass_list
-            )
-            proxy_zip = proxy_helper.PROXY_ZIP_PATH
-            chrome_options.add_extension(proxy_zip)
+            proxy_zip_lock = fasteners.InterProcessLock(PROXY_ZIP_LOCK)
+            with proxy_zip_lock:
+                proxy_helper.create_proxy_ext(
+                    proxy_string, proxy_user, proxy_pass, bypass_list
+                )
+                proxy_zip = proxy_helper.PROXY_ZIP_PATH
+                chrome_options.add_extension(proxy_zip)
         else:
-            proxy_helper.create_proxy_ext(
-                proxy_string, proxy_user, proxy_pass, bypass_list, zip_it=False
-            )
-            proxy_dir_path = proxy_helper.PROXY_DIR_PATH
-            chrome_options = add_chrome_ext_dir(chrome_options, proxy_dir_path)
+            proxy_dir_lock = fasteners.InterProcessLock(PROXY_DIR_LOCK)
+            with proxy_dir_lock:
+                proxy_helper.create_proxy_ext(
+                    proxy_string,
+                    proxy_user,
+                    proxy_pass,
+                    bypass_list,
+                    zip_it=False,
+                )
+                proxy_dir_path = proxy_helper.PROXY_DIR_PATH
+                chrome_options = add_chrome_ext_dir(
+                    chrome_options, proxy_dir_path
+                )
     else:
         # Multi-threaded
         if zip_it:
             proxy_zip_lock = fasteners.InterProcessLock(PROXY_ZIP_LOCK)
             with proxy_zip_lock:
+                with suppress(Exception):
+                    shared_utils.make_writable(PROXY_ZIP_LOCK)
                 if multi_proxy:
                     _set_proxy_filenames()
                 if not os.path.exists(proxy_helper.PROXY_ZIP_PATH):
@@ -1789,6 +1847,8 @@ def _add_chrome_proxy_extension(
         else:
             proxy_dir_lock = fasteners.InterProcessLock(PROXY_DIR_LOCK)
             with proxy_dir_lock:
+                with suppress(Exception):
+                    shared_utils.make_writable(PROXY_DIR_LOCK)
                 if multi_proxy:
                     _set_proxy_filenames()
                 if not os.path.exists(proxy_helper.PROXY_DIR_PATH):
@@ -1797,7 +1857,7 @@ def _add_chrome_proxy_extension(
                         proxy_user,
                         proxy_pass,
                         bypass_list,
-                        False,
+                        zip_it=False,
                     )
                 chrome_options = add_chrome_ext_dir(
                     chrome_options, proxy_helper.PROXY_DIR_PATH
@@ -1814,6 +1874,8 @@ def is_using_uc(undetectable, browser_name):
 def _unzip_to_new_folder(zip_file, folder):
     proxy_dir_lock = fasteners.InterProcessLock(PROXY_DIR_LOCK)
     with proxy_dir_lock:
+        with suppress(Exception):
+            shared_utils.make_writable(PROXY_DIR_LOCK)
         if not os.path.exists(folder):
             import zipfile
             zip_ref = zipfile.ZipFile(zip_file, "r")
@@ -2298,7 +2360,6 @@ def _set_chrome_options(
     chrome_options.add_argument("--disable-ipc-flooding-protection")
     chrome_options.add_argument("--disable-password-generation")
     chrome_options.add_argument("--disable-domain-reliability")
-    chrome_options.add_argument("--disable-component-update")
     chrome_options.add_argument("--disable-breakpad")
     included_disabled_features = []
     included_disabled_features.append("OptimizationHints")
@@ -2383,8 +2444,6 @@ def _set_firefox_options(
     options.set_preference("dom.webnotifications.enabled", False)
     options.set_preference("dom.disable_beforeunload", True)
     options.set_preference("browser.contentblocking.database.enabled", True)
-    options.set_preference("extensions.allowPrivateBrowsingByDefault", True)
-    options.set_preference("extensions.PrivateBrowsing.notification", False)
     options.set_preference("extensions.systemAddon.update.enabled", False)
     options.set_preference("extensions.update.autoUpdateDefault", False)
     options.set_preference("extensions.update.enabled", False)
@@ -2600,6 +2659,118 @@ def get_driver(
             or browser_name == constants.Browser.EDGE
         )
     ):
+        if (
+            binary_location.lower() == "cft"
+            and browser_name == constants.Browser.GOOGLE_CHROME
+        ):
+            binary_folder = None
+            if IS_MAC:
+                if IS_ARM_MAC:
+                    binary_folder = "chrome-mac-arm64"
+                else:
+                    binary_folder = "chrome-mac-x64"
+            elif IS_LINUX:
+                binary_folder = "chrome-linux64"
+            elif IS_WINDOWS:
+                if "64" in ARCH:
+                    binary_folder = "chrome-win64"
+                else:
+                    binary_folder = "chrome-win32"
+            if binary_folder:
+                binary_location = os.path.join(DRIVER_DIR, binary_folder)
+                if not os.path.exists(binary_location):
+                    from seleniumbase.console_scripts import sb_install
+                    args = " ".join(sys.argv)
+                    if not (
+                        "-n" in sys.argv or " -n=" in args or args == "-c"
+                    ):
+                        # (Not multithreaded)
+                        sys_args = sys.argv  # Save a copy of current sys args
+                        log_d(
+                            "\nWarning: Chrome for Testing binary not found..."
+                        )
+                        try:
+                            sb_install.main(override="cft")
+                        except Exception as e:
+                            log_d("\nWarning: Chrome download failed: %s" % e)
+                        sys.argv = sys_args  # Put back the original sys args
+                    else:
+                        chrome_fixing_lock = fasteners.InterProcessLock(
+                            constants.MultiBrowser.DRIVER_FIXING_LOCK
+                        )
+                        with chrome_fixing_lock:
+                            with suppress(Exception):
+                                shared_utils.make_writable(
+                                    constants.MultiBrowser.DRIVER_FIXING_LOCK
+                                )
+                            if not os.path.exists(binary_location):
+                                sys_args = sys.argv  # Save a copy of sys args
+                                log_d(
+                                    "\nWarning: "
+                                    "Chrome for Testing binary not found..."
+                                )
+                                sb_install.main(override="cft")
+                                sys.argv = sys_args  # Put back original args
+            else:
+                binary_location = None
+        if (
+            binary_location.lower() == "chs"
+            and browser_name == constants.Browser.GOOGLE_CHROME
+        ):
+            binary_folder = None
+            if IS_MAC:
+                if IS_ARM_MAC:
+                    binary_folder = "chrome-headless-shell-mac-arm64"
+                else:
+                    binary_folder = "chrome-headless-shell-mac-x64"
+            elif IS_LINUX:
+                binary_folder = "chrome-headless-shell-linux64"
+            elif IS_WINDOWS:
+                if "64" in ARCH:
+                    binary_folder = "chrome-headless-shell-win64"
+                else:
+                    binary_folder = "chrome-headless-shell-win32"
+            if binary_folder:
+                binary_location = os.path.join(DRIVER_DIR, binary_folder)
+                if not os.path.exists(binary_location):
+                    from seleniumbase.console_scripts import sb_install
+                    args = " ".join(sys.argv)
+                    if not (
+                        "-n" in sys.argv or " -n=" in args or args == "-c"
+                    ):
+                        # (Not multithreaded)
+                        sys_args = sys.argv  # Save a copy of current sys args
+                        log_d(
+                            "\nWarning: "
+                            "Chrome-Headless-Shell binary not found..."
+                        )
+                        try:
+                            sb_install.main(override="chs")
+                        except Exception as e:
+                            log_d(
+                                "\nWarning: "
+                                "Chrome-Headless-Shell download failed: %s" % e
+                            )
+                        sys.argv = sys_args  # Put back the original sys args
+                    else:
+                        chrome_fixing_lock = fasteners.InterProcessLock(
+                            constants.MultiBrowser.DRIVER_FIXING_LOCK
+                        )
+                        with chrome_fixing_lock:
+                            with suppress(Exception):
+                                shared_utils.make_writable(
+                                    constants.MultiBrowser.DRIVER_FIXING_LOCK
+                                )
+                            if not os.path.exists(binary_location):
+                                sys_args = sys.argv  # Save a copy of sys args
+                                log_d(
+                                    "\nWarning: "
+                                    "Chrome-Headless-Shell binary not found..."
+                                )
+                                sb_install.main(override="chs")
+                                sys.argv = sys_args  # Put back original args
+            else:
+                binary_location = None
         if not os.path.exists(binary_location):
             log_d(
                 "\nWarning: The Chromium binary specified (%s) was NOT found!"
@@ -2609,7 +2780,7 @@ def get_driver(
         elif binary_location.endswith("/") or binary_location.endswith("\\"):
             log_d(
                 "\nWarning: The Chromium binary path must be a full path "
-                "that includes the driver filename at the end of it!"
+                "that includes the browser filename at the end of it!"
                 "\n(Will use default settings...)\n" % binary_location
             )
             # Example of a valid binary location path - MacOS:
@@ -2618,6 +2789,34 @@ def get_driver(
         else:
             binary_name = binary_location.split("/")[-1].split("\\")[-1]
             valid_names = get_valid_binary_names_for_browser(browser_name)
+            if binary_name == "Google Chrome for Testing.app":
+                binary_name = "Google Chrome for Testing"
+                binary_location += "/Contents/MacOS/Google Chrome for Testing"
+            elif binary_name in ["chrome-mac-arm64", "chrome-mac-x64"]:
+                binary_name = "Google Chrome for Testing"
+                binary_location += "/Google Chrome for Testing.app"
+                binary_location += "/Contents/MacOS/Google Chrome for Testing"
+            elif binary_name == "chrome-linux64":
+                binary_name = "chrome"
+                binary_location += "/chrome"
+            elif binary_name in ["chrome-win32", "chrome-win64"]:
+                binary_name = "chrome.exe"
+                binary_location += "\\chrome.exe"
+            elif binary_name in [
+                "chrome-headless-shell-mac-arm64",
+                "chrome-headless-shell-mac-x64",
+            ]:
+                binary_name = "chrome-headless-shell"
+                binary_location += "/chrome-headless-shell"
+            elif binary_name == "chrome-headless-shell-linux64":
+                binary_name = "chrome-headless-shell"
+                binary_location += "/chrome-headless-shell"
+            elif binary_name in [
+                "chrome-headless-shell-win32",
+                "chrome-headless-shell-win64",
+            ]:
+                binary_name = "chrome-headless-shell.exe"
+                binary_location += "\\chrome-headless-shell.exe"
             if binary_name not in valid_names:
                 log_d(
                     "\nWarning: The Chromium binary specified is NOT valid!"
@@ -2626,6 +2825,8 @@ def get_driver(
                     "" % (binary_name, valid_names)
                 )
                 binary_location = None
+            elif binary_location.lower() == "chs":
+                headless = True
     if (uc_cdp_events or uc_subprocess) and not undetectable:
         undetectable = True
     if mobile_emulator and not user_agent:
@@ -2923,6 +3124,8 @@ def get_remote_driver(
             constants.PipInstall.FINDLOCK
         )
         with pip_find_lock:  # Prevent issues with multiple processes
+            with suppress(Exception):
+                shared_utils.make_writable(constants.PipInstall.FINDLOCK)
             try:
                 from seleniumwire import webdriver
                 import blinker
@@ -3360,6 +3563,8 @@ def get_local_driver(
             constants.PipInstall.FINDLOCK
         )
         with pip_find_lock:  # Prevent issues with multiple processes
+            with suppress(Exception):
+                shared_utils.make_writable(constants.PipInstall.FINDLOCK)
             try:
                 from seleniumwire import webdriver
                 import blinker
@@ -3423,6 +3628,10 @@ def get_local_driver(
                     constants.MultiBrowser.DRIVER_FIXING_LOCK
                 )
                 with geckodriver_fixing_lock:
+                    with suppress(Exception):
+                        shared_utils.make_writable(
+                            constants.MultiBrowser.DRIVER_FIXING_LOCK
+                        )
                     if not geckodriver_on_path():
                         sys_args = sys.argv  # Save a copy of sys args
                         log_d(
@@ -3725,6 +3934,10 @@ def get_local_driver(
                     constants.MultiBrowser.DRIVER_FIXING_LOCK
                 )
                 with edgedriver_fixing_lock:
+                    with suppress(Exception):
+                        shared_utils.make_writable(
+                            constants.MultiBrowser.DRIVER_FIXING_LOCK
+                        )
                     msg = "Microsoft Edge Driver not found."
                     if edgedriver_upgrade_needed:
                         msg = "Microsoft Edge Driver update needed."
@@ -3783,6 +3996,12 @@ def get_local_driver(
             edge_options.add_argument("--guest")
         if dark_mode:
             edge_options.add_argument("--enable-features=WebContentsForceDark")
+        if headless1:
+            # developer.chrome.com/blog/removing-headless-old-from-chrome
+            with suppress(Exception):
+                if int(str(use_version).split(".")[0]) >= 132:
+                    headless1 = False
+                    headless2 = True
         if headless2:
             try:
                 if use_version == "latest" or int(use_version) >= 109:
@@ -4036,7 +4255,6 @@ def get_local_driver(
         edge_options.add_argument("--disable-ipc-flooding-protection")
         edge_options.add_argument("--disable-password-generation")
         edge_options.add_argument("--disable-domain-reliability")
-        edge_options.add_argument("--disable-component-update")
         edge_options.add_argument("--disable-breakpad")
         included_disabled_features = []
         included_disabled_features.append("OptimizationHints")
@@ -4108,6 +4326,10 @@ def get_local_driver(
                     constants.MultiBrowser.DRIVER_FIXING_LOCK
                 )
                 with edgedriver_fixing_lock:
+                    with suppress(Exception):
+                        shared_utils.make_writable(
+                            constants.MultiBrowser.DRIVER_FIXING_LOCK
+                        )
                     with suppress(Exception):
                         if not _was_driver_repaired():
                             _repair_edgedriver(edge_version)
@@ -4321,6 +4543,12 @@ def get_local_driver(
             use_version = find_chromedriver_version_to_use(
                 use_version, driver_version
             )
+            if headless1:
+                # developer.chrome.com/blog/removing-headless-old-from-chrome
+                with suppress(Exception):
+                    if int(str(use_version).split(".")[0]) >= 132:
+                        headless1 = False
+                        headless2 = True
             if headless2:
                 try:
                     if (
@@ -4490,6 +4718,10 @@ def get_local_driver(
                         constants.MultiBrowser.DRIVER_FIXING_LOCK
                     )
                     with chromedriver_fixing_lock:
+                        with suppress(Exception):
+                            shared_utils.make_writable(
+                                constants.MultiBrowser.DRIVER_FIXING_LOCK
+                            )
                         msg = "chromedriver update needed. Getting it now:"
                         if not path_chromedriver:
                             msg = "chromedriver not found. Getting it now:"
@@ -4581,6 +4813,10 @@ def get_local_driver(
                     constants.MultiBrowser.DRIVER_FIXING_LOCK
                 )
                 with uc_lock:  # Avoid multithreaded issues
+                    with suppress(Exception):
+                        shared_utils.make_writable(
+                            constants.MultiBrowser.DRIVER_FIXING_LOCK
+                        )
                     if make_uc_driver_from_chromedriver:
                         if os.path.exists(LOCAL_CHROMEDRIVER):
                             with suppress(Exception):
@@ -4813,7 +5049,13 @@ def get_local_driver(
                                 )
                                 uc_activated = True
                             except URLError as e:
-                                if cert in e.args[0] and IS_MAC:
+                                if (
+                                    IS_MAC
+                                    and hasattr(e, "args")
+                                    and isinstance(e.args, (list, tuple))
+                                    and len(e.args) > 0
+                                    and cert in e.args[0]
+                                ):
                                     mac_certificate_error = True
                                 else:
                                     raise
@@ -4840,6 +5082,10 @@ def get_local_driver(
                                 if not os.path.exists(cf_lock_path):
                                     # Avoid multithreaded issues
                                     with cf_lock:
+                                        with suppress(Exception):
+                                            shared_utils.make_writable(
+                                                cf_lock_path
+                                            )
                                         # Install Python Certificates (MAC)
                                         os.system(
                                             r"bash /Applications/Python*/"
@@ -4983,6 +5229,10 @@ def get_local_driver(
                             constants.MultiBrowser.DRIVER_FIXING_LOCK
                         )
                         with chromedriver_fixing_lock:
+                            with suppress(Exception):
+                                shared_utils.make_writable(
+                                    constants.MultiBrowser.DRIVER_FIXING_LOCK
+                                )
                             if not _was_driver_repaired():
                                 _repair_chromedriver(
                                     chrome_options, headless_options, mcv
@@ -5181,7 +5431,10 @@ def get_local_driver(
                             chromedr_fixing_lock = fasteners.InterProcessLock(
                                 constants.MultiBrowser.DRIVER_FIXING_LOCK
                             )
+                            D_F_L = constants.MultiBrowser.DRIVER_FIXING_LOCK
                             with chromedr_fixing_lock:
+                                with suppress(Exception):
+                                    shared_utils.make_writable(D_F_L)
                                 if not _was_driver_repaired():
                                     with suppress(Exception):
                                         _repair_chromedriver(