polyapi-python 0.0.35__py3-none-any.whl → 0.1.0__py3-none-any.whl

polyapi/api.py

@@ -1,31 +1,8 @@
-import os
 from typing import Any, Dict, List, Tuple
 
-from polyapi.constants import BASIC_PYTHON_TYPES, JSONSCHEMA_TO_PYTHON_TYPE_MAP
-from polyapi.typedefs import PropertySpecification, PropertyType
-from polyapi.utils import append_init, camelCase
-from polyapi.schema import generate_schema_types, clean_title
+from polyapi.typedefs import PropertySpecification
+from polyapi.utils import add_type_import_path, camelCase, parse_arguments, get_type_and_def
 
-# map the function type from the spec type to the function execute type
-TEMPLATE_FUNCTION_TYPE_MAP = {
-    "apiFunction": "api",
-    "serverFunction": "server",
-}
-
-SERVER_DEFS_TEMPLATE = """
-from typing import List, Dict, Any, TypedDict
-{args_def}
-{return_type_def}
-"""
-
-SERVER_FUNCTION_TEMPLATE = """
-def {function_name}(
-{args}
-) -> {return_type_name}:
-    "{function_description}"
-    resp = execute("{function_type}", "{function_id}", {data})
-    return {return_action}
-"""
 
 API_DEFS_TEMPLATE = """
 from typing import List, Dict, Any, TypedDict
@@ -47,109 +24,7 @@ def {function_name}(
 """
 
 
