stream-chat 4.23.0__py3-none-any.whl → 4.25.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.23.0"
+__version__ = "4.25.0"
 __maintainer__ = "Tommaso Barbugli"
 __email__ = "support@getstream.io"
 __status__ = "Production"

stream_chat/async_chat/channel.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Iterable, List, Union
+from typing import Any, Dict, Iterable, List, Optional, Union
 
 from stream_chat.base.channel import ChannelInterface, add_user_id
 from stream_chat.base.exceptions import StreamChannelException
@@ -84,8 +84,8 @@ class Channel(ChannelInterface):
         payload = {"set": to_set or {}, "unset": to_unset or []}
         return await self.client.patch(self.url, data=payload)
 
-    async def delete(self) -> StreamResponse:
-        return await self.client.delete(self.url)
+    async def delete(self, hard: bool = False) -> StreamResponse:
+        return await self.client.delete(self.url, {"hard_delete": hard})
 
     async def truncate(self, **options: Any) -> StreamResponse:
         return await self.client.post(f"{self.url}/truncate", data=options)
@@ -247,3 +247,23 @@ class Channel(ChannelInterface):
 
         payload = {"set": to_set or {}, "unset": to_unset or []}
         return await self.client.patch(f"{self.url}/member/{user_id}", data=payload)
+
+    async def create_draft(self, message: Dict, user_id: str) -> StreamResponse:
+        payload = {"message": add_user_id(message, user_id)}
+        return await self.client.post(f"{self.url}/draft", data=payload)
+
+    async def delete_draft(
+        self, user_id: str, parent_id: Optional[str] = None
+    ) -> StreamResponse:
+        params = {"user_id": user_id}
+        if parent_id:
+            params["parent_id"] = parent_id
+        return await self.client.delete(f"{self.url}/draft", params=params)
+
+    async def get_draft(
+        self, user_id: str, parent_id: Optional[str] = None
+    ) -> StreamResponse:
+        params = {"user_id": user_id}
+        if parent_id:
+            params["parent_id"] = parent_id
+        return await self.client.get(f"{self.url}/draft", params=params)

stream_chat/async_chat/client.py

@@ -21,6 +21,7 @@ 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.draft import QueryDraftsFilter, QueryDraftsOptions
 from stream_chat.types.segment import (
     QuerySegmentsOptions,
     QuerySegmentTargetsOptions,
@@ -222,6 +223,22 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
             "query_banned_users", params={"payload": json.dumps(query_conditions)}
         )
 
+    async def block_user(
+        self, blocked_user_id: str, user_id: str, **options: Any
+    ) -> StreamResponse:
+        data = {"blocked_user_id": blocked_user_id, "user_id": user_id, **options}
+        return await self.post("users/block", data=data)
+
+    async def unblock_user(
+        self, blocked_user_id: str, user_id: str, **options: Any
+    ) -> StreamResponse:
+        data = {"blocked_user_id": blocked_user_id, "user_id": user_id, **options}
+        return await self.post("users/unblock", data=data)
+
+    async def get_blocked_users(self, user_id: str, **options: Any) -> StreamResponse:
+        params = {"user_id": user_id, **options}
+        return await self.get("users/block", params=params)
+
     async def run_message_action(self, message_id: str, data: Dict) -> StreamResponse:
         return await self.post(f"messages/{message_id}/action", data=data)
 
@@ -360,6 +377,13 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
         )
         return await self.post("messages/history", data=params)
 
+    async def query_threads(
+        self, filter: Dict = None, sort: List[Dict] = None, **options: Any
+    ) -> StreamResponse:
+        params = options.copy()
+        params.update({"filter": filter, "sort": self.normalize_sort(sort)})
+        return await self.post("threads", data=params)
+
     async def query_users(
         self, filter_conditions: Dict, sort: List[Dict] = None, **options: Any
     ) -> StreamResponse:
@@ -825,6 +849,113 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
     async def unread_counts_batch(self, user_ids: List[str]) -> StreamResponse:
         return await self.post("unread_batch", data={"user_ids": user_ids})
 
+    async def query_drafts(
+        self,
+        user_id: str,
+        filter: Optional[QueryDraftsFilter] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QueryDraftsOptions] = None,
+    ) -> StreamResponse:
+        data: Dict[str, Union[str, Dict[str, Any], List[SortParam]]] = {
+            "user_id": user_id
+        }
+
+        if filter is not None:
+            data["filter"] = cast(dict, filter)
+
+        if sort is not None:
+            data["sort"] = cast(dict, sort)
+
+        if options is not None:
+            data.update(cast(dict, options))
+
+        return await self.post("drafts/query", data=data)
+
+    async def create_reminder(
+        self,
+        message_id: str,
+        user_id: str,
+        remind_at: Optional[datetime.datetime] = None,
+    ) -> StreamResponse:
+        """
+        Creates a reminder for a message.
+
+        :param message_id: The ID of the message to create a reminder for
+        :param user_id: The ID of the user creating the reminder
+        :param remind_at: When to remind the user (optional)
+        :return: API response
+        """
+        data = {"user_id": user_id}
+        remind_at_timestamp = ""
+        if remind_at is not None:
+            if isinstance(remind_at, datetime.datetime):
+                remind_at_timestamp = remind_at.isoformat()
+            else:
+                remind_at_timestamp = str(remind_at)
+
+            data["remind_at"] = remind_at_timestamp
+
+        return await self.post(f"messages/{message_id}/reminders", data=data)
+
+    async def update_reminder(
+        self,
+        message_id: str,
+        user_id: str,
+        remind_at: Optional[datetime.datetime] = None,
+    ) -> StreamResponse:
+        """
+        Updates a reminder for a message.
+
+        :param message_id: The ID of the message with the reminder
+        :param user_id: The ID of the user who owns the reminder
+        :param remind_at: When to remind the user (optional)
+        :return: API response
+        """
+        data = {"user_id": user_id}
+        remind_at_timestamp = ""
+        if remind_at is not None:
+            if isinstance(remind_at, datetime.datetime):
+                remind_at_timestamp = remind_at.isoformat()
+            else:
+                remind_at_timestamp = str(remind_at)
+
+            data["remind_at"] = remind_at_timestamp
+        return await self.patch(f"messages/{message_id}/reminders", data=data)
+
+    async def delete_reminder(self, message_id: str, user_id: str) -> StreamResponse:
+        """
+        Deletes a reminder for a message.
+
+        :param message_id: The ID of the message with the reminder
+        :param user_id: The ID of the user who owns the reminder
+        :return: API response
+        """
+        return await self.delete(
+            f"messages/{message_id}/reminders", params={"user_id": user_id}
+        )
+
+    async def query_reminders(
+        self,
+        user_id: str,
+        filter_conditions: Dict = None,
+        sort: List[Dict] = None,
+        **options: Any,
+    ) -> StreamResponse:
+        """
+        Queries reminders based on filter conditions.
+
+        :param user_id: The ID of the user whose reminders to query
+        :param filter_conditions: Conditions to filter reminders
+        :param sort: Sort parameters (default: [{ field: 'remind_at', direction: 1 }])
+        :param options: Additional query options like limit, offset
+        :return: API response with reminders
+        """
+        params = options.copy()
+        params["filter_conditions"] = 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)
+
     async def close(self) -> None:
         await self.session.close()
 

stream_chat/base/channel.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Any, Awaitable, Dict, Iterable, List, Union
+from typing import Any, Awaitable, Dict, Iterable, List, Optional, Union
 
 from stream_chat.base.client import StreamChatInterface
 from stream_chat.base.exceptions import StreamChannelException
@@ -165,7 +165,9 @@ class ChannelInterface(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def delete(self) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+    def delete(
+        self, hard: bool = False
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Delete the channel. Messages are permanently removed.
 
@@ -486,6 +488,45 @@ class ChannelInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def create_draft(
+        self, message: Dict, user_id: str
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Creates or updates a draft message in a channel.
+
+        :param message: The message object
+        :param user_id: The ID of the user creating the draft
+        :return: The Server Response
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_draft(
+        self, user_id: str, parent_id: Optional[str] = None
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Deletes a draft message from a channel.
+
+        :param user_id: The ID of the user who owns the draft
+        :param parent_id: Optional ID of the parent message if this is a thread draft
+        :return: The Server Response
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_draft(
+        self, user_id: str, parent_id: Optional[str] = None
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Retrieves a draft message from a channel.
+
+        :param user_id: The ID of the user who owns the draft
+        :param parent_id: Optional ID of the parent message if this is a thread draft
+        :return: The Server Response
+        """
+        pass
+
 
 def add_user_id(payload: Dict, user_id: str) -> Dict:
     return {**payload, "user": {"id": user_id}}

stream_chat/base/client.py

@@ -9,6 +9,7 @@ from typing import Any, Awaitable, Dict, Iterable, List, Optional, TypeVar, Unio
 
 from stream_chat.types.base import SortParam
 from stream_chat.types.campaign import CampaignData, QueryCampaignsOptions
+from stream_chat.types.draft import QueryDraftsFilter, QueryDraftsOptions
 from stream_chat.types.segment import (
     QuerySegmentsOptions,
     QuerySegmentTargetsOptions,
@@ -354,6 +355,37 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def block_user(
+        self, blocked_user_id: str, user_id: str, **options: Any
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Blocks a user. When a user is blocked, they will not be able to communicate with the
+        blocking user in 1-on-1 channels, and will not be able to add the blocking user to channels.
+        To unblock a user, use `unblock_user` method.
+        """
+        pass
+
+    @abc.abstractmethod
+    def unblock_user(
+        self, blocked_user_id: str, user_id: str, **options: Any
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Unblocks a user. This allows the previously blocked user to communicate with the
+        unblocking user in 1-on-1 channels again, and all previous messages become visible.
+        To block a user, use `block_user` method.
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_blocked_users(
+        self, user_id: str, **options: Any
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Retrieves the list of users that have been blocked by the specified user.
+        """
+        pass
+
     @abc.abstractmethod
     def run_message_action(
         self, message_id: str, data: Dict
@@ -562,6 +594,19 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def query_threads(
+        self, filter: Dict = None, sort: List[Dict] = None, **options: Any
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Allows you to query threads using filter and sort. You can find the complete list of supported operators in the query syntax section of the docs.
+
+        :param filter: Filter conditions for the query
+        :param sort: Sort conditions for the query
+        :return: StreamResponse containing the threads
+        """
+        pass
+
     @abc.abstractmethod
     def query_users(
         self, filter_conditions: Dict, sort: List[Dict] = None, **options: Any
@@ -1384,6 +1429,82 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def query_drafts(
+        self,
+        user_id: str,
+        filter: Optional[QueryDraftsFilter] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QueryDraftsOptions] = None,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def create_reminder(
+        self,
+        message_id: str,
+        user_id: str,
+        remind_at: Optional[datetime.datetime] = None,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Creates a reminder for a message.
+
+        :param message_id: The ID of the message to create a reminder for
+        :param user_id: The ID of the user creating the reminder
+        :param remind_at: When to remind the user (optional)
+        :return: API response
+        """
+        pass
+
+    @abc.abstractmethod
+    def update_reminder(
+        self,
+        message_id: str,
+        user_id: str,
+        remind_at: Optional[datetime.datetime] = None,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Updates a reminder for a message.
+
+        :param message_id: The ID of the message with the reminder
+        :param user_id: The ID of the user who owns the reminder
+        :param remind_at: When to remind the user (optional)
+        :return: API response
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_reminder(
+        self, message_id: str, user_id: str
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Deletes a reminder for a message.
+
+        :param message_id: The ID of the message with the reminder
+        :param user_id: The ID of the user who owns the reminder
+        :return: API response
+        """
+        pass
+
+    @abc.abstractmethod
+    def query_reminders(
+        self,
+        user_id: str,
+        filter_conditions: Dict = None,
+        sort: List[Dict] = None,
+        **options: Any,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Queries reminders based on filter conditions.
+
+        :param user_id: The ID of the user whose reminders to query
+        :param filter_conditions: Conditions to filter reminders
+        :param sort: Sort parameters (default: [{ field: 'remind_at', direction: 1 }])
+        :param options: Additional query options like limit, offset
+        :return: API response with reminders
+        """
+        pass
+
     #####################
     #  Private methods  #
     #####################

stream_chat/base/query_threads.py

@@ -0,0 +1,31 @@
+import abc
+from typing import Any, Awaitable, Dict, List, Union
+
+from stream_chat.base.client import StreamChatInterface
+from stream_chat.types.stream_response import StreamResponse
+
+
+class QueryThreadsInterface(abc.ABC):
+    @abc.abstractmethod
+    def __init__(self, client: StreamChatInterface):
+        self.client = client
+
+    @property
+    def url(self) -> str:
+        return "threads"
+
+    @abc.abstractmethod
+    def query_threads(
+        self,
+        filter: Dict[str, Dict[str, Any]],
+        sort: List[Dict[str, Any]],
+        **options: Any,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Get a list of threads given filter and sort options
+
+        :param filter: filter conditions (e.g. {"created_by_user_id": {"$eq": "user_123"}})
+        :param sort: sort options (e.g. [{"field": "last_message_at", "direction": -1}])
+        :return: the Server Response
+        """
+        pass

stream_chat/channel.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Iterable, List, Union
+from typing import Any, Dict, Iterable, List, Optional, Union
 
 from stream_chat.base.channel import ChannelInterface, add_user_id
 from stream_chat.base.exceptions import StreamChannelException
@@ -82,8 +82,8 @@ class Channel(ChannelInterface):
         payload = {"set": to_set or {}, "unset": to_unset or []}
         return self.client.patch(self.url, data=payload)
 
-    def delete(self) -> StreamResponse:
-        return self.client.delete(self.url)
+    def delete(self, hard: bool = False) -> StreamResponse:
+        return self.client.delete(self.url, params={"hard_delete": hard})
 
     def truncate(self, **options: Any) -> StreamResponse:
         return self.client.post(f"{self.url}/truncate", data=options)
@@ -248,3 +248,26 @@ class Channel(ChannelInterface):
 
         payload = {"set": to_set or {}, "unset": to_unset or []}
         return self.client.patch(f"{self.url}/member/{user_id}", data=payload)
+
+    def create_draft(self, message: Dict, user_id: str) -> StreamResponse:
+        message["user_id"] = user_id
+        payload = {"message": message}
+        return self.client.post(f"{self.url}/draft", data=payload)
+
+    def delete_draft(
+        self, user_id: str, parent_id: Optional[str] = None
+    ) -> StreamResponse:
+        params = {"user_id": user_id}
+        if parent_id:
+            params["parent_id"] = parent_id
+
+        return self.client.delete(f"{self.url}/draft", params=params)
+
+    def get_draft(
+        self, user_id: str, parent_id: Optional[str] = None
+    ) -> StreamResponse:
+        params = {"user_id": user_id}
+        if parent_id:
+            params["parent_id"] = parent_id
+
+        return self.client.get(f"{self.url}/draft", params=params)

stream_chat/client.py

@@ -10,6 +10,7 @@ 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.draft import QueryDraftsFilter, QueryDraftsOptions
 from stream_chat.types.segment import (
     QuerySegmentsOptions,
     QuerySegmentTargetsOptions,
@@ -208,6 +209,22 @@ class StreamChat(StreamChatInterface):
             "query_banned_users", params={"payload": json.dumps(query_conditions)}
         )
 
+    def block_user(
+        self, blocked_user_id: str, user_id: str, **options: Any
+    ) -> StreamResponse:
+        data = {"blocked_user_id": blocked_user_id, "user_id": user_id, **options}
+        return self.post("users/block", data=data)
+
+    def unblock_user(
+        self, blocked_user_id: str, user_id: str, **options: Any
+    ) -> StreamResponse:
+        data = {"blocked_user_id": blocked_user_id, "user_id": user_id, **options}
+        return self.post("users/unblock", data=data)
+
+    def get_blocked_users(self, user_id: str, **options: Any) -> StreamResponse:
+        params = {"user_id": user_id, **options}
+        return self.get("users/block", params=params)
+
     def run_message_action(self, message_id: str, data: Dict) -> StreamResponse:
         return self.post(f"messages/{message_id}/action", data=data)
 
@@ -342,6 +359,13 @@ class StreamChat(StreamChatInterface):
         params.update({"filter": filter, "sort": self.normalize_sort(sort)})
         return self.post("messages/history", data=params)
 
+    def query_threads(
+        self, filter: Dict = None, sort: List[Dict] = None, **options: Any
+    ) -> StreamResponse:
+        params = options.copy()
+        params.update({"filter": filter, "sort": self.normalize_sort(sort)})
+        return self.post("threads", data=params)
+
     def query_users(
         self, filter_conditions: Dict, sort: List[Dict] = None, **options: Any
     ) -> StreamResponse:
@@ -782,3 +806,95 @@ class StreamChat(StreamChatInterface):
 
     def unread_counts_batch(self, user_ids: List[str]) -> StreamResponse:
         return self.post("unread_batch", data={"user_ids": user_ids})
+
+    def query_drafts(
+        self,
+        user_id: str,
+        filter: Optional[QueryDraftsFilter] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QueryDraftsOptions] = None,
+    ) -> StreamResponse:
+        data: Dict[str, Union[str, Dict[str, Any], List[SortParam]]] = {
+            "user_id": user_id
+        }
+        if filter is not None:
+            data["filter"] = cast(dict, filter)
+        if sort is not None:
+            data["sort"] = cast(dict, sort)
+        if options is not None:
+            data.update(cast(dict, options))
+        return self.post("drafts/query", data=data)
+
+    def create_reminder(
+        self,
+        message_id: str,
+        user_id: str,
+        remind_at: Optional[datetime.datetime] = None,
+    ) -> StreamResponse:
+        """
+        Creates a reminder for a message.
+
+        :param message_id: The ID of the message to create a reminder for
+        :param user_id: The ID of the user creating the reminder
+        :param remind_at: When to remind the user (optional)
+        :return: API response
+        """
+        data = {"user_id": user_id}
+        if remind_at is not None:
+            # Format as ISO 8601 date string without microseconds
+            data["remind_at"] = remind_at.strftime("%Y-%m-%dT%H:%M:%SZ")
+        return self.post(f"messages/{message_id}/reminders", data=data)
+
+    def update_reminder(
+        self,
+        message_id: str,
+        user_id: str,
+        remind_at: Optional[datetime.datetime] = None,
+    ) -> StreamResponse:
+        """
+        Updates a reminder for a message.
+
+        :param message_id: The ID of the message with the reminder
+        :param user_id: The ID of the user who owns the reminder
+        :param remind_at: When to remind the user (optional)
+        :return: API response
+        """
+        data = {"user_id": user_id}
+        if remind_at is not None:
+            # Format as ISO 8601 date string without microseconds
+            data["remind_at"] = remind_at.strftime("%Y-%m-%dT%H:%M:%SZ")
+        return self.patch(f"messages/{message_id}/reminders", data=data)
+
+    def delete_reminder(self, message_id: str, user_id: str) -> StreamResponse:
+        """
+        Deletes a reminder for a message.
+
+        :param message_id: The ID of the message with the reminder
+        :param user_id: The ID of the user who owns the reminder
+        :return: API response
+        """
+        return self.delete(
+            f"messages/{message_id}/reminders", params={"user_id": user_id}
+        )
+
+    def query_reminders(
+        self,
+        user_id: str,
+        filter_conditions: Dict = None,
+        sort: List[Dict] = None,
+        **options: Any,
+    ) -> StreamResponse:
+        """
+        Queries reminders based on filter conditions.
+
+        :param user_id: The ID of the user whose reminders to query
+        :param filter_conditions: Conditions to filter reminders
+        :param sort: Sort parameters (default: [{ field: 'remind_at', direction: 1 }])
+        :param options: Additional query options like limit, offset
+        :return: API response with reminders
+        """
+        params = options.copy()
+        params["filter_conditions"] = filter_conditions or {}
+        params["sort"] = sort or [{"field": "remind_at", "direction": 1}]
+        params["user_id"] = user_id
+        return self.post("reminders/query", data=params)

stream_chat/query_threads.py

@@ -0,0 +1,15 @@
+from typing import Any, Awaitable, Dict, List, Union
+
+from stream_chat.base.query_threads import QueryThreadsInterface
+from stream_chat.types.stream_response import StreamResponse
+
+
+class QueryThreads(QueryThreadsInterface):
+    def query_threads(
+        self,
+        filter: Dict[str, Dict[str, Any]],
+        sort: List[Dict[str, Any]],
+        **options: Any,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        payload = {"filter": filter, "sort": sort, **options}
+        return self.client.post(self.url, data=payload)

stream_chat/types/draft.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+from typing import Optional, TypedDict
+
+from stream_chat.types.base import Pager
+
+
+class QueryDraftsFilter(TypedDict):
+    channel_cid: Optional[str]
+    parent_id: Optional[str]
+    created_at: Optional[datetime]
+
+
+class QueryDraftsOptions(Pager):
+    pass

{stream_chat-4.23.0.dist-info → stream_chat-4.25.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: stream-chat
-Version: 4.23.0
+Version: 4.25.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.23.0
+Project-URL: Release Notes, https://github.com/GetStream/stream-chat-python/releases/tag/v4.25.0
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: OS Independent

{stream_chat-4.23.0.dist-info → stream_chat-4.25.0.dist-info}/RECORD

@@ -1,29 +1,32 @@
 stream_chat/__init__.py,sha256=xYQuC8xcPLJxJnFWzaNaO-sVUc7IJZYe13OIPRaDBEA,116
-stream_chat/__pkg__.py,sha256=yY9To71nWkYKV795IUKgyX4xLM2i7sf5lHQFJRW3Bs4,206
+stream_chat/__pkg__.py,sha256=WwppLHryS6nJerG5x3TNJ-ETXWjeMTqzKIs4cJCEaWY,206
 stream_chat/campaign.py,sha256=Z7bBo2rGMs02JkA1k9_206J0spcSLecjdhQuRnrc2Eo,2156
-stream_chat/channel.py,sha256=LnlHx1CDDnoxq4fCQ2sqlgjzIgPt0MmtKqph4240Uyg,9489
-stream_chat/client.py,sha256=xSzqPBVdtdR__tCiInKSvWhcQXb1qvB4Y1PWmWl_rTw,29335
+stream_chat/channel.py,sha256=KP8aSKFMG8iE_YUR1VwVp0-rNLmufETQRriWJ18Omc4,10328
+stream_chat/client.py,sha256=dBC4J_z-kfey8G8HahsCAd84TT0qjTkn2-sDmKy1EE0,33768
 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=-n-Fq3MrIhGy6DzyHwOOHijSrDAudUxV0Akp-OVn7V0,9919
-stream_chat/async_chat/client.py,sha256=frzDqBguHqNy_ztABCNwb4veg0GSNBYjzEwKKf7gpNI,31638
+stream_chat/async_chat/channel.py,sha256=R7r8kIJ3SjQN-jlF27Sp49ZGYRJl7ebh1pJ1cSIbSsg,10770
+stream_chat/async_chat/client.py,sha256=dMwlzK7eAGQpfwLB3GU9a7rmTFlM54mRpofpFr08ko0,36454
 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=bK-bbDFQquPskktXSu3UspWgOsH0EOBaHVpyg4vt2VM,15684
-stream_chat/base/client.py,sha256=jxqWN5Q00Hu_bw4SoiWxvrlSPMnEvn8AOqEaFBeFSU4,42151
+stream_chat/base/channel.py,sha256=FSYnKbfPPPpjYO8ODGw3E3udRwaV-phngsEoMgV1T9o,16986
+stream_chat/base/client.py,sha256=jvNHiNtLDn7ErYysSDsDzsHC8IMovCRwgV8V3QpeHlM,46360
 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/campaign.py,sha256=JyAn08oMaEsxPSqmVTdsfJK4xpfErPQV7Xr7zLQm99M,2293
+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/stream_response.py,sha256=jWKPrOU7u6dZ2SyOK53uQCXTstrL1HshO9fA7R6Bt_A,2391
-stream_chat-4.23.0.dist-info/LICENSE,sha256=H66SBDuPWSRHzKPEdyjAk3C0THQRcGPfqqve4naQuu0,14424
-stream_chat-4.23.0.dist-info/METADATA,sha256=qErwYreb3GgmbHsHF2t3B9juYcoWkor-8L8IC-0uqoA,7405
-stream_chat-4.23.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-stream_chat-4.23.0.dist-info/top_level.txt,sha256=26uTfg4bWcEaFrVKlzGGgfONH1p5DDe21G07EKfYSvo,12
-stream_chat-4.23.0.dist-info/RECORD,,
+stream_chat-4.25.0.dist-info/LICENSE,sha256=H66SBDuPWSRHzKPEdyjAk3C0THQRcGPfqqve4naQuu0,14424
+stream_chat-4.25.0.dist-info/METADATA,sha256=YBaA1MwUQDzJt8QakLoPZhB3kgFMX7xGQ9EZeaOQvI8,7405
+stream_chat-4.25.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+stream_chat-4.25.0.dist-info/top_level.txt,sha256=26uTfg4bWcEaFrVKlzGGgfONH1p5DDe21G07EKfYSvo,12
+stream_chat-4.25.0.dist-info/RECORD,,