WIP: provide typing default for optional typevar

CoderJoshDK · CoderJoshDK · commit 7ef84940acea · 2025-10-19T18:53:05.000-04:00
diff --git a/disnake/ext/commands/bot_base.py b/disnake/ext/commands/bot_base.py
@@ -10,7 +10,7 @@
 import traceback
 import warnings
 from collections.abc import Iterable
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union, cast
 
 import disnake
 from disnake.utils import iscoroutinefunction
@@ -26,6 +26,7 @@
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from disnake.ext.commands.bot import AutoShardedBot, Bot
     from disnake.message import Message
 
     from ._types import Check, CoroFunc, MaybeCoro
@@ -507,7 +508,9 @@ class be provided, it must be similar enough to :class:`.Context`\'s
             ``cls`` parameter.
         """
         view = StringView(message.content)
-        ctx = cls(prefix=None, view=view, bot=self, message=message)
+        ctx = cls(
+            prefix=None, view=view, bot=cast("Union[Bot, AutoShardedBot]", self), message=message
+        )
 
         if message.author.id == self.user.id:  # pyright: ignore[reportAttributeAccessIssue]
             return ctx
diff --git a/disnake/ext/commands/context.py b/disnake/ext/commands/context.py
@@ -32,13 +32,21 @@
 
 
 T = TypeVar("T")
-BotT = TypeVar("BotT", bound="Union[Bot, AutoShardedBot]")
 CogT = TypeVar("CogT", bound="Cog")
 
 if TYPE_CHECKING:
+    from typing_extensions import TypeVar  # noqa: TC004
+
     P = ParamSpec("P")
+    BotT = TypeVar(
+        "BotT",
+        bound="Union[Bot, AutoShardedBot]",
+        covariant=True,
+        default=Union[Bot, AutoShardedBot],
+    )
 else:
     P = TypeVar("P")
+    BotT = TypeVar("BotT", bound="Union[Bot, AutoShardedBot]")
 
 
 class Context(disnake.abc.Messageable, Generic[BotT]):
diff --git a/disnake/ext/commands/core.py b/disnake/ext/commands/core.py
@@ -97,25 +97,30 @@
 
 MISSING: Any = disnake.utils.MISSING
 
-T = TypeVar("T")
 VT = TypeVar("VT")
-CogT = TypeVar("CogT", bound="Optional[Cog]")
 CommandT = TypeVar("CommandT", bound="Command")
-ContextT = TypeVar("ContextT", bound="Context")
 GroupT = TypeVar("GroupT", bound="Group")
 HookT = TypeVar("HookT", bound="Hook")
 ErrorT = TypeVar("ErrorT", bound="Error")
 
 
 if TYPE_CHECKING:
-    P = ParamSpec("P")
+    from typing_extensions import TypeVar  # noqa: TC004
 
+    P = ParamSpec("P", default=...)
+    T = TypeVar("T", default=Any)
+
+    CogT = TypeVar("CogT", bound="Optional[Cog]", default="Optional[Cog]")
+    ContextT = TypeVar("ContextT", bound="Context", default="Context")
     CommandCallback = Union[
         Callable[Concatenate[CogT, ContextT, P], Coro[T]],
         Callable[Concatenate[ContextT, P], Coro[T]],
     ]
 else:
+    T = TypeVar("T")
     P = TypeVar("P")
+    CogT = TypeVar("CogT", bound="Optional[Cog]")
+    ContextT = TypeVar("ContextT", bound="Context")
 
 
 def wrap_callback(coro: Callable[..., Coro[T]]) -> Callable[..., Coro[Optional[T]]]:
@@ -1418,7 +1423,7 @@ def copy(self: GroupT) -> GroupT:
         """
         ret = super().copy()
         for cmd in self.commands:
-            ret.add_command(cmd.copy())
+            ret.add_command(cast("Command[CogT, Any, Any]", cmd.copy()))
         return ret
 
     async def invoke(self, ctx: Context) -> None:
diff --git a/disnake/ui/_types.py b/disnake/ui/_types.py
@@ -6,7 +6,10 @@
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing_extensions import (
+        TypeAlias,
+        TypeVar,  # noqa: TC004
+    )
 
     from . import (
         ActionRow,
@@ -24,7 +27,9 @@
     from .select import ChannelSelect, MentionableSelect, RoleSelect, StringSelect, UserSelect
     from .view import View
 
-V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True, default=Optional[View])
+else:
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
 
 AnySelect = Union[
     "ChannelSelect[V_co]",
diff --git a/disnake/ui/button.py b/disnake/ui/button.py
@@ -17,18 +17,23 @@
 )
 
 if TYPE_CHECKING:
-    from typing_extensions import ParamSpec, Self
+    from typing_extensions import (
+        ParamSpec,
+        Self,
+        TypeVar,  # noqa: TC004
+    )
 
     from ..emoji import Emoji
     from .item import ItemCallbackType
     from .view import View
 
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True, default=Optional[View])
 else:
     ParamSpec = TypeVar
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
 
 B = TypeVar("B", bound="Button")
 B_co = TypeVar("B_co", bound="Button", covariant=True)
