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

hyperpocket/auth/spotify/oauth2_handler.py

@@ -0,0 +1,163 @@
+import base64
+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.spotify.oauth2_context import SpotifyOAuth2AuthContext
+from hyperpocket.auth.spotify.oauth2_schema import (
+    SpotifyOAuth2Response,
+    SpotifyOAuth2Request,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class SpotifyOAuth2AuthHandler(AuthHandlerInterface):
+    _SPOTIFY_OAUTH_URL: str = "https://accounts.spotify.com/authorize"
+    _SPOTIFY_TOKEN_URL: str = "https://accounts.spotify.com/api/token"
+
+    name: str = "spotify-oauth2"
+    description: str = "This handler is used to authenticate users using the Spotify OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.SPOTIFY
+
+    @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: SpotifyOAuth2Request,
+        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/spotify/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: SpotifyOAuth2Request, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        auth_code = await future_data.future
+
+        auth_string = (
+            f"{config().auth.spotify.client_id}:{config().auth.spotify.client_secret}"
+        )
+        auth_bytes = auth_string.encode("utf-8")
+        auth_base64 = base64.b64encode(auth_bytes).decode("utf-8")
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._SPOTIFY_TOKEN_URL,
+                data={
+                    "code": auth_code,
+                    "redirect_uri": future_data.data["redirect_uri"],
+                    "grant_type": "authorization_code",
+                },
+                headers={
+                    "content-type": "application/x-www-form-urlencoded",
+                    "Authorization": f"Basic {auth_base64}",
+                },
+            )
+        resp.raise_for_status()
+        resp_json = resp.json()
+        resp_typed = SpotifyOAuth2Response(**resp_json)
+        return SpotifyOAuth2AuthContext.from_spotify_oauth2_response(resp_typed)
+
+    async def refresh(
+        self, auth_req: SpotifyOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        spotify_context: SpotifyOAuth2AuthContext = context
+        refresh_token = spotify_context.refresh_token
+
+        auth_string = (
+            f"{config().auth.spotify.client_id}:{config().auth.spotify.client_secret}"
+        )
+        auth_bytes = auth_string.encode("utf-8")
+        auth_base64 = base64.b64encode(auth_bytes).decode("utf-8")
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._SPOTIFY_TOKEN_URL,
+                data={
+                    "client_id": auth_req.client_id,
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                },
+                headers={
+                    "content-type": "application/x-www-form-urlencoded",
+                    "Authorization": f"Basic {auth_base64}",
+                },
+            )
+
+        resp.raise_for_status()
+        resp_json = resp.json()
+        new_resp = SpotifyOAuth2Response(**resp_json)
+
+        return SpotifyOAuth2AuthContext.from_spotify_oauth2_response(new_resp)
+
+    def _make_auth_url(self, req: SpotifyOAuth2Request, redirect_uri: str, state: str):
+        params = {
+            "response_type": "code",
+            "client_id": req.client_id,
+            "scope": " ".join(req.auth_scopes),
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._SPOTIFY_OAUTH_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> SpotifyOAuth2Request:
+        return SpotifyOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config().auth.spotify.client_id,
+            client_secret=config().auth.spotify.client_secret,
+        )

hyperpocket/auth/spotify/oauth2_schema.py

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

hyperpocket/auth/stripe/README.md

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

hyperpocket/auth/stripe/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.stripe.context import StripeAuthContext
+from hyperpocket.auth.stripe.token_schema import StripeTokenResponse
+
+
+class StripeTokenAuthContext(StripeAuthContext):
+    @classmethod
+    def from_stripe_token_response(cls, response: StripeTokenResponse):
+        description = f"Stripe Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/stripe/token_schema.py

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

hyperpocket/auth/supabase/README.md

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

hyperpocket/auth/supabase/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.supabase.context import SupabaseAuthContext
+from hyperpocket.auth.supabase.token_schema import SupabaseTokenResponse
+
+
+class SupabaseTokenAuthContext(SupabaseAuthContext):
+    @classmethod
+    def from_supabase_token_response(cls, response: SupabaseTokenResponse):
+        description = f"Supabase Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/supabase/token_schema.py

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

hyperpocket/auth/tavily/README.md

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

hyperpocket/auth/tavily/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.tavily.context import TavilyAuthContext
+from hyperpocket.auth.tavily.token_schema import TavilyTokenResponse
+
+
+class TavilyTokenAuthContext(TavilyAuthContext):
+    @classmethod
+    def from_tavily_token_response(cls, response: TavilyTokenResponse):
+        description = f"Tavily Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/tavily/token_schema.py

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

hyperpocket/auth/timekit/README.md

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

hyperpocket/auth/timekit/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.timekit.context import TimekitAuthContext
+from hyperpocket.auth.timekit.token_schema import TimekitTokenResponse
+
+
+class TimekitTokenAuthContext(TimekitAuthContext):
+    @classmethod
+    def from_timekit_token_response(cls, response: TimekitTokenResponse):
+        description = f"Timekit Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )