♻️ move cached_slot_property to private

Author: Paillat-dev

discord/interactions.py

@@ -29,7 +29,7 @@
 import datetime
 from typing import TYPE_CHECKING, Any, Coroutine, Union
 
-from .utils.private import get_as_snowflake, deprecated, delay_task
+from .utils.private import get_as_snowflake, deprecated, delay_task, cached_slot_property
 from . import utils
 from .channel import ChannelType, PartialMessageable, _threaded_channel_factory
 from .enums import (
@@ -297,7 +297,7 @@ def is_component(self) -> bool:
         """Indicates whether the interaction is a message component."""
         return self.type == InteractionType.component
 
-    @utils.cached_slot_property("_cs_channel")
+    @cached_slot_property("_cs_channel")
     @deprecated("Interaction.channel", "2.7", stacklevel=4)
     def cached_channel(self) -> InteractionChannel | None:
         """The cached channel from which the interaction was sent.
@@ -322,12 +322,12 @@ def permissions(self) -> Permissions:
         """
         return Permissions(self._permissions)
 
-    @utils.cached_slot_property("_cs_app_permissions")
+    @cached_slot_property("_cs_app_permissions")
     def app_permissions(self) -> Permissions:
         """The resolved permissions of the application in the channel, including overwrites."""
         return Permissions(self._app_permissions)
 
-    @utils.cached_slot_property("_cs_response")
+    @cached_slot_property("_cs_response")
     def response(self) -> InteractionResponse:
         """Returns an object responsible for handling responding to the interaction.
 
@@ -336,7 +336,7 @@ def response(self) -> InteractionResponse:
         """
         return InteractionResponse(self)
 
-    @utils.cached_slot_property("_cs_followup")
+    @cached_slot_property("_cs_followup")
     def followup(self) -> Webhook:
         """Returns the followup webhook for followup interactions."""
         payload = {
@@ -1542,7 +1542,7 @@ def __init__(self, *, data: InteractionMetadataPayload, state: ConnectionState):
     def __repr__(self):
         return f"<InteractionMetadata id={self.id} type={self.type!r} user={self.user!r}>"
 
-    @utils.cached_slot_property("_cs_original_response_message")
+    @cached_slot_property("_cs_original_response_message")
     def original_response_message(self) -> Message | None:
         """Optional[:class:`Message`]: The original response message.
         Returns ``None`` if the message is not in cache, or if :attr:`original_response_message_id` is ``None``.
@@ -1551,7 +1551,7 @@ def original_response_message(self) -> Message | None:
             return None
         return self._state._get_message(self.original_response_message_id)
 
-    @utils.cached_slot_property("_cs_interacted_message")
+    @cached_slot_property("_cs_interacted_message")
     def interacted_message(self) -> Message | None:
         """Optional[:class:`Message`]: The message that triggered the interaction.
         Returns ``None`` if the message is not in cache, or if :attr:`interacted_message_id` is ``None``.
@@ -1597,7 +1597,7 @@ def __eq__(self, other):
     def __ne__(self, other):
         return not self.__eq__(other)
 
-    @utils.cached_slot_property("_cs_user")
+    @cached_slot_property("_cs_user")
     def user(self) -> User | None:
         """Optional[:class:`User`]: The user that authorized the integration.
         Returns ``None`` if the user is not in cache, or if :attr:`user_id` is ``None``.
@@ -1606,7 +1606,7 @@ def user(self) -> User | None:
             return None
         return self._state.get_user(self.user_id)
 
-    @utils.cached_slot_property("_cs_guild")
+    @cached_slot_property("_cs_guild")
     def guild(self) -> Guild | None:
         """Optional[:class:`Guild`]: The guild that authorized the integration.
         Returns ``None`` if the guild is not in cache, or if :attr:`guild_id` is ``0`` or ``None``.

discord/message.py

@@ -41,7 +41,7 @@
 )
 from urllib.parse import parse_qs, urlparse
 
-from .utils.private import get_as_snowflake, parse_time, warn_deprecated, delay_task
+from .utils.private import get_as_snowflake, parse_time, warn_deprecated, delay_task, cached_slot_property
 from . import utils
 from .channel import PartialMessageable
 from .components import _component_factory
@@ -1263,7 +1263,7 @@ def interaction(self, value: MessageInteraction | None) -> None:
         )
         self._interaction = value
 
-    @utils.cached_slot_property("_cs_raw_mentions")
+    @cached_slot_property("_cs_raw_mentions")
     def raw_mentions(self) -> list[int]:
         """A property that returns an array of user IDs matched with
         the syntax of ``<@user_id>`` in the message content.
@@ -1273,28 +1273,28 @@ def raw_mentions(self) -> list[int]:
         """
         return [int(x) for x in re.findall(r"<@!?([0-9]{15,20})>", self.content)]
 
-    @utils.cached_slot_property("_cs_raw_channel_mentions")
+    @cached_slot_property("_cs_raw_channel_mentions")
     def raw_channel_mentions(self) -> list[int]:
         """A property that returns an array of channel IDs matched with
         the syntax of ``<#channel_id>`` in the message content.
         """
         return [int(x) for x in re.findall(r"<#([0-9]{15,20})>", self.content)]
 
-    @utils.cached_slot_property("_cs_raw_role_mentions")
+    @cached_slot_property("_cs_raw_role_mentions")
     def raw_role_mentions(self) -> list[int]:
         """A property that returns an array of role IDs matched with
         the syntax of ``<@&role_id>`` in the message content.
         """
         return [int(x) for x in re.findall(r"<@&([0-9]{15,20})>", self.content)]
 
-    @utils.cached_slot_property("_cs_channel_mentions")
+    @cached_slot_property("_cs_channel_mentions")
     def channel_mentions(self) -> list[GuildChannel]:
         if self.guild is None:
             return []
         it = filter(None, map(self.guild.get_channel, self.raw_channel_mentions))
         return list(dict.fromkeys(it))  # using dict.fromkeys and not set to preserve order
 
-    @utils.cached_slot_property("_cs_clean_content")
+    @cached_slot_property("_cs_clean_content")
     def clean_content(self) -> str:
         """A property that returns the content in a "cleaned up"
         manner. This basically means that mentions are transformed
@@ -1371,7 +1371,7 @@ def is_system(self) -> bool:
             MessageType.thread_starter_message,
         )
 
-    @utils.cached_slot_property("_cs_system_content")
+    @cached_slot_property("_cs_system_content")
     def system_content(self) -> str:
         r"""A property that returns the content that is rendered
         regardless of the :attr:`Message.type`.
@@ -2185,7 +2185,7 @@ def created_at(self) -> datetime.datetime:
     def poll(self) -> Poll | None:
         return self._state._polls.get(self.id)
 
-    @utils.cached_slot_property("_cs_guild")
+    @cached_slot_property("_cs_guild")
     def guild(self) -> Guild | None:
         """The guild that the partial message belongs to, if applicable."""
         return getattr(self.channel, "guild", None)

discord/stage_instance.py

@@ -30,7 +30,8 @@
 from .enums import StagePrivacyLevel, try_enum
 from .errors import InvalidArgument
 from .mixins import Hashable
-from .utils import MISSING, Undefined, cached_slot_property
+from .utils import MISSING, Undefined
+from .utils.private import cached_slot_property
 
 __all__ = ("StageInstance",)
 

discord/sticker.py

@@ -32,7 +32,8 @@
 from .enums import StickerFormatType, StickerType, try_enum
 from .errors import InvalidData
 from .mixins import Hashable
-from .utils import MISSING, Undefined, cached_slot_property, find, snowflake_time
+from .utils import MISSING, Undefined, find, snowflake_time
+from .utils.private import cached_slot_property
 
 __all__ = (
     "StickerPack",

discord/utils/__init__.py

@@ -30,14 +30,11 @@
     TYPE_CHECKING,
     Any,
     AsyncIterator,
-    Callable,
-    Generic,
     Iterator,
     Mapping,
     Protocol,
     TypeVar,
     Union,
-    overload,
 )
 
 from ..errors import HTTPException
@@ -126,50 +123,6 @@ class _RequestLike(Protocol):
 _Iter = Union[Iterator[T], AsyncIterator[T]]
 
 
-class CachedSlotProperty(Generic[T, T_co]):
-    def __init__(self, name: str, function: Callable[[T], T_co]) -> None:
-        self.name = name
-        self.function = function
-        self.__doc__ = getattr(function, "__doc__")
-
-    @overload
-    def __get__(self, instance: None, owner: type[T]) -> CachedSlotProperty[T, T_co]: ...
-
-    @overload
-    def __get__(self, instance: T, owner: type[T]) -> T_co: ...
-
-    def __get__(self, instance: T | None, owner: type[T]) -> Any:
-        if instance is None:
-            return self
-
-        try:
-            return getattr(instance, self.name)
-        except AttributeError:
-            value = self.function(instance)
-            setattr(instance, self.name, value)
-            return value
-
-
-class classproperty(Generic[T_co]):
-    def __init__(self, fget: Callable[[Any], T_co]) -> None:
-        self.fget = fget
-
-    def __get__(self, instance: Any | None, owner: type[Any]) -> T_co:
-        return self.fget(owner)
-
-    def __set__(self, instance, value) -> None:
-        raise AttributeError("cannot set attribute")
-
-
-def cached_slot_property(
-    name: str,
-) -> Callable[[Callable[[T], T_co]], CachedSlotProperty[T, T_co]]:
-    def decorator(func: Callable[[T], T_co]) -> CachedSlotProperty[T, T_co]:
-        return CachedSlotProperty(name, func)
-
-    return decorator
-
-
 async def get_or_fetch(obj, attr: str, id: int, *, default: Any = MISSING) -> Any:
     """|coro|
 

discord/utils/private.py

@@ -32,7 +32,6 @@
     Iterator,
 )
 
-from . import T_co
 from ..errors import InvalidArgument, HTTPException
 
 if TYPE_CHECKING:
@@ -43,6 +42,7 @@
 
 P = ParamSpec("P")
 T = TypeVar("T")
+T_co = TypeVar("T_co", covariant=True)
 
 
 def resolve_invite(invite: Invite | str) -> str:
@@ -489,3 +489,36 @@ def index(self, value: Any, *args, **kwargs) -> int:
 
     def count(self, value: Any) -> int:
         return self.__proxied.count(value)
+
+
+class CachedSlotProperty(Generic[T, T_co]):
+    def __init__(self, name: str, function: Callable[[T], T_co]) -> None:
+        self.name = name
+        self.function = function
+        self.__doc__ = getattr(function, "__doc__")
+
+    @overload
+    def __get__(self, instance: None, owner: type[T]) -> CachedSlotProperty[T, T_co]: ...
+
+    @overload
+    def __get__(self, instance: T, owner: type[T]) -> T_co: ...
+
+    def __get__(self, instance: T | None, owner: type[T]) -> Any:
+        if instance is None:
+            return self
+
+        try:
+            return getattr(instance, self.name)
+        except AttributeError:
+            value = self.function(instance)
+            setattr(instance, self.name, value)
+            return value
+
+
+def cached_slot_property(
+    name: str,
+) -> Callable[[Callable[[T], T_co]], CachedSlotProperty[T, T_co]]:
+    def decorator(func: Callable[[T], T_co]) -> CachedSlotProperty[T, T_co]:
+        return CachedSlotProperty(name, func)
+
+    return decorator