feat: preliminary support for python 3.14 (#1337)

Co-authored-by: vi <8530778+shiftinv@users.noreply.github.com>

Author: onerandomusername

.github/workflows/lint-test.yml

@@ -110,6 +110,7 @@ jobs:
       - lint
     strategy:
       matrix:
+        # TODO: add 3.14 once we switch to uv
         python-version: ${{ fromJson(needs.python-versions.outputs.pyright) }}
         experimental: [false]
       fail-fast: false
@@ -241,6 +242,7 @@ jobs:
     strategy:
       matrix:
         os: ["windows-latest", "ubuntu-latest", "macos-latest"]
+        # TODO: add 3.14 once we switch to uv
         python-version: ${{ fromJson(needs.python-versions.outputs.tests) }}
         experimental: [false]
       fail-fast: true

changelog/1337.feature.rst

@@ -0,0 +1 @@
+Add preliminary support for Python 3.14.

disnake/client.py

@@ -8,7 +8,6 @@
 import sys
 import traceback
 import types
-import warnings
 from datetime import datetime, timedelta
 from errno import ECONNRESET
 from typing import (
@@ -240,8 +239,8 @@ class Client:
             Allow disabling the message cache and change the default size to ``1000``.
     loop: Optional[:class:`asyncio.AbstractEventLoop`]
         The :class:`asyncio.AbstractEventLoop` to use for asynchronous operations.
-        Defaults to ``None``, in which case the default event loop is used via
-        :func:`asyncio.get_event_loop()`.
+        Defaults to ``None``, in which case the current event loop is
+        used, or a new loop is created if there is none.
     asyncio_debug: :class:`bool`
         Whether to enable asyncio debugging when the client starts.
         Defaults to False.
@@ -407,9 +406,7 @@ def __init__(
         self.ws: DiscordWebSocket = None  # type: ignore
 
         if loop is None:
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", DeprecationWarning)
-                self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
+            self.loop: asyncio.AbstractEventLoop = utils.get_event_loop()
         else:
             self.loop: asyncio.AbstractEventLoop = loop
 
@@ -840,7 +837,7 @@ async def another_message(message): pass
             else (name if isinstance(name, str) else f"on_{name.value}")
         )
 
-        if not asyncio.iscoroutinefunction(func):
+        if not utils.iscoroutinefunction(func):
             raise TypeError("Listeners must be coroutines")
 
         if name_ in self.extra_events:
@@ -1866,7 +1863,7 @@ async def on_ready():
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not utils.iscoroutinefunction(coro):
             raise TypeError("event registered must be a coroutine function")
 
         setattr(self, coro.__name__, coro)

disnake/ext/commands/base_core.py

@@ -24,7 +24,13 @@
 from disnake.enums import ApplicationCommandType
 from disnake.flags import ApplicationInstallTypes, InteractionContextTypes
 from disnake.permissions import Permissions
-from disnake.utils import _generated, _overload_with_permissions, async_all, maybe_coroutine
+from disnake.utils import (
+    _generated,
+    _overload_with_permissions,
+    async_all,
+    iscoroutinefunction,
+    maybe_coroutine,
+)
 
 from .cooldowns import BucketType, CooldownMapping, MaxConcurrency
 from .errors import CheckFailure, CommandError, CommandInvokeError, CommandOnCooldown
@@ -481,7 +487,7 @@ def error(self, coro: ErrorT) -> ErrorT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The error handler must be a coroutine.")
 
         self.on_error: Error = coro
@@ -597,7 +603,7 @@ def before_invoke(self, coro: HookT) -> HookT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The pre-invoke hook must be a coroutine.")
 
         self._before_invoke = coro
@@ -620,7 +626,7 @@ def after_invoke(self, coro: HookT) -> HookT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The post-invoke hook must be a coroutine.")
 
         self._after_invoke = coro

disnake/ext/commands/bot_base.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import collections
 import collections.abc
 import inspect
@@ -13,6 +12,7 @@
 from typing import TYPE_CHECKING, Any, Callable, Iterable, List, Optional, Type, TypeVar, Union
 
 import disnake
+from disnake.utils import iscoroutinefunction
 
 from . import errors
 from .common_bot_base import CommonBotBase
@@ -355,7 +355,7 @@ def before_invoke(self, coro: CFT) -> CFT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The pre-invoke hook must be a coroutine.")
 
         self._before_invoke = coro
@@ -390,7 +390,7 @@ def after_invoke(self, coro: CFT) -> CFT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The post-invoke hook must be a coroutine.")
 
         self._after_invoke = coro

disnake/ext/commands/cog.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import inspect
 import logging
 from typing import (
@@ -193,7 +192,7 @@ def __new__(cls: Type[CogMeta], *args: Any, **kwargs: Any) -> CogMeta:
                     if elem.startswith(("cog_", "bot_")):
                         raise TypeError(no_bot_cog.format(base, elem))
                     app_commands[elem] = value
-                elif asyncio.iscoroutinefunction(value):
+                elif disnake.utils.iscoroutinefunction(value):
                     if hasattr(value, "__cog_listener__"):
                         if elem.startswith(("cog_", "bot_")):
                             raise TypeError(no_bot_cog.format(base, elem))
@@ -419,7 +418,7 @@ def decorator(func: FuncT) -> FuncT:
             actual = func
             if isinstance(actual, staticmethod):
                 actual = actual.__func__
-            if not asyncio.iscoroutinefunction(actual):
+            if not disnake.utils.iscoroutinefunction(actual):
                 raise TypeError("Listener function must be a coroutine function.")
             actual.__cog_listener__ = True
             to_assign = (

disnake/ext/commands/core.py

@@ -31,6 +31,7 @@
     _generated,
     _overload_with_permissions,
     get_signature_parameters,
+    iscoroutinefunction,
     unwrap_function,
 )
 
@@ -278,7 +279,7 @@ def __init__(
         func: CommandCallback[CogT, ContextT, P, T],
         **kwargs: Any,
     ) -> None:
-        if not asyncio.iscoroutinefunction(func):
+        if not iscoroutinefunction(func):
             raise TypeError("Callback must be a coroutine.")
 
         name = kwargs.get("name") or func.__name__
@@ -508,9 +509,8 @@ async def dispatch_error(self, ctx: Context, error: Exception) -> None:
                     stop_propagation = await wrapped(ctx, error)
                     # User has an option to cancel the global error handler by returning True
         finally:
-            if stop_propagation:
-                return  # noqa: B012
-            ctx.bot.dispatch("command_error", ctx, error)
+            if not stop_propagation:
+                ctx.bot.dispatch("command_error", ctx, error)
 
     async def transform(self, ctx: Context, param: inspect.Parameter) -> Any:
         required = param.default is param.empty
@@ -886,7 +886,7 @@ def error(self, coro: ErrorT) -> ErrorT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The error handler must be a coroutine.")
 
         self.on_error: Error = coro
@@ -922,7 +922,7 @@ def before_invoke(self, coro: HookT) -> HookT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The pre-invoke hook must be a coroutine.")
 
         self._before_invoke = coro
@@ -949,7 +949,7 @@ def after_invoke(self, coro: HookT) -> HookT:
         TypeError
             The coroutine passed is not actually a coroutine.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The post-invoke hook must be a coroutine.")
 
         self._after_invoke = coro
@@ -1702,7 +1702,7 @@ def decorator(func: Union[Command, CoroFunc]) -> Union[Command, CoroFunc]:
 
         return func
 
-    if asyncio.iscoroutinefunction(predicate):
+    if iscoroutinefunction(predicate):
         decorator.predicate = predicate
     else:
 

disnake/ext/commands/ctx_menus_core.py

@@ -2,13 +2,13 @@
 
 from __future__ import annotations
 
-import asyncio
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Sequence, Tuple, Union
 
 from disnake.app_commands import MessageCommand, UserCommand
 from disnake.flags import ApplicationInstallTypes, InteractionContextTypes
 from disnake.i18n import Localized
 from disnake.permissions import Permissions
+from disnake.utils import iscoroutinefunction
 
 from .base_core import InvokableApplicationCommand, _get_overridden_method
 from .errors import CommandError
@@ -124,9 +124,8 @@ async def _call_external_error_handlers(
                     stop_propagation = await local(inter, error)
                     # User has an option to cancel the global error handler by returning True
         finally:
-            if stop_propagation:
-                return  # noqa: B012
-            inter.bot.dispatch("user_command_error", inter, error)
+            if not stop_propagation:
+                inter.bot.dispatch("user_command_error", inter, error)
 
     async def __call__(
         self,
@@ -236,9 +235,8 @@ async def _call_external_error_handlers(
                     stop_propagation = await local(inter, error)
                     # User has an option to cancel the global error handler by returning True
         finally:
-            if stop_propagation:
-                return  # noqa: B012
-            inter.bot.dispatch("message_command_error", inter, error)
+            if not stop_propagation:
+                inter.bot.dispatch("message_command_error", inter, error)
 
     async def __call__(
         self,
@@ -337,7 +335,7 @@ def user_command(
     def decorator(
         func: InteractionCommandCallback[CogT, UserCommandInteraction, P],
     ) -> InvokableUserCommand:
-        if not asyncio.iscoroutinefunction(func):
+        if not iscoroutinefunction(func):
             raise TypeError(f"<{func.__qualname__}> must be a coroutine function")
         if hasattr(func, "__command_flag__"):
             raise TypeError("Callback is already a command.")
@@ -445,7 +443,7 @@ def message_command(
     def decorator(
         func: InteractionCommandCallback[CogT, MessageCommandInteraction, P],
     ) -> InvokableMessageCommand:
-        if not asyncio.iscoroutinefunction(func):
+        if not iscoroutinefunction(func):
             raise TypeError(f"<{func.__qualname__}> must be a coroutine function")
         if hasattr(func, "__command_flag__"):
             raise TypeError("Callback is already a command.")

disnake/ext/commands/interaction_bot_base.py

@@ -29,7 +29,7 @@
 from disnake.custom_warnings import SyncWarning
 from disnake.enums import ApplicationCommandType
 from disnake.flags import ApplicationInstallTypes, InteractionContextTypes
-from disnake.utils import warn_deprecated
+from disnake.utils import iscoroutinefunction, warn_deprecated
 
 from . import errors
 from .base_core import InvokableApplicationCommand
@@ -1300,7 +1300,7 @@ def before_slash_command_invoke(self, coro: CFT) -> CFT:
         """Similar to :meth:`Bot.before_invoke` but for slash commands,
         and it takes an :class:`.ApplicationCommandInteraction` as its only parameter.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The pre-invoke hook must be a coroutine.")
 
         self._before_slash_command_invoke = coro
@@ -1310,39 +1310,39 @@ def after_slash_command_invoke(self, coro: CFT) -> CFT:
         """Similar to :meth:`Bot.after_invoke` but for slash commands,
         and it takes an :class:`.ApplicationCommandInteraction` as its only parameter.
         """
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The post-invoke hook must be a coroutine.")
 
         self._after_slash_command_invoke = coro
         return coro
 
     def before_user_command_invoke(self, coro: CFT) -> CFT:
         """Similar to :meth:`Bot.before_slash_command_invoke` but for user commands."""
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The pre-invoke hook must be a coroutine.")
 
         self._before_user_command_invoke = coro
         return coro
 
     def after_user_command_invoke(self, coro: CFT) -> CFT:
         """Similar to :meth:`Bot.after_slash_command_invoke` but for user commands."""
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The post-invoke hook must be a coroutine.")
 
         self._after_user_command_invoke = coro
         return coro
 
     def before_message_command_invoke(self, coro: CFT) -> CFT:
         """Similar to :meth:`Bot.before_slash_command_invoke` but for message commands."""
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The pre-invoke hook must be a coroutine.")
 
         self._before_message_command_invoke = coro
         return coro
 
     def after_message_command_invoke(self, coro: CFT) -> CFT:
         """Similar to :meth:`Bot.after_slash_command_invoke` but for message commands."""
-        if not asyncio.iscoroutinefunction(coro):
+        if not iscoroutinefunction(coro):
             raise TypeError("The post-invoke hook must be a coroutine.")
 
         self._after_message_command_invoke = coro

disnake/ext/commands/slash_core.py

@@ -677,9 +677,8 @@ async def _call_external_error_handlers(
                     stop_propagation = await local(inter, error)
                     # User has an option to cancel the global error handler by returning True
         finally:
-            if stop_propagation:
-                return  # noqa: B012
-            inter.bot.dispatch("slash_command_error", inter, error)
+            if not stop_propagation:
+                inter.bot.dispatch("slash_command_error", inter, error)
 
     async def _call_autocompleter(
         self, param: str, inter: ApplicationCommandInteraction, user_input: str
@@ -871,7 +870,7 @@ def slash_command(
     """
 
     def decorator(func: CommandCallback) -> InvokableSlashCommand:
-        if not asyncio.iscoroutinefunction(func):
+        if not utils.iscoroutinefunction(func):
             raise TypeError(f"<{func.__qualname__}> must be a coroutine function")
         if hasattr(func, "__command_flag__"):
             raise TypeError("Callback is already a command.")