New User methods and fix

User methods added for the new goals and chat settings endpoints.

fetch_channel_teams now correctly returns empty list rather than unhandled error if no team is found.

Author: chillymosh

docs/changelog.rst

@@ -6,10 +6,13 @@ Massive documentation updates
 
 - TwitchIO
     - Removed unexpected loop termination from `WSConnection._close()`
-    - Fix bug where # prefixed channel names in initial_channels would not trigger :func:`twitchio.Client.event_ready`
+    - Fix bug where # prefixed channel names and capitals in initial_channels would not trigger :func:`twitchio.Client.event_ready`
     - :func:`User.create_clip` has been fixed by converting bool to string in http request
     - Poll endpoints added :func:`User.fetch_polls` :func:`User.create_poll` and :func:`User.end_poll`
     - :func:`Client.fetch_cheermotes` color attribute corrected
+    - :func:`User.fetch_channel_teams` returns empty list if no teams found rather than unhandled error
+    - :func:`User.fetch_goals` method added
+    - :func:`User.fetch_chat_settings` and :func:`User.update_chat_settings` methods added
 
 - ext.commands
     - :func:`Bot.handle_commands` now also invokes on threads / replies

docs/reference.rst

@@ -74,6 +74,14 @@ ChannelTeams
     :members:
     :inherited-members:
 
+ChatSettings
+-------------
+.. attributetable:: ChatSettings
+
+.. autoclass:: ChatSettings
+    :members:
+    :inherited-members:
+
 Chatter
 --------
 .. attributetable:: PartialChatter
@@ -159,6 +167,14 @@ Game
     :members:
     :inherited-members:
 
+Goal
+------
+.. attributetable:: Goal
+
+.. autoclass:: Goal
+    :members:
+    :inherited-members:
+
 HypeTrainContribution
 -----------------------
 .. attributetable:: HypeTrainContribution

twitchio/http.py

@@ -859,7 +859,7 @@ async def get_teams(self, team_name: str = None, team_id: str = None):
 
     async def get_channel_teams(self, broadcaster_id: str):
         q = [("broadcaster_id", broadcaster_id)]
