feat(web-api): add slackLists methods

integration_tests/web/test_slack_lists.py

@@ -0,0 +1,88 @@
+import logging
+import os
+import unittest
+
+from integration_tests.env_variable_names import (
+    SLACK_SDK_TEST_BOT_TOKEN,
+)
+from integration_tests.helpers import async_test
+from slack_sdk.web import WebClient
+from slack_sdk.web.async_client import AsyncWebClient
+from slack_sdk.models.blocks import RichTextBlock
+from slack_sdk.models.blocks.block_elements import RichTextSection, RichTextText
+
+
+class TestSlackLists(unittest.TestCase):
+    """Runs integration tests with real Slack API testing the slackLists.* APIs"""
+
+    def setUp(self):
+        if not hasattr(self, "logger"):
+            self.logger = logging.getLogger(__name__)
+            self.bot_token = os.environ[SLACK_SDK_TEST_BOT_TOKEN]
+            self.async_client: AsyncWebClient = AsyncWebClient(token=self.bot_token)
+            self.sync_client: WebClient = WebClient(token=self.bot_token)
+
+    def tearDown(self):
+        pass
+
+    def test_create_list_with_dicts(self):
+        """Test creating a list with description_blocks as dicts"""
+        client = self.sync_client
+
+        create_response = client.slackLists_create(
+            name="Test Sales Pipeline",
+            description_blocks=[
+                {
+                    "type": "rich_text",
+                    "elements": [
+                        {
+                            "type": "rich_text_section",
+                            "elements": [{"type": "text", "text": "This is a test list for integration testing"}],
+                        }
+                    ],
+                }
+            ],
+            schema=[
+                {"key": "deal_name", "name": "Deal Name", "type": "text", "is_primary_column": True},
+                {"key": "amount", "name": "Amount", "type": "number", "options": {"format": "currency", "precision": 2}},
+            ],
+        )
+
+        self.assertIsNotNone(create_response)
+        self.assertTrue(create_response["ok"])
+        self.assertIn("list", create_response)
+        list_id = create_response["list"]["id"]
+        self.logger.info(f"✓ Created list with ID: {list_id}")
+
+    def test_create_list_with_rich_text_blocks(self):
+        """Test creating a list with RichTextBlock objects"""
+        client = self.sync_client
+
+        create_response = client.slackLists_create(
+            name="Test List with Rich Text Blocks",
+            description_blocks=[
+                RichTextBlock(
+                    elements=[RichTextSection(elements=[RichTextText(text="Created with RichTextBlock objects!")])]
+                )
+            ],
+            schema=[{"key": "task_name", "name": "Task", "type": "text", "is_primary_column": True}],
+        )
+
+        self.assertIsNotNone(create_response)
+        self.assertTrue(create_response["ok"])
+        list_id = create_response["list"]["id"]
+        self.logger.info(f"✓ Created list with RichTextBlocks, ID: {list_id}")
+
+    @async_test
+    async def test_create_list_async(self):
+        """Test creating a list with async client"""
+        client = self.async_client
+
+        create_response = await client.slackLists_create(
+            name="Async Test List", schema=[{"key": "item_name", "name": "Item", "type": "text", "is_primary_column": True}]
+        )
+
+        self.assertIsNotNone(create_response)
+        self.assertTrue(create_response["ok"])
+        list_id = create_response["list"]["id"]
+        self.logger.info(f"✓ Created list asynchronously, ID: {list_id}")

slack_sdk/web/async_client.py

@@ -21,7 +21,7 @@
 from slack_sdk.web.async_chat_stream import AsyncChatStream
 
 from ..models.attachments import Attachment
