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

hyperpocket/server/auth/adobe.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+adobe_auth_router = APIRouter(prefix="/adobe")
+
+
+@adobe_auth_router.get("/token/callback")
+async def adobe_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/affinity.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+affinity_auth_router = APIRouter(prefix="/affinity")
+
+
+@affinity_auth_router.get("/token/callback")
+async def affinity_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/agentql.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+agentql_auth_router = APIRouter(prefix="/agentql")
+
+
+@agentql_auth_router.get("/oauth2/callback")
+async def agentql_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@agentql_auth_router.get("/token/callback")
+async def agentql_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/ahrefs.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+ahrefs_auth_router = APIRouter(prefix="/ahrefs")
+
+
+@ahrefs_auth_router.get("/token/callback")
+async def ahrefs_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/airtable.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+airtable_auth_router = APIRouter(prefix="/airtable")
+
+
+@airtable_auth_router.get("/token/callback")
+async def airtable_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/alchemy.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+alchemy_auth_router = APIRouter(prefix="/alchemy")
+
+
+@alchemy_auth_router.get("/token/callback")
+async def alchemy_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/altoviz.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+altoviz_auth_router = APIRouter(prefix="/altoviz")
+
+
+@altoviz_auth_router.get("/token/callback")
+async def altoviz_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/asana.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+asana_auth_router = APIRouter(prefix="/asana")
+
+
+@asana_auth_router.get("/oauth2/callback")
+async def asana_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@asana_auth_router.get("/token/callback")
+async def asana_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/bamboohr.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+bamboohr_auth_router = APIRouter(prefix="/bamboohr")
+
+
+@bamboohr_auth_router.get("/token/callback")
+async def bamboohr_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/bitbucket.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+bitbucket_auth_router = APIRouter(prefix="/bitbucket")
+
+
+@bitbucket_auth_router.get("/oauth2/callback")
+async def bitbucket_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@bitbucket_auth_router.get("/token/callback")
+async def bitbucket_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/bitwarden.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+bitwarden_auth_router = APIRouter(prefix="/bitwarden")
+
+
+@bitwarden_auth_router.get("/token/callback")
+async def bitwarden_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/brevo.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+brevo_auth_router = APIRouter(prefix="/brevo")
+
+
+@brevo_auth_router.get("/token/callback")
+async def brevo_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/brex.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+brex_auth_router = APIRouter(prefix="/brex")
+
+
+@brex_auth_router.get("/token/callback")
+async def brex_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/cal.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+cal_auth_router = APIRouter(prefix="/cal")
+
+
+@cal_auth_router.get("/token/callback")
+async def cal_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/canvas.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+canvas_auth_router = APIRouter(prefix="/canvas")
+
+
+@canvas_auth_router.get("/token/callback")
+async def canvas_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/clickup.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+clickup_auth_router = APIRouter(prefix="/clickup")
+
+
+@clickup_auth_router.get("/token/callback")
+async def clickup_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/cloudflare.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+cloudflare_auth_router = APIRouter(prefix="/cloudflare")
+
+
+@cloudflare_auth_router.get("/token/callback")
+async def cloudflare_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/dailybot.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+dailybot_auth_router = APIRouter(prefix="/dailybot")
+
+
+@dailybot_auth_router.get("/token/callback")
+async def dailybot_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/datadog.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+datadog_auth_router = APIRouter(prefix="/datadog")
+
+
+@datadog_auth_router.get("/token/callback")
+async def datadog_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/discord.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+discord_auth_router = APIRouter(prefix="/discord")
+
+
+@discord_auth_router.get("/oauth2/callback")
+async def discord_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@discord_auth_router.get("/token/callback")
+async def discord_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/discordbot.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+discordbot_auth_router = APIRouter(prefix="/discordbot")
+
+
+@discordbot_auth_router.get("/token/callback")
+async def discordbot_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/elevenlabs.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+elevenlabs_auth_router = APIRouter(prefix="/elevenlabs")
+
+
+@elevenlabs_auth_router.get("/token/callback")
+async def elevenlabs_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/exa.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+exa_auth_router = APIRouter(prefix="/exa")
+
+
+@exa_auth_router.get("/token/callback")
+async def exa_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/facebook.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+facebook_auth_router = APIRouter(prefix="/facebook")
+
+
+@facebook_auth_router.get("/oauth2/callback")
+async def facebook_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@facebook_auth_router.get("/token/callback")
+async def facebook_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/finage.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+finage_auth_router = APIRouter(prefix="/finage")
+
+
+@finage_auth_router.get("/token/callback")
+async def finage_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/happyrobot.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+
+from hyperpocket.futures import FutureStore
+
+happyrobot_auth_router = APIRouter(prefix="/happyrobot")
+
+
+@happyrobot_auth_router.get("/oauth2/callback")
+async def happyrobot_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@happyrobot_auth_router.get("/token/callback")
+async def happyrobot_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/heygen.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+heygen_auth_router = APIRouter(prefix="/heygen")
+
+
+@heygen_auth_router.get("/token/callback")
+async def heygen_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/hubspot.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+
+from hyperpocket.futures import FutureStore
+
+hubspot_auth_router = APIRouter(prefix="/hubspot")
+
+
+@hubspot_auth_router.get("/oauth2/callback")
+async def hubspot_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@hubspot_auth_router.get("/token/callback")
+async def hubspot_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/jira.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+jira_auth_router = APIRouter(prefix="/jira")
+
+
+@jira_auth_router.get("/oauth2/callback")
+async def jira_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@jira_auth_router.get("/token/callback")
+async def jira_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/klaviyo.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+klaviyo_auth_router = APIRouter(prefix="/klaviyo")
+
+
+@klaviyo_auth_router.get("/token/callback")
+async def klaviyo_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/lever.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+lever_auth_router = APIRouter(prefix="/lever")
+
+
+@lever_auth_router.get("/token/callback")
+async def lever_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/lever_sandbox.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+lever_sandbox_auth_router = APIRouter(prefix="/lever_sandbox")
+
+
+@lever_sandbox_auth_router.get("/token/callback")
+async def lever_sandbox_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")

hyperpocket/server/auth/linear.py

@@ -1,13 +1,32 @@
 from fastapi import APIRouter
 from starlette.responses import HTMLResponse
-
 from hyperpocket.futures import FutureStore
 
 linear_auth_router = APIRouter(prefix="/linear")
 
 
+@linear_auth_router.get("/oauth2/callback")
+async def linear_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@linear_auth_router.get("/oauth2/callback")
+async def linear_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
 @linear_auth_router.get("/token/callback")
-async def slack_token_callback(state: str, token: str):
+async def linear_token_callback(state: str, token: str):
     try:
         FutureStore.resolve_future(state, token)
     except ValueError:

hyperpocket/server/auth/linkedin.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+linkedin_auth_router = APIRouter(prefix="/linkedin")
+
+
+@linkedin_auth_router.get("/oauth2/callback")
+async def linkedin_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@linkedin_auth_router.get("/token/callback")
+async def linkedin_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/listennotes.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+listennotes_auth_router = APIRouter(prefix="/listennotes")
+
+
+@listennotes_auth_router.get("/token/callback")
+async def listennotes_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+    return HTMLResponse(content="success")