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

hyperpocket/auth/discord/oauth2_handler.py

@@ -0,0 +1,133 @@
+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.discord.oauth2_context import DiscordOAuth2AuthContext
+from hyperpocket.auth.discord.oauth2_schema import (
+    DiscordOAuth2Response,
+    DiscordOAuth2Request,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class DiscordOAuth2AuthHandler(AuthHandlerInterface):
+    _DISCORD_OAUTH_URL: str = "https://discord.com/oauth2/authorize"
+    _DISCORD_TOKEN_URL: str = "https://discord.com/api/oauth2/token"
+
+    name: str = "discord-oauth2"
+    description: str = "This handler is used to authenticate users using the Discord OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.DISCORD
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: DiscordOAuth2Request,
+        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/discord/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: DiscordOAuth2Request, 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:
+            headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+            resp = await client.post(
+                url=self._DISCORD_TOKEN_URL,
+                data={
+                    "grant_type": "authorization_code",
+                    "code": auth_code,
+                    "redirect_uri": future_data.data["redirect_uri"],
+                },
+                auth=(auth_req.client_id, auth_req.client_secret),
+                headers=headers,
+            )
+
+        resp.raise_for_status()
+        resp_json = resp.json()
+        resp_typed = DiscordOAuth2Response(**resp_json)
+        return DiscordOAuth2AuthContext.from_discord_oauth2_response(resp_typed)
+
+    async def refresh(
+        self, auth_req: DiscordOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        discord_context: DiscordOAuth2AuthContext = context
+        refresh_token = discord_context.refresh_token
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._DISCORD_TOKEN_URL,
+                data={
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                },
+                auth=(auth_req.client_id, auth_req.client_secret),
+            )
+
+        resp.raise_for_status()
+        resp_json = resp.json()
+        new_resp = DiscordOAuth2Response(**resp_json)
+
+        return DiscordOAuth2AuthContext.from_discord_oauth2_response(new_resp)
+
+    def _make_auth_url(self, req: DiscordOAuth2Request, redirect_uri: str, state: str):
+        params = {
+            "response_type": "code",
+            "client_id": req.client_id,
+            "scope": " ".join(req.auth_scopes),
+            "state": state,
+            "redirect_uri": redirect_uri,
+            "prompt": "consent",
+            "integration_type": 1,  # user token
+        }
+        auth_url = f"{self._DISCORD_OAUTH_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> DiscordOAuth2Request:
+        return DiscordOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config().auth.discord.client_id,
+            client_secret=config().auth.discord.client_secret,
+        )

hyperpocket/auth/discord/oauth2_schema.py

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

hyperpocket/auth/discord/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.discord.context import DiscordAuthContext
+from hyperpocket.auth.discord.token_schema import DiscordTokenResponse
+
+
+class DiscordTokenAuthContext(DiscordAuthContext):
+    @classmethod
+    def from_discord_token_response(cls, response: DiscordTokenResponse):
+        description = f"Discord Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/discord/token_schema.py

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

hyperpocket/auth/discordbot/README.md

@@ -0,0 +1,14 @@
+# Discordbot Authentication
+
+## Supported Authentication Types
+
+- OAuth2
+- Token
+
+## How to Create a Token
+
+- See here: [link](https://discord.com/developers/docs/topics/oauth2)
+
+## Additional Resources
+
+- [Official Documentation](https://discord.com/developers/docs)

hyperpocket/auth/discordbot/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.discordbot.context import DiscordbotAuthContext
+from hyperpocket.auth.discordbot.token_schema import DiscordbotTokenResponse
+
+
+class DiscordbotTokenAuthContext(DiscordbotAuthContext):
+    @classmethod
+    def from_discordbot_token_response(cls, response: DiscordbotTokenResponse):
+        description = f"Discordbot Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/discordbot/token_schema.py

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

hyperpocket/auth/elevenlabs/README.md

@@ -0,0 +1,9 @@
+# Elevenlabs Authentication
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://docs.elevenlabs.com)

hyperpocket/auth/elevenlabs/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.elevenlabs.context import ElevenlabsAuthContext
+from hyperpocket.auth.elevenlabs.token_schema import ElevenlabsTokenResponse
+
+
+class ElevenlabsTokenAuthContext(ElevenlabsAuthContext):
+    @classmethod
+    def from_elevenlabs_token_response(cls, response: ElevenlabsTokenResponse):
+        description = f"Elevenlabs Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/elevenlabs/token_schema.py

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

hyperpocket/auth/exa/README.md

@@ -0,0 +1,9 @@
+# Exa Authentication
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://docs.exa.com)

hyperpocket/auth/exa/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.exa.context import ExaAuthContext
+from hyperpocket.auth.exa.token_schema import ExaTokenResponse
+
+
+class ExaTokenAuthContext(ExaAuthContext):
+    @classmethod
+    def from_exa_token_response(cls, response: ExaTokenResponse):
+        description = f"Exa Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )