R18 release

polyapi/cli.py

@@ -21,7 +21,7 @@ def execute_from_cli():
         description="Manage your Poly API configurations and functions",
         formatter_class=argparse.RawTextHelpFormatter
     )
-    
+
     subparsers = parser.add_subparsers(help="Available commands")
 
     ###########################################################################
@@ -66,13 +66,13 @@ def generate_command(args):
     fn_add_parser.add_argument("--description", required=False, default="", help="Description of the function")
     fn_add_parser.add_argument("--server", action="store_true", help="Marks the function as a server function")
     fn_add_parser.add_argument("--client", action="store_true", help="Marks the function as a client function")
-    fn_add_parser.add_argument("--logs", choices=["enabled", "disabled"], default="disabled", help="Enable or disable logs for the function.")
+    fn_add_parser.add_argument("--logs", choices=["enabled", "disabled"], default=None, help="Enable or disable logs for the function.")
     fn_add_parser.add_argument("--execution-api-key", required=False, default="", help="API key for execution (for server functions only).")
     fn_add_parser.add_argument("--disable-ai", "--skip-generate", action="store_true", help="Pass --disable-ai skip AI generation of missing descriptions")
 
     def add_function(args):
         initialize_config()
-        logs_enabled = args.logs == "enabled"
+        logs_enabled = args.logs == "enabled" if args.logs else None
         err = ""
         if args.server and args.client:
             err = "Specify either `--server` or `--client`. Found both."

polyapi/deployables.py

@@ -245,7 +245,7 @@ def update_deployment_comments(file_content: str, deployable: dict) -> str:
     if deployable['deployments']:
         deployment_comments = write_deploy_comments(deployable['deployments'])
         deployable['deploymentCommentRanges'] = [(0, len(deployment_comments) + 1)]
-        file_content = f"{deployment_comments}{file_content}"
+        file_content = f"{deployment_comments}\n{file_content}"
     return file_content
 
 def update_deployable_function_comments(file_content: str, deployable: dict, disable_docs: bool = False) -> str:
@@ -261,7 +261,7 @@ def update_deployable_function_comments(file_content: str, deployable: dict, dis
         if deployable["docStartIndex"] == deployable["docEndIndex"]:
             # Function doesn't yet have any docstrings so we need to add additional whitespace
             docstring = "    " + docstring + "\n"
-        
+
         return f"{file_content[:deployable['docStartIndex']]}{docstring}{file_content[deployable['docEndIndex']:]}"
     return file_content
 
@@ -271,17 +271,17 @@ def write_updated_deployable(deployable: dict, disable_docs: bool = False) -> di
     """
     with open(deployable['file'], 'r', encoding='utf-8') as file:
         file_contents = file.read()
-    
+
     if deployable['type'] in ['client-function', 'server-function']:
         file_contents = update_deployable_function_comments(file_contents, deployable, disable_docs)
     else:
         raise ValueError(f"Unsupported deployable type: '{deployable['type']}'")
 
     file_contents = update_deployment_comments(file_contents, deployable)
-    
+
     with open(deployable['file'], 'w', encoding='utf-8') as file:
         file.write(file_contents)
-    
+
     deployable['fileRevision'] = get_deployable_file_revision(file_contents)
     return deployable
 

polyapi/function_cli.py

@@ -1,5 +1,5 @@
 import sys
-from typing import Any, List
+from typing import Any, List, Optional
 import requests
 from polyapi.generate import get_functions_and_parse, generate_functions
 from polyapi.config import get_api_key_and_url
@@ -23,7 +23,7 @@ def function_add_or_update(
     description: str,
     client: bool,
     server: bool,
-    logs_enabled: bool,
+    logs_enabled: Optional[bool],
     generate: bool = True,
     execution_api_key: str = ""
 ):
@@ -45,16 +45,18 @@ def function_add_or_update(
         )
         sys.exit(1)
 
+    if logs_enabled is None:
+        logs_enabled = parsed["config"].get("logs_enabled", None)
+
     data = {
         "context": context or parsed["context"],
         "name": name,
         "description": description or parsed["types"]["description"],
         "code": code,
         "language": "python",
         "returnType": get_jsonschema_type(return_type),
-        "returnTypeSchema": parsed["types"]["returns"]["typeSchema"],
-        "arguments": [{**p, "key": p["name"], "type": get_jsonschema_type(p["type"])  } for p in parsed["types"]["params"]],
-        "logsEnabled": logs_enabled or parsed["config"].get("logs_enabled", False),
+        "arguments": [{**p, "key": p["name"], "type": get_jsonschema_type(p["type"])} for p in parsed["types"]["params"]],
+        "logsEnabled": logs_enabled,
     }
 
     if server and parsed["dependencies"]:

polyapi/parser.py

@@ -47,7 +47,7 @@ def _parse_sphinx_docstring(docstring: str) -> Dict[str, Any]:
         "type": "Any"
     }
     current_section = None
-    
+
     for line in lines:
         stripped_line = line.strip()
         if stripped_line.startswith(":param "):
@@ -56,7 +56,7 @@ def _parse_sphinx_docstring(docstring: str) -> Dict[str, Any]:
             param_name = param_name.strip()
             if param_name in params:
                 params[param_name]["description"] = param_desc.strip()
-            else:    
+            else:
                 params[param_name] = { "name": param_name, "type": "", "description": param_desc.strip() }
             current_section = param_name
 
@@ -118,7 +118,7 @@ def _parse_google_docstring(docstring: str) -> Dict[str, Any]:
     for line in lines:
         line = line.rstrip()
         section_match = section_pattern.match(line)
-        
+
         if section_match:
             mode = section_match.group(1).lower()
             continue
@@ -181,7 +181,7 @@ def _get_schemas(code: str) -> List[Dict]:
 
 def get_jsonschema_type(python_type: str):
     if python_type == "Any":
-        return "Any"
+        return "any"
 
     if python_type == "List":
         return "array"
@@ -338,6 +338,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
             "params": [],
             "returns": {
                 "type": "",
+                "typeSchema": None,
                 "description": "",
             }
         },
@@ -364,7 +365,7 @@ def __init__(self):
                 self._line_offsets.append(
                     self._line_offsets[i-1] + len(self._lines[i-1])
                 )
-            
+
             self._extract_deploy_comments()
 
         def visit_AnnAssign(self, node):
@@ -435,13 +436,14 @@ def _extract_docstring_from_function(self, node: ast.FunctionDef):
 
         def _extract_deploy_comments(self):
             for i in range(len(self._lines)):
-                line = self._lines[i].strip()
+                line = self._lines[i]
                 if line and not line.startswith("#"):
                     return
-                deployment = _parse_deploy_comment(line)
+                deployment = _parse_deploy_comment(line.strip())
                 if deployment:
+                    start = self._line_offsets[i]
                     deployable["deployments"].append(deployment)
-                    deployable["deploymentCommentRanges"].append([self._line_offsets[i], len(line)])
+                    deployable["deploymentCommentRanges"].append([start, start + len(line)])
 
         def visit_Import(self, node: ast.Import):
             # TODO maybe handle `import foo.bar` case?
@@ -471,8 +473,7 @@ def visit_FunctionDef(self, node: ast.FunctionDef):
                         "type": python_type,
                         "description": "",
                     }
-                    if type_schema:
-                        json_arg["typeSchema"] = json.dumps(type_schema)
+                    json_arg["typeSchema"] = json.dumps(type_schema) if type_schema else None
 
                     if docstring_params:
                         try:
@@ -482,7 +483,7 @@ def visit_FunctionDef(self, node: ast.FunctionDef):
                                 if docstring_params[type_index]["type"] != python_type:
                                     deployable["dirty"] = True
                         except:
-                            pass    
+                            pass
                     else:
                         deployable["dirty"] = True
 
@@ -496,7 +497,7 @@ def visit_FunctionDef(self, node: ast.FunctionDef):
                     deployable["types"]["returns"]["typeSchema"] = return_type_schema
                 else:
                     deployable["types"]["returns"]["type"] = "Any"
-                
+
         def generic_visit(self, node):
             if hasattr(node, 'lineno') and hasattr(node, 'col_offset'):
                 self._current_offset = self._line_offsets[node.lineno - 1] + node.col_offset

pyproject.toml

@@ -3,12 +3,12 @@ requires = ["setuptools>=61.2", "wheel"]
 
 [project]
 name = "polyapi-python"
-version = "0.3.1"
+version = "0.3.2"
 description = "The Python Client for PolyAPI, the IPaaS by Developers for Developers"
 authors = [{ name = "Dan Fellin", email = "dan@polyapi.io" }]
 dependencies = [
     "requests==2.31.0",
-    "typing_extensions==4.10.0",
+    "typing_extensions>=4.10.0",
     "jsonschema-gentypes==2.6.0",
     "pydantic==2.6.4",
     "stdlib_list==0.10.0",

requirements.txt

@@ -1,5 +1,5 @@
 requests==2.31.0
-typing_extensions==4.10.0
+typing_extensions>=4.10.0
 jsonschema-gentypes==2.6.0
 pydantic==2.6.4
 stdlib_list==0.10.0

tests/test_deployables.py

@@ -65,17 +65,26 @@ def foobar(foo: str, bar: Dict[str, str]) -> int:
     """A function that does something really import.
 
     Args:
-        foo (str): 
-        bar (Dict[str, str]): 
+        foo (str):
+        bar (Dict[str, str]):
 
     Returns:
-        int: 
+        int:
     """
     print("Okay then!")
     return 7
 '''
 
 class T(unittest.TestCase):
+    def test_parse_and_write_deployment_comment(self):
+        test_deployable = parse_function_code(EXPECTED_SERVER_FN_DEPLOYMENTS, "foobar")
+        deployable_comment_ranges = test_deployable["deploymentCommentRanges"]
+        updated_file_contents = update_deployment_comments(EXPECTED_SERVER_FN_DEPLOYMENTS, test_deployable)
+        self.assertEqual(updated_file_contents, EXPECTED_SERVER_FN_DEPLOYMENTS)
+        # Deployment comment ranges collapsed into one of equal size
+        self.assertEqual(test_deployable["deploymentCommentRanges"][0][0], deployable_comment_ranges[0][0])
+        self.assertEqual(test_deployable["deploymentCommentRanges"][0][1], deployable_comment_ranges[1][1])
+
     def test_write_deployment_comment(self):
         test_deployable = {
             "deployments": [
@@ -98,7 +107,7 @@ def test_write_deployment_comment(self):
                     'type': 'server-function'
                 }
             ],
-            "deploymentCommentRanges": [[0, 178]]
+            "deploymentCommentRanges": [[0, 177]]
         }
         updated_file_contents = update_deployment_comments(INITIAL_SERVER_FN_DEPLOYMENTS, test_deployable)
         self.assertEqual(updated_file_contents, EXPECTED_SERVER_FN_DEPLOYMENTS)

tests/test_parser.py

@@ -3,6 +3,11 @@
 from polyapi.parser import parse_function_code
 
 
+CODE_NO_TYPES = """
+def foobar(a, b):
+    return a + b
+"""
+
 SIMPLE_CODE = """
 def foobar(n: int) -> int:
     return 9
@@ -124,11 +129,21 @@ def foobar(foo: str, bar: Dict[str, str]) -> int:
 '''
 
 class T(unittest.TestCase):
+    def test_no_types(self):
+        deployable = parse_function_code(CODE_NO_TYPES, "foobar")
+        types = deployable["types"]
+        self.assertEqual(len(types["params"]), 2)
+        self.assertEqual(types["params"][0], {"name": "a", "type": "Any", "typeSchema": None, "description": ""})
+        self.assertEqual(types["params"][1], {"name": "b", "type": "Any", "typeSchema": None, "description": ""})
+        self.assertEqual(types["returns"]["type"], "Any")
+        self.assertIsNone(types["returns"]["typeSchema"])
+        self.assertEqual(deployable["dependencies"], [])
+
     def test_simple_types(self):
         deployable = parse_function_code(SIMPLE_CODE, "foobar")
         types = deployable["types"]
         self.assertEqual(len(types["params"]), 1)
-        self.assertEqual(types["params"][0], {"name": "n", "type": "int", "description": ""})
+        self.assertEqual(types["params"][0], {"name": "n", "type": "int", "typeSchema": None, "description": ""})
         self.assertEqual(types["returns"]["type"], "int")
         self.assertIsNone(types["returns"]["typeSchema"])
         self.assertEqual(deployable["dependencies"], [])
@@ -137,7 +152,7 @@ def test_complex_return_type(self):
         deployable = parse_function_code(COMPLEX_RETURN_TYPE, "foobar")
         types = deployable["types"]
         self.assertEqual(len(types["params"]), 1)
-        self.assertEqual(types["params"][0], {"name": "n", "type": "int", "description": ""})
+        self.assertEqual(types["params"][0], {"name": "n", "type": "int", "typeSchema": None, "description": ""})
         self.assertEqual(types["returns"]["type"], "Barbar")
         self.assertEqual(types["returns"]["typeSchema"]['title'], "Barbar")
 
@@ -153,7 +168,7 @@ def test_list_complex_return_type(self):
         deployable = parse_function_code(LIST_COMPLEX_RETURN_TYPE, "foobar")
         types = deployable["types"]
         self.assertEqual(len(types["params"]), 1)
-        self.assertEqual(types["params"][0], {"name": "n", "type": "int", "description": ""})
+        self.assertEqual(types["params"][0], {"name": "n", "type": "int", "typeSchema": None, "description": ""})
         self.assertEqual(types["returns"]["type"], "List[Barbar]")
         self.assertEqual(types["returns"]["typeSchema"]["items"]['title'], "Barbar")
 
@@ -171,7 +186,7 @@ def test_parse_import_base(self):
         code = "import requests\n\n\ndef foobar(n: int) -> int:\n    return 9\n"
         deployable = parse_function_code(code, "foobar")
         self.assertEqual(deployable["dependencies"], [])
-    
+
     def test_parse_glide_server_function_no_docstring(self):
         code = GLIDE_SIMPLE_SERVER_FN
         deployable = parse_function_code(code, "foobar")
@@ -186,11 +201,13 @@ def test_parse_glide_server_function_bad_docstring(self):
         self.assertEqual(deployable["types"]["params"][0], {
             "name": "foo",
             "type": "Any",
+            "typeSchema": None,
             "description": "The foo in question"
         })
         self.assertEqual(deployable["types"]["params"][1], {
             "name": "bar",
             "type": "Any",
+            "typeSchema": None,
             "description": "Configuration of bars"
         })
         self.assertEqual(deployable["types"]["returns"], {
@@ -205,11 +222,13 @@ def test_parse_glide_server_function_ok_docstring(self):
         self.assertEqual(deployable["types"]["params"][0], {
             "name": "foo",
             "type": "str",
+            "typeSchema": None,
             "description": "The foo in question"
         })
         self.assertEqual(deployable["types"]["params"][1], {
             "name": "bar",
             "type": "Dict[str, str]",
+            "typeSchema": None,
             "description": "Configuration of bars"
         })
         self.assertEqual(deployable["types"]["returns"], {