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.