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

hyperpocket/server/auth/mailchimp.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+mailchimp_auth_router = APIRouter(prefix="/mailchimp")
+
+
+@mailchimp_auth_router.get("/oauth2/callback")
+async def mailchimp_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@mailchimp_auth_router.get("/token/callback")
+async def mailchimp_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/mem0.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+mem0_auth_router = APIRouter(prefix="/mem0")
+
+
+@mem0_auth_router.get("/token/callback")
+async def mem0_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/microsoft_clarity.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+microsoft_clarity_auth_router = APIRouter(prefix="/microsoft_clarity")
+
+
+@microsoft_clarity_auth_router.get("/token/callback")
+async def microsoft_clarity_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/neon.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+neon_auth_router = APIRouter(prefix="/neon")
+
+
+@neon_auth_router.get("/token/callback")
+async def neon_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/ngrok.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+ngrok_auth_router = APIRouter(prefix="/ngrok")
+
+
+@ngrok_auth_router.get("/token/callback")
+async def ngrok_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/notion.py

@@ -1,11 +1,30 @@
 from fastapi import APIRouter
 from starlette.responses import HTMLResponse
-
 from hyperpocket.futures import FutureStore
 
 notion_auth_router = APIRouter(prefix="/notion")
 
 
+@notion_auth_router.get("/oauth2/callback")
+async def notion_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@notion_auth_router.get("/oauth2/callback")
+async def notion_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
 @notion_auth_router.get("/token/callback")
 async def notion_token_callback(state: str, token: str):
     try:

hyperpocket/server/auth/oncehub.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+oncehub_auth_router = APIRouter(prefix="/oncehub")
+
+
+@oncehub_auth_router.get("/token/callback")
+async def oncehub_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/pagerduty.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+pagerduty_auth_router = APIRouter(prefix="/pagerduty")
+
+
+@pagerduty_auth_router.get("/token/callback")
+async def pagerduty_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/pandadoc.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+pandadoc_auth_router = APIRouter(prefix="/pandadoc")
+
+
+@pandadoc_auth_router.get("/token/callback")
+async def pandadoc_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/pipedrive.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+pipedrive_auth_router = APIRouter(prefix="/pipedrive")
+
+
+@pipedrive_auth_router.get("/token/callback")
+async def pipedrive_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/posthog.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+posthog_auth_router = APIRouter(prefix="/posthog")
+
+
+@posthog_auth_router.get("/token/callback")
+async def posthog_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/ravenseotools.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+ravenseotools_auth_router = APIRouter(prefix="/ravenseotools")
+
+
+@ravenseotools_auth_router.get("/token/callback")
+async def ravenseotools_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/salesforce.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+salesforce_auth_router = APIRouter(prefix="/salesforce")
+
+
+@salesforce_auth_router.get("/oauth2/callback")
+async def salesforce_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@salesforce_auth_router.get("/token/callback")
+async def salesforce_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/sendgrid.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+sendgrid_auth_router = APIRouter(prefix="/sendgrid")
+
+
+@sendgrid_auth_router.get("/token/callback")
+async def sendgrid_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/serpapi.py

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

hyperpocket/server/auth/spotify.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+spotify_auth_router = APIRouter(prefix="/spotify")
+
+
+@spotify_auth_router.get("/oauth2/callback")
+async def spotify_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@spotify_auth_router.get("/token/callback")
+async def spotify_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/stripe.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+stripe_auth_router = APIRouter(prefix="/stripe")
+
+
+@stripe_auth_router.get("/token/callback")
+async def stripe_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/supabase.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+supabase_auth_router = APIRouter(prefix="/supabase")
+
+
+@supabase_auth_router.get("/token/callback")
+async def supabase_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/tavily.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+tavily_auth_router = APIRouter(prefix="/tavily")
+
+
+@tavily_auth_router.get("/token/callback")
+async def tavily_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/timekit.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+timekit_auth_router = APIRouter(prefix="/timekit")
+
+
+@timekit_auth_router.get("/token/callback")
+async def timekit_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/trello.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+trello_auth_router = APIRouter(prefix="/trello")
+
+
+@trello_auth_router.get("/token/callback")
+async def trello_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/wandb.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+wandb_auth_router = APIRouter(prefix="/wandb")
+
+
+@wandb_auth_router.get("/oauth2/callback")
+async def wandb_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@wandb_auth_router.get("/token/callback")
+async def wandb_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/workiom.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+workiom_auth_router = APIRouter(prefix="/workiom")
+
+
+@workiom_auth_router.get("/token/callback")
+async def workiom_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/zoom.py

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

hyperpocket/server/server.py

@@ -165,19 +165,22 @@ class PocketServer(object):
 
         error_queue = mp.Queue()
         self.pipe = mp.Pipe()
-        self.process = mp.Process(
-            target=self._run, args=(pocket_core, )
-        )
+        self.process = mp.Process(target=self._run, args=(pocket_core,))
         self.process.start()  # process start
 
         if not error_queue.empty():
             error_message = error_queue.get()
             raise error_message
-    
+
     def _report_initialized(self, error: Optional[Exception] = None):
         _, conn = self.pipe
-        conn.send(('server-initialization', error,))
-    
+        conn.send(
+            (
+                "server-initialization",
+                error,
+            )
+        )
+
     def wait_initialized(self):
         conn, _ = self.pipe
         while True:

{hyperpocket-0.3.4.dist-info → hyperpocket-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.3.4
+Version: 0.3.5
 Summary: Building AI agent with hyperpocket tool in a flash
 Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
 Project-URL: Repository, https://github.com/vessl-ai/hyperpocket