Additional methods + fix remove_cog (#195)

* Replace if statement with if expression

* Simplify conditional into return statement

* Inline variable that is immediately returned

* Comparison moved to the right
Use set when checking membership of a collection of literals

* Inline variable that is immediately returned

* remove none from dict.get returns none by default

* Replace if statement with if expression
Replace multiple comparisons of same variable with `in` operator
Remove redundant conditional

* Merge nested if conditions
Remove none from dict.get returns none by default

* Lift code into else after jump in control flow, Merge else clause's nested if statement into elif
Remove redundant pass statements
Simplify logical expression

* Inline variable that is immediately returned

* Merge nested if conditions
Inline variable that is immediately returned

* Merge nested if conditions

* Swap if/else branches, Remove unnecessary else after guard condition

* Replace unneeded comprehension with generator

* added fetch_channel to client

* formatting

* remove typehint of User

* Added fetch_follow method
Removed for loop for fetch_channel

* Update README.rst

Added myself....just because

* fix remove_cog

* Fixed remove_cog

* changed from list to set

* Moved fetch_follow to user from client
Fixed black formatting to 120

* Added ChannelInfo class in models
Changed fetch_channel to return the ChannelInfo object

* Removed except from remove_cog
Issue was in unload_module
Missing .items() for callsbacks
Missing .__name__ for comparison

* fixed reload_module

* added created_at to User class

* Routine fix where after task run completion
iterations would set to 0 and run infinitely.

* Add typehint for PartialUser in fetch_follow

Author: chillymosh

README.rst

@@ -111,5 +111,6 @@ Special thanks to:
 
 `Scragly <https://github.com/scragly>`_
 
+`Chillymosh <https://github.com/chillymosh>`_
 
 If I have forgotten anyone please let me know <3: `EvieePy <https://github.com/EvieePy>`_

twitchio/abcs.py

@@ -42,11 +42,7 @@ def get_bucket(self, channel: str, method: str) -> RateBucket:
 
         if bucket.method != method:
             bucket.method = method
-            if method == "mod":
-                bucket.limit = bucket.MODLIMIT
-            else:
-                bucket.limit = bucket.IRCLIMIT
-
+            bucket.limit = bucket.MODLIMIT if method == "mod" else bucket.IRCLIMIT
             self.buckets[channel] = bucket
 
         return bucket

twitchio/chatter.py

@@ -160,10 +160,7 @@ def is_mod(self) -> bool:
         """A boolean indicating whether the User is a moderator of the current channel."""
         if self._mod == 1:
             return True
-        if self.channel.name == self.display_name.lower():
-            return True
-        else:
-            return False
+        return self.channel.name == self.display_name.lower()
 
     @property
     def is_turbo(self) -> Optional[bool]:

twitchio/client.py

@@ -30,6 +30,7 @@
 import sys
 from typing import Union, Callable, List, Optional, Tuple, Any
 
+from twitchio.errors import HTTPException
 from . import models
 from .websocket import WSConnection
 from .http import TwitchHTTP
@@ -83,7 +84,11 @@ def __init__(
 
         self._http = TwitchHTTP(self, api_token=token, client_secret=client_secret)
         self._connection = WSConnection(
-            client=self, token=token, loop=self.loop, initial_channels=initial_channels, heartbeat=heartbeat
+            client=self,
+            token=token,
+            loop=self.loop,
+            initial_channels=initial_channels,
+            heartbeat=heartbeat,
         )
 
         self._events = {}
@@ -127,7 +132,10 @@ def from_client_credentials(
         self._http = TwitchHTTP(self, client_id=client_id, client_secret=client_secret)
         self._heartbeat = heartbeat
         self._connection = WSConnection(
-            client=self, loop=self.loop, initial_channels=None, heartbeat=self._heartbeat
+            client=self,
+            loop=self.loop,
+            initial_channels=None,
+            heartbeat=self._heartbeat,
         )  # The only reason we're even creating this is to avoid attribute errors
         self._events = {}
         self._waiting = []
@@ -192,7 +200,10 @@ async def wrapped(func):
             if inspect.iscoroutinefunction(inner_cb):
                 self.loop.create_task(wrapped(inner_cb))
             else:
-                warnings.warn(f"event '{name}' callback is not a coroutine", category=RuntimeWarning)
+                warnings.warn(
+                    f"event '{name}' callback is not a coroutine",
+                    category=RuntimeWarning,
+                )
 
         if name in self._events:
             for event in self._events[name]:
@@ -239,7 +250,11 @@ def decorator(func: Callable) -> Callable:
         return decorator
 
     async def wait_for(
-        self, event: str, predicate: Callable[[], bool] = lambda *a: True, *, timeout=60.0
+        self,
+        event: str,
+        predicate: Callable[[], bool] = lambda *a: True,
+        *,
+        timeout=60.0,
     ) -> Tuple[Any]:
         """|coro|
 
@@ -285,8 +300,26 @@ def get_channel(self, name: str) -> Optional[Channel]:
             # With the associated users as a set.
             # We create a Channel here and return it only if the cache has that channel key.
 
-            channel = Channel(name=name, websocket=self._connection)
-            return channel
+            return Channel(name=name, websocket=self._connection)
+
+    async def fetch_channel(self, broadcaster: str) -> list:
+        """Retrieve a channel from the API.
+
+        Parameters
+        -----------
+        name: str
+            The channel name or ID to request from API. Returns empty list if no channel was found.
+
+        Returns
+        --------
+            :class:`list`
+        """
+
+        if not broadcaster.isdigit():
+            get_id = await self.fetch_users(names=[broadcaster.lower()])
+            broadcaster = get_id[0].id
+
+        return await self._http.get_channels(broadcaster)
 
     async def join_channels(self, channels: Union[List[str], Tuple[str]]):
         """|coro|
@@ -334,7 +367,11 @@ def create_user(self, user_id: int, user_name: str) -> PartialUser:
 
     @user_cache()
     async def fetch_users(
-        self, names: List[str] = None, ids: List[int] = None, token: str = None, force=False
+        self,
+        names: List[str] = None,
+        ids: List[int] = None,
+        token: str = None,
+        force=False,
     ) -> List[User]:
         """|coro|
         Fetches users from the helix API
@@ -378,6 +415,34 @@ async def fetch_clips(self, ids: List[str]):
         data = await self._http.get_clips(ids=ids)
         return [models.Clip(self._http, d) for d in data]
 
+    async def fetch_channel(self, broadcaster: str):
+        """Retrieve a channel from the API.
+
+        Parameters
+        -----------
+        name: str
+            The channel name or ID to request from API. Returns empty dict if no channel was found.
+
+        Returns
+        --------
+            :class:`twitchio.ChannelInfo`
+        """
+
+        if not broadcaster.isdigit():
+            get_id = await self.fetch_users(names=[broadcaster.lower()])
+            if not get_id:
+                raise IndexError("Invalid channel name.")
+            broadcaster = get_id[0].id
+        try:
+            data = await self._http.get_channels(broadcaster)
+
+            from .models import ChannelInfo
+
+            return ChannelInfo(self._http, data=data[0])
+
+        except HTTPException:
+            raise HTTPException("Incorrect channel ID.")
+
     async def fetch_videos(
         self,
         ids: List[int] = None,
@@ -419,7 +484,13 @@ async def fetch_videos(
         from .models import Video
 
         data = await self._http.get_videos(
-            ids, user_id=user_id, game_id=game_id, period=period, sort=sort, type=type, language=language
+            ids,
+            user_id=user_id,
+            game_id=game_id,
+            period=period,
+            sort=sort,
+            type=type,
+            language=language,
         )
         return [Video(self._http, x) for x in data]
 

twitchio/ext/commands/bot.py

@@ -192,9 +192,7 @@ def get_cog(self, name: str) -> Optional[Cog]:
         ---------
         Optional[:class:`.Cog`]
         """
-        cog = self.cogs.get(name, None)
-
-        return cog
+        return self.cogs.get(name, None)
 
     async def get_context(self, message, *, cls=None):
         """Get a Context object from a message.
@@ -302,11 +300,11 @@ def unload_module(self, name: str):
             except:
                 pass
 
-        to_delete = [cog_name for cog_name, cog in self._cogs.items() if cog.__module__ == module]
+        to_delete = [cog_name for cog_name, cog in self._cogs.items() if cog.__module__ == module.__name__]
         for name in to_delete:
             self.remove_cog(name)
 
-        to_delete = [name for name, cmd in self._commands if cmd._callback.__module__ == module]
+        to_delete = [name for name, cmd in self._commands.items() if cmd._callback.__module__ == module.__name__]
         for name in to_delete:
             self.remove_command(name)
 
@@ -330,7 +328,7 @@ def reload_module(self, name: str):
         if name not in self._modules:
             raise ValueError(f"Module <{name}> is not loaded")
 
-        module = self._modules.pop(name)
+        module = self._modules[name]
 
         modules = {
             name: m
@@ -370,7 +368,6 @@ def add_cog(self, cog: Cog):
 
     def remove_cog(self, cog_name: str):
         """Method which removes a cog from the bot.
-
         Parameters
         ----------
         cog_name: str
@@ -380,7 +377,6 @@ def remove_cog(self, cog_name: str):
             raise InvalidCog(f"Cog '{cog_name}' not found")
 
         cog = self._cogs.pop(cog_name)
-
         cog._unload_methods(self)
 
     async def global_before_invoke(self, ctx):

twitchio/ext/commands/core.py

@@ -102,9 +102,12 @@ def full_name(self):
         return f"{self.parent.full_name} {self._name}"
 
     def _resolve_converter(self, converter: Union[Callable, Awaitable, type]) -> Callable:
-        if isinstance(converter, type) and converter.__module__.startswith("twitchio"):
-            if converter in builtin_converter._mapping:
-                return builtin_converter._mapping[converter]
+        if (
+            isinstance(converter, type)
+            and converter.__module__.startswith("twitchio")
+            and converter in builtin_converter._mapping
+        ):
+            return builtin_converter._mapping[converter]
 
         return converter
 
@@ -277,9 +280,8 @@ async def handle_checks(self, context):
                 if not result:
                     raise CheckFailure(f"The check {predicate} for command {self.name} failed.")
 
-            if self.cog:
-                if not await self.cog.cog_check(context):
-                    raise CheckFailure(f"The cog check for command <{self.name}> failed.")
+            if self.cog and not await self.cog.cog_check(context):
+                raise CheckFailure(f"The cog check for command <{self.name}> failed.")
 
             return True
         except Exception as e:
@@ -457,9 +459,12 @@ def command(
 
     def decorator(func: Callable):
         fname = name or func.__name__
-        cmd = cls(name=fname, func=func, aliases=aliases, no_global_checks=no_global_checks)
-
-        return cmd
+        return cls(
+            name=fname,
+            func=func,
+            aliases=aliases,
+            no_global_checks=no_global_checks,
+        )
 
     return decorator
 
@@ -477,16 +482,14 @@ def group(
 
     def decorator(func: Callable):
         fname = name or func.__name__
-        cmd = cls(
+        return cls(
             name=fname,
             func=func,
             aliases=aliases,
             no_global_checks=no_global_checks,
             invoke_with_subcommand=invoke_with_subcommand,
         )
 
-        return cmd
-
     return decorator
 
 

twitchio/ext/commands/meta.py

@@ -47,9 +47,10 @@ def __new__(mcs, *args, **kwargs):
         self._commands = {}
 
         for name, mem in inspect.getmembers(self):
-            if isinstance(mem, (CogEvent, Command)):
-                if name.startswith(("cog_", "bot_")):  # Invalid method prefixes
-                    raise RuntimeError(f'The event or command "{name}" starts with an invalid prefix (cog_ or bot_).')
+            if isinstance(mem, (CogEvent, Command)) and name.startswith(
+                ("cog_", "bot_")
+            ):  # Invalid method prefixes
+                raise RuntimeError(f'The event or command "{name}" starts with an invalid prefix (cog_ or bot_).')
 
             if isinstance(mem, CogEvent):
                 try:

twitchio/ext/pubsub/pool.py

@@ -87,17 +87,16 @@ async def unsubscribe_topics(self, topics: List[Topic]):
                 self._pool.remove(node)
 
     def _find_node(self, topics: List[Topic]) -> Optional[PubSubWebsocket]:
-        if self._mode == "group":
-            for p in self._pool:
-                if len(p.max_topics) + len(topics) <= p.max_topics:
-                    return p
-
-            if len(self._pool) < self._max_size:
-                return None
-            else:
-                raise models.PoolFull(
-                    f"The pubsub pool has reached maximum topics. Unable to allocate a group of {len(topics)} topics."
-                )
+        if self._mode != "group":
+            raise ValueError("group is the only supported mode.")
+
+        for p in self._pool:
+            if len(p.max_topics) + len(topics) <= p.max_topics:
+                return p
 
+        if len(self._pool) < self._max_size:
+            return None
         else:
-            raise ValueError("group is the only supported mode.")
+            raise models.PoolFull(
+                f"The pubsub pool has reached maximum topics. Unable to allocate a group of {len(topics)} topics."
+            )

twitchio/ext/pubsub/websocket.py

@@ -134,7 +134,7 @@ async def subscribe_topics(self, topics: List[Topic]):
         await self._send_topics(topics)
 
     async def unsubscribe_topic(self, topics: List[Topic]):
-        if not all([t in self.topics for t in topics]):
+        if any(t not in self.topics for t in topics):
             raise ValueError("Topics were given that have not been subscribed to")
 
         await self._send_topics(topics, type="UNLISTEN")

twitchio/ext/routines/__init__.py

@@ -288,6 +288,9 @@ async def _routine(self, *args, **kwargs) -> None:
         if self._wait_first and not self._time:
             await asyncio.sleep(self._delta)
 
+        if self._remaining_iterations == 0:
+            self._remaining_iterations = self._iterations
+
         while True:
             start = datetime.datetime.now(datetime.timezone.utc)