Python Slack SDK

https://docs.slack.dev/tools/python-slack-sdk/
Admin
A Python SDK for building Slack applications with support for Web API, Webhooks, OAuth, Socket Mode,...
Tokens:866,472
Snippets:4,805
Trust Score:10
Update:21 hours ago
Show doc for...
Tokens:
Raw
### Clone and install from source

Source: https://docs.slack.dev/tools/python-slack-sdk/installation/

Clone the repository, create a virtual environment, and install the SDK in editable mode.

```bash
git clone https://github.com/slackapi/python-slack-sdk.git
cd python-slack-sdk
python3 -m venv .venv
source .venv/bin/activate
pip install -U pip
pip install -e .  # install the SDK project into the virtual env
```

--------------------------------

### InstallationStore.__init__

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/index.html

Constructor for the InstallationStore class. Initializes an installation object with all relevant fields for OAuth installation data.

```APIDOC
## InstallationStore.__init__

### Description
Constructor for the InstallationStore class. Initializes an installation object with all relevant fields for OAuth installation data.

### Method
Constructor

### Signature
```python
def __init__(
    self,
    *,
    app_id: Optional[str] = None,
    enterprise_id: Optional[str] = None,
    enterprise_name: Optional[str] = None,
    enterprise_url: Optional[str] = None,
    team_id: Optional[str] = None,
    team_name: Optional[str] = None,
    bot_token: Optional[str] = None,
    bot_id: Optional[str] = None,
    bot_user_id: Optional[str] = None,
    bot_scopes: Union[str, Sequence[str]] = "",
    bot_refresh_token: Optional[str] = None,
    bot_token_expires_in: Optional[int] = None,
    bot_token_expires_at: Optional[Union[int, datetime, str]] = None,
    user_id: str,
    user_token: Optional[str] = None,
    user_scopes: Union[str, Sequence[str]] = "",
    user_refresh_token: Optional[str] = None,
    user_token_expires_in: Optional[int] = None,
    user_token_expires_at: Optional[Union[int, datetime, str]] = None,
    incoming_webhook_url: Optional[str] = None,
    incoming_webhook_channel: Optional[str] = None,
    incoming_webhook_channel_id: Optional[str] = None,
    incoming_webhook_configuration_url: Optional[str] = None,
    is_enterprise_install: Optional[bool] = False,
    token_type: Optional[str] = None,
    installed_at: Optional[Union[float, datetime, str]] = None,
    custom_values: Optional[Dict[str, Any]] = None,
):
```

### Parameters
#### Keyword Arguments (all keyword-only)
- **app_id** (Optional[str]) - Optional - The application ID.
- **enterprise_id** (Optional[str]) - Optional - The enterprise ID for org/workspace.
- **enterprise_name** (Optional[str]) - Optional - The enterprise name.
- **enterprise_url** (Optional[str]) - Optional - The enterprise URL.
- **team_id** (Optional[str]) - Optional - The team ID.
- **team_name** (Optional[str]) - Optional - The team name.
- **bot_token** (Optional[str]) - Optional - The bot token.
- **bot_id** (Optional[str]) - Optional - The bot ID.
- **bot_user_id** (Optional[str]) - Optional - The bot user ID.
- **bot_scopes** (Union[str, Sequence[str]]) - Optional - The bot scopes. If a string is provided, it is split by commas into a list.
- **bot_refresh_token** (Optional[str]) - Optional - The bot refresh token (only when token rotation is enabled).
- **bot_token_expires_in** (Optional[int]) - Optional - The bot token expiration time in seconds (only when token rotation is enabled).
- **bot_token_expires_at** (Optional[Union[int, datetime, str]]) - Optional - The bot token expiration timestamp (only when token rotation is enabled).
- **user_id** (str) - Required - The installer user ID.
- **user_token** (Optional[str]) - Optional - The user token.
- **user_scopes** (Union[str, Sequence[str]]) - Optional - The user scopes. If a string is provided, it is split by commas into a list.
- **user_refresh_token** (Optional[str]) - Optional - The user refresh token (only when token rotation is enabled).
- **user_token_expires_in** (Optional[int]) - Optional - The user token expiration time in seconds (only when token rotation is enabled).
- **user_token_expires_at** (Optional[Union[int, datetime, str]]) - Optional - The user token expiration timestamp (only when token rotation is enabled).
- **incoming_webhook_url** (Optional[str]) - Optional - The incoming webhook URL.
- **incoming_webhook_channel** (Optional[str]) - Optional - The incoming webhook channel.
- **incoming_webhook_channel_id** (Optional[str]) - Optional - The incoming webhook channel ID.
- **incoming_webhook_configuration_url** (Optional[str]) - Optional - The incoming webhook configuration URL.
- **is_enterprise_install** (Optional[bool]) - Optional - Whether this is an enterprise install. Defaults to False.
- **token_type** (Optional[str]) - Optional - The token type.
- **installed_at** (Optional[Union[float, datetime, str]]) - Optional - The installation timestamp. If not provided, the current time is used.
- **custom_values** (Optional[Dict[str, Any]]) - Optional - Custom values associated with the installation.

### Behavior
- If `bot_scopes` is a string, it is split by commas into a list; otherwise, it is used as-is.
- If `bot_token_expires_at` is provided, it is converted to an integer timestamp; otherwise, if `bot_token_expires_in` is provided, `bot_token_expires_at` is set to `int(time()) + bot_token_expires_in`; otherwise, it is set to None.
- If `user_scopes` is a string, it is split by commas into a list; otherwise, it is used as-is.
- If `user_token_expires_at` is provided, it is converted to an integer timestamp; otherwise, if `user_token_expires_in` is provided, `user_token_expires_at` is set to `int(time()) + user_token_expires_in`; otherwise, it is set to None.
- If `installed_at` is None, it is set to the current timestamp; otherwise, it is converted to a float.
- `custom_values` defaults to an empty dictionary if not provided.

### Attributes Set
- `self.app_id`
- `self.enterprise_id`
- `self.enterprise_name`
- `self.enterprise_url`
- `self.team_id`
- `self.team_name`
- `self.bot_token`
- `self.bot_id`
- `self.bot_user_id`
- `self.bot_scopes`
- `self.bot_refresh_token`
- `self.bot_token_expires_at`
- `self.user_id`
- `self.user_token`
- `self.user_scopes`
- `self.user_refresh_token`
- `self.user_token_expires_at`
- `self.incoming_webhook_url`
- `self.incoming_webhook_channel`
- `self.incoming_webhook_channel_id`
- `self.incoming_webhook_configuration_url`
- `self.is_enterprise_install`
- `self.token_type`
- `self.installed_at`
- `self.custom_values`
```

--------------------------------

### Find installation

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/index.html

Synchronously finds and returns the installation data. If a user installation is requested, it may also retrieve the latest bot token to update the installation object.

```python
def find_installation(
    self,
    *,
    enterprise_id: Optional[str],
    team_id: Optional[str],
    user_id: Optional[str] = None,
    is_enterprise_install: Optional[bool] = False,
) -> Optional[Installation]:
    none = "none"
    e_id = enterprise_id or none
    t_id = team_id or none
    if is_enterprise_install:
        t_id = none
    installation_filepath = f"{self.base_dir}/{e_id}-{t_id}/installer-latest"
    if user_id is not None:
        installation_filepath = f"{self.base_dir}/{e_id}-{t_id}/installer-{user_id}-latest"

    try:
        installation: Optional[Installation] = None
        with open(installation_filepath) as f:
            data = json.loads(f.read())
            installation = Installation(**data)

        has_user_installation = user_id is not None and installation is not None
        no_bot_token_installation = installation is not None and installation.bot_token is None
        should_find_bot_installation = has_user_installation or no_bot_token_installation
        if should_find_bot_installation:
            # Retrieve the latest bot token, just in case
            # See also: https://github.com/slackapi/bolt-python/issues/664
            latest_bot_installation = self.find_bot(
                enterprise_id=enterprise_id,
                team_id=team_id,
                is_enterprise_install=is_enterprise_install,
            )
            if latest_bot_installation is not None and installation.bot_token != latest_bot_installation.bot_token:
                # NOTE: this logic is based on the assumption that every single installation has bot scopes
                # If you need to installation patterns without bot scopes in the same S3 bucket,
                # please fork this code and implement your own logic.
                installation.bot_id = latest_bot_installation.bot_id
                installation.bot_user_id = latest_bot_installation.bot_user_id
                installation.bot_token = latest_bot_installation.bot_token
                installation.bot_scopes = latest_bot_installation.bot_scopes
                installation.bot_refresh_token = latest_bot_installation.bot_refresh_token
                installation.bot_token_expires_at = latest_bot_installation.bot_token_expires_at

        return installation

    except FileNotFoundError as e:
        message = f"Installation data missing for enterprise: {e_id}, team: {t_id}: {e}"
        self.logger.debug(message)
        return None
```

--------------------------------

### async_find_installation method

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/sqlalchemy/index.html

Retrieves the latest installation for a given client, enterprise, team, and optionally user. If is_enterprise_install or team_id is None, team_id is set to None. If a user_id is provided, the query filters by user_id. After fetching the installation, if it is a user installation or lacks a bot token, it fetches the latest bot installation and updates the installation's bot fields if the bot token differs.

```python
    async def async_find_installation(
        self,
        *,
        enterprise_id: Optional[str],
        team_id: Optional[str],
        user_id: Optional[str] = None,
        is_enterprise_install: Optional[bool] = False,
    ) -> Optional[Installation]:
        if is_enterprise_install or team_id is None:
            team_id = None

        c = self.installations.c
        where_clause = and_(
            c.client_id == self.client_id,
            c.enterprise_id == enterprise_id,
            c.team_id == team_id,
        )
        if user_id is not None:
            where_clause = and_(
                c.client_id == self.client_id,
                c.enterprise_id == enterprise_id,
                c.team_id == team_id,
                c.user_id == user_id,
            )

        query = self.installations.select().where(where_clause).order_by(desc(c.installed_at)).limit(1)

        installation: Optional[Installation] = None
        async with self.engine.connect() as conn:
            result: object = await conn.execute(query)
            for row in result.mappings():  # type: ignore[attr-defined]
                installation = SQLAlchemyInstallationStore.build_installation_entity(row)

        has_user_installation = user_id is not None and installation is not None
        no_bot_token_installation = installation is not None and installation.bot_token is None
        should_find_bot_installation = has_user_installation or no_bot_token_installation
        if should_find_bot_installation:
            # Retrieve the latest bot token, just in case
            # See also: https://github.com/slackapi/bolt-python/issues/664
            latest_bot_installation = await self.async_find_bot(
                enterprise_id=enterprise_id,
                team_id=team_id,
                is_enterprise_install=is_enterprise_install,
            )
            if (
                latest_bot_installation is not None
                and installation is not None
                and installation.bot_token != latest_bot_installation.bot_token
            ):
                installation.bot_id = latest_bot_installation.bot_id
                installation.bot_user_id = latest_bot_installation.bot_user_id
                installation.bot_token = latest_bot_installation.bot_token
                installation.bot_scopes = latest_bot_installation.bot_scopes
                installation.bot_refresh_token = latest_bot_installation.bot_refresh_token
                installation.bot_token_expires_at = latest_bot_installation.bot_token_expires_at

        return installation
```

--------------------------------

### Async find installation

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/index.html

Asynchronous wrapper for find_installation that returns the installation data.

```python
async def async_find_installation(
    self,
    *,
    enterprise_id: Optional[str],
    team_id: Optional[str],
    user_id: Optional[str] = None,
    is_enterprise_install: Optional[bool] = False,
) -> Optional[Installation]:
    return self.find_installation(
        enterprise_id=enterprise_id,
        team_id=team_id,
        user_id=user_id,
        is_enterprise_install=is_enterprise_install,
    )
```

--------------------------------

### find_installation method

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/amazon_s3/index.html

Synchronous method that retrieves installation data from S3. It constructs a key based on user_id, fetches the object, and returns an Installation instance. If a user installation is found but lacks a bot token, it fetches the latest bot installation and updates the bot fields. Returns None on failure.

```python
    def find_installation(
        self,
        *,
        enterprise_id: Optional[str],
        team_id: Optional[str],
        user_id: Optional[str] = None,
        is_enterprise_install: Optional[bool] = False,
    ) -> Optional[Installation]:
        none = "none"
        e_id = enterprise_id or none
        t_id = team_id or none
        if is_enterprise_install:
            t_id = none
        workspace_path = f"{self.client_id}/{e_id}-{t_id}"
        try:
            key = f"{workspace_path}/installer-{user_id}-latest" if user_id else f"{workspace_path}/installer-latest"
            fetch_response = self.s3_client.get_object(
                Bucket=self.bucket_name,
                Key=key,
            )
            self.logger.debug(f"S3 get_object response: {fetch_response}")
            body = fetch_response["Body"].read().decode("utf-8")
            data = json.loads(body)
            installation = Installation(**data)

            has_user_installation = user_id is not None and installation is not None
            no_bot_token_installation = installation is not None and installation.bot_token is None
            should_find_bot_installation = has_user_installation or no_bot_token_installation
            if should_find_bot_installation:
                # Retrieve the latest bot token, just in case
                # See also: https://github.com/slackapi/bolt-python/issues/664
                latest_bot_installation = self.find_bot(
                    enterprise_id=enterprise_id,
                    team_id=team_id,
                    is_enterprise_install=is_enterprise_install,
                )
                if latest_bot_installation is not None and installation.bot_token != latest_bot_installation.bot_token:
                    # NOTE: this logic is based on the assumption that every single installation has bot scopes
                    # If you need to installation patterns without bot scopes in the same S3 bucket,
                    # please fork this code and implement your own logic.
                    installation.bot_id = latest_bot_installation.bot_id
                    installation.bot_user_id = latest_bot_installation.bot_user_id
                    installation.bot_token = latest_bot_installation.bot_token
                    installation.bot_scopes = latest_bot_installation.bot_scopes
                    installation.bot_refresh_token = latest_bot_installation.bot_refresh_token
                    installation.bot_token_expires_at = latest_bot_installation.bot_token_expires_at

            return installation

        except Exception as e:
            message = f"Failed to find an installation data for enterprise: {e_id}, team: {t_id}: {e}"
            self.logger.warning(message)
            return None
```

--------------------------------

### class Installation

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/index.html

The Installation class represents an OAuth installation of a Slack app. It stores bot and user tokens, scopes, enterprise/team identifiers, and incoming webhook details.

```APIDOC
## class Installation

### Description
Represents an OAuth installation of a Slack app, including bot and user tokens, scopes, and webhook details.

### Constructor Parameters
- **app_id** (str | None) - Optional - The Slack app ID.
- **enterprise_id** (str | None) - Optional - The enterprise ID for enterprise installs.
- **enterprise_name** (str | None) - Optional - The enterprise name.
- **enterprise_url** (str | None) - Optional - The enterprise URL.
- **team_id** (str | None) - Optional - The team ID.
- **team_name** (str | None) - Optional - The team name.
- **bot_token** (str | None) - Optional - The bot user token.
- **bot_id** (str | None) - Optional - The bot ID.
- **bot_user_id** (str | None) - Optional - The bot user ID.
- **bot_scopes** (str | Sequence[str]) - Optional - Scopes granted to the bot (default: '').
- **bot_refresh_token** (str | None) - Optional - Bot refresh token (only when token rotation is enabled).
- **bot_token_expires_in** (int | None) - Optional - Bot token expiration time in seconds.
- **bot_token_expires_at** (int | datetime.datetime | str | None) - Optional - Bot token expiration timestamp (Unix time in seconds).
- **user_id** (str) - Required - The user ID.
- **user_token** (str | None) - Optional - The user token.
- **user_scopes** (str | Sequence[str]) - Optional - Scopes granted to the user (default: '').
- **user_refresh_token** (str | None) - Optional - User refresh token (only when token rotation is enabled).
- **user_token_expires_in** (int | None) - Optional - User token expiration time in seconds.
- **user_token_expires_at** (int | datetime.datetime | str | None) - Optional - User token expiration timestamp (Unix time in seconds).
- **incoming_webhook_url** (str | None) - Optional - The incoming webhook URL.
- **incoming_webhook_channel** (str | None) - Optional - The incoming webhook channel.
- **incoming_webhook_channel_id** (str | None) - Optional - The incoming webhook channel ID.
- **incoming_webhook_configuration_url** (str | None) - Optional - The incoming webhook configuration URL.
- **is_enterprise_install** (bool | None) - Optional - Whether this is an enterprise install (default: False).
- **token_type** (str | None) - Optional - The token type.
- **installed_at** (float | datetime.datetime | str | None) - Optional - The installation timestamp.
- **custom_values** (Dict[str, Any] | None) - Optional - Custom key-value pairs.

### Inherited Methods
- **async_delete_installation** - Inherited from AsyncInstallationStore.
- **async_delete_all** - Inherited from AsyncInstallationStore.

```

--------------------------------

### Installation class definition

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/models/index.html

Defines the Installation class with all its attributes. Comments indicate fields only used when token rotation is enabled.

```python
class Installation:
    app_id: Optional[str]
    enterprise_id: Optional[str]
    enterprise_name: Optional[str]
    enterprise_url: Optional[str]
    team_id: Optional[str]
    team_name: Optional[str]
    bot_token: Optional[str]
    bot_id: Optional[str]
    bot_user_id: Optional[str]
    bot_scopes: Optional[Sequence[str]]
    bot_refresh_token: Optional[str]  # only when token rotation is enabled
    # only when token rotation is enabled
    # Unix time (seconds): only when token rotation is enabled
    bot_token_expires_at: Optional[int]
    user_id: str
    user_token: Optional[str]
    user_scopes: Optional[Sequence[str]]
    user_refresh_token: Optional[str]  # only when token rotation is enabled
    # Unix time (seconds): only when token rotation is enabled
    user_token_expires_at: Optional[int]
    incoming_webhook_url: Optional[str]
    incoming_webhook_channel: Optional[str]
    incoming_webhook_channel_id: Optional[str]
    incoming_webhook_configuration_url: Optional[str]
    is_enterprise_install: bool
    token_type: Optional[str]
    installed_at: float

    custom_values: Dict[str, Any]
```

--------------------------------

### chat_stream usage example

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/

Example of using the chat_stream method to start a streaming conversation, append markdown text in chunks, and stop the stream. Requires channel, thread_ts, recipient_team_id, and recipient_user_id.

```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()
```

--------------------------------

### Set up virtual environment and install slack_sdk

Source: https://docs.slack.dev/tools/python-slack-sdk/installation/

Commands to create a virtual environment, activate it, install the slack_sdk package, and set the SLACK_BOT_TOKEN environment variable. Use 'source .venv/bin/activate' on Unix-like systems and 'set' command on Windows.

```bash
# Create a dedicated virtual env for running your Python scripts
python -m venv .venv

# Run .venv\Scripts\activate on Windows OS
source .venv/bin/activate

# Install slack_sdk PyPI package
pip install "slack_sdk>=3.0"

# Set your token as an env variable (`set` command for Windows OS)
export SLACK_BOT_TOKEN=xoxb-***
```

--------------------------------

### Send message asynchronously with AsyncWebhookClient

Source: https://docs.slack.dev/tools/python-slack-sdk/webhook/

Use AsyncWebhookClient for asyncio-based applications. Requires installing aiohttp via 'pip install aiohttp'. The example sends a message and asserts the response status and body.

```python
import asyncio
# requires: pip install aiohttp
from slack_sdk.webhook.async_client import AsyncWebhookClient
url = "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"

async def send_message_via_webhook(url: str):
    webhook = AsyncWebhookClient(url)
    response = await webhook.send(text="Hello!")
    assert response.status_code == 200
    assert response.body == "ok"

# This is the simplest way to run the async method
# but you can go with any ways to run it
asyncio.run(send_message_via_webhook(url))
```

--------------------------------

### Usage example for LegacySlackResponse

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/web/legacy_slack_response.html

Example from the class docstring showing how to use slack.WebClient to make API calls and iterate over paginated responses. It demonstrates accessing response data via dictionary-style indexing and the get method.

```python
import os
import slack

client = slack.WebClient(token=os.environ['SLACK_API_TOKEN'])

response1 = client.auth_revoke(test='true')
assert not response1['revoked']

response2 = client.auth_test()
assert response2.get('ok', False)

users = []
for page in client.users_list(limit=2):
    TODO: This example should specify when to break.
    users = users + page['members']
```

--------------------------------

### Installation.__init__

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/models/installation.html

Constructor for the Installation class. Initializes an installation object with optional parameters for app, workspace, bot, user, incoming webhook, and token rotation details.

```APIDOC
## Installation.__init__

### Description
Initializes an Installation object with all installation details.

### Method
Constructor

### Signature
```python
Installation(
    *,
    app_id: Optional[str] = None,
    enterprise_id: Optional[str] = None,
    enterprise_name: Optional[str] = None,
    enterprise_url: Optional[str] = None,
    team_id: Optional[str] = None,
    team_name: Optional[str] = None,
    bot_token: Optional[str] = None,
    bot_id: Optional[str] = None,
    bot_user_id: Optional[str] = None,
    bot_scopes: Union[str, Sequence[str]] = "",
    bot_refresh_token: Optional[str] = None,
    bot_token_expires_in: Optional[int] = None,
    bot_token_expires_at: Optional[Union[int, datetime, str]] = None,
    user_id: str,
    user_token: Optional[str] = None,
    user_scopes: Union[str, Sequence[str]] = "",
    user_refresh_token: Optional[str] = None,
    user_token_expires_in: Optional[int] = None,
    user_token_expires_at: Optional[Union[int, datetime, str]] = None,
    incoming_webhook_url: Optional[str] = None,
    incoming_webhook_channel: Optional[str] = None,
    incoming_webhook_channel_id: Optional[str] = None,
    incoming_webhook_configuration_url: Optional[str] = None,
    is_enterprise_install: Optional[bool] = False,
    token_type: Optional[str] = None,
    installed_at: Optional[Union[float, datetime, str]] = None,
    custom_values: Optional[Dict[str, Any]] = None,
)
```

### Parameters
- **app_id** (Optional[str]) - Optional - The Slack app ID.
- **enterprise_id** (Optional[str]) - Optional - The enterprise (org) ID.
- **enterprise_name** (Optional[str]) - Optional - The enterprise (org) name.
- **enterprise_url** (Optional[str]) - Optional - The enterprise (org) URL.
- **team_id** (Optional[str]) - Optional - The workspace team ID.
- **team_name** (Optional[str]) - Optional - The workspace team name.
- **bot_token** (Optional[str]) - Optional - The bot user token.
- **bot_id** (Optional[str]) - Optional - The bot ID.
- **bot_user_id** (Optional[str]) - Optional - The bot user ID.
- **bot_scopes** (Union[str, Sequence[str]]) - Optional - The bot scopes. If a string, it is split by commas.
- **bot_refresh_token** (Optional[str]) - Optional - The bot refresh token (only when token rotation is enabled).
- **bot_token_expires_in** (Optional[int]) - Optional - The bot token expiration time in seconds (only when token rotation is enabled).
- **bot_token_expires_at** (Optional[Union[int, datetime, str]]) - Optional - The bot token expiration timestamp (Unix time in seconds) (only when token rotation is enabled).
- **user_id** (str) - Required - The installer's user ID.
- **user_token** (Optional[str]) - Optional - The user token.
- **user_scopes** (Union[str, Sequence[str]]) - Optional - The user scopes. If a string, it is split by commas.
- **user_refresh_token** (Optional[str]) - Optional - The user refresh token (only when token rotation is enabled).
- **user_token_expires_in** (Optional[int]) - Optional - The user token expiration time in seconds (only when token rotation is enabled).
- **user_token_expires_at** (Optional[Union[int, datetime, str]]) - Optional - The user token expiration timestamp (Unix time in seconds) (only when token rotation is enabled).
- **incoming_webhook_url** (Optional[str]) - Optional - The incoming webhook URL.
- **incoming_webhook_channel** (Optional[str]) - Optional - The incoming webhook channel.
- **incoming_webhook_channel_id** (Optional[str]) - Optional - The incoming webhook channel ID.
- **incoming_webhook_configuration_url** (Optional[str]) - Optional - The incoming webhook configuration URL.
- **is_enterprise_install** (Optional[bool]) - Optional - Whether this is an enterprise installation. Defaults to False.
- **token_type** (Optional[str]) - Optional - The token type.
- **installed_at** (Optional[Union[float, datetime, str]]) - Optional - The installation timestamp. Expected float, but other types are handled. For strings, only ISO datetime format is supported.
- **custom_values** (Optional[Dict[str, Any]]) - Optional - Custom key-value pairs for additional data.

### Attributes
- **app_id** (Optional[str]) - The Slack app ID.
- **enterprise_id** (Optional[str]) - The enterprise (org) ID.
- **enterprise_name** (Optional[str]) - The enterprise (org) name.
- **enterprise_url** (Optional[str]) - The enterprise (org) URL.
- **team_id** (Optional[str]) - The workspace team ID.
- **team_name** (Optional[str]) - The workspace team name.
- **bot_token** (Optional[str]) - The bot user token.
- **bot_id** (Optional[str]) - The bot ID.
- **bot_user_id** (Optional[str]) - The bot user ID.
- **bot_scopes** (Optional[Sequence[str]]) - The bot scopes as a list.
- **bot_refresh_token** (Optional[str]) - The bot refresh token (only when token rotation is enabled).
- **bot_token_expires_at** (Optional[int]) - The bot token expiration timestamp (Unix time in seconds) (only when token rotation is enabled).
- **user_id** (str) - The installer's user ID.
- **user_token** (Optional[str]) - The user token.
- **user_scopes** (Optional[Sequence[str]]) - The user scopes as a list.
- **user_refresh_token** (Optional[str]) - The user refresh token (only when token rotation is enabled).
- **user_token_expires_at** (Optional[int]) - The user token expiration timestamp (Unix time in seconds) (only when token rotation is enabled).
- **incoming_webhook_url** (Optional[str]) - The incoming webhook URL.
- **incoming_webhook_channel** (Optional[str]) - The incoming webhook channel.
- **incoming_webhook_channel_id** (Optional[str]) - The incoming webhook channel ID.
- **incoming_webhook_configuration_url** (Optional[str]) - The incoming webhook configuration URL.
- **is_enterprise_install** (bool) - Whether this is an enterprise installation.
- **token_type** (Optional[str]) - The token type.
- **installed_at** (float) - The installation timestamp.
- **custom_values** (Dict[str, Any]) - Custom key-value pairs for additional data.

### Example
```python
installation = Installation(
    app_id="A123",
    team_id="T123",
    user_id="U123",
    bot_token="xoxb-...",
    bot_scopes="chat:write,commands",
)
```
```