-        return await self.request(Route("GET", "teams/channel", query=q))
+        return await self.request(Route("GET", "teams/channel", query=q), paginate=False, full_body=True)
 
     async def get_polls(
         self,
@@ -921,3 +921,48 @@ async def post_poll(
     async def patch_poll(self, broadcaster_id: str, token: str, id: str, status: str):
         body = {"broadcaster_id": broadcaster_id, "id": id, "status": status}
         return await self.request(Route("PATCH", "polls", body=body, token=token))
+
+    async def get_goals(self, broadcaster_id: str, token: str):
+        return await self.request(Route("GET", "goals", query=[("broadcaster_id", broadcaster_id)], token=token))
+
+    async def get_chat_settings(self, broadcaster_id: str, moderator_id: Optional[str] = None, token: Optional[str] = None):
+        q = [("broadcaster_id", broadcaster_id)]
+        if moderator_id and token:
+            q.append(("moderator_id", moderator_id))
+        return await self.request(Route("GET", "chat/settings", query=q, token=token))
+
+    async def patch_chat_settings(
+        self,
+        broadcaster_id: str,
+        moderator_id: str,
+        token: str,
+        emote_mode: Optional[bool] = None,
+        follower_mode: Optional[bool] = None,
+        follower_mode_duration: Optional[int] = None,
+        slow_mode: Optional[bool] = None,
+        slow_mode_wait_time: Optional[int] = None,
+        subscriber_mode: Optional[bool] = None,
+        unique_chat_mode: Optional[bool] = None,
+        non_moderator_chat_delay: Optional[bool] = None,
+        non_moderator_chat_delay_duration: Optional[int] = None
+        ):
+        if follower_mode_duration and follower_mode_duration > 129600:
+            raise ValueError("follower_mode_duration must be below 129600")
+        if slow_mode_wait_time and (slow_mode_wait_time < 3 or slow_mode_wait_time > 120):
+            raise ValueError("slow_mode_wait_time must be between 3 and 120")
+        if non_moderator_chat_delay_duration and non_moderator_chat_delay_duration not in {2, 4, 6}:
+            raise ValueError("non_moderator_chat_delay_duration must be 2, 4 or 6")
+        q = [("broadcaster_id", broadcaster_id), ("moderator_id", moderator_id)]
+        data = {
+            "emote_mode": emote_mode,
+            "follower_mode": follower_mode,
+            "follower_mode_duration": follower_mode_duration,
+            "slow_mode": slow_mode,
+            "slow_mode_wait_time": slow_mode_wait_time,
+            "subscriber_mode": subscriber_mode,
+            "unique_chat_mode": unique_chat_mode,
+            "non_moderator_chat_delay": non_moderator_chat_delay,
+            "non_moderator_chat_delay_duration": non_moderator_chat_delay_duration,
+        }
+        data = {k: v for k, v in data.items() if v is not None}
+        return await self.request(Route("PATCH", "chat/settings", query=q, body=data, token=token))

twitchio/models.py

@@ -70,6 +70,8 @@
     "ChannelInfo",
     "Poll",
     "PollChoice",
+    "Goal",
+    "ChatSettings",
 )
 
 
@@ -1375,9 +1377,9 @@ class Poll:
     duration: :class:`int`
         Total duration for the poll (in seconds).
     started_at: :class:`datetime.datetime`
-        Date and time the the poll was started.
+        Date and time the poll was started.
     ended_at: :class:`datetime.datetime`
-        Date and time the the poll was ended.
+        Date and time the poll was ended.
     """
 
     __slots__ = (
@@ -1441,3 +1443,111 @@ def __init__(self, data: dict):
 
     def __repr__(self):
         return f"<PollChoice id={self.id} title={self.title} votes={self.votes} channel_points_votes={self.channel_points_votes} bits_votes={self.bits_votes}>"
+
+class Goal:
+    """
+    Represents a list of Goals for a broadcaster / channel
+
+    Attributes
+    -----------
+    id: :class:`str`
+        An ID that uniquely identifies this goal.
+    broadcaster: :class:`~twitchio.PartialUser`
+        User of the broadcaster.
+    type: :class:`str`
+        The type of goal.
+        Valid values: follower, subscription and new_subscription.
+    description: :class:`str`
+        A description of the goal, if specified.
+    current_amount: :class:`int`
+        The current value.
+    target_amount: :class:`int`
+        Number of Bits required to vote once with Bits.
+    created_at: :class:`datetime.datetime`
+        Date and time of when the broadcaster created the goal.
+    """
+
+    __slots__ = (
+        "id",
+        "broadcaster",
+        "type",
+        "description",
+        "current_amount",
+        "target_amount",
+        "created_at",
+    )
+
+    def __init__(self, http: "TwitchHTTP", data: dict):
+        self.id: str = data["id"]
+        self.broadcaster = PartialUser(http, data["broadcaster_id"], data["broadcaster_login"])
+        self.type: str = data["type"]
+        self.description: str = data["description"]
+        self.current_amount: int = data["current_amount"]
+        self.target_amount: int = data["target_amount"]
+        self.created_at: datetime.datetime = parse_timestamp(data["created_at"])
+
+    def __repr__(self):
+        return f"<Goal id={self.id} broadcaster={self.broadcaster} description={self.description} current_amount={self.current_amount} target_amount={self.target_amount} created_at={self.created_at}>"
+
+class ChatSettings:
+    """
+    Represents current chat settings of a broadcaster / channel
+
+    Attributes
+    -----------
+    broadcaster: :class:`~twitchio.PartialUser`
+        User of the broadcaster. Only returns the ID.
+    emote_mode: :class:`bool`
+        Indicates whether emote only mode is enabled.
+    follower_mode: :class:`bool`
+        Indicates whether follower only chat is enabled.
+    follower_mode_duration: Optional[:class:`int`]
+        The length of time, in minutes, that the followers must have followed the broadcaster to participate in chat.
+    slow_mode: :class:`bool`
+        Indicates whether the chat is in slow mode.
+    slow_mode_wait_time: Optional[:class:`int`]
+        The amount of time, in seconds, that users need to wait between sending messages.
+    subscriber_mode: :class:`bool`
+        Indicates whether only users that subscribe to the broadcaster's channel can talk in chat.
+    unique_chat_mode: :class:`bool`
+        Indicates whether the broadcaster requires users to post only unique messages in the chat room.
+    moderator: Optional[:class:`~twitchio.PartialUser`]
+        The User of the moderator, if provided. Only returns the ID.
+    non_moderator_chat_delay: Optional[:class:`bool`]
+        Indicates whether the broadcaster adds a short delay before chat messages appear in the chat room.
+    non_moderator_chat_delay_duration: Optional[:class:`int`]
+        The amount of time, in seconds, that messages are delayed from appearing in chat.
+    """
+
+    __slots__ = (
+        "broadcaster",
+        "emote_mode",
+        "follower_mode",
+        "follower_mode_duration",
+        "slow_mode",
+        "slow_mode_wait_time",
+        "subscriber_mode",
+        "unique_chat_mode",
+        "moderator",
+        "non_moderator_chat_delay",
+        "non_moderator_chat_delay_duration",
+    )
+
+    def __init__(self, http: "TwitchHTTP", data: dict):
+        self.broadcaster = PartialUser(http, data["broadcaster_id"], None)
+        self.emote_mode: bool = data["emote_mode"]
+        self.follower_mode: bool = data["follower_mode"]
+        self.follower_mode_duration: Optional[int] = data.get("follower_mode_duration")
+        self.slow_mode: bool = data["slow_mode"]
+        self.slow_mode_wait_time: Optional[int] = data.get("slow_mode_wait_time")
+        self.subscriber_mode: bool = data["subscriber_mode"]
+        self.unique_chat_mode: bool = data["unique_chat_mode"]
+        self.non_moderator_chat_delay: Optional[bool] = data.get("non_moderator_chat_delay")
+        self.non_moderator_chat_delay_duration: Optional[int] = data.get("non_moderator_chat_delay_duration")
+        try:
+            self.moderator  = PartialUser(http, data["moderator_id"], None)
+        except KeyError:
+            self.moderator = None
+
+    def __repr__(self):
+        return f"<ChatSettings broadcaster={self.broadcaster} emote_mode={self.emote_mode} follower_mode={self.follower_mode} slow_mode={self.slow_mode} subscriber_mode={self.subscriber_mode} unique_chat_mode={self.unique_chat_mode}>"

twitchio/user.py

@@ -801,7 +801,7 @@ async def fetch_channel_teams(self):
             broadcaster_id=str(self.id),
         )
 
-        return [ChannelTeams(self._http, x) for x in data]
+        return [ChannelTeams(self._http, x) for x in data["data"]] if data["data"] else []
 
     async def fetch_polls(self, token: str, poll_ids: Optional[List[str]] = None, first: Optional[int] = 20):
         """|coro|
@@ -824,7 +824,7 @@ async def fetch_polls(self, token: str, poll_ids: Optional[List[str]] = None, fi
         from .models import Poll
 
         data = await self._http.get_polls(broadcaster_id=str(self.id), token=token, poll_ids=poll_ids, first=first)
-        return [Poll(self._http, x) for x in data["data"]] if data["data"] else None
+        return [Poll(self._http, x) for x in data["data"]] if data["data"] else []
 
     async def create_poll(
         self,
@@ -904,6 +904,111 @@ async def end_poll(self, token: str, poll_id: str, status: str):
         data = await self._http.patch_poll(broadcaster_id=str(self.id), token=token, id=poll_id, status=status)
         return Poll(self._http, data[0])
 
+    async def fetch_goals(self, token: str):
+        """|coro|
+
+        Fetches a list of goals for the specified channel/broadcaster.
+
+        Parameters
+        -----------
+        token: :class:`str`
+            An oauth token with the user:read:broadcast scope
+
+        Returns
+        --------
+        List[:class:`twitchio.Goal`]
+        """
+        from .models import Goal
+
+        data = await self._http.get_goals(broadcaster_id=str(self.id), token=token)
+        return [Goal(self._http, x) for x in data]
+
+    async def fetch_chat_settings(self, moderator_id: Optional[int] = None, token: Optional[str] = None):
+        """|coro|
+
+        Fetches the current chat settings for this channel/broadcaster.
+
+        Parameters
+        -----------
+        moderator_id: Optional[:class:`int`]
+            The ID of a user that has permission to moderate the broadcaster's chat room.
+        token: Optional[:class:`str`]
+            An oauth token with the moderator:read:chat_settings scope. Required if moderator_id is provided.
+
+        Returns
+        --------
+        :class:`twitchio.ChatSettings`
+        """
+        from .models import ChatSettings
+
+        data = await self._http.get_chat_settings(broadcaster_id=str(self.id), moderator_id=str(moderator_id), token=token)
+        return ChatSettings(self._http, data[0])
+
+    async def update_chat_settings(
+        self,
+        moderator_id: int,
+        token: str,
+        emote_mode: Optional[bool] = None,
+        follower_mode: Optional[bool] = None,
+        follower_mode_duration: Optional[int] = None,
+        slow_mode: Optional[bool] = None,
+        slow_mode_wait_time: Optional[int] = None,
+        subscriber_mode: Optional[bool] = None,
+        unique_chat_mode: Optional[bool] = None,
+        non_moderator_chat_delay: Optional[bool] = None,
+        non_moderator_chat_delay_duration: Optional[int] = None
+        ):
+        """|coro|
+
+        Updates the current chat settings for this channel/broadcaster.
+
+        Parameters
+        -----------
+        moderator_id: :class:`int`
+            The ID of a user that has permission to moderate the broadcaster's chat room.
+        token: :class:`str`
+            An oauth token with the moderator:manage:chat_settings scope.
+        emote_mode: Optional[:class:`bool`]
+            A boolean to determine whether chat must contain only emotes or not.
+        follower_mode: Optional[:class:`bool`]
+            A boolean to determine whether chat must contain only emotes or not.
+        follower_mode_duration: Optional[:class:`int`]
+            The length of time, in minutes, that the followers must have followed the broadcaster to participate in chat.
+            Values: 0 (no restriction) through 129600 (3 months). The default is 0.
+        slow_mode: Optional[:class:`bool`]
+            A boolean to determine whether the broadcaster limits how often users in the chat room are allowed to send messages.
+        slow_mode_wait_time: Optional[:class:`int`]
+            The amount of time, in seconds, that users need to wait between sending messages.
+            Values: 3 through 120 (2 minute delay). The default is 30 seconds.
+        subscriber_mode: Optional[:class:`bool`]
+            A boolean to determine whether only users that subscribe to the broadcaster's channel can talk in chat.
+        unique_chat_mode: Optional[:class:`bool`]
+            A boolean to determine whether the broadcaster requires users to post only unique messages in chat.
+        non_moderator_chat_delay: Optional[:class:`bool`]
+            A boolean to determine whether the broadcaster adds a short delay before chat messages appear in chat.
+        non_moderator_chat_delay_duration: Optional[:class:`int`]
+            The amount of time, in seconds, that messages are delayed from appearing in chat.
+            Valid values: 2, 4 and 6.
+
+        Returns
+        --------
+        :class:`twitchio.ChatSettings`
+        """
+        from .models import ChatSettings
+        data = await self._http.patch_chat_settings(
+            broadcaster_id=str(self.id),
+            moderator_id=str(moderator_id),
+            token=token, emote_mode=emote_mode,
+            follower_mode=follower_mode,
+            follower_mode_duration=follower_mode_duration,
+            slow_mode=slow_mode,
+            slow_mode_wait_time=slow_mode_wait_time,
+            subscriber_mode=subscriber_mode,
+            unique_chat_mode=unique_chat_mode,
+            non_moderator_chat_delay=non_moderator_chat_delay,
+            non_moderator_chat_delay_duration=non_moderator_chat_delay_duration
+            )
+        return ChatSettings(self._http, data[0])
 
 class BitLeaderboardUser(PartialUser):