Don't use the asyncio loop outside of async context

Author: linuxdaemon

cloudbot/util/async_util.py

@@ -3,7 +3,6 @@
 """
 
 import asyncio
-import sys
 from asyncio import AbstractEventLoop
 from asyncio.tasks import Task
 from functools import partial
@@ -56,19 +55,10 @@ def run_coroutine_threadsafe(coro, loop):
     if not asyncio.iscoroutine(coro):
         raise TypeError("A coroutine object is required")
 
-    if sys.version_info < (3, 5, 1):
-        loop.call_soon_threadsafe(partial(wrap_future, coro, loop=loop))
-    else:
-        asyncio.run_coroutine_threadsafe(coro, loop)
-
-
-def create_future(loop=None) -> asyncio.Future:
-    if loop is None:
-        loop = asyncio.get_event_loop()
+    asyncio.run_coroutine_threadsafe(coro, loop)
 
-    if sys.version_info < (3, 5, 2):
-        return asyncio.Future(loop=loop)
 
+def create_future(loop) -> asyncio.Future:
     return loop.create_future()
 
 

cloudbot/util/mapping.py

@@ -1,6 +1,6 @@
 import weakref
 from collections import defaultdict
-from typing import Generic, Mapping, MutableMapping, Type, TypeVar, cast
+from typing import TYPE_CHECKING, Generic, MutableMapping, TypeVar, cast
 
 __all__ = (
     "KeyFoldDict",
@@ -13,54 +13,48 @@
 K = TypeVar("K", bound=str)
 V = TypeVar("V")
 
+if TYPE_CHECKING:
 
-class KeyFoldMixin(Generic[K, V]):
+    class MapBase(MutableMapping[K, V]):
+        ...
+
+else:
+
+    class MapBase(Generic[K, V]):
+        ...
+
+
+class KeyFoldMixin(MapBase[K, V]):
     """
     A mixin for Mapping to allow for case-insensitive keys
     """
 
-    @classmethod
-    def get_class(cls) -> Type[MutableMapping[K, V]]:
-        raise NotImplementedError
-
     def __getitem__(self, item: K) -> V:
-        return self.get_class().__getitem__(
-            cast(Mapping[K, V], self), cast(K, item.casefold())
-        )
+        return super().__getitem__(cast(K, item.casefold()))
 
     def __setitem__(self, key: K, value: V) -> None:
-        return self.get_class().__setitem__(
-            cast(MutableMapping[K, V], self), cast(K, key.casefold()), value
-        )
+        return super().__setitem__(cast(K, key.casefold()), value)
 
     def __delitem__(self, key: K) -> None:
-        return self.get_class().__delitem__(
-            cast(MutableMapping[K, V], self), cast(K, key.casefold())
-        )
+        return super().__delitem__(cast(K, key.casefold()))
 
     def pop(self, key: K, *args) -> V:
         """
         Wraps `dict.pop`
         """
-        return self.get_class().pop(
-            cast(MutableMapping[K, V], self), cast(K, key.casefold()), *args
-        )
+        return super().pop(cast(K, key.casefold()), *args)
 
     def get(self, key: K, default=None):
         """
         Wrap `dict.get`
         """
-        return self.get_class().get(
-            cast(Mapping[K, V], self), cast(K, key.casefold()), default
-        )
+        return super().get(cast(K, key.casefold()), default)
 
     def setdefault(self, key: K, default=None):
         """
         Wrap `dict.setdefault`
         """
-        return self.get_class().setdefault(
-            cast(MutableMapping[K, V], self), cast(K, key.casefold()), default
-        )
+        return super().setdefault(cast(K, key.casefold()), default)
 
     def update(self, *args, **kwargs):
         """
@@ -84,26 +78,14 @@ class KeyFoldDict(KeyFoldMixin, dict):
     KeyFolded dict type
     """
 
-    @classmethod
-    def get_class(cls) -> Type[MutableMapping[K, V]]:
-        return dict
-
 
 class DefaultKeyFoldDict(KeyFoldMixin, defaultdict):
     """
     KeyFolded defaultdict
     """
 
-    @classmethod
-    def get_class(cls) -> Type[MutableMapping[K, V]]:
-        return defaultdict
-
 
 class KeyFoldWeakValueDict(KeyFoldMixin, weakref.WeakValueDictionary):
     """
     KeyFolded WeakValueDictionary
     """
-
-    @classmethod
-    def get_class(cls) -> Type[MutableMapping[K, V]]:
-        return weakref.WeakValueDictionary

requirements-dev.txt

@@ -1,6 +1,6 @@
 coverage == 6.1.2
 freezegun == 1.1.0
-mypy == 0.910
+mypy ~= 0.910
 pre-commit == 2.17.0
 pylint == 2.11.1
 pytest == 6.2.5

tests/plugin_tests/test_brew.py

@@ -1,3 +1,4 @@
+from typing import Any, Dict
 from unittest.mock import MagicMock
 
 import pytest
@@ -108,7 +109,7 @@ def test_results(
     if website:
         brewery["website"] = website
 
-    beer = {
+    beer: Dict[str, Any] = {
         "breweries": [
             brewery,
         ],

tests/util/mock_bot.py

@@ -22,11 +22,15 @@ def __init__(
     ):
         self.old_db = None
         self.do_db_migrate = False
+        self.loop = loop
         self.base_dir = base_dir
         self.data_path = self.base_dir / "data"
         self.data_dir = str(self.data_path)
         self.plugin_dir = self.base_dir / "plugins"
-        self.stopped_future: Awaitable[bool] = create_future()
+        if self.loop:
+            self.stopped_future: Awaitable[bool] = create_future(self.loop)
+        else:
+            self.stopped_future = None
 
         if db:
             self.db_engine = db.engine
@@ -35,7 +39,6 @@ def __init__(
 
         self.running = True
         self.logger = logging.getLogger("cloudbot")
-        self.loop = loop
         self.config = MockConfig(self)
 
         if config is not None: