axe-devtools-api Référence de l'API Python
Référence API pour le package Python axe-devtools-api pour injecter et exécuter axe-core
Fournit une API permettant d'injecter et d'exécuter axe-core sur une page web.
axe_devtools_api.Axe
Configure la manière dont axe-core est exécuté et l'exécute sur la page.
report = Axe(page).with_rules("document-title", "label").analyze()Axe(page, report_configuration=None, axe_source=None)
Initialisez une instance Axe avec un adaptateur de navigateur et une configuration optionnelle.
page : Un adaptateur de navigateur, tel qu'une instance AxeDriver de axe-devtools-selenium.
report_configuration : Optionnel. Un objet de configuration de rapport.
axe_source : Optionnel. Une chaîne de code source axe-core à utiliser à la place de la version intégrée.
analyze()
Injectez axe-core dans la page et exécutez l'analyse d'accessibilité.
Renvoie un objet Results. Voir Générer des rapports avec Python pour l'API complète Results et comment configurer les métadonnées du rapport.
report = Axe(page).analyze()including(*selector)
Spécifiez une partie de la page à analyser par axe-core. Pour analyser plusieurs parties non liées de la page, appelez including() une fois pour chacune, en passant un seul sélecteur à chaque fois.
selector : Un seul sélecteur CSS pour les éléments à inclure. Passer plus d'un sélecteur dans un même appel est toujours interprété comme un sélecteur d'iframe plutôt que comme des inclusions séparées : chaque sélecteur sauf le dernier correspond à un niveau d'imbrication d'iframe, et le dernier correspond à l'élément à analyser à l'intérieur de l'iframe la plus interne.
Retourne cet objet pour le chaînage.
# Analyze .sidebar and .some-class, which are both in the top-level document
report = Axe(page).including(".sidebar").including(".some-class").analyze()
# Analyze .some-class inside the iframe matched by .sidebar-frame
report = Axe(page).including(".sidebar-frame", ".some-class").analyze()Pour atteindre un élément à l'intérieur d'une shadow root, passez un seul dictionnaire fromShadowDom au lieu d'un sélecteur CSS. Chaque sélecteur dans la liste sauf le dernier correspond à un hôte shadow; le dernier correspond à l'élément à analyser à l'intérieur de la shadow root la plus interne.
# Analyze #shadow-button inside the shadow root attached to #shadow-host
report = Axe(page).including({"fromShadowDom": ["#shadow-host", "#shadow-button"]}).analyze()Un dictionnaire fromFrames est l'équivalent explicite du sélecteur d'iframe présenté ci-dessus, et est la forme recommandée pour les nouveaux tests.
# Analyze the form inside the #payment-frame iframe
report = Axe(page).including({"fromFrames": ["#payment-frame", "form"]}).analyze()Les deux peuvent être combinés pour atteindre une iframe qui se trouve à l'intérieur d'une shadow root. Le dictionnaire fromShadowDom doit être imbriqué dans la liste fromFrames; l'inverse provoque une erreur.
# Analyze the form inside the iframe matched by #shadow-frame, which is inside the
# shadow root attached to #shadow-host
report = Axe(page).including({
"fromFrames": [
{"fromShadowDom": ["#shadow-host", "#shadow-frame"]},
"form",
]
}).analyze()excluding(*selector)
Spécifiez une partie de la page à ignorer lors de l'analyse par axe-core. Pour ignorer plusieurs parties non liées de la page, appelez excluding() une fois pour chacune, en passant un seul sélecteur à chaque fois.
selector : Un seul sélecteur CSS pour les éléments à exclure. Passer plus d'un sélecteur dans un même appel est toujours interprété comme un sélecteur d'iframe plutôt que comme des exclusions séparées : chaque sélecteur sauf le dernier correspond à un niveau d'imbrication d'iframe, et le dernier correspond à l'élément à ignorer à l'intérieur de l'iframe la plus interne.
Retourne cet objet pour le chaînage.
# Skip .third-party-ad and .cookie-banner, which are both in the top-level document
report = Axe(page).excluding(".third-party-ad").excluding(".cookie-banner").analyze()
# Skip .third-party-ad inside the iframe matched by .iframe1
report = Axe(page).excluding(".iframe1", ".third-party-ad").analyze()Comme pour including(), un seul dictionnaire fromShadowDom ou fromFrames peut être passé à la place d'un sélecteur CSS, et les deux peuvent être imbriqués. Voir including() pour la description complète de ces formes.
# Skip #shadow-button inside the shadow root attached to #shadow-host
report = Axe(page).excluding({"fromShadowDom": ["#shadow-host", "#shadow-button"]}).analyze()
# Skip the form inside the #payment-frame iframe
report = Axe(page).excluding({"fromFrames": ["#payment-frame", "form"]}).analyze()with_rules(*rules)
Spécifiez les règles (par ID) pour que axe-core les exécute. Seules les règles spécifiées sont utilisées. Cette option est incompatible avec with_tags.
rules : Un ou plusieurs identifiants de règles. Voir pour une liste des IDs valides. pour une liste des ID valides.
Retourne cet objet pour le chaînage.
Soulève RuntimeError si appelé conjointement avec with_tags sur la même instance.
report = Axe(page).with_rules("document-title", "label").analyze()with_tags(*tags)
Spécifiez les règles (par tag) pour que axe-core les exécute. Seules les règles spécifiées sont utilisées. Cette option est incompatible avec with_rules.
tags : Un ou plusieurs noms de tags. Voir pour une liste des étiquettes valides. pour une liste de tags valides.
Retourne cet objet pour le chaînage.
Soulève RuntimeError si appelé conjointement avec with_rules sur la même instance.
report = Axe(page).with_tags("best-practice", "wcag2a").analyze()disabling_rules(*rules)
: Un ou plusieurs IDs de règles.
rules : Un ou plusieurs identifiants de règles.
Retourne cet objet pour le chaînage.
report = Axe(page).disabling_rules("html-has-lang", "label").analyze()run_options(options)
Spécifiez à passer à axe-core lors de l'appel de à passer à axe-core lors de l'appel de axe.run.
options : Objet options à passer à axe-core.
Retourne cet objet pour le chaînage.
options = {"iframes": False}
report = Axe(page).run_options(options).analyze()configure(spec)
Configurez axe-core via axe.configure.
spec : Objet spécification à passer à axe.configure.
Retourne cet objet pour le chaînage.
report = Axe(page).configure(spec).analyze()without_iframe_sandboxes()
Supprimez l'attribut sandbox des iframe pour que axe-core puisse s'exécuter à l'intérieur.
Retourne cet objet pour le chaînage.
report = Axe(page).without_iframe_sandboxes().analyze()with_config_file(config_path)
Définissez le chemin vers un fichier de configuration de jeu de règles. Le chemin par défaut est config/axe-ruleset.json, ou la valeur de la variable d'environnement $AXE_RULESET_PATH si elle est définie.
config_path : Chemin vers le fichier de configuration.
Retourne cet objet pour le chaînage.
report = Axe(page).with_config_file("path/to/file.json").analyze()with_ruleset(ruleset_id, enable_best_practices=False)
Utiliser un jeu de règles spécifique pour l'exécution d'axe-core.
ruleset_id : ID du jeu de règles à utiliser. Jeux de règles disponibles : wcag2, wcag2.1, wcag2.2, wcag2aaa, wcag2.1aaa, wcag2.2aaa, 508, en301549, ttv5, rgaav4.
enable_best_practices : Si les règles taguées best-practice doivent être activées. Par défaut False.
Retourne cet objet pour le chaînage.
report = Axe(page).with_ruleset("508").analyze()set_legacy_mode(state=True)
Utilisez axe.run au lieu de axe.runPartial. A des implications transfrontalières.
state : Si le mode héritage doit être activé. Par défaut True.
Retourne cet objet pour le chaînage.
report = Axe(page).set_legacy_mode().analyze()Service d'utilisation
Obtenez un aperçu des tendances d'utilisation d'Axe DevTools au sein de votre organisation. Par défaut, le service d'utilisation est activé et transmet des rapports à https://usage.deque.com. Définissez la variable d'environnement AXE_TRACK_USAGE sur false pour le désactiver.
Variables d'environnement du service d'utilisation
Ces variables d'environnement vous permettent de configurer le service d'utilisation et de modifier les propriétés des événements signalés.
| Nom | Type | Peut remplacer | Description |
|---|---|---|---|
AXE_DISTINCT_ID |
Chaîne de caractères | — | Un identifiant UUID qui reste le même pour l'utilisateur connecté (sauf s'il est régénéré). En Ruby, cette variable est nommée DEQUE_DISTINCT_ID. |
AXE_INCLUDE_TEST_RESULTS |
Booléen | — | Définir sur true pour inclure les résultats complets de axe-core dans l'objet testResults de chaque événement (la valeur par défaut est false). Pris en charge uniquement par la CLI et les API Node.js. |
AXE_METRICS_URL |
Chaîne de caractères | — | L'URL du point de terminaison de l'utilisation REST (la valeur par défaut est https://usage.deque.com) |
AXE_TRACK_USAGE |
Booléen | — | Définir sur false pour désactiver le rapport de service d'utilisation. Le rapport est activé par défaut. |
AXE_APPLICATION |
Chaîne de caractères | faux | L'application qui a été utilisée pour vérifier les erreurs d'accessibilité |
AXE_DEV_INSTANCE |
Booléen | vrai | Indique si cet événement provient d'actions d'un développeur logiciel. Utile pour marquer et supprimer ensuite les événements enregistrés pendant le développement ou les tests. |
AXE_DEPARTMENT |
Chaîne de caractères | vrai | Le département de l'utilisateur au sein de l'organisation |
AXE_KEYCLOAK_ID |
Chaîne de caractères | faux | L'ID Keycloak de l'utilisateur |
AXE_LOGGED_IN |
Booléen | faux | Enregistre si l'utilisateur est connecté à l'application en test |
AXE_ORGANIZATION |
Chaîne de caractères | vrai | L'organisation de l'utilisateur. Pour que votre utilisation apparaisse dans Axe Reports, définissez ceci sur l'ID de votre organisation (contactez Deque pour l'obtenir). |
AXE_SESSION_ID |
Chaîne de caractères | faux | Un UUID identifiant la session de l'utilisateur |
AXE_USER_ID |
Chaîne de caractères | faux | L'identité d'un utilisateur spécifique, telle qu'une adresse e-mail, un nom ou un identifiant de connexion. Axe Reports compte les utilisateurs uniques à partir de cette valeur. |
AXE_USER_JOB_ROLE |
Chaîne de caractères | faux | Le rôle professionnel de l'utilisateur |
AXE_USER_STATUS |
Chaîne de caractères | faux | Informations de statut que vous souhaitez associer à l'utilisateur |
enable_tracking(state)
Choisissez d'envoyer ou non des données au service d'utilisation. L'envoi est activé par défaut.
state : Si le suivi est activé.
Retourne cet objet pour le chaînage.
report = Axe(page).enable_tracking(True).analyze()set_tracking_url(url)
Définir où les données des métriques d'utilisation sont envoyées.
url : URL où les données seront envoyées.
Retourne cet objet pour le chaînage.
report = Axe(page).set_tracking_url("https://usage.deque.com").analyze()set_distinct_id(id)
Définir l'ID distinct utilisé lors de l'envoi des métriques d'utilisation.
id : ID distinct à envoyer.
Retourne cet objet pour le chaînage.
report = Axe(page).set_distinct_id("SOMEUUID").analyze()