--------------------------------

### apps_event_authorizations_list

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/

Get a list of authorizations for the given event context. Each authorization represents an app installation that the event is visible to.

```APIDOC
## apps_event_authorizations_list

### Description
Get a list of authorizations for the given event context. Each authorization represents an app installation that the event is visible to.

### Method
SDK method (calls Slack API method `apps.event.authorizations.list`)

### Parameters
- **event_context** (str) - Required - The event context string.
- **cursor** (str) - Optional - Pagination cursor.
- **limit** (int) - Optional - Maximum number of items to return.
- **kwargs** - Additional arguments passed to the API call.

### Returns
SlackResponse - The response from the Slack API.

### Example
```python
response = client.apps_event_authorizations_list(event_context="...")
```
```

--------------------------------

### apps_event_authorizations_list

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/

Gets a list of authorizations for the given event context. Each authorization represents an app installation that the event is visible to.

```APIDOC
## apps_event_authorizations_list

### Description
Gets a list of authorizations for the given event context. Each authorization represents an app installation that the event is visible to.

### Method
POST

### Endpoint
apps.event.authorizations.list

### Parameters
#### Query Parameters
- **event_context** (string) - Required - The event context to list authorizations for.
- **cursor** (string, optional) - Pagination cursor for the next page of results.
- **limit** (integer, optional) - Maximum number of items to return.

### Request Example
{
  "event_context": "EC12345",
  "cursor": "dXNlcjpVMEc5V0ZYT0E=",
  "limit": 10
}

### Response
#### Success Response (200)
- **ok** (boolean) - Indicates success.
- **authorizations** (array) - List of authorizations.

#### Response Example
{
  "ok": true,
  "authorizations": [
    {
      "enterprise_id": "E12345",
      "team_id": "T12345",
      "user_id": "U12345",
      "is_bot": true,
      "is_enterprise_install": false
    }
  ]
}
```

--------------------------------

### Installation constructor and methods

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/models/installation.html

The Installation class constructor initializes bot and user token details, scopes, expiration times, and custom values. It also includes methods to convert to a Bot object, set/get custom values, and serialize to dictionaries.

