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

hyperpocket/__init__.py

@@ -1,7 +1,7 @@
-from hyperpocket.pocket_main import Pocket
 from hyperpocket.pocket_auth import PocketAuth
+from hyperpocket.pocket_main import Pocket
 
 __all__ = [
-    'Pocket',
-    'PocketAuth',
-]
+    "Pocket",
+    "PocketAuth",
+]

hyperpocket/auth/__init__.py

@@ -1,16 +1,21 @@
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
 from hyperpocket.auth.provider import AuthProvider
-from hyperpocket.util.find_all_leaf_class_in_package import find_all_leaf_class_in_package
+from hyperpocket.util.find_all_leaf_class_in_package import (
+    find_all_leaf_class_in_package,
+)
 
-PREBUILT_AUTH_HANDLERS = find_all_leaf_class_in_package("hyperpocket.auth", AuthHandlerInterface)
+PREBUILT_AUTH_HANDLERS = find_all_leaf_class_in_package(
+    "hyperpocket.auth", AuthHandlerInterface
+)
 AUTH_CONTEXT_MAP = {
-    leaf.__name__: leaf for leaf in find_all_leaf_class_in_package("hyperpocket.auth", AuthContext)
+    leaf.__name__: leaf
+    for leaf in find_all_leaf_class_in_package("hyperpocket.auth", AuthContext)
 }
 
 __all__ = [
-    'PREBUILT_AUTH_HANDLERS',
-    'AUTH_CONTEXT_MAP',
-    'AuthProvider',
-    'AuthHandlerInterface',
+    "PREBUILT_AUTH_HANDLERS",
+    "AUTH_CONTEXT_MAP",
+    "AuthProvider",
+    "AuthHandlerInterface",
 ]

hyperpocket/auth/calendly/oauth2_handler.py

@@ -4,7 +4,10 @@ from urllib.parse import urlencode, urljoin
 import httpx
 
 from hyperpocket.auth.calendly.oauth2_context import CalendlyOAuth2AuthContext
-from hyperpocket.auth.calendly.oauth2_schema import CalendlyOAuth2Request, CalendlyOAuth2Response
+from hyperpocket.auth.calendly.oauth2_schema import (
+    CalendlyOAuth2Request,
+    CalendlyOAuth2Response,
+)
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface, AuthProvider
 from hyperpocket.config import config
@@ -16,7 +19,9 @@ class CalendlyOAuth2AuthHandler(AuthHandlerInterface):
     _CALENDLY_TOKEN_URL = "https://auth.calendly.com/oauth/token"
 
     name: str = "calendly-oauth2"
-    description: str = "This handler is used to authenticate users using Calendly OAuth."
+    description: str = (
+        "This handler is used to authenticate users using Calendly OAuth."
+    )
     scoped: bool = False
 
     @staticmethod
@@ -32,17 +37,17 @@ class CalendlyOAuth2AuthHandler(AuthHandlerInterface):
         return set()
 
     def prepare(
-            self,
-            auth_req: CalendlyOAuth2Request,
-            thread_id: str,
-            profile: str,
-            future_uid: str,
-            *args,
-            **kwargs,
+        self,
+        auth_req: CalendlyOAuth2Request,
+        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/calendly/oauth2/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/calendly/oauth2/callback",
         )
         auth_url = self._make_auth_url(auth_req, redirect_uri, future_uid)
 
@@ -58,7 +63,7 @@ class CalendlyOAuth2AuthHandler(AuthHandlerInterface):
         return f"User needs to authenticate using the following URL: {auth_url}"
 
     async def authenticate(
-            self, auth_req: CalendlyOAuth2Request, future_uid: str, *args, **kwargs
+        self, auth_req: CalendlyOAuth2Request, future_uid: str, *args, **kwargs
     ) -> AuthContext:
         future_data = FutureStore.get_future(future_uid)
         auth_code = await future_data.future
@@ -97,7 +102,7 @@ class CalendlyOAuth2AuthHandler(AuthHandlerInterface):
         return CalendlyOAuth2AuthContext.from_calendly_oauth2_response(auth_response)
 
     async def refresh(
-            self, auth_req: CalendlyOAuth2Request, context: AuthContext, *args, **kwargs
+        self, auth_req: CalendlyOAuth2Request, context: AuthContext, *args, **kwargs
     ) -> AuthContext:
         last_oauth2_resp: CalendlyOAuth2Response = context.detail
         refresh_token = last_oauth2_resp.refresh_token
@@ -127,7 +132,9 @@ class CalendlyOAuth2AuthHandler(AuthHandlerInterface):
             response = CalendlyOAuth2Response(**resp_json)
             return CalendlyOAuth2AuthContext.from_calendly_oauth2_response(response)
 
-    def _make_auth_url(self, auth_req: CalendlyOAuth2Request, redirect_uri: str, state: str):
+    def _make_auth_url(
+        self, auth_req: CalendlyOAuth2Request, redirect_uri: str, state: str
+    ):
         params = {
             "client_id": auth_req.client_id,
             "redirect_uri": redirect_uri,
@@ -137,10 +144,10 @@ class CalendlyOAuth2AuthHandler(AuthHandlerInterface):
         return f"{self._CALENDLY_AUTH_URL}?{urlencode(params)}"
 
     def make_request(
-            self, auth_scopes: Optional[list[str]] = None, **kwargs
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
     ) -> CalendlyOAuth2Request:
         return CalendlyOAuth2Request(
             auth_scopes=auth_scopes,
-            client_id=config.auth.calendly.client_id,
-            client_secret=config.auth.calendly.client_secret,
+            client_id=config().auth.calendly.client_id,
+            client_secret=config().auth.calendly.client_secret,
         )

hyperpocket/auth/calendly/oauth2_schema.py

@@ -1,7 +1,9 @@
 from typing import Optional
-from hyperpocket.auth.handler import AuthenticateRequest
+
 from pydantic import BaseModel
 
+from hyperpocket.auth.handler import AuthenticateRequest
+
 
 class CalendlyOAuth2Request(AuthenticateRequest):
     client_id: str

hyperpocket/auth/context.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Optional, Any
+from typing import Any, Optional
 
 from pydantic import BaseModel, Field
 
@@ -9,6 +9,7 @@ class AuthContext(BaseModel, ABC):
     """
     This class is used to define the interface of the authentication model.
     """
+
     access_token: str = Field(description="user's access token")
     description: str = Field(description="description of this authentication context")
     expires_at: Optional[datetime] = Field(description="expiration datetime")

hyperpocket/auth/github/oauth2_handler.py

@@ -5,7 +5,10 @@ import httpx
 
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.github.oauth2_context import GitHubOAuth2AuthContext
-from hyperpocket.auth.github.oauth2_schema import GitHubOAuth2Request, GitHubOAuth2Response
+from hyperpocket.auth.github.oauth2_schema import (
+    GitHubOAuth2Request,
+    GitHubOAuth2Response,
+)
 from hyperpocket.auth.handler import AuthHandlerInterface, AuthProvider
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
@@ -41,8 +44,8 @@ class GitHubOAuth2AuthHandler(AuthHandlerInterface):
         **kwargs,
     ) -> str:
         redirect_uri = urljoin(
-            config.public_base_url + "/",
-            f"{config.callback_url_rewrite_prefix}/auth/github/oauth2/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/github/oauth2/callback",
         )
         auth_url = self._make_auth_url(auth_req, redirect_uri, future_uid)
 
@@ -60,7 +63,7 @@ class GitHubOAuth2AuthHandler(AuthHandlerInterface):
     async def authenticate(
         self, auth_req: GitHubOAuth2Request, future_uid: str, *args, **kwargs
     ) -> AuthContext:
-        future_data = FutureStore.get_future( future_uid)
+        future_data = FutureStore.get_future(future_uid)
         auth_code = await future_data.future
 
         async with httpx.AsyncClient() as client:
@@ -124,7 +127,9 @@ class GitHubOAuth2AuthHandler(AuthHandlerInterface):
             response = GitHubOAuth2Response(**resp_json)
             return GitHubOAuth2AuthContext.from_github_oauth2_response(response)
 
-    def _make_auth_url(self, auth_req: GitHubOAuth2Request, redirect_uri: str, state: str):
+    def _make_auth_url(
+        self, auth_req: GitHubOAuth2Request, redirect_uri: str, state: str
+    ):
         params = {
             "client_id": auth_req.client_id,
             "redirect_uri": redirect_uri,
@@ -132,12 +137,12 @@ class GitHubOAuth2AuthHandler(AuthHandlerInterface):
             "state": state,
         }
         return f"{self._GITHUB_AUTH_URL}?{urlencode(params)}"
-        
+
     def make_request(
         self, auth_scopes: Optional[list[str]] = None, **kwargs
     ) -> GitHubOAuth2Request:
         return GitHubOAuth2Request(
             auth_scopes=auth_scopes,
-            client_id=config.auth.github.client_id,
-            client_secret=config.auth.github.client_secret,
+            client_id=config().auth.github.client_id,
+            client_secret=config().auth.github.client_secret,
         )

hyperpocket/auth/github/token_handler.py

@@ -1,7 +1,7 @@
 from typing import Optional
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urlencode, urljoin
 
-from hyperpocket.auth import AuthProvider, AuthHandlerInterface
+from hyperpocket.auth import AuthHandlerInterface, AuthProvider
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.github.token_context import GitHubTokenAuthContext
 from hyperpocket.auth.github.token_schema import GitHubTokenRequest, GitHubTokenResponse
@@ -17,7 +17,10 @@ class GitHubTokenAuthHandler(AuthHandlerInterface):
     )
     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:
@@ -28,19 +31,21 @@ class GitHubTokenAuthHandler(AuthHandlerInterface):
         return set()
 
     def prepare(
-            self,
-            auth_req: AuthenticateRequest,
-            thread_id: str,
-            profile: str,
-            future_uid: str,
-            *args,
-            **kwargs,
+        self,
+        auth_req: AuthenticateRequest,
+        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/github/token/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/github/token/callback",
+        )
+        auth_url = self._make_auth_url(
+            auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid
         )
-        auth_url = self._make_auth_url(auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid)
         FutureStore.create_future(
             future_uid,
             data={
@@ -53,7 +58,7 @@ class GitHubTokenAuthHandler(AuthHandlerInterface):
         return f"User needs to authenticate using the following URL: {auth_url}"
 
     async def authenticate(
-            self, auth_req: GitHubTokenRequest, future_uid: str, *args, **kwargs
+        self, auth_req: GitHubTokenRequest, future_uid: str, *args, **kwargs
     ) -> GitHubTokenAuthContext:
         future_data = FutureStore.get_future(future_uid)
         access_token = await future_data.future
@@ -64,16 +69,17 @@ class GitHubTokenAuthHandler(AuthHandlerInterface):
         return context
 
     async def refresh(
-            self, auth_req: GitHubTokenRequest, context: AuthContext, *args, **kwargs
+        self, auth_req: GitHubTokenRequest, context: AuthContext, *args, **kwargs
     ) -> AuthContext:
         raise Exception("GitHub token doesn't support refresh")
 
-    def _make_auth_url(self, auth_req: GitHubTokenRequest, redirect_uri: str, state: str):
-        params = {
-            "redirect_uri": redirect_uri,
-            "state": state
-        }
+    def _make_auth_url(
+        self, auth_req: GitHubTokenRequest, 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) -> GitHubTokenRequest:
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> GitHubTokenRequest:
         return GitHubTokenRequest()

hyperpocket/auth/google/context.py

@@ -5,9 +5,7 @@ class GoogleAuthContext(AuthContext):
     _ACCESS_TOKEN_KEY: str = "GOOGLE_TOKEN"
 
     def to_dict(self) -> dict[str, str]:
-        return {
-            self._ACCESS_TOKEN_KEY: self.access_token
-        }
+        return {self._ACCESS_TOKEN_KEY: self.access_token}
 
     def to_profiled_dict(self, profile: str) -> dict[str, str]:
         return {

hyperpocket/auth/google/oauth2_context.py

@@ -12,7 +12,7 @@ class GoogleOAuth2AuthContext(GoogleAuthContext):
 
     @classmethod
     def from_google_oauth2_response(
-            cls, response: GoogleOAuth2Response
+        cls, response: GoogleOAuth2Response
     ) -> "GoogleOAuth2AuthContext":
         description = f"Google OAuth2 Context logged in with {response.scope} scopes"
         now = datetime.now(tz=timezone.utc)

hyperpocket/auth/google/oauth2_handler.py

@@ -5,7 +5,10 @@ import httpx
 
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.google.oauth2_context import GoogleOAuth2AuthContext
-from hyperpocket.auth.google.oauth2_schema import GoogleOAuth2Request, GoogleOAuth2Response
+from hyperpocket.auth.google.oauth2_schema import (
+    GoogleOAuth2Request,
+    GoogleOAuth2Response,
+)
 from hyperpocket.auth.handler import AuthHandlerInterface, AuthProvider
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
@@ -32,17 +35,17 @@ class GoogleOAuth2AuthHandler(AuthHandlerInterface):
         return set()
 
     def prepare(
-            self,
-            auth_req: GoogleOAuth2Request,
-            thread_id: str,
-            profile: str,
-            future_uid: str,
-            *args,
-            **kwargs,
+        self,
+        auth_req: GoogleOAuth2Request,
+        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/google/oauth2/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/google/oauth2/callback",
         )
         auth_url = self._make_auth_url(auth_req, redirect_uri, future_uid)
 
@@ -58,9 +61,9 @@ class GoogleOAuth2AuthHandler(AuthHandlerInterface):
         return f"User needs to authenticate using the following URL: {auth_url}"
 
     async def authenticate(
-            self, auth_req: GoogleOAuth2Request, future_uid: str, *args, **kwargs
+        self, auth_req: GoogleOAuth2Request, future_uid: str, *args, **kwargs
     ) -> AuthContext:
-        future_data = FutureStore.get_future( future_uid)
+        future_data = FutureStore.get_future(future_uid)
         auth_code = await future_data.future
 
         async with httpx.AsyncClient() as client:
@@ -83,7 +86,7 @@ class GoogleOAuth2AuthHandler(AuthHandlerInterface):
         return GoogleOAuth2AuthContext.from_google_oauth2_response(auth_response)
 
     async def refresh(
-            self, auth_req: GoogleOAuth2Request, context: AuthContext, *args, **kwargs
+        self, auth_req: GoogleOAuth2Request, context: AuthContext, *args, **kwargs
     ) -> AuthContext:
         google_context: GoogleOAuth2AuthContext = context
         last_oauth2_resp: GoogleOAuth2Response = google_context.detail
@@ -116,7 +119,9 @@ class GoogleOAuth2AuthHandler(AuthHandlerInterface):
             response = GoogleOAuth2Response(**resp_json)
             return GoogleOAuth2AuthContext.from_google_oauth2_response(response)
 
-    def _make_auth_url(self, auth_req: GoogleOAuth2Request, redirect_uri: str, state: str):
+    def _make_auth_url(
+        self, auth_req: GoogleOAuth2Request, redirect_uri: str, state: str
+    ):
         params = {
             "client_id": auth_req.client_id,
             "redirect_uri": redirect_uri,
@@ -128,10 +133,10 @@ class GoogleOAuth2AuthHandler(AuthHandlerInterface):
         return f"{self._GOOGLE_AUTH_URL}?{urlencode(params)}"
 
     def make_request(
-            self, auth_scopes: Optional[list[str]] = None, **kwargs
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
     ) -> GoogleOAuth2Request:
         return GoogleOAuth2Request(
             auth_scopes=auth_scopes,
-            client_id=config.auth.google.client_id,
-            client_secret=config.auth.google.client_secret,
+            client_id=config().auth.google.client_id,
+            client_secret=config().auth.google.client_secret,
         )

hyperpocket/auth/gumloop/token_context.py

@@ -3,13 +3,10 @@ from hyperpocket.auth.gumloop.token_schema import GumloopTokenResponse
 
 
 class GumLoopTokenContext(GumLoopContext):
-
     @classmethod
     def from_gumloop_token_response(cls, response: GumloopTokenResponse):
         description = "Gumloop 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/gumloop/token_handler.py

@@ -1,9 +1,12 @@
 from typing import Optional
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urlencode, urljoin
 
-from hyperpocket.auth import AuthHandlerInterface, AuthContext, AuthProvider
+from hyperpocket.auth import AuthContext, AuthHandlerInterface, AuthProvider
 from hyperpocket.auth.gumloop.token_context import GumLoopTokenContext
-from hyperpocket.auth.gumloop.token_schema import GumloopTokenRequest, GumloopTokenResponse
+from hyperpocket.auth.gumloop.token_schema import (
+    GumloopTokenRequest,
+    GumloopTokenResponse,
+)
 from hyperpocket.auth.schema import AuthenticateRequest
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
@@ -11,10 +14,15 @@ from hyperpocket.futures import FutureStore
 
 class GumloopTokenAuthHandler(AuthHandlerInterface):
     name: str = "gumloop-token"
-    description: str = "This handler is used to authenticate users using the gumloop token"
+    description: str = (
+        "This handler is used to authenticate users using the gumloop token"
+    )
     scoped: bool = False
 
-    _TOKEN_URL = urljoin(config.public_base_url + "/", f"{config.callback_url_rewrite_prefix}/auth/token")
+    _TOKEN_URL = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
 
     @staticmethod
     def provider() -> AuthProvider:
@@ -28,25 +36,41 @@ class GumloopTokenAuthHandler(AuthHandlerInterface):
     def recommended_scopes() -> set[str]:
         return set()
 
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> AuthenticateRequest:
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> AuthenticateRequest:
         return GumloopTokenRequest()
 
-    def prepare(self, auth_req: AuthenticateRequest, thread_id: str, profile: str, future_uid: str, *args,
-                **kwargs) -> str:
+    def prepare(
+        self,
+        auth_req: AuthenticateRequest,
+        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/gumloop/token/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/gumloop/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: AuthenticateRequest, future_uid: str, *args, **kwargs) -> AuthContext:
+    async def authenticate(
+        self, auth_req: AuthenticateRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
         future_data = FutureStore.get_future(future_uid)
         access_token = await future_data.future
 
@@ -55,10 +79,14 @@ class GumloopTokenAuthHandler(AuthHandlerInterface):
 
         return context
 
-    async def refresh(self, auth_req: AuthenticateRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+    async def refresh(
+        self, auth_req: AuthenticateRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
         raise Exception("gumloop token doesn't support refresh")
 
-    def _make_auth_url(self, auth_req: AuthenticateRequest, redirect_uri: str, state: str):
+    def _make_auth_url(
+        self, auth_req: AuthenticateRequest, redirect_uri: str, state: str
+    ):
         params = {
             "redirect_uri": redirect_uri,
             "state": state,

hyperpocket/auth/gumloop/token_schema.py

@@ -4,5 +4,6 @@ from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
 class GumloopTokenRequest(AuthenticateRequest):
     pass
 
+
 class GumloopTokenResponse(AuthenticateResponse):
-    access_token: str
+    access_token: str

hyperpocket/auth/handler.py

@@ -11,7 +11,9 @@ from hyperpocket.auth.schema import AuthenticateRequest
 class AuthHandlerInterface(ABC):
     name: str = Field(description="name of the authentication handler")
     description: str = Field(description="description of the authentication handler")
-    scoped: bool = Field(description="Indicates whether the handler requires an auth_scope for access control")
+    scoped: bool = Field(
+        description="Indicates whether the handler requires an auth_scope for access control"
+    )
 
     @staticmethod
     def provider() -> AuthProvider:
@@ -73,7 +75,9 @@ class AuthHandlerInterface(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> AuthenticateRequest:
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> AuthenticateRequest:
         """
         Make an AuthenticationRequest.
 
@@ -102,8 +106,15 @@ class AuthHandlerInterface(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    def prepare(self, auth_req: AuthenticateRequest, thread_id: str, profile: str,
-                future_uid: str, *args, **kwargs) -> str:
+    def prepare(
+        self,
+        auth_req: AuthenticateRequest,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
         """
         Performs preliminary tasks required for authentication.
 
@@ -124,7 +135,9 @@ class AuthHandlerInterface(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    async def authenticate(self, auth_req: AuthenticateRequest, future_uid: str, *args, **kwargs) -> AuthContext:
+    async def authenticate(
+        self, auth_req: AuthenticateRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
         """
         Performs the actual authentication process.
 
@@ -149,7 +162,9 @@ class AuthHandlerInterface(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    async def refresh(self, auth_req: AuthenticateRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+    async def refresh(
+        self, auth_req: AuthenticateRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
         """
         Performs re-authentication for an expired session.
 

hyperpocket/auth/linear/token_context.py

@@ -3,13 +3,10 @@ from hyperpocket.auth.linear.token_schema import LinearTokenResponse
 
 
 class LinearTokenAuthContext(LinearAuthContext):
-
     @classmethod
     def from_linear_token_response(cls, response: LinearTokenResponse):
-        description = 'Linear Token Context logged in'
+        description = "Linear 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
         )