polyapi-python 0.2.3.dev8__tar.gz → 0.2.4__tar.gz

{polyapi_python-0.2.3.dev8/polyapi_python.egg-info → polyapi_python-0.2.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.2.3.dev8
-Summary: The PolyAPI Python Client
+Version: 0.2.4
+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.3.dev8 → polyapi_python-0.2.4}/polyapi/__init__.py

@@ -1,6 +1,7 @@
 import os
 import sys
 import truststore
+from typing import Dict, Any
 truststore.inject_into_ssl()
 from .cli import CLI_COMMANDS
 
@@ -11,4 +12,12 @@ if len(sys.argv) > 1 and sys.argv[1] not in CLI_COMMANDS:
     currdir = os.path.dirname(os.path.abspath(__file__))
     if not os.path.isdir(os.path.join(currdir, "poly")):
         print("No 'poly' found. Please run 'python3 -m polyapi generate' to generate the 'poly' library for your tenant.")
-        sys.exit(1)
+        sys.exit(1)
+
+
+polyCustom: Dict[str, Any] = {
+  "executionId": None,
+  "executionApiKey": None,
+  "responseStatusCode": 200,
+  "responseContentType": None,
+}

{polyapi_python-0.2.3.dev8 → polyapi_python-0.2.4}/polyapi/client.py

@@ -10,6 +10,22 @@ from typing import List, Dict, Any, TypedDict
 """
 
 
+def _wrap_code_in_try_except(code: str) -> str:
+    """ this is necessary because client functions with imports will blow up ALL server functions,
+    even if they don't use them.
+    because the server function will try to load all client functions when loading the library
+    """
+    prefix = """logger = logging.getLogger("poly")
+try:
+    """
+    suffix = """except ImportError as e:
+    logger.debug(e)"""
+
+    lines = code.split("\n")
+    code = "\n    ".join(lines)
+    return "".join([prefix, code, "\n", suffix])
+
+
 def render_client_function(
     function_name: str,
     code: str,
@@ -22,4 +38,7 @@ def render_client_function(
         args_def=args_def,
         return_type_def=return_type_def,
     )
+
+    code = _wrap_code_in_try_except(code)
+
     return code + "\n\n", func_type_defs

polyapi_python-0.2.4/polyapi/error_handler.py

@@ -0,0 +1,85 @@
+import asyncio
+import copy
+import socketio  # type: ignore
+from socketio.exceptions import ConnectionError  # type: ignore
+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
+
+
+def prepare():
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(get_client_and_connect())
+    print("Client initialized!")
+
+
+
+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['path']}...")
+    assert client
+    await client.emit(
+        "unregisterErrorHandler",
+        data,
+        "/events",
+    )
+
+
+async def unregister_all():
+    _, base_url = get_api_key_and_url()
+    # need to reconnect because maybe socketio client disconnected after Ctrl+C?
+    try:
+        await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
+    except ConnectionError:
+        pass
+    await asyncio.gather(*[unregister(handler) for handler in active_handlers])
+
+
+async def on(
+    path: str, callback: Callable, options: Optional[Dict[str, Any]] = None
+) -> None:
+    print(f"Starting error handler for {path}...")
+
+    if not client:
+        raise Exception("Client not initialized. Abort!")
+
+    api_key, _ = get_api_key_and_url()
+    handler_id = None
+    data = copy.deepcopy(options or {})
+    data["path"] = path
+    data["apiKey"] = api_key
+
+    def registerCallback(id: int):
+        nonlocal handler_id
+        handler_id = id
+        client.on(f"handleError:{handler_id}", callback, namespace="/events")
+        active_handlers.append({"path": path, "id": handler_id, "apiKey": api_key})
+
+    await client.emit("registerErrorHandler", data, "/events", registerCallback)
+
+
+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.3.dev8 → polyapi_python-0.2.4}/polyapi/execute.py

@@ -11,7 +11,9 @@ 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:
+    # print(resp.status_code)
+    # print(resp.headers["content-type"])
+    if resp.status_code < 200 or resp.status_code >= 300:
         error_content = resp.content.decode("utf-8", errors="ignore")
         raise PolyApiException(f"{resp.status_code}: {error_content}")
     return resp

{polyapi_python-0.2.3.dev8 → polyapi_python-0.2.4}/polyapi/function_cli.py

@@ -4,6 +4,7 @@ import json
 import types
 import sys
 from typing import Dict, List, Mapping, Optional, Tuple
+from typing import _TypedDictMeta as BaseTypedDict  # type: ignore
 from typing_extensions import _TypedDictMeta  # type: ignore
 import requests
 from stdlib_list import stdlib_list
@@ -18,9 +19,18 @@ import importlib
 
 # these libraries are already installed in the base docker image
 # and shouldnt be included in additional requirements
-BASE_REQUIREMENTS = {"polyapi", "requests", "typing_extensions", "jsonschema-gentypes", "pydantic", "cloudevents"}
-all_stdlib_symbols = stdlib_list('.'.join([str(v) for v in sys.version_info[0:2]]))
-BASE_REQUIREMENTS.update(all_stdlib_symbols)  # dont need to pip install stuff in the python standard library
+BASE_REQUIREMENTS = {
+    "polyapi",
+    "requests",
+    "typing_extensions",
+    "jsonschema-gentypes",
+    "pydantic",
+    "cloudevents",
+}
+all_stdlib_symbols = stdlib_list(".".join([str(v) for v in sys.version_info[0:2]]))
+BASE_REQUIREMENTS.update(
+    all_stdlib_symbols
+)  # dont need to pip install stuff in the python standard library
 
 
 def _get_schemas(code: str) -> List[Dict]:
@@ -28,7 +38,14 @@ def _get_schemas(code: str) -> List[Dict]:
     user_code = types.SimpleNamespace()
     exec(code, user_code.__dict__)
     for name, obj in user_code.__dict__.items():
-        if (
+        if isinstance(obj, BaseTypedDict):
+            print_red("ERROR")
+            print_red("\nERROR DETAILS: ")
+            print(
+                "It looks like you have used TypedDict in a custom function. Please use `from typing_extensions import TypedDict` instead. The `typing_extensions` version is more powerful and better allows us to provide rich types for your function."
+            )
+            sys.exit(1)
+        elif (
             isinstance(obj, type)
             and isinstance(obj, _TypedDictMeta)
             and name != "TypedDict"
@@ -76,6 +93,13 @@ def get_python_type_from_ast(expr: ast.expr) -> str:
         if name == "List":
             slice = getattr(expr.slice, "id", "Any")
             return f"List[{slice}]"
+        elif name == "Dict":
+            if expr.slice and isinstance(expr.slice, ast.Tuple):
+                key = get_python_type_from_ast(expr.slice.dims[0])
+                value = get_python_type_from_ast(expr.slice.dims[1])
+                return f"Dict[{key}, {value}]"
+            else:
+                return "Dict"
         return "Any"
     else:
         return "Any"
@@ -104,7 +128,9 @@ def _get_type(expr: ast.expr | None, schemas: List[Dict]) -> Tuple[str, Dict | N
     return json_type, _get_type_schema(json_type, python_type, schemas)
 
 
-def _get_req_name_if_not_in_base(n: Optional[str], pip_name_lookup: Mapping[str, List[str]]) -> Optional[str]:
+def _get_req_name_if_not_in_base(
+    n: Optional[str], pip_name_lookup: Mapping[str, List[str]]
+) -> Optional[str]:
     if not n:
         return None
 
@@ -175,7 +201,12 @@ def _func_already_exists(context: str, function_name: str) -> bool:
 
 
 def function_add_or_update(
-    context: str, description: str, client: bool, server: bool, logs_enabled: bool, subcommands: List
+    context: str,
+    description: str,
+    client: bool,
+    server: bool,
+    logs_enabled: bool,
+    subcommands: List,
 ):
     parser = argparse.ArgumentParser()
     parser.add_argument("subcommand", choices=["add"])
@@ -191,16 +222,15 @@ def function_add_or_update(
         code = f.read()
 
     # OK! let's parse the code and generate the arguments
-    (
-        arguments,
-        return_type,
-        return_type_schema,
-        requirements
-    ) = _parse_code(code, args.function_name)
+    (arguments, return_type, return_type_schema, requirements) = _parse_code(
+        code, args.function_name
+    )
 
     if not return_type:
         print_red("ERROR")
-        print(f"Function {args.function_name} not found as top-level function in {args.filename}")
+        print(
+            f"Function {args.function_name} not found as top-level function in {args.filename}"
+        )
         sys.exit(1)
 
     data = {
@@ -216,7 +246,9 @@ def function_add_or_update(
     }
 
     if server and requirements:
-        print_yellow('\nPlease note that deploying your functions will take a few minutes because it makes use of libraries other than polyapi.')
+        print_yellow(
+            "\nPlease note that deploying your functions will take a few minutes because it makes use of libraries other than polyapi."
+        )
         data["requirements"] = requirements
 
     api_key, api_url = get_api_key_and_url()

{polyapi_python-0.2.3.dev8 → polyapi_python-0.2.4}/polyapi/generate.py

@@ -176,6 +176,7 @@ def render_spec(spec: SpecificationDto):
     function_type = spec["type"]
     function_description = spec["description"]
     function_name = spec["name"]
+    function_context = spec["context"]
     function_id = spec["id"]
 
     arguments: List[PropertySpecification] = []
@@ -223,6 +224,7 @@ def render_spec(spec: SpecificationDto):
     elif function_type == "webhookHandle":
         func_str, func_type_defs = render_webhook_handle(
             function_type,
+            function_context,
             function_name,
             function_id,
             function_description,

{polyapi_python-0.2.3.dev8 → polyapi_python-0.2.4}/polyapi/server.py

@@ -18,7 +18,10 @@ def {function_name}(
     Function ID: {function_id}
     \"""
     resp = execute("{function_type}", "{function_id}", {data})
-    return {return_action}
+    try:
+        return {return_action}
+    except:
+        return resp.text
 """
 
 
@@ -54,14 +57,6 @@ def render_server_function(
 def _get_server_return_action(return_type_name: str) -> str:
     if return_type_name == "str":
         return_action = "resp.text"
-    elif return_type_name == "Any":
-        return_action = "resp.text"
-    elif return_type_name == "int":
-        return_action = "int(resp.text.replace('(int) ', ''))"
-    elif return_type_name == "float":
-        return_action = "float(resp.text.replace('(float) ', ''))"
-    elif return_type_name == "bool":
-        return_action = "False if resp.text == 'False' else True"
     else:
         return_action = "resp.json()"
     return return_action

{polyapi_python-0.2.3.dev8 → polyapi_python-0.2.4}/polyapi/utils.py

@@ -1,5 +1,6 @@
 import re
 import os
+import logging
 from typing import Tuple, List
 from colorama import Fore, Style
 from polyapi.constants import BASIC_PYTHON_TYPES
@@ -9,7 +10,7 @@ from polyapi.schema import generate_schema_types, clean_title, map_primitive_typ
 
 # this string should be in every __init__ file.
 # it contains all the imports needed for the function or variable code to run
-CODE_IMPORTS = "from typing import List, Dict, Any, TypedDict, Optional\nimport requests\nimport socketio  # type: ignore\nfrom polyapi.config import get_api_key_and_url\nfrom polyapi.execute import execute, execute_post, variable_get, variable_update\n\n"
+CODE_IMPORTS = "from typing import List, Dict, Any, TypedDict, Optional\nimport logging\nimport requests\nimport socketio  # type: ignore\nfrom polyapi.config import get_api_key_and_url\nfrom polyapi.execute import execute, execute_post, variable_get, variable_update\n\n"
 
 
 def init_the_init(full_path: str) -> None:
@@ -91,7 +92,11 @@ def get_type_and_def(type_spec: PropertyType) -> Tuple[str, str]:
         if type_spec.get("items"):
             items = type_spec["items"]
             if items.get("$ref"):
-                return "ResponseType", generate_schema_types(type_spec, root="ResponseType")  # type: ignore
+                try:
+                    return "ResponseType", generate_schema_types(type_spec, root="ResponseType")  # type: ignore
+                except:
+                    logging.exception(f"Error when generating schema type: {type_spec}")
+                    return "Dict", ""
             else:
                 item_type, _ = get_type_and_def(items)
                 title = f"List[{item_type}]"
@@ -108,7 +113,12 @@ def get_type_and_def(type_spec: PropertyType) -> Tuple[str, str]:
             if title:
                 assert isinstance(title, str)
                 title = clean_title(title)
-                return title, generate_schema_types(schema, root=title)  # type: ignore
+                try:
+                    return title, generate_schema_types(schema, root=title)  # type: ignore
+                except:
+                    logging.exception(f"Error when generating schema type: {schema}")
+                    return "Dict", ""
+
             elif schema.get("items"):
                 # fallback to schema $ref name if no explicit title
                 items = schema.get("items")  # type: ignore
@@ -123,7 +133,11 @@ def get_type_and_def(type_spec: PropertyType) -> Tuple[str, str]:
                     return "List", ""
 
                 title = f"List[{title}]"
-                return title, generate_schema_types(schema, root=title)
+                try:
+                    return title, generate_schema_types(schema, root=title)
+                except:
+                    logging.exception(f"Error when generating schema type: {schema}")
+                    return "List", ""
             else:
                 return "Any", ""
         else:
@@ -151,4 +165,13 @@ def parse_arguments(function_name: str, arguments: List[PropertySpecification])
                 arg_string += f",  # {description}\n"
         else:
             arg_string += ",\n"
-    return arg_string.rstrip("\n"), "\n\n".join(args_def)
+    return arg_string.rstrip("\n"), "\n\n".join(args_def)
+
+
+def poly_full_path(context, name) -> str:
+    """get the functions path as it will be exposed in the poly library"""
+    if context:
+        path = context + "." + name
+    else:
+        path = name
+    return f"poly.{path}"

polyapi_python-0.2.4/polyapi/webhook.py

@@ -0,0 +1,137 @@
+import asyncio
+import socketio  # type: ignore
+from socketio.exceptions import ConnectionError  # 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
+from polyapi.utils import poly_full_path
+
+# 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 handler for {function_path}...")
+
+    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, "path": "{function_path}"}})
+"""
+
+
+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 webhook handler for {data['path']}...")
+    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()
+    # maybe need to reconnect because maybe socketio client disconnected after Ctrl+C?
+    # feels like Linux disconnects but Windows stays connected
+    try:
+        await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
+    except ConnectionError:
+        pass
+    await asyncio.gather(*[unregister(handler) for handler in active_handlers])
+
+
+def render_webhook_handle(
+    function_type: str,
+    function_context: 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,
+        function_path=poly_full_path(function_context, 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.3.dev8 → polyapi_python-0.2.4/polyapi_python.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.2.3.dev8
-Summary: The PolyAPI Python Client
+Version: 0.2.4
+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.3.dev8 → polyapi_python-0.2.4}/pyproject.toml

@@ -3,8 +3,8 @@ requires = ["setuptools>=61.2", "wheel"]
 
 [project]
 name = "polyapi-python"
-version = "0.2.3.dev8"
-description = "The PolyAPI Python Client"
+version = "0.2.4"
+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.3.dev8/polyapi/error_handler.py

@@ -1,52 +0,0 @@
-import asyncio
-import copy
-import socketio  # type: ignore
-from typing import Any, Callable, Dict, Optional
-
-from polyapi.config import get_api_key_and_url
-
-
-local_error_handlers: Dict[str, Any] = {}
-
-
-def on(path: str, callback: Callable, options: Optional[Dict[str, Any]] = None) -> Callable:
-    assert not local_error_handlers
-    socket = socketio.AsyncClient()
-    api_key, base_url = get_api_key_and_url()
-
-    async def _inner():
-        await socket.connect(base_url, transports=["websocket"], namespaces=["/events"])
-
-        handler_id = None
-        data = copy.deepcopy(options or {})
-        data["path"] = path
-        data["apiKey"] = api_key
-
-        def registerCallback(id: int):
-            nonlocal handler_id, socket
-            handler_id = id
-            socket.on(f"handleError:{handler_id}", callback, namespace="/events")
-
-        await socket.emit("registerErrorHandler", data, "/events", registerCallback)
-        if local_error_handlers.get(path):
-            local_error_handlers[path].append(callback)
-        else:
-            local_error_handlers[path] = [callback]
-
-        async def unregister():
-            nonlocal handler_id, socket
-            if handler_id and socket:
-                await socket.emit(
-                    "unregisterErrorHandler",
-                    {"id": handler_id, "path": path, "apiKey": api_key},
-                    namespace="/events",
-                )
-
-            if local_error_handlers.get(path):
-                local_error_handlers[path].remove(callback)
-
-        await socket.wait()
-
-        return unregister
-
-    return asyncio.run(_inner())

polyapi_python-0.2.3.dev8/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, ""