slack-sdk 3.36.0.dev4__tar.gz → 3.36.0.dev6__tar.gz

{slack_sdk-3.36.0.dev4/slack_sdk.egg-info → slack_sdk-3.36.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack_sdk
-Version: 3.36.0.dev4
+Version: 3.36.0.dev6
 Summary: The Slack API Platform SDK for Python
 Home-page: https://github.com/slackapi/python-slack-sdk
 Author: Slack Technologies, LLC

{slack_sdk-3.36.0.dev4 → slack_sdk-3.36.0.dev6}/slack_sdk/version.py

@@ -1,3 +1,3 @@
 """Check the latest version at https://pypi.org/project/slack-sdk/"""
 
-__version__ = "3.36.0.dev4"
+__version__ = "3.36.0.dev6"

slack_sdk-3.36.0.dev6/slack_sdk/web/async_chat_stream.py

@@ -0,0 +1,212 @@
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+#
+#  *** DO NOT EDIT THIS FILE ***
+#
+#  1) Modify slack_sdk/web/client.py
+#  2) Run `python scripts/codegen.py`
+#  3) Run `black slack_sdk/`
+#
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+import json
+import logging
+from typing import TYPE_CHECKING, Dict, Optional, Sequence, Union
+
+import slack_sdk.errors as e
+from slack_sdk.models.blocks.blocks import Block
+from slack_sdk.models.metadata import Metadata
+from slack_sdk.web.async_slack_response import AsyncSlackResponse
+
+if TYPE_CHECKING:
+    from slack_sdk.web.async_client import AsyncWebClient
+
+
+class AsyncChatStream:
+    """A helper class for streaming markdown text into a conversation using the chat streaming APIs.
+
+    This class provides a convenient interface for the chat.startStream, chat.appendStream, and chat.stopStream API
+    methods, with automatic buffering and state management.
+    """
+
+    def __init__(
+        self,
+        client: "AsyncWebClient",
+        *,
+        channel: str,
+        logger: logging.Logger,
+        thread_ts: str,
+        buffer_size: int,
+        recipient_team_id: Optional[str] = None,
+        recipient_user_id: Optional[str] = None,
+        **kwargs,
+    ):
+        """Initialize a new ChatStream instance.
+
+        The __init__ method creates a unique ChatStream instance that keeps track of one chat stream.
+
+        Args:
+            client: The WebClient instance to use for API calls.
+            channel: An encoded ID that represents a channel, private group, or DM.
+            logger: A logging channel for outputs.
+            thread_ts: Provide another message's ts value to reply to. Streamed messages should always be replies to a user
+              request.
+            recipient_team_id: The encoded ID of the team the user receiving the streaming text belongs to. Required when
+              streaming to channels.
+            recipient_user_id: The encoded ID of the user to receive the streaming text. Required when streaming to channels.
+            buffer_size: The length of markdown_text to buffer in-memory before calling a method. Increasing this value
+              decreases the number of method calls made for the same amount of text, which is useful to avoid rate limits.
+            **kwargs: Additional arguments passed to the underlying API calls.
+        """
+        self._client = client
+        self._logger = logger
+        self._token: Optional[str] = kwargs.pop("token", None)
+        self._stream_args = {
+            "channel": channel,
+            "thread_ts": thread_ts,
+            "recipient_team_id": recipient_team_id,
+            "recipient_user_id": recipient_user_id,
+            **kwargs,
+        }
+        self._buffer = ""
+        self._state = "starting"
+        self._stream_ts: Optional[str] = None
+        self._buffer_size = buffer_size
+
+    async def append(
+        self,
+        *,
+        markdown_text: str,
+        **kwargs,
+    ) -> Optional[AsyncSlackResponse]:
+        """Append to the stream.
+
+        The "append" method appends to the chat stream being used. This method can be called multiple times. After the stream
+        is stopped this method cannot be called.
+
+        Args:
+            markdown_text: Accepts message text formatted in markdown. Limit this field to 12,000 characters. This text is
+              what will be appended to the message received so far.
+            **kwargs: Additional arguments passed to the underlying API calls.
+
+        Returns:
+            AsyncSlackResponse if the buffer was flushed, None if buffering.
+
+        Raises:
+            SlackRequestError: If the stream is already completed.
+
+        Example:
+            ```python
+            streamer = client.chat_stream(
+                channel="C0123456789",
+                thread_ts="1700000001.123456",
+                recipient_team_id="T0123456789",
+                recipient_user_id="U0123456789",
+            )
+            streamer.append(markdown_text="**hello wo")
+            streamer.append(markdown_text="rld!**")
+            streamer.stop()
+            ```
+        """
+        if self._state == "completed":
+            raise e.SlackRequestError(f"Cannot append to stream: stream state is {self._state}")
+        if kwargs.get("token"):
+            self._token = kwargs.pop("token")
+        self._buffer += markdown_text
+        if len(self._buffer) >= self._buffer_size:
+            return await self._flush_buffer(**kwargs)
+        details = {
+            "buffer_length": len(self._buffer),
+            "buffer_size": self._buffer_size,
+            "channel": self._stream_args.get("channel"),
+            "recipient_team_id": self._stream_args.get("recipient_team_id"),
+            "recipient_user_id": self._stream_args.get("recipient_user_id"),
+            "thread_ts": self._stream_args.get("thread_ts"),
+        }
+        self._logger.debug(f"ChatStream appended to buffer: {json.dumps(details)}")
+        return None
+
+    async def stop(
+        self,
+        *,
+        markdown_text: Optional[str] = None,
+        blocks: Optional[Union[str, Sequence[Union[Dict, Block]]]] = None,
+        metadata: Optional[Union[Dict, Metadata]] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Stop the stream and finalize the message.
+
+        Args:
+            blocks: A list of blocks that will be rendered at the bottom of the finalized message.
+            markdown_text: Accepts message text formatted in markdown. Limit this field to 12,000 characters. This text is
+              what will be appended to the message received so far.
+            metadata: JSON object with event_type and event_payload fields, presented as a URL-encoded string. Metadata you
+              post to Slack is accessible to any app or user who is a member of that workspace.
+            **kwargs: Additional arguments passed to the underlying API calls.
+
+        Returns:
+            AsyncSlackResponse from the chat.stopStream API call.
+
+        Raises:
+            SlackRequestError: If the stream is already completed.
+
+        Example:
+            ```python
+            streamer = client.chat_stream(
+                channel="C0123456789",
+                thread_ts="1700000001.123456",
+                recipient_team_id="T0123456789",
+                recipient_user_id="U0123456789",
+            )
+            streamer.append(markdown_text="**hello wo")
+            streamer.append(markdown_text="rld!**")
+            streamer.stop()
+            ```
+        """
+        if self._state == "completed":
+            raise e.SlackRequestError(f"Cannot stop stream: stream state is {self._state}")
+        if kwargs.get("token"):
+            self._token = kwargs.pop("token")
+        if markdown_text:
+            self._buffer += markdown_text
+        if not self._stream_ts:
+            response = await self._client.chat_startStream(
+                **self._stream_args,
+                token=self._token,
+            )
+            if not response.get("ts"):
+                raise e.SlackRequestError("Failed to stop stream: stream not started")
+            self._stream_ts = str(response["ts"])
+            self._state = "in_progress"
+        response = await self._client.chat_stopStream(
+            token=self._token,
+            channel=self._stream_args["channel"],
+            ts=self._stream_ts,
+            blocks=blocks,
+            markdown_text=self._buffer,
+            metadata=metadata,
+            **kwargs,
+        )
+        self._state = "completed"
+        return response
+
+    async def _flush_buffer(self, **kwargs) -> AsyncSlackResponse:
+        """Flush the internal buffer by making appropriate API calls."""
+        if not self._stream_ts:
+            response = await self._client.chat_startStream(
+                **self._stream_args,
+                token=self._token,
+                **kwargs,
+                markdown_text=self._buffer,
+            )
+            self._stream_ts = response.get("ts")
+            self._state = "in_progress"
+        else:
+            response = await self._client.chat_appendStream(
+                token=self._token,
+                channel=self._stream_args["channel"],
+                ts=self._stream_ts,
+                **kwargs,
+                markdown_text=self._buffer,
+            )
+        self._buffer = ""
+        return response

{slack_sdk-3.36.0.dev4 → slack_sdk-3.36.0.dev6}/slack_sdk/web/async_client.py

@@ -18,6 +18,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 
 import slack_sdk.errors as e
 from slack_sdk.models.views import View
+from slack_sdk.web.async_chat_stream import AsyncChatStream
 
 from ..models.attachments import Attachment
 from ..models.blocks import Block
@@ -2084,7 +2085,8 @@ class AsyncWebClient(AsyncBaseClient):
         kwargs.update(
             {"channel_id": channel_id, "thread_ts": thread_ts, "status": status, "loading_messages": loading_messages}
         )
-        return await self.api_call("assistant.threads.setStatus", params=kwargs)
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("assistant.threads.setStatus", json=kwargs)
 
     async def assistant_threads_setTitle(
         self,
@@ -2882,8 +2884,6 @@ class AsyncWebClient(AsyncBaseClient):
         markdown_text: Optional[str] = None,
         recipient_team_id: Optional[str] = None,
         recipient_user_id: Optional[str] = None,
-        unfurl_links: Optional[bool] = None,
-        unfurl_media: Optional[bool] = None,
         **kwargs,
     ) -> AsyncSlackResponse:
         """Starts a new streaming conversation.
@@ -2896,8 +2896,6 @@ class AsyncWebClient(AsyncBaseClient):
                 "markdown_text": markdown_text,
                 "recipient_team_id": recipient_team_id,
                 "recipient_user_id": recipient_user_id,
-                "unfurl_links": unfurl_links,
-                "unfurl_media": unfurl_media,
             }
         )
         kwargs = _remove_none_values(kwargs)
