polyapi-python 0.2.3.dev5__tar.gz → 0.2.3.dev7__tar.gz

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.2.3.dev5
+Version: 0.2.3.dev7
 Summary: The PolyAPI Python Client
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/polyapi/cli.py

@@ -23,7 +23,8 @@ def execute_from_cli():
     )
     parser.add_argument("--context", required=False, default="")
     parser.add_argument("--description", required=False, default="")
-    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("--client", action="store_true", help="Pass --client when adding function to add a client function.")
+    parser.add_argument("--server", action="store_true", help="Pass --server when adding function to add a server function.")
     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="*")
@@ -47,4 +48,4 @@ def execute_from_cli():
         print("Clearing the generated library...")
         clear()
     elif command == "function":
-        function_add_or_update(args.context, args.description, args.server, args.logs, args.subcommands)
+        function_add_or_update(args.context, args.description, args.client, args.server, args.logs, args.subcommands)

polyapi-python-0.2.3.dev7/polyapi/client.py

@@ -0,0 +1,25 @@
+from typing import Any, Dict, List, Tuple
+
+from polyapi.typedefs import PropertySpecification
+from polyapi.utils import camelCase, add_type_import_path, parse_arguments, get_type_and_def
+
+DEFS_TEMPLATE = """
+from typing import List, Dict, Any, TypedDict
+{args_def}
+{return_type_def}
+"""
+
+
+def render_client_function(
+    function_name: str,
+    code: str,
+    arguments: List[PropertySpecification],
+    return_type: Dict[str, Any],
+) -> Tuple[str, str]:
+    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 = DEFS_TEMPLATE.format(
+        args_def=args_def,
+        return_type_def=return_type_def,
+    )
+    return code, func_type_defs

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/polyapi/function_cli.py

@@ -175,7 +175,7 @@ def _func_already_exists(context: str, function_name: str) -> bool:
 
 
 def function_add_or_update(
-    context: str, description: str, 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"])
@@ -184,7 +184,8 @@ def function_add_or_update(
     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="")
+    ftype = "server" if server else "client"
+    print(f"{verb} custom {ftype} function...", end="")
 
     with open(args.filename, "r") as f:
         code = f.read()
@@ -202,9 +203,6 @@ def function_add_or_update(
         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,
@@ -213,18 +211,24 @@ def function_add_or_update(
         "language": "python",
         "returnType": return_type,
         "returnTypeSchema": return_type_schema,
-        "requirements": requirements,
         "arguments": arguments,
         "logsEnabled": logs_enabled,
     }
 
+    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.')
+        data["requirements"] = requirements
+
     api_key, api_url = get_api_key_and_url()
     assert api_key
     if server:
         url = f"{api_url}/functions/server"
+    elif client:
+        url = f"{api_url}/functions/client"
     else:
-        raise NotImplementedError("Client functions not yet implemented.")
-        # url = f"{base_url}/functions/client"
+        print_red("ERROR")
+        print("Please specify type of function with --client or --server")
+        sys.exit(1)
 
     headers = get_auth_headers(api_key)
     resp = requests.post(url, headers=headers, json=data)

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/polyapi/generate.py

@@ -2,9 +2,10 @@ import json
 import requests
 import os
 import shutil
-from typing import Any, Dict, List, Tuple
+from typing import List
 
 from polyapi.auth import render_auth_function
+from polyapi.client import render_client_function
 from polyapi.execute import execute_post
 from polyapi.webhook import render_webhook_handle
 
@@ -18,6 +19,7 @@ from .config import get_api_key_and_url, initialize_config
 SUPPORTED_FUNCTION_TYPES = {
     "apiFunction",
     "authFunction",
+    "customFunction",
     "serverFunction",
     "webhookHandle",
 }
@@ -38,32 +40,29 @@ def get_specs() -> List:
 
 
 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]]]:
+    specs: List[SpecificationDto],
+    limit_ids: List[str] | None,  # optional list of ids to limit to
+) -> List[SpecificationDto]:
     functions = []
     for spec in specs:
+        if not spec or "function" not in spec:
+            continue
+
+        if not spec["function"]:
+            continue
+
         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"],
-            )
-        )
+        if spec["type"] == "customFunction" and spec["language"] != "python":
+            # poly libraries only support client functions of same language
+            continue
+
+        functions.append(spec)
+
     return functions
 
 
@@ -90,11 +89,10 @@ def read_cached_specs() -> List[SpecificationDto]:
         return json.loads(f.read())
 
 
-def get_functions_and_parse(limit_ids: List[str] | None = None):
+def get_functions_and_parse(limit_ids: List[str] | None = None) -> List[SpecificationDto]:
     specs = get_specs()
     cache_specs(specs)
-    functions = parse_function_specs(specs, limit_ids=limit_ids)
-    return functions
+    return parse_function_specs(specs, limit_ids=limit_ids)
 
 
 def get_variables() -> List[VariableSpecDto]:
@@ -162,14 +160,7 @@ def save_rendered_specs() -> None:
     api_specs = [spec for spec in specs if spec["type"] == "apiFunction"]
     for spec in api_specs:
         assert spec["function"]
