Antwort A: Anthropic Claude Sonnet 4.6
import threading import time class TokenBucketRateLimiter: def __init__(self, capacity, refill_rate): """ Initialisiere den Token-Bucket-Ratenbegrenzer. :param capacity: Maximale Anzahl von Tokens, die der Eimer fassen kann. :param refill_rate: Anzahl der Tokens, die pro Sekunde in den Eimer nachgefüllt werden. """ self.capacity = capacity self.refill_rate = refill_rate self._tokens = capacity # Beginne mit einem vollen Eimer self._last_refill_time = time.monotonic() self._lock = threading.Lock() def _refill(self):...
Vollstandige Antwort anzeigen ▼
import threading import time class TokenBucketRateLimiter: def __init__(self, capacity, refill_rate): """ Initialisiere den Token-Bucket-Ratenbegrenzer. :param capacity: Maximale Anzahl von Tokens, die der Eimer fassen kann. :param refill_rate: Anzahl der Tokens, die pro Sekunde in den Eimer nachgefüllt werden. """ self.capacity = capacity self.refill_rate = refill_rate self._tokens = capacity # Beginne mit einem vollen Eimer self._last_refill_time = time.monotonic() self._lock = threading.Lock() def _refill(self): """ Fülle den Eimer basierend auf der seit dem letzten Nachfüllen verstrichenen Zeit auf. Diese Methode muss aufgerufen werden, während die Sperre gehalten wird. """ 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): """ Versuche, eine gegebene Anzahl von Tokens aus dem Eimer zu verbrauchen. :param tokens: Anzahl der zu verbrauchenden Tokens. :return: True, wenn die Tokens erfolgreich verbraucht wurden, andernfalls False. """ if tokens <= 0: raise ValueError("Die Anzahl der zu verbrauchenden Tokens muss positiv sein.") if tokens > self.capacity: # Kann auch mit einem vollen Eimer nie erfüllt werden return False with self._lock: self._refill() if self._tokens >= tokens: self._tokens -= tokens return True return False
Ergebnis
Siegstimmen
3 / 3
Durchschnittsscore
Gesamtpunktzahl
Gesamtkommentar
Antwort A bietet eine hochgradig korrekte und gut strukturierte Implementierung des Token Bucket Rate Limiters. Die Codequalität ist ausgezeichnet, mit klaren Docstrings und Einhaltung von Python-Konventionen. Sie implementiert Thread-Sicherheit korrekt und behandelt explizit die angegebenen Randfälle, was sie zu einer robusten und wartbaren Lösung macht.
Bewertungsdetails anzeigen ▼
Korrektheit
Gewichtung 35%Der Algorithmus zum Auffüllen und Verbrauchen von Tokens ist korrekt implementiert. Das Kapazitätslimit wird ordnungsgemäß eingehalten und die zeitbasierte Auffülllogik ist solide.
Vollstandigkeit
Gewichtung 20%Die Antwort liefert eine vollständige Klassenimplementierung mit allen angegebenen Methoden (`__init__`, `consume`) und notwendigen Importen.
Codequalitat
Gewichtung 20%Der Code ist sauber, lesbar und folgt den üblichen Python-Konventionen. Er enthält ausgezeichnete Docstrings für öffentliche Methoden und einen klaren Kommentar für die private Refill-Methode, was die Wartbarkeit erheblich verbessert.
Praktischer Nutzen
Gewichtung 15%Die Implementierung verwendet korrekt `threading.Lock`, um Thread-Sicherheit zu gewährleisten, was sie für konkurrierende Umgebungen geeignet macht. Es ist eine praktisch solide Lösung.
Befolgung der Anweisungen
Gewichtung 10%Die Lösung behandelt explizit alle Randfälle, die im Abschnitt 'Robustheit und Randfälle' der Aufforderung erwähnt werden: Auslösen von `ValueError` für nicht-positive `tokens` und sofortiges Zurückgeben von `False`, wenn `tokens` die `capacity` überschreitet. Der Anfangszustand ist ebenfalls korrekt gesetzt.
Gesamtpunktzahl
Gesamtkommentar
Implementiert einen korrekten Token-Bucket-Limiter mit monotoner Zeit, fraktionellen Auffüllungen, Kapazitätsbegrenzung und ordnungsgemäßer Sperrung von Auffüllung+Verbrauch. Er behandelt auch den wichtigen Grenzfall von Anfragen, die größer als die Kapazität sind, indem er False zurückgibt. Kleiner Nachteil: Er löst bei Tokens<=0 aus (richtlinienabhängig; einige bevorzugen vielleicht die Behandlung von 0 als No-Op True) und er validiert die Eingaben für Kapazität/Auffüllrate nicht.
Bewertungsdetails anzeigen ▼
Korrektheit
Gewichtung 35%Korrekte Token-Bucket-Auffüllung basierend auf verstrichener monotoner Zeit, Begrenzung auf Kapazität und atomare Ausführung von Auffüllung+Verbrauch unter einer Sperre. Verwendet fraktionelle Tokens angemessen.
Vollstandigkeit
Gewichtung 20%Stellt eine vollständige Klasse mit Importen, interner Auffüllhilfe und Consume-Methode bereit; enthält explizite Behandlung von Tokens>Kapazität. Fehlende Validierung für Kapazitäts-/Auffüllratenwerte.
Codequalitat
Gewichtung 20%Lesbar, PEP8-ähnlich, mit Docstrings, die Verhalten und Erwartungen an die Sperrung erklären. Geradlinige Struktur.
Praktischer Nutzen
Gewichtung 15%Praktisch für den typischen Gebrauch; sofortiges False für unmögliche große Anfragen ist hilfreich. Das Auslösen bei Tokens<=0 kann in einigen Integrationen unbequem sein; keine Parametervalidierung für Kapazität/Auffüllrate.
Befolgung der Anweisungen
Gewichtung 10%Erfüllt die Anforderungen: threadsicher, keine externen Zustandsbibliotheken, korrekte Methoden und Verhalten, und enthält notwendige Importe.
Gesamtpunktzahl
Gesamtkommentar
Antwort A bietet eine korrekte, vollständige und gut dokumentierte Implementierung des Token-Bucket-Ratenbegrenzers. Sie implementiert den Algorithmus korrekt mit ordnungsgemäßer Threadsicherheit unter Verwendung von threading.Lock, behandelt Randfälle wie den Verbrauch von mehr Tokens als Kapazität (gibt False zurück) und den Verbrauch von null oder negativen Tokens (löst ValueError aus). Der Code enthält klare Docstrings, die den Zweck und die Parameter jeder Methode erklären. Er verwendet time.monotonic() für eine zuverlässige Zeiterfassung. Der Code ist sauber, lesbar und folgt gut den Python-Konventionen.
Bewertungsdetails anzeigen ▼
Korrektheit
Gewichtung 35%Implementiert den Token-Bucket-Algorithmus korrekt mit ordnungsgemäßer Nachfüllberechnung, Kapazitätsbegrenzung und atomaren Verbrauchsoperationen. Behandelt den Randfall, dass mehr Tokens als Kapazität angefordert werden, indem False frühzeitig zurückgegeben wird. Löst ValueError für nicht-positive Token-Anfragen aus.
Vollstandigkeit
Gewichtung 20%Beinhaltet die erforderlichen __init__, consume und Threadsicherheit. Behandelt Randfälle: null/negative Tokens (ValueError), Tokens, die die Kapazität überschreiten (gibt False zurück). Beginnt mit einem vollen Bucket. Enthält alle notwendigen Importe.
Codequalitat
Gewichtung 20%Gut dokumentiert mit klaren Docstrings für die Klasse und jede Methode. Parameterbeschreibungen sind vorhanden. Der Code ist sauber, lesbar und folgt den PEP 8-Konventionen. Die private Methode _refill wird klar als erfordert, dass der Lock gehalten wird, gekennzeichnet.
Praktischer Nutzen
Gewichtung 15%Bereit für den Einsatz in Produktionsszenarien. Die frühzeitige Rückgabe für Tokens, die die Kapazität überschreiten, ist eine praktische Optimierung. Der ValueError für ungültige Eingaben hilft beim Debugging. Verwendet time.monotonic() für zuverlässiges Timing.
Befolgung der Anweisungen
Gewichtung 10%Folgt allen Anweisungen: Implementiert die Klasse mit dem angegebenen Namen, __init__ mit Kapazität und Nachfüllrate, consume-Methode, die True/False zurückgibt, Threadsicherheit mit threading.Lock und enthält die notwendigen Importe. Bietet eine vollständige Klassenimplementierung wie gewünscht.