-def _map_primitive_types(type_: str) -> str:
-    # Define your mapping logic here
-    return JSONSCHEMA_TO_PYTHON_TYPE_MAP.get(type_, "Any")
-
-
-def _get_type(type_spec: PropertyType) -> Tuple[str, str]:
-    if type_spec["kind"] == "plain":
-        value = type_spec["value"]
-        if value.endswith("[]"):
-            primitive = _map_primitive_types(value[:-2])
-            return f"List[{primitive}]", ""
-        else:
-            return _map_primitive_types(value), ""
-    elif type_spec["kind"] == "primitive":
-        return _map_primitive_types(type_spec["type"]), ""
-    elif type_spec["kind"] == "array":
-        if type_spec.get("items"):
-            items = type_spec["items"]
-            if items.get("$ref"):
-                return "ResponseType", generate_schema_types(type_spec, root="ResponseType")  # type: ignore
-            else:
-                item_type, _ = _get_type(items)
-                title = f"List[{item_type}]"
-                title = clean_title(title)
-                return title, ""
-        else:
-            return "List", ""
-    elif type_spec["kind"] == "void":
-        return "None", ""
-    elif type_spec["kind"] == "object":
-        if type_spec.get("schema"):
-            schema = type_spec["schema"]
-            title = schema.get("title", "")
-            if title:
-                assert isinstance(title, str)
-                title = clean_title(title)
-                return title, generate_schema_types(schema, root=title)  # type: ignore
-            elif schema.get("items"):
-                # fallback to schema $ref name if no explicit title
-                items = schema.get("items")  # type: ignore
-                title = items.get("title", "")  # type: ignore
-                if not title:
-                    # title is actually a reference to another schema
-                    title = items.get("$ref", "")  # type: ignore
-
-                title = title.rsplit("/", 1)[-1]
-                title = clean_title(title)
-                if not title:
-                    return "List", ""
-
-                title = f"List[{title}]"
-                return title, generate_schema_types(schema, root=title)
-            else:
-                return "Any", ""
-        else:
-            return "Dict", ""
-    elif type_spec["kind"] == "any":
-        return "Any", ""
-    else:
-        return "Any", ""
-
-
-def _parse_arguments(function_name: str, arguments: List[PropertySpecification]) -> Tuple[str, str]:
-    args_def = []
-    arg_string = ""
-    for idx, a in enumerate(arguments):
-        arg_type, arg_def = _get_type(a["type"])
-        if arg_def:
-            args_def.append(arg_def)
-        a["name"] = camelCase(a["name"])
-        arg_string += f"    {a['name']}: {_add_type_import_path(function_name, arg_type)}"
-        description = a.get("description", "")
-        if description:
-            if idx == len(arguments) - 1:
-                arg_string += f"  # {description}\n"
-            else:
-                arg_string += f",  # {description}\n"
-        else:
-            arg_string += ",\n"
-    return arg_string.rstrip("\n"), "\n\n".join(args_def)
-
-
-def _add_type_import_path(function_name: str, arg: str) -> str:
-    """ if not basic type, coerce to camelCase and add the import path
-    """
-    if arg in BASIC_PYTHON_TYPES:
-        return arg
-
-    if arg.startswith("List["):
-        sub = arg[5:-1]
-        if sub in BASIC_PYTHON_TYPES:
-            return arg
-        else:
-            if '"' in sub:
-                sub = sub.replace('"', "")
-                return f'List["_{function_name}.{camelCase(sub)}"]'
-            else:
-                return f'List[_{function_name}.{camelCase(sub)}]'
-
-    return f'_{function_name}.{camelCase(arg)}'
-
-
-def render_function(
+def render_api_function(
     function_type: str,
     function_name: str,
     function_id: str,
@@ -157,134 +32,26 @@ def render_function(
     arguments: List[PropertySpecification],
     return_type: Dict[str, Any],
 ) -> Tuple[str, str]:
+    assert function_type == "apiFunction"
     arg_names = [a["name"] for a in arguments]
-    args, args_def = _parse_arguments(function_name, arguments)
-    return_type_name, return_type_def = _get_type(return_type)  # type: ignore
+    args, args_def = parse_arguments(function_name, arguments)
+    return_type_name, return_type_def = get_type_and_def(return_type)  # type: ignore
     data = "{" + ", ".join([f"'{arg}': {camelCase(arg)}" for arg in arg_names]) + "}"
-    if function_type == "apiFunction":
-        api_response_type = f"{function_name}Response"
-        func_type_defs = API_DEFS_TEMPLATE.format(
-            args_def=args_def,
-            api_response_type=api_response_type,
-            return_type_name=return_type_name,
-            return_type_def=return_type_def,
-        )
-        func_str = API_FUNCTION_TEMPLATE.format(
-            function_type=TEMPLATE_FUNCTION_TYPE_MAP[function_type],
-            function_name=function_name,
-            function_id=function_id,
-            function_description=function_description.replace('"', "'"),
-            args=args,
-            data=data,
-            api_response_type=_add_type_import_path(function_name, api_response_type),
-        )
-    else:
-        func_type_defs = SERVER_DEFS_TEMPLATE.format(
-            args_def=args_def,
-            return_type_def=return_type_def,
-        )
-        func_str = SERVER_FUNCTION_TEMPLATE.format(
-            return_type_name=_add_type_import_path(function_name, return_type_name),
-            function_type=TEMPLATE_FUNCTION_TYPE_MAP[function_type],
-            function_name=function_name,
-            function_id=function_id,
-            function_description=function_description.replace('"', "'"),
-            args=args,
-            return_action=_get_server_return_action(return_type_name),
-            data=data,
-        )
-    return func_str, func_type_defs
-
-
-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
 
-
-def add_function_file(
-    function_type: str,
-    full_path: str,
-    function_name: str,
-    function_id: str,
-    function_description: str,
-    arguments: List[PropertySpecification],
-    return_type: Dict[str, Any],
-):
-    # first lets add the import to the __init__
-    init_path = os.path.join(full_path, "__init__.py")
-    _init_the_init(init_path)
-
-    func_str, func_type_defs = render_function(
-        function_type,
-        function_name,
-        function_id,
-        function_description,
-        arguments,
-        return_type,
+    api_response_type = f"{function_name}Response"
+    func_type_defs = API_DEFS_TEMPLATE.format(
+        args_def=args_def,
+        api_response_type=api_response_type,
+        return_type_name=return_type_name,
+        return_type_def=return_type_def,
     )
-
-    with open(init_path, "a") as f:
-        f.write(f"\n\nfrom . import _{function_name}\n\n{func_str}")
-
-    # now lets add the code!
-    file_path = os.path.join(full_path, f"_{function_name}.py")
-    with open(file_path, "w") as f:
-        f.write(func_type_defs)
-
-
-def _init_the_init(init_path: str) -> None:
-    if not os.path.exists(init_path):
-        with open(init_path, "w") as f:
-            f.write("from typing import List, Dict, Any, TypedDict\nfrom polyapi.execute import execute\nfrom polyapi.exceptions import PolyApiException\n")
-
-
-def create_function(
-    function_type: str,
-    path: str,
-    function_id: str,
-    function_description: str,
-    arguments: List[PropertySpecification],
-    return_type: Dict[str, Any],
-) -> None:
-    full_path = os.path.dirname(os.path.abspath(__file__))
-
-    folders = path.split(".")
-    for idx, folder in enumerate(folders):
-        if idx + 1 == len(folders):
-            # special handling for final level
-            add_function_file(
-                function_type,
-                full_path,
-                folder,
-                function_id,
-                function_description,
-                arguments,
-                return_type,
-            )
-        else:
-            full_path = os.path.join(full_path, folder)
-            if not os.path.exists(full_path):
-                os.makedirs(full_path)
-
-            # append to __init__.py file if nested folders
-            next = folders[idx + 1] if idx + 2 < len(folders) else ""
-            if next:
-                _init_the_init(os.path.join(full_path, "__init__.py"))
-                append_init(full_path, next)
-
-
-def generate_api(api_functions: List) -> None:
-    for func in api_functions:
-        create_function(*func)
-    print("API functions generated!")
+    func_str = API_FUNCTION_TEMPLATE.format(
+        function_type="api",
+        function_name=function_name,
+        function_id=function_id,
+        function_description=function_description.replace('"', "'"),
+        args=args,
+        data=data,
+        api_response_type=add_type_import_path(function_name, api_response_type),
+    )
+    return func_str, func_type_defs

polyapi/auth.py

@@ -0,0 +1,151 @@
+from typing import List, Dict, Any, Tuple
+import uuid
+
+from polyapi.typedefs import PropertySpecification
+from polyapi.utils import parse_arguments, get_type_and_def
+
+
+AUTH_DEFS_TEMPLATE = """
+from typing import List, Dict, Any, TypedDict, Optional
+{args_def}
+{return_type_def}
+"""
+
+GET_TOKEN_TEMPLATE = """
+import asyncio
+import socketio  # type: ignore
+from polyapi.config import get_api_key_and_url
+
+
+async def getToken(clientId: str, clientSecret: str, scopes: List[str], callback, options: Optional[Dict[str, Any]] = None):
+    {description}
+    eventsClientId = "{client_id}"
+    function_id = "{function_id}"
+
+    options = options or {{}}
+    path = "/auth-providers/{function_id}/execute"
+    data = {{
+        "clientId": clientId,
+        "clientSecret": clientSecret,
+        "scopes": scopes,
+        "audience": options.get("audience"),
+        "callbackUrl": options.get("callbackUrl"),
+        "userId": options.get("userId"),
+    }}
+    resp = execute_post(path, data)
+    data = resp.json()
+    assert resp.status_code == 201, (resp.status_code, resp.content)
+
+    token = data.get("token")
+    url = data.get("url")
+    error = data.get("error")
+    if token:
+        return callback(token, url, error)
+    elif url and options.get("autoCloseOnUrl"):
+        return callback(token, url, error)
+
+    timeout = options.get("timeout", 120)
+
+    api_key, base_url = get_api_key_and_url()
+    socket = socketio.AsyncClient()
+    await socket.connect(base_url, transports=['websocket'], namespaces=['/events'])
+
+    async def closeEventHandler():
+        nonlocal socket
+        if not socket:
+            return
+
+        del socket.handlers['/events']['handleAuthFunctionEvent:{function_id}']
+        await socket.emit('unregisterAuthFunctionEventHandler', {{
+            "clientID": eventsClientId,
+            "functionId": function_id,
+            "apiKey": api_key
+        }}, namespace="/events")
+        await socket.disconnect()
+        socket = None
+
+
+    async def waitUntilTimeout(timeout):
+        await asyncio.sleep(timeout)
+        await closeEventHandler()
+
+
+    async def handleEvent(data):
+        nonlocal options
+        callback(data.get('token'), data.get('url'), data.get('error'))
+        if data.get('token') and options.get("autoCloseOnToken", True):
+            await closeEventHandler()
+
+
+    def registerCallback(registered: bool):
+        nonlocal socket
+        if registered:
+            socket.on('handleAuthFunctionEvent:{function_id}', handleEvent, namespace="/events")
+            callback(data.get('token'), data.get('url'), data.get('error'))
+
+    data2 = {{
+        "clientID": eventsClientId,
+        "functionId": function_id,
+        "apiKey": api_key
+    }}
+    await socket.emit('registerAuthFunctionEventHandler', data2, namespace="/events", callback=registerCallback)
+
+    # run timeout task in background
+    timeout = options.get("timeout", 120)
+    timeout_task = asyncio.create_task(waitUntilTimeout(timeout))
+
+    # cancel timeout task if socket.wait finishes before timeout up
+    await socket.wait()
+    timeout_task.cancel()
+
+    return {{"close": closeEventHandler}}
+"""
+
+REFRESH_TOKEN_TEMPLATE = """
+def refreshToken(token: str) -> str:
+    {description}
+    url = "/auth-providers/{function_id}/refresh"
+    resp = execute_post(url, {{"token": token}})
+    assert resp.status_code == 201, (resp.status_code, resp.content)
+    return resp.text
+"""
+
+REVOKE_TOKEN_TEMPLATE = """
+def revokeToken(token: str) -> None:
+    {description}
+    url = "/auth-providers/{function_id}/revoke"
+    resp = execute_post(url, {{"token": token}})
+    assert resp.status_code == 201, (resp.status_code, resp.content)
+"""
+
+
+def render_auth_function(
+    function_type: str,
+    function_name: str,
+    function_id: str,
+    function_description: str,
+    arguments: List[PropertySpecification],
+    return_type: Dict[str, Any],
+) -> Tuple[str, str]:
+    """ renders getToken, revokeToken, refreshToken as appropriate
+    """
+    args, args_def = parse_arguments(function_name, arguments)
+    return_type_name, return_type_def = get_type_and_def(return_type)  # type: ignore
+    func_type_defs = AUTH_DEFS_TEMPLATE.format(
+        args_def=args_def,
+        return_type_def=return_type_def,
+    )
+
+    func_str = ""
+
+    if function_description:
+        function_description = f'"""{function_description}"""'
+
+    if function_name == "getToken":
+        func_str = GET_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description, client_id=uuid.uuid4().hex)
+    elif function_name == "refreshToken":
+        func_str = REFRESH_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description)
+    elif function_name == "revokeToken":
+        func_str = REVOKE_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description)
+
+    return func_str, func_type_defs

polyapi/cli.py

@@ -1,21 +1,30 @@
 import argparse
 
+from polyapi.utils import print_green
+
 from .config import clear_config
 from .generate import generate, clear
 from .function_cli import function_add_or_update
 
 
-CLI_COMMANDS = ["generate", "config", "clear", "function", "help"]
+CLI_COMMANDS = ["setup", "generate", "function", "clear", "help"]
+
+CLIENT_DESC = """Commands
+  python -m polyapi setup                Setup your Poly connection
+  python -m polyapi generate             Generates Poly library
+  python -m polyapi function <command>   Manages functions
+  python -m polyapi clear                Clear current generated Poly library
+"""
 
 
 def execute_from_cli():
     parser = argparse.ArgumentParser(
-        prog="python -m polyapi", description="PolyAPI Client"
+        prog="python -m polyapi", description=CLIENT_DESC, formatter_class=argparse.RawTextHelpFormatter
     )
     parser.add_argument("--context", required=False, default="")
     parser.add_argument("--description", required=False, default="")
-    parser.add_argument("--server", action="store_true", help="Pass --server if you want this to be a server function. By default, it will be a client function.")
-    parser.add_argument("--logs", action="store_true", help="Pass --logs if you want to store and see the logs from this function executing")
+    parser.add_argument("--server", action="store_true", help="Pass --server when adding function to add a server function. By default, new functions are client.")
+    parser.add_argument("--logs", action="store_true", help="Pass --logs when adding function if you want to store and see the function logs.")
     parser.add_argument("command", choices=CLI_COMMANDS)
     parser.add_argument("subcommands", nargs="*")
     args = parser.parse_args()
@@ -24,10 +33,10 @@ def execute_from_cli():
     if command == "help":
         parser.print_help()
     elif command == "generate":
-        print("Generating...")
+        print("Generating Poly functions...", end="")
         generate()
-    elif command == "config":
-        print("Clearing old config...")
+        print_green("DONE")
+    elif command == "setup":
         clear_config()
         generate()
     elif command == "clear":

polyapi/config.py

@@ -69,6 +69,15 @@ def initialize_config():
 
 
 def clear_config():
+    if os.environ.get("POLY_API_KEY"):
+        print("Using POLY_API_KEY from environment. Please unset environment variable to manually set api key.")
+        return
+
+    global API_KEY
+    global API_URL
+    API_KEY = None
+    API_URL = None
+
     path = get_config_file_path()
     if os.path.exists(path):
         os.remove(path)

polyapi/execute.py

@@ -5,10 +5,41 @@ from polyapi.exceptions import PolyApiException
 
 
 def execute(function_type, function_id, data) -> Response:
+    """ execute a specific function id/type
+    """
     api_key, api_url = get_api_key_and_url()
     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:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
+    return resp
+
+
+def execute_post(path, data):
+    api_key, api_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    resp = requests.post(api_url + path, json=data, headers=headers)
+    return resp
+
+
+def variable_get(variable_id: str) -> Response:
+    api_key, base_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{base_url}/variables/{variable_id}/value"
+    resp = requests.get(url, headers=headers)
+    if resp.status_code != 200 and resp.status_code != 201:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
+    return resp
+
+
+def variable_update(variable_id: str, value) -> Response:
+    api_key, base_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{base_url}/variables/{variable_id}/value"
+    resp = requests.patch(url, data={"value": value}, headers=headers)
     if resp.status_code != 200 and resp.status_code != 201:
         error_content = resp.content.decode("utf-8", errors="ignore")
         raise PolyApiException(f"{resp.status_code}: {error_content}")