-        func_str, type_defs = render_spec(
-            spec["type"],
-            spec["name"],
-            spec["id"],
-            spec["description"],
-            spec["function"]["arguments"],
-            spec["function"]["returnType"],
-        )
+        func_str, type_defs = render_spec(spec)
         data = {
             "language": "python",
             "apiFunctionId": spec["id"],
@@ -181,14 +172,20 @@ def save_rendered_specs() -> None:
         assert resp.status_code == 201, (resp.text, resp.status_code)
 
 
-def render_spec(
-    function_type: str,
-    function_name: str,
-    function_id: str,
-    function_description: str,
-    arguments: List[PropertySpecification],
-    return_type: Dict[str, Any],
-):
+def render_spec(spec: SpecificationDto):
+    function_type = spec["type"]
+    function_description = spec["description"]
+    function_name = spec["name"]
+    function_id = spec["id"]
+
+    arguments: List[PropertySpecification] = []
+    return_type = {}
+    if spec["function"]:
+        arguments = [
+            arg for arg in spec["function"]["arguments"]
+        ]
+        return_type = spec["function"]["returnType"]
+
     if function_type == "apiFunction":
         func_str, func_type_defs = render_api_function(
             function_type,
@@ -198,6 +195,13 @@ def render_spec(
             arguments,
             return_type,
         )
+    elif function_type == "customFunction":
+        func_str, func_type_defs = render_client_function(
+            function_name,
+            spec["code"],
+            arguments,
+            return_type,
+        )
     elif function_type == "serverFunction":
         func_str, func_type_defs = render_server_function(
             function_type,
@@ -229,25 +233,14 @@ def render_spec(
 
 
 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],
+    spec: SpecificationDto,
 ):
     # first lets add the import to the __init__
     init_the_init(full_path)
 
-    func_str, func_type_defs = render_spec(
-        function_type,
-        function_name,
-        function_id,
-        function_description,
-        arguments,
-        return_type,
-    )
+    func_str, func_type_defs = render_spec(spec)
 
     if func_str:
         # add function to init
@@ -262,27 +255,17 @@ def add_function_file(
 
 
 def create_function(
-    function_type: str,
-    path: str,
-    function_id: str,
-    function_description: str,
-    arguments: List[PropertySpecification],
-    return_type: Dict[str, Any],
+    spec: SpecificationDto
 ) -> None:
     full_path = os.path.dirname(os.path.abspath(__file__))
-
-    folders = path.split(".")
+    folders = f"poly.{spec['context']}.{spec['name']}".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,
+                spec,
             )
         else:
             full_path = os.path.join(full_path, folder)
@@ -296,9 +279,6 @@ def create_function(
                 add_import_to_init(full_path, next)
 
 
-# TODO create the socket and pass to create_function?
-
-
-def generate_functions(functions: List) -> None:
+def generate_functions(functions: List[SpecificationDto]) -> None:
     for func in functions:
-        create_function(*func)
+        create_function(func)

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/polyapi/typedefs.py

@@ -32,9 +32,11 @@ class SpecificationDto(TypedDict):
     context: str
     name: str
     description: str
-    # function is none if this is actually VariableSpecDto
-    function: FunctionSpecification | None
+    # function is none (or function key not present) if this is actually VariableSpecDto
+    function: NotRequired[FunctionSpecification | None]
     type: Literal['apiFunction', 'customFunction', 'serverFunction', 'authFunction', 'webhookHandle', 'serverVariable']
+    code: NotRequired[str]
+    language: str
 
 
 class VariableSpecification(TypedDict):

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/polyapi_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.2.3.dev5
+Version: 0.2.3.dev7
 Summary: The PolyAPI Python Client
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/polyapi_python.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ polyapi/__main__.py
 polyapi/api.py
 polyapi/auth.py
 polyapi/cli.py
+polyapi/client.py
 polyapi/config.py
 polyapi/constants.py
 polyapi/error_handler.py

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.2", "wheel"]
 
 [project]
 name = "polyapi-python"
-version = "0.2.3.dev5"
+version = "0.2.3.dev7"
 description = "The PolyAPI Python Client"
 authors = [{ name = "Dan Fellin", email = "dan@polyapi.io" }]
 dependencies = [

{polyapi-python-0.2.3.dev5 → polyapi-python-0.2.3.dev7}/tests/test_function_cli.py

@@ -79,12 +79,12 @@ class T(unittest.TestCase):
     def test_parse_import_basic(self):
         code = "import flask\n\n\ndef foobar(n: int) -> int:\n    return 9\n"
         _, _, _, additional_requirements = _parse_code(code, "foobar")
-        self.assertEqual(additional_requirements, ["flask"])
+        self.assertEqual(additional_requirements, ["Flask"])
 
     def test_parse_import_from(self):
         code = "from flask import Request, Response\n\n\ndef foobar(n: int) -> int:\n    return 9\n"
         _, _, _, additional_requirements = _parse_code(code, "foobar")
-        self.assertEqual(additional_requirements, ["flask"])
+        self.assertEqual(additional_requirements, ["Flask"])
 
     def test_parse_import_base(self):
         code = "import requests\n\n\ndef foobar(n: int) -> int:\n    return 9\n"