bookmarks.* API support (via #1176) - thanks @filmaj!ssl_context to SocketModeHandler if it is defined in the web_client (via #1177) - thanks @charlch!admin.users.unsupportedVersions.export API support (via #1174) - thanks @seratch!admin.apps.requests.cancel API method support - Thanks @seratchasyncio.CancelledError if the connection is already closed - Thanks @seratch @vectoralphaaccessibility_label to button block element - Thanks @seratchAdd Support for Subscribe in Slack (apps.manifest.*) by @srajiang in #1151
This release includes support for apps.notifications.subscriptions.* endpoints and adds message metadata field to the chat.postMessage and chat.update arguments.
apps.notifications.subscriptions.create apps.notifications.subscriptions.update apps.notifications.subscriptions.delete
Full Changelog: v3.13.0...v3.130b1
team.* & admin.users.session.resetBulk APIs - Thanks @seratchslack_sdk.models classes - Thanks @seratchchannel_posting_permissions_updated action - Thanks @seratchThis release includes support for app manifests. The apps.manifest.* endpoints can be used to create, delete, update, and copy your Slack apps with ease. New endpoints include:
apps.manifest.createapps.manifest.deleteapps.manifest.exportapps.manifest.updateapps.manifest.validatetooling.tokens.rotateFull Changelog: https://github.com/slackapi/python-slack-sdk/compare/v3.11.2...v3.12.0b1
Refer to v3.11.0 release notes
WebClient / AsyncWebClientSince this version, all the methods in WebClient / AsyncWebClient have not only required arguments but also all possible ones in the method signature for better developer experience. Refer to the pull request enabling this #1099 for details.
Now that SlackResponse / AsyncSlackResponse now have __contains__ method, you can test if a key exists in WebClient responses. Refer to the pull request enabling this #1104 for details.
token = "xoxb-"
response = WebClient(token).auth_test()
"error" in response # True / False
__contains__ method in slack_sdk.web.SlackResponse / AsyncSlackResponse - Thanks @seratchContextBlock element type hint - Thanks @uroboro @seratchget/__getitem__ method behavior when response body is empty - Thanks @janeliang0522 @seratchSign in with Slack helps users log into your service using their Slack profile. The platform feature was recently upgraded to be compatible with the standard OpenID Connect specification. With this version of slack-sdk, implementing the auth flow is much easier.
When you create a new Slack app, set the following user scopes:
oauth_config:
redirect_urls:
- https://{your-domain}/slack/oauth_redirect
scopes:
user:
- openid # required
- email # optional
- profile # optionalCheck the Flask example in the repository. It does the following:
slack_sdk.oauth.OpenIDConnectAuthorizeUrlGenerator helps you easily do thisOAuthStateStore is still available for generating state parameter value (it's available for nonce management too)WebClient can perform openid.connect.token API calls with given code parameterIf you want to know the way with asyncio, check the Sanic app example in the same directory.
This version introduces a built-in retry functionalities to the following API clients:
slack_sdk.web.WebClientslack_sdk.webhook.WebhookClientslack_sdk.audit_logs.AuditLogsClientslack_sdk.scim.SCIMClientslack_sdk.web.async_client.AsyncWebClient (aiohttp/asyncio compatible)slack_sdk.webhook.async_client.AsyncWebhookClient (aiohttp/asyncio compatible)slack_sdk.audit_logs.async_client.AsyncAuditLogsClient (aiohttp/asyncio compatible)slack_sdk.scim.async_client.AsyncSCIMClient (aiohttp/asyncio compatible)With the default settings, only slack_sdk.http_retry.builtin_handlers.ConnectionErrorRetryHandler (AsyncConnectionErrorRetryHandler for asyncio clients) with its default configuratio (=only one retry in the manner of exponential backoff and jitter) is enabled in the above clients. The retry handler retries if an API client encounters a connectivity-related failure (e.g., Connection reset by peer).
import os
from slack_sdk.web import WebClient
# Only ConnectionErrorRetryHandler is enabled
client = WebClient(token=os.environ["SLACK_BOT_TOKEN"])
Another built-in retry handler is the one that handles rate limited errors.
# --------------------------------
# Use the built-in handlers
# --------------------------------
client = WebClient(token=os.environ["SLACK_BOT_TOKEN"])
# This handler does retries when HTTP status 429 is returned
from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
rate_limit_handler = RateLimitErrorRetryHandler(max_retry_count=1)
# Enable rate limited error retries as well
cient.retry_handlers.append(rate_limit_handler)
Creating your own ones is also quite simple. Defining a new class that inherits slack_sdk.http_retry.RetryHandler and implements required methods (internals of can_retry / prepare_for_next_retry). Check the built-in ones' source code for learning how to properly implement.
# --------------------------------
# Create your own one
# --------------------------------
import socket
from typing import Optional
from slack_sdk.http_retry import (RetryHandler, RetryState, HttpRequest, HttpResponse)
from slack_sdk.http_retry.builtin_interval_calculators import (
BackoffRetryIntervalCalculator,
)
from slack_sdk.http_retry.jitter import RandomJitter
class MyRetryHandler(RetryHandler):
def _can_retry(
self,
*,
state: RetryState,
request: HttpRequest,
response: Optional[HttpResponse] = None,
error: Optional[Exception] = None
) -> bool:
# [Errno 104] Connection reset by peer
return (
error is not None and isinstance(error, socket.error) and error.errno == 104
)
# Customize the settings
my_handler = MyRetryHandler(
max_retry_count=2, # retry twice at maximum; the default is 1
interval_calculator=BackoffRetryIntervalCalculator( # exponential backoff and jitter is the default
backoff_factor=1.0, # 1, 2, 4, 8, 16 seconds later ...
jitter=RandomJitter(), # will add 0.0 -- 1.0 second to the backoff duration
),
)
client = WebClient(
token=os.environ["SLACK_BOT_TOKEN"],
retry_handlers=[rate_limit_handler, my_handler],
)
For asyncio apps, Async prefixed corresponding modules are available. All the methods in those methods are async/await compatible. Check the source code and tests for more details.
Refer to the v3.9.0 release note
Refer to the v3.9.0 release note
This version includes the token rotation feature support for better security. Refer to the API document for the general information about the feature.
Apart from the column additions for the feature (specifically, refresh token + expiration date time) and the corresponding changes in your app code, no significant code is needed. Checking the example apps using Flask, Sanic in this directory can be helpful to learn what to do.
In a nutshell, you can call the following rotate_tokens method before handling every single incoming request from Slack. As long as your InstallationStore support the token rotation patterns, the code below should work as-is.
from slack_sdk.oauth.token_rotation import TokenRotator
from slack_sdk.oauth.installation_store import FileInstallationStore
# This instance can be singleton; thread-safe
token_rotator = TokenRotator(
# These are required for refreshing tokens
client_id=client_id,
client_secret=client_secret,
)
# Your own InstallationStore here
installation_store = FileInstallationStore()
def rotate_tokens(
enterprise_id: Optional[str] = None,
team_id: Optional[str] = None,
user_id: Optional[str] = None,
is_enterprise_install: Optional[bool] = None,
):
installation = installation_store.find_installation(
enterprise_id=enterprise_id,
team_id=team_id,
user_id=user_id,
is_enterprise_install=is_enterprise_install,
)
if installation is not None:
# If rotation does not occur, refreshed_installation is None
refreshed_installation = token_rotator.perform_token_rotation(installation=installation)
if refreshed_installation is not None:
# Save the new access token for the following processes
installation_store.save(refreshed_installation)
SQLAlchemyInstallationStore usersIf your app uses the built-in SQLAlchemyInstallationStore for managing Slack app installations, adding the following database columns is required for this version upgrade. Refer to the code to check the complete ones.
Also, since this version, all the table columns for string data have their max length for better compatibility with MySQL. We recommend setting the same ones for your models.
Column("bot_refresh_token", String(200)),Column("bot_token_expires_at", DateTime),Column("user_refresh_token", String(200)),Column("user_token_expires_at", DateTime),Column("bot_refresh_token", String(200)),Column("bot_token_expires_at", DateTime),