```python
        if bot_token_expires_at is not None:
            self.bot_token_expires_at = _timestamp_to_type(bot_token_expires_at, int)
        elif bot_token_expires_in is not None:
            self.bot_token_expires_at = int(time()) + bot_token_expires_in
        else:
            self.bot_token_expires_at = None

        self.user_id = user_id
        self.user_token = user_token
        if isinstance(user_scopes, str):
            self.user_scopes = user_scopes.split(",") if len(user_scopes) > 0 else []
        else:
            self.user_scopes = user_scopes
        self.user_refresh_token = user_refresh_token

        if user_token_expires_at is not None:
            self.user_token_expires_at = _timestamp_to_type(user_token_expires_at, int)
        elif user_token_expires_in is not None:
            self.user_token_expires_at = int(time()) + user_token_expires_in
        else:
            self.user_token_expires_at = None

        self.incoming_webhook_url = incoming_webhook_url
        self.incoming_webhook_channel = incoming_webhook_channel
        self.incoming_webhook_channel_id = incoming_webhook_channel_id
        self.incoming_webhook_configuration_url = incoming_webhook_configuration_url

        self.is_enterprise_install = is_enterprise_install or False
        self.token_type = token_type

        if installed_at is None:
            self.installed_at = datetime.now().timestamp()
        else:
            self.installed_at = _timestamp_to_type(installed_at, float)

        self.custom_values = custom_values if custom_values is not None else {}

    def to_bot(self) -> Bot:
        return Bot(
            app_id=self.app_id,
            enterprise_id=self.enterprise_id,
            enterprise_name=self.enterprise_name,
            team_id=self.team_id,
            team_name=self.team_name,
            bot_token=self.bot_token,  # type: ignore[arg-type]
            bot_id=self.bot_id,  # type: ignore[arg-type]
            bot_user_id=self.bot_user_id,  # type: ignore[arg-type]
            bot_scopes=self.bot_scopes,  # type: ignore[arg-type]
            bot_refresh_token=self.bot_refresh_token,
            bot_token_expires_at=self.bot_token_expires_at,
            is_enterprise_install=self.is_enterprise_install,
            installed_at=self.installed_at,
            custom_values=self.custom_values,
        )

    def set_custom_value(self, name: str, value: Any):
        self.custom_values[name] = value

    def get_custom_value(self, name: str) -> Optional[Any]:
        return self.custom_values.get(name)

    def _to_standard_value_dict(self) -> Dict[str, Any]:
        return {
            "app_id": self.app_id,
            "enterprise_id": self.enterprise_id,
            "enterprise_name": self.enterprise_name,
            "enterprise_url": self.enterprise_url,
            "team_id": self.team_id,
            "team_name": self.team_name,
            "bot_token": self.bot_token,
            "bot_id": self.bot_id,
            "bot_user_id": self.bot_user_id,
            "bot_scopes": ",".join(self.bot_scopes) if self.bot_scopes else None,
            "bot_refresh_token": self.bot_refresh_token,
            "bot_token_expires_at": (
                datetime.fromtimestamp(self.bot_token_expires_at, tz=timezone.utc)
                if self.bot_token_expires_at is not None
                else None
            ),
            "user_id": self.user_id,
            "user_token": self.user_token,
            "user_scopes": ",".join(self.user_scopes) if self.user_scopes else None,
            "user_refresh_token": self.user_refresh_token,
            "user_token_expires_at": (
                datetime.fromtimestamp(self.user_token_expires_at, tz=timezone.utc)
                if self.user_token_expires_at is not None
                else None
            ),
            "incoming_webhook_url": self.incoming_webhook_url,
            "incoming_webhook_channel": self.incoming_webhook_channel,
            "incoming_webhook_channel_id": self.incoming_webhook_channel_id,
            "incoming_webhook_configuration_url": self.incoming_webhook_configuration_url,
            "is_enterprise_install": self.is_enterprise_install,
            "token_type": self.token_type,
            "installed_at": datetime.fromtimestamp(self.installed_at, tz=timezone.utc),
        }

    def to_dict_for_copying(self) -> Dict[str, Any]:
        return {"custom_values": self.custom_values, **self._to_standard_value_dict()}

    def to_dict(self) -> Dict[str, Any]:
        # prioritize standard_values over custom_values
        # when the same keys exist in both
        return {**self.custom_values, **self._to_standard_value_dict()}
```

--------------------------------

### InstallationStore.to_bot()

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/index.html

Converts the current Installation object to a Bot object, preserving all relevant fields.

```APIDOC
## InstallationStore.to_bot()

### Description
Converts the current Installation object to a Bot object, preserving all relevant fields.

### Method
`to_bot(self) -> Bot`

### Parameters
None

### Returns
- **Bot** - A new Bot object with the installation's bot-related fields.
```

--------------------------------

### rtm_connect

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/

Starts a Real Time Messaging session. This method calls the Slack API method rtm.connect using a GET request.

```APIDOC
## rtm_connect

### Description
Starts a Real Time Messaging session.

### Method
GET

### Endpoint
rtm.connect

### Parameters
- **batch_presence_aware** (bool | None) - Optional - Whether to batch presence events.
- **presence_sub** (bool | None) - Optional - Whether to subscribe to presence events.

### Request Example
```python
client.rtm_connect(batch_presence_aware=True, presence_sub=True)
```

### Response
Returns a SlackResponse object.
```

--------------------------------

### rtm_connect method implementation

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/

Starts a Real Time Messaging session. Calls the rtm.connect API endpoint with a GET request, passing batch_presence_aware and presence_sub parameters.

```python
def rtm_connect(
    self,
    *,
    batch_presence_aware: Optional[bool] = None,
    presence_sub: Optional[bool] = None,
    **kwargs,
) -> SlackResponse:
    """Starts a Real Time Messaging session.

    https://docs.slack.dev/reference/methods/rtm.connect
    """
    kwargs.update({"batch_presence_aware": batch_presence_aware, "presence_sub": presence_sub})
    return self.api_call("rtm.connect", http_verb="GET", params=kwargs)
```

--------------------------------

### Bot.__init__

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/oauth/installation_store/models/bot.html

Initializes a Bot instance with installation details, bot credentials, and optional custom values.

```APIDOC
## Bot.__init__

### Description
Initializes a Bot instance with installation details, bot credentials, and optional custom values.

### Method
Constructor

### Signature
```python
Bot(*, app_id: Optional[str] = None, enterprise_id: Optional[str] = None, enterprise_name: Optional[str] = None, team_id: Optional[str] = None, team_name: Optional[str] = None, bot_token: str, bot_id: str, bot_user_id: str, bot_scopes: Union[str, Sequence[str]] = "", bot_refresh_token: Optional[str] = None, bot_token_expires_in: Optional[int] = None, bot_token_expires_at: Optional[Union[int, datetime, str]] = None, is_enterprise_install: Optional[bool] = False, installed_at: Union[float, datetime, str], custom_values: Optional[Dict[str, Any]] = None)
```

### Parameters
- **app_id** (Optional[str]) - Optional - The application ID.
- **enterprise_id** (Optional[str]) - Optional - The enterprise ID for org installations.
- **enterprise_name** (Optional[str]) - Optional - The enterprise name.
- **team_id** (Optional[str]) - Optional - The team ID.
- **team_name** (Optional[str]) - Optional - The team name.
- **bot_token** (str) - Required - The bot access token.
- **bot_id** (str) - Required - The bot ID.
- **bot_user_id** (str) - Required - The bot user ID.
- **bot_scopes** (Union[str, Sequence[str]]) - Optional - Bot scopes as a comma-separated string or a sequence. Defaults to empty string.
- **bot_refresh_token** (Optional[str]) - Optional - Refresh token for token rotation.
- **bot_token_expires_in** (Optional[int]) - Optional - Seconds until token expiration.
- **bot_token_expires_at** (Optional[Union[int, datetime, str]]) - Optional - Expiration timestamp as int, datetime, or ISO string.
- **is_enterprise_install** (Optional[bool]) - Optional - Whether this is an enterprise install. Defaults to False.
- **installed_at** (Union[float, datetime, str]) - Required - Installation timestamp as float, datetime, or ISO string.
- **custom_values** (Optional[Dict[str, Any]]) - Optional - Custom key-value pairs.

### Attributes
- **app_id** (Optional[str]) - The application ID.
- **enterprise_id** (Optional[str]) - The enterprise ID.
- **enterprise_name** (Optional[str]) - The enterprise name.
- **team_id** (Optional[str]) - The team ID.
- **team_name** (Optional[str]) - The team name.
- **bot_token** (str) - The bot access token.
- **bot_id** (str) - The bot ID.
- **bot_user_id** (str) - The bot user ID.
- **bot_scopes** (Sequence[str]) - List of bot scopes.
- **bot_refresh_token** (Optional[str]) - Refresh token for token rotation.
- **bot_token_expires_at** (Optional[int]) - Expiration timestamp as Unix timestamp.
- **is_enterprise_install** (bool) - Whether this is an enterprise install.
- **installed_at** (float) - Installation timestamp as Unix timestamp.
- **custom_values** (Dict[str, Any]) - Custom key-value pairs.
```

--------------------------------

### Create Python virtual environment and install slack-sdk

Source: https://docs.slack.dev/tools/python-slack-sdk/tutorial/uploading-files/

Creates a requirements.txt with slack-sdk>=3.12,<4, sets up a virtual environment, activates it, upgrades pip, and installs dependencies.

```bash
echo 'slack-sdk>=3.12,<4' > requirements.txt
python3 -m venv .venv
source .venv/bin/activate
pip install -U pip
pip install -r requirements.txt
```

--------------------------------

### RTMClient usage example with run_on decorator

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/rtm/index.html

Example from the RTMClient docstring showing how to set up an RTM client, register a message event handler with @RTMClient.run_on, and start the client. It requires a Slack API token in the SLACK_API_TOKEN environment variable and uses the web_client to post a reply when a message contains 'Hello'.

```python
import os
from slack import RTMClient


@RTMClient.run_on(event="message")
def say_hello(**payload):
    data = payload["data"]
    web_client = payload["web_client"]
    if "Hello" in data["text"]:
        channel_id = data["channel"]
        thread_ts = data["ts"]
        user = data["user"]

        web_client.chat_postMessage(channel=channel_id, text=f"Hi <@{user}>!", thread_ts=thread_ts)


slack_token = os.environ["SLACK_API_TOKEN"]
rtm_client = RTMClient(token=slack_token)
rtm_client.start()
```

--------------------------------

### rtm_start method implementation

Source: https://docs.slack.dev/tools/python-slack-sdk/reference/

Starts a Real Time Messaging session. Accepts optional parameters like batch_presence_aware, include_locale, mpim_aware, no_latest, no_unreads, presence_sub, and simple_latest. Calls the 'rtm.start' API with HTTP GET.

```python
def rtm_start(
    self,
    *,
    batch_presence_aware: Optional[bool] = None,
    include_locale: Optional[bool] = None,
    mpim_aware: Optional[bool] = None,
    no_latest: Optional[bool] = None,
    no_unreads: Optional[bool] = None,
    presence_sub: Optional[bool] = None,
    simple_latest: Optional[bool] = None,
    **kwargs,
) -> SlackResponse:
    """Starts a Real Time Messaging session.

    https://docs.slack.dev/reference/methods/rtm.start
    """
    kwargs.update(
        {
            "batch_presence_aware": batch_presence_aware,
            "include_locale": include_locale,
            "mpim_aware": mpim_aware,
            "no_latest": no_latest,
            "no_unreads": no_unreads,
            "presence_sub": presence_sub,
            "simple_latest": simple_latest,
        }
    )
    return self.api_call("rtm.start", http_verb="GET", params=kwargs)
```
Tokens:
Raw