hyperpocket 0.5.4__tar.gz → 0.5.6__tar.gz

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/PKG-INFO

@@ -1,18 +1,19 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.5.4
+Version: 0.5.6
 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
 Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1.7
+Requires-Dist: cryptography>=44.0.0
 Requires-Dist: dynaconf>=3.2.6
 Requires-Dist: fastapi>=0.115.5
 Requires-Dist: gitpython>=3.1.43
 Requires-Dist: httpx==0.27
 Requires-Dist: jinja2>=3.1.4
-Requires-Dist: multiprocess>=0.70.17
+Requires-Dist: multiprocess>=0.70.16
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: pydantic>=2.10.2
 Requires-Dist: pygithub>=2.5.0
@@ -335,6 +336,24 @@ client_secret = "" # your slack client secret
 - in this case, by putting your slack app client_id and client_secret on `.secrets.toml`, you can manage your sensitive
   data more safely.
 
+#### When using Basic Auth
+
+IMPORTANT: You should update `auth_encryption_secret_key` in `{WORKDIR}/.secret.toml` with your own secret key.
+
+```toml
+[auth]
+auth_encryption_secret_key = "<YOUR_SECRET_KEY>"
+```
+
+The secret key should be a 32 Base64 encoded string.
+
+You can generate the secret key with the following command.
+
+```shell
+pip install cryptography
+python -c 'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())'
+```
+
 #### How to integrate github OAuth app
 
 1. Follow the github documentation to create a new OAuth

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/README.md

@@ -308,6 +308,24 @@ client_secret = "" # your slack client secret
 - in this case, by putting your slack app client_id and client_secret on `.secrets.toml`, you can manage your sensitive
   data more safely.
 
+#### When using Basic Auth
+
+IMPORTANT: You should update `auth_encryption_secret_key` in `{WORKDIR}/.secret.toml` with your own secret key.
+
+```toml
+[auth]
+auth_encryption_secret_key = "<YOUR_SECRET_KEY>"
+```
+
+The secret key should be a 32 Base64 encoded string.
+
+You can generate the secret key with the following command.
+
+```shell
+pip install cryptography
+python -c 'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())'
+```
+
 #### How to integrate github OAuth app
 
 1. Follow the github documentation to create a new OAuth

hyperpocket-0.5.6/hyperpocket/auth/basicauth/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.5.6/hyperpocket/auth/basicauth/basicauth_context.py

@@ -0,0 +1,14 @@
+from hyperpocket.auth.basicauth.context import BasicAuthContext
+from hyperpocket.auth.basicauth.basicauth_schema import (
+    BasicAuthResponse,
+)
+
+
+class BasicAuthContext(BasicAuthContext):
+    @classmethod
+    def from_api_token_response(cls, response: BasicAuthResponse):
+        description = "Api Token Context logged in"
+
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket-0.5.6/hyperpocket/auth/basicauth/basicauth_handler.py

@@ -0,0 +1,94 @@
+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.basicauth.basicauth_context import BasicAuthContext
+from hyperpocket.auth.basicauth.basicauth_schema import (
+    BasicAuthRequest,
+    BasicAuthResponse,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class BasicAuthHandler(AuthHandlerInterface):
+    name: str = "basicauth"
+    description: str = (
+        "This handler is used to authenticate users using the Basic Auth."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/basicauth",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.BASICAUTH
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    def prepare(
+        self,
+        auth_req: BasicAuthRequest,
+        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/basicauth/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: BasicAuthRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = BasicAuthResponse(access_token=access_token)
+        context = BasicAuthContext.from_api_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: BasicAuthRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Basic auth doesn't support refresh")
+
+    def _make_auth_url(self, auth_req: BasicAuthRequest, 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
+    ) -> BasicAuthRequest:
+        return BasicAuthRequest()

hyperpocket-0.5.6/hyperpocket/auth/basicauth/basicauth_schema.py

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

hyperpocket-0.5.6/hyperpocket/auth/basicauth/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class BasicAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "BASIC_AUTH"
+
+    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.5.4 → hyperpocket-0.5.6}/hyperpocket/auth/hubspot/oauth2_context.py

@@ -12,9 +12,7 @@ class HubspotOAuth2AuthContext(HubspotAuthContext):
 
     @classmethod
     def from_hubspot_oauth2_response(cls, response: HubspotOAuth2Response):
-        description = (
-            f"Hubspot OAuth2 Context logged in as a user {response.authed_user.id}"
-        )
+        description = "Hubspot OAuth2 Context logged in"
         now = datetime.now(tz=timezone.utc)
 
         access_token = response.access_token
@@ -22,7 +20,7 @@ class HubspotOAuth2AuthContext(HubspotAuthContext):
         expires_in = response.expires_in
 
         if expires_in:
-            expires_at = now + timedelta(seconds=response.authed_user.expires_in)
+            expires_at = now + timedelta(seconds=response.expires_in)
         else:
             expires_at = None
 

hyperpocket-0.5.6/hyperpocket/auth/linkedin/basicauth_context.py

@@ -0,0 +1,14 @@
+from hyperpocket.auth.linkedin.context import LinkedinAuthContext
+from hyperpocket.auth.linkedin.basicauth_schema import LinkedinBasicAuthResponse
+
+
+class LinkedinBasicAuthContext(LinkedinAuthContext):
+    _ACCESS_TOKEN_KEY: str = "LINKEDIN_BASIC_AUTH"
+
+    @classmethod
+    def from_api_token_response(cls, response: LinkedinBasicAuthResponse):
+        description = "Api Token Context logged in"
+
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket-0.5.6/hyperpocket/auth/linkedin/basicauth_handler.py

@@ -0,0 +1,97 @@
+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.config import config
+from hyperpocket.futures import FutureStore
+
+from hyperpocket.auth.linkedin.basicauth_context import LinkedinBasicAuthContext
+from hyperpocket.auth.linkedin.basicauth_schema import (
+    LinkedinBasicAuthRequest,
+    LinkedinBasicAuthResponse,
+)
+
+
+class LinkedinBasicAuthHandler(AuthHandlerInterface):
+    name: str = "linkedin-basicauth"
+    description: str = (
+        "This handler is used to authenticate users using the Basic Auth."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/basicauth",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.LINKEDIN
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    def prepare(
+        self,
+        auth_req: LinkedinBasicAuthRequest,
+        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/linkedin/basicauth/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: LinkedinBasicAuthRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = LinkedinBasicAuthResponse(access_token=access_token)
+        context = LinkedinBasicAuthContext.from_api_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: LinkedinBasicAuthRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Basic auth doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: LinkedinBasicAuthRequest, 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
+    ) -> LinkedinBasicAuthRequest:
+        return LinkedinBasicAuthRequest()

hyperpocket-0.5.6/hyperpocket/auth/linkedin/basicauth_schema.py

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

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/hyperpocket/auth/linkedin/oauth2_handler.py

@@ -29,7 +29,7 @@ class LinkedinOAuth2AuthHandler(AuthHandlerInterface):
 
     @staticmethod
     def provider_default() -> bool:
-        return True
+        return False
 
     @staticmethod
     def recommended_scopes() -> set[str]:

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/hyperpocket/auth/provider.py

@@ -75,6 +75,7 @@ class AuthProvider(Enum):
     WEAVIATE = "weaviate"
     VALYU = "valyu"
     KRAKEN = "kraken"
+    BASICAUTH = "basicauth"
 
     @classmethod
     def get_auth_provider(cls, auth_provider_name: str) -> "AuthProvider":

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/hyperpocket/config/auth.py

@@ -104,6 +104,7 @@ class AuthConfig(BaseModel):
     linear: Optional[LinearAuthConfig] = None
     facebook: Optional[FacebookAuthConfig] = None
     use_prebuilt_auth: bool = Field(default=True)
+    auth_encryption_secret_key: Optional[str] = Field(default=None)
 
 
 DefaultAuthConfig = AuthConfig()

hyperpocket-0.5.6/hyperpocket/server/auth/basicauth.py

@@ -0,0 +1,88 @@
+import base64
+from http import HTTPStatus
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+
+from cryptography.fernet import Fernet
+from fastapi import APIRouter, Form
+from starlette.responses import HTMLResponse, RedirectResponse
+
+from hyperpocket.config import config
+from hyperpocket.config.auth import DefaultAuthConfig
+from hyperpocket.futures import FutureStore
+
+default_router = APIRouter()
+
+
+@default_router.get("/basicauth", response_class=HTMLResponse)
+async def basicauth_form(redirect_uri: str, state: str = ""):
+    html = f"""    
+    <html>
+        <body>
+            <h2>Enter ID and Password</h2>
+                     <form action="submit" method="post">
+                <input type="hidden" name="redirect_uri" value="{redirect_uri}">
+                <input type="hidden" name="state" value="{state}">
+                
+                <label for="username">Username:</label>
+                <input type="text" id="username" name="username" required>
+                
+                <label for="password">Password:</label>
+                <input type="password" id="password" name="password" required>
+                
+                <button type="submit">submit</button>
+            </form>
+        </body>
+    </html>
+    """
+    return HTMLResponse(content=html)
+
+
+@default_router.post("/submit", response_class=RedirectResponse)
+async def submit_basicauth(
+    username: str = Form(...),
+    password: str = Form(...),
+    redirect_uri: str = Form(...),
+    state: str = Form(...),
+):
+    token = f"{username}:{password}"
+    base64_token = base64.b64encode(token.encode()).decode("utf-8")
+    key = config().auth.auth_encryption_secret_key.encode()
+    encrypted = Fernet(key).encrypt(base64_token.encode()).decode()
+    new_callback_url = add_query_params(
+        redirect_uri, {"token": encrypted, "state": state}
+    )
+    return RedirectResponse(url=new_callback_url, status_code=HTTPStatus.SEE_OTHER)
+
+
+def add_query_params(url: str, params: dict):
+    url_parts = urlparse(url)
+    query_params = parse_qs(url_parts.query)
+    query_params.update(params)
+    new_query = urlencode(query_params, doseq=True)
+
+    new_url = urlunparse(
+        (
+            url_parts.scheme,
+            url_parts.netloc,
+            url_parts.path,
+            url_parts.params,
+            new_query,
+            url_parts.fragment,
+        )
+    )
+    return new_url
+
+
+basicauth_router = APIRouter(prefix="/basicauth")
+
+
+@basicauth_router.get("/basicauth/callback")
+async def basicauth_basicauth_callback(state: str, token: str):
+    try:
+        key = DefaultAuthConfig.auth_encryption_secret_key.encode()
+        decrypted = Fernet(key).decrypt(token.encode()).decode()
+        FutureStore.resolve_future(state, decrypted)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/hyperpocket/server/auth/linkedin.py

@@ -1,5 +1,8 @@
+from cryptography.fernet import Fernet
 from fastapi import APIRouter
 from starlette.responses import HTMLResponse
+
+from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 
 linkedin_auth_router = APIRouter(prefix="/linkedin")
@@ -15,10 +18,12 @@ async def linkedin_oauth2_callback(state: str, code: str):
     return HTMLResponse(content="success")
 
 
-@linkedin_auth_router.get("/token/callback")
-async def linkedin_token_callback(state: str, token: str):
+@linkedin_auth_router.get("/basicauth/callback")
+async def linkedin_basicauth_callback(state: str, token: str):
     try:
-        FutureStore.resolve_future(state, token)
+        key = config().auth.auth_encryption_secret_key.encode()
+        decrypted = Fernet(key).decrypt(token.encode()).decode()
+        FutureStore.resolve_future(state, decrypted)
     except ValueError:
         return HTMLResponse(content="failed")
 

hyperpocket-0.5.6/hyperpocket/util/convert_pydantic_to_dict.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def convert_pydantic_to_dict(data: Any):
+    if isinstance(data, BaseModel):
+        return data.model_dump()
+    elif isinstance(data, dict):
+        return {key: convert_pydantic_to_dict(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [convert_pydantic_to_dict(item) for item in data]
+
+    return data

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperpocket"
-version = "0.5.4"
+version = "0.5.6"
 description = "Building AI agent with hyperpocket tool in a flash"
 authors = [{ name = "Hyperpocket Team", email = "hyperpocket@vessl.ai" }]
 requires-python = ">=3.10"
@@ -15,12 +15,13 @@ dependencies = [
     "toml>=0.10.2",
     "jinja2>=3.1.4",
     "pygithub>=2.5.0",
-    "multiprocess>=0.70.17",
+    "multiprocess>=0.70.16",
     "gitpython>=3.1.43",
     "redis>=5.2.1",
     "dynaconf>=3.2.6",
     "nest-asyncio>=1.6.0",
     "python-multipart>=0.0.18",
+    "cryptography>=44.0.0",
 ]
 
 [project.urls]

{hyperpocket-0.5.4 → hyperpocket-0.5.6}/uv.lock

@@ -438,6 +438,7 @@ version = "0.3.6"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
+    { name = "cryptography" },
     { name = "dynaconf" },
     { name = "fastapi" },
     { name = "gitpython" },
@@ -471,13 +472,14 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "click", specifier = ">=8.1.7" },
+    { name = "cryptography", specifier = ">=44.0.0" },
     { name = "dynaconf", specifier = ">=3.2.6" },
     { name = "fastapi", specifier = ">=0.115.5" },
     { name = "gitpython", specifier = ">=3.1.43" },
     { name = "httpx", specifier = "==0.27" },
     { name = "hyperdock-container", marker = "extra == 'standard'", editable = "../docks/hyperdock-container" },
     { name = "jinja2", specifier = ">=3.1.4" },
-    { name = "multiprocess", specifier = ">=0.70.17" },
+    { name = "multiprocess", specifier = ">=0.70.16" },
     { name = "nest-asyncio", specifier = ">=1.6.0" },
     { name = "pydantic", specifier = ">=2.10.2" },
     { name = "pygithub", specifier = ">=2.5.0" },
@@ -829,7 +831,7 @@ version = "0.0.20"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e1/f4/ddd0fcdc454cf3870153ae16a818256523d31c3c8136e216bc6836ed4cd1/python_multipart-0.0.19-py3-none-any.whl", hash = "sha256:f8d5b0b9c618575bf9df01c684ded1d94a338839bdd8223838afacfb4bb2082d", size = 24448 },
+    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546 },
 ]
 
 [[package]]