Patcher

from undetected import Patcher

# Automatic usage (handled by Chrome class)
driver = uc.Chrome()  # Patcher used internally

# Manual usage for multiprocessing
Patcher.patch()

Patcher(
    version_main: int,
    driver_executable_path: str = None,
    user_multi_procs: bool = False,
    for_patch: bool = False
)

from undetected import Patcher

patcher = Patcher(
    version_main=120,
    driver_executable_path='/custom/path/chromedriver'
)

@staticmethod
Patcher.patch(
    browser_executable_path: str = None,
    driver_executable_path: str = None
)

from undetected import Patcher
import multiprocessing

# Call once before multiprocessing
Patcher.patch()

def worker():
    import undetected as uc
    driver = uc.Chrome(user_multi_procs=True)
    driver.get('https://example.com')
    driver.quit()

if __name__ == '__main__':
    processes = []
    for _ in range(4):
        p = multiprocessing.Process(target=worker)
        p.start()
        processes.append(p)
    
    for p in processes:
        p.join()

@classmethod
Patcher.cleanup_unused_files()

from undetected import Patcher

# Clean up old ChromeDriver files
Patcher.cleanup_unused_files()

@staticmethod
Patcher.kill_all_instances(path: str)

from undetected import Patcher

Patcher.kill_all_instances('/path/to/chromedriver')

patcher.verify() -> bool

patcher = Patcher(version_main=120)
if patcher.verify():
    print(f"Valid binary found at: {patcher.driver_executable_path}")
else:
    print("No valid binary found")

patcher.download_and_patch() -> bool

patcher = Patcher(version_main=120)
patcher.download_and_patch()
print(f"Patched driver at: {patcher.driver_executable_path}")

patcher.fetch_release_number() -> Version

from undetected import Patcher

patcher = Patcher(version_main=120)
version = patcher.fetch_release_number()
print(f"Full version: {version}")  # e.g., 120.0.6099.109

patcher.fetch_package() -> str

patcher = Patcher(version_main=120)
patcher.version_full = patcher.fetch_release_number()
zip_path = patcher.fetch_package()
print(f"Downloaded to: {zip_path}")

patcher.unzip_package(fp: str) -> str

zip_path = patcher.fetch_package()
exe_path = patcher.unzip_package(zip_path)
print(f"Extracted to: {exe_path}")

patcher.patch_exe()

patcher = Patcher(version_main=120)
patcher.download_and_patch()  # Calls patch_exe internally

patcher.is_binary_patched(driver_executable_path: str = None) -> bool

if patcher.is_binary_patched('/path/to/chromedriver'):
    print("Binary is patched")
else:
    print("Binary needs patching")

patcher.driver_binary_in_use(path: str = None) -> bool

if patcher.driver_binary_in_use():
    print("ChromeDriver is currently running")

patcher.parse_exe_version() -> Version

patcher = Patcher(version_main=120)
version = patcher.parse_exe_version()
print(f"Binary version: {version}")

# The patching process
patcher = Patcher(version_main=120)
release = patcher.fetch_release_number()  # Get full version
zip_path = patcher.fetch_package()         # Download ZIP
patcher.unzip_package(zip_path)            # Extract
patcher.patch_exe()                        # Apply patches
patcher.is_binary_patched()                # Verify

from undetected import Patcher, Chrome
from multiprocessing import Process

# IMPORTANT: Call before spawning processes
Patcher.patch()

def run_browser(url):
    driver = Chrome(user_multi_procs=True)
    driver.get(url)
    print(driver.title)
    driver.quit()

if __name__ == '__main__':
    urls = ['https://example.com', 'https://example.org']
    processes = [Process(target=run_browser, args=(url,)) for url in urls]
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()