polyapi/function_cli.py

@@ -8,15 +8,16 @@ from typing_extensions import _TypedDictMeta  # type: ignore
 import requests
 from stdlib_list import stdlib_list
 from pydantic import TypeAdapter
-from polyapi.generate import generate
+from polyapi.generate import get_functions_and_parse, generate_functions
 from polyapi.config import get_api_key_and_url
 from polyapi.constants import PYTHON_TO_JSONSCHEMA_TYPE_MAP
-from polyapi.utils import get_auth_headers
+from polyapi.utils import get_auth_headers, print_green, print_red, print_yellow
+import importlib
 
 
 # these libraries are already installed in the base docker image
 # and shouldnt be included in additional requirements
-BASE_REQUIREMENTS = {"requests", "typing_extensions", "jsonschema-gentypes", "pydantic"}
+BASE_REQUIREMENTS = {"polyapi", "requests", "typing_extensions", "jsonschema-gentypes", "pydantic"}
 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
 
@@ -141,6 +142,14 @@ def _parse_code(code: str, function_name: str):
     return parsed_args, return_type, return_type_schema, requirements
 
 
+def _func_already_exists(context: str, function_name: str) -> bool:
+    try:
+        module = importlib.import_module(f"polyapi.poly.{context}")
+        return bool(getattr(module, function_name, False))
+    except ModuleNotFoundError:
+        return False
+
+
 def function_add_or_update(
     context: str, description: str, server: bool, logs_enabled: bool, subcommands: List
 ):
@@ -150,6 +159,9 @@ def function_add_or_update(
     parser.add_argument("filename")
     args = parser.parse_args(subcommands)
 
+    verb = "Updating" if _func_already_exists(context, args.function_name) else "Adding"
+    print(f"{verb} custom server side function...", end="")
+
     with open(args.filename, "r") as f:
         code = f.read()
 
@@ -162,11 +174,13 @@ def function_add_or_update(
     ) = _parse_code(code, args.function_name)
 
     if not return_type:
-        print(
-            f"Error: function named {args.function_name} not found as top-level function in file. Exiting."
-        )
+        print_red("ERROR")
+        print(f"Function {args.function_name} not found as top-level function in {args.filename}")
         sys.exit(1)
 
+    if requirements:
+        print_yellow('\nPlease note that deploying your functions will take a few minutes because it makes use of libraries other than polyapi.')
+
     data = {
         "context": context,
         "name": args.function_name,
@@ -189,13 +203,15 @@ def function_add_or_update(
         # url = f"{base_url}/functions/client"
 
     headers = get_auth_headers(api_key)
-    print("Adding function...")
     resp = requests.post(url, headers=headers, json=data)
     if resp.status_code == 201:
+        print_green("DEPLOYED")
         function_id = resp.json()["id"]
-        print(f"Function added successfully. Function id is {function_id}")
-        print("Regenerating library...")
-        generate()
+        print(f"Function ID: {function_id}")
+        print("Generating new custom function...", end="")
+        functions = get_functions_and_parse(limit_ids=[function_id])
+        generate_functions(functions)
+        print_green("DONE")
     else:
         print("Error adding function.")
         print(resp.status_code)