@@ -2929,6 +2927,69 @@ class AsyncWebClient(AsyncBaseClient):
         kwargs = _remove_none_values(kwargs)
         return await self.api_call("chat.stopStream", json=kwargs)
 
+    async def chat_stream(
+        self,
+        *,
+        buffer_size: int = 256,
+        channel: str,
+        thread_ts: str,
+        recipient_team_id: Optional[str] = None,
+        recipient_user_id: Optional[str] = None,
+        **kwargs,
+    ) -> AsyncChatStream:
+        """Stream markdown text into a conversation.
+
+        This method starts a new chat stream in a coversation that can be appended to. After appending an entire message,
+        the stream can be stopped with concluding arguments such as "blocks" for gathering feedback.
+
+        The following methods are used:
+
+        - chat.startStream: Starts a new streaming conversation.
+          [Reference](https://docs.slack.dev/reference/methods/chat.startStream).
+        - chat.appendStream: Appends text to an existing streaming conversation.
+          [Reference](https://docs.slack.dev/reference/methods/chat.appendStream).
+        - chat.stopStream: Stops a streaming conversation.
+          [Reference](https://docs.slack.dev/reference/methods/chat.stopStream).
+
+        Args:
+            buffer_size: The length of markdown_text to buffer in-memory before calling a stream method. Increasing this
+              value decreases the number of method calls made for the same amount of text, which is useful to avoid rate
+              limits. Default: 256.
+            channel: An encoded ID that represents a channel, private group, or DM.
+            thread_ts: Provide another message's ts value to reply to. Streamed messages should always be replies to a user
+              request.
+            recipient_team_id: The encoded ID of the team the user receiving the streaming text belongs to. Required when
+              streaming to channels.
+            recipient_user_id: The encoded ID of the user to receive the streaming text. Required when streaming to channels.
+            **kwargs: Additional arguments passed to the underlying API calls.
+
+        Returns:
+            ChatStream instance for managing the stream
+
+        Example:
+            ```python
+            streamer = await client.chat_stream(
+                channel="C0123456789",
+                thread_ts="1700000001.123456",
+                recipient_team_id="T0123456789",
+                recipient_user_id="U0123456789",
+            )
+            await streamer.append(markdown_text="**hello wo")
+            await streamer.append(markdown_text="rld!**")
+            await streamer.stop()
+            ```
+        """
+        return AsyncChatStream(
+            self,
+            logger=self._logger,
+            channel=channel,
+            thread_ts=thread_ts,
+            recipient_team_id=recipient_team_id,
+            recipient_user_id=recipient_user_id,
+            buffer_size=buffer_size,
+            **kwargs,
+        )
+
     async def chat_unfurl(
         self,
         *,

slack_sdk-3.36.0.dev6/slack_sdk/web/chat_stream.py

@@ -0,0 +1,202 @@
+import json
+import logging
+from typing import TYPE_CHECKING, Dict, Optional, Sequence, Union
+
+import slack_sdk.errors as e
+from slack_sdk.models.blocks.blocks import Block
+from slack_sdk.models.metadata import Metadata
+from slack_sdk.web.slack_response import SlackResponse
+
+if TYPE_CHECKING:
+    from slack_sdk import WebClient
+
+
+class ChatStream:
+    """A helper class for streaming markdown text into a conversation using the chat streaming APIs.
+
+    This class provides a convenient interface for the chat.startStream, chat.appendStream, and chat.stopStream API
+    methods, with automatic buffering and state management.
+    """
+
+    def __init__(
+        self,
+        client: "WebClient",
+        *,
+        channel: str,
+        logger: logging.Logger,
+        thread_ts: str,
+        buffer_size: int,
+        recipient_team_id: Optional[str] = None,
+        recipient_user_id: Optional[str] = None,
+        **kwargs,
+    ):
+        """Initialize a new ChatStream instance.
+
+        The __init__ method creates a unique ChatStream instance that keeps track of one chat stream.
+
+        Args:
+            client: The WebClient instance to use for API calls.
+            channel: An encoded ID that represents a channel, private group, or DM.
+            logger: A logging channel for outputs.
+            thread_ts: Provide another message's ts value to reply to. Streamed messages should always be replies to a user
+              request.
+            recipient_team_id: The encoded ID of the team the user receiving the streaming text belongs to. Required when
+              streaming to channels.
+            recipient_user_id: The encoded ID of the user to receive the streaming text. Required when streaming to channels.
+            buffer_size: The length of markdown_text to buffer in-memory before calling a method. Increasing this value
+              decreases the number of method calls made for the same amount of text, which is useful to avoid rate limits.
+            **kwargs: Additional arguments passed to the underlying API calls.
+        """
+        self._client = client
+        self._logger = logger
+        self._token: Optional[str] = kwargs.pop("token", None)
+        self._stream_args = {
+            "channel": channel,
+            "thread_ts": thread_ts,
+            "recipient_team_id": recipient_team_id,
+            "recipient_user_id": recipient_user_id,
+            **kwargs,
+        }
+        self._buffer = ""
+        self._state = "starting"
+        self._stream_ts: Optional[str] = None
+        self._buffer_size = buffer_size
+
+    def append(
+        self,
+        *,
+        markdown_text: str,
+        **kwargs,
+    ) -> Optional[SlackResponse]:
+        """Append to the stream.
+
+        The "append" method appends to the chat stream being used. This method can be called multiple times. After the stream
+        is stopped this method cannot be called.
+
+        Args:
+            markdown_text: Accepts message text formatted in markdown. Limit this field to 12,000 characters. This text is
+              what will be appended to the message received so far.
+            **kwargs: Additional arguments passed to the underlying API calls.
+
+        Returns:
+            SlackResponse if the buffer was flushed, None if buffering.
+
+        Raises:
+            SlackRequestError: If the stream is already completed.
+
+        Example:
+            ```python
+            streamer = client.chat_stream(
+                channel="C0123456789",
+                thread_ts="1700000001.123456",
+                recipient_team_id="T0123456789",
+                recipient_user_id="U0123456789",
+            )
+            streamer.append(markdown_text="**hello wo")
+            streamer.append(markdown_text="rld!**")
+            streamer.stop()
+            ```
+        """
+        if self._state == "completed":
+            raise e.SlackRequestError(f"Cannot append to stream: stream state is {self._state}")
+        if kwargs.get("token"):
+            self._token = kwargs.pop("token")
+        self._buffer += markdown_text
+        if len(self._buffer) >= self._buffer_size:
+            return self._flush_buffer(**kwargs)
+        details = {
+            "buffer_length": len(self._buffer),
+            "buffer_size": self._buffer_size,
+            "channel": self._stream_args.get("channel"),
+            "recipient_team_id": self._stream_args.get("recipient_team_id"),
+            "recipient_user_id": self._stream_args.get("recipient_user_id"),
+            "thread_ts": self._stream_args.get("thread_ts"),
+        }
+        self._logger.debug(f"ChatStream appended to buffer: {json.dumps(details)}")
+        return None
+
+    def stop(
+        self,
+        *,
+        markdown_text: Optional[str] = None,
+        blocks: Optional[Union[str, Sequence[Union[Dict, Block]]]] = None,
+        metadata: Optional[Union[Dict, Metadata]] = None,
+        **kwargs,
+    ) -> SlackResponse:
+        """Stop the stream and finalize the message.
+
+        Args:
+            blocks: A list of blocks that will be rendered at the bottom of the finalized message.
+            markdown_text: Accepts message text formatted in markdown. Limit this field to 12,000 characters. This text is
+              what will be appended to the message received so far.
+            metadata: JSON object with event_type and event_payload fields, presented as a URL-encoded string. Metadata you
+              post to Slack is accessible to any app or user who is a member of that workspace.
+            **kwargs: Additional arguments passed to the underlying API calls.
+
+        Returns:
+            SlackResponse from the chat.stopStream API call.
+
+        Raises:
+            SlackRequestError: If the stream is already completed.
+
+        Example:
+            ```python
+            streamer = client.chat_stream(
+                channel="C0123456789",
+                thread_ts="1700000001.123456",
+                recipient_team_id="T0123456789",
+                recipient_user_id="U0123456789",
+            )
+            streamer.append(markdown_text="**hello wo")
+            streamer.append(markdown_text="rld!**")
+            streamer.stop()
+            ```
+        """
+        if self._state == "completed":
+            raise e.SlackRequestError(f"Cannot stop stream: stream state is {self._state}")
+        if kwargs.get("token"):
+            self._token = kwargs.pop("token")
+        if markdown_text:
+            self._buffer += markdown_text
+        if not self._stream_ts:
+            response = self._client.chat_startStream(
+                **self._stream_args,
+                token=self._token,
+            )
+            if not response.get("ts"):
+                raise e.SlackRequestError("Failed to stop stream: stream not started")
+            self._stream_ts = str(response["ts"])
+            self._state = "in_progress"
+        response = self._client.chat_stopStream(
+            token=self._token,
+            channel=self._stream_args["channel"],
+            ts=self._stream_ts,
+            blocks=blocks,
+            markdown_text=self._buffer,
+            metadata=metadata,
+            **kwargs,
+        )
+        self._state = "completed"
+        return response
+
+    def _flush_buffer(self, **kwargs) -> SlackResponse:
+        """Flush the internal buffer by making appropriate API calls."""
+        if not self._stream_ts:
+            response = self._client.chat_startStream(
+                **self._stream_args,
+                token=self._token,
+                **kwargs,
+                markdown_text=self._buffer,
+            )
+            self._stream_ts = response.get("ts")
+            self._state = "in_progress"
+        else:
+            response = self._client.chat_appendStream(
+                token=self._token,
+                channel=self._stream_args["channel"],
+                ts=self._stream_ts,
+                **kwargs,
+                markdown_text=self._buffer,
+            )
+        self._buffer = ""
+        return response

{slack_sdk-3.36.0.dev4 → slack_sdk-3.36.0.dev6}/slack_sdk/web/client.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 
 import slack_sdk.errors as e
 from slack_sdk.models.views import View
+from slack_sdk.web.chat_stream import ChatStream
 
 from ..models.attachments import Attachment
 from ..models.blocks import Block
@@ -2074,7 +2075,8 @@ class WebClient(BaseClient):
         kwargs.update(
             {"channel_id": channel_id, "thread_ts": thread_ts, "status": status, "loading_messages": loading_messages}
         )
-        return self.api_call("assistant.threads.setStatus", params=kwargs)
+        kwargs = _remove_none_values(kwargs)
+        return self.api_call("assistant.threads.setStatus", json=kwargs)
 
     def assistant_threads_setTitle(
         self,
@@ -2872,8 +2874,6 @@ class WebClient(BaseClient):
         markdown_text: Optional[str] = None,
         recipient_team_id: Optional[str] = None,
         recipient_user_id: Optional[str] = None,
-        unfurl_links: Optional[bool] = None,
-        unfurl_media: Optional[bool] = None,
         **kwargs,
     ) -> SlackResponse:
         """Starts a new streaming conversation.
@@ -2886,8 +2886,6 @@ class WebClient(BaseClient):
                 "markdown_text": markdown_text,
                 "recipient_team_id": recipient_team_id,
                 "recipient_user_id": recipient_user_id,
-                "unfurl_links": unfurl_links,
-                "unfurl_media": unfurl_media,
             }
         )
         kwargs = _remove_none_values(kwargs)
@@ -2919,6 +2917,69 @@ class WebClient(BaseClient):
         kwargs = _remove_none_values(kwargs)
         return self.api_call("chat.stopStream", json=kwargs)
 
+    def chat_stream(
+        self,
+        *,
+        buffer_size: int = 256,
+        channel: str,
+        thread_ts: str,
+        recipient_team_id: Optional[str] = None,
+        recipient_user_id: Optional[str] = None,
+        **kwargs,
+    ) -> ChatStream:
+        """Stream markdown text into a conversation.
+
+        This method starts a new chat stream in a coversation that can be appended to. After appending an entire message,
+        the stream can be stopped with concluding arguments such as "blocks" for gathering feedback.
+
+        The following methods are used:
+
+        - chat.startStream: Starts a new streaming conversation.
+          [Reference](https://docs.slack.dev/reference/methods/chat.startStream).
+        - chat.appendStream: Appends text to an existing streaming conversation.
+          [Reference](https://docs.slack.dev/reference/methods/chat.appendStream).
+        - chat.stopStream: Stops a streaming conversation.
+          [Reference](https://docs.slack.dev/reference/methods/chat.stopStream).
+
+        Args:
+            buffer_size: The length of markdown_text to buffer in-memory before calling a stream method. Increasing this
+              value decreases the number of method calls made for the same amount of text, which is useful to avoid rate
+              limits. Default: 256.
+            channel: An encoded ID that represents a channel, private group, or DM.
+            thread_ts: Provide another message's ts value to reply to. Streamed messages should always be replies to a user
+              request.
+            recipient_team_id: The encoded ID of the team the user receiving the streaming text belongs to. Required when
+              streaming to channels.
+            recipient_user_id: The encoded ID of the user to receive the streaming text. Required when streaming to channels.
+            **kwargs: Additional arguments passed to the underlying API calls.
+
+        Returns:
+            ChatStream instance for managing the stream
+
+        Example:
+            ```python
+            streamer = client.chat_stream(
+                channel="C0123456789",
+                thread_ts="1700000001.123456",
+                recipient_team_id="T0123456789",
+                recipient_user_id="U0123456789",
+            )
+            streamer.append(markdown_text="**hello wo")
+            streamer.append(markdown_text="rld!**")
+            streamer.stop()
+            ```
+        """
+        return ChatStream(
+            self,
+            logger=self._logger,
+            channel=channel,
+            thread_ts=thread_ts,
+            recipient_team_id=recipient_team_id,
+            recipient_user_id=recipient_user_id,
+            buffer_size=buffer_size,
+            **kwargs,
+        )
+
     def chat_unfurl(
         self,
         *,

{slack_sdk-3.36.0.dev4 → slack_sdk-3.36.0.dev6}/slack_sdk/web/legacy_client.py

@@ -2086,7 +2086,8 @@ class LegacyWebClient(LegacyBaseClient):
         kwargs.update(
             {"channel_id": channel_id, "thread_ts": thread_ts, "status": status, "loading_messages": loading_messages}
         )
-        return self.api_call("assistant.threads.setStatus", params=kwargs)
+        kwargs = _remove_none_values(kwargs)
+        return self.api_call("assistant.threads.setStatus", json=kwargs)
 
     def assistant_threads_setTitle(
         self,
@@ -2884,8 +2885,6 @@ class LegacyWebClient(LegacyBaseClient):
         markdown_text: Optional[str] = None,
         recipient_team_id: Optional[str] = None,
         recipient_user_id: Optional[str] = None,
-        unfurl_links: Optional[bool] = None,
-        unfurl_media: Optional[bool] = None,
         **kwargs,
     ) -> Union[Future, SlackResponse]:
         """Starts a new streaming conversation.
@@ -2898,8 +2897,6 @@ class LegacyWebClient(LegacyBaseClient):
                 "markdown_text": markdown_text,
                 "recipient_team_id": recipient_team_id,
                 "recipient_user_id": recipient_user_id,
-                "unfurl_links": unfurl_links,
-                "unfurl_media": unfurl_media,
             }
         )
         kwargs = _remove_none_values(kwargs)

{slack_sdk-3.36.0.dev4 → slack_sdk-3.36.0.dev6/slack_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack_sdk
-Version: 3.36.0.dev4
+Version: 3.36.0.dev6
 Summary: The Slack API Platform SDK for Python
 Home-page: https://github.com/slackapi/python-slack-sdk
 Author: Slack Technologies, LLC

{slack_sdk-3.36.0.dev4 → slack_sdk-3.36.0.dev6}/slack_sdk.egg-info/SOURCES.txt

@@ -144,6 +144,7 @@ slack_sdk/socket_mode/websocket_client/__init__.py
 slack_sdk/socket_mode/websockets/__init__.py
 slack_sdk/web/__init__.py
 slack_sdk/web/async_base_client.py
+slack_sdk/web/async_chat_stream.py
 slack_sdk/web/async_client.py
 slack_sdk/web/async_internal_utils.py
 slack_sdk/web/async_slack_response.py