hyperpocket 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

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

hyperpocket/auth/ahrefs/token_schema.py

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

hyperpocket/auth/airtable/README.md

@@ -0,0 +1,8 @@
+# Airtable Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [Airtable API Documentation](https://airtable.com/api) 

hyperpocket/auth/airtable/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.airtable.context import AirtableAuthContext
+from hyperpocket.auth.airtable.token_schema import AirtableTokenResponse
+
+
+class AirtableTokenAuthContext(AirtableAuthContext):
+    @classmethod
+    def from_airtable_token_response(cls, response: AirtableTokenResponse):
+        description = f"Airtable Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/airtable/token_schema.py

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

hyperpocket/auth/alchemy/README.md

@@ -0,0 +1,8 @@
+# Alchemy Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [Alchemy API Documentation](https://docs.alchemy.com) 

hyperpocket/auth/alchemy/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.alchemy.context import AlchemyAuthContext
+from hyperpocket.auth.alchemy.token_schema import AlchemyTokenResponse
+
+
+class AlchemyTokenAuthContext(AlchemyAuthContext):
+    @classmethod
+    def from_alchemy_token_response(cls, response: AlchemyTokenResponse):
+        description = f"Alchemy Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/alchemy/token_schema.py

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

hyperpocket/auth/altoviz/README.md

@@ -0,0 +1,8 @@
+# Altoviz Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [Altoviz API Documentation](https://docs.altoviz.com) 

hyperpocket/auth/altoviz/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.altoviz.context import AltovizAuthContext
+from hyperpocket.auth.altoviz.token_schema import AltovizTokenResponse
+
+
+class AltovizTokenAuthContext(AltovizAuthContext):
+    @classmethod
+    def from_altoviz_token_response(cls, response: AltovizTokenResponse):
+        description = f"Altoviz Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/altoviz/token_schema.py

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

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/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/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
+        )