AIDE PYTHON

Répéter des fonctions avec Tenacity en Python

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Mis à jour:juin 22, 2025

Lors du développement de programmes solides et résilients dans le langage de programmation Python, il est courant de devoir gérer gracieusement les erreurs temporaires, en particulier lors de l'utilisation de services externes ou d'opérations réseau. C'est là que la puissante bibliothèque générale de réessai Python Tenacity entre en jeu. Les développeurs peuvent accroître la fiabilité et la robustesse de leurs opérations de génération de PDF en combinant Tenacity avec IronPDF, un cadre riche en fonctionnalités pour créer des documents PDF dans des applications Python.

Tenacity offre une structure adaptable et personnalisable pour réessayer les tâches susceptibles d'échouer ou de soulever des exceptions en raison de problèmes transitoires tels que des pannes réseau, des délais d'attente ou des interruptions de service. Tenacity simplifie le développement de la logique de réessai grâce à son API conviviale et à son ensemble de fonctionnalités étendu, libérant ainsi les développeurs pour qu'ils puissent se concentrer sur la création de systèmes fiables plutôt que de se préoccuper des échecs passagers.

Dans cet article, nous examinerons les avantages de l'intégration de la bibliothèque Tenacity avec IronPDF, présenterons des exemples pratiques et donnerons des conseils sur la façon de créer des processus de génération de PDF fiables dans des applications Python. Les développeurs peuvent améliorer la robustesse et la fiabilité de leurs applications tout en fournissant aux consommateurs des documents PDF de haute qualité en combinant la puissance de Tenacity avec IronPDF.

Réessai basé sur des décorateurs

Tenacity permet aux programmeurs d'utiliser les décorateurs Python pour ajouter une logique de réessai aux fonctions ou méthodes. Ainsi, ajouter un comportement de réessai à des actions particulières sans modifier le code d'origine est simple.

Plans de réessai personnalisables

Tenacity propose plusieurs paramètres ajustables pour spécifier les plans de réessai. Le nombre maximal de réessais, l'intervalle entre les réessais et les circonstances dans lesquelles les réessais doivent avoir lieu sont tous personnalisables par les développeurs.

Recule exponentiel

Tenacity favorise le backoff exponentiel, une technique d'invocation de réessai populaire actuelle dans laquelle l'intervalle entre les réessais croît de manière exponentielle avec le nombre de tentatives à chaque essai. En faisant cela, vous pouvez éviter de saturer le service cible avec des demandes lorsqu'il y a beaucoup de trafic ou de congestion.

Jitter et Aléatoire

Tenacity propose des options pour introduire du jitter et de l'aléatoire aux retards de réessai afin de prévenir les problèmes de synchronisation et les problèmes de troupeau grondant. Cela réduit la possibilité que plusieurs clients réessaient en même temps en étalant les tentatives de réessai dans le temps.

Conditions de réessai et Exceptions

En fonction de la valeur de retour de l'opération ou de toute exception soulevée, les développeurs peuvent créer des conditions de réessai uniques. Cela permet de réguler précisément quand et dans quelles conditions les réessais doivent être effectués.

Délais d'attente et Limites de temps

Tenacity facilite la création de délais d'attente et de limites de temps d'opérations générales, garantissant que les tentatives de réessai ne sont pas faites indéfiniment et que les opérations sont finalement terminées si elles prennent plus longtemps que les seuils prédéterminés.

Intégration avec des cadres Python populaires

Flask, Django et Celery ne sont que quelques-uns des cadres avec lesquels Tenacity interagit facilement. Cela permet aux développeurs d'ajouter facilement une logique de réessai aux opérations en arrière-plan, aux points de terminaison web ou à toute autre partie de leurs systèmes.

Créer et Configurer Tenacity

Recule exponentiel

from tenacity import retry, wait_exponential

# Decorate the function with a retry mechanism
@retry(wait=wait_exponential(multiplier=1, min=1, max=10))
def my_function():
    # Your code logic here
    pass

# Explanation:
# - `multiplier`: Used to increase the interval between retries.
# - `min`: Minimum wait time in seconds between retries.
# - `max`: Maximum wait time allowed between retries.

from tenacity import retry, wait_exponential

# Decorate the function with a retry mechanism
@retry(wait=wait_exponential(multiplier=1, min=1, max=10))
def my_function():
    # Your code logic here
    pass

# Explanation:
# - `multiplier`: Used to increase the interval between retries.
# - `min`: Minimum wait time in seconds between retries.
# - `max`: Maximum wait time allowed between retries.

PYTHON

