hyperpocket 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

hyperpocket/auth/linear/token_handler.py

@@ -1,21 +1,26 @@
 from typing import Optional
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urlencode, urljoin
 
 from hyperpocket.auth import AuthProvider
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
 from hyperpocket.auth.linear.token_context import LinearTokenAuthContext
-from hyperpocket.auth.linear.token_schema import LinearTokenResponse, LinearTokenRequest
+from hyperpocket.auth.linear.token_schema import LinearTokenRequest, LinearTokenResponse
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 
 
 class LinearTokenAuthHandler(AuthHandlerInterface):
     name: str = "linear-token"
-    description: str = "This handler is used to authenticate users using the Linear token."
+    description: str = (
+        "This handler is used to authenticate users using the Linear token."
+    )
     scoped: bool = False
 
-    _TOKEN_URL: str = urljoin(config.public_base_url + "/", f"{config.callback_url_rewrite_prefix}/auth/token")
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
 
     @staticmethod
     def provider() -> AuthProvider:
@@ -29,24 +34,37 @@ class LinearTokenAuthHandler(AuthHandlerInterface):
     def recommended_scopes() -> set[str]:
         return set()
 
-    def prepare(self, auth_req: LinearTokenRequest, thread_id: str, profile: str,
-                future_uid: str, *args, **kwargs) -> str:
+    def prepare(
+        self,
+        auth_req: LinearTokenRequest,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
         redirect_uri = urljoin(
-            config.public_base_url + "/",
-            f"{config.callback_url_rewrite_prefix}/auth/linear/token/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/linear/token/callback",
+        )
+        auth_url = self._make_auth_url(
+            auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid
+        )
+        FutureStore.create_future(
+            future_uid,
+            data={
+                "redirect_uri": redirect_uri,
+                "thread_id": thread_id,
+                "profile": profile,
+            },
         )
-        auth_url = self._make_auth_url(auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid)
-        FutureStore.create_future(future_uid, data={
-            "redirect_uri": redirect_uri,
-            "thread_id": thread_id,
-            "profile": profile,
-        })
 
-        return f'User needs to authenticate using the following URL: {auth_url}'
+        return f"User needs to authenticate using the following URL: {auth_url}"
 
-    async def authenticate(self, auth_req: LinearTokenResponse, future_uid: str, *args,
-                           **kwargs) -> LinearTokenAuthContext:
-        future_data = FutureStore.get_future( future_uid)
+    async def authenticate(
+        self, auth_req: LinearTokenResponse, future_uid: str, *args, **kwargs
+    ) -> LinearTokenAuthContext:
+        future_data = FutureStore.get_future(future_uid)
         access_token = await future_data.future
 
         response = LinearTokenResponse(access_token=access_token)
@@ -54,15 +72,21 @@ class LinearTokenAuthHandler(AuthHandlerInterface):
 
         return context
 
-    async def refresh(self, auth_req: LinearTokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+    async def refresh(
+        self, auth_req: LinearTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
         raise Exception("Linear token doesn't support refresh")
 
-    def _make_auth_url(self, auth_req: LinearTokenRequest, redirect_uri: str, state: str):
+    def _make_auth_url(
+        self, auth_req: LinearTokenRequest, redirect_uri: str, state: str
+    ):
         params = {
             "redirect_uri": redirect_uri,
             "state": state,
         }
         return f"{self._TOKEN_URL}?{urlencode(params)}"
 
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> LinearTokenRequest:
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> LinearTokenRequest:
         return LinearTokenRequest()

hyperpocket/auth/notion/context.py

@@ -1,6 +1,6 @@
-
 from hyperpocket.auth.context import AuthContext
 
+
 class NotionAuthContext(AuthContext):
     _ACCESS_TOKEN_KEY: str = "NOTION_TOKEN"
 
@@ -12,4 +12,4 @@ class NotionAuthContext(AuthContext):
     def to_profiled_dict(self, profile: str) -> dict[str, str]:
         return {
             f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
-        }
+        }

hyperpocket/auth/notion/token_context.py

@@ -5,10 +5,8 @@ from hyperpocket.auth.notion.token_schema import NotionTokenResponse
 class NotionTokenAuthContext(NotionAuthContext):
     @classmethod
     def from_notion_token_response(cls, response: NotionTokenResponse):
-        description = 'Notion Token Context logged in'
+        description = "Notion Token Context logged in"
 
         return cls(
-            access_token=response.access_token,
-            description=description,
-            expires_at=None
+            access_token=response.access_token, description=description, expires_at=None
         )

hyperpocket/auth/notion/token_handler.py

@@ -1,22 +1,26 @@
-
 from typing import Optional
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urlencode, urljoin
 
 from hyperpocket.auth import AuthProvider
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
 from hyperpocket.auth.notion.token_context import NotionTokenAuthContext
-from hyperpocket.auth.notion.token_schema import NotionTokenResponse, NotionTokenRequest
+from hyperpocket.auth.notion.token_schema import NotionTokenRequest, NotionTokenResponse
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 
 
 class NotionTokenAuthHandler(AuthHandlerInterface):
     name: str = "notion-token"
-    description: str = "This handler is used to authenticate users using the Notion token."
+    description: str = (
+        "This handler is used to authenticate users using the Notion token."
+    )
     scoped: bool = False
 
-    _TOKEN_URL: str = urljoin(config.public_base_url + "/", f"{config.callback_url_rewrite_prefix}/auth/token")
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
 
     @staticmethod
     def provider() -> AuthProvider:
@@ -26,22 +30,36 @@ class NotionTokenAuthHandler(AuthHandlerInterface):
     def recommended_scopes() -> set[str]:
         return set()
 
-    def prepare(self, auth_req: NotionTokenRequest, thread_id: str, profile: str,
-                future_uid: str, *args, **kwargs) -> str:
+    def prepare(
+        self,
+        auth_req: NotionTokenRequest,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
         redirect_uri = urljoin(
-            config.public_base_url + "/",
-            f"{config.callback_url_rewrite_prefix}/auth/notion/token/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/notion/token/callback",
+        )
+        url = self._make_auth_url(
+            auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid
+        )
+        FutureStore.create_future(
+            future_uid,
+            data={
+                "redirect_uri": redirect_uri,
+                "thread_id": thread_id,
+                "profile": profile,
+            },
         )
-        url = self._make_auth_url(auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid)
-        FutureStore.create_future(future_uid, data={
-            "redirect_uri": redirect_uri,
-            "thread_id": thread_id,
-            "profile": profile,
-        })
 
-        return f'User needs to authenticate using the following URL: {url}'
+        return f"User needs to authenticate using the following URL: {url}"
 
-    async def authenticate(self, auth_req: NotionTokenRequest, future_uid: str, *args, **kwargs) -> AuthContext:
+    async def authenticate(
+        self, auth_req: NotionTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
         future_data = FutureStore.get_future(future_uid)
         access_token = await future_data.future
 
@@ -50,10 +68,14 @@ class NotionTokenAuthHandler(AuthHandlerInterface):
 
         return context
 
-    async def refresh(self, auth_req: NotionTokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+    async def refresh(
+        self, auth_req: NotionTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
         raise Exception("Notion token doesn't support refresh")
 
-    def _make_auth_url(self, auth_req: NotionTokenRequest, redirect_uri: str, state: str):
+    def _make_auth_url(
+        self, auth_req: NotionTokenRequest, redirect_uri: str, state: str
+    ):
         params = {
             "redirect_uri": redirect_uri,
             "state": state,
@@ -61,5 +83,7 @@ class NotionTokenAuthHandler(AuthHandlerInterface):
         auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
         return auth_url
 
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> NotionTokenRequest:
-        return NotionTokenRequest()
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> NotionTokenRequest:
+        return NotionTokenRequest()

hyperpocket/auth/notion/token_schema.py

@@ -1,4 +1,3 @@
-
 from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
 
 

hyperpocket/auth/reddit/oauth2_handler.py

@@ -1,7 +1,6 @@
 import base64
-from os import access
 from typing import Optional
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urlencode, urljoin
 
 import httpx
 
@@ -10,8 +9,8 @@ from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
 from hyperpocket.auth.reddit.oauth2_context import RedditOAuth2AuthContext
 from hyperpocket.auth.reddit.oauth2_schema import (
-    RedditOAuth2Response,
     RedditOAuth2Request,
+    RedditOAuth2Response,
 )
 from hyperpocket.config import config as config
 from hyperpocket.futures import FutureStore
@@ -35,7 +34,7 @@ class RedditOAuth2AuthHandler(AuthHandlerInterface):
 
     @staticmethod
     def recommended_scopes() -> set[str]:
-        if config.auth.reddit.use_recommended_scope:
+        if config().auth.reddit.use_recommended_scope:
             recommended_scopes = {"account", "identity", "read"}
         else:
             recommended_scopes = {}
@@ -51,8 +50,8 @@ class RedditOAuth2AuthHandler(AuthHandlerInterface):
         **kwargs,
     ) -> str:
         redirect_uri = urljoin(
-            config.public_base_url + "/",
-            f"{config.callback_url_rewrite_prefix}/auth/reddit/oauth2/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/reddit/oauth2/callback",
         )
         print(f"redirect_uri: {redirect_uri}")
         auth_url = self._make_auth_url(
@@ -108,8 +107,8 @@ class RedditOAuth2AuthHandler(AuthHandlerInterface):
             resp = await client.post(
                 url=self._REDDIT_TOKEN_URL,
                 data={
-                    "client_id": config.auth.reddit.client_id,
-                    "client_secret": config.auth.reddit.client_secret,
+                    "client_id": config().auth.reddit.client_id,
+                    "client_secret": config().auth.reddit.client_secret,
                     "grant_type": "refresh_token",
                     "refresh_token": refresh_token,
                 },
@@ -146,6 +145,6 @@ class RedditOAuth2AuthHandler(AuthHandlerInterface):
     ) -> RedditOAuth2Request:
         return RedditOAuth2Request(
             auth_scopes=auth_scopes,
-            client_id=config.auth.reddit.client_id,
-            client_secret=config.auth.reddit.client_secret,
+            client_id=config().auth.reddit.client_id,
+            client_secret=config().auth.reddit.client_secret,
         )

hyperpocket/auth/reddit/oauth2_schema.py

@@ -1,7 +1,5 @@
 from typing import Optional
 
-from pydantic import BaseModel
-
 from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
 
 

hyperpocket/auth/schema.py

@@ -7,13 +7,16 @@ class AuthenticateRequest(BaseModel):
     """
     This class is used to define the interface of the authentication request.
     """
+
     auth_scopes: Optional[list[str]] = Field(
         default_factory=list,
-        description="authentication scopes. if the authentication handler is non scoped, it isn't needed")
+        description="authentication scopes. if the authentication handler is non scoped, it isn't needed",
+    )
 
 
 class AuthenticateResponse(BaseModel):
     """
     This class is used to define the interface of the authentication response.
     """
+
     pass

hyperpocket/auth/slack/oauth2_context.py

@@ -12,7 +12,9 @@ class SlackOAuth2AuthContext(SlackAuthContext):
 
     @classmethod
     def from_slack_oauth2_response(cls, response: SlackOAuth2Response):
-        description = f'Slack OAuth2 Context logged in as a user {response.authed_user.id}'
+        description = (
+            f"Slack OAuth2 Context logged in as a user {response.authed_user.id}"
+        )
         now = datetime.now(tz=timezone.utc)
 
         # user token

hyperpocket/auth/slack/oauth2_handler.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urlencode, urljoin
 
 import httpx
 
@@ -7,7 +7,7 @@ from hyperpocket.auth import AuthProvider
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
 from hyperpocket.auth.slack.oauth2_context import SlackOAuth2AuthContext
-from hyperpocket.auth.slack.oauth2_schema import SlackOAuth2Response, SlackOAuth2Request
+from hyperpocket.auth.slack.oauth2_schema import SlackOAuth2Request, SlackOAuth2Response
 from hyperpocket.config import config as config
 from hyperpocket.futures import FutureStore
 
@@ -30,7 +30,7 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
 
     @staticmethod
     def recommended_scopes() -> set[str]:
-        if config.auth.slack.use_recommended_scope:
+        if config().auth.slack.use_recommended_scope:
             recommended_scopes = {
                 "channels:history",
                 "channels:read",
@@ -46,24 +46,38 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
             recommended_scopes = {}
         return recommended_scopes
 
-    def prepare(self, auth_req: SlackOAuth2Request, thread_id: str, profile: str,
-                future_uid: str, *args, **kwargs) -> str:
+    def prepare(
+        self,
+        auth_req: SlackOAuth2Request,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
         redirect_uri = urljoin(
-            config.public_base_url + "/",
-            f"{config.callback_url_rewrite_prefix}/auth/slack/oauth2/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/slack/oauth2/callback",
         )
         print(f"redirect_uri: {redirect_uri}")
-        auth_url = self._make_auth_url(req=auth_req, redirect_uri=redirect_uri, state=future_uid)
+        auth_url = self._make_auth_url(
+            req=auth_req, redirect_uri=redirect_uri, state=future_uid
+        )
 
-        FutureStore.create_future(future_uid, data={
-            "redirect_uri": redirect_uri,
-            "thread_id": thread_id,
-            "profile": profile,
-        })
+        FutureStore.create_future(
+            future_uid,
+            data={
+                "redirect_uri": redirect_uri,
+                "thread_id": thread_id,
+                "profile": profile,
+            },
+        )
 
-        return f'User needs to authenticate using the following URL: {auth_url}'
+        return f"User needs to authenticate using the following URL: {auth_url}"
 
-    async def authenticate(self, auth_req: SlackOAuth2Request, future_uid: str, *args, **kwargs) -> AuthContext:
+    async def authenticate(
+        self, auth_req: SlackOAuth2Request, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
         future_data = FutureStore.get_future(future_uid)
         auth_code = await future_data.future
 
@@ -71,11 +85,11 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
             resp = await client.post(
                 url=self._SLACK_TOKEN_URL,
                 data={
-                    'client_id': auth_req.client_id,
-                    'client_secret': auth_req.client_secret,
-                    'code': auth_code,
-                    'redirect_uri': future_data.data["redirect_uri"],
-                }
+                    "client_id": auth_req.client_id,
+                    "client_secret": auth_req.client_secret,
+                    "code": auth_code,
+                    "redirect_uri": future_data.data["redirect_uri"],
+                },
             )
         if resp.status_code != 200:
             raise Exception(f"failed to authenticate. status_code : {resp.status_code}")
@@ -87,7 +101,9 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
         resp_typed = SlackOAuth2Response(**resp_json)
         return SlackOAuth2AuthContext.from_slack_oauth2_response(resp_typed)
 
-    async def refresh(self, auth_req: SlackOAuth2Request, context: AuthContext, *args, **kwargs) -> AuthContext:
+    async def refresh(
+        self, auth_req: SlackOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
         slack_context: SlackOAuth2AuthContext = context
         last_oauth2_resp: SlackOAuth2Response = slack_context.detail
         refresh_token = slack_context.refresh_token
@@ -96,10 +112,10 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
             resp = await client.post(
                 url=self._SLACK_TOKEN_URL,
                 data={
-                    'client_id': config.auth.slack.client_id,
-                    'client_secret': config.auth.slack.client_secret,
-                    'grant_type': 'refresh_token',
-                    'refresh_token': refresh_token,
+                    "client_id": config().auth.slack.client_id,
+                    "client_secret": config().auth.slack.client_secret,
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
                 },
             )
 
@@ -113,12 +129,14 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
         if last_oauth2_resp.authed_user:
             new_resp = last_oauth2_resp.model_copy(
                 update={
-                    "authed_user": SlackOAuth2Response.AuthedUser(**{
-                        **last_oauth2_resp.authed_user.model_dump(),
-                        "access_token": resp_json["access_token"],
-                        "refresh_token": resp_json["refresh_token"],
-                        "expires_in": resp_json["expires_in"],
-                    })
+                    "authed_user": SlackOAuth2Response.AuthedUser(
+                        **{
+                            **last_oauth2_resp.authed_user.model_dump(),
+                            "access_token": resp_json["access_token"],
+                            "refresh_token": resp_json["refresh_token"],
+                            "expires_in": resp_json["expires_in"],
+                        }
+                    )
                 }
             )
         else:
@@ -135,7 +153,7 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
 
     def _make_auth_url(self, req: SlackOAuth2Request, redirect_uri: str, state: str):
         params = {
-            "user_scope": ','.join(req.auth_scopes),
+            "user_scope": ",".join(req.auth_scopes),
             "client_id": req.client_id,
             "redirect_uri": redirect_uri,
             "state": state,
@@ -143,9 +161,11 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
         auth_url = f"{self._SLACK_OAUTH_URL}?{urlencode(params)}"
         return auth_url
 
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> SlackOAuth2Request:
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> SlackOAuth2Request:
         return SlackOAuth2Request(
             auth_scopes=auth_scopes,
-            client_id=config.auth.slack.client_id,
-            client_secret=config.auth.slack.client_secret,
+            client_id=config().auth.slack.client_id,
+            client_secret=config().auth.slack.client_secret,
         )

hyperpocket/auth/slack/token_context.py

@@ -5,10 +5,8 @@ from hyperpocket.auth.slack.token_schema import SlackTokenResponse
 class SlackTokenAuthContext(SlackAuthContext):
     @classmethod
     def from_slack_token_response(cls, response: SlackTokenResponse):
-        description = 'Slack Token Context logged in'
+        description = "Slack Token Context logged in"
 
         return cls(
-            access_token=response.access_token,
-            description=description,
-            expires_at=None
+            access_token=response.access_token, description=description, expires_at=None
         )

hyperpocket/auth/slack/token_handler.py

@@ -1,21 +1,26 @@
 from typing import Optional
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urlencode, urljoin
 
 from hyperpocket.auth import AuthProvider
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
 from hyperpocket.auth.slack.token_context import SlackTokenAuthContext
-from hyperpocket.auth.slack.token_schema import SlackTokenResponse, SlackTokenRequest
+from hyperpocket.auth.slack.token_schema import SlackTokenRequest, SlackTokenResponse
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 
 
 class SlackTokenAuthHandler(AuthHandlerInterface):
     name: str = "slack-token"
-    description: str = "This handler is used to authenticate users using the Slack token."
+    description: str = (
+        "This handler is used to authenticate users using the Slack token."
+    )
     scoped: bool = False
 
-    _TOKEN_URL: str = urljoin(config.public_base_url + "/", f"{config.callback_url_rewrite_prefix}/auth/token")
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
 
     @staticmethod
     def provider() -> AuthProvider:
@@ -25,23 +30,37 @@ class SlackTokenAuthHandler(AuthHandlerInterface):
     def recommended_scopes() -> set[str]:
         return set()
 
-    def prepare(self, auth_req: SlackTokenRequest, thread_id: str, profile: str,
-                future_uid: str, *args, **kwargs) -> str:
+    def prepare(
+        self,
+        auth_req: SlackTokenRequest,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
         redirect_uri = urljoin(
-            config.public_base_url + "/",
-            f"{config.callback_url_rewrite_prefix}/auth/slack/token/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/slack/token/callback",
+        )
+        url = self._make_auth_url(
+            req=auth_req, redirect_uri=redirect_uri, state=future_uid
+        )
+        FutureStore.create_future(
+            future_uid,
+            data={
+                "redirect_uri": redirect_uri,
+                "thread_id": thread_id,
+                "profile": profile,
+            },
         )
-        url = self._make_auth_url(req=auth_req, redirect_uri=redirect_uri, state=future_uid)
-        FutureStore.create_future(future_uid, data={
-            "redirect_uri": redirect_uri,
-            "thread_id": thread_id,
-            "profile": profile,
-        })
 
-        return f'User needs to authenticate using the following URL: {url}'
+        return f"User needs to authenticate using the following URL: {url}"
 
-    async def authenticate(self, auth_req: SlackTokenRequest, future_uid: str, *args, **kwargs) -> AuthContext:
-        future_data = FutureStore.get_future( future_uid)
+    async def authenticate(
+        self, auth_req: SlackTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
         access_token = await future_data.future
 
         response = SlackTokenResponse(access_token=access_token)
@@ -49,7 +68,9 @@ class SlackTokenAuthHandler(AuthHandlerInterface):
 
         return context
 
-    async def refresh(self, auth_req: SlackTokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+    async def refresh(
+        self, auth_req: SlackTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
         raise Exception("Slack token doesn't support refresh")
 
     def _make_auth_url(self, req: SlackTokenRequest, redirect_uri: str, state: str):
@@ -60,5 +81,7 @@ class SlackTokenAuthHandler(AuthHandlerInterface):
         auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
         return auth_url
 
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> SlackTokenRequest:
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> SlackTokenRequest:
         return SlackTokenRequest()

hyperpocket/builtin.py

@@ -2,7 +2,7 @@ from typing import List
 
 from hyperpocket.auth import AuthProvider
 from hyperpocket.pocket_auth import PocketAuth
-from hyperpocket.tool import from_func, Tool
+from hyperpocket.tool import Tool, from_func
 
 
 def get_builtin_tools(pocket_auth: PocketAuth) -> List[Tool]:
@@ -34,7 +34,9 @@ def get_builtin_tools(pocket_auth: PocketAuth) -> List[Tool]:
         session_list = pocket_auth.list_session_state(thread_id)
         return str(session_list)
 
-    def __delete_session(auth_provider_name: str, thread_id: str = "default", profile: str = "default") -> str:
+    def __delete_session(
+        auth_provider_name: str, thread_id: str = "default", profile: str = "default"
+    ) -> str:
         """
         This tool deletes a saved session for a specified authentication provider in the given thread and profile.