polyapi-python 0.0.35__tar.gz → 0.1.0__tar.gz

{polyapi-python-0.0.35 → polyapi-python-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.0.35
+Version: 0.1.0
 Summary: The PolyAPI Python Client
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
@@ -33,6 +33,8 @@ Requires-Dist: typing_extensions
 Requires-Dist: jsonschema-gentypes
 Requires-Dist: pydantic>=2.5.3
 Requires-Dist: stdlib_list
+Requires-Dist: colorama
+Requires-Dist: python-socketio[asyncio_client]
 
 # PolyAPI Python Library
 
@@ -145,6 +147,14 @@ To upgrade your library to the latest dev version, pass the `--pre` flag.
 pip install polyapi-python --pre --upgrade
 ```
 
+## Change Your API Key
+
+If you need to change your API key or what server you are pointing to, you can run:
+
+```bash
+python -m polyapi setup
+```
+
 ## Unit Tests
 
 To run this library's unit tests, please clone the repo then run:

{polyapi-python-0.0.35 → polyapi-python-0.1.0}/README.md

@@ -109,6 +109,14 @@ To upgrade your library to the latest dev version, pass the `--pre` flag.
 pip install polyapi-python --pre --upgrade
 ```
 
+## Change Your API Key
+
+If you need to change your API key or what server you are pointing to, you can run:
+
+```bash
+python -m polyapi setup
+```
+
 ## Unit Tests
 
 To run this library's unit tests, please clone the repo then run:

polyapi-python-0.1.0/polyapi/api.py

@@ -0,0 +1,57 @@
+from typing import Any, Dict, List, Tuple
+
+from polyapi.typedefs import PropertySpecification
+from polyapi.utils import add_type_import_path, camelCase, parse_arguments, get_type_and_def
+
+
+API_DEFS_TEMPLATE = """
+from typing import List, Dict, Any, TypedDict
+{args_def}
+{return_type_def}
+class {api_response_type}(TypedDict):
+    status: int
+    headers: Dict
+    data: {return_type_name}
+"""
+
+API_FUNCTION_TEMPLATE = """
+def {function_name}(
+{args}
+) -> {api_response_type}:
+    "{function_description}"
+    resp = execute("{function_type}", "{function_id}", {data})
+    return {api_response_type}(resp.json())  # type: ignore
+"""
+
+
+def render_api_function(
+    function_type: str,
+    function_name: str,
+    function_id: str,
+    function_description: str,
+    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_and_def(return_type)  # type: ignore
+    data = "{" + ", ".join([f"'{arg}': {camelCase(arg)}" for arg in arg_names]) + "}"
+
+    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="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-python-0.1.0/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-python-0.0.35 → polyapi-python-0.1.0}/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-python-0.0.35 → polyapi-python-0.1.0}/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-python-0.1.0/polyapi/execute.py

@@ -0,0 +1,46 @@
+import requests
+from requests import Response
+from polyapi.config import get_api_key_and_url
+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}")
+    return resp

{polyapi-python-0.0.35 → polyapi-python-0.1.0}/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)

polyapi-python-0.1.0/polyapi/generate.py

@@ -0,0 +1,243 @@
+import json
+import requests
+import os
+import shutil
+from typing import Any, Dict, List, Tuple
+
+from polyapi.auth import render_auth_function
+
+from .typedefs import PropertySpecification, SpecificationDto, VariableSpecDto
+from .api import render_api_function
+from .server import render_server_function
+from .utils import add_import_to_init, get_auth_headers, init_the_init
+from .variables import generate_variables
+from .config import get_api_key_and_url, initialize_config
+
+SUPPORTED_FUNCTION_TYPES = {
+    "apiFunction",
+    "authFunction",
+    "serverFunction",
+}
+
+SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable"}
+
+
+def get_specs() -> List:
+    api_key, api_url = get_api_key_and_url()
+    assert api_key
+    headers = get_auth_headers(api_key)
+    url = f"{api_url}/specs"
+    resp = requests.get(url, headers=headers)
+    if resp.status_code == 200:
+        return resp.json()
+    else:
+        raise NotImplementedError(resp.content)
+
+
+def parse_function_specs(
+    specs: List,
+    limit_ids: List[str] | None  # optional list of ids to limit to
+) -> List[Tuple[str, str, str, str, List[PropertySpecification], Dict[str, Any]]]:
+    functions = []
+    for spec in specs:
+        if limit_ids and spec["id"] not in limit_ids:
+            continue
+
+        if spec["type"] not in SUPPORTED_FUNCTION_TYPES:
+            continue
+
+        function_type = spec["type"]
+        function_name = f"poly.{spec['context']}.{spec['name']}"
+        function_id = spec["id"]
+        arguments: List[PropertySpecification] = [
+            arg for arg in spec["function"]["arguments"]
+        ]
+        functions.append(
+            (
+                function_type,
+                function_name,
+                function_id,
+                spec["description"],
+                arguments,
+                spec["function"]["returnType"],
+            )
+        )
+    return functions
+
+
+def cache_specs(specs: List[SpecificationDto]):
+    supported = []
+    for spec in specs:
+        # this needs to stay in sync with logic in parse_specs
+        if spec["type"] in SUPPORTED_TYPES:
+            supported.append(spec)
+
+    full_path = os.path.dirname(os.path.abspath(__file__))
+    full_path = os.path.join(full_path, "poly")
+    if not os.path.exists(full_path):
+        os.makedirs(full_path)
+
+    with open(os.path.join(full_path, "specs.json"), "w") as f:
+        f.write(json.dumps(supported))
+
+
+def get_functions_and_parse(limit_ids: List[str] | None = None):
+    specs = get_specs()
+    cache_specs(specs)
+    functions = parse_function_specs(specs, limit_ids=limit_ids)
+    return functions
+
+
+def get_variables() -> List[VariableSpecDto]:
+    api_key, api_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    # TODO do some caching so this and get_functions just do 1 function call
+    url = f"{api_url}/specs"
+    resp = requests.get(url, headers=headers)
+    if resp.status_code == 200:
+        specs = resp.json()
+        return [spec for spec in specs if spec['type'] == "serverVariable"]
+    else:
+        raise NotImplementedError(resp.content)
+
+
+def remove_old_library():
+    currdir = os.path.dirname(os.path.abspath(__file__))
+    path = os.path.join(currdir, "poly")
+    if os.path.exists(path):
+        shutil.rmtree(path)
+
+    path = os.path.join(currdir, "vari")
+    if os.path.exists(path):
+        shutil.rmtree(path)
+
+
+def generate() -> None:
+    initialize_config()
+
+    remove_old_library()
+
+    functions = get_functions_and_parse()
+    if functions:
+        generate_functions(functions)
+    else:
+        print(
+            "No functions exist yet in this tenant! Empty library initialized. Let's add some functions!"
+        )
+        exit()
+
+    variables = get_variables()
+    if variables:
+        generate_variables(variables)
+
+    # indicator to vscode extension that this is a polyapi-python project
+    file_path = os.path.join(os.getcwd(), '.polyapi-python')
+    open(file_path, 'w').close()
+
+
+
+def clear() -> None:
+    base = os.path.dirname(os.path.abspath(__file__))
+    poly_path = os.path.join(base, "poly")
+    if os.path.exists(poly_path):
+        shutil.rmtree(poly_path)
+
+    vari_path = os.path.join(base, "vari")
+    if os.path.exists(vari_path):
+        shutil.rmtree(vari_path)
+    print("Cleared!")
+
+
+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_the_init(full_path)
+
+    if function_type == "apiFunction":
+        func_str, func_type_defs = render_api_function(
+            function_type,
+            function_name,
+            function_id,
+            function_description,
+            arguments,
+            return_type,
+        )
+    elif function_type == "serverFunction":
+        func_str, func_type_defs = render_server_function(
+            function_type,
+            function_name,
+            function_id,
+            function_description,
+            arguments,
+            return_type,
+        )
+    elif function_type == "authFunction":
+        func_str, func_type_defs = render_auth_function(
+            function_type,
+            function_name,
+            function_id,
+            function_description,
+            arguments,
+            return_type,
+        )
+
+    if func_str:
+        # add function to init
+        init_path = os.path.join(full_path, "__init__.py")
+        with open(init_path, "a") as f:
+            f.write(f"\n\nfrom . import _{function_name}\n\n{func_str}")
+
+        # add type_defs to underscore file
+        file_path = os.path.join(full_path, f"_{function_name}.py")
+        with open(file_path, "w") as f:
+            f.write(func_type_defs)
+
+
+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(full_path)
+                add_import_to_init(full_path, next)
+
+
+# TODO create the socket and pass to create_function?
+
+
+def generate_functions(functions: List) -> None:
+    for func in functions:
+        create_function(*func)