Module slack_bolt.kwargs_injection.async_args

Classes

class AsyncArgs (*,
logger: logging.Logger,
client: slack_sdk.web.async_client.AsyncWebClient,
req: AsyncBoltRequest,
resp: BoltResponse,
context: AsyncBoltContext,
body: Dict[str, Any],
payload: Dict[str, Any],
options: Dict[str, Any] | None = None,
shortcut: Dict[str, Any] | None = None,
action: Dict[str, Any] | None = None,
view: Dict[str, Any] | None = None,
command: Dict[str, Any] | None = None,
event: Dict[str, Any] | None = None,
message: Dict[str, Any] | None = None,
ack: AsyncAck,
say: AsyncSay,
respond: AsyncRespond,
complete: AsyncComplete,
fail: AsyncFail,
set_status: AsyncSetStatus | None = None,
set_title: AsyncSetTitle | None = None,
set_suggested_prompts: AsyncSetSuggestedPrompts | None = None,
get_thread_context: AsyncGetThreadContext | None = None,
save_thread_context: AsyncSaveThreadContext | None = None,
next: Callable[[], Awaitable[None]],
**kwargs)

Expand source code

class AsyncArgs:
    """All the arguments in this class are available in any middleware / listeners.
    You can inject the named variables in the argument list in arbitrary order.

        @app.action("link_button")
        async def handle_buttons(ack, respond, logger, context, body, client):
            logger.info(f"request body: {body}")
            await ack()
            if context.channel_id is not None:
                await respond("Hi!")
            await client.views_open(
                trigger_id=body["trigger_id"],
                view={ ... }
            )

    Alternatively, you can include a parameter named `args` and it will be injected with an instance of this class.

        @app.action("link_button")
        async def handle_buttons(args):
            args.logger.info(f"request body: {args.body}")
            await args.ack()
            if args.context.channel_id is not None:
                await args.respond("Hi!")
            await args.client.views_open(
                trigger_id=args.body["trigger_id"],
                view={ ... }
            )

    """

    logger: Logger
    """Logger instance"""
    client: AsyncWebClient
    """`slack_sdk.web.async_client.AsyncWebClient` instance with a valid token"""
    req: AsyncBoltRequest
    """Incoming request from Slack"""
    resp: BoltResponse
    """Response representation"""
    request: AsyncBoltRequest
    """Incoming request from Slack"""
    response: BoltResponse
    """Response representation"""
    context: AsyncBoltContext
    """Context data associated with the incoming request"""
    body: Dict[str, Any]
    """Parsed request body data"""
    # payload
    payload: Dict[str, Any]
    """The unwrapped core data in the request body"""
    options: Optional[Dict[str, Any]]  # payload alias
    """An alias for payload in an `@app.options` listener"""
    shortcut: Optional[Dict[str, Any]]  # payload alias
    """An alias for payload in an `@app.shortcut` listener"""
    action: Optional[Dict[str, Any]]  # payload alias
    """An alias for payload in an `@app.action` listener"""
    view: Optional[Dict[str, Any]]  # payload alias
    """An alias for payload in an `@app.view` listener"""
    command: Optional[Dict[str, Any]]  # payload alias
    """An alias for payload in an `@app.command` listener"""
    event: Optional[Dict[str, Any]]  # payload alias
    """An alias for payload in an `@app.event` listener"""
    message: Optional[Dict[str, Any]]  # payload alias
    """An alias for payload in an `@app.message` listener"""
    # utilities
    ack: AsyncAck
    """`ack()` utility function, which returns acknowledgement to the Slack servers"""
    say: AsyncSay
    """`say()` utility function, which calls chat.postMessage API with the associated channel ID"""
    respond: AsyncRespond
    """`respond()` utility function, which utilizes the associated `response_url`"""
    complete: AsyncComplete
    """`complete()` utility function, signals a successful completion of the custom function"""
    fail: AsyncFail
    """`fail()` utility function, signal that the custom function failed to complete"""
    set_status: Optional[AsyncSetStatus]
    """`set_status()` utility function for AI Agents & Assistants"""
    set_title: Optional[AsyncSetTitle]
    """`set_title()` utility function for AI Agents & Assistants"""
    set_suggested_prompts: Optional[AsyncSetSuggestedPrompts]
    """`set_suggested_prompts()` utility function for AI Agents & Assistants"""
    get_thread_context: Optional[AsyncGetThreadContext]
    """`get_thread_context()` utility function for AI Agents & Assistants"""
    save_thread_context: Optional[AsyncSaveThreadContext]
    """`save_thread_context()` utility function for AI Agents & Assistants"""
    # middleware
    next: Callable[[], Awaitable[None]]
    """`next()` utility function, which tells the middleware chain that it can continue with the next one"""
    next_: Callable[[], Awaitable[None]]
    """An alias of `next()` for avoiding the Python built-in method overrides in middleware functions"""

    def __init__(
        self,
        *,
        logger: Logger,
        client: AsyncWebClient,
        req: AsyncBoltRequest,
        resp: BoltResponse,
        context: AsyncBoltContext,
        body: Dict[str, Any],
        payload: Dict[str, Any],
        options: Optional[Dict[str, Any]] = None,
        shortcut: Optional[Dict[str, Any]] = None,
        action: Optional[Dict[str, Any]] = None,
        view: Optional[Dict[str, Any]] = None,
        command: Optional[Dict[str, Any]] = None,
        event: Optional[Dict[str, Any]] = None,
        message: Optional[Dict[str, Any]] = None,
        ack: AsyncAck,
        say: AsyncSay,
        respond: AsyncRespond,
        complete: AsyncComplete,
        fail: AsyncFail,
        set_status: Optional[AsyncSetStatus] = None,
        set_title: Optional[AsyncSetTitle] = None,
        set_suggested_prompts: Optional[AsyncSetSuggestedPrompts] = None,
        get_thread_context: Optional[AsyncGetThreadContext] = None,
        save_thread_context: Optional[AsyncSaveThreadContext] = None,
        next: Callable[[], Awaitable[None]],
        **kwargs,  # noqa
    ):
        self.logger: Logger = logger
        self.client: AsyncWebClient = client
        self.request = self.req = req
        self.response = self.resp = resp
        self.context: AsyncBoltContext = context

        self.body: Dict[str, Any] = body
        self.payload: Dict[str, Any] = payload
        self.options: Optional[Dict[str, Any]] = options
        self.shortcut: Optional[Dict[str, Any]] = shortcut
        self.action: Optional[Dict[str, Any]] = action
        self.view: Optional[Dict[str, Any]] = view
        self.command: Optional[Dict[str, Any]] = command
        self.event: Optional[Dict[str, Any]] = event
        self.message: Optional[Dict[str, Any]] = message

        self.ack: AsyncAck = ack
        self.say: AsyncSay = say
        self.respond: AsyncRespond = respond
        self.complete: AsyncComplete = complete
        self.fail: AsyncFail = fail

        self.set_status = set_status
        self.set_title = set_title
        self.set_suggested_prompts = set_suggested_prompts
        self.get_thread_context = get_thread_context
        self.save_thread_context = save_thread_context

        self.next: Callable[[], Awaitable[None]] = next
        self.next_: Callable[[], Awaitable[None]] = next

All the arguments in this class are available in any middleware / listeners. You can inject the named variables in the argument list in arbitrary order.

@app.action("link_button")
async def handle_buttons(ack, respond, logger, context, body, client):
    logger.info(f"request body: {body}")
    await ack()
    if context.channel_id is not None:
        await respond("Hi!")
    await client.views_open(
        trigger_id=body["trigger_id"],
        view={ ... }
    )

Alternatively, you can include a parameter named args and it will be injected with an instance of this class.

@app.action("link_button")
async def handle_buttons(args):
    args.logger.info(f"request body: {args.body}")
    await args.ack()
    if args.context.channel_id is not None:
        await args.respond("Hi!")
    await args.client.views_open(
        trigger_id=args.body["trigger_id"],
        view={ ... }
    )

Class variables

var ack : AsyncAck

ack() utility function, which returns acknowledgement to the Slack servers

var action : Dict[str, Any] | None

An alias for payload in an @app.action listener

var body : Dict[str, Any]

Parsed request body data

var client : slack_sdk.web.async_client.AsyncWebClient

slack_sdk.web.async_client.AsyncWebClient instance with a valid token

var command : Dict[str, Any] | None

An alias for payload in an @app.command listener

var complete : AsyncComplete

complete() utility function, signals a successful completion of the custom function

var context : AsyncBoltContext

Context data associated with the incoming request

var event : Dict[str, Any] | None

An alias for payload in an @app.event listener

var fail : AsyncFail

fail() utility function, signal that the custom function failed to complete

var get_thread_context : AsyncGetThreadContext | None

get_thread_context() utility function for AI Agents & Assistants

var logger : logging.Logger

Logger instance

var message : Dict[str, Any] | None

An alias for payload in an @app.message listener

var next : Callable[[], Awaitable[None]]

next() utility function, which tells the middleware chain that it can continue with the next one

var next_ : Callable[[], Awaitable[None]]

An alias of next() for avoiding the Python built-in method overrides in middleware functions

var options : Dict[str, Any] | None

An alias for payload in an @app.options listener

var payload : Dict[str, Any]

The unwrapped core data in the request body

var req : AsyncBoltRequest

Incoming request from Slack

var request : AsyncBoltRequest

Incoming request from Slack

var resp : BoltResponse

Response representation

var respond : AsyncRespond

respond() utility function, which utilizes the associated response_url

var response : BoltResponse

Response representation

var save_thread_context : AsyncSaveThreadContext | None

save_thread_context() utility function for AI Agents & Assistants

var say : AsyncSay

say() utility function, which calls chat.postMessage API with the associated channel ID

var set_status : AsyncSetStatus | None

set_status() utility function for AI Agents & Assistants

var set_suggested_prompts : AsyncSetSuggestedPrompts | None

set_suggested_prompts() utility function for AI Agents & Assistants

var set_title : AsyncSetTitle | None

set_title() utility function for AI Agents & Assistants

var shortcut : Dict[str, Any] | None

An alias for payload in an @app.shortcut listener

var view : Dict[str, Any] | None

An alias for payload in an @app.view listener