hyperpocket 0.3.2__tar.gz → 0.3.4__tar.gz

{hyperpocket-0.3.2 → hyperpocket-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.3.2
+Version: 0.3.4
 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

hyperpocket-0.3.4/hyperpocket/auth/apitoken/README.md

@@ -0,0 +1,28 @@
+### API Token Auth
+
+This module provides authentication using simple API tokens.
+
+1. To use this authentication in your tool, include the following in your `config.toml`:
+
+```toml
+[auth]
+auth_provider = "apitoken"
+auth_handler = "apitoken"
+scopes = []
+```
+
+2. To use it with `function_tool`, you can define your function as follows:
+
+```python
+from hyperpocket.tool import function_tool
+from hyperpocket.auth import AuthProvider
+
+
+@function_tool(
+    auth_provider=AuthProvider.API_TOKEN
+)
+def my_function(**kwargs):
+    token = kwargs["API_TOKEN"]
+
+    # ...
+```

hyperpocket-0.3.4/hyperpocket/auth/apitoken/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class ApiTokenAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "API_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-0.3.4/hyperpocket/auth/apitoken/token_context.py

@@ -0,0 +1,12 @@
+from hyperpocket.auth.apitoken.context import ApiTokenAuthContext
+from hyperpocket.auth.apitoken.token_schema import ApiTokenResponse
+
+
+class ApiTokenAuthContext(ApiTokenAuthContext):
+    @classmethod
+    def from_api_token_response(cls, response: ApiTokenResponse):
+        description = "Api Token Context logged in"
+
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket-0.3.4/hyperpocket/auth/apitoken/token_handler.py

@@ -0,0 +1,89 @@
+from typing import Optional
+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.apitoken.token_context import ApiTokenAuthContext
+from hyperpocket.auth.apitoken.token_schema import ApiTokenRequest, ApiTokenResponse
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class ApiTokenAuthHandler(AuthHandlerInterface):
+    name: str = "apitoken"
+    description: str = "This handler is used to authenticate users using the Api 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.APITOKEN
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    def prepare(
+        self,
+        auth_req: ApiTokenRequest,
+        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/apitoken/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: ApiTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = ApiTokenResponse(access_token=access_token)
+        context = ApiTokenAuthContext.from_api_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: ApiTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Api token doesn't support refresh")
+
+    def _make_auth_url(self, auth_req: ApiTokenRequest, 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
+    ) -> ApiTokenRequest:
+        return ApiTokenRequest()

hyperpocket-0.3.4/hyperpocket/auth/apitoken/token_schema.py

@@ -0,0 +1,9 @@
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class ApiTokenRequest(AuthenticateRequest):
+    pass
+
+
+class ApiTokenResponse(AuthenticateResponse):
+    access_token: str

{hyperpocket-0.3.2 → hyperpocket-0.3.4}/hyperpocket/auth/provider.py

@@ -10,7 +10,9 @@ class AuthProvider(Enum):
     NOTION = "notion"
     REDDIT = "reddit"
     GUMLOOP = "gumloop"
+    SERPAPI = "serpapi"
     X = "x"
+    APITOKEN = "apitoken"
 
     @classmethod
     def get_auth_provider(cls, auth_provider_name: str) -> "AuthProvider":

hyperpocket-0.3.4/hyperpocket/auth/serpapi/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class SerpapiAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "SERPAPI_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-0.3.4/hyperpocket/auth/serpapi/token_context.py

@@ -0,0 +1,13 @@
+from hyperpocket.auth.serpapi.context import SerpapiAuthContext
+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'
+        return cls(
+            access_token=response.access_token,
+            description=description,
+            expires_at=None
+        )

hyperpocket-0.3.4/hyperpocket/auth/serpapi/token_handler.py

@@ -0,0 +1,68 @@
+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.serpapi.token_context import SerpapiTokenAuthContext
+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."
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(config().public_base_url + "/", f"{config().callback_url_rewrite_prefix}/auth/token")
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.SERPAPI
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    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,
+        })
+
+        return f'User needs to authenticate using the following URL: {url}'
+
+    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
+
+        response = SerpapiTokenResponse(access_token=access_token)
+        context = SerpapiTokenAuthContext.from_serpapi_token_response(response)
+
+        return context
+
+    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):
+        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) -> SerpapiTokenRequest:
+        return SerpapiTokenRequest()

hyperpocket-0.3.4/hyperpocket/auth/serpapi/token_schema.py

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

hyperpocket-0.3.4/hyperpocket/server/auth/apitoken.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+
+from hyperpocket.futures import FutureStore
+
+api_token_auth_router = APIRouter(prefix="/apitoken")
+
+
+@api_token_auth_router.get("/token/callback")
+async def notion_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket-0.3.4/hyperpocket/server/auth/serpapi.py

@@ -0,0 +1,14 @@
+
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+serpapi_auth_router = APIRouter(
+    prefix="/serpapi"
+)
+@serpapi_auth_router.get("/token/callback")
+async def serpapi_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

{hyperpocket-0.3.2 → hyperpocket-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperpocket"
-version = "0.3.2"
+version = "0.3.4"
 description = "Building AI agent with hyperpocket tool in a flash"
 authors = [{ name = "Hyperpocket Team", email = "hyperpocket@vessl.ai" }]
 requires-python = ">=3.10"