Merge branch 'master' into message_reminders

# Conflicts:
#	stream_chat/async_chat/client.py
#	stream_chat/base/client.py
#	stream_chat/client.py

Author: nijeesh-stream

.github/CODEOWNERS

@@ -1 +1 @@
-* @10printhello @totalimmersion
+* @10printhello @totalimmersion @slavabobik

.gitignore

@@ -60,6 +60,7 @@ secrets.*sh
 .idea
 
 .venv
+venv
 .python-version
 pip-selfcheck.json
 .idea

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [4.24.0](https://github.com/GetStream/stream-chat-python/compare/v4.23.0...v4.24.0) (2025-04-07)
+
+## [4.23.0](https://github.com/GetStream/stream-chat-python/compare/v4.22.0...v4.23.0) (2025-03-11)
+
 ## [4.22.0](https://github.com/GetStream/stream-chat-python/compare/v4.21.0...v4.22.0) (2025-02-18)
 
 ## [4.21.0](https://github.com/GetStream/stream-chat-python/compare/v4.20.0...v4.21.0) (2025-02-11)

stream_chat/__pkg__.py

@@ -1,6 +1,6 @@
 __author__ = "Tommaso Barbugli"
 __copyright__ = "Copyright 2019-2022, Stream.io, Inc"
-__version__ = "4.22.0"
+__version__ = "4.24.0"
 __maintainer__ = "Tommaso Barbugli"
 __email__ = "[email protected]"
 __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 @@ async def update_partial(
         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 @@ async def update_member_partial(
 
         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.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,
@@ -190,6 +191,13 @@ async def restore_users(self, user_ids: Iterable[str]) -> StreamResponse:
     async def deactivate_user(self, user_id: str, **options: Any) -> StreamResponse:
         return await self.post(f"users/{user_id}/deactivate", data=options)
 
+    async def deactivate_users(
+        self, user_ids: Iterable[str], **options: Any
+    ) -> StreamResponse:
+        return await self.post(
+            "users/deactivate", data=dict(options, user_ids=user_ids)
+        )
+
     async def reactivate_user(self, user_id: str, **options: Any) -> StreamResponse:
         return await self.post(f"users/{user_id}/reactivate", data=options)
 
@@ -215,6 +223,22 @@ async def query_banned_users(self, query_conditions: Dict) -> StreamResponse:
             "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)
 
@@ -353,6 +377,13 @@ async def query_message_history(
         )
         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:
@@ -818,6 +849,28 @@ async def unread_counts(self, user_id: str) -> StreamResponse:
     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,

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 @@ def update_partial(
         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 @@ def update_member_partial(
         """
         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 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,
@@ -256,6 +257,21 @@ def deactivate_user(
         """
         pass
 
+    @abc.abstractmethod
+    def deactivate_users(
+        self, user_ids: Iterable[str], **options: Any
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Deactivates multiple users in a batch operation.
+        Deactivated users cannot connect to Stream Chat, and can't send or receive messages.
+        To reactivate users, use `reactivate_user` method for each user.
+
+        :param user_ids: a list of user IDs to deactivate
+        :param options: additional options
+        :return: task_id
+        """
+        pass
+
     @abc.abstractmethod
     def reactivate_user(
         self, user_id: str, **options: Any
@@ -339,6 +355,37 @@ def query_banned_users(
         """
         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
@@ -547,6 +594,19 @@ def query_message_history(
         """
         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
@@ -1369,6 +1429,16 @@ def unread_counts_batch(
         """
         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,

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