hyperpocket 0.1.10__tar.gz → 0.2.0__tar.gz

{hyperpocket-0.1.10 → hyperpocket-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.1.10
+Version: 0.2.0
 Summary: Building AI agent with hyperpocket tool in a flash
 Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
 Project-URL: Repository, https://github.com/vessl-ai/hyperpocket
@@ -23,13 +23,14 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: uvicorn>=0.32.1
 Description-Content-Type: text/markdown
 
+<p align="center">
+<img src="../../logo.png" alt="hyperpocket" width="570"/>
+</p>
+
 # Hyperpocket 👛
 
 Hyperpocket is where tools belong. Power your agent up with a pocket of tools. 👛
 
-<figure>
-<img src="../../logo.png" alt="hyperpocket" width="200"/>
-</figure>
 
 ## Introduction
 
@@ -160,13 +161,15 @@ graph_builder.compile()
 ```
 
 ```python
+import os
+
 from llama_index.core.agent import FunctionCallingAgent
 from llama_index.llms.openai import OpenAI
 
 from hyperpocket.config import secret
 from hyperpocket_llamaindex import PocketLlamaindex
 
-llm = OpenAI(api_key=secret["OPENAI_API_KEY"])
+llm = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 pocket = PocketLlamaindex(
   tools=[
     "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
@@ -318,3 +321,6 @@ scopes = []
 )
 def my_function(**kwargs):
 ```
+
+## Special thanks
+- [tott](https://x.com/tott____) for drawing the cute possum in a pocket.

{hyperpocket-0.1.10 → hyperpocket-0.2.0}/README.md

@@ -1,10 +1,11 @@
+<p align="center">
+<img src="../../logo.png" alt="hyperpocket" width="570"/>
+</p>
+
 # Hyperpocket 👛
 
 Hyperpocket is where tools belong. Power your agent up with a pocket of tools. 👛
 
-<figure>
-<img src="../../logo.png" alt="hyperpocket" width="200"/>
-</figure>
 
 ## Introduction
 
@@ -135,13 +136,15 @@ graph_builder.compile()
 ```
 
 ```python
+import os
+
 from llama_index.core.agent import FunctionCallingAgent
 from llama_index.llms.openai import OpenAI
 
 from hyperpocket.config import secret
 from hyperpocket_llamaindex import PocketLlamaindex
 
-llm = OpenAI(api_key=secret["OPENAI_API_KEY"])
+llm = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 pocket = PocketLlamaindex(
   tools=[
     "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
@@ -293,3 +296,6 @@ scopes = []
 )
 def my_function(**kwargs):
 ```
+
+## Special thanks
+- [tott](https://x.com/tott____) for drawing the cute possum in a pocket.

{hyperpocket-0.1.10 → hyperpocket-0.2.0}/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-0.2.0/hyperpocket/auth/__init__.py

@@ -0,0 +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,
+)
+
+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)
+}
+
+__all__ = [
+    "PREBUILT_AUTH_HANDLERS",
+    "AUTH_CONTEXT_MAP",
+    "AuthProvider",
+    "AuthHandlerInterface",
+]

{hyperpocket-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.1.10 → hyperpocket-0.2.0}/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-0.2.0/hyperpocket/auth/gumloop/token_handler.py

@@ -0,0 +1,94 @@
+from typing import Optional
+from urllib.parse import urlencode, urljoin
+
+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.schema import AuthenticateRequest
+from hyperpocket.config import config
+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"
+    )
+    scoped: bool = False
+
+    _TOKEN_URL = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.GUMLOOP
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    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:
+        redirect_uri = urljoin(
+            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,
+            },
+        )
+
+        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:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = GumloopTokenResponse(access_token=access_token)
+        context = GumLoopTokenContext.from_gumloop_token_response(response)
+
+        return context
+
+    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
+    ):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        return f"{self._TOKEN_URL}?{urlencode(params)}"

{hyperpocket-0.1.10 → hyperpocket-0.2.0}/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