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

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

hyperpocket/auth/pipedrive/token_schema.py

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

hyperpocket/auth/posthog/README.md

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

hyperpocket/auth/posthog/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.posthog.context import PosthogAuthContext
+from hyperpocket.auth.posthog.token_schema import PosthogTokenResponse
+
+
+class PosthogTokenAuthContext(PosthogAuthContext):
+    @classmethod
+    def from_posthog_token_response(cls, response: PosthogTokenResponse):
+        description = f"Posthog Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/posthog/token_schema.py

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

hyperpocket/auth/provider.py

@@ -10,7 +10,66 @@ class AuthProvider(Enum):
     NOTION = "notion"
     REDDIT = "reddit"
     GUMLOOP = "gumloop"
+    SERPAPI = "serpapi"
     X = "x"
+    JIRA = "jira"
+    SENDGRID = "sendgird"
+    POSTHOG = "posthog"
+    PAGERDUTY = "pagerduty"
+    PIPEDRIVE = "pipedrive"
+    KLAVIYO = "klaviyo"
+    BREVO = "brevo"
+    BAMBOOHR = "bamboohr"
+    CAL = "cal"
+    CLICKUP = "clickup"
+    SUPABASE = "supabase"
+    NEON = "neon"
+    CANVAS = "canvas"
+    ELEVENLABS = "elevenlabs"
+    AHREFS = "ahrefs"
+    MEM0 = "mem0"
+    HEYGEN = "heygen"
+    LISTENNOTES = "listennotes"
+    STRIPE = "stripe"
+    AFFINITY = "affinity"
+    TRELLO = "trello"
+    HUBSPOT = "hubspot"
+    DISCORD = "discord"
+    DISCORDBOT = "discordbot"
+    MICROSOFT_CLARITY = "microsoft_clarity"
+    LEVER_SANDBOX = "lever_sandbox"
+    ALTOVIZ = "altoviz"
+    RAVENSEOTOOLS = "ravenseotools"
+    BREX = "brex"
+    BITWARDEN = "bitwarden"
+    DATADOG = "datadog"
+    ONCEHUB = "oncehub"
+    LEVER = "lever"
+    NGROK = "ngrok"
+    PANDADOC = "pandadoc"
+    TIMEKIT = "timekit"
+    FINAGE = "finage"
+    DAILYBOT = "dailybot"
+    WORKIOM = "workiom"
+    ALCHEMY = "alchemy"
+    CLOUDFLARE = "cloudflare"
+    ADOBE = "adobe"
+    TAVILY = "tavily"
+    EXA = "exa"
+    AIRTABLE = "airtable"
+    BITBUCKET = "bitbucket"
+    MAILCHIMP = "mailchimp"
+    ASANA = "asana"
+    ZOOM = "zoom"
+    SALESFORCE = "salesforce"
+    SPOTIFY = "spotify"
+    FACEBOOK = "facebook"
+    ACTIVELOOP = "activeloop"
+    AGENTQL = "agentql"
+    HAPPYROBOT = "happyrobot"
+    LINKEDIN = "linkedin"
+    WANDB = "wandb"
+    APITOKEN = "apitoken"
 
     @classmethod
     def get_auth_provider(cls, auth_provider_name: str) -> "AuthProvider":

hyperpocket/auth/ravenseotools/README.md

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

hyperpocket/auth/ravenseotools/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.ravenseotools.context import RavenseotoolsAuthContext
+from hyperpocket.auth.ravenseotools.token_schema import RavenseotoolsTokenResponse
+
+
+class RavenseotoolsTokenAuthContext(RavenseotoolsAuthContext):
+    @classmethod
+    def from_ravenseotools_token_response(cls, response: RavenseotoolsTokenResponse):
+        description = f"Ravenseotools Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/ravenseotools/token_handler.py

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

hyperpocket/auth/ravenseotools/token_schema.py

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

hyperpocket/auth/reddit/README.md

@@ -0,0 +1,16 @@
+# Reddit Authentication
+
+This document provides instructions on how to set up OAuth2 authentication for Reddit using Hyperpocket.
+
+## Supported Authentication Types
+
+- OAuth2
+
+## How to Create an OAuth2 App
+
+- See here: [link](https://github.com/reddit-archive/reddit/wiki/OAuth2)
+
+## Additional Resources
+
+- [Official Documentation](https://www.reddit.com/dev/api)
+- [Support](https://www.reddit.com/r/redditdev/) 

hyperpocket/auth/salesforce/README.md

@@ -0,0 +1,16 @@
+# Salesforce Authentication
+
+This document provides instructions on how to set up OAuth2 authentication for Salesforce using Hyperpocket.
+
+## Supported Authentication Types
+
+- OAuth2
+
+## How to Create an OAuth2 App
+
+- See here: [link](https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/intro_oauth_and_connected_apps.htm)
+
+## Additional Resources
+
+- [Official Documentation](https://developer.salesforce.com/docs)
+- [Support](https://help.salesforce.com) 

hyperpocket/auth/salesforce/context.py

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

@@ -0,0 +1,33 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.salesforce.context import SalesforceAuthContext
+from hyperpocket.auth.salesforce.oauth2_schema import SalesforceOAuth2Response
+
+
+class SalesforceOAuth2AuthContext(SalesforceAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_salesforce_oauth2_response(cls, response: SalesforceOAuth2Response):
+        description = f"Salesforce 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=60 * 60)  # 1 hour
+        else:
+            expires_at = None
+
+        return cls(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            description=description,
+            detail=response,
+        )