Module slack_bolt.adapter.socket_mode.async_handler

Default implementation is the aiohttp-based one.

Classes

class AsyncSocketModeHandler (app: AsyncApp,
app_token: str | None = None,
logger: logging.Logger | None = None,
web_client: slack_sdk.web.async_client.AsyncWebClient | None = None,
proxy: str | None = None,
ping_interval: float = 10,
loop: asyncio.events.AbstractEventLoop | None = None)

Expand source code

class AsyncSocketModeHandler(AsyncBaseSocketModeHandler):
    app: AsyncApp
    app_token: str
    client: SocketModeClient

    def __init__(
        self,
        app: AsyncApp,
        app_token: Optional[str] = None,
        logger: Optional[Logger] = None,
        web_client: Optional[AsyncWebClient] = None,
        proxy: Optional[str] = None,
        ping_interval: float = 10,
        loop: Optional[AbstractEventLoop] = None,
    ):
        self.app = app
        self.app_token = app_token or os.environ["SLACK_APP_TOKEN"]
        self.client = SocketModeClient(
            app_token=self.app_token,
            logger=logger if logger is not None else app.logger,
            web_client=web_client if web_client is not None else app.client,
            proxy=proxy,
            ping_interval=ping_interval,
            loop=loop,
        )
        self.client.socket_mode_request_listeners.append(self.handle)  # type: ignore[arg-type]

    async def handle(self, client: SocketModeClient, req: SocketModeRequest) -> None:  # type: ignore[override]
        start = time()
        bolt_resp: BoltResponse = await run_async_bolt_app(self.app, req)
        await send_async_response(client, req, bolt_resp, start)

Ancestors

• AsyncBaseSocketModeHandler

Class variables

var app_token : str

The type of the None singleton.

Inherited members

• AsyncBaseSocketModeHandler:
  • app
  • client
  • close_async
  • connect_async
  • disconnect_async
  • handle
  • start_async