-from ..models.blocks import Block
+from ..models.blocks import Block, RichTextBlock
 from ..models.metadata import Metadata, EntityMetadata, EventAndEntityMetadata
 from .async_base_client import AsyncBaseClient, AsyncSlackResponse
 from .internal_utils import (
@@ -4925,6 +4925,249 @@ async def search_messages(
         )
         return await self.api_call("search.messages", http_verb="GET", params=kwargs)
 
+    async def slackLists_access_delete(
+        self,
+        *,
+        list_id: str,
+        channel_ids: Optional[List[str]] = None,
+        user_ids: Optional[List[str]] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Revoke access to a List for specified entities.
+        https://docs.slack.dev/reference/methods/slackLists.access.delete
+        """
+        kwargs.update({"list_id": list_id, "channel_ids": channel_ids, "user_ids": user_ids})
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.access.delete", json=kwargs)
+
+    async def slackLists_access_set(
+        self,
+        *,
+        list_id: str,
+        access_level: str,
+        channel_ids: Optional[List[str]] = None,
+        user_ids: Optional[List[str]] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Set the access level to a List for specified entities.
+        https://docs.slack.dev/reference/methods/slackLists.access.set
+        """
+        kwargs.update({"list_id": list_id, "access_level": access_level, "channel_ids": channel_ids, "user_ids": user_ids})
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.access.set", json=kwargs)
+
+    async def slackLists_create(
+        self,
+        *,
+        name: str,
+        description_blocks: Optional[Union[str, Sequence[Union[Dict, RichTextBlock]]]] = None,
+        schema: Optional[List[Dict[str, Any]]] = None,
+        copy_from_list_id: Optional[str] = None,
+        include_copied_list_records: Optional[bool] = None,
+        todo_mode: Optional[bool] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Creates a List.
+        https://docs.slack.dev/reference/methods/slackLists.create
+        """
+        kwargs.update(
+            {
+                "name": name,
+                "description_blocks": description_blocks,
+                "schema": schema,
+                "copy_from_list_id": copy_from_list_id,
+                "include_copied_list_records": include_copied_list_records,
+                "todo_mode": todo_mode,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.create", json=kwargs)
+
+    async def slackLists_download_get(
+        self,
+        *,
+        list_id: str,
+        job_id: str,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Retrieve List download URL from an export job to download List contents.
+        https://docs.slack.dev/reference/methods/slackLists.download.get
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "job_id": job_id,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.download.get", json=kwargs)
+
+    async def slackLists_download_start(
+        self,
+        *,
+        list_id: str,
+        include_archived: Optional[bool] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Initiate a job to export List contents.
+        https://docs.slack.dev/reference/methods/slackLists.download.start
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "include_archived": include_archived,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.download.start", json=kwargs)
+
+    async def slackLists_items_create(
+        self,
+        *,
+        list_id: str,
+        duplicated_item_id: Optional[str] = None,
+        parent_item_id: Optional[str] = None,
+        initial_fields: Optional[List[Dict[str, Any]]] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Add a new item to an existing List.
+        https://docs.slack.dev/reference/methods/slackLists.items.create
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "duplicated_item_id": duplicated_item_id,
+                "parent_item_id": parent_item_id,
+                "initial_fields": initial_fields,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.items.create", json=kwargs)
+
+    async def slackLists_items_delete(
+        self,
+        *,
+        list_id: str,
+        id: str,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Deletes an item from an existing List.
+        https://docs.slack.dev/reference/methods/slackLists.items.delete
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "id": id,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.items.delete", json=kwargs)
+
+    async def slackLists_items_deleteMultiple(
+        self,
+        *,
+        list_id: str,
+        ids: List[str],
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Deletes multiple items from an existing List.
+        https://docs.slack.dev/reference/methods/slackLists.items.deleteMultiple
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "ids": ids,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.items.deleteMultiple", json=kwargs)
+
+    async def slackLists_items_info(
+        self,
+        *,
+        list_id: str,
+        id: str,
+        include_is_subscribed: Optional[bool] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Get a row from a List.
+        https://docs.slack.dev/reference/methods/slackLists.items.info
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "id": id,
+                "include_is_subscribed": include_is_subscribed,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.items.info", json=kwargs)
+
+    async def slackLists_items_list(
+        self,
+        *,
+        list_id: str,
+        limit: Optional[int] = None,
+        cursor: Optional[str] = None,
+        archived: Optional[bool] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Get records from a List.
+        https://docs.slack.dev/reference/methods/slackLists.items.list
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "limit": limit,
+                "cursor": cursor,
+                "archived": archived,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.items.list", json=kwargs)
+
+    async def slackLists_items_update(
+        self,
+        *,
+        list_id: str,
+        cells: List[Dict[str, Any]],
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Updates cells in a List.
+        https://docs.slack.dev/reference/methods/slackLists.items.update
+        """
+        kwargs.update(
+            {
+                "list_id": list_id,
+                "cells": cells,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.items.update", json=kwargs)
+
+    async def slackLists_update(
+        self,
+        *,
+        id: str,
+        name: Optional[str] = None,
+        description_blocks: Optional[Union[str, Sequence[Union[Dict, RichTextBlock]]]] = None,
+        todo_mode: Optional[bool] = None,
+        **kwargs,
+    ) -> AsyncSlackResponse:
+        """Update a List.
+        https://docs.slack.dev/reference/methods/slackLists.update
+        """
+        kwargs.update(
+            {
+                "id": id,
+                "name": name,
+                "description_blocks": description_blocks,
+                "todo_mode": todo_mode,
+            }
+        )
+        kwargs = _remove_none_values(kwargs)
+        return await self.api_call("slackLists.update", json=kwargs)
+
     async def stars_add(
         self,
         *,