Scalability and Future Extension Questions

import time
import threading
from abc import ABC, abstractmethod

class TokenBucket:
    def __init__(self, capacity, refill_rate):
        self.capacity = capacity
        self.refill_rate = refill_rate  # tokens per second
        self.tokens = capacity
        self.last = time.time()
        self.lock = threading.Lock()

    def allow(self):
        with self.lock:
            now = time.time()
            elapsed = now - self.last
            added = elapsed * self.refill_rate
            if added > 0:
                self.tokens = min(self.capacity, self.tokens + added)
                self.last = now
            if self.tokens >= 1:
                self.tokens -= 1
                return True
            return False

class TokenStore(ABC):
    @abstractmethod
    def get_or_create(self, user_id, capacity, refill_rate) -> TokenBucket:
        pass

class InMemoryTokenStore(TokenStore):
    def __init__(self):
        self.store = {}
        self.store_lock = threading.Lock()

    def get_or_create(self, user_id, capacity, refill_rate):
        bucket = self.store.get(user_id)
        if bucket:
            return bucket
        with self.store_lock:
            # double-check
            bucket = self.store.get(user_id)
            if not bucket:
                bucket = TokenBucket(capacity, refill_rate)
                self.store[user_id] = bucket
            return bucket

class RateLimiter:
    def __init__(self, capacity, refill_rate, store=None):
        self.capacity = capacity
        self.refill_rate = refill_rate
        self.store = store or InMemoryTokenStore()

    def allow_request(self, user_id) -> bool:
        bucket = self.store.get_or_create(user_id, self.capacity, self.refill_rate)
        return bucket.allow()