polyapi-python 0.2.4.dev3__tar.gz → 0.2.4.dev5__tar.gz

{polyapi_python-0.2.4.dev3/polyapi_python.egg-info → polyapi_python-0.2.4.dev5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.2.4.dev3
-Summary: The PolyAPI Python Client
+Version: 0.2.4.dev5
+Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
         

{polyapi_python-0.2.4.dev3 → polyapi_python-0.2.4.dev5}/polyapi/error_handler.py

@@ -6,7 +6,10 @@ from typing import Any, Callable, Dict, List, Optional
 from polyapi.config import get_api_key_and_url
 
 
+# all active webhook handlers, used by unregister_all to cleanup
 active_handlers: List[Dict[str, Any]] = []
+
+# global client shared by all error handlers, will be initialized by webhook.start
 client = None
 
 
@@ -47,7 +50,7 @@ async def on(
     print(f"starting error handler for {path}...")
 
     if not client:
-        raise Exception("Client not initialized. Please call error_handler.prepare() first.")
+        raise Exception("Client not initialized. Abort!")
 
     api_key, _ = get_api_key_and_url()
     handler_id = None

{polyapi_python-0.2.4.dev3 → polyapi_python-0.2.4.dev5}/polyapi/execute.py

@@ -11,7 +11,7 @@ def execute(function_type, function_id, data) -> Response:
     headers = {"Authorization": f"Bearer {api_key}"}
     url = f"{api_url}/functions/{function_type}/{function_id}/execute"
     resp = requests.post(url, json=data, headers=headers)
-    if resp.status_code != 200 and resp.status_code != 201:
+    if resp.status_code < 200 or resp.status_code >= 400:
         error_content = resp.content.decode("utf-8", errors="ignore")
         raise PolyApiException(f"{resp.status_code}: {error_content}")
     return resp

{polyapi_python-0.2.4.dev3 → polyapi_python-0.2.4.dev5}/polyapi/poly_custom.py

@@ -1,4 +1,7 @@
-polyCustom = {
+from typing import Dict, Any
+
+
+polyCustom: Dict[str, Any] = {
   "executionId": None,
   "executionApiKey": None,
   "responseStatusCode": 200,

polyapi_python-0.2.4.dev5/polyapi/webhook.py

@@ -0,0 +1,129 @@
+import asyncio
+import socketio  # type: ignore
+import uuid
+from typing import Any, Dict, List, Tuple
+
+from polyapi.config import get_api_key_and_url
+from polyapi.typedefs import PropertySpecification
+
+# all active webhook handlers, used by unregister_all to cleanup
+active_handlers: List[Dict[str, Any]] = []
+
+# global client shared by all webhooks, will be initialized by webhook.start
+client = None
+
+
+WEBHOOK_TEMPLATE = """
+
+
+async def {function_name}(callback, options=None):
+    \"""{description}
+
+    Function ID: {function_id}
+    \"""
+    from polyapi.webhook import client, active_handlers
+
+    print("Starting webhook for {function_name}...")
+
+    if not client:
+        raise Exception("Client not initialized. Abort!")
+
+    options = options or {{}}
+    eventsClientId = "{client_id}"
+    function_id = "{function_id}"
+
+    api_key, base_url = get_api_key_and_url()
+
+    def registerCallback(registered: bool):
+        if registered:
+            client.on('handleWebhookEvent:{function_id}', handleEvent, namespace="/events")
+        else:
+            print("Could not set register webhook event handler for {function_id}")
+
+    async def handleEvent(data):
+        nonlocal api_key
+        nonlocal options
+        polyCustom = {{}}
+        resp = callback(data.get("body"), data.get("headers"), data.get("params"), polyCustom)
+        if options.get("waitForResponse"):
+            await client.emit('setWebhookListenerResponse', {{
+                "webhookHandleID": function_id,
+                "apiKey": api_key,
+                "clientID": eventsClientId,
+                "executionId": data.get("executionId"),
+                "response": {{
+                    "data": resp,
+                    "statusCode": polyCustom.get("responseStatusCode", 200),
+                    "contentType": polyCustom.get("responseContentType", None),
+                }},
+            }}, namespace="/events")
+
+    data = {{
+        "clientID": eventsClientId,
+        "webhookHandleID": function_id,
+        "apiKey": api_key,
+        "waitForResponse": options.get("waitForResponse"),
+    }}
+    await client.emit('registerWebhookEventHandler', data, namespace="/events", callback=registerCallback)
+    active_handlers.append({{"clientID": eventsClientId, "webhookHandleID": function_id, "apiKey": api_key}})
+"""
+
+
+async def get_client_and_connect():
+    _, base_url = get_api_key_and_url()
+    global client
+    client = socketio.AsyncClient()
+    await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
+
+
+async def unregister(data: Dict[str, Any]):
+    print(f"stopping error handler for '{data['webhookHandleID']}'...")
+    assert client
+    await client.emit(
+        "unregisterWebhookEventHandler",
+        {
+            "clientID": data["clientID"],
+            "webhookHandleID": data["webhookHandleID"],
+            "apiKey": data["apiKey"],
+        },
+        "/events",
+    )
+
+
+async def unregister_all():
+    _, base_url = get_api_key_and_url()
+    # need to reconnect because maybe socketio client disconnected after Ctrl+C?
+    await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
+    await asyncio.gather(*[unregister(handler) for handler in active_handlers])
+
+
+def render_webhook_handle(
+    function_type: str,
+    function_name: str,
+    function_id: str,
+    function_description: str,
+    arguments: List[PropertySpecification],
+    return_type: Dict[str, Any],
+) -> Tuple[str, str]:
+    func_str = WEBHOOK_TEMPLATE.format(
+        description=function_description,
+        client_id=uuid.uuid4().hex,
+        function_id=function_id,
+        function_name=function_name,
+    )
+
+    return func_str, ""
+
+
+def start(*args):
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(get_client_and_connect())
+    asyncio.gather(*args)
+
+    try:
+        loop.run_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        loop.run_until_complete(unregister_all())
+        loop.stop()

{polyapi_python-0.2.4.dev3 → polyapi_python-0.2.4.dev5/polyapi_python.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.2.4.dev3
-Summary: The PolyAPI Python Client
+Version: 0.2.4.dev5
+Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
         

{polyapi_python-0.2.4.dev3 → polyapi_python-0.2.4.dev5}/pyproject.toml

@@ -3,8 +3,8 @@ requires = ["setuptools>=61.2", "wheel"]
 
 [project]
 name = "polyapi-python"
-version = "0.2.4.dev3"
-description = "The PolyAPI Python Client"
+version = "0.2.4.dev5"
+description = "The Python Client for PolyAPI, the IPaaS by Developers for Developers"
 authors = [{ name = "Dan Fellin", email = "dan@polyapi.io" }]
 dependencies = [
     "requests==2.31.0",

polyapi_python-0.2.4.dev3/polyapi/webhook.py

@@ -1,92 +0,0 @@
-import uuid
-from typing import Any, Dict, List, Tuple
-
-from polyapi.typedefs import PropertySpecification
-
-WEBHOOK_TEMPLATE = """
-import asyncio
-
-
-def {function_name}(callback, options=None):
-    \"""{description}
-
-    Function ID: {function_id}
-    \"""
-    options = options or {{}}
-    eventsClientId = "{client_id}"
-    function_id = "{function_id}"
-
-    api_key, base_url = get_api_key_and_url()
-
-    async def _inner():
-        socket = socketio.AsyncClient()
-        await socket.connect(base_url, transports=['websocket'], namespaces=['/events'])
-
-        def registerCallback(registered: bool):
-            nonlocal socket
-            if registered:
-                socket.on('handleWebhookEvent:{function_id}', handleEvent, namespace="/events")
-            else:
-                print("Could not set register webhook event handler for {function_id}")
-
-        async def handleEvent(data):
-            nonlocal api_key
-            nonlocal options
-            polyCustom = {{}}
-            resp = await callback(data.get("body"), data.get("headers"), data.get("params"), polyCustom)
-            if options.get("waitForResponse"):
-                await socket.emit('setWebhookListenerResponse', {{
-                    "webhookHandleID": function_id,
-                    "apiKey": api_key,
-                    "clientID": eventsClientId,
-                    "executionId": data.get("executionId"),
-                    "response": {{
-                        "data": resp,
-                        "statusCode": polyCustom.get("responseStatusCode", 200),
-                        "contentType": polyCustom.get("responseContentType", None),
-                    }},
-                }}, namespace="/events")
-
-        data = {{
-            "clientID": eventsClientId,
-            "webhookHandleID": function_id,
-            "apiKey": api_key,
-            "waitForResponse": options.get("waitForResponse"),
-        }}
-        await socket.emit('registerWebhookEventHandler', data, namespace="/events", callback=registerCallback)
-
-        async def closeEventHandler():
-            nonlocal socket
-            if not socket:
-                return
-
-            await socket.emit('unregisterWebhookEventHandler', {{
-                "clientID": eventsClientId,
-                "webhookHandleID": function_id,
-                "apiKey": api_key
-            }}, namespace="/events")
-
-        await socket.wait()
-
-        return closeEventHandler
-
-    return asyncio.run(_inner())
-"""
-
-
-def render_webhook_handle(
-    function_type: str,
-    function_name: str,
-    function_id: str,
-    function_description: str,
-    arguments: List[PropertySpecification],
-    return_type: Dict[str, Any],
-) -> Tuple[str, str]:
-    func_str = WEBHOOK_TEMPLATE.format(
-        description=function_description,
-        client_id=uuid.uuid4().hex,
-        function_id=function_id,
-        function_name=function_name,
-    )
-
-    return func_str, ""