Future function interactivity (#1)

moving changes to future branch

Author: WilliamBergamin

slack_bolt/app/app.py

@@ -19,6 +19,7 @@
     CallableAuthorize,
 )
 from slack_bolt.error import BoltError, BoltUnhandledRequestError
+from slack_bolt.function import Function
 from slack_bolt.lazy_listener.thread_runner import ThreadLazyListenerRunner
 from slack_bolt.listener.builtins import TokenRevocationListeners
 from slack_bolt.listener.custom_listener import CustomListener
@@ -63,6 +64,7 @@
     IgnoringSelfEvents,
     CustomMiddleware,
 )
+from slack_bolt.middleware.function_listener_matches import FunctionListenerToken
 from slack_bolt.middleware.message_listener_matches import MessageListenerMatches
 from slack_bolt.middleware.middleware_error_handler import (
     DefaultMiddlewareErrorHandler,
@@ -78,6 +80,7 @@
     create_web_client,
     get_boot_message,
     get_name_for_callable,
+    create_copy
 )
 from slack_bolt.workflows.step import WorkflowStep, WorkflowStepMiddleware
 from slack_bolt.workflows.step.step import WorkflowStepBuilder
@@ -794,7 +797,7 @@ def __call__(*args, **kwargs):
 
     def function(
         self,
-        callback_id: Union[str, Pattern],
+        callback_id: Union[str, Function],
         matchers: Optional[Sequence[Callable[..., bool]]] = None,
         middleware: Optional[Sequence[Union[Callable, Middleware]]] = None,
     ) -> Callable[..., Optional[Callable[..., Optional[BoltResponse]]]]:
@@ -825,11 +828,11 @@ def reverse_string(event, complete_success: CompleteSuccess, complete_error: Com
             middleware: A list of lister middleware functions.
                 Only when all the middleware call `next()` method, the listener function can be invoked.
         """
-
+        middleware = list(middleware) if middleware else []
+        middleware.insert(0, FunctionListenerToken())
         def __call__(*args, **kwargs):
             functions = self._to_listener_functions(kwargs) if kwargs else list(args)
-            primary_matcher = builtin_matchers.function_event(callback_id=callback_id, base_logger=self._base_logger)
-            return self._register_listener(list(functions), primary_matcher, matchers, middleware, True)
+            return Function(self._register_listener, self._base_logger, list(functions), callback_id, matchers, middleware)
 
         return __call__
 
@@ -1249,7 +1252,7 @@ def _init_context(self, req: BoltRequest):
         req.context["token"] = self._token
         if self._token is not None:
             # This WebClient instance can be safely singleton
-            req.context["client"] = self._client
+            req.context["client"] = create_copy(self._client)
         else:
             # Set a new dedicated instance for this request
             client_per_request: WebClient = WebClient(

slack_bolt/context/base_context.py

@@ -21,6 +21,7 @@ class BaseContext(dict):
         "response_url",
         "matches",
         "authorize_result",
+        "bot_access_token",
         "bot_token",
         "bot_id",
         "bot_user_id",
@@ -91,6 +92,11 @@ def authorize_result(self) -> Optional[AuthorizeResult]:
         """The authorize result resolved for this request."""
         return self.get("authorize_result")
 
+    @property
+    def bot_access_token(self) -> Optional[str]:
+        """The bot token resolved for this function request."""
+        return self.get("bot_access_token")
+
     @property
     def bot_token(self) -> Optional[str]:
         """The bot token resolved for this request."""

slack_bolt/function/Function.py

@@ -0,0 +1,60 @@
+from typing import List, Union, Pattern, Callable, Dict, Optional, Sequence, Any
+from logging import Logger
+
+from slack_bolt.listener_matcher import builtins as builtin_matchers
+
+from slack_bolt.response import BoltResponse
+from slack_bolt.middleware import Middleware
+
+
+# TDOD this is a duplicate function in App
+def _to_listener_functions(
+    kwargs: dict,
+) -> Optional[Sequence[Callable[..., Optional[BoltResponse]]]]:
+    if kwargs:
+        functions = [kwargs["ack"]]
+        for sub in kwargs["lazy"]:
+            functions.append(sub)
+        return functions
+    return None
+
+
+class Function:
+
+    def __init__(
+        self,
+        _register_listener: Callable[..., Optional[Callable[..., Optional[BoltResponse]]]],
+        _base_logger: Logger,
+        functions: List[Callable[..., Optional[Callable[..., Optional[BoltResponse]]]]],
+        callback_id: Union[str, Pattern],
+        matchers: Optional[Sequence[Callable[..., bool]]] = None,
+        middleware: Optional[Sequence[Union[Callable, Middleware]]] = None
+    ):
+        self._register_listener = _register_listener
+        self._base_logger = _base_logger
+        self.callback_id = callback_id
+
+        primary_matcher = builtin_matchers.function_event(callback_id=self.callback_id, base_logger=_base_logger)
+        self.function = self._register_listener(functions, primary_matcher, matchers, middleware, True)
+
+    def __call__(self, *args, **kwargs) -> Optional[Callable[..., Optional[BoltResponse]]]:
+        return self.function(*args, **kwargs)
+
+    def action(
+        self,
+        constraints: Union[str, Pattern, Dict[str, Union[str, Pattern]]],
+        matchers: Optional[Sequence[Callable[..., bool]]] = None,
+        middleware: Optional[Sequence[Union[Callable, Middleware]]] = None,
+    ) -> Callable[..., Optional[Callable[..., Optional[BoltResponse]]]]:
+        """Registers a new action listener. This method can be used as either a decorator or a method.
+
+        """
+
+        def __call__(*args, **kwargs):
+            print("action reistered")
+
+        return __call__
+
+    @property
+    def __isabstractmethod__(self):
+        return getattr(self.function, '__isabstractmethod__', False)

slack_bolt/function/__init__.py

@@ -0,0 +1,6 @@
+from .function import Function
+
+
+__all__ = [
+    "Function",
+]

slack_bolt/middleware/function_listener_matches/__init__.py

@@ -0,0 +1,5 @@
+from .function_listener_token import FunctionListenerToken
+
+__all__ = [
+    "FunctionListenerToken",
+]

slack_bolt/middleware/function_listener_matches/function_listener_token.py

@@ -0,0 +1,26 @@
+import re
+from typing import Callable, Pattern, Union
+
+from slack_bolt.request import BoltRequest
+from slack_bolt.response import BoltResponse
+from slack_bolt.middleware.middleware import Middleware
+
+
+class FunctionListenerToken(Middleware):  # type: ignore
+
+    def process(
+        self,
+        *,
+        req: BoltRequest,
+        resp: BoltResponse,
+        # As this method is not supposed to be invoked by bolt-python users,
+        # the naming conflict with the built-in one affects
+        # only the internals of this method
+        next: Callable[[], BoltResponse],
+    ) -> BoltResponse:
+        if req.context.bot_access_token:
+            req.context.client.token = req.context.bot_access_token
+            return next()
+
+        # As the text doesn't match, skip running the listener
+        return resp

slack_bolt/request/internals.py

@@ -135,6 +135,14 @@ def extract_function_execution_id(payload: Dict[str, Any]) -> Optional[str]:
     return None
 
 
+def extract_bot_access_token(payload: Dict[str, Any]) -> Optional[str]:
+    if payload.get("bot_access_token") is not None:
+        return payload.get("bot_access_token")
+    if payload.get("event") is not None:
+        return extract_bot_access_token(payload["event"])
+    return None
+
+
 def build_context(context: BoltContext, body: Dict[str, Any]) -> BoltContext:
     context["is_enterprise_install"] = extract_is_enterprise_install(body)
     enterprise_id = extract_enterprise_id(body)
@@ -152,6 +160,9 @@ def build_context(context: BoltContext, body: Dict[str, Any]) -> BoltContext:
     function_execution_id = extract_function_execution_id(body)
     if function_execution_id:
         context["function_execution_id"] = function_execution_id
+    bot_access_token = extract_bot_access_token(body)
+    if bot_access_token:
+        context["bot_access_token"] = bot_access_token
     if "response_url" in body:
         context["response_url"] = body["response_url"]
     elif "response_urls" in body: