hyperpocket 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

hyperpocket/auth/salesforce/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class SalesforceAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "SALESFORCE_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/salesforce/oauth2_context.py

@@ -0,0 +1,33 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.salesforce.context import SalesforceAuthContext
+from hyperpocket.auth.salesforce.oauth2_schema import SalesforceOAuth2Response
+
+
+class SalesforceOAuth2AuthContext(SalesforceAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_salesforce_oauth2_response(cls, response: SalesforceOAuth2Response):
+        description = f"Salesforce OAuth2 Context logged in"
+        now = datetime.now(tz=timezone.utc)
+
+        access_token = response.access_token
+        refresh_token = response.refresh_token
+        expires_in = response.expires_in
+
+        if expires_in:
+            expires_at = now + timedelta(seconds=60 * 60)  # 1 hour
+        else:
+            expires_at = None
+
+        return cls(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            description=description,
+            detail=response,
+        )

hyperpocket/auth/salesforce/oauth2_handler.py

@@ -0,0 +1,136 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+import httpx
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface
+from hyperpocket.auth.salesforce.oauth2_context import SalesforceOAuth2AuthContext
+from hyperpocket.auth.salesforce.oauth2_schema import (
+    SalesforceOAuth2Response,
+    SalesforceOAuth2Request,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class SalesforceOAuth2AuthHandler(AuthHandlerInterface):
+    _SALESFORCE_OAUTH_URL: str = "{base_url}/services/oauth2/authorize"
+    _SALESFORCE_TOKEN_URL: str = "{base_url}/services/oauth2/token"
+
+    name: str = "salesforce-oauth2"
+    description: str = "This handler is used to authenticate users using the Salesforce OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.SALESFORCE
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: SalesforceOAuth2Request,
+        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/salesforce/oauth2/callback",
+        )
+        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,
+            },
+        )
+
+        return f"User needs to authenticate using the following URL: {auth_url}"
+
+    async def authenticate(
+        self, auth_req: SalesforceOAuth2Request, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        auth_code = await future_data.future
+        base_token_url = self._SALESFORCE_TOKEN_URL.format(
+            base_url=config().auth.salesforce.domain_url
+        )
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=base_token_url,
+                data={
+                    "grant_type": "authorization_code",
+                    "code": auth_code,
+                    "client_id": auth_req.client_id,
+                    "client_secret": auth_req.client_secret,
+                    "redirect_uri": future_data.data["redirect_uri"],
+                },
+            )
+        resp.raise_for_status()
+        resp_json = resp.json()
+        resp_typed = SalesforceOAuth2Response(**resp_json)
+        return SalesforceOAuth2AuthContext.from_salesforce_oauth2_response(resp_typed)
+
+    async def refresh(
+        self, auth_req: SalesforceOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        salesforce_context: SalesforceOAuth2AuthContext = context
+        refresh_token = salesforce_context.refresh_token
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._SALESFORCE_TOKEN_URL,
+                data={
+                    "client_id": auth_req.client_id,
+                    "client_secret": auth_req.client_secret,
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                },
+            )
+
+        resp.raise_for_status()
+        resp_json = resp.json()
+        new_resp = SalesforceOAuth2Response(**resp_json)
+
+        return SalesforceOAuth2AuthContext.from_salesforce_oauth2_response(new_resp)
+
+    def _make_auth_url(
+        self, req: SalesforceOAuth2Request, redirect_uri: str, state: str
+    ):
+        params = {
+            "scope": " ".join(req.auth_scopes),
+            "client_id": req.client_id,
+            "redirect_uri": redirect_uri,
+            "response_type": "code",
+            "state": state,
+        }
+        base_auth_url = self._SALESFORCE_OAUTH_URL.format(
+            base_url=config().auth.salesforce.domain_url
+        )
+        auth_url = f"{base_auth_url}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> SalesforceOAuth2Request:
+        return SalesforceOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config().auth.salesforce.client_id,
+            client_secret=config().auth.salesforce.client_secret,
+        )

hyperpocket/auth/salesforce/oauth2_schema.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class SalesforceOAuth2Request(AuthenticateRequest):
+    client_id: str
+    client_secret: str
+
+
+class SalesforceOAuth2Response(AuthenticateResponse):
+    access_token: str
+    signature: str
+    scope: str
+    id_token: str
+    instance_url: str
+    token_type: str
+    issued_at: str
+    refresh_token: Optional[str] = Field(default=None)

hyperpocket/auth/semantic_scholar/context.py

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

hyperpocket/auth/semantic_scholar/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.semantic_scholar.context import SemanticScholarAuthContext
+from hyperpocket.auth.semantic_scholar.token_schema import SemanticScholarTokenResponse
+class SemanticScholarTokenAuthContext(SemanticScholarAuthContext):
+    @classmethod
+    def from_semantic_scholar_token_response(cls, response: SemanticScholarTokenResponse):
+        description = f'SemanticScholar Token Context logged in'
+        return cls(
+            access_token=response.access_token,
+            description=description,
+            expires_at=None
+        )

hyperpocket/auth/semantic_scholar/token_handler.py

@@ -0,0 +1,64 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
+from hyperpocket.auth.semantic_scholar.token_context import SemanticScholarTokenAuthContext
+from hyperpocket.auth.semantic_scholar.token_schema import SemanticScholarTokenResponse, SemanticScholarTokenRequest
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class SemanticScholarTokenAuthHandler(AuthHandlerInterface):
+    name: str = "semantic-scholar-token"
+    description: str = "This handler is used to authenticate users using the SemanticScholar token."
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(config().public_base_url + "/", f"{config().callback_url_rewrite_prefix}/auth/token")
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.SEMANTIC_SCHOLAR
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(self, auth_req: SemanticScholarTokenRequest, 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/semantic_scholar/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,
+        })
+
+        return f'User needs to authenticate using the following URL: {url}'
+
+    async def authenticate(self, auth_req: SemanticScholarTokenRequest, future_uid: str, *args, **kwargs) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = SemanticScholarTokenResponse(access_token=access_token)
+        context = SemanticScholarTokenAuthContext.from_semantic_scholar_token_response(response)
+
+        return context
+
+    async def refresh(self, auth_req: SemanticScholarTokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+        raise Exception("SemanticScholar token doesn't support refresh")
+
+    def _make_auth_url(self, auth_req: SemanticScholarTokenRequest, redirect_uri: str, state: str):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> SemanticScholarTokenRequest:
+        return SemanticScholarTokenRequest()

hyperpocket/auth/semantic_scholar/token_schema.py

@@ -0,0 +1,7 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+class SemanticScholarTokenRequest(AuthenticateRequest):
+    pass
+class SemanticScholarTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/sendgrid/README.md

@@ -0,0 +1,12 @@
+# Sendgrid Authentication
+
+This document provides instructions on how to set up token-based authentication for Sendgrid using Hyperpocket.
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://sendgrid.com/docs)
+- [Support](https://support.sendgrid.com) 

hyperpocket/auth/sendgrid/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class SendgridAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "SENDGRID_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/sendgrid/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.sendgrid.context import SendgridAuthContext
+from hyperpocket.auth.sendgrid.token_schema import SendgridTokenResponse
+
+
+class SendgridTokenAuthContext(SendgridAuthContext):
+    @classmethod
+    def from_sendgrid_token_response(cls, response: SendgridTokenResponse):
+        description = f"Sendgrid Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/sendgrid/token_handler.py

@@ -0,0 +1,92 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
+from hyperpocket.auth.sendgrid.token_context import SendgridTokenAuthContext
+from hyperpocket.auth.sendgrid.token_schema import (
+    SendgridTokenResponse,
+    SendgridTokenRequest,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class SendgridTokenAuthHandler(AuthHandlerInterface):
+    name: str = "sendgrid-token"
+    description: str = (
+        "This handler is used to authenticate users using the Sendgrid token."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.SENDGRID
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: SendgridTokenRequest,
+        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/sendgrid/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,
+            },
+        )
+
+        return f"User needs to authenticate using the following URL: {url}"
+
+    async def authenticate(
+        self, auth_req: SendgridTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = SendgridTokenResponse(access_token=access_token)
+        context = SendgridTokenAuthContext.from_sendgrid_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: SendgridTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Sendgrid token doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: SendgridTokenRequest, redirect_uri: str, state: str
+    ):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> SendgridTokenRequest:
+        return SendgridTokenRequest()

hyperpocket/auth/sendgrid/token_schema.py

@@ -0,0 +1,11 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class SendgridTokenRequest(AuthenticateRequest):
+    pass
+
+
+class SendgridTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/serpapi/README.md

@@ -0,0 +1,13 @@
+# Serpapi Authentication
+
+This document provides instructions on how to set up token-based authentication for Serpapi using Hyperpocket.
+
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://serpapi.com/docs)
+- [Support](https://serpapi.com/contact) 

hyperpocket/auth/serpapi/token_context.py

@@ -5,9 +5,7 @@ from hyperpocket.auth.serpapi.token_schema import SerpapiTokenResponse
 class SerpapiTokenAuthContext(SerpapiAuthContext):
     @classmethod
     def from_serpapi_token_response(cls, response: SerpapiTokenResponse):
-        description = f'Serpapi Token Context logged in'
+        description = f"Serpapi 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/serpapi/token_handler.py

@@ -5,17 +5,25 @@ from hyperpocket.auth import AuthProvider
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
 from hyperpocket.auth.serpapi.token_context import SerpapiTokenAuthContext
-from hyperpocket.auth.serpapi.token_schema import SerpapiTokenResponse, SerpapiTokenRequest
+from hyperpocket.auth.serpapi.token_schema import (
+    SerpapiTokenResponse,
+    SerpapiTokenRequest,
+)
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 
 
 class SerpapiTokenAuthHandler(AuthHandlerInterface):
     name: str = "serpapi-token"
-    description: str = "This handler is used to authenticate users using the Serpapi token."
+    description: str = (
+        "This handler is used to authenticate users using the Serpapi 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_default() -> bool:
@@ -29,22 +37,36 @@ class SerpapiTokenAuthHandler(AuthHandlerInterface):
     def recommended_scopes() -> set[str]:
         return set()
 
-    def prepare(self, auth_req: SerpapiTokenRequest, thread_id: str, profile: str,
-                future_uid: str, *args, **kwargs) -> str:
+    def prepare(
+        self,
+        auth_req: SerpapiTokenRequest,
+        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/serpapi/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: SerpapiTokenRequest, future_uid: str, *args, **kwargs) -> AuthContext:
+    async def authenticate(
+        self, auth_req: SerpapiTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
         future_data = FutureStore.get_future(future_uid)
         access_token = await future_data.future
 
@@ -53,10 +75,14 @@ class SerpapiTokenAuthHandler(AuthHandlerInterface):
 
         return context
 
-    async def refresh(self, auth_req: SerpapiTokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+    async def refresh(
+        self, auth_req: SerpapiTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
         raise Exception("Serpapi token doesn't support refresh")
 
-    def _make_auth_url(self, auth_req: SerpapiTokenRequest, redirect_uri: str, state: str):
+    def _make_auth_url(
+        self, auth_req: SerpapiTokenRequest, redirect_uri: str, state: str
+    ):
         params = {
             "redirect_uri": redirect_uri,
             "state": state,
@@ -64,5 +90,7 @@ class SerpapiTokenAuthHandler(AuthHandlerInterface):
         auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
         return auth_url
 
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> SerpapiTokenRequest:
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> SerpapiTokenRequest:
         return SerpapiTokenRequest()

hyperpocket/auth/slack/README.md

@@ -0,0 +1,17 @@
+# Slack Authentication
+
+This document provides instructions on how to set up OAuth2 authentication for Slack using Hyperpocket.
+
+## Supported Authentication Types
+
+- Token
+- OAuth2
+
+## How to Create an OAuth2 App
+
+- See here: ]link](https://api.slack.com/authentication/oauth-v2)
+
+## Additional Resources
+
+- [Official Documentation](https://api.slack.com)
+- [Support](https://slack.com/help) 

hyperpocket/auth/spotify/README.md

@@ -0,0 +1,15 @@
+# Spotify Authentication
+
+This document provides instructions on how to set up OAuth2 authentication for Spotify using Hyperpocket.
+
+## Supported Authentication Types
+
+- OAuth2
+
+## How to Create an OAuth2 App
+
+- See here: [link](https://developer.spotify.com/documentation/web-api/concepts/authorization)
+
+## Additional Resources
+
+- [Official Documentation](https://developer.spotify.com/documentation/web-api/)

hyperpocket/auth/spotify/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class SpotifyAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "SPOTIFY_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/spotify/oauth2_context.py

@@ -0,0 +1,33 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.spotify.context import SpotifyAuthContext
+from hyperpocket.auth.spotify.oauth2_schema import SpotifyOAuth2Response
+
+
+class SpotifyOAuth2AuthContext(SpotifyAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_spotify_oauth2_response(cls, response: SpotifyOAuth2Response):
+        description = f"Spotify OAuth2 Context logged in"
+        now = datetime.now(tz=timezone.utc)
+
+        access_token = response.access_token
+        refresh_token = response.refresh_token
+        expires_in = response.expires_in
+
+        if expires_in:
+            expires_at = now + timedelta(seconds=response.expires_in)
+        else:
+            expires_at = None
+
+        return cls(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            description=description,
+            detail=response,
+        )