Selenium Driverless

Sans conducteur (utilisation non commerciale uniquement!)

Remarque: ce projet s'éloigne de la syntaxe de sélénium

Documentation

• Utilisez du sélénium sans chromedriver
• Passe actuellement Cloudflare , Bet365 , Tursitile et autres
• Plusieurs onglets simultanément
• Plusieurs contextes incognito avec cookies isolés et stockage local
• Support proxy-AuTH (exemple de code)
• Interception du réseau (documentation)
• Demandes uniques (documentation)

Vous être détecté avec les interactions?

CDP-Patches (Headfull Uniquement) devrait résoudre ce problème
(l'intégrera à un moment donné)

Questions?

N'hésitez pas à rejoindre la communauté sans conducteur sur Discord :)

Voir également Dev-Branch pour les dernières implémentations.

Dev-installation (cliquez pour développer)

pip uninstall -y selenium-driverless
pip install https://github.com/kaliiiiiiiiii/Selenium-Driverless/archive/refs/heads/dev.zip

Sponsors

Ce projet n'est actuellement pas parrainé.

Dépendances

• Python> = 3,8
• Google-chrome installé (chrome non testé)

Installation

• Installer google-chrome
• pip install selenium-driverless

Usage

avec asyncio

 from selenium_driverless import webdriver
from selenium_driverless . types . by import By
import asyncio


async def main ():
    options = webdriver . ChromeOptions ()
    async with webdriver . Chrome ( options = options ) as driver :
        await driver . get ( 'http://nowsecure.nl#relax' , wait_load = True )
        await driver . sleep ( 0.5 )
        await driver . wait_for_cdp ( "Page.domContentEventFired" , timeout = 15 )
        
        # wait 10s for elem to exist
        elem = await driver . find_element ( By . XPATH , '/html/body/div[2]/div/main/p[2]/a' , timeout = 10 )
        await elem . click ( move_to = True )

        alert = await driver . switch_to . alert
        print ( alert . text )
        await alert . accept ()

        print ( await driver . title )


asyncio . run ( main ())

synchrone

asyndicaté, les bogues doivent s'attendre

exemple de code

 from selenium_driverless . sync import webdriver

options = webdriver . ChromeOptions ()
with webdriver . Chrome ( options = options ) as driver :
    driver . get ( 'http://nowsecure.nl#relax' )
    driver . sleep ( 0.5 )
    driver . wait_for_cdp ( "Page.domContentEventFired" , timeout = 15 )

    title = driver . title
    url = driver . current_url
    source = driver . page_source
    print ( title )

Adresse de débogueur personnalisée

 from selenium_driverless import webdriver

options = webdriver . ChromeOptions ()
options . debugger_address = "127.0.0.1:2005"

# specify if you don't want to run remote
# options.add_argument("--remote-debugging-port=2005")

async with webdriver . Chrome ( options = options ) as driver :
  await driver . get ( 'http://nowsecure.nl#relax' , wait_load = True )

Plusieurs onglets simultanément

Remarque: Asyncio est recommandé, le threadage ne fonctionne que sur des instances Webdriver indépendantes.

Exemple de code (cliquez pour agrandir)

 from selenium_driverless . sync import webdriver
from selenium_driverless . utils . utils import read
from selenium_driverless import webdriver
import asyncio


async def target_1_handler ( target ):
    await target . get ( 'https://abrahamjuliot.github.io/creepjs/' )
    print ( await target . title )


async def target_2_handler ( target ):
    await target . get ( "about:blank" )
    await target . execute_script ( await script = read ( "/files/js/show_mousemove.js" ))
    await target . pointer . move_to ( 500 , 500 , total_time = 2 )


async def main ():
    options = webdriver . ChromeOptions ()
    async with webdriver . Chrome ( options = options ) as driver :
        target_1 = await driver . current_target
        target_2 = await driver . new_window ( "tab" , activate = False )
        await asyncio . gather (
            target_1_handler ( target_1 ),
            target_2_handler ( target_2 )
        )
        await target_1 . focus ()
        input ( "press ENTER to exit" )


asyncio . run ( main ())

Contextes d'exécution isolés

• Exécuter javascript sans être détecté (dans un monde isolé )

Exemple de code (cliquez pour agrandir)

 from selenium_driverless . sync import webdriver
from selenium_driverless import webdriver
import asyncio


async def main ():
    options = webdriver . ChromeOptions ()
    async with webdriver . Chrome ( options = options ) as driver :
        await driver . get ( 'chrome://version' )
        script = """
        const proxy = new Proxy(document.documentElement, {
          get(target, prop, receiver) {
            if(prop === "outerHTML"){
                console.log('detected access on "'+prop+'"', receiver)
                return "mocked value:)"
            }
            else{return Reflect.get(...arguments)}
          },
        });
        Object.defineProperty(document, "documentElement", {
          value: proxy
        })
        """
        await driver . execute_script ( script )
        src = await driver . execute_script ( "return document.documentElement.outerHTML" , unique_context = True )
        mocked = await driver . execute_script ( "return document.documentElement.outerHTML" , unique_context = False )
        print ( src , mocked )


asyncio . run ( main ())

Interaction du pointeur

Voir @ maître / tests / show_mousmove.py pour la visualisation

 pointer = driver . current_pointer
move_kwargs = { "total_time" : 0.7 , "accel" : 2 , "smooth_soft" : 20 }

await pointer . move_to ( 100 , 500 )
await pointer . click ( 500 , 50 , move_kwargs = move_kwargs , move_to = True )

Iframes / cadres

dû swtich_to.frame() déprécié pour sans conducteur, utilisez-le à la place

 iframes = await driver . find_elements ( By . TAG_NAME , "iframe" )
await asyncio . sleep ( 0.5 )
iframe_document = await iframes [ 0 ]. content_document
# iframe_document.find_elements(...)

Préférences d'utilisation

 from selenium_driverless import webdriver
options = webdriver . ChromeOptions ()

 # recommended usage
options . update_pref ( "download.prompt_for_download" , False )
# or
options . prefs . update ({ "download" : { "prompt_for_download" : False }})

# supported
options . add_experimental_option ( "prefs" , { "download.prompt_for_download" : False })

Plusieurs contextes

• différents cookies pour chaque contexte
• Un contexte peut avoir plusieurs fenêtres et onglets à l'intérieur
• Différents proxy pour chaque contexte
• s'ouvre comme une fenêtre comme incognito

Exemple de code (cliquez pour agrandir)

 from selenium_driverless import webdriver
import asyncio


async def main ():
    options = webdriver . ChromeOptions ()
    async with webdriver . Chrome ( options = options ) as driver :
        context_1 = driver . current_context
        
        await driver . set_auth ( "username" , "password" , "localhost:5000" )
        # proxy not supported on windows due to https://bugs.chromium.org/p/chromium/issues/detail?id=1310057
        context_2 = await driver . new_context ( proxy_bypass_list = [ "localhost" ], proxy_server = "http://localhost:5000" )
        
        await context_1 . current_target . get ( "https://examle.com" )
        await context_2 . get ( "https://examle.com" )
        input ( "press ENTER to exit:)" )


asyncio . run ( main ())

Gestion des exceptions personnalisées

Vous pouvez implémenter une gestion des exceptions personnalisée comme suivant

 import selenium_driverless
import sys
handler = ( lambda e : print ( f'Exception in event-handler: n { e . __class__ . __module__ } . { e . __class__ . __name__ } : { e } ' ,
                           file = sys . stderr ))
sys . modules [ "selenium_driverless" ]. EXC_HANDLER = handler
sys . modules [ "cdp_socket" ]. EXC_HANDLER = handler 

Aide

Vous avez trouvé un bug? N'hésitez pas à ouvrir un problème :) Vous avez d'autres questions ou proposiaux? N'hésitez pas à rejoindre la communauté sans conducteur sur Discord ou à ouvrir une discours

Copyright et auteur

Aurin Aegerter (alias Steve )

Licence

Ce travail est concédé sous licence Creative Commons Attribution-noncommercial-Sharealike 4.0 International avec un ajout pour Section 1(k) dans le code juridique:

Les moyens commerciaux principalement destinés ou orientés vers un avantage commercial ou une compensation monétaire.
Une entreprise, un projet ou un accord public avec une intention commerciale de toute nature qui profite plus que, ou égal à 7 000 dollars américains par mois, ou tout équivalent monétaire à celui-ci, n'est pas soumis à cette définition de non commercial.

---

Si vous souhaitez utiliser ce projet commercialement, vous pouvez contacter l'auteur pour une licence personnalisée. Cela comprend généralement des frais d'environ 5 à 6% en fonction de votre bénéfice actuel.

Clause de non-responsabilité

Ce projet est destiné à des fins éducatives uniquement . L'utilisez de manière responsable.
L'auteur ne fournit aucune garantie et n'est pas responsable de quoi ou comment il est utilisé.

Remerciements

Inspiration, extraits de code, etc.

• selenium_driverless / utils / find_chrome_exucuable
• cdp-socket
• jsobject
• pYCDP / Browser.py