-V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
 P = ParamSpec("P")
 
 
diff --git a/disnake/ui/item.py b/disnake/ui/item.py
@@ -22,11 +22,12 @@
     "Item",
 )
 
-I = TypeVar("I", bound="Item[Any]")  # noqa: E741
-V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
 
 if TYPE_CHECKING:
-    from typing_extensions import Self
+    from typing_extensions import (
+        Self,
+        TypeVar,  # noqa: TC004
+    )
 
     from ..client import Client
     from ..components import ActionRowChildComponent, Component
@@ -35,8 +36,18 @@
     from ..types.components import ActionRowChildComponent as ActionRowChildComponentPayload
     from .view import View
 
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True, default=Optional[View])
+    I = TypeVar("I", bound="Item[Any]", default="Item[Any]")  # noqa: E741
     ItemCallbackType = Callable[[V_co, I, MessageInteraction], Coroutine[Any, Any, Any]]
 
+    SelfViewT = TypeVar("SelfViewT", bound="Optional[View]", default=Optional[View])
+else:
+    I = TypeVar("I", bound="Item[Any]")  # noqa: E741
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
+
+    SelfViewT = TypeVar("SelfViewT", bound="Optional[View]")
+
+
 ClientT = TypeVar("ClientT", bound="Client")
 UIComponentT = TypeVar("UIComponentT", bound="UIComponent")
 
@@ -217,9 +228,6 @@ async def callback(self, interaction: MessageInteraction[ClientT], /) -> None:
         pass
 
 
-SelfViewT = TypeVar("SelfViewT", bound="Optional[View]")
-
-
 # While the decorators don't actually return a descriptor that matches this protocol,
 # this protocol ensures that type checkers don't complain about statements like `self.button.disabled = True`,
 # which work as `View.__init__` replaces the handler with the item.
diff --git a/disnake/ui/select/base.py b/disnake/ui/select/base.py
@@ -24,19 +24,24 @@
 __all__ = ("BaseSelect",)
 
 if TYPE_CHECKING:
-    from typing_extensions import ParamSpec, Self
+    from typing_extensions import (
+        ParamSpec,
+        Self,
+        TypeVar,  # noqa: TC004
+    )
 
     from ...abc import Snowflake
     from ...interactions import MessageInteraction
     from ..item import ItemCallbackType
     from ..view import View
 
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True, default=Optional[View])
 else:
     ParamSpec = TypeVar
+    V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
 
 
 S_co = TypeVar("S_co", bound="BaseSelect", covariant=True)
-V_co = TypeVar("V_co", bound="Optional[View]", covariant=True)
 SelectMenuT = TypeVar("SelectMenuT", bound=AnySelectMenu)
 SelectValueT = TypeVar("SelectValueT")
 P = ParamSpec("P")
diff --git a/disnake/ui/view.py b/disnake/ui/view.py
@@ -11,7 +11,14 @@
 from collections.abc import Sequence
 from functools import partial
 from itertools import groupby
-from typing import TYPE_CHECKING, Callable, ClassVar, Optional
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    ClassVar,
+    Generic,
+    Optional,
+    TypeVar,
+)
 
 from ..components import (
     VALID_ACTION_ROW_MESSAGE_COMPONENT_TYPES,
@@ -38,37 +45,39 @@
     from .item import ItemCallbackType
 
 
+V_co = TypeVar("V_co", bound="View", covariant=True)
+
 _log = logging.getLogger(__name__)
 
 
-def _component_to_item(component: ActionRowMessageComponent) -> Item:
+def _component_to_item(component: ActionRowMessageComponent) -> Item[V_co]:
     if item := _message_component_to_item(component):
         return item
     else:
-        return Item.from_component(component)
+        return Item[V_co].from_component(component)
 
 
-class _ViewWeights:
+class _ViewWeights(Generic[V_co]):
     __slots__ = ("weights",)
 
-    def __init__(self, children: list[Item]) -> None:
+    def __init__(self, children: list[Item[V_co]]) -> None:
         self.weights: list[int] = [0, 0, 0, 0, 0]
 
-        key: Callable[[Item[View]], int] = lambda i: sys.maxsize if i.row is None else i.row
+        key: Callable[[Item[V_co]], int] = lambda i: sys.maxsize if i.row is None else i.row
         children = sorted(children, key=key)
         for _, group in groupby(children, key=key):
             for item in group:
                 self.add_item(item)
 
-    def find_open_space(self, item: Item) -> int:
+    def find_open_space(self, item: Item[V_co]) -> int:
         for index, weight in enumerate(self.weights):
             if weight + item.width <= 5:
                 return index
 
         msg = "could not find open space for item"
         raise ValueError(msg)
 
-    def add_item(self, item: Item) -> None:
+    def add_item(self, item: Item[V_co]) -> None:
         if item.row is not None:
             total = self.weights[item.row] + item.width
             if total > 5:
@@ -81,7 +90,7 @@ def add_item(self, item: Item) -> None:
             self.weights[index] += item.width
             item._rendered_row = index
 
-    def remove_item(self, item: Item) -> None:
+    def remove_item(self, item: Item[V_co]) -> None:
         if item._rendered_row is not None:
             self.weights[item._rendered_row] -= item.width
             item._rendered_row = None
@@ -142,7 +151,7 @@ def __init__(self, *, timeout: Optional[float] = 180.0) -> None:
             setattr(self, func.__name__, item)
             self.children.append(item)
 
-        self.__weights = _ViewWeights(self.children)
+        self.__weights: _ViewWeights = _ViewWeights(self.children)
         loop = asyncio.get_running_loop()
         self.id: str = os.urandom(16).hex()
         self.__cancel_callback: Optional[Callable[[View], None]] = None
@@ -173,7 +182,7 @@ async def __timeout_task_impl(self) -> None:
             await asyncio.sleep(self.__timeout_expiry - now)
 
     def to_components(self) -> list[ActionRowPayload]:
-        def key(item: Item[View]) -> int:
+        def key(item: Item[Self]) -> int:
             return item._rendered_row or 0
 
         children = sorted(self.children, key=key)
@@ -239,7 +248,7 @@ def _expires_at(self) -> Optional[float]:
             return time.monotonic() + self.timeout
         return None
 
-    def add_item(self, item: Item) -> Self:
+    def add_item(self, item: Item[Self]) -> Self:
         """Adds an item to the view.
 
         This function returns the class instance to allow for fluent-style
@@ -272,7 +281,7 @@ def add_item(self, item: Item) -> Self:
         self.children.append(item)
         return self
 
-    def remove_item(self, item: Item) -> Self:
+    def remove_item(self, item: Item[Self]) -> Self:
         """Removes an item from the view.
 
         This function returns the class instance to allow for fluent-style
@@ -336,7 +345,9 @@ async def on_timeout(self) -> None:
         """
         pass
 
-    async def on_error(self, error: Exception, item: Item, interaction: MessageInteraction) -> None:
+    async def on_error(
+        self, error: Exception, item: Item[Self], interaction: MessageInteraction
+    ) -> None:
         """|coro|
 
         A callback that is called when an item's callback or :meth:`interaction_check`
@@ -356,7 +367,7 @@ async def on_error(self, error: Exception, item: Item, interaction: MessageInter
         print(f"Ignoring exception in view {self} for item {item}:", file=sys.stderr)
         traceback.print_exception(error.__class__, error, error.__traceback__, file=sys.stderr)
 
-    async def _scheduled_task(self, item: Item, interaction: MessageInteraction) -> None:
+    async def _scheduled_task(self, item: Item[Self], interaction: MessageInteraction) -> None:
         try:
             if self.timeout:
                 self.__timeout_expiry = time.monotonic() + self.timeout
@@ -386,7 +397,7 @@ def _dispatch_timeout(self) -> None:
         self.__stopped.set_result(True)
         asyncio.create_task(self.on_timeout(), name=f"disnake-ui-view-timeout-{self.id}")
 
-    def _dispatch_item(self, item: Item, interaction: MessageInteraction) -> None:
+    def _dispatch_item(self, item: Item[Self], interaction: MessageInteraction) -> None:
         if self.__stopped.done():
             return
 
@@ -396,15 +407,15 @@ def _dispatch_item(self, item: Item, interaction: MessageInteraction) -> None:
 
     def refresh(self, components: list[ActionRowComponent[ActionRowMessageComponent]]) -> None:
         # TODO: this is pretty hacky at the moment, see https://github.com/DisnakeDev/disnake/commit/9384a72acb8c515b13a600592121357e165368da
-        old_state: dict[tuple[int, str], Item] = {
+        old_state: dict[tuple[int, str], Item[Self]] = {
             (item.type.value, item.custom_id): item  # pyright: ignore[reportAttributeAccessIssue]
             for item in self.children
             if item.is_dispatchable()
         }
 
-        children: list[Item] = []
+        children: list[Item[Self]] = []
         for component in (c for row in components for c in row.children):
-            older: Optional[Item] = None
+            older: Optional[Item[Self]] = None
             try:
                 older = old_state[component.type.value, component.custom_id]  # pyright: ignore[reportArgumentType]
             except (KeyError, AttributeError):
@@ -490,7 +501,7 @@ async def wait(self) -> bool:
 class ViewStore:
     def __init__(self, state: ConnectionState) -> None:
         # (component_type, message_id, custom_id): (View, Item)
-        self._views: dict[tuple[int, Optional[int], str], tuple[View, Item]] = {}
+        self._views: dict[tuple[int, int | None, str], tuple[View, Item[View]]] = {}
         # message_id: View
         self._synced_message_views: dict[int, View] = {}
         self._state: ConnectionState = state
