Apply the latest black formatter

Author: seratch

slack/rtm/client.py

@@ -569,7 +569,7 @@ async def _wait_exponentially(self, exception, max_wait_time=300):
         """
         wait_time = exception.response.get("headers", {}).get(
             "Retry-After",
-            min((2 ** self._connection_attempts) + random.random(), max_wait_time),
+            min((2**self._connection_attempts) + random.random(), max_wait_time),
         )
         self._logger.debug("Waiting %s seconds before reconnecting.", wait_time)
         await asyncio.sleep(float(wait_time))
@@ -580,7 +580,8 @@ def _close_websocket(self) -> List[Future]:
         close_method = getattr(self._websocket, "close", None)
         if callable(close_method):
             future = asyncio.ensure_future(
-                close_method(), loop=self._event_loop,  # skipcq: PYL-E1102
+                close_method(),
+                loop=self._event_loop,  # skipcq: PYL-E1102
             )
             futures.append(future)
         self._websocket = None

slack/signature/verifier.py

@@ -23,7 +23,9 @@ def __init__(self, signing_secret: str, clock: Clock = Clock()):
         self.clock = clock
 
     def is_valid_request(
-        self, body: Union[str, bytes], headers: Dict[str, str],
+        self,
+        body: Union[str, bytes],
+        headers: Dict[str, str],
     ) -> bool:
         """Verifies if the given signature is valid"""
         if headers is None:
@@ -36,7 +38,10 @@ def is_valid_request(
         )
 
     def is_valid(
-        self, body: Union[str, bytes], timestamp: str, signature: str,
+        self,
+        body: Union[str, bytes],
+        timestamp: str,
+        signature: str,
     ) -> bool:
         """Verifies if the given signature is valid"""
         if timestamp is None or signature is None:

slack/web/async_base_client.py

@@ -111,7 +111,9 @@ async def api_call(  # skipcq: PYL-R1710
         show_2020_01_deprecation(api_method)
 
         return await self._send(
-            http_verb=http_verb, api_url=api_url, req_args=req_args,
+            http_verb=http_verb,
+            api_url=api_url,
+            req_args=req_args,
         )
 
     async def _send(

slack/web/async_slack_response.py

@@ -133,7 +133,9 @@ async def __anext__(self):
             self.req_args.update({"params": params})
 
             response = await self._client._request(  # skipcq: PYL-W0212
-                http_verb=self.http_verb, api_url=self.api_url, req_args=self.req_args,
+                http_verb=self.http_verb,
+                api_url=self.api_url,
+                req_args=self.req_args,
             )
 
             self.data = response["data"]

slack/web/classes/blocks.py

@@ -159,7 +159,10 @@ class DividerBlock(Block):
     type = "divider"
 
     def __init__(
-        self, *, block_id: Optional[str] = None, **others: dict,
+        self,
+        *,
+        block_id: Optional[str] = None,
+        **others: dict,
     ):
         """A content divider, like an <hr>, to split up different blocks inside of a message.
         https://api.slack.com/reference/block-kit/blocks#divider

slack/web/classes/objects.py

@@ -558,7 +558,9 @@ def parse(cls, config: Union["DispatchActionConfig", dict]):
         return None
 
     def __init__(
-        self, *, trigger_actions_on: Optional[list] = None,
+        self,
+        *,
+        trigger_actions_on: Optional[list] = None,
     ):
         """
         Determines when a plain-text input element will return a block_actions interaction payload.

slack/web/classes/views.py

@@ -152,7 +152,9 @@ def _show_warning_about_unknown(cls, value):
         )
 
     def __init__(
-        self, *, values: Dict[str, Dict[str, Union[dict, "ViewStateValue"]]],
+        self,
+        *,
+        values: Dict[str, Dict[str, Union[dict, "ViewStateValue"]]],
     ):
         value_objects: Dict[str, Dict[str, ViewStateValue]] = {}
         new_state_values = copy.copy(values)

slack/webhook/client.py

@@ -147,7 +147,10 @@ def _perform_http_request(
             charset = e.headers.get_content_charset() or "utf-8"
             body: str = e.read().decode(charset)  # read the response body here
             resp = WebhookResponse(
-                url=url, status_code=e.code, body=body, headers=e.headers,
+                url=url,
+                status_code=e.code,
+                body=body,
+                headers=e.headers,
             )
             if e.code == 429:
                 # for backward-compatibility with WebClient (v.2.5.0 or older)

slack/webhook/internal_utils.py

@@ -14,7 +14,8 @@ def _build_body(original_body: Dict[str, any]) -> Dict[str, any]:
 
 
 def _build_request_headers(
-    default_headers: Dict[str, str], additional_headers: Optional[Dict[str, str]],
+    default_headers: Dict[str, str],
+    additional_headers: Optional[Dict[str, str]],
 ) -> Dict[str, str]:
     if default_headers is None and additional_headers is None:
         return {}

slack/webhook/webhook_response.py

@@ -1,6 +1,11 @@
 class WebhookResponse:
     def __init__(
-        self, *, url: str, status_code: int, body: str, headers: dict,
+        self,
+        *,
+        url: str,
+        status_code: int,
+        body: str,
+        headers: dict,
     ):
         self.api_url = url
         self.status_code = status_code