hyperpocket 0.0.3__py3-none-any.whl → 0.1.8__py3-none-any.whl

hyperpocket/auth/README.md

@@ -236,15 +236,15 @@ class AuthHandlerInterface(ABC):
     - This class perform the actual prepare, authenticate, and refresh steps.
 
 5. Add a new enum value to the `AuthProvider` Enum(only implement new auth provider)
-    - If a new `AuthProvider` is added, update the `AuthProvider` enum in `pocket/auth/provider.py`
+    - If a new `AuthProvider` is added, update the `AuthProvider` enum in `hyperpocket/auth/provider.py`
 
 6. Add new auth callback server endpoint
-    - Add the endpoint under `pocket/server/auth/` packages.
+    - Add the endpoint under `hyperpocket/server/auth/` packages.
     - Declare an appropriate `APIRouter` in the package. Pocket will automatically register the endpoint during
       initialization.
 
 7. Add test code(optional)
-    - Add the test code under `pocket/auth/tests/` packages.
+    - Add the test code under `hyperpocket/auth/tests/` packages.
 
 ---
 

hyperpocket/auth/__init__.py

@@ -1,14 +1,6 @@
 from hyperpocket.auth.context import AuthContext
-from hyperpocket.auth.github.context import GitHubAuthContext
-from hyperpocket.auth.github.oauth2_context import GitHubOAuth2AuthContext
-from hyperpocket.auth.github.token_context import GitHubTokenAuthContext
-from hyperpocket.auth.google.context import GoogleAuthContext
-from hyperpocket.auth.google.oauth2_context import GoogleOAuth2AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
-from hyperpocket.auth.linear.token_context import LinearTokenAuthContext
 from hyperpocket.auth.provider import AuthProvider
-from hyperpocket.auth.slack.oauth2_context import SlackOAuth2AuthContext
-from hyperpocket.auth.slack.token_context import SlackTokenAuthContext
 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)

hyperpocket/auth/gumloop/context.py

@@ -0,0 +1,13 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class GumLoopContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "GUMLOOP_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/gumloop/token_context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.gumloop.context import GumLoopContext
+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
+        )

hyperpocket/auth/gumloop/token_handler.py

@@ -0,0 +1,66 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthHandlerInterface, AuthContext, 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/auth/gumloop/token_schema.py

@@ -0,0 +1,8 @@
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class GumloopTokenRequest(AuthenticateRequest):
+    pass
+
+class GumloopTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/linear/token_context.py

@@ -6,7 +6,7 @@ class LinearTokenAuthContext(LinearAuthContext):
 
     @classmethod
     def from_linear_token_response(cls, response: LinearTokenResponse):
