Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Fonctions de bibliothèque disponibles pour les scripts Canary Python utilisant Selenium
<a name="CloudWatch_Synthetics_Canaries_Library_Python"></a>

Cette section répertorie les fonctions de bibliothèque Selenium disponibles pour les scripts Canary Python.

**Topics**
+ [Classes et fonctions de bibliothèque Python et Selenium qui s'appliquent à tous les scripts Canary](#CloudWatch_Synthetics_Library_allcanaries_Python)
+ [Classes et fonctions de bibliothèque Python et Selenium qui s'appliquent aux scripts Canary d'interface utilisateur uniquement](#CloudWatch_Synthetics_Library_Python_UIcanaries)

## Classes et fonctions de bibliothèque Python et Selenium qui s'appliquent à tous les scripts Canary
<a name="CloudWatch_Synthetics_Library_allcanaries_Python"></a>

Les fonctions de la bibliothèque CloudWatch Synthetics Selenium pour Python suivantes sont utiles pour tous les canaris.

**Topics**
+ [SyntheticsConfiguration classe](#CloudWatch_Synthetics_Library_SyntheticsConfiguration_Python)
+ [SyntheticsLogger classe](#CloudWatch_Synthetics_Library_SyntheticsLogger_Python)

### SyntheticsConfiguration classe
<a name="CloudWatch_Synthetics_Library_SyntheticsConfiguration_Python"></a>

Vous pouvez utiliser la SyntheticsConfiguration classe pour configurer le comportement des fonctions de la bibliothèque Synthetics. Par exemple, vous pouvez utiliser cette classe pour configurer la fonction ` executeStep()` pour ne pas prendre de captures d'écran.

Vous pouvez définir CloudWatch des configurations Synthetics au niveau global.

Définitions des fonctions :

#### set\$1config(options)
<a name="CloudWatch_Synthetics_Library_setConfig_Python"></a>

```
from aws_synthetics.common import synthetics_configuration
```

` options ` est un objet, qui est un ensemble d'options configurables pour votre script Canary. Les sections suivantes expliquent les champs possibles dans ` options `.
+ `screenshot_on_step_start` (booléen) : indique s'il faut prendre une capture d'écran avant de commencer une étape.
+ `screenshot_on_step_success` (booléen) : indique s'il faut prendre une capture d'écran après la réussite d'une étape.
+ `screenshot_on_step_failure` (booléen) : indique s'il faut prendre une capture d'écran après l'échec d'une étape.

 **with\$1screenshot\$1on\$1step\$1start(screenshot\$1on\$1step\$1start)** 

Accepte un argument booléen qui indique s'il faut prendre une capture d'écran avant de commencer une étape.

 **with\$1screenshot\$1on\$1step\$1success(screenshot\$1on\$1step\$1success)** 

Accepte un argument booléen qui indique s'il faut prendre une capture d'écran après la réussite d'une étape.

 **with\$1screenshot\$1on\$1step\$1failure(screenshot\$1on\$1step\$1failure)** 

Accepte un argument booléen qui indique s'il faut prendre une capture d'écran après l'échec d'une étape.

 **get\$1screenshot\$1on\$1step\$1start()** 

Renvoie une valeur indiquant s'il faut prendre une capture d'écran avant de commencer une étape.

 **get\$1screenshot\$1on\$1step\$1success()** 

Renvoie une valeur indiquant s'il faut prendre une capture d'écran après la réussite d'une étape.

 **get\$1screenshot\$1on\$1step\$1failure()** 

Renvoie une valeur indiquant s'il faut prendre une capture d'écran après l'échec d'une étape.

 **disable\$1step\$1screenshots()** 

Désactive toutes les options de capture d'écran (get\$1screenshot\$1on\$1step\$1start, get\$1screenshot\$1on\$1step\$1success et get\$1screenshot\$1on\$1step\$1failure).

 **enable\$1step\$1screenshots()** 

Active toutes les options de capture d'écran (get\$1screenshot\$1on\$1step\$1start, get\$1screenshot\$1on\$1step\$1success et get\$1screenshot\$1on\$1step\$1failure). Par défaut, toutes ces méthodes sont activées.

 **SetConfig (options) concernant les métriques CloudWatch ** 

Pour les canaris utilisant `syn-python-selenium-1.1` ou version ultérieure, les **(options)** de **SetConfig** peuvent inclure les paramètres booléens suivants qui déterminent les métriques publiées par le canari. La valeur par défaut de chacune de ces options est `true`. Les options qui commencent par ` aggregated` déterminent si la métrique est émise sans la dimension ` CanaryName`. Vous pouvez utiliser ces métriques pour afficher les résultats agrégés de tous vos scripts Canary. Les autres options déterminent si la métrique est émise avec la dimension `CanaryName`. Vous pouvez utiliser ces métriques pour afficher les résultats de chaque script Canary individuel.

Pour une liste des CloudWatch métriques émises par les canaris, voir[CloudWatch statistiques publiées par canaries](CloudWatch_Synthetics_Canaries_metrics.md).
+ `failed_canary_metric` (booléen) : indique s'il faut émettre la métrique ` Failed` (avec la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `failed_requests_metric` (booléen) : indique s'il faut émettre la métrique `Failed requests` (avec la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `2xx_metric` (booléen) : indique s'il faut émettre la métrique `2xx` (avec la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `4xx_metric` (booléen) : indique s'il faut émettre la métrique `4xx` (avec la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `5xx_metric` (booléen) : indique s'il faut émettre la métrique `5xx` (avec la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `step_duration_metric` (booléen) : indique s'il faut émettre la métrique `Step duration` (avec les dimensions `CanaryName` `StepName`) pour ce script Canary. La valeur par défaut est `true`.
+ `step_success_metric` (booléen) : indique s'il faut émettre la métrique `Step success` (avec les dimensions `CanaryName` `StepName`) pour ce script Canary. La valeur par défaut est `true`.
+ `aggregated_failed_canary_metric` (booléen) : indique s'il faut émettre la métrique `Failed` (sans la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `aggregated_failed_requests_metric` (booléen) : indique s'il faut émettre la métrique `Failed Requests` (sans la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `aggregated_2xx_metric` (booléen) : indique s'il faut émettre la métrique ` 2xx` (sans la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `aggregated_4xx_metric` (booléen) : indique s'il faut émettre la métrique ` 4xx` (sans la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.
+ `aggregated_5xx_metric` (booléen) : indique s'il faut émettre la métrique ` 5xx` (sans la dimension `CanaryName`) pour ce script Canary. La valeur par défaut est `true`.

 **with\$12xx\$1metric(2xx\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `2xx` avec la dimension `CanaryName` pour ce script Canary.

 **with\$14xx\$1metric(4xx\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `4xx` avec la dimension `CanaryName` pour ce script Canary.

 **with\$15xx\$1metric(5xx\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `5xx` avec la dimension `CanaryName` pour ce script Canary.

 **withAggregated2xxMetric(aggregated2xxMetric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `2xx` sans dimension pour ce script Canary.

 **withAggregated4xxMetric(aggregated4xxMetric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `4xx` sans dimension pour ce script Canary.

 **with\$1aggregated\$15xx\$1metric(aggregated\$15xx\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `5xx` sans dimension pour ce script Canary.

 **with\$1aggregated\$1failed\$1canary\$1metric (aggregated\$1failed\$1canary\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `Failed` sans dimension pour ce script Canary.

 **with\$1aggregated\$1failed\$1requests\$1metric (aggregated\$1failed\$1requests\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `Failed requests` sans dimension pour ce script Canary.

 **with\$1failed\$1canary\$1metric(failed\$1canary\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `Failed` avec la dimension `CanaryName` pour ce script Canary.

 **with\$1failed\$1requests\$1metric(failed\$1requests\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `Failed requests` avec la dimension `CanaryName` pour ce script Canary.

 **with\$1step\$1duration\$1metric(step\$1duration\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `Duration` avec la dimension `CanaryName` pour ce script Canary.

 **with\$1step\$1success\$1metric(step\$1success\$1metric)** 

Accepte un argument booléen qui spécifie s'il faut émettre une métrique `StepSuccess` avec la dimension `CanaryName` pour ce script Canary.

##### Méthodes pour activer ou désactiver les métriques
<a name="CloudWatch_Synthetics_Python_setConfig_metrics"></a>

 **disable\$1aggregated\$1request\$1metrics()** 

Désactive l'émission par le script Canary de toutes les métriques de demande émises sans dimension ` CanaryName`.

 **disable\$1request\$1metrics()** 

Désactive toutes les métriques de demande, y compris les métriques par script Canary et les métriques agrégées pour tous les scripts Canary.

 **disable\$1step\$1metrics()** 

Désactive toutes les métriques d'étapes, y compris les métriques de succès des étapes et les métriques de durée des étapes.

 **enable\$1aggregated\$1request\$1metrics()** 

Active l'émission par le script Canary de toutes les métriques de demande émises sans dimension ` CanaryName`.

 **enable\$1request\$1metrics()** 

Active toutes les métriques de demande, y compris les métriques par script Canary et les métriques agrégées pour tous les scripts Canary.

 **enable\$1step\$1metrics()** 

Active toutes les métriques d'étapes, y compris les métriques de succès des étapes et les métriques de durée des étapes.

 **Utilisation dans les scripts canary d'interface utilisateur** 

Tout d'abord, importez la dépendance Synthetics et récupérez la configuration. Ensuite, définissez la configuration de chaque option en appelant la méthode setConfig à l'aide de l'une des options suivantes.

```
from aws_synthetics.common import synthetics_configuration

synthetics_configuration.set_config(
     {
        "screenshot_on_step_start": False,
        "screenshot_on_step_success": False,
        "screenshot_on_step_failure": True
     }
)

or
```

Or

```
synthetics_configuration.with_screenshot_on_step_start(False).with_screenshot_on_step_success(False).with_screenshot_on_step_failure(True)
```

Pour désactiver toutes les captures d'écran, utilisez la fonction disableStepScreenshots () comme dans cet exemple.

```
synthetics_configuration.disable_step_screenshots()
```

Vous pouvez activer et désactiver des captures d'écran à tout moment dans le code. Par exemple, pour désactiver les captures d'écran pour une seule étape, désactivez-les avant d'exécuter cette étape, puis activez-les après l'étape.

##### set\$1config(options) pour les scripts Canary d'interface utilisateur
<a name="CloudWatch_Synthetics_Library_Python_UI"></a>

En commençant par `syn-python-selenium-1.1`, pour les scripts Canary d'interface utilisateur, ` set_config` peut inclure les paramètres booléens suivants :
+ `continue_on_step_failure`**(booléen) — S'il faut continuer à exécuter le script Canary après l'échec d'une étape (cela fait référence à la fonction ExecuteStep).** Si une étape échoue, l'exécution du script Canary sera toujours marquée comme ayant échoué. La valeur par défaut est `false`.

### SyntheticsLogger classe
<a name="CloudWatch_Synthetics_Library_SyntheticsLogger_Python"></a>

`synthetics_logger` écrit les journaux dans la console et dans un fichier journal local au même niveau de journalisation. Ce fichier journal est écrit dans les deux emplacements seulement si le niveau de journalisation est égal ou inférieur au niveau de journalisation souhaité de la fonction de journalisation qui a été appelée.

Les instructions de journalisation dans le fichier journal local sont précédées de « DEBUG: », « INFO: », etc., pour respecter le niveau de journalisation de la fonction appelée.

L'utilisation de `synthetics_logger` n'est pas nécessaire pour créer un fichier journal qui est téléchargé dans votre emplacement des résultats Amazon S3. Vous pouvez créer à la place un autre fichier journal dans le dossier `/tmp`. Tous les fichiers créés sous le dossier `/tmp` sont téléchargés vers l'emplacement des résultats dans le compartiment S3 en tant qu'artefacts.

Pour utiliser `synthetics_logger` :

```
from aws_synthetics.common import synthetics_logger
```

****Définitions de fonctions utiles :

Obtenir le niveau de journalisation :

```
log_level = synthetics_logger.get_level()
```

Définir le niveau de journalisation :

```
synthetics_logger.set_level()
```

Journaliser un message avec un niveau spécifié. Le niveau peut être `DEBUG`, ` INFO`, `WARN` ou `ERROR`, comme dans les exemples de syntaxe suivants :

```
synthetics_logger.debug(message, *args, **kwargs)
```

```
synthetics_logger.info(message, *args, **kwargs)
```

```
synthetics_logger.log(message, *args, **kwargs)
```

```
synthetics_logger.warning(message, *args, **kwargs)
```

```
synthetics_logger.error(message, *args, **kwargs)
```

Pour plus d'informations sur les paramètres de débogage, consultez [logging.debug](https://docs.python.org/3/library/logging.html#logging.debug) dans la documentation Python standard.

Dans ces fonctions de journalisation, le `message` est la chaîne de format du message. Les `args` sont les arguments qui sont fusionnés dans le `msg` à l'aide de l'opérateur de formatage de chaîne.

Il y a trois arguments de mot-clé dans `kwargs` :
+ `exc_info` : s'il n'est pas évalué comme false (faux), ajoute des informations d'exception au message de journalisation.
+ `stack_info` : la valeur par défaut est false (faux). Si true (vrai), ajoute des informations de pile au message de journalisation, y compris l'appel de journalisation réel.
+ `extra` : le troisième argument de mot-clé facultatif, que vous pouvez utiliser pour transmettre un dictionnaire qui est utilisé pour remplir le `__dict__` du `LogRecord` créé pour l'événement de journalisation avec des attributs définis par l'utilisateur.

Exemples :

Journaliser un message avec le niveau `DEBUG`:

```
synthetics_logger.debug('Starting step - login.')
```

Journaliser un message avec le niveau `INFO`. `logger.log` est un synonyme de `logger.info` :

```
synthetics_logger.info('Successfully completed step - login.')
```

or

```
synthetics_logger.log('Successfully completed step - login.')
```

Journaliser un message avec le niveau `WARN` :

```
synthetics_logger.warning('Warning encountered trying to publish %s', 'CloudWatch Metric')
```

Journaliser un message avec le niveau `ERROR` :

```
synthetics_logger.error('Error encountered trying to publish %s', 'CloudWatch Metric')
```

Journaliser une exception :

```
synthetics_logger.exception(message, *args, **kwargs)
```

Journalise un message avec le niveau `ERROR`. Des informations d'exception sont ajoutées au message de journalisation. Vous ne devriez appeler cette fonction qu'à partir d'un gestionnaire d'exceptions.

Pour plus d'informations sur les paramètres d'exception, consultez la documentation standard de Python sur [logging.exception](https://docs.python.org/3/library/logging.html#logging.exception)

Le `message` est la chaîne de format du message. Les `args` sont les arguments qui sont fusionnés dans le `msg` à l'aide de l'opérateur de formatage de chaîne.

Il y a trois arguments de mot-clé dans `kwargs` :
+ `exc_info` : s'il n'est pas évalué comme false (faux), ajoute des informations d'exception au message de journalisation.
+ `stack_info` : la valeur par défaut est false (faux). Si true (vrai), ajoute des informations de pile au message de journalisation, y compris l'appel de journalisation réel.
+ `extra` : le troisième argument de mot-clé facultatif, que vous pouvez utiliser pour transmettre un dictionnaire qui est utilisé pour remplir le `__dict__` du `LogRecord` créé pour l'événement de journalisation avec des attributs définis par l'utilisateur.

Exemple :

```
synthetics_logger.exception('Error encountered trying to publish %s', 'CloudWatch Metric')
```

## Classes et fonctions de bibliothèque Python et Selenium qui s'appliquent aux scripts Canary d'interface utilisateur uniquement
<a name="CloudWatch_Synthetics_Library_Python_UIcanaries"></a>

Les fonctions suivantes de la bibliothèque CloudWatch Synthetics Selenium pour Python ne sont utiles que pour les canaris de l'interface utilisateur.

**Topics**
+ [SyntheticsBrowser classe](#CloudWatch_Synthetics_Library_Python_SyntheticsBrowser)
+ [SyntheticsWebDriver classe](#CloudWatch_Synthetics_Library_Python_SyntheticsWebDriver)

### SyntheticsBrowser classe
<a name="CloudWatch_Synthetics_Library_Python_SyntheticsBrowser"></a>

**Note**  
`SyntheticsBrowser` n’est pris en charge que sur le navigateur Chrome.

Lorsque vous créez une instance de navigateur en appelant `synthetics_webdriver.Chrome()`, l'instance de navigateur renvoyée est du type `SyntheticsBrowser`. La ` SyntheticsBrowser` classe hérite de la WebDriver classe et donne accès à toutes les méthodes exposées par le [WebDriver](https://www.selenium.dev/documentation/webdriver/). Il contrôle le ChromeDriver navigateur et permet au script Canary de piloter le navigateur, permettant ainsi au Selenium de WebDriver fonctionner avec Synthetics.

**Note**  
Synthetics remplace la méthode d'arrêt WebDriver [du](https://www.selenium.dev/selenium/docs/api/py/selenium_webdriver_firefox/selenium.webdriver.firefox.webdriver.html) tabac pour ne rien faire. Vous n’avez donc pas besoin de fermer manuellement le navigateur, car Synthetics le gère automatiquement.

En plus des méthodes Selenium standard, elle fournit également les méthodes suivantes. 

**Topics**
+ [set\$1viewport\$1size(largeur, hauteur)](#CloudWatch_Synthetics_Library_set_viewport_size)
+ [save\$1screenshot(filename, suffix)](#CloudWatch_Synthetics_Library_save_screenshot)

#### set\$1viewport\$1size(largeur, hauteur)
<a name="CloudWatch_Synthetics_Library_set_viewport_size"></a>

Définit la fenêtre d'affichage du navigateur. Exemple :

```
browser.set_viewport_size(1920, 1080)
```

#### save\$1screenshot(filename, suffix)
<a name="CloudWatch_Synthetics_Library_save_screenshot"></a>

Enregistre les captures d'écran dans le répertoire `/tmp`. Les captures d'écran sont téléchargées à partir de ce répertoire dans le dossier des artefacts des scripts Canary dans le compartiment S3.

*filename* est le nom de fichier de la capture d'écran, et le *suffixe* est une chaîne facultative à utiliser pour nommer la capture d'écran.

Exemple :

```
browser.save_screenshot('loaded.png', 'page1')
```

### SyntheticsWebDriver classe
<a name="CloudWatch_Synthetics_Library_Python_SyntheticsWebDriver"></a>

Pour utiliser cette classe, utilisez ce qui suit dans votre script :

```
from aws_synthetics.selenium import synthetics_webdriver
```

**Topics**
+ [add\$1execution\$1error(errorMessage, ex);](#CloudWatch_Synthetics_Library_Python_addExecutionError)
+ [add\$1user\$1agent(user\$1agent\$1str)](#CloudWatch_Synthetics_Library_add_user_agent)
+ [execute\$1step(step\$1name, function\$1to\$1execute)](#CloudWatch_Synthetics_Library_Python_execute_step)
+ [get\$1http\$1response(url)](#CloudWatch_Synthetics_Library_Python_get_http_response)
+ [Chrome()](#CloudWatch_Synthetics_Library_Python_Chrome)

#### add\$1execution\$1error(errorMessage, ex);
<a name="CloudWatch_Synthetics_Library_Python_addExecutionError"></a>

`errorMessage` décrit l'erreur et `ex` est l'exception rencontrée.

Vous pouvez utiliser `add_execution_error` pour définir les erreurs d'exécution pour votre script Canary. Ce code fait échouer le script Canary sans interrompre l'exécution du script. Cela n'a pas non plus d'impact sur vos métriques `successPercent`.

Vous ne devriez suivre les erreurs comme des erreurs d'exécution que si elles ne sont pas importantes pour indiquer le succès ou l'échec de votre script Canary.

L'exemple suivant illustre l'utilisation de `add_execution_error`. Vous surveillez la disponibilité de votre point de terminaison et vous prenez des captures d'écran après le chargement de la page. Étant donné que l'échec de la prise d'une capture d'écran ne détermine pas la disponibilité du point de terminaison, vous pouvez détecter toutes les erreurs rencontrées lors de la prise de captures d'écran et les ajouter en tant qu'erreurs d'exécution. Vos métriques de disponibilité indiqueront toujours que le point de terminaison est opérationnel, mais le statut de votre script Canary indiquera qu'il a échoué. L'exemple de bloc de code suivant détecte une telle erreur et l'ajoute en tant qu'erreur d'exécution.

```
try:
    browser.save_screenshot("loaded.png")  
except Exception as ex:
   self.add_execution_error("Unable to take screenshot", ex)
```

#### add\$1user\$1agent(user\$1agent\$1str)
<a name="CloudWatch_Synthetics_Library_add_user_agent"></a>

Ajoute la valeur de `user_agent_str` à l'en-tête de l'agent utilisateur du navigateur. Vous devez assigner `user_agent_str` avant de créer l'instance du navigateur.

Exemple :

```
await synthetics_webdriver.add_user_agent('MyApp-1.0')
```

`add_user_agent` doit être utilisé à l’intérieur d’une fonction `async`.

#### execute\$1step(step\$1name, function\$1to\$1execute)
<a name="CloudWatch_Synthetics_Library_Python_execute_step"></a>

Traite une fonction. Elle effectue également les opérations suivantes :
+ Elle consigne le fait que l'étape a commencé.
+ Prend une capture d'écran appelée `<stepName>-starting`.
+ Elle démarre un minuteur.
+ Elle exécute la fonction fournie.
+ Si la fonction a un retour normal, elle est considérée comme une réussite. Si la fonction lève une exception, elle est considérée comme un échec.
+ Elle arrête le minuteur.
+ Elle consigne le fait que l'étape a réussi ou échoué.
+ Prend une capture d'écran appelée `<stepName>-succeeded` ou ` <stepName>-failed`.
+ Elle émet la métrique `stepName` `SuccessPercent`, 100 pour succès ou 0 pour échec.
+ Elle émet la métrique `stepName` `Duration` avec une valeur basée sur les heures de début et de fin de l'étape.
+ Enfin, elle retourne ce que `functionToExecute` a retourné ou lève à son tour ce que `functionToExecute` a levé.

Exemple :

```
from selenium.webdriver.common.by import By

def custom_actions():
        #verify contains
        browser.find_element(By.XPATH, "//*[@id=\"id_1\"][contains(text(),'login')]")
        #click a button
        browser.find_element(By.XPATH, '//*[@id="submit"]/a').click()

    await synthetics_webdriver.execute_step("verify_click", custom_actions)
```

#### get\$1http\$1response(url)
<a name="CloudWatch_Synthetics_Library_Python_get_http_response"></a>

Envoie une requête HTTP vers l’URL fournie et retourne le code de réponse HTTP correspondant. Si une exception se produit pendant la requête HTTP, la fonction renvoie la chaîne de caractères « erreur » à la place.

Exemple :

```
response_code = syn_webdriver.get_http_response(url)
if not response_code or response_code == "error" or response_code < 200 or response_code > 299:
    raise Exception("Failed to load page!")
```

#### Chrome()
<a name="CloudWatch_Synthetics_Library_Python_Chrome"></a>

Lance une instance du navigateur Chromium et renvoie l'instance créée du navigateur.

Exemple :

```
browser = synthetics_webdriver.Chrome()
browser.get("https://example.com/)
```

Pour lancer un navigateur en mode navigation privée, utilisez ce qui suit :

```
add_argument('——incognito')
```

Pour ajouter des paramètres proxys, utilisez ce qui suit :

```
add_argument('--proxy-server=%s' % PROXY)
```

Exemple :

```
from selenium.webdriver.chrome.options import Options
chrome_options = Options()
chrome_options.add_argument("——incognito")
browser = syn_webdriver.Chrome(chrome_options=chrome_options)
```