polyapi-python 0.2.3.dev9__py3-none-any.whl → 0.2.4__py3-none-any.whl

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/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/error_handler.py

@@ -1,52 +1,85 @@
 import asyncio
 import copy
 import socketio  # type: ignore
-from typing import Any, Callable, Dict, Optional
+from socketio.exceptions import ConnectionError  # type: ignore
+from typing import Any, Callable, Dict, List, Optional
 
 from polyapi.config import get_api_key_and_url
 
 
-local_error_handlers: Dict[str, Any] = {}
+# 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 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"])
+def prepare():
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(get_client_and_connect())
+    print("Client initialized!")
 
-        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 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():
-            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)
+async def unregister(data: Dict[str, Any]):
+    print(f"Stopping error handler for {data['path']}...")
+    assert client
+    await client.emit(
+        "unregisterErrorHandler",
+        data,
+        "/events",
+    )
 
-        await socket.wait()
 
-        return unregister
+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])
 
-    return asyncio.run(_inner())
+
+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/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/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/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/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/utils.py

@@ -10,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:
@@ -165,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/webhook.py

@@ -1,81 +1,111 @@
+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 = """
-import asyncio
 
 
-def {function_name}(callback, options=None):
+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()
 
-    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,
+    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
+                "apiKey": api_key,
+                "clientID": eventsClientId,
+                "executionId": data.get("executionId"),
+                "response": {{
+                    "data": resp,
+                    "statusCode": polyCustom.get("responseStatusCode", 200),
+                    "contentType": polyCustom.get("responseContentType", None),
+                }},
             }}, namespace="/events")
 
-        await socket.wait()
+    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}"}})
+"""
 
-        return closeEventHandler
 
-    return asyncio.run(_inner())
-"""
+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,
@@ -87,6 +117,21 @@ def render_webhook_handle(
         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, ""
+    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.dev9.dist-info → polyapi_python-0.2.4.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.2.3.dev9
-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.4.dist-info/RECORD

@@ -0,0 +1,25 @@
+polyapi/__init__.py,sha256=5iujRodfgRyLxT-zY0L3xax3rKRvfSt4NZlZYKOz03w,608
+polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
+polyapi/api.py,sha256=Pq_OT8egmtlzMjovN5GGZXWnF5oWMkrgR0rmrzJ6ifM,1861
+polyapi/auth.py,sha256=p2KSLt6q52t9gnqPmgXTOQ2_lmdFilZkIoGmQrRTPLQ,5330
+polyapi/cli.py,sha256=xlKH4cSmSo7eXbyXCLWyL4rXM1QFsltC_MxoxMPgt6I,2187
+polyapi/client.py,sha256=w15XOABkwdL4V4r2iWY_nypzLjvoKVuux8jUKbA16pQ,1329
+polyapi/config.py,sha256=S8TU10upy5OW1_vX-CqQTJD-ZOB6329aMjiUCmukfUI,2292
+polyapi/constants.py,sha256=NGjso6K5rGnE8TGdrXmdEfvvr-HI3DTVGwOYiWO68LM,511
+polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
+polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
+polyapi/execute.py,sha256=kXnvlNQ7nz9cRlV2_5gXH09UCmyiDP5zi3wiAw0uDuk,1943
+polyapi/function_cli.py,sha256=F0cb5MGcmFvspgwxptWq_2e50X5NNno0B0p8Vgu_oNI,9129
+polyapi/generate.py,sha256=fNEBy3ALEu4m1GEEcly-5u-Y1i3G6EWMKKgCyBBJsqc,8568
+polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polyapi/schema.py,sha256=1a7nIO867Xy3bagmPUNdYMxtS5OoCAv8oKIbYgj55dk,2957
+polyapi/server.py,sha256=iXUR1Kd5TnWK-V5qHhvFvQuHx-3IcTv8WChXVY5Mbog,1882
+polyapi/typedefs.py,sha256=a5WfHaAvjeql3y1iA3_SkpUztTbKvS5bPqkVxkCvr9E,1459
+polyapi/utils.py,sha256=9dFboLurZwBBtFZxXBDNri4QvSJAyZhkNUWK5LZh6ME,6180
+polyapi/variables.py,sha256=d36-trnfTL_8m2NkorMiImb4O3UrJbiFV38CHxV5i0A,4200
+polyapi/webhook.py,sha256=KidW6J1R4pWsgJ9duPiG-kzO8S28zfVyPhSn8ypD30Y,4325
+polyapi_python-0.2.4.dist-info/LICENSE,sha256=Hi0kDr56Dsy0uYIwNt4r9G7tI8x8miXRTlyvbeplCP8,1068
+polyapi_python-0.2.4.dist-info/METADATA,sha256=kKKRqtXYD-PhlLUa0GZoAXACMsUsOtq3gcMsZuOcrjM,4862
+polyapi_python-0.2.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+polyapi_python-0.2.4.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
+polyapi_python-0.2.4.dist-info/RECORD,,

polyapi_python-0.2.3.dev9.dist-info/RECORD

@@ -1,25 +0,0 @@
-polyapi/__init__.py,sha256=VRAaN5WZPDmj7AnprtJ3szHXWlqWInKXBfEmfpyXTK8,434
-polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
-polyapi/api.py,sha256=Pq_OT8egmtlzMjovN5GGZXWnF5oWMkrgR0rmrzJ6ifM,1861
-polyapi/auth.py,sha256=p2KSLt6q52t9gnqPmgXTOQ2_lmdFilZkIoGmQrRTPLQ,5330
-polyapi/cli.py,sha256=xlKH4cSmSo7eXbyXCLWyL4rXM1QFsltC_MxoxMPgt6I,2187
-polyapi/client.py,sha256=8k50Vwg9HnmHHTyfKH1vfMJqF0jnnVMsWuWI9AfASkM,761
-polyapi/config.py,sha256=S8TU10upy5OW1_vX-CqQTJD-ZOB6329aMjiUCmukfUI,2292
-polyapi/constants.py,sha256=NGjso6K5rGnE8TGdrXmdEfvvr-HI3DTVGwOYiWO68LM,511
-polyapi/error_handler.py,sha256=vl6ZBtsHmC3eu13IMpmZEXBTDJbrPrzmViBCCrEspd4,1621
-polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
-polyapi/execute.py,sha256=06XWTxGJqtsDiLY10RjRebIMFRfhtAIMmBRbuWu3e8A,1873
-polyapi/function_cli.py,sha256=KkFvnGSSCwYPMV4cX4yMQmXKyLtgYR64Fz5BfjGv3qY,8230
-polyapi/generate.py,sha256=O1lb7rLsce7tItIrMx1EbWzRlAKKOp-7upNM80cMmMw,8499
-polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polyapi/schema.py,sha256=1a7nIO867Xy3bagmPUNdYMxtS5OoCAv8oKIbYgj55dk,2957
-polyapi/server.py,sha256=mcbH8pG16fFMiFL52wdii0217ZLsznQnElAFEvXZ7IA,2211
-polyapi/typedefs.py,sha256=a5WfHaAvjeql3y1iA3_SkpUztTbKvS5bPqkVxkCvr9E,1459
-polyapi/utils.py,sha256=UD3uV3kzt2w23zxAdHCUROhdvtdO44KCJIpqnFwEhqE,5937
-polyapi/variables.py,sha256=d36-trnfTL_8m2NkorMiImb4O3UrJbiFV38CHxV5i0A,4200
-polyapi/webhook.py,sha256=A89eNnYcVpVe9doJPDLfscIhF-C7Q2AI3vu-SzGxMBg,2923
-polyapi_python-0.2.3.dev9.dist-info/LICENSE,sha256=Hi0kDr56Dsy0uYIwNt4r9G7tI8x8miXRTlyvbeplCP8,1068
-polyapi_python-0.2.3.dev9.dist-info/METADATA,sha256=3pEducW3Aaun4Vy6JgbJ1SksuPLLbWSMXAlYPyg--4A,4823
-polyapi_python-0.2.3.dev9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-polyapi_python-0.2.3.dev9.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
-polyapi_python-0.2.3.dev9.dist-info/RECORD,,