feat: subscriptions & related changes

CHANGELOG.md

@@ -22,6 +22,8 @@ These changes are available on the `master` branch, but have not yet been releas
   `tags`. ([#2520](https://github.com/Pycord-Development/pycord/pull/2520))
 - Added `Member.guild_banner` and `Member.display_banner` properties.
   ([#2556](https://github.com/Pycord-Development/pycord/pull/2556))
+- Added new `Subscription` object and related methods/events.
+  ([#2564](https://github.com/Pycord-Development/pycord/pull/2564))
 
 ### Fixed
 
@@ -39,12 +41,19 @@ These changes are available on the `master` branch, but have not yet been releas
   ([#2496](https://github.com/Pycord-Development/pycord/pull/2496))
 - ⚠️ **Removed support for Python 3.8.**
   ([#2521](https://github.com/Pycord-Development/pycord/pull/2521))
+- `Entitlement.ends_at` can now be `None`.
+  ([#2564](https://github.com/Pycord-Development/pycord/pull/2564))
 
 ### Deprecated
 
 - Deprecated `AppInfo.summary` in favor of `AppInfo.description`.
   ([#2520](https://github.com/Pycord-Development/pycord/pull/2520))
 
+### Fixed
+
+- Fixed `AttributeError` when trying to consume a consumable entitlement.
+  ([#2564](https://github.com/Pycord-Development/pycord/pull/2564))
+
 ## [2.6.1] - 2024-09-15
 
 ### Fixed

discord/client.py

@@ -2048,7 +2048,7 @@ async def fetch_skus(self) -> list[SKU]:
             The bot's SKUs.
         """
         data = await self._connection.http.list_skus(self.application_id)
-        return [SKU(data=s) for s in data]
+        return [SKU(state=self._connection, data=s) for s in data]
 
     def entitlements(
         self,

discord/enums.py

@@ -1053,6 +1053,14 @@ class PollLayoutType(Enum):
     default = 1
 
 
+class SubscriptionStatus(Enum):
+    """The status of a subscription."""
+
+    active = 0
+    ending = 1
+    inactive = 2
+
+
 T = TypeVar("T")
 
 

discord/http.py

@@ -3000,6 +3000,43 @@ def delete_test_entitlement(
         )
         return self.request(r)
 
+    def list_sku_subscriptions(
+        self,
+        sku_id: Snowflake,
+        *,
+        before: Snowflake | None = None,
+        after: Snowflake | None = None,
+        limit: int = 50,
+        user_id: Snowflake | None = None,
+    ) -> Response[list[monetization.Subscription]]:
+        params: dict[str, Any] = {}
+        if before is not None:
+            params["before"] = before
+        if after is not None:
+            params["after"] = after
+        if limit is not None:
+            params["limit"] = limit
+        if user_id is not None:
+            params["user_id"] = user_id
+        return self.request(
+            Route("GET", "/skus/{sku_id}/subscriptions", sku_id=sku_id),
+            params=params,
+        )
+
+    def get_subscription(
+        self,
+        sku_id: Snowflake,
+        subscription_id: Snowflake,
+    ) -> Response[monetization.Subscription]:
+        return self.request(
+            Route(
+                "GET",
+                "/skus/{sku_id}/subscriptions/{subscription_id}",
+                sku_id=sku_id,
+                subscription_id=subscription_id,
+            )
+        )
+
     # Onboarding
 
     def get_onboarding(self, guild_id: Snowflake) -> Response[onboarding.Onboarding]:

discord/iterators.py

@@ -40,7 +40,6 @@
 
 from .audit_logs import AuditLogEntry
 from .errors import NoMoreItems
-from .monetization import Entitlement
 from .object import Object
 from .utils import maybe_coroutine, snowflake_time, time_snowflake
 
@@ -52,19 +51,22 @@
     "MemberIterator",
     "ScheduledEventSubscribersIterator",
     "EntitlementIterator",
+    "SubscriptionIterator",
 )
 
 if TYPE_CHECKING:
     from .abc import Snowflake
     from .guild import BanEntry, Guild
     from .member import Member
     from .message import Message
+    from .monetization import Entitlement, Subscription
     from .scheduled_events import ScheduledEvent
     from .threads import Thread
     from .types.audit_log import AuditLog as AuditLogPayload
     from .types.guild import Guild as GuildPayload
     from .types.message import Message as MessagePayload
     from .types.monetization import Entitlement as EntitlementPayload
+    from .types.monetization import Subscription as SubscriptionPayload
     from .types.threads import Thread as ThreadPayload
     from .types.user import PartialUser as PartialUserPayload
     from .user import User
@@ -1021,6 +1023,11 @@ def _get_retrieve(self):
         self.retrieve = r
         return r > 0
 
+    def create_entitlement(self, data) -> Entitlement:
+        from .monetization import Entitlement
+
+        return Entitlement(data=data, state=self.state)
+
     async def fill_entitlements(self):
         if not self._get_retrieve():
             return
@@ -1034,9 +1041,9 @@ async def fill_entitlements(self):
             self.limit = 0  # terminate loop
 
         for element in data:
-            await self.entitlements.put(Entitlement(data=element, state=self.state))
+            await self.entitlements.put(self.create_entitlement(element))
 
-    async def _retrieve_entitlements(self, retrieve) -> list[Entitlement]:
+    async def _retrieve_entitlements(self, retrieve) -> list[EntitlementPayload]:
         """Retrieve entitlements and update next parameters."""
         raise NotImplementedError
 
@@ -1079,3 +1086,105 @@ async def _retrieve_entitlements_after_strategy(
                 self.limit -= retrieve
             self.after = Object(id=int(data[-1]["id"]))
         return data
+
+
+class SubscriptionIterator(_AsyncIterator["Subscription"]):
+    def __init__(
+        self,
+        state,
+        sku_id: int,
+        limit: int = None,
+        before: datetime.datetime | None = None,
+        after: datetime.datetime | None = None,
+        user_id: int | None = None,
+    ):
+        if isinstance(before, datetime.datetime):
+            before = Object(id=time_snowflake(before, high=False))
+        if isinstance(after, datetime.datetime):
+            after = Object(id=time_snowflake(after, high=True))
+
+        self.state = state
+        self.sku_id = sku_id
+        self.limit = limit
+        self.before = before
+        self.after = after
+        self.user_id = user_id
+
+        self._filter = None
+
+        self.get_subscriptions = state.http.list_sku_subscriptions
+        self.subscriptions = asyncio.Queue()
+
+        if self.before and self.after:
+            self._retrieve_subscriptions = self._retrieve_subscriptions_before_strategy
+            self._filter = lambda m: int(m["id"]) > self.after.id
+        elif self.after:
+            self._retrieve_subscriptions = self._retrieve_subscriptions_after_strategy
+        else:
+            self._retrieve_subscriptions = self._retrieve_subscriptions_before_strategy
+
+    async def next(self) -> Guild:
+        if self.subscriptions.empty():
+            await self.fill_subscriptions()
+
+        try:
+            return self.subscriptions.get_nowait()
+        except asyncio.QueueEmpty:
+            raise NoMoreItems()
+
+    def _get_retrieve(self):
+        l = self.limit
+        if l is None or l > 100:
+            r = 100
+        else:
+            r = l
+        self.retrieve = r
+        return r > 0
+
+    def create_subscription(self, data) -> Subscription:
+        from .monetization import Subscription
+
+        return Subscription(state=self.state, data=data)
+
+    async def fill_subscriptions(self):
+        if self._get_retrieve():
+            data = await self._retrieve_subscriptions(self.retrieve)
+            if self.limit is None or len(data) < 100:
+                self.limit = 0
+
+            if self._filter:
+                data = filter(self._filter, data)
+
+            for element in data:
+                await self.subscriptions.put(self.create_subscription(element))
+
+    async def _retrieve_subscriptions(self, retrieve) -> list[SubscriptionPayload]:
+        raise NotImplementedError
+
+    async def _retrieve_subscriptions_before_strategy(self, retrieve):
+        before = self.before.id if self.before else None
+        data: list[SubscriptionPayload] = await self.get_subscriptions(
+            self.sku_id,
+            limit=retrieve,
+            before=before,
+            user_id=self.user_id,
+        )
+        if len(data):
+            if self.limit is not None:
+                self.limit -= retrieve
+            self.before = Object(id=int(data[-1]["id"]))
+        return data
+
+    async def _retrieve_subscriptions_after_strategy(self, retrieve):
+        after = self.after.id if self.after else None
+        data: list[SubscriptionPayload] = await self.get_subscriptions(
+            self.sku_id,
+            limit=retrieve,
+            after=after,
+            user_id=self.user_id,
+        )
+        if len(data):
+            if self.limit is not None:
+                self.limit -= retrieve
+            self.after = Object(id=int(data[0]["id"]))
+        return data