polyapi-python 0.3.2.dev2__py3-none-any.whl → 0.3.3.dev9__py3-none-any.whl

polyapi/api.py

@@ -8,6 +8,7 @@ API_DEFS_TEMPLATE = """
 from typing import List, Dict, Any, TypedDict
 {args_def}
 {return_type_def}
+
 class {api_response_type}(TypedDict):
     status: int
     headers: Dict
@@ -41,6 +42,7 @@ def render_api_function(
     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}': {rewrite_arg_name(arg)}" for arg in arg_names]) + "}"
 
     api_response_type = f"{function_name}Response"

polyapi/cli.py

@@ -13,6 +13,7 @@ from .sync import sync_deployables
 
 CLI_COMMANDS = ["setup", "generate", "function", "clear", "help", "update_rendered_spec"]
 
+
 def execute_from_cli():
     # First we setup all our argument parsing logic
     # Then we parse the arguments (waaay at the bottom)
@@ -21,7 +22,7 @@ def execute_from_cli():
         description="Manage your Poly API configurations and functions",
         formatter_class=argparse.RawTextHelpFormatter
     )
-    
+
     subparsers = parser.add_subparsers(help="Available commands")
 
     ###########################################################################
@@ -46,9 +47,7 @@ def execute_from_cli():
 
     def generate_command(args):
         initialize_config()
-        print("Generating Poly functions...", end="")
         generate()
-        print_green("DONE")
 
     generate_parser.set_defaults(command=generate_command)
 

polyapi/config.py

@@ -55,6 +55,10 @@ def set_api_key_and_url(key: str, url: str):
     config.set("polyapi", "poly_api_base_url", url)
     with open(get_config_file_path(), "w") as f:
         config.write(f)
+    global API_KEY
+    global API_URL
+    API_KEY = key
+    API_URL = url
 
 
 def initialize_config(force=False):
@@ -81,7 +85,7 @@ def initialize_config(force=False):
                 sys.exit(1)
 
             set_api_key_and_url(key, url)
-            print_green(f"Poly setup complete.")
+            print_green("Poly setup complete.")
 
     if not key or not url:
         print_yellow("Poly API Key and Poly API Base URL are required.")

polyapi/deployables.py

@@ -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/execute.py

@@ -1,3 +1,4 @@
+from typing import Dict
 import requests
 from requests import Response
 from polyapi.config import get_api_key_and_url
@@ -7,10 +8,14 @@ from polyapi.exceptions import PolyApiException
 def execute(function_type, function_id, data) -> Response:
     """ execute a specific function id/type
     """
+    data_without_None = data
+    if isinstance(data, Dict):
+        data_without_None = {k: v for k, v in data.items() if v is not None}
+
     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)
+    resp = requests.post(url, json=data_without_None, headers=headers)
     # print(resp.status_code)
     # print(resp.headers["content-type"])
     if resp.status_code < 200 or resp.status_code >= 300:

polyapi/function_cli.py

@@ -1,7 +1,7 @@
 import sys
 from typing import Any, List, Optional
 import requests
-from polyapi.generate import get_functions_and_parse, generate_functions
+from polyapi.generate import generate as generate_library
 from polyapi.config import get_api_key_and_url
 from polyapi.utils import get_auth_headers, print_green, print_red, print_yellow
 from polyapi.parser import parse_function_code, get_jsonschema_type
@@ -55,7 +55,7 @@ def function_add_or_update(
         "code": code,
         "language": "python",
         "returnType": get_jsonschema_type(return_type),
-        "arguments": [{**p, "key": p["name"], "type": get_jsonschema_type(p["type"])  } for p in parsed["types"]["params"]],
+        "arguments": [{**p, "key": p["name"], "type": get_jsonschema_type(p["type"])} for p in parsed["types"]["params"]],
         "logsEnabled": logs_enabled,
     }
 
@@ -87,10 +87,7 @@ def function_add_or_update(
         function_id = resp.json()["id"]
         print(f"Function ID: {function_id}")
         if generate:
-            print("Generating new custom function...", end="")
-            functions = get_functions_and_parse(limit_ids=[function_id])
-            generate_functions(functions)
-            print_green("DONE")
+            generate_library()
     else:
         print("Error adding function.")
         print(resp.status_code)

polyapi/generate.py

@@ -2,28 +2,38 @@ import json
 import requests
 import os
 import shutil
-from typing import List
+from typing import List, Tuple, cast
 
-from polyapi.auth import render_auth_function
-from polyapi.client import render_client_function
-from polyapi.webhook import render_webhook_handle
+from .auth import render_auth_function
+from .client import render_client_function
+from .poly_schemas import generate_schemas
+from .webhook import render_webhook_handle
 
-from .typedefs import PropertySpecification, SpecificationDto, VariableSpecDto
+from .typedefs import PropertySpecification, SchemaSpecDto, 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, to_func_namespace
+from .utils import add_import_to_init, get_auth_headers, init_the_init, print_green, to_func_namespace
 from .variables import generate_variables
 from .config import get_api_key_and_url
 
 SUPPORTED_FUNCTION_TYPES = {
     "apiFunction",
     "authFunction",
-    "customFunction",
+    "customFunction",  # client function - this is badly named in /specs atm
     "serverFunction",
     "webhookHandle",
 }
 
-SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable"}
+SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable", "schema", "snippet"}
+
+
+X_POLY_REF_WARNING = '''"""
+x-poly-ref:
+  path:'''
+
+X_POLY_REF_BETTER_WARNING = '''"""
+Unresolved schema, please add the following schema to complete it:
+  path:'''
 
 
 def get_specs() -> List:
@@ -38,9 +48,56 @@ def get_specs() -> List:
         raise NotImplementedError(resp.content)
 
 
+def build_schema_index(items):
+    index = {}
+    for item in items:
+        if item.get("type") == "schema" and "contextName" in item:
+            index[item["contextName"]] = {**item.get("definition", {}), "name": item.get("name")}
+    return index
+
+
+def resolve_poly_refs(obj, schema_index):
+    if isinstance(obj, dict):
+        if "x-poly-ref" in obj:
+            ref = obj["x-poly-ref"]
+            if isinstance(ref, dict) and "path" in ref:
+                path = ref["path"]
+                if path in schema_index:
+                    return resolve_poly_refs(schema_index[path], schema_index)
+                else:
+                    return obj
+        return {k: resolve_poly_refs(v, schema_index) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [resolve_poly_refs(item, schema_index) for item in obj]
+    else:
+        return obj
+
+
+def replace_poly_refs_in_functions(specs: List[SpecificationDto], schema_index):
+    spec_idxs_to_remove = []
+    for idx, spec in enumerate(specs):
+        if spec.get("type") in ("apiFunction", "customFunction", "serverFunction"):
+            func = spec.get("function")
+            if func:
+                try:
+                    spec["function"] = resolve_poly_refs(func, schema_index)
+                except Exception:
+                    # print()
+                    # print(f"{spec['context']}.{spec['name']} (id: {spec['id']}) failed to resolve poly refs, skipping!")
+                    spec_idxs_to_remove.append(idx)
+
+    # reverse the list so we pop off later indexes first
+    spec_idxs_to_remove.reverse()
+
+    for idx in spec_idxs_to_remove:
+        specs.pop(idx)
+
+    return specs
+
+
 def parse_function_specs(
     specs: List[SpecificationDto],
-    limit_ids: List[str] | None,  # optional list of ids to limit to
+    limit_ids: List[str] | None = None,  # optional list of ids to limit to
 ) -> List[SpecificationDto]:
     functions = []
     for spec in specs:
@@ -91,23 +148,14 @@ def read_cached_specs() -> List[SpecificationDto]:
         return json.loads(f.read())
 
 
-def get_functions_and_parse(limit_ids: List[str] | None = None) -> List[SpecificationDto]:
-    specs = get_specs()
-    cache_specs(specs)
-    return parse_function_specs(specs, limit_ids=limit_ids)
+def get_variables() -> List[VariableSpecDto]:
+    specs = read_cached_specs()
+    return [cast(VariableSpecDto, spec) for spec in specs if spec["type"] == "serverVariable"]
 
 
-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 get_schemas() -> List[SchemaSpecDto]:
+    specs = read_cached_specs()
+    return [cast(SchemaSpecDto, spec) for spec in specs if spec["type"] == "schema"]
 
 
 def remove_old_library():
@@ -120,12 +168,28 @@ def remove_old_library():
     if os.path.exists(path):
         shutil.rmtree(path)
 
+    path = os.path.join(currdir, "schemas")
+    if os.path.exists(path):
+        shutil.rmtree(path)
 
-def generate() -> None:
 
+def generate() -> None:
+    print("Generating Poly Python SDK...", end="", flush=True)
     remove_old_library()
 
-    functions = get_functions_and_parse()
+    specs = get_specs()
+    cache_specs(specs)
+
+    limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
+    functions = parse_function_specs(specs, limit_ids=limit_ids)
+
+    schemas = get_schemas()
+    if schemas:
+        generate_schemas(schemas)
+
+    schema_index = build_schema_index(schemas)
+    functions = replace_poly_refs_in_functions(functions, schema_index)
+
     if functions:
         generate_functions(functions)
     else:
@@ -138,10 +202,13 @@ def generate() -> None:
     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()
 
+    print_green("DONE")
+
 
 def clear() -> None:
     base = os.path.dirname(os.path.abspath(__file__))
@@ -155,7 +222,7 @@ def clear() -> None:
     print("Cleared!")
 
 
-def render_spec(spec: SpecificationDto):
+def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
     function_type = spec["type"]
     function_description = spec["description"]
     function_name = spec["name"]
@@ -214,6 +281,12 @@ def render_spec(spec: SpecificationDto):
             arguments,
             return_type,
         )
+
+    if X_POLY_REF_WARNING in func_type_defs:
+        # this indicates that jsonschema_gentypes has detected an x-poly-ref
+        # let's add a more user friendly error explaining what is going on
+        func_type_defs = func_type_defs.replace(X_POLY_REF_WARNING, X_POLY_REF_BETTER_WARNING)
+
     return func_str, func_type_defs
 
 

polyapi/parser.py

@@ -5,7 +5,7 @@ import sys
 import re
 from typing import Dict, List, Mapping, Optional, Tuple, Any
 from typing import _TypedDictMeta as BaseTypedDict  # type: ignore
-from typing_extensions import _TypedDictMeta  # type: ignore
+from typing_extensions import _TypedDictMeta, cast # type: ignore
 from stdlib_list import stdlib_list
 from pydantic import TypeAdapter
 from importlib.metadata import packages_distributions
@@ -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
@@ -158,6 +158,7 @@ def _parse_google_docstring(docstring: str) -> Dict[str, Any]:
 
     return parsed
 
+
 def _get_schemas(code: str) -> List[Dict]:
     schemas = []
     user_code = types.SimpleNamespace()
@@ -245,7 +246,7 @@ def _get_type_schema(json_type: str, python_type: str, schemas: List[Dict]):
                 return schema
 
 
-def _get_type(expr: ast.expr | None, schemas: List[Dict]) -> Tuple[str, Dict | None]:
+def _get_type(expr: ast.expr | None, schemas: List[Dict]) -> Tuple[Any, Any, Any]:
     if not expr:
         return "any", "Any", None
     python_type = get_python_type_from_ast(expr)
@@ -317,7 +318,7 @@ def _parse_value(value):
         return None
 
 
-def parse_function_code(code: str, name: Optional[str] = "", context: Optional[str] = ""):
+def parse_function_code(code: str, name: Optional[str] = "", context: Optional[str] = ""):  # noqa: C901
     schemas = _get_schemas(code)
 
     # the pip name and the import name might be different
@@ -325,9 +326,9 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
     # see https://stackoverflow.com/a/75144378
     pip_name_lookup = packages_distributions()
 
-    deployable: DeployableRecord = {
-        "context": context,
-        "name": name,
+    deployable: DeployableRecord = {  # type: ignore
+        "context": context,  # type: ignore
+        "name": name,  # type: ignore
         "description": "",
         "config": {},
         "gitRevision": "",
@@ -365,7 +366,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
                 self._line_offsets.append(
                     self._line_offsets[i-1] + len(self._lines[i-1])
                 )
-            
+
             self._extract_deploy_comments()
 
         def visit_AnnAssign(self, node):
@@ -381,7 +382,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
                 if node.annotation.id == "PolyServerFunction":
                     deployable["type"] = "server-function"
                 elif node.annotation.id == "PolyClientFunction":
-                    deployable["type"] = "server-function"
+                    deployable["type"] = "client-function"
                 else:
                     print_red("ERROR")
                     print(f"Unsupported polyConfig type '${node.annotation.id}'")
@@ -404,6 +405,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
                 if type(docstring) is None or (not docstring and '"""' not in self._lines[start_lineno] and "'''" not in self._lines[start_lineno]):
                     return None
 
+            docstring = cast(str, docstring)
 
             # Support both types of triple quotation marks
             pattern = '"""'
@@ -483,7 +485,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
                                 if docstring_params[type_index]["type"] != python_type:
                                     deployable["dirty"] = True
                         except:
-                            pass    
+                            pass
                     else:
                         deployable["dirty"] = True
 
@@ -497,7 +499,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
                     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

polyapi/poly_schemas.py

@@ -0,0 +1,95 @@
+import os
+from typing import Any, Dict, List, Tuple
+
+from polyapi.schema import wrapped_generate_schema_types
+from polyapi.utils import add_import_to_init, init_the_init, to_func_namespace
+
+from .typedefs import SchemaSpecDto
+
+SCHEMA_CODE_IMPORTS = """from typing_extensions import TypedDict, NotRequired
+
+__all__ = []
+
+
+"""
+
+
+FALLBACK_SPEC_TEMPLATE = """class {name}(TypedDict, total=False):
+    ''' unable to generate schema for {name}, defaulting to permissive type '''
+    pass
+"""
+
+
+def generate_schemas(specs: List[SchemaSpecDto]):
+    for spec in specs:
+        create_schema(spec)
+
+
+def add_schema_file(
+    full_path: str,
+    schema_name: str,
+    spec: SchemaSpecDto,
+):
+    # first lets add the import to the __init__
+    init_the_init(full_path, SCHEMA_CODE_IMPORTS)
+
+    if not spec["definition"].get("title"):
+        # very empty schemas like mews.Unit are possible
+        # add a title here to be sure they render
+        spec["definition"]["title"] = schema_name
+
+    schema_defs = render_poly_schema(spec)
+
+    if schema_defs:
+        # 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 ._{to_func_namespace(schema_name)} import {schema_name}\n__all__.append('{schema_name}')\n")
+
+        # add type_defs to underscore file
+        file_path = os.path.join(full_path, f"_{to_func_namespace(schema_name)}.py")
+        with open(file_path, "w") as f:
+            f.write(schema_defs)
+
+
+def create_schema(
+    spec: SchemaSpecDto
+) -> None:
+    full_path = os.path.dirname(os.path.abspath(__file__))
+    folders = f"schemas.{spec['context']}.{spec['name']}".split(".")
+    for idx, folder in enumerate(folders):
+        if idx + 1 == len(folders):
+            # special handling for final level
+            add_schema_file(
+                full_path,
+                folder,
+                spec,
+            )
+        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, SCHEMA_CODE_IMPORTS)
+                add_import_to_init(full_path, next)
+
+
+def add_schema_to_init(full_path: str, spec: SchemaSpecDto):
+    init_the_init(full_path, code_imports="")
+    init_path = os.path.join(full_path, "__init__.py")
+    with open(init_path, "a") as f:
+        f.write(render_poly_schema(spec) + "\n\n")
+
+
+def render_poly_schema(spec: SchemaSpecDto) -> str:
+    definition = spec["definition"]
+    if not definition.get("type"):
+        definition["type"] = "object"
+    root, schema_types = wrapped_generate_schema_types(
+        definition, root=spec["name"], fallback_type=Dict
+    )
+    return schema_types
+    # return FALLBACK_SPEC_TEMPLATE.format(name=spec["name"])

polyapi/schema.py

@@ -1,11 +1,17 @@
+""" NOTE: this file represents the schema parsing logic for jsonschema_gentypes
+"""
 import logging
 import contextlib
+import re
 from typing import Dict
 from jsonschema_gentypes.cli import process_config
 from jsonschema_gentypes import configuration
+import referencing
 import tempfile
 import json
 
+import referencing.exceptions
+
 from polyapi.constants import JSONSCHEMA_TO_PYTHON_TYPE_MAP
 
 
@@ -33,8 +39,16 @@ def _temp_store_input_data(input_data: Dict) -> str:
 
 
 def wrapped_generate_schema_types(type_spec: dict, root, fallback_type):
+    from polyapi.utils import pascalCase
     if not root:
-        root = "MyList" if fallback_type == "List" else "MyDict"
+        root = "List" if fallback_type == "List" else "Dict"
+        if type_spec.get("x-poly-ref") and type_spec["x-poly-ref"].get("path"):
+            # x-poly-ref occurs when we have an unresolved reference
+            # lets name the root after the reference for some level of visibility
+            root += pascalCase(type_spec["x-poly-ref"]["path"].replace(".", " "))
+        else:
+            # if we have no root, just add "My"
+            root = "My" + root
 
     root = clean_title(root)
 
@@ -44,8 +58,13 @@ def wrapped_generate_schema_types(type_spec: dict, root, fallback_type):
         # some schemas are so huge, our library cant handle it
         # TODO identify critical recursion penalty and maybe switch underlying logic to iterative?
         return fallback_type, ""
+    except referencing.exceptions.CannotDetermineSpecification:
+        # just go with fallback_type here
+        # we couldn't match the right $ref earlier in resolve_poly_refs
+        # {'$ref': '#/definitions/FinanceAccountListModel'}
+        return fallback_type, ""
     except:
-        logging.exception(f"Error when generating schema type: {type_spec}")
+        logging.error(f"Error when generating schema type: {type_spec}\nusing fallback type '{fallback_type}'")
         return fallback_type, ""
 
 
@@ -77,9 +96,23 @@ def generate_schema_types(input_data: Dict, root=None):
     with open(tmp_output) as f:
         output = f.read()
 
+    output = clean_malformed_examples(output)
+
     return output
 
 
+# Regex to match everything between "# example: {\n" and "^}$"
+MALFORMED_EXAMPLES_PATTERN = re.compile(r"# example: \{\n.*?^\}$", flags=re.DOTALL | re.MULTILINE)
+
+
+def clean_malformed_examples(example: str) -> str:
+    """ there is a bug in the `jsonschmea_gentypes` library where if an example from a jsonchema is an object,
+    it will break the code because the object won't be properly commented out
+    """
+    cleaned_example = MALFORMED_EXAMPLES_PATTERN.sub("", example)
+    return cleaned_example
+
+
 def clean_title(title: str) -> str:
     """ used by library generation, sometimes functions can be added with spaces in the title
     or other nonsense. fix them!

polyapi/server.py

@@ -1,7 +1,7 @@
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Tuple, cast
 
-from polyapi.typedefs import PropertySpecification
-from polyapi.utils import add_type_import_path, parse_arguments, get_type_and_def, rewrite_arg_name
+from polyapi.typedefs import PropertySpecification, PropertyType
+from polyapi.utils import add_type_import_path, parse_arguments, get_type_and_def, return_type_already_defined_in_args, rewrite_arg_name
 
 SERVER_DEFS_TEMPLATE = """
 from typing import List, Dict, Any, TypedDict, Callable
@@ -21,7 +21,7 @@ def {function_name}(
     try:
         return {return_action}
     except:
-        return resp.text
+        return resp.text  # type: ignore # fallback for debugging
 
 
 """
@@ -37,7 +37,11 @@ def render_server_function(
 ) -> Tuple[str, str]:
     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
+    return_type_name, return_type_def = get_type_and_def(cast(PropertyType, return_type), "ReturnType")
+
+    if return_type_def and return_type_already_defined_in_args(return_type_name, args_def):
+        return_type_def = ""
+
     data = "{" + ", ".join([f"'{arg}': {rewrite_arg_name(arg)}" for arg in arg_names]) + "}"
     func_type_defs = SERVER_DEFS_TEMPLATE.format(
         args_def=args_def,

polyapi/typedefs.py

@@ -55,6 +55,19 @@ class VariableSpecDto(TypedDict):
     variable: VariableSpecification
     type: Literal['serverVariable']
 
+
+class SchemaSpecDto(TypedDict):
+    id: str
+    context: str
+    name: str
+    contextName: str
+    type: Literal['schema']
+    definition: Dict[Any, Any]
+    visibilityMetadata: object
+    unresolvedPolySchemaRefs: List
+    # TODO add more
+
+
 Visibility = Union[Literal['PUBLIC'], Literal['TENANT'], Literal['ENVIRONMENT']]
 
 
@@ -69,6 +82,7 @@ class PolyServerFunction(PolyDeployable):
     always_on: NotRequired[bool]
     visibility: NotRequired[Visibility]
 
+
 class PolyClientFunction(PolyDeployable):
     logs_enabled: NotRequired[bool]
     visibility: NotRequired[Visibility]

polyapi/utils.py

@@ -6,24 +6,28 @@ from typing import Tuple, List
 from colorama import Fore, Style
 from polyapi.constants import BASIC_PYTHON_TYPES
 from polyapi.typedefs import PropertySpecification, PropertyType
-from polyapi.schema import wrapped_generate_schema_types, clean_title, map_primitive_types
+from polyapi.schema import (
+    wrapped_generate_schema_types,
+    clean_title,
+    map_primitive_types,
+)
 
 
 # this string should be in every __init__ file.
 # it contains all the imports needed for the function or variable code to run
-CODE_IMPORTS = "from typing import List, Dict, Any, TypedDict, Optional, Callable\nimport logging\nimport requests\nimport socketio  # type: ignore\nfrom polyapi.config import get_api_key_and_url\nfrom polyapi.execute import execute, execute_post, variable_get, variable_update\n\n"
-FALLBACK_TYPES = {"Dict", "List"}
+CODE_IMPORTS = "from typing import List, Dict, Any, Optional, Callable\nfrom typing_extensions import TypedDict, NotRequired\nimport logging\nimport requests\nimport socketio  # type: ignore\nfrom polyapi.config import get_api_key_and_url\nfrom polyapi.execute import execute, execute_post, variable_get, variable_update\n\n"
 
 
-def init_the_init(full_path: str) -> None:
+def init_the_init(full_path: str, code_imports="") -> None:
     init_path = os.path.join(full_path, "__init__.py")
     if not os.path.exists(init_path):
+        code_imports = code_imports or CODE_IMPORTS
         with open(init_path, "w") as f:
-            f.write(CODE_IMPORTS)
+            f.write(code_imports)
 
 
-def add_import_to_init(full_path: str, next: str) -> None:
-    init_the_init(full_path)
+def add_import_to_init(full_path: str, next: str, code_imports="") -> None:
+    init_the_init(full_path, code_imports=code_imports)
 
     init_path = os.path.join(full_path, "__init__.py")
     with open(init_path, "a+") as f:
@@ -38,16 +42,20 @@ def get_auth_headers(api_key: str):
     return {"Authorization": f"Bearer {api_key}"}
 
 
-def camelCase(s):
+def camelCase(s: str) -> str:
     s = s.strip()
     if " " in s or "-" in s:
         s = re.sub(r"(_|-)+", " ", s).title().replace(" ", "")
-        return ''.join([s[0].lower(), s[1:]])
+        return "".join([s[0].lower(), s[1:]])
     else:
         # s is already in camelcase as best as we can tell, just move on!
         return s
 
 
+def pascalCase(s) -> str:
+    return re.sub(r"(^|_)([a-z])", lambda match: match.group(2).upper(), s)
+
+
 def print_green(s: str):
     print(Fore.GREEN + s + Style.RESET_ALL)
 
@@ -61,8 +69,7 @@ def print_red(s: str):
 
 
 def add_type_import_path(function_name: str, arg: str) -> str:
-    """ if not basic type, coerce to camelCase and add the import path
-    """
+    """if not basic type, coerce to camelCase and add the import path"""
     # for now, just treat Callables as basic types
     if arg.startswith("Callable"):
         return arg
@@ -79,12 +86,16 @@ def add_type_import_path(function_name: str, arg: str) -> str:
                 sub = sub.replace('"', "")
                 return f'List["{to_func_namespace(function_name)}.{camelCase(sub)}"]'
             else:
-                return f'List[{to_func_namespace(function_name)}.{camelCase(sub)}]'
+                return f"List[{to_func_namespace(function_name)}.{camelCase(sub)}]"
 
-    return f'{to_func_namespace(function_name)}.{camelCase(arg)}'
+    return f"{to_func_namespace(function_name)}.{camelCase(arg)}"
 
 
-def get_type_and_def(type_spec: PropertyType) -> Tuple[str, str]:
+def get_type_and_def(
+    type_spec: PropertyType, title_fallback: str = ""
+) -> Tuple[str, str]:
+    """ returns type and type definition for a given PropertyType
+    """
     if type_spec["kind"] == "plain":
         value = type_spec["value"]
         if value.endswith("[]"):
@@ -111,18 +122,27 @@ def get_type_and_def(type_spec: PropertyType) -> Tuple[str, str]:
     elif type_spec["kind"] == "object":
         if type_spec.get("schema"):
             schema = type_spec["schema"]
-            title = schema.get("title", "")
-            if title:
+            title = schema.get("title", schema.get("name", title_fallback))
+            if title and schema.get("type") == "array":
+                # TODO fix me
+                # we don't use ReturnType as name for the list type here, we use _ReturnTypeItem
+                return "List", ""
+            elif title:
                 assert isinstance(title, str)
                 return wrapped_generate_schema_types(schema, title, "Dict")  # type: ignore
-
+            elif schema.get("allOf") and len(schema["allOf"]):
+                # we are in a case of a single allOf, lets strip off the allOf and move on!
+                # our library doesn't handle allOf well yet
+                allOf = schema["allOf"][0]
+                title = allOf.get("title", allOf.get("name", title_fallback))
+                return wrapped_generate_schema_types(allOf, title, "Dict")
             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
+                title = items.get("title")  # type: ignore
                 if not title:
                     # title is actually a reference to another schema
-                    title = items.get("$ref", "")  # type: ignore
+                    title = items.get("$ref", title_fallback)  # type: ignore
 
                 title = title.rsplit("/", 1)[-1]
                 if not title:
@@ -144,12 +164,18 @@ def get_type_and_def(type_spec: PropertyType) -> Tuple[str, str]:
                 return_type = "Any"
 
             for argument in type_spec["spec"]["arguments"]:
+                # do NOT add this fallback here
+                # callable arguments don't understand the imports yet
+                # if it's not a basic type here, we'll just do Any
+                # _maybe_add_fallback_schema_name(argument)
                 arg_type, arg_def = get_type_and_def(argument["type"])
                 arg_types.append(arg_type)
                 if arg_def:
                     arg_defs.append(arg_def)
 
-            final_arg_type = "Callable[[{}], {}]".format(", ".join(arg_types), return_type)
+            final_arg_type = "Callable[[{}], {}]".format(
+                ", ".join(arg_types), return_type
+            )
             return final_arg_type, "\n".join(arg_defs)
         else:
             return "Callable", ""
@@ -159,15 +185,30 @@ def get_type_and_def(type_spec: PropertyType) -> Tuple[str, str]:
         return "Any", ""
 
 
-def parse_arguments(function_name: str, arguments: List[PropertySpecification]) -> Tuple[str, str]:
+def _maybe_add_fallback_schema_name(a: PropertySpecification):
+    if a["type"]["kind"] == "object" and a["type"].get("schema"):
+        schema = a["type"].get("schema", {})
+        if not schema.get("title") and not schema.get("name") and a["name"]:
+            schema["title"] = a["name"].title()
+
+
+def parse_arguments(
+    function_name: str, arguments: List[PropertySpecification]
+) -> Tuple[str, str]:
     args_def = []
     arg_string = ""
     for idx, a in enumerate(arguments):
+        _maybe_add_fallback_schema_name(a)
         arg_type, arg_def = get_type_and_def(a["type"])
         if arg_def:
             args_def.append(arg_def)
         a["name"] = rewrite_arg_name(a["name"])
-        arg_string += f"    {a['name']}: {add_type_import_path(function_name, arg_type)}"
+        arg_string += (
+            f"    {a['name']}: {add_type_import_path(function_name, arg_type)}"
+        )
+        if not a["required"]:
+            arg_string += " = None"
+
         description = a.get("description", "")
         description = description.replace("\n", " ")
         if description:
@@ -193,7 +234,7 @@ RESERVED_WORDS = {"List", "Dict", "Any", "Optional", "Callable"} | set(keyword.k
 
 
 def to_func_namespace(s: str) -> str:
-    """ convert a function name to some function namespace
+    """convert a function name to some function namespace
     by default it is
     """
     rv = s[0].upper() + s[1:]
@@ -212,6 +253,10 @@ def rewrite_arg_name(s: str):
     return rewrite_reserved(camelCase(s))
 
 
+# def get_return_type_name(function_name: str) -> str:
+#     return function_name[0].upper() + function_name[1:] + "ReturnType"
+
+
 valid_subdomains = ["na[1-2]", "eu[1-2]", "dev"]
 
 
@@ -229,3 +274,21 @@ def is_valid_uuid(uuid_string, version=4):
         return False
 
     return str(uuid_obj) == uuid_string
+
+
+def return_type_already_defined_in_args(return_type_name: str, args_def: str) -> bool:
+    """
+    Checks if the return_type_name preceded optionally by 'class ' and followed by ' =' exists in args_def.
+
+    Args:
+        return_type_name (str): The name of the return type to check.
+        args_def (str): The string containing argument definitions.
+
+    Returns:
+        bool: True if the pattern exists, False otherwise.
+    """
+    basic_pattern = rf"^{re.escape(return_type_name)}\s="
+    basic_match = bool(re.search(basic_pattern, args_def, re.MULTILINE))
+    class_pattern = rf"^class {re.escape(return_type_name)}\(TypedDict"
+    class_match = bool(re.search(class_pattern, args_def, re.MULTILINE))
+    return basic_match or class_match

{polyapi_python-0.3.2.dev2.dist-info → polyapi_python-0.3.3.dev9.dist-info}/METADATA

@@ -1,11 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.2.dev2
+Version: 0.3.3.dev9
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
         
-        Copyright (c) 2023 PolyAPI Inc.
+        Copyright (c) 2025 PolyAPI Inc.
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -28,14 +28,15 @@ Project-URL: Homepage, https://github.com/polyapi/polyapi-python
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests==2.31.0
-Requires-Dist: typing_extensions>=4.10.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: typing_extensions>=4.12.2
 Requires-Dist: jsonschema-gentypes==2.6.0
 Requires-Dist: pydantic==2.6.4
 Requires-Dist: stdlib_list==0.10.0
 Requires-Dist: colorama==0.4.4
 Requires-Dist: python-socketio[asyncio_client]==5.11.1
 Requires-Dist: truststore==0.8.0
+Dynamic: license-file
 
 # PolyAPI Python Library
 
@@ -182,6 +183,26 @@ To run this library's unit tests, please clone the repo then run:
 python -m unittest discover
 ```
 
+## Linting
+
+The flake8 config is at the root of this repo at `.flake8`.
+
+When hacking on this library, please enable flake8 and add this line to your flake8 args (e.g., in your VSCode Workspace Settings):
+
+```
+--config=.flake8
+```
+
+## Mypy Type Improvements
+
+This script is handy for checking for any mypy types:
+
+```bash
+./check_mypy.sh
+```
+
+Please ignore \[name-defined\] errors for now. This is a known bug we are working to fix!
+
 ## Support
 
 If you run into any issues or want help getting started with this project, please contact support@polyapi.io

polyapi_python-0.3.3.dev9.dist-info/RECORD

@@ -0,0 +1,31 @@
+polyapi/__init__.py,sha256=a1Poy1kaTncYnUg6nWRcTjVm-R1CUQk12UX7VYQ9d5k,616
+polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
+polyapi/api.py,sha256=f1037HFJF7DtQSSypM4PE5AmmxWxjd0JiW6ARZqrgac,1879
+polyapi/auth.py,sha256=zrIGatjba5GwUTNjKj1GHQWTEDP9B-HrSzCKbLFoqvc,5336
+polyapi/cli.py,sha256=AKsWVHZPKGnypOdnzIpoZOsTuwcAuDGQajXhLe9OQKI,8239
+polyapi/client.py,sha256=CoFDYvyKsqL4wPQbUDIr0Qb8Q5eD92xN4OEEcJEVuGQ,1296
+polyapi/config.py,sha256=Vgc_q9FYXWGCOTr13EbpD0AwHks0Nflimy1NtZxgynA,3088
+polyapi/constants.py,sha256=sc-FnS0SngBLvSu1ZWMs0UCf9EYD1u1Yhfr-sZXGLns,607
+polyapi/deployables.py,sha256=WVcNNB6W5ZW_-ukf_kK3moRcnwIkC-O4te6vLepjcco,11936
+polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
+polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
+polyapi/execute.py,sha256=T9lXtiOz-JZTJgBKvJptA5_mz31qvYa6-O4NzM52mq4,2118
+polyapi/function_cli.py,sha256=htgmcx_dPmw4_5NKRgIivcwS7D8bkOsxCTOrJhzV3pU,3989
+polyapi/generate.py,sha256=IIbU4Kc8Ut-N3cPI1qzgV3M4r_GHi39dgU0ngpUY86Q,10473
+polyapi/parser.py,sha256=mdoh4pNq8pyiHE0-i6Coqj8frEXfBLRk6itpAXMrrgI,20373
+polyapi/poly_schemas.py,sha256=KFVmpB047pWQaTkiCJ3A9sUTNplTS8JETon1Sm2lnQs,2969
+polyapi/prepare.py,sha256=Q8CWV4kmZ2dbXYVsud34AgJkj5ymcQ_IcYhLuikc9yk,6659
+polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polyapi/rendered_spec.py,sha256=uaNzBhP4cX7iGfKwzZv0dxMagWzsGeDr0cQYx_AyIhQ,2153
+polyapi/schema.py,sha256=ZSzeUjpqigLvE4tFKB7y4AaZG-W5N5Z9wMH-F-vjMBU,4616
+polyapi/server.py,sha256=YXWxhYBx-hluwDQ8Jvfpy2s8ogz0GsNTMcZVNcP5ca8,2147
+polyapi/sync.py,sha256=PGdC0feBBjEVrF3d9EluW_OAxbWuzSrfh84czma8kWg,6476
+polyapi/typedefs.py,sha256=KniVl7vwcDOhgAJmHSgTJKkP0rKWvSLIPOGsWuf9jRU,2239
+polyapi/utils.py,sha256=K6QMKEf2fgmh3AswyNBADfv53sIOSAbXmGx2MaW5vy8,10261
+polyapi/variables.py,sha256=d36-trnfTL_8m2NkorMiImb4O3UrJbiFV38CHxV5i0A,4200
+polyapi/webhook.py,sha256=LWv28c2MLz_OKBI_Nn7WR4C-gs1SWgbdXsoxIIf-9UI,4886
+polyapi_python-0.3.3.dev9.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
+polyapi_python-0.3.3.dev9.dist-info/METADATA,sha256=fd2KtyjZKHie7x1Ua2p-QshQIE4Rc8gb5CMczxqGqgg,5782
+polyapi_python-0.3.3.dev9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+polyapi_python-0.3.3.dev9.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
+polyapi_python-0.3.3.dev9.dist-info/RECORD,,

{polyapi_python-0.3.2.dev2.dist-info → polyapi_python-0.3.3.dev9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{polyapi_python-0.3.2.dev2.dist-info → polyapi_python-0.3.3.dev9.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 PolyAPI Inc.
+Copyright (c) 2025 PolyAPI Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

polyapi_python-0.3.2.dev2.dist-info/RECORD

@@ -1,30 +0,0 @@
-polyapi/__init__.py,sha256=a1Poy1kaTncYnUg6nWRcTjVm-R1CUQk12UX7VYQ9d5k,616
-polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
-polyapi/api.py,sha256=e-8nOzq6SXD7_YPVBlW82_9wVxDCc8XD9ioMv_QvnH0,1877
-polyapi/auth.py,sha256=zrIGatjba5GwUTNjKj1GHQWTEDP9B-HrSzCKbLFoqvc,5336
-polyapi/cli.py,sha256=w0SOiRHR7gJRoEwkfyGC1sdBT76sgx8MUcF8_GnGuJU,8324
-polyapi/client.py,sha256=CoFDYvyKsqL4wPQbUDIr0Qb8Q5eD92xN4OEEcJEVuGQ,1296
-polyapi/config.py,sha256=uvEvOfWYZTLmBmZX-5jJxCzWPpwzVmEOIiQIdi98P4Y,3015
-polyapi/constants.py,sha256=sc-FnS0SngBLvSu1ZWMs0UCf9EYD1u1Yhfr-sZXGLns,607
-polyapi/deployables.py,sha256=qKoyuPUv46yZoLBvSOmk6JsBWqomwJAkadhItp8Lx40,11956
-polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
-polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
-polyapi/execute.py,sha256=kXnvlNQ7nz9cRlV2_5gXH09UCmyiDP5zi3wiAw0uDuk,1943
-polyapi/function_cli.py,sha256=-Fjv_DECZB5LK8rT222B62GPw4vksAi7KsIqT-ss5FM,4185
-polyapi/generate.py,sha256=SIRfN7RF3Z7eQ8kSNg4H70LeT7Hmh-Mn5maibvM7kAM,7969
-polyapi/parser.py,sha256=noi3Tjf1vVNm5gjTzgvOlJ6IMaoZ9DheklibVWfPPhk,20311
-polyapi/prepare.py,sha256=Q8CWV4kmZ2dbXYVsud34AgJkj5ymcQ_IcYhLuikc9yk,6659
-polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polyapi/rendered_spec.py,sha256=uaNzBhP4cX7iGfKwzZv0dxMagWzsGeDr0cQYx_AyIhQ,2153
-polyapi/schema.py,sha256=VVMHAT5yU47cRC7xF44BrmUSemlk5oIKSxH2HTVPaQ8,3169
-polyapi/server.py,sha256=NzQCZFSAJK7XiRw1kiU_i9uMvgYK7i8qh7UX2xjytJU,1908
-polyapi/sync.py,sha256=PGdC0feBBjEVrF3d9EluW_OAxbWuzSrfh84czma8kWg,6476
-polyapi/typedefs.py,sha256=U0i30Y9CgoUBWeMUbpM28S8eVOEU9NfdckK1VAop3A0,1994
-polyapi/utils.py,sha256=jzCh-ivKMcgp5fIXynhYmP9UyzsISr9bGGEzdPP8n3w,7644
-polyapi/variables.py,sha256=d36-trnfTL_8m2NkorMiImb4O3UrJbiFV38CHxV5i0A,4200
-polyapi/webhook.py,sha256=LWv28c2MLz_OKBI_Nn7WR4C-gs1SWgbdXsoxIIf-9UI,4886
-polyapi_python-0.3.2.dev2.dist-info/LICENSE,sha256=Hi0kDr56Dsy0uYIwNt4r9G7tI8x8miXRTlyvbeplCP8,1068
-polyapi_python-0.3.2.dev2.dist-info/METADATA,sha256=YKwIhWvsJJ3qnsGIa1LqH7fu86jCs2a9pA5lrBtzfF8,5326
-polyapi_python-0.3.2.dev2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-polyapi_python-0.3.2.dev2.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
-polyapi_python-0.3.2.dev2.dist-info/RECORD,,