aiohttp: rate limiting parallel requests

Question

APIs often have rate limits that users have to follow. As an example let\'s take 50 requests/second. Sequential requests take 0.5-1 second and thus are too slow to come clos

Answer 1

I approached the problem by creating a sub class of aiohttp.ClientSession() with rate-limiter in-built based on leaky-bucket algorithm. I use asyncio.Queue() for ratelimiting instead of Semaphores. I only overrode the _request() method. I find this approach cleaner since you only replace session = aiohttp.ClientSession() with session = ThrottledClientSession(rate_limit=15)

Code:

class ThrottledClientSession(aiohttp.ClientSession):
    """Rate-throttled client session class inherited from aiohttp.ClientSession)""" 
MIN_SLEEP = 0.1

def __init__(self, rate_limit: float =None, *args,**kwargs) -> None: 
    super().__init__(*args,**kwargs)
    self.rate_limit = rate_limit
    self._fillerTask = None
    self._queue = None
    self._start_time = time.time()
    if rate_limit != None:
        if rate_limit <= 0:
            raise ValueError('rate_limit must be positive')
        self._queue = asyncio.Queue(min(2, int(rate_limit)+1))
        self._fillerTask = asyncio.create_task(self._filler(rate_limit))

 
def _get_sleep(self) -> list:
    if self.rate_limit != None:
        return max(1/self.rate_limit, self.MIN_SLEEP)
    return None
    
async def close(self) -> None:
    """Close rate-limiter's "bucket filler" task"""
    if self._fillerTask != None:
        self._fillerTask.cancel()
    try:
        await asyncio.wait_for(self._fillerTask, timeout= 0.5)
    except asyncio.TimeoutError as err:
        print(str(err))
    await super().close()


async def _filler(self, rate_limit: float = 1):
    """Filler task to fill the leaky bucket algo"""
    try:
        if self._queue == None:
            return 
        self.rate_limit = rate_limit
        sleep = self._get_sleep()
        updated_at = time.monotonic()
        fraction = 0
        extra_increment = 0
        for i in range(0,self._queue.maxsize):
            self._queue.put_nowait(i)
        while True:
            if not self._queue.full():
                now = time.monotonic()
                increment = rate_limit * (now - updated_at)
                fraction += increment % 1
                extra_increment = fraction // 1
                items_2_add = int(min(self._queue.maxsize - self._queue.qsize(), int(increment) + extra_increment))
                fraction = fraction % 1
                for i in range(0,items_2_add):
                    self._queue.put_nowait(i)
                updated_at = now
            await asyncio.sleep(sleep)
    except asyncio.CancelledError:
        print('Cancelled')
    except Exception as err:
        print(str(err))


async def _allow(self) -> None:
    if self._queue != None:
        # debug 
        #if self._start_time == None:
        #    self._start_time = time.time()
        await self._queue.get()
        self._queue.task_done()
    return None


async def _request(self, *args,**kwargs):
    """Throttled _request()"""
    await self._allow()
    return await super()._request(*args,**kwargs)