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

hyperpocket/auth/ngrok/token_handler.py

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

hyperpocket/auth/ngrok/token_schema.py

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

hyperpocket/auth/notion/README.md

@@ -1,28 +1,18 @@
-### Notion Token Auth
+# Notion Authentication
 
-This module provides authentication using Notion tokens.
+This document provides instructions on how to set up token-based authentication for Notion using Hyperpocket.
 
-1. To use this authentication in your tool, include the following in your `config.toml`:
+## Supported Authentication Types
 
-```toml
-[auth]
-auth_provider = "notion"
-auth_handler = "notion-token"
-scopes = []
-```
+- OAuth2
+- Token
 
-2. To use it with `function_tool`, you can define your function as follows:
+## How to Create an OAuth2 App
 
-```python
-from hyperpocket.tool import function_tool
-from hyperpocket.auth import AuthProvider
+- See here: [link](https://developers.notion.com/docs/authorization)
 
+## Additional Resources
+
+- [Official Documentation](https://developers.notion.com/)
 
-@function_tool(
-    auth_provider=AuthProvider.NOTION
-)
-def my_function(**kwargs):
-    token = kwargs["NOTION_TOKEN"]
 
-    # ...
-```

hyperpocket/auth/notion/oauth2_context.py

@@ -0,0 +1,33 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.notion.context import NotionAuthContext
+from hyperpocket.auth.notion.oauth2_schema import NotionOAuth2Response
+
+
+class NotionOAuth2AuthContext(NotionAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_notion_oauth2_response(cls, response: NotionOAuth2Response):
+        description = f"Notion 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,
+        )

hyperpocket/auth/notion/oauth2_handler.py

@@ -0,0 +1,152 @@
+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.notion.oauth2_context import NotionOAuth2AuthContext
+from hyperpocket.auth.notion.oauth2_schema import (
+    NotionOAuth2Response,
+    NotionOAuth2Request,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class NotionOAuth2AuthHandler(AuthHandlerInterface):
+    _NOTION_OAUTH_URL: str = "https://api.notion.com/v1/oauth/authorize"  # e.g. "https://slack.com/oauth/v2/authorize"
+    _NOTION_TOKEN_URL: str = "https://api.notion.com/v1/oauth/token"  # e.g. "https://slack.com/api/oauth.v2.access"
+
+    name: str = "notion-oauth2"
+    description: str = "This handler is used to authenticate users using the Notion OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.NOTION
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        """
+        This method returns a set of recommended scopes for the service.
+        If the service has a recommended scope, it should be returned here.
+        Example:
+        return {
+            "channels:history",
+            "channels:read",
+            "chat:write",
+            "groups:history",
+            "groups:read",
+            "im:history",
+            "mpim:history",
+            "reactions:read",
+            "reactions:write",
+        }
+        """
+        return set()
+
+    def prepare(
+        self,
+        auth_req: NotionOAuth2Request,
+        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/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: NotionOAuth2Request, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        auth_code = await future_data.future
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._NOTION_TOKEN_URL,
+                auth=(auth_req.client_id, auth_req.client_secret),
+                data={
+                    "code": auth_code,
+                    "redirect_uri": future_data.data["redirect_uri"],
+                    "grant_type": "authorization_code",
+                },
+            )
+        resp.raise_for_status()
+        resp_json = resp.json()
+        resp_typed = NotionOAuth2Response(**resp_json)
+        return NotionOAuth2AuthContext.from_notion_oauth2_response(resp_typed)
+
+    async def refresh(
+        self, auth_req: NotionOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        notion_context: NotionOAuth2AuthContext = context
+        refresh_token = notion_context.refresh_token
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._NOTION_TOKEN_URL,
+                auth=(auth_req.client_id, auth_req.client_secret),
+                data={
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                    "redirect_uri": urljoin(
+                        config().public_base_url + "/",
+                        f"{config().callback_url_rewrite_prefix}/auth/notion/oauth2/callback",
+                    ),
+                },
+            )
+
+        resp.raise_for_status()
+        resp_json = resp.json()
+
+        new_resp = NotionOAuth2Response(
+            access_token=resp_json["access_token"],
+            refresh_token=resp_json["refresh_token"],
+            expires_in=resp_json["expires_in"],
+        )
+
+        return NotionOAuth2AuthContext.from_notion_oauth2_response(new_resp)
+
+    def _make_auth_url(self, req: NotionOAuth2Request, redirect_uri: str, state: str):
+        params = {
+            "client_id": req.client_id,
+            "redirect_uri": redirect_uri,
+            "response_type": "code",
+            "owner": "user",
+            "state": state,
+        }
+        auth_url = f"{self._NOTION_OAUTH_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> NotionOAuth2Request:
+        return NotionOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config().auth.notion.client_id,
+            client_secret=config().auth.notion.client_secret,
+        )