Jitter Aléatoire

from tenacity import retry, wait_random

@retry(wait=wait_random(min=1, max=10))
def my_function():
    # Your code logic here
    pass

# Explanation:
# - `min`: Minimum random wait time in seconds between retries.
# - `max`: Maximum random wait time in seconds between retries.

from tenacity import retry, wait_random

@retry(wait=wait_random(min=1, max=10))
def my_function():
    # Your code logic here
    pass

# Explanation:
# - `min`: Minimum random wait time in seconds between retries.
# - `max`: Maximum random wait time in seconds between retries.

PYTHON

Personnalisation des Conditions de Réessai

Exceptions Personnaliser le Réessai

from tenacity import retry, retry_if_exception_type

# Retry on specific exceptions like ConnectionError
@retry(retry=retry_if_exception_type(ConnectionError))
def my_function():
    # Your code logic here
    pass

# Explanation:
# Retry only if a ConnectionError exception is raised during the function execution.

from tenacity import retry, retry_if_exception_type

# Retry on specific exceptions like ConnectionError
@retry(retry=retry_if_exception_type(ConnectionError))
def my_function():
    # Your code logic here
    pass

# Explanation:
# Retry only if a ConnectionError exception is raised during the function execution.

PYTHON

Réessai Basé sur la Valeur de Retour

from tenacity import retry, retry_if_result

@retry(retry=retry_if_result(lambda result: result is None))
def my_function():
    # Your code logic here
    return some_result

# Explanation:
# Retry if the function result is `None`.

from tenacity import retry, retry_if_result

@retry(retry=retry_if_result(lambda result: result is None))
def my_function():
    # Your code logic here
    return some_result

# Explanation:
# Retry if the function result is `None`.

PYTHON

Conditions d'Arrêt

from tenacity import retry, stop_after_delay

@retry(stop=stop_after_delay(30))
def my_function():
    # Your code logic here
    pass

# Explanation:
# Stop retrying after 30 seconds have elapsed since the first attempt.

from tenacity import retry, stop_after_delay

@retry(stop=stop_after_delay(30))
def my_function():
    # Your code logic here
    pass

# Explanation:
# Stop retrying after 30 seconds have elapsed since the first attempt.

PYTHON

Callbacks de Réessai

from tenacity import retry, after_log
import logging

logger = logging.getLogger(__name__)

@retry(after=after_log(logger, logging.DEBUG))
def my_function():
    # Your code logic here
    pass

# Explanation:
# Use a logger to log details of each retry attempt at the DEBUG level.

from tenacity import retry, after_log
import logging

logger = logging.getLogger(__name__)

@retry(after=after_log(logger, logging.DEBUG))
def my_function():
    # Your code logic here
    pass

# Explanation:
# Use a logger to log details of each retry attempt at the DEBUG level.

PYTHON

Démarrage

Qu'est-ce qu'IronPDF ?

Nous pouvons créer, éditer et rendre des documents PDF à l'intérieur de programmes grâce à la populaire boîte à outils IronPDF. Travaillez avec les PDFs de diverses manières : vous pouvez convertir des pages HTML en PDFs, ajouter du texte, des images et des formes à celles qui existent déjà, et extraire du texte et des images de celles qui existent déjà. Même à partir de contenu HTML, d'images ou de données brutes, vous pouvez créer de nouvelles pages PDF.

IronPDF est incroyablement facile à utiliser, ce qui est l'un de ses principaux avantages. L'API conviviale et la documentation détaillée de Python rendent simple pour les développeurs de commencer à créer des PDFs à partir de leurs projets. IronPDF possède également deux autres caractéristiques : la vitesse et l'efficacité, qui permettent aux développeurs de créer rapidement des documents PDF de haute qualité.

Quelques avantages d'IronPDF :

Transformer des images, des données brutes et du HTML en PDFs.
Supprimer des images et du texte des fichiers PDF.
Ajouter des en-têtes, des pieds de page et des filigranes aux fichiers PDF.
Protéger les fichiers PDF par des mots de passe et le cryptage.
La capacité de signer électroniquement et de compléter des formulaires.

Installer les bibliothèques

L'installation des dépendances requises et l'intégration des deux bibliothèques dans votre flux de génération de PDF sont les premières étapes de l'utilisation de Tenacity et IronPDF ensemble dans une application Python.

pip install tenacity
pip install ironpdf

pip install tenacity
pip install ironpdf

SHELL

Importez dans votre script Python les modules requis de Tenacity et IronPDF :

from tenacity import retry, stop_after_attempt, wait_fixed
from IronPdf import IronPdf

# Set up retry behavior on the PDF generating function
@retry(
    stop=stop_after_attempt(3),   # Stop retrying after 3 attempts
    wait=wait_fixed(2)            # Wait 2 seconds between retry attempts
)
def generate_pdf(html_content):
    iron_pdf = IronPdf()
    # Render the HTML content as a PDF
    iron_pdf.render_html_as_pdf(html_content)
    # Save the generated PDF to a file
    iron_pdf.save_as_pdf("output.pdf")

# Explanation:
# - `@retry(stop=stop_after_attempt(3))`: Stop after 3 failed attempts.
# - `wait_fixed(2)`: Wait 2 seconds before each retry attempt.

from tenacity import retry, stop_after_attempt, wait_fixed
from IronPdf import IronPdf

# Set up retry behavior on the PDF generating function
@retry(
    stop=stop_after_attempt(3),   # Stop retrying after 3 attempts
    wait=wait_fixed(2)            # Wait 2 seconds between retry attempts
)
def generate_pdf(html_content):
    iron_pdf = IronPdf()
    # Render the HTML content as a PDF
    iron_pdf.render_html_as_pdf(html_content)
    # Save the generated PDF to a file
    iron_pdf.save_as_pdf("output.pdf")

# Explanation:
# - `@retry(stop=stop_after_attempt(3))`: Stop after 3 failed attempts.
# - `wait_fixed(2)`: Wait 2 seconds before each retry attempt.

PYTHON

Appelez votre fonction de création de PDFs et transmettez-lui le texte HTML. Tenacity réessayera automatiquement la fonction conformément aux paramètres de réessai prédéfinis en cas d'exception.

try:
    html_content = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
    generate_pdf(html_content)
    print("PDF generated successfully")
except Exception as e:
    print("Failed to generate PDF:", e)

# Explanation:
# Attempt to generate a PDF and handle any exceptions that might occur during the process.

try:
    html_content = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
    generate_pdf(html_content)
    print("PDF generated successfully")
except Exception as e:
    print("Failed to generate PDF:", e)

# Explanation:
# Attempt to generate a PDF and handle any exceptions that might occur during the process.

PYTHON

En modifiant des facteurs tels que le nombre de réessais, la condition de réessai et la condition d'attente, l'intervalle entre les réessais et les circonstances dans lesquelles les réessais devraient se produire, vous pouvez alter davantage le comportement de réessai. Tenacity comprend différentes méthodes de réessai et stratégies de réessai et d'attente que vous pouvez utiliser pour ajuster finement le comportement de réessai selon vos besoins.

Sortie Exemple

Ci-dessous se trouve la sortie générée par le code ci-dessus :

Tenacity Python (Comment Ça Fonctionne Pour Les Développeurs) : Figure 1 - Résultat attendu du renvoi de PDF

Conclusion

En résumé, Tenacity et IronPDF ensemble fournissent une solution puissante pour créer des flux de travail de génération de PDF robustes et fiables dans des applications Python. Les développeurs peuvent s'assurer que leurs processus de génération de PDF sont robustes et résilients face aux échecs temporaires et aux réessais en utilisant les puissantes capacités de génération de PDF d'IronPDF et la logique de réessai personnalisable de Tenacity.

Grâce à l'ensemble de fonctionnalités étendu de Tenacity, les développeurs peuvent ajuster précisément les tactiques de réessai pour plusieurs conditions, spécifier des critères de réessai uniques, personnaliser les réessais sur les exceptions et inclure des options de configuration avancées. Tenacity permet aux développeurs de gérer gracieusement les échecs temporaires, tels que les pannes de réseau ou les interruptions de service, et garantit que les processus de création de PDF cruciaux sont réessayés immédiatement.

En conclusion, les développeurs peuvent créer des solutions de production de PDF fiables et robustes capables de supporter les rigueurs des environnements réels en utilisant Tenacity avec IronPDF. Cette combinaison offre une base solide pour créer des flux de travail de génération de PDF fiables et évolutifs dans des applications Python, que le flux de travail concerne la production de factures, de rapports ou de documents.

Une licence à vie pour IronPDF est incluse dans le package pour un tarif raisonnable. Pour de nombreux systèmes, le package est disponible à un prix très abordable $799. Les détenteurs de licence bénéficient d'un accès 24 heures sur 24 au support en ligne d'ingénierie. Veuillez visiter la page des licences pour obtenir des détails supplémentaires sur les frais. Pour en savoir plus sur les produits d'Iron Software, rendez-vous sur la page de la bibliothèque.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...