Adjust join rate limiting, add retain_cache

Join channels rate limiting has been adjusted to fix 20+ initial_channels

retain_cache has also been added as a kwarg to Client

Author: chillymosh

docs/changelog.rst

@@ -7,6 +7,8 @@ Massive documentation updates
 - TwitchIO
     - Removed unexpected loop termination from `WSConnection._close()`
     - Fix bug where # prefixed channel names and capitals in initial_channels would not trigger :func:`twitchio.Client.event_ready`
+    - Adjusted join channel rate limit handling
+    - Added `retain_cache` kwarg to Client and Bot
     - :func:`User.create_clip` has been fixed by converting bool to string in http request
     - Poll endpoints added :func:`User.fetch_polls` :func:`User.create_poll` and :func:`User.end_poll`
     - :func:`Client.fetch_cheermotes` color attribute corrected

twitchio/client.py

@@ -60,6 +60,9 @@ class Client:
         The event loop the client will use to run.
     heartbeat: Optional[float]
         An optional float in seconds to send a PING message to the server. Defaults to 30.0.
+    retain_cache: Optional[bool]
+        An optional bool that will retain the cache if PART is received from websocket when True.
+        It will still remove from cache if part_channels is manually called. Defaults to False.
 
     Attributes
     ------------
@@ -75,6 +78,7 @@ def __init__(
         initial_channels: Union[list, tuple, Callable] = None,
         loop: asyncio.AbstractEventLoop = None,
         heartbeat: Optional[float] = 30.0,
+        retain_cache: Optional[bool] = False,
     ):
 
         self.loop: asyncio.AbstractEventLoop = loop or asyncio.get_event_loop()
@@ -89,6 +93,7 @@ def __init__(
             loop=self.loop,
             initial_channels=initial_channels,
             heartbeat=heartbeat,
+            retain_cache=retain_cache,
         )
 
         self._events = {}

twitchio/ext/commands/bot.py

@@ -55,10 +55,15 @@ def __init__(
         client_secret: str = None,
         initial_channels: Union[list, tuple, Callable] = None,
         heartbeat: Optional[float] = 30.0,
+        retain_cache: Optional[bool] = False,
         **kwargs,
     ):
         super().__init__(
-            token=token, client_secret=client_secret, initial_channels=initial_channels, heartbeat=heartbeat
+            token=token,
+            client_secret=client_secret,
+            initial_channels=initial_channels,
+            heartbeat=heartbeat,
+            retain_cache = retain_cache,
         )
 
         self._prefix = prefix

twitchio/websocket.py

@@ -60,6 +60,7 @@ def __init__(
         token: str = None,
         modes: tuple = None,
         initial_channels: List[str] = None,
+        retain_cache: Optional[bool] = False,
     ):
         self._loop = loop
         self._backoff = ExponentialBackoff()
@@ -94,6 +95,7 @@ def __init__(
         self._token = token
         self.modes = modes or ("commands", "tags", "membership")
         self._initial_channels = initial_channels or []
+        self._retain_cache = retain_cache
 
         if callable(self._initial_channels):
             _temp_initial_channels = self._initial_channels()
@@ -261,6 +263,8 @@ async def part_channels(self, *channels: str):
         for channel in channels:
             channel = re.sub("[#]", "", channel).lower()
             await self.send(f"PART #{channel}\r\n")
+            if self._retain_cache:
+                self._cache.pop(channel, None)
 
     async def join_channels(self, *channels: str):
         """|coro|
@@ -276,11 +280,10 @@ async def join_channels(self, *channels: str):
             for channel in channels:
                 if self._join_handle < time.time():  # Handle is less than the current time
                     self._join_tick = 20  # So lets start a new rate limit bucket..
-                    self._join_handle = time.time() + 10  # Set the handle timeout time
+                    self._join_handle = time.time() + 11  # Set the handle timeout time
 
                 if self._join_tick == 0:  # We have exhausted the bucket, wait so we can make a new one...
                     await asyncio.sleep(self._join_handle - time.time())
-                    continue
 
                 asyncio.create_task(self._join_channel(channel))
                 self._join_tick -= 1
@@ -294,7 +297,7 @@ async def _join_channel(self, entry):
 
     async def _join_future_handle(self, fut: asyncio.Future, channel: str):
         try:
-            await asyncio.wait_for(fut, timeout=10)
+            await asyncio.wait_for(fut, timeout=11)
         except asyncio.TimeoutError:
             log.error(f'The channel "{channel}" was unable to be joined. Check the channel is valid.')
             self._join_pending.pop(channel)
@@ -386,8 +389,8 @@ async def _part(self, parsed):  # TODO
                 pass
             else:
                 self._join_pending.pop(channel)
-
-        self._cache.pop(channel, None)
+        if not self._retain_cache:
+            self._cache.pop(channel, None)
 
         channel = Channel(name=channel, websocket=self)
         user = Chatter(name=parsed["user"], bot=self._client, websocket=self, channel=channel, tags=parsed["badges"])