hyperpocket/auth/notion/oauth2_schema.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class NotionOAuth2Request(AuthenticateRequest):
+    client_id: str
+    client_secret: str
+
+
+class NotionOAuth2Response(AuthenticateResponse):
+    access_token: Optional[str] = None
+    bot_id: Optional[str] = None
+    duplicated_template_id: Optional[str] = None
+    owner: Optional[dict] = None
+    workspace_id: Optional[str] = None
+    workspace_name: Optional[str] = None
+    workspace_icon: Optional[str] = None
+    refresh_token: Optional[str] = None
+    expires_in: Optional[int] = None

hyperpocket/auth/oncehub/README.md

@@ -0,0 +1,11 @@
+# Oncehub Authentication
+
+This document provides instructions on how to set up token-based authentication for Oncehub using Hyperpocket.
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://www.oncehub.com/api)

hyperpocket/auth/oncehub/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.oncehub.context import OncehubAuthContext
+from hyperpocket.auth.oncehub.token_schema import OncehubTokenResponse
+
+
+class OncehubTokenAuthContext(OncehubAuthContext):
+    @classmethod
+    def from_oncehub_token_response(cls, response: OncehubTokenResponse):
+        description = f"Oncehub Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/oncehub/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.oncehub.token_context import OncehubTokenAuthContext
+from hyperpocket.auth.oncehub.token_schema import (
+    OncehubTokenResponse,
+    OncehubTokenRequest,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class OncehubTokenAuthHandler(AuthHandlerInterface):
+    name: str = "oncehub-token"
+    description: str = (
+        "This handler is used to authenticate users using the Oncehub 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.ONCEHUB
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: OncehubTokenRequest,
+        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/oncehub/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: OncehubTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = OncehubTokenResponse(access_token=access_token)
+        context = OncehubTokenAuthContext.from_oncehub_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: OncehubTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Oncehub token doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: OncehubTokenRequest, 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
+    ) -> OncehubTokenRequest:
+        return OncehubTokenRequest()

hyperpocket/auth/oncehub/token_schema.py

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

hyperpocket/auth/pagerduty/README.md

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

hyperpocket/auth/pagerduty/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.pagerduty.context import PagerdutyAuthContext
+from hyperpocket.auth.pagerduty.token_schema import PagerdutyTokenResponse
+
+
+class PagerdutyTokenAuthContext(PagerdutyAuthContext):
+    @classmethod
+    def from_pagerduty_token_response(cls, response: PagerdutyTokenResponse):
+        description = f"Pagerduty Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/pagerduty/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.pagerduty.token_context import PagerdutyTokenAuthContext
+from hyperpocket.auth.pagerduty.token_schema import (
+    PagerdutyTokenResponse,
+    PagerdutyTokenRequest,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class PagerdutyTokenAuthHandler(AuthHandlerInterface):
+    name: str = "pagerduty-token"
+    description: str = (
+        "This handler is used to authenticate users using the Pagerduty 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.PAGERDUTY
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: PagerdutyTokenRequest,
+        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/pagerduty/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: PagerdutyTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = PagerdutyTokenResponse(access_token=access_token)
+        context = PagerdutyTokenAuthContext.from_pagerduty_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: PagerdutyTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Pagerduty token doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: PagerdutyTokenRequest, 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
+    ) -> PagerdutyTokenRequest:
+        return PagerdutyTokenRequest()

hyperpocket/auth/pagerduty/token_schema.py

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

hyperpocket/auth/pandadoc/README.md

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

hyperpocket/auth/pandadoc/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class PandadocAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "PANDADOC_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,
+        }