Resposta A: Anthropic Claude Sonnet 4.6
import threading
import time
class TokenBucketRateLimiter:
def init(self, capacity, refill_rate):
"""
Inicializa o Token Bucket Rate Limiter.
:param capacity: Número máximo de tokens que o balde pode conter.
:param refill_rate: Número de tokens adicionados ao balde por segundo.
"""
self.capacity = capacity
self.refill_rate = refill_rate
self._tokens = capacity # Começa com um balde cheio
self._last_refill_time = time.monotonic()
self._lock = threading.Lock()
def _refill(self):
"""
Recarrega o balde com...
Mostrar resposta completa ▼
import threading
import time
class TokenBucketRateLimiter:
def init(self, capacity, refill_rate):
"""
Inicializa o Token Bucket Rate Limiter.
:param capacity: Número máximo de tokens que o balde pode conter.
:param refill_rate: Número de tokens adicionados ao balde por segundo.
"""
self.capacity = capacity
self.refill_rate = refill_rate
self._tokens = capacity # Começa com um balde cheio
self._last_refill_time = time.monotonic()
self._lock = threading.Lock()
def _refill(self):
"""
Recarrega o balde com base no tempo decorrido desde a última recarga.
Este método deve ser chamado enquanto o bloqueio estiver ativo.
"""
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):
"""
Tenta consumir um determinado número de tokens do balde.
:param tokens: Número de tokens a serem consumidos.
:return: True se os tokens foram consumidos com sucesso, False caso contrário.
"""
if tokens <= 0:
raise ValueError("O número de tokens a consumir deve ser positivo.")
if tokens > self.capacity:
# Nunca pode ser satisfeito mesmo com um balde cheio
return False
with self._lock:
self._refill()
if self._tokens >= tokens:
self._tokens -= tokens
return True
return False
Resultado
Votos de vitoria
3 / 3
Pontuacao media
Pontuacao total
Comentario geral
A Resposta A fornece uma implementação altamente correta e bem estruturada do Token Bucket Rate Limiter. A qualidade do seu código é excelente, apresentando docstrings claras e adesão às convenções do Python. Implementa corretamente a segurança de threads e lida explicitamente com os casos de borda especificados, tornando-a uma solução robusta e de fácil manutenção.
Ver detalhes da avaliacao ▼
Correcao
Peso 35%O algoritmo para recarregar e consumir tokens está corretamente implementado. O limite de capacidade é devidamente aplicado e a lógica de recarga baseada em tempo é sólida.
Completude
Peso 20%A resposta fornece uma implementação de classe completa com todos os métodos especificados (`__init__`, `consume`) e as importações necessárias.
Qualidade do codigo
Peso 20%O código é limpo, legível e segue as convenções padrão do Python. Inclui excelentes docstrings para métodos públicos e um comentário claro para o método privado de recarga, aumentando significativamente a manutenibilidade.
Valor pratico
Peso 15%A implementação usa corretamente `threading.Lock` para garantir a segurança de threads, tornando-a adequada para ambientes concorrentes. É uma solução praticamente sólida.
Seguimento de instrucoes
Peso 10%A solução lida explicitamente com todos os casos de borda mencionados na seção 'Robustez e Casos de Borda' do prompt: levantando `ValueError` para `tokens` não positivos e retornando `False` imediatamente se `tokens` exceder `capacity`. O estado inicial também está corretamente definido.
Pontuacao total
Comentario geral
Implementa um limitador de bucket de tokens correto com tempo monotônico, recargas fracionárias, limitação de capacidade e bloqueio adequado em recarga+consumo. Também lida com o importante caso extremo de requisições maiores que a capacidade, retornando False. Desvantagem menor: levanta exceção para tokens<=0 (dependente da política; alguns podem preferir tratar 0 como um True sem operação) e não valida as entradas de capacidade/taxa_de_recarga.
Ver detalhes da avaliacao ▼
Correcao
Peso 35%Recarga correta do bucket de tokens com base no tempo monotônico decorrido, limita na capacidade e executa recarga+consumo atomicamente sob um bloqueio. Usa tokens fracionários apropriadamente.
Completude
Peso 20%Fornece classe completa com importações, helper interno de recarga e método de consumo; inclui tratamento explícito para tokens>capacidade. Falta validação para valores de capacidade/taxa_de_recarga.
Qualidade do codigo
Peso 20%Legível, estilo PEP8, com docstrings explicando o comportamento e as expectativas de bloqueio. Estrutura direta.
Valor pratico
Peso 15%Prático para uso típico; o False imediato para requisições grandes impossíveis é útil. Levantar exceção para tokens<=0 pode ser inconveniente em algumas integrações; sem validação de parâmetros para capacidade/taxa_de_recarga.
Seguimento de instrucoes
Peso 10%Atende aos requisitos: thread-safe, sem bibliotecas de estado externas, métodos e comportamento corretos, e inclui as importações necessárias.
Pontuacao total
Comentario geral
A Resposta A fornece uma implementação correta, completa e bem documentada do limitador de taxa de balde de tokens. Implementa corretamente o algoritmo com segurança de thread adequada usando threading.Lock, lida com casos extremos como consumir mais tokens do que a capacidade (retorna False) e consumir zero ou tokens negativos (gera ValueError). O código inclui docstrings claras explicando o propósito e os parâmetros de cada método. Usa time.monotonic() para rastreamento de tempo confiável. O código é limpo, legível e segue bem as convenções do Python.
Ver detalhes da avaliacao ▼
Correcao
Peso 35%Implementa corretamente o algoritmo de balde de tokens com cálculo de recarga adequado, limitação de capacidade e operações de consumo atômicas. Lida com o caso extremo de solicitar mais tokens do que a capacidade retornando False antecipadamente. Gera ValueError para solicitações de tokens não positivas.
Completude
Peso 20%Cobre o __init__ necessário, consume e segurança de thread. Lida com casos extremos: tokens zero/negativos (ValueError), tokens excedendo a capacidade (retorna False). Começa com um balde cheio. Inclui todas as importações necessárias.
Qualidade do codigo
Peso 20%Bem documentado com docstrings claras para a classe e cada método. Descrições de parâmetros são fornecidas. O código é limpo, legível e segue as convenções PEP 8. O método privado _refill é claramente anotado como exigindo que o lock seja mantido.
Valor pratico
Peso 15%Pronto para uso em cenários de produção. O retorno antecipado para tokens excedendo a capacidade é uma otimização prática. O ValueError para entrada inválida ajuda na depuração. Usa time.monotonic() para tempo confiável.
Seguimento de instrucoes
Peso 10%Segue todas as instruções: implementa a classe com o nome especificado, __init__ com capacidade e taxa de recarga, método consume retornando True/False, segurança de thread com threading.Lock e inclui as importações necessárias. Fornece implementação completa da classe conforme solicitado.