Reponse A: Anthropic Claude Sonnet 4.6
import threading import time class TokenBucketRateLimiter: def __init__(self, capacity, refill_rate): """ Initialiser le limiteur de débit de bucket de jetons. :param capacity: Nombre maximum de jetons que le bucket peut contenir. :param refill_rate: Nombre de jetons ajoutés au bucket par seconde. """ self.capacity = capacity self.refill_rate = refill_rate self._tokens = capacity # Commence avec un bucket plein self._last_refill_time = time.monotonic() self._lock = threading.Lock() def _refill(self): """ R...
Afficher la reponse complete ▼
import threading import time class TokenBucketRateLimiter: def __init__(self, capacity, refill_rate): """ Initialiser le limiteur de débit de bucket de jetons. :param capacity: Nombre maximum de jetons que le bucket peut contenir. :param refill_rate: Nombre de jetons ajoutés au bucket par seconde. """ self.capacity = capacity self.refill_rate = refill_rate self._tokens = capacity # Commence avec un bucket plein self._last_refill_time = time.monotonic() self._lock = threading.Lock() def _refill(self): """ Remplir le bucket en fonction du temps écoulé depuis le dernier remplissage. Cette méthode doit être appelée pendant que le verrou est détenu. """ now = time.monotonic() elapsed = now - self._last_refill_time tokens_to_add = elapsed * self.refill_rate self._tokens = min(self.capacity, self._tokens + tokens_to_add) self._last_refill_time = now def consume(self, tokens): """ Tenter de consommer un nombre donné de jetons du bucket. :param tokens: Nombre de jetons à consommer. :return: True si les jetons ont été consommés avec succès, False sinon. """ if tokens <= 0: raise ValueError("Le nombre de jetons à consommer doit être positif.") if tokens > self.capacity: # Ne peut jamais être satisfait même avec un bucket plein return False with self._lock: self._refill() if self._tokens >= tokens: self._tokens -= tokens return True return False
Resultat
Votes gagnants
3 / 3
Score moyen
Score total
Commentaire global
La réponse A fournit une implémentation hautement correcte et bien structurée du limiteur de débit de jetons (Token Bucket Rate Limiter). La qualité de son code est excellente, avec des docstrings claires et le respect des conventions Python. Elle implémente correctement la sécurité des threads et gère explicitement les cas limites spécifiés, ce qui en fait une solution robuste et maintenable.
Afficher le detail de l evaluation ▼
Exactitude
Poids 35%L'algorithme de remplissage et de consommation des jetons est correctement implémenté. La limite de capacité est correctement appliquée et la logique de remplissage basée sur le temps est saine.
Completude
Poids 20%La réponse fournit une implémentation de classe complète avec toutes les méthodes spécifiées (`__init__`, `consume`) et les importations nécessaires.
Qualite du code
Poids 20%Le code est propre, lisible et suit les conventions Python standard. Il comprend d'excellentes docstrings pour les méthodes publiques et un commentaire clair pour la méthode privée `refill`, améliorant considérablement la maintenabilité.
Valeur pratique
Poids 15%L'implémentation utilise correctement `threading.Lock` pour assurer la sécurité des threads, la rendant adaptée aux environnements concurrents. C'est une solution pratiquement valable.
Respect des consignes
Poids 10%La solution gère explicitement tous les cas limites mentionnés dans la section 'Robustesse et Cas Limites' de l'invite : lever une `ValueError` pour des `tokens` non positifs et retourner immédiatement `False` si `tokens` dépasse la `capacity`. L'état initial est également correctement défini.
Score total
Commentaire global
Implémente un limiteur de bucket de jetons correct avec temps monotone, recharges fractionnaires, plafonnement de capacité et verrouillage approprié autour de la recharge+consommation. Il gère également le cas limite important des requêtes plus grandes que la capacité en retournant False. Petit inconvénient : il lève une exception si tokens<=0 (dépendant de la politique ; certains pourraient préférer traiter 0 comme un True sans opération) et il ne valide pas les entrées de capacité/taux de recharge.
Afficher le detail de l evaluation ▼
Exactitude
Poids 35%Recharge correcte du bucket de jetons basée sur le temps monotone écoulé, plafonne à la capacité et effectue la recharge+consommation de manière atomique sous un verrou. Utilise correctement les jetons fractionnaires.
Completude
Poids 20%Fournit une classe complète avec les importations, une aide interne pour la recharge et une méthode de consommation ; inclut la gestion explicite des jetons>capacité. Manque de validation pour les valeurs de capacité/taux de recharge.
Qualite du code
Poids 20%Lisible, style PEP8, avec des docstrings expliquant le comportement et les attentes en matière de verrouillage. Structure simple.
Valeur pratique
Poids 15%Pratique pour une utilisation typique ; le retour immédiat de False pour les requêtes impossibles et volumineuses est utile. Lever une exception si tokens<=0 peut être gênant dans certaines intégrations ; pas de validation des paramètres pour la capacité/le taux de recharge.
Respect des consignes
Poids 10%Répond aux exigences : thread-safe, pas de bibliothèques d'état externes, méthodes et comportement corrects, et inclut les importations nécessaires.
Score total
Commentaire global
La réponse A fournit une implémentation correcte, complète et bien documentée du limiteur de débit de bucket de jetons. Elle implémente correctement l'algorithme avec une sécurité de thread appropriée à l'aide de threading.Lock, gère les cas limites tels que la consommation de plus de jetons que la capacité (renvoie False) et la consommation de zéro ou de jetons négatifs (lève une ValueError). Le code comprend des docstrings claires expliquant le but et les paramètres de chaque méthode. Il utilise time.monotonic() pour un suivi fiable du temps. Le code est propre, lisible et suit bien les conventions Python.
Afficher le detail de l evaluation ▼
Exactitude
Poids 35%Implémente correctement l'algorithme du bucket de jetons avec un calcul de remplissage approprié, une limitation de capacité et des opérations de consommation atomiques. Gère le cas limite de demande de plus de jetons que la capacité en renvoyant False tôt. Lève une ValueError pour les demandes de jetons non positives.
Completude
Poids 20%Couvre les __init__, consume et la sécurité de thread requis. Gère les cas limites : jetons zéro/négatifs (ValueError), jetons dépassant la capacité (renvoie False). Commence avec un bucket plein. Inclut toutes les importations nécessaires.
Qualite du code
Poids 20%Bien documenté avec des docstrings claires pour la classe et chaque méthode. Les descriptions des paramètres sont fournies. Le code est propre, lisible et suit les conventions PEP 8. La méthode privée _refill est clairement indiquée comme nécessitant que le verrou soit détenu.
Valeur pratique
Poids 15%Prêt à être utilisé dans des scénarios de production. Le retour anticipé pour les jetons dépassant la capacité est une optimisation pratique. La ValueError pour une entrée invalide aide au débogage. Utilise time.monotonic() pour une synchronisation fiable.
Respect des consignes
Poids 10%Suit toutes les instructions : implémente la classe avec le nom spécifié, __init__ avec la capacité et le taux de remplissage, la méthode consume renvoyant True/False, la sécurité de thread avec threading.Lock, et inclut les importations nécessaires. Fournit une implémentation de classe complète comme demandé.