Add PartialUser.create_custom_reward

Added a PartialUser method that allows creation of a custom reward

Author: chillymosh

twitchio/http.py

@@ -346,14 +346,14 @@ async def create_reward(
         broadcaster_id: int,
         title: str,
         cost: int,
-        prompt: str = None,
-        is_enabled: bool = True,
-        background_color: str = None,
-        user_input_required: bool = False,
-        max_per_stream: int = None,
-        max_per_user: int = None,
-        global_cooldown: int = None,
-        fufill_immediatly: bool = False,
+        prompt: Optional[str] = None,
+        is_enabled: Optional[bool] = True,
+        background_color: Optional[str] = None,
+        user_input_required: Optional[bool] = False,
+        max_per_stream: Optional[int] = None,
+        max_per_user: Optional[int] = None,
+        global_cooldown: Optional[int] = None,
+        fufill_immediatly: Optional[bool] = False,
     ):
         params = [("broadcaster_id", str(broadcaster_id))]
         data = {
@@ -366,10 +366,10 @@ async def create_reward(
         }
         if max_per_stream:
             data["max_per_stream"] = max_per_stream
-            data["max_per_stream_enabled"] = True
+            data["is_max_per_stream_enabled"] = True
         if max_per_user:
             data["max_per_user_per_stream"] = max_per_user
-            data["max_per_user_per_stream_enabled"] = True
+            data["is_max_per_user_per_stream_enabled"] = True
         if background_color:
             data["background_color"] = background_color
         if global_cooldown:

twitchio/rewards.py

@@ -33,8 +33,6 @@
 if TYPE_CHECKING:
     from .http import TwitchHTTP
     from .user import PartialUser
-
-
 __all__ = "CustomReward", "CustomRewardRedemption"
 
 
@@ -73,7 +71,6 @@ def __init__(self, http: "TwitchHTTP", obj: dict, channel: "PartialUser"):
             self._broadcaster_id = obj["broadcaster_id"]
         except KeyError:
             self._broadcaster_id = obj["channel_id"]
-
         self.id = obj["id"]
         self.image = obj["image"]["url_1x"] if obj["image"] else obj["default_image"]["url_1x"]
         self.background_color = obj["background_color"]
@@ -106,7 +103,6 @@ def __init__(self, http: "TwitchHTTP", obj: dict, channel: "PartialUser"):
                 obj["global_cooldown"]["is_enabled"],
                 obj["global_cooldown"]["global_cooldown_seconds"],
             )
-
         self.paused = obj["is_paused"]
         self.in_stock = obj["is_in_stock"]
         self.redemptions_skip_queue = obj["should_redemptions_skip_request_queue"]
@@ -194,7 +190,6 @@ async def edit(
                 if reward["id"] == self.id:
                     self.__init__(self._http, reward, self._channel)
                     break
-
         return self
 
     async def delete(self, token: str):
@@ -263,6 +258,7 @@ async def get_redemptions(self, token: str, status: str, sort: str = "OLDEST", f
     def __repr__(self):
         return f"<CustomReward id={self.id} title={self.title} cost={self.cost}>"
 
+
 class CustomRewardRedemption:
 
     __slots__ = "_http", "_broadcaster_id", "id", "user_id", "user_name", "input", "status", "redeemed_at", "reward"

twitchio/user.py

@@ -178,6 +178,78 @@ async def get_custom_rewards(
             self._cached_rewards = time.monotonic(), values
             return values
 
+    async def create_custom_reward(
+        self,
+        token: str,
+        title: str,
+        cost: int,
+        prompt: Optional[str] = None,
+        enabled: Optional[bool] = True,
+        background_color: Optional[str] = None,
+        input_required: Optional[bool] = False,
+        max_per_stream: Optional[int] = None,
+        max_per_user_per_stream: Optional[int] = None,
+        global_cooldown: Optional[int] = None,
+        redemptions_skip_queue: Optional[bool] = False,
+    ) -> "CustomReward":
+        """|coro|
+
+        Creates a custom reward for the user.
+
+        Parameters
+        -----------
+        token: :class:`str`
+            An oauth token with the user:edit:broadcast scope
+        title: :class:`str`
+            The title of the reward
+        cost: :class:`int`
+            The cost of the reward
+        prompt: Optional[:class:`str`]
+            The prompt for the reward. Defaults to None
+        enabled: Optional[:class:`bool`]
+            Whether the reward is enabled. Defaults to True
+        background_color: Optional[:class:`str`]
+            The background color of the reward. Defaults to None
+        input_required: Optional[:class:`bool`]
+            Whether the reward requires input. Defaults to False
+        max_per_stream: Optional[:class:`int`]
+            The maximum number of times the reward can be redeemed per stream. Defaults to None
+        max_per_user_per_stream: Optional[:class:`int`]
+            The maximum number of times the reward can be redeemed per user per stream. Defaults to None
+        global_cooldown: Optional[:class:`int`]
+            The global cooldown of the reward. Defaults to None
+        redemptions_skip_queue: Optional[:class:`bool`]
+            Whether the reward skips the queue when redeemed. Defaults to False
+        """
+        try:
+            data = await self._http.create_reward(
+                token,
+                self.id,
+                title,
+                cost,
+                prompt,
+                enabled,
+                background_color,
+                input_required,
+                max_per_stream,
+                max_per_user_per_stream,
+                global_cooldown,
+                redemptions_skip_queue,
+            )
+            return CustomReward(self._http, data[0], self)
+        except Unauthorized as error:
+            raise Unauthorized("The given token is invalid", "", 401) from error
+        except HTTPException as error:
+            status = error.args[2]
+            if status == 403:
+                raise HTTPException(
+                    "The custom reward was created by a different application, or channel points are "
+                    "not available for the broadcaster (403)",
+                    error.args[1],
+                    403,
+                ) from error
+            raise
+
     async def fetch_bits_leaderboard(
         self, token: str, period: str = "all", user_id: int = None, started_at: datetime.datetime = None
     ) -> "BitsLeaderboard":