polyapi-python 0.2.3.dev4__tar.gz → 0.2.3.dev6__tar.gz

{polyapi-python-0.2.3.dev4 → polyapi-python-0.2.3.dev6}/PKG-INFO

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

polyapi-python-0.2.3.dev6/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.dev4 → polyapi-python-0.2.3.dev6}/polyapi/function_cli.py

@@ -3,7 +3,7 @@ import argparse
 import json
 import types
 import sys
-from typing import Dict, List, Tuple
+from typing import Dict, List, Mapping, Optional, Tuple
 from typing_extensions import _TypedDictMeta  # type: ignore
 import requests
 from stdlib_list import stdlib_list
@@ -18,7 +18,7 @@ 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"}
+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
 
@@ -104,6 +104,19 @@ 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]:
+    if not n:
+        return None
+
+    if "." in n:
+        n = n.split(".")[0]
+
+    if n in BASE_REQUIREMENTS:
+        return None
+    else:
+        return pip_name_lookup[n][0]
+
+
 def _parse_code(code: str, function_name: str):
     parsed_args = []
     return_type = None
@@ -121,13 +134,16 @@ def _parse_code(code: str, function_name: str):
 
     for node in ast.iter_child_nodes(parsed_code):
         if isinstance(node, ast.Import):
+            # TODO maybe handle `import foo.bar` case?
             for name in node.names:
-                if name.name not in BASE_REQUIREMENTS:
-                    requirements.append(name.name)
+                req = _get_req_name_if_not_in_base(name.name, pip_name_lookup)
+                if req:
+                    requirements.append(req)
         elif isinstance(node, ast.ImportFrom):
-            if node.module and node.module not in BASE_REQUIREMENTS:
-                req = pip_name_lookup[node.module][0]
-                requirements.append(req)
+            if node.module:
+                req = _get_req_name_if_not_in_base(node.module, pip_name_lookup)
+                if req:
+                    requirements.append(req)
 
         elif isinstance(node, ast.FunctionDef) and node.name == function_name:
             function_args = [arg for arg in node.args.args]
@@ -168,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()
@@ -186,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,
@@ -197,18 +211,20 @@ 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"
     else:
-        raise NotImplementedError("Client functions not yet implemented.")
-        # url = f"{base_url}/functions/client"
+        url = f"{api_url}/functions/client"
 
     headers = get_auth_headers(api_key)
     resp = requests.post(url, headers=headers, json=data)

{polyapi-python-0.2.3.dev4 → polyapi-python-0.2.3.dev6}/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.dev4 → polyapi-python-0.2.3.dev6}/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.dev4 → polyapi-python-0.2.3.dev6}/polyapi_python.egg-info/PKG-INFO

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

{polyapi-python-0.2.3.dev4 → polyapi-python-0.2.3.dev6}/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.dev4 → polyapi-python-0.2.3.dev6}/pyproject.toml

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