stream-chat 4.28.0__py3-none-any.whl → 4.30.0__py3-none-any.whl

stream_chat/__pkg__.py

@@ -1,6 +1,6 @@
 __author__ = "Tommaso Barbugli"
 __copyright__ = "Copyright 2019-2022, Stream.io, Inc"
-__version__ = "4.28.0"
+__version__ = "4.30.0"
 __maintainer__ = "Tommaso Barbugli"
 __email__ = "support@getstream.io"
 __status__ = "Production"

stream_chat/async_chat/channel_batch_updater.py

@@ -0,0 +1,242 @@
+from typing import TYPE_CHECKING, List
+
+from stream_chat.types.channel_batch import (
+    ChannelBatchMemberRequest,
+    ChannelDataUpdate,
+    ChannelsBatchFilters,
+    ChannelsBatchOptions,
+)
+from stream_chat.types.stream_response import StreamResponse
+
+if TYPE_CHECKING:
+    from stream_chat.async_chat.client import StreamChatAsync
+
+
+class ChannelBatchUpdater:
+    """
+    Provides convenience methods for batch channel operations (async).
+    """
+
+    def __init__(self, client: "StreamChatAsync") -> None:
+        self.client = client
+
+    async def add_members(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Adds members to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to add.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "addMembers",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def remove_members(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Removes members from channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to remove.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "removeMembers",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def invite_members(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Invites members to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to invite.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "inviteMembers",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def add_moderators(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Adds moderators to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to add as moderators.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "addModerators",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def demote_moderators(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Removes moderator role from members in channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to demote from moderators.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "demoteModerators",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def assign_roles(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Assigns roles to members in channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members with roles to assign.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "assignRoles",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def hide(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Hides channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to hide channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "hide",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def show(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Shows channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to show channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "show",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def archive(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Archives channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to archive channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "archive",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def unarchive(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Unarchives channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to unarchive channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "unarchive",
+            "filter": filter,
+            "members": members,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def update_data(
+        self, filter: ChannelsBatchFilters, data: ChannelDataUpdate
+    ) -> StreamResponse:
+        """
+        Updates data on channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param data: Channel data to update.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "updateData",
+            "filter": filter,
+            "data": data,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def add_filter_tags(
+        self, filter: ChannelsBatchFilters, tags: List[str]
+    ) -> StreamResponse:
+        """
+        Adds filter tags to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param tags: List of filter tags to add.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "addFilterTags",
+            "filter": filter,
+            "filter_tags_update": tags,
+        }
+        return await self.client.update_channels_batch(options)
+
+    async def remove_filter_tags(
+        self, filter: ChannelsBatchFilters, tags: List[str]
+    ) -> StreamResponse:
+        """
+        Removes filter tags from channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param tags: List of filter tags to remove.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "removeFilterTags",
+            "filter": filter,
+            "filter_tags_update": tags,
+        }
+        return await self.client.update_channels_batch(options)

stream_chat/async_chat/client.py

@@ -4,6 +4,7 @@ import sys
 import warnings
 from types import TracebackType
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncContextManager,
     Callable,
@@ -15,12 +16,17 @@ from typing import (
     Union,
     cast,
 )
+
+if TYPE_CHECKING:
+    from stream_chat.async_chat.channel_batch_updater import ChannelBatchUpdater
+
 from urllib.parse import urlparse
 
 from stream_chat.async_chat.campaign import Campaign
 from stream_chat.async_chat.segment import Segment
 from stream_chat.types.base import SortParam
 from stream_chat.types.campaign import CampaignData, QueryCampaignsOptions
+from stream_chat.types.channel_batch import ChannelsBatchOptions
 from stream_chat.types.draft import QueryDraftsFilter, QueryDraftsOptions
 from stream_chat.types.segment import (
     QuerySegmentsOptions,
@@ -226,6 +232,22 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
             "query_banned_users", params={"payload": json.dumps(query_conditions)}
         )
 
+    async def query_future_channel_bans(self, **options: Any) -> StreamResponse:
+        """
+        Query future channel bans created by a user.
+
+        :param options: Optional parameters including:
+            - user_id: The ID of the user who created the bans
+            - exclude_expired_bans: Whether to exclude expired bans
+            - limit: Maximum number of results to return
+            - offset: Number of results to skip
+
+        :return: A StreamResponse containing the list of future channel bans
+        """
+        return await self.get(
+            "query_future_channel_bans", params={"payload": json.dumps(options)}
+        )
+
     async def block_user(
         self, blocked_user_id: str, user_id: str, **options: Any
     ) -> StreamResponse:
@@ -965,7 +987,7 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
         :return: API response with reminders
         """
         params = options.copy()
-        params["filter_conditions"] = filter_conditions or {}
+        params["filter"] = filter_conditions or {}
         params["sort"] = sort or [{"field": "remind_at", "direction": 1}]
         params["user_id"] = user_id
         return await self.post("reminders/query", data=params)
@@ -1028,6 +1050,30 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
 
         return await self.mark_delivered(data)
 
+    async def update_channels_batch(
+        self, options: ChannelsBatchOptions
+    ) -> StreamResponse:
+        """
+        Updates channels in batch based on the provided options.
+
+        :param options: ChannelsBatchOptions containing operation, filter, and operation-specific data.
+        :return: StreamResponse containing task_id.
+        """
+        if options is None:
+            raise ValueError("options must not be None")
+
+        return await self.put("channels/batch", data=options)
+
+    def channel_batch_updater(self) -> "ChannelBatchUpdater":
+        """
+        Returns a ChannelBatchUpdater instance for batch channel operations.
+
+        :return: ChannelBatchUpdater instance.
+        """
+        from stream_chat.async_chat.channel_batch_updater import ChannelBatchUpdater
+
+        return ChannelBatchUpdater(self)
+
     async def close(self) -> None:
         await self.session.close()
 

stream_chat/base/client.py

@@ -356,6 +356,23 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def query_future_channel_bans(
+        self, **options: Any
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Query future channel bans created by a user.
+
+        :param options: Optional parameters including:
+            - user_id: The ID of the user who created the bans
+            - exclude_expired_bans: Whether to exclude expired bans
+            - limit: Maximum number of results to return
+            - offset: Number of results to skip
+
+        :return: A StreamResponse containing the list of future channel bans
+        """
+        pass
+
     @abc.abstractmethod
     def block_user(
         self, blocked_user_id: str, user_id: str, **options: Any
@@ -1302,6 +1319,27 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def update_channels_batch(
+        self, options: Any
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Updates channels in batch based on the provided options.
+
+        :param options: ChannelsBatchOptions containing operation, filter, and operation-specific data.
+        :return: StreamResponse containing task_id.
+        """
+        pass
+
+    @abc.abstractmethod
+    def channel_batch_updater(self) -> Any:
+        """
+        Returns a ChannelBatchUpdater instance for batch channel operations.
+
+        :return: ChannelBatchUpdater instance.
+        """
+        pass
+
     @abc.abstractmethod
     def send_user_custom_event(
         self, user_id: str, event: Dict

stream_chat/channel_batch_updater.py

@@ -0,0 +1,242 @@
+from typing import TYPE_CHECKING, List
+
+from stream_chat.types.channel_batch import (
+    ChannelBatchMemberRequest,
+    ChannelDataUpdate,
+    ChannelsBatchFilters,
+    ChannelsBatchOptions,
+)
+from stream_chat.types.stream_response import StreamResponse
+
+if TYPE_CHECKING:
+    from stream_chat.client import StreamChat
+
+
+class ChannelBatchUpdater:
+    """
+    Provides convenience methods for batch channel operations.
+    """
+
+    def __init__(self, client: "StreamChat") -> None:
+        self.client = client
+
+    def add_members(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Adds members to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to add.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "addMembers",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def remove_members(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Removes members from channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to remove.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "removeMembers",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def invite_members(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Invites members to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to invite.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "inviteMembers",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def add_moderators(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Adds moderators to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to add as moderators.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "addModerators",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def demote_moderators(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Removes moderator role from members in channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members to demote from moderators.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "demoteModerators",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def assign_roles(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Assigns roles to members in channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param members: List of members with roles to assign.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "assignRoles",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def hide(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Hides channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to hide channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "hide",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def show(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Shows channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to show channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "show",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def archive(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Archives channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to archive channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "archive",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def unarchive(
+        self, filter: ChannelsBatchFilters, members: List[ChannelBatchMemberRequest]
+    ) -> StreamResponse:
+        """
+        Unarchives channels matching the filter for the specified members.
+
+        :param filter: The filter to match channels.
+        :param members: List of members for whom to unarchive channels.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "unarchive",
+            "filter": filter,
+            "members": members,
+        }
+        return self.client.update_channels_batch(options)
+
+    def update_data(
+        self, filter: ChannelsBatchFilters, data: ChannelDataUpdate
+    ) -> StreamResponse:
+        """
+        Updates data on channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param data: Channel data to update.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "updateData",
+            "filter": filter,
+            "data": data,
+        }
+        return self.client.update_channels_batch(options)
+
+    def add_filter_tags(
+        self, filter: ChannelsBatchFilters, tags: List[str]
+    ) -> StreamResponse:
+        """
+        Adds filter tags to channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param tags: List of filter tags to add.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "addFilterTags",
+            "filter": filter,
+            "filter_tags_update": tags,
+        }
+        return self.client.update_channels_batch(options)
+
+    def remove_filter_tags(
+        self, filter: ChannelsBatchFilters, tags: List[str]
+    ) -> StreamResponse:
+        """
+        Removes filter tags from channels matching the filter.
+
+        :param filter: The filter to match channels.
+        :param tags: List of filter tags to remove.
+        :return: StreamResponse containing task_id.
+        """
+        options: ChannelsBatchOptions = {
+            "operation": "removeFilterTags",
+            "filter": filter,
+            "filter_tags_update": tags,
+        }
+        return self.client.update_channels_batch(options)

stream_chat/client.py

@@ -2,14 +2,28 @@ import datetime
 import json
 import sys
 import warnings
-from typing import Any, Callable, Dict, Iterable, List, Optional, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Union,
+    cast,
+)
 from urllib.parse import urlparse
 from urllib.request import Request, urlopen
 
+if TYPE_CHECKING:
+    from stream_chat.channel_batch_updater import ChannelBatchUpdater
+
 from stream_chat.campaign import Campaign
 from stream_chat.segment import Segment
 from stream_chat.types.base import SortParam
 from stream_chat.types.campaign import CampaignData, QueryCampaignsOptions
+from stream_chat.types.channel_batch import ChannelsBatchOptions
 from stream_chat.types.draft import QueryDraftsFilter, QueryDraftsOptions
 from stream_chat.types.segment import (
     QuerySegmentsOptions,
@@ -218,6 +232,22 @@ class StreamChat(StreamChatInterface):
             "query_banned_users", params={"payload": json.dumps(query_conditions)}
         )
 
+    def query_future_channel_bans(self, **options: Any) -> StreamResponse:
+        """
+        Query future channel bans created by a user.
+
+        :param options: Optional parameters including:
+            - user_id: The ID of the user who created the bans
+            - exclude_expired_bans: Whether to exclude expired bans
+            - limit: Maximum number of results to return
+            - offset: Number of results to skip
+
+        :return: A StreamResponse containing the list of future channel bans
+        """
+        return self.get(
+            "query_future_channel_bans", params={"payload": json.dumps(options)}
+        )
+
     def block_user(
         self, blocked_user_id: str, user_id: str, **options: Any
     ) -> StreamResponse:
@@ -919,7 +949,7 @@ class StreamChat(StreamChatInterface):
         :return: API response with reminders
         """
         params = options.copy()
-        params["filter_conditions"] = filter_conditions or {}
+        params["filter"] = filter_conditions or {}
         params["sort"] = sort or [{"field": "remind_at", "direction": 1}]
         params["user_id"] = user_id
         return self.post("reminders/query", data=params)
@@ -985,3 +1015,25 @@ class StreamChat(StreamChatInterface):
             "user_id": user_id,
         }
         return self.mark_delivered(data=data)
+
+    def update_channels_batch(self, options: ChannelsBatchOptions) -> StreamResponse:
+        """
+        Updates channels in batch based on the provided options.
+
+        :param options: ChannelsBatchOptions containing operation, filter, and operation-specific data.
+        :return: StreamResponse containing task_id.
+        """
+        if options is None:
+            raise ValueError("options must not be None")
+
+        return self.put("channels/batch", data=options)
+
+    def channel_batch_updater(self) -> "ChannelBatchUpdater":
+        """
+        Returns a ChannelBatchUpdater instance for batch channel operations.
+
+        :return: ChannelBatchUpdater instance.
+        """
+        from stream_chat.channel_batch_updater import ChannelBatchUpdater
+
+        return ChannelBatchUpdater(self)

stream_chat/types/base.py

@@ -1,6 +1,6 @@
 import sys
 from enum import IntEnum
-from typing import Optional
+from typing import Any, Dict, List, Optional
 
 if sys.version_info >= (3, 8):
     from typing import TypedDict
@@ -43,3 +43,20 @@ class Pager(TypedDict, total=False):
     limit: Optional[int]
     next: Optional[str]
     prev: Optional[str]
+
+
+class ParsedPredefinedFilterResponse(TypedDict, total=False):
+    """
+    Represents the parsed/interpolated predefined filter returned in QueryChannels response.
+
+    This is only present when a predefined filter is used in the query.
+
+    Parameters:
+        name: The name of the predefined filter that was used.
+        filter: The interpolated filter with placeholders replaced by actual values.
+        sort: The interpolated sort parameters (optional).
+    """
+
+    name: str
+    filter: Dict[str, Any]
+    sort: Optional[List[SortParam]]

stream_chat/types/channel_batch.py

@@ -0,0 +1,93 @@
+import sys
+from typing import Any, Dict, List, Optional
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, TypedDict
+else:
+    from typing_extensions import Literal, TypedDict
+
+ChannelBatchOperation = Literal[
+    "addMembers",
+    "removeMembers",
+    "inviteMembers",
+    "assignRoles",
+    "addModerators",
+    "demoteModerators",
+    "hide",
+    "show",
+    "archive",
+    "unarchive",
+    "updateData",
+    "addFilterTags",
+    "removeFilterTags",
+]
+
+
+class ChannelBatchMemberRequest(TypedDict, total=False):
+    """
+    Represents a member in batch operations.
+
+    Parameters:
+        user_id: The ID of the user.
+        channel_role: The role of the user in the channel (optional).
+    """
+
+    user_id: str
+    channel_role: Optional[str]
+
+
+class ChannelDataUpdate(TypedDict, total=False):
+    """
+    Represents data that can be updated on channels in batch.
+
+    Parameters:
+        frozen: Whether the channel is frozen.
+        disabled: Whether the channel is disabled.
+        custom: Custom data for the channel.
+        team: The team ID for the channel.
+        config_overrides: Configuration overrides for the channel.
+        auto_translation_enabled: Whether auto-translation is enabled.
+        auto_translation_language: The language for auto-translation.
+    """
+
+    frozen: Optional[bool]
+    disabled: Optional[bool]
+    custom: Optional[Dict[str, Any]]
+    team: Optional[str]
+    config_overrides: Optional[Dict[str, Any]]
+    auto_translation_enabled: Optional[bool]
+    auto_translation_language: Optional[str]
+
+
+class ChannelsBatchFilters(TypedDict, total=False):
+    """
+    Represents filters for batch channel updates.
+
+    Parameters:
+        cids: Filter by channel CIDs (can be a dict with operators like $in).
+        types: Filter by channel types (can be a dict with operators like $in).
+        filter_tags: Filter by filter tags (can be a dict with operators like $in).
+    """
+
+    cids: Optional[Any]
+    types: Optional[Any]
+    filter_tags: Optional[Any]
+
+
+class ChannelsBatchOptions(TypedDict, total=False):
+    """
+    Represents options for batch channel updates.
+
+    Parameters:
+        operation: The batch operation to perform (required).
+        filter: The filter to match channels (required).
+        members: List of members for member-related operations (optional).
+        data: Channel data updates for updateData operation (optional).
+        filter_tags_update: List of filter tags for filter tag operations (optional).
+    """
+
+    operation: ChannelBatchOperation
+    filter: ChannelsBatchFilters
+    members: Optional[List[ChannelBatchMemberRequest]]
+    data: Optional[ChannelDataUpdate]
+    filter_tags_update: Optional[List[str]]

{stream_chat-4.28.0.dist-info → stream_chat-4.30.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: stream-chat
-Version: 4.28.0
+Version: 4.30.0
 Summary: Client for Stream Chat.
 Home-page: https://github.com/GetStream/stream-chat-python
 Author: Tommaso Barbugli
 Author-email: support@getstream.io
 Project-URL: Bug Tracker, https://github.com/GetStream/stream-chat-python/issues
 Project-URL: Documentation, https://getstream.io/activity-feeds/docs/python/?language=python
-Project-URL: Release Notes, https://github.com/GetStream/stream-chat-python/releases/tag/v4.28.0
+Project-URL: Release Notes, https://github.com/GetStream/stream-chat-python/releases/tag/v4.30.0
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: OS Independent

{stream_chat-4.28.0.dist-info → stream_chat-4.30.0.dist-info}/RECORD

@@ -1,34 +1,37 @@
 stream_chat/__init__.py,sha256=xYQuC8xcPLJxJnFWzaNaO-sVUc7IJZYe13OIPRaDBEA,116
-stream_chat/__pkg__.py,sha256=fpIg3ZYFBkAJ_dSTRSfYWMRtq6Wb22Vc9affBpGAQWQ,206
+stream_chat/__pkg__.py,sha256=GnrN9f9j_gBmgUVVxVXsMyzcYVmyKp27E4LbAFdPY0Q,206
 stream_chat/campaign.py,sha256=Z7bBo2rGMs02JkA1k9_206J0spcSLecjdhQuRnrc2Eo,2156
 stream_chat/channel.py,sha256=40q61hI0A0iy_Q2Xdv6D94oSG47Bu1PYaBXMRX2k03g,11059
-stream_chat/client.py,sha256=KOl4FRjlN2Af9p_yhBn5B8WFVYD9CoPDz1tZySfBIqg,37292
+stream_chat/channel_batch_updater.py,sha256=QkO7MlIsD0q0krox_zKqKrqNNsB0wiSRKiwIXALdyd0,8216
+stream_chat/client.py,sha256=U-640jHDkabpeKg9518FWq3cJoghEU--k5drhR7U4dw,38933
 stream_chat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stream_chat/query_threads.py,sha256=zz0w7DnTq0FR8OAvNkPH7Q1CSYaWOtoP_NAa8JgsKtE,542
 stream_chat/segment.py,sha256=MD1de83rVsaqxcyPy8wTXDudFjxz5Mvr70z4pTkW3P0,2691
 stream_chat/async_chat/__init__.py,sha256=V6x7yDCdXbP3vMuSan6Xm7RE_njZUvflImqOxfKRt4Y,67
 stream_chat/async_chat/campaign.py,sha256=Bc3iHZigxserUycZK4wDuXU0wXVH2G6fIDiYNVYPkeE,1885
 stream_chat/async_chat/channel.py,sha256=20dj1jQVm6dU_VUDpFJ1rUqxZVJtLhQeFxjJvcFm56s,11525
-stream_chat/async_chat/client.py,sha256=FGJaySh2YeJuWmFGz1s5JncavW4Ig_tjYhKkBdXvSMg,39437
+stream_chat/async_chat/channel_batch_updater.py,sha256=UiPHN8j49tn15RnjxqUBW6p6Ee3enMmvbNZn3gNWEBY,8401
+stream_chat/async_chat/client.py,sha256=PeCjdCunhXPkMWGvtDvWipgLwR8-tOwe5AHxHwu4vuw,41102
 stream_chat/async_chat/segment.py,sha256=G_YEwW2SXIE7huTW3Zu_rim2XkYcuFNYekLZZGDjFkA,2777
 stream_chat/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stream_chat/base/campaign.py,sha256=dAVkTYyirEpgyOPn8JyDebNMKeJu02vTuqgmPvdQoWU,1449
 stream_chat/base/channel.py,sha256=zaVhpVHXW-e3GHCqOtQO8x2yHqqAQ6MKP-AZXarQOUc,17805
-stream_chat/base/client.py,sha256=1n8JQngKNRWT7cnVKzxmVjWTCXrb0Dj2v1e2tc0eEVE,48391
+stream_chat/base/client.py,sha256=XUfW4ZojcGGz2qC52GBhs3IDmzKgezbkv_7_SqdJfQA,49631
 stream_chat/base/exceptions.py,sha256=eh1qW5d6zjUrlgsHNEBebAr0jVH2UupZ06w8sp2cseI,819
 stream_chat/base/query_threads.py,sha256=LfC09Atsw6cwL98MJjL-cGzQU4V1r7CRbRLitgBV-x8,934
 stream_chat/base/segment.py,sha256=X82DX8Y-cERJ1OvF2tz9iIM4CBNW6tx8HGaTEXBva9I,2364
 stream_chat/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stream_chat/types/base.py,sha256=JKlOxQVPvMClTo0ev63Ya-K-dX-98j95qSE-KKzziEE,858
+stream_chat/types/base.py,sha256=yMmYa_fH0YJRi5tkOlKCQUCAQccGe3IkMCTzzxsVG_M,1423
 stream_chat/types/campaign.py,sha256=3Hsgf3SGKA5jh-szQkGLJlmIuswKVTFQBW7vxpJVu-g,2795
+stream_chat/types/channel_batch.py,sha256=KskaIJCwQMXjanJaFOA3q5ipAgQjhw_RiNpyTmv6k_E,2714
 stream_chat/types/delivery_receipts.py,sha256=ir1EYIvRCKo2pw5nMPJ_JNJck1c_9xRXOANEW_803gk,1607
 stream_chat/types/draft.py,sha256=EJP1JkCtDFnz-DTC8p7WFWXfTazA8x5XKE7ghag7gJM,288
 stream_chat/types/rate_limit.py,sha256=v3Z4Ur0yoEdFLiHa1CNABEej2nxPlHQ6Bpy2XxW-TYQ,165
 stream_chat/types/segment.py,sha256=KzOi5N-VzLfj0m4zeZ9U_29ey9dxDtewtcNv9g4Aums,1273
 stream_chat/types/shared_locations.py,sha256=2rO4e0G1RX9DXGHcg3HJt5gp33G-LRKox62hfc0skGA,200
 stream_chat/types/stream_response.py,sha256=jWKPrOU7u6dZ2SyOK53uQCXTstrL1HshO9fA7R6Bt_A,2391
-stream_chat-4.28.0.dist-info/licenses/LICENSE,sha256=H66SBDuPWSRHzKPEdyjAk3C0THQRcGPfqqve4naQuu0,14424
-stream_chat-4.28.0.dist-info/METADATA,sha256=0GkcPlDkP4Rts1vuS_wdxbVMmapT2u5UDdWCj61DdgU,7638
-stream_chat-4.28.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-stream_chat-4.28.0.dist-info/top_level.txt,sha256=26uTfg4bWcEaFrVKlzGGgfONH1p5DDe21G07EKfYSvo,12
-stream_chat-4.28.0.dist-info/RECORD,,
+stream_chat-4.30.0.dist-info/licenses/LICENSE,sha256=H66SBDuPWSRHzKPEdyjAk3C0THQRcGPfqqve4naQuu0,14424
+stream_chat-4.30.0.dist-info/METADATA,sha256=XqhKdpv8lR3-5lhNMm8Vpaee2H8Q-czOGNJ_UoGLd3Y,7638
+stream_chat-4.30.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+stream_chat-4.30.0.dist-info/top_level.txt,sha256=26uTfg4bWcEaFrVKlzGGgfONH1p5DDe21G07EKfYSvo,12
+stream_chat-4.30.0.dist-info/RECORD,,