-        description = f'Linear Token Context logged in'
+        description = 'Linear Token Context logged in'
 
         return cls(
             access_token=response.access_token,

hyperpocket/auth/notion/README.md

@@ -0,0 +1,28 @@
+### Notion Token Auth
+
+This module provides authentication using Notion tokens.
+
+1. To use this authentication in your tool, include the following in your `config.toml`:
+
+```toml
+[auth]
+auth_provider = "notion"
+auth_handler = "notion-token"
+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.NOTION
+)
+def my_function(**kwargs):
+    token = kwargs["NOTION_TOKEN"]
+
+    # ...
+```

hyperpocket/auth/notion/context.py

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

@@ -0,0 +1,14 @@
+from hyperpocket.auth.notion.context import NotionAuthContext
+from hyperpocket.auth.notion.token_schema import NotionTokenResponse
+
+
+class NotionTokenAuthContext(NotionAuthContext):
+    @classmethod
+    def from_notion_token_response(cls, response: NotionTokenResponse):
+        description = 'Notion Token Context logged in'
+
+        return cls(
+            access_token=response.access_token,
+            description=description,
+            expires_at=None
+        )

hyperpocket/auth/notion/token_handler.py

@@ -0,0 +1,65 @@
+
+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
+from hyperpocket.auth.notion.token_context import NotionTokenAuthContext
+from hyperpocket.auth.notion.token_schema import NotionTokenResponse, NotionTokenRequest
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class NotionTokenAuthHandler(AuthHandlerInterface):
+    name: str = "notion-token"
+    description: str = "This handler is used to authenticate users using the Notion 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.NOTION
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(self, auth_req: NotionTokenRequest, 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/notion/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: NotionTokenRequest, future_uid: str, *args, **kwargs) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = NotionTokenResponse(access_token=access_token)
+        context = NotionTokenAuthContext.from_notion_token_response(response)
+
+        return context
+
+    async def refresh(self, auth_req: NotionTokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+        raise Exception("Notion token doesn't support refresh")
+
+    def _make_auth_url(self, auth_req: NotionTokenRequest, 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) -> NotionTokenRequest:
+        return NotionTokenRequest()

hyperpocket/auth/notion/token_schema.py

@@ -0,0 +1,10 @@
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class NotionTokenRequest(AuthenticateRequest):
+    pass
+
+
+class NotionTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/provider.py

@@ -2,11 +2,14 @@ from enum import Enum
 
 
 class AuthProvider(Enum):
-    SLACK = 'slack'
-    LINEAR = 'linear'
-    GITHUB = 'github'
-    GOOGLE = 'google'
-    CALENDLY = 'calendly'
+    SLACK = "slack"
+    LINEAR = "linear"
+    GITHUB = "github"
+    GOOGLE = "google"
+    CALENDLY = "calendly"
+    NOTION = "notion"
+    REDDIT = "reddit"
+    GUMLOOP = "gumloop"
 
     @classmethod
     def get_auth_provider(cls, auth_provider_name: str) -> "AuthProvider":

hyperpocket/auth/reddit/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class RedditAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "REDDIT_BOT_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/reddit/oauth2_context.py

@@ -0,0 +1,32 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.reddit.context import RedditAuthContext
+from hyperpocket.auth.reddit.oauth2_schema import RedditOAuth2Response
+
+
+class RedditOAuth2AuthContext(RedditAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_reddit_oauth2_response(cls, response: RedditOAuth2Response):
+        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=expires_in)
+        else:
+            expires_at = None
+
+        return cls(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            description="Reddit OAuth2 authentication context",
+            detail=response,
+        )

hyperpocket/auth/reddit/oauth2_handler.py

@@ -0,0 +1,151 @@
+import base64
+from os import access
+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.reddit.oauth2_context import RedditOAuth2AuthContext
+from hyperpocket.auth.reddit.oauth2_schema import (
+    RedditOAuth2Response,
+    RedditOAuth2Request,
+)
+from hyperpocket.config import config as config
+from hyperpocket.futures import FutureStore
+
+
+class RedditOAuth2AuthHandler(AuthHandlerInterface):
+    _REDDIT_OAUTH_URL: str = "https://www.reddit.com/api/v1/authorize"
+    _REDDIT_TOKEN_URL: str = "https://www.reddit.com/api/v1/access_token"
+
+    name: str = "reddit-oauth2"
+    description: str = "This handler is used to authenticate users using the Reddit OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.REDDIT
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        if config.auth.reddit.use_recommended_scope:
+            recommended_scopes = {"account", "identity", "read"}
+        else:
+            recommended_scopes = {}
+        return recommended_scopes
+
+    def prepare(
+        self,
+        auth_req: RedditOAuth2Request,
+        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/reddit/oauth2/callback",
+        )
+        print(f"redirect_uri: {redirect_uri}")
+        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: RedditOAuth2Request, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        auth_code = await future_data.future
+
+        basic_auth = f"{auth_req.client_id}:{auth_req.client_secret}"
+        basic_auth_encoded = base64.b64encode(basic_auth.encode()).decode()
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._REDDIT_TOKEN_URL,
+                data={
+                    "code": auth_code,
+                    "redirect_uri": future_data.data["redirect_uri"],
+                    "grant_type": "authorization_code",
+                },
+                headers={
+                    "Authorization": f"Basic {basic_auth_encoded}",
+                },
+            )
+        if resp.status_code != 200:
+            raise Exception(f"failed to authenticate. status_code : {resp.status_code}")
+
+        resp_json = resp.json()
+
+        resp_typed = RedditOAuth2Response(**resp_json)
+        return RedditOAuth2AuthContext.from_reddit_oauth2_response(resp_typed)
+
+    async def refresh(
+        self, auth_req: RedditOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        reddit_context: RedditOAuth2AuthContext = context
+        refresh_token = reddit_context.refresh_token
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._REDDIT_TOKEN_URL,
+                data={
+                    "client_id": config.auth.reddit.client_id,
+                    "client_secret": config.auth.reddit.client_secret,
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                },
+            )
+
+        if resp.status_code != 200:
+            raise Exception(f"failed to refresh. status_code : {resp.status_code}")
+
+        resp_json = resp.json()
+
+        new_resp: RedditOAuth2Response = RedditOAuth2Response(
+            access_token=resp_json["access_token"],
+            token_type=resp_json["token_type"],
+            expires_in=resp_json["expires_in"],
+            scope=resp_json["scope"],
+        )
+
+        return RedditOAuth2AuthContext.from_reddit_oauth2_response(new_resp)
+
+    def _make_auth_url(self, req: RedditOAuth2Request, redirect_uri: str, state: str):
+        params = {
+            "scope": ",".join(req.auth_scopes),
+            "client_id": req.client_id,
+            "redirect_uri": redirect_uri,
+            "state": state,
+            "response_type": "code",
+            "duration": "permanent",
+        }
+        auth_url = f"{self._REDDIT_OAUTH_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> RedditOAuth2Request:
+        return RedditOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config.auth.reddit.client_id,
+            client_secret=config.auth.reddit.client_secret,
+        )

hyperpocket/auth/reddit/oauth2_schema.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class RedditOAuth2Request(AuthenticateRequest):
+    client_id: str
+    client_secret: str
+
+
+class RedditOAuth2Response(AuthenticateResponse):
+    access_token: Optional[str] = None
+    token_type: Optional[str] = None
+    refresh_token: Optional[str] = None
+    expires_in: Optional[int] = None
+    scope: Optional[str] = None

hyperpocket/auth/slack/token_context.py

@@ -5,7 +5,7 @@ from hyperpocket.auth.slack.token_schema import SlackTokenResponse
 class SlackTokenAuthContext(SlackAuthContext):
     @classmethod
     def from_slack_token_response(cls, response: SlackTokenResponse):
-        description = f'Slack Token Context logged in'
+        description = 'Slack Token Context logged in'
 
         return cls(
             access_token=response.access_token,

hyperpocket/builtin.py

@@ -0,0 +1,63 @@
+from typing import List
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.pocket_auth import PocketAuth
+from hyperpocket.tool import from_func, Tool
+
+
+def get_builtin_tools(pocket_auth: PocketAuth) -> List[Tool]:
+    """
+    Get Builtin Tools
+
+    Builtin Tool can access to Pocket Core.
+    """
+
+    def __get_current_thread_session_state(thread_id: str = "default") -> str:
+        """
+        This tool retrieves the current session state list for the specified thread.
+
+        The tool should only be called when a user explicitly requests to view their session information.
+
+        The output includes a list of session states in the format:
+        - `[AUTH PROVIDER] [state] [scopes, ...] : explanation`
+
+        It does not contain any sensitive information.
+
+        Args:
+        - thread_id (str): Thread ID
+
+        Returns:
+        - str: A list of session states describing the current authentication status.
+
+        This tool ensures transparency about the current session but must respect user-driven intent and should never be called automatically or without a specific user request.
+        """
+        session_list = pocket_auth.list_session_state(thread_id)
+        return str(session_list)
+
+    def __delete_session(auth_provider_name: str, thread_id: str = "default", profile: str = "default") -> str:
+        """
+        This tool deletes a saved session for a specified authentication provider in the given thread and profile.
+
+        The tool should only be called when a user explicitly requests to delete a session.
+
+        Args:
+        - auth_provider_name (str): The name of the authentication provider for the session to be deleted.
+        - thread_id (str): Thread ID
+        - profile (str): Profile
+
+        Returns:
+        - str: A flag indicating whether the session was successfully deleted.
+
+        This tool should only be used in response to a user's explicit intent to manage their sessions. Automatic or unauthorized invocation is strictly prohibited.
+        """
+
+        auth_provider = AuthProvider.get_auth_provider(auth_provider_name)
+        is_deleted = pocket_auth.delete_session(auth_provider, thread_id, profile)
+        return str(is_deleted)
+
+    builtin_tools = [
+        from_func(func=__get_current_thread_session_state),
+        from_func(func=__delete_session),
+    ]
+
+    return builtin_tools

hyperpocket/cli/__main__.py

@@ -1,12 +1,24 @@
 import click
 
 from hyperpocket.cli.pull import pull
+from hyperpocket.cli.sync import sync
+from hyperpocket.cli.eject import eject
+from hyperpocket.cli.auth import create_token_auth_template
 
 
 @click.group()
 def cli():
     pass
 
+@click.group()
+def devtool():
+    pass
+
+cli.add_command(devtool)
+devtool.add_command(create_token_auth_template)
+
 cli.add_command(pull)
+cli.add_command(sync)
+cli.add_command(eject)
 
 cli()