type the commands ext to mypy

Author: IAmTomahawkx

twitchio/ext/commands/bot.py

@@ -22,19 +22,23 @@
 DEALINGS IN THE SOFTWARE.
 """
 
+from __future__ import annotations
 import importlib
 import inspect
 import sys
 import traceback
-from typing import Callable, Optional, Union, Coroutine
+import types
+from typing import Callable, Optional, Union, Coroutine, Dict, List, TYPE_CHECKING, Mapping, Awaitable
 
 from twitchio.client import Client
-from .core import *
+from .core import Command, Group, Context
 from .errors import *
 from .meta import Cog
 from .stringparser import StringParser
 from .utils import _CaseInsensitiveDict
 
+if TYPE_CHECKING:
+    from twitchio import Message
 
 class Bot(Client):
     def __init__(
@@ -54,15 +58,15 @@ def __init__(
         self._prefix = prefix
 
         if kwargs.get("case_insensitive", False):
-            self._commands = _CaseInsensitiveDict()
-            self._command_aliases = _CaseInsensitiveDict()
+            self._commands: Union[dict, _CaseInsensitiveDict] = _CaseInsensitiveDict()
+            self._command_aliases: Union[dict, _CaseInsensitiveDict] = _CaseInsensitiveDict()
         else:
             self._commands = {}
             self._command_aliases = {}
 
-        self._modules = {}
-        self._cogs = {}
-        self._checks = []
+        self._modules: Dict[str, types.ModuleType] = {}
+        self._cogs: Dict[str, Cog] = {}
+        self._checks: List[Callable[[Context], Union[bool, Awaitable[bool]]]] = []
 
         self.__init__commands__()
 
@@ -259,7 +263,7 @@ async def invoke(self, context):
         self.run_event("command_invoke", context)
         await context.command(context)
 
-    def load_module(self, name: str):
+    def load_module(self, name: str) -> None:
         """Method which loads a module and it's cogs.
 
         Parameters
@@ -273,15 +277,15 @@ def load_module(self, name: str):
         module = importlib.import_module(name)
 
         if hasattr(module, "prepare"):
-            module.prepare(self)
+            module.prepare(self) # type: ignore
         else:
             del module
             del sys.modules[name]
             raise ImportError(f"Module <{name}> is missing a prepare method")
 
         self._modules[name] = module
 
-    def unload_module(self, name: str):
+    def unload_module(self, name: str) -> None:
         """Method which unloads a module and it's cogs.
 
         Parameters
@@ -296,7 +300,7 @@ def unload_module(self, name: str):
 
         if hasattr(module, "breakdown"):
             try:
-                module.breakdown(self)
+                module.breakdown(self) # type: ignore
             except:
                 pass
 
@@ -341,7 +345,7 @@ def reload_module(self, name: str):
             self.load_module(name)
         except Exception as e:
             sys.modules.update(modules)
-            module.prepare(self)
+            module.prepare(self) # type: ignore
             raise
 
     def add_cog(self, cog: Cog):
@@ -411,7 +415,7 @@ async def my_command(self, ctx):
         """
         pass
 
-    async def global_after_invoke(self, ctx):
+    async def global_after_invoke(self, ctx: Context) -> None:
         """|coro|
 
         Method which is called after any command is invoked regardless if it failed or not.
@@ -435,11 +439,11 @@ def commands(self):
         return self._commands
 
     @property
-    def cogs(self):
+    def cogs(self) -> Mapping[str, Cog]:
         """The currently loaded cogs."""
         return self._cogs
 
-    async def event_command_error(self, context, error):
+    async def event_command_error(self, context: Context, error: Exception) -> None:
         """|coro|
 
         Event called when an error occurs during command invocation.
@@ -454,7 +458,7 @@ async def event_command_error(self, context, error):
         print(f"Ignoring exception in command: {error}:", file=sys.stderr)
         traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)
 
-    async def event_message(self, message):
+    async def event_message(self, message: Message) -> None:
         """|coro|
 
         Event called when a PRIVMSG is received from Twitch.

twitchio/ext/commands/builtin_converter.py

@@ -22,6 +22,7 @@
 DEALINGS IN THE SOFTWARE.
 """
 
+from __future__ import annotations
 import re
 from typing import TYPE_CHECKING
 
@@ -42,7 +43,7 @@
 )
 
 
-async def convert_Chatter(ctx: "Context", arg: str):
+async def convert_Chatter(ctx: Context, arg: str) -> Chatter:
     """
     Converts the argument into a chatter in the chat. If the chatter is not found, BadArgument is raised.
     """
@@ -54,14 +55,14 @@ async def convert_Chatter(ctx: "Context", arg: str):
     return resp[0]
 
 
-async def convert_PartialChatter(ctx: "Context", arg: str):
+async def convert_PartialChatter(ctx: Context, arg: str) -> Chatter:
     """
     Actually a shorthand to :ref:`~convert_Chatter`
     """
-    return convert_Chatter(ctx, arg)
+    return await convert_Chatter(ctx, arg)
 
 
-async def convert_Clip(ctx: "Context", arg: str):
+async def convert_Clip(ctx: Context, arg: str) -> Clip:
     finder = re.search(r"(https://clips.twitch.tv/)?(?P<slug>.*)", arg)
     if not finder:
         raise RuntimeError("regex failed to match") # this should never ever raise, but its here to make type checkers happy
@@ -74,7 +75,7 @@ async def convert_Clip(ctx: "Context", arg: str):
     return clips[0]
 
 
-async def convert_User(ctx: "Context", arg: str):
+async def convert_User(ctx: Context, arg: str) -> User:
     """
     Similar to convert_Chatter, but fetches from the twitch API instead,
     returning a :class:`twitchio.User` instead of a :class:`twitchio.Chatter`.
@@ -87,14 +88,14 @@ async def convert_User(ctx: "Context", arg: str):
     return user[0]
 
 
-async def convert_PartialUser(ctx: "Context", arg: str):
+async def convert_PartialUser(ctx: Context, arg: str) -> User:
     """
     This is simply a shorthand to :ref:`~convert_User`, as fetching from the api will return a full user model
     """
     return await convert_User(ctx, arg)
 
 
-async def convert_Channel(ctx: "Context", arg: str):
+async def convert_Channel(ctx: Context, arg: str) -> Channel:
     if arg not in ctx.bot._connection._cache:
         raise BadArgument(f"Not connected to channel '{arg}'")
 

twitchio/ext/commands/cooldowns.py

@@ -24,6 +24,7 @@
 DEALINGS IN THE SOFTWARE.
 """
 
+from __future__ import annotations
 import enum
 import time