One approach as a context manager (to help delineate the code waiting for quota):

class _RateLimitManager:

    """A context manager which waits until there is some request quota.

    This context manager is **not** thread-safe.
    """

    def __init__(self, gh: "GitHubAPI", need: int) -> None:
        self._gh = gh
        self._need = need

    def update_rate_limit(self) -> None:
        """Update the rate limit in a blocking fashion."""
        pass

    async def __aenter__(self) -> None:
        """Wait until there is at least enough requested quota."""
        if self._gh.rate_limit is None:
            # First time using the GitHubAPI instance, so get accurate rate
            # limit details.
            self.update_rate_limit()
        # A worst-case scenario is when the rate limit is reached, the limit is
        # N requests, there are N+1 sleeping coroutines, and all N+1 coroutines
        # wake up in FIFO order and being waiting for responses before the first
        # request completes with the new rate limit details. To prevent this
        # worst-case from occurring, the last step is short-circuited by doing
        # a **blocking** check for the current rate limit. That makes sure
        # there's no potential race conditions in getting the new rate limit
        # when the reset epoch has passed.
        while self._gh.rate_limit.remaining < self._need:
            now = datetime.datetime.now(datetime.timezone.utc)
            if self._gh.rate_limit.reset_datetime > now:
                wait = self.rate_limit.reset_datetime - now
                await self._sleep(wait.total_seconds())
            else:
                self.update_rate_limit()

    async def __aexit__(self, exc_type, exc, tb):
        pass

Uh oh!

Provide a way to sleep until rate limit resets #19

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions