polyapi · nahuel-polyapi · Feb 19, 2026 · Oct 31, 2024 · Nov 4, 2024 · Nov 4, 2024
diff --git a/.flake8 b/.flake8
@@ -1,4 +1,4 @@
 [flake8]
-ignore = E203,E303,E402,E501,E722,W391,F401,W292,F811,E302
+ignore = E203,E303,E402,E501,E722,W391,F401,W292,F811,E302,W291,W293
 max-line-length = 150
 max-complexity = 22
diff --git a/README.md b/README.md
@@ -145,6 +145,14 @@ This script is handy for checking for any mypy types:
 
 Please ignore \[name-defined\] errors for now. This is a known bug we are working to fix!
 
+## Strategies for QA'ing Changes To Generate Or Other Core Functionality
+
+Our https://na1.polyapi.io has a large OOB catalog (as does eu1/na2). We also have several big internal PolyAPI projects with Python (message @eupharis if you need a pointer to which ones).
+
+Running `python -m polyapi generate` in all these projects and then checking the flake8 and check_mypy steps above is a great way to build confidence that the `generate` changes has no gotchas.
+
+Of course all this is in addition to the changes passing through normal unittests and integration tests!
+
 ## Support
 
 If you run into any issues or want help getting started with this project, please contact [email protected]

diff --git a/polyapi/deployables.py b/polyapi/deployables.py
@@ -6,6 +6,7 @@
 import hashlib
 from pathlib import Path
 from typing import TypedDict, List, Dict, Tuple, Optional, Any, Union
+from typing_extensions import Required
 from subprocess import check_output, CalledProcessError
 
 
@@ -54,7 +55,7 @@ class DeployableRecord(ParsedDeployableConfig, total=False):
     gitRevision: str
     fileRevision: str
     file: str
-    types: DeployableFunctionTypes
+    types: Required[DeployableFunctionTypes]
     typeSchemas: Dict[str, Any]
     dependencies: List[str]
     deployments: List[Deployment]

diff --git a/polyapi/parser.py b/polyapi/parser.py
@@ -3,7 +3,7 @@
 import types
 import sys
 import re
-from typing import Dict, List, Mapping, Optional, Tuple, Any
+from typing import Dict, List, Mapping, Optional, Tuple, Any, Union
 from typing import _TypedDictMeta as BaseTypedDict  # type: ignore
 from typing_extensions import _TypedDictMeta, cast # type: ignore
 from stdlib_list import stdlib_list
@@ -390,7 +390,7 @@ def visit_AnnAssign(self, node):
                 deployable["config"] = _parse_dict(node.value)
                 self._name = deployable["config"]["name"]
 
-        def _extract_docstring_from_function(self, node: ast.FunctionDef):
+        def _extract_docstring_from_function(self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]):
             start_lineno = (node.body[0].lineno if node.body else node.lineno) - 1
             start_offset = self._line_offsets[start_lineno]
             end_offset = start_offset
@@ -452,15 +452,19 @@ def visit_Import(self, node: ast.Import):
             for name in node.names:
                 req = _get_req_name_if_not_in_base(name.name, pip_name_lookup)
                 if req:
+                    if "dependencies" not in deployable or deployable["dependencies"] is None:
+                        deployable["dependencies"] = []
                     deployable["dependencies"].append(req)
 
         def visit_ImportFrom(self, node: ast.ImportFrom):
             if node.module:
                 req = _get_req_name_if_not_in_base(node.module, pip_name_lookup)
                 if req:
+                    if "dependencies" not in deployable or deployable["dependencies"] is None:
+                        deployable["dependencies"] = []
                     deployable["dependencies"].append(req)
 
-        def visit_FunctionDef(self, node: ast.FunctionDef):
+        def _handle_function_def(self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]):
             if node.name == self._name:
                 # Parse docstring which may contain param types and descriptions
                 self._extract_docstring_from_function(node)
@@ -506,6 +510,12 @@ def visit_FunctionDef(self, node: ast.FunctionDef):
                 else:
                     deployable["types"]["returns"]["type"] = "Any"
 
+        def visit_FunctionDef(self, node: ast.FunctionDef):
+            self._handle_function_def(node)
+
+        def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+            self._handle_function_def(node)
+
         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

diff --git a/polyapi/poly_tables.py b/polyapi/poly_tables.py
@@ -1,27 +1,64 @@
 import os
 import requests
 from typing_extensions import NotRequired, TypedDict
-from typing import List, Union, Type, Dict, Any, Literal, Tuple, Optional, get_args, get_origin
+from typing import (
+    List,
+    Union,
+    Type,
+    Dict,
+    Any,
+    Literal,
+    Tuple,
+    Optional,
+    get_args,
+    get_origin,
+)
 from polyapi.utils import add_import_to_init, init_the_init
 from polyapi.typedefs import TableSpecDto
 from polyapi.constants import JSONSCHEMA_TO_PYTHON_TYPE_MAP
+from polyapi.config import get_api_key_and_url
 
-def scrub(data) -> Dict[str, Any]:
-    if (not data or not isinstance(data, (Dict, List))): return data
+TABI_MODULE_IMPORTS = "\n".join(
+    [
+        "from typing_extensions import NotRequired, TypedDict",
+        "from typing import Union, List, Dict, Any, Literal, Optional, Required, overload",
+        "from polyapi.poly_tables import execute_query, first_result, transform_query, delete_one_response",
+        "from polyapi.typedefs import Table, PolyCountResult, PolyDeleteResult, PolyDeleteResults, SortOrder, StringFilter, NullableStringFilter, NumberFilter, NullableNumberFilter, BooleanFilter, NullableBooleanFilter, NullableObjectFilter",
+    ]
+)
+
+
+def scrub(data: Any) -> Any:
+    if not data or not isinstance(data, (Dict, List)):
+        return data
     if isinstance(data, List):
         return [scrub(item) for item in data]
     else:
         temp = {}
-        secrets = ["x_api_key", "x-api-key", "access_token", "access-token", "authorization", "api_key", "api-key", "apikey", "accesstoken", "token", "password", "key"]
+        secrets = [
+            "x_api_key",
+            "x-api-key",
+            "access_token",
+            "access-token",
+            "authorization",
+            "api_key",
+            "api-key",
+            "apikey",
+            "accesstoken",
+            "token",
+            "password",
+            "key",
+        ]
         for key, value in data.items():
             if isinstance(value, (Dict, List)):
                 temp[key] = scrub(data[key])
             elif key.lower() in secrets:
-                temp[key] = '********'
+                temp[key] = "********"
             else:
                 temp[key] = data[key]
         return temp
 
+
 def scrub_keys(e: Exception) -> Dict[str, Any]:
     """
     Scrub the keys of an exception to remove sensitive information.
@@ -31,18 +68,26 @@ def scrub_keys(e: Exception) -> Dict[str, Any]:
         "error": str(e),
         "type": type(e).__name__,
         "message": str(e),
-        "args": scrub(getattr(e, 'args', None))
+        "args": scrub(getattr(e, "args", None)),
     }
 
 
 def execute_query(table_id, method, query):
     from polyapi import polyCustom
     from polyapi.poly.client_id import client_id
+
     try:
-        url = f"/tables/{table_id}/{method}?clientId={client_id}"
-        headers = {{
-            'x-poly-execution-id': polyCustom.get('executionId')
-        }}
+        api_key, base_url = get_api_key_and_url()
+        if not base_url:
+            raise ValueError(
+                "PolyAPI Instance URL is not configured, run `python -m polyapi setup`."
+            )
+
+        auth_key = polyCustom.get("executionApiKey") or api_key
+        url = f"{base_url.rstrip('/')}/tables/{table_id}/{method}?clientId={client_id}"
+        headers = {"x-poly-execution-id": polyCustom.get("executionId")}
+        if auth_key:
+            headers["Authorization"] = f"Bearer {auth_key}"
         response = requests.post(url, json=query, headers=headers)
         response.raise_for_status()
         return response.json()
@@ -51,14 +96,16 @@ def execute_query(table_id, method, query):
 
 
 def first_result(rsp):
-    if isinstance(rsp, dict) and isinstance(rsp.get('results'), list):
-        return rsp['results'][0] if rsp['results'] else None
+    if isinstance(rsp, dict) and isinstance(rsp.get("results"), list):
+        return rsp["results"][0] if rsp["results"] else None
     return rsp
 
+
 def delete_one_response(rsp):
-    if isinstance(rsp, dict) and isinstance(rsp.get('deleted'), int):
-        return { 'deleted': bool(rsp.get('deleted')) }
-    return { 'deleted': false }
+    if isinstance(rsp, dict) and isinstance(rsp.get("deleted"), int):
+        return {"deleted": bool(rsp.get("deleted"))}
+    return {"deleted": False}
+
 
 _key_transform_map = {
     "not_": "not",
@@ -72,8 +119,7 @@ def delete_one_response(rsp):
 def _transform_keys(obj: Any) -> Any:
     if isinstance(obj, dict):
         return {
-            _key_transform_map.get(k, k): _transform_keys(v)
-            for k, v in obj.items()
+            _key_transform_map.get(k, k): _transform_keys(v) for k, v in obj.items()
         }
 
     elif isinstance(obj, list):
@@ -88,13 +134,13 @@ def transform_query(query: dict) -> dict:
         return {
             **query,
             "where": _transform_keys(query["where"]) if query["where"] else None,
-            "orderBy": query["order_by"] if query["order_by"] else None
+            "orderBy": query["order_by"] if query["order_by"] else None,
         }
 
     return query
 
 
-TABI_TABLE_TEMPLATE = '''
+TABI_TABLE_TEMPLATE = """
 {table_name}Columns = Literal[{table_columns}]
 
 
@@ -369,19 +415,25 @@ def delete_one(*args, **kwargs) -> PolyDeleteResult:
             query["where"]["id"] = kwargs["id"]
             query.pop("id", None)
         return delete_one_response(execute_query({table_name}.table_id, "delete", transform_query(query)))
-'''
+"""
 
 
 def _get_column_type_str(name: str, schema: Dict[str, Any], is_required: bool) -> str:
     result = ""
 
     col_type = schema.get("type", "object")
     if isinstance(col_type, list):
-        subtypes = [_get_column_type_str(name, { **schema, "type": t }, is_required) for t in col_type]
+        subtypes = [
+            _get_column_type_str(name, {**schema, "type": t}, is_required)
+            for t in col_type
+        ]
         result = f"Union[{', '.join(subtypes)}]"
     elif col_type == "array":
         if isinstance(schema["items"], list):
-            subtypes = [_get_column_type_str(f"{name}{i}", s, True) for i, s in enumerate(schema["items"])]
+            subtypes = [
+                _get_column_type_str(f"{name}{i}", s, True)
+                for i, s in enumerate(schema["items"])
+            ]
             result = f"Tuple[{', '.join(subtypes)}]"
         elif isinstance(schema["items"], dict):
             result = f"List[{_get_column_type_str(name, schema['items'], True)}]"
@@ -391,7 +443,10 @@ def _get_column_type_str(name: str, schema: Dict[str, Any], is_required: bool) -
         if isinstance(schema.get("patternProperties"), dict):
             # TODO: Handle multiple pattern properties
             result = f"Dict[str, {_get_column_type_str(f'{name}_', schema['patternProperties'], True)}]"
-        elif isinstance(schema.get("properties"), dict) and len(schema["properties"].values()) > 0:
+        elif (
+            isinstance(schema.get("properties"), dict)
+            and len(schema["properties"].values()) > 0
+        ):
             # TODO: Handle x-poly-refs
             result = f'"{name}"'
         else:
@@ -413,24 +468,32 @@ def _render_table_row_classes(table_name: str, schema: Dict[str, Any]) -> str:
     return output[1].split("\n", 1)[1].strip()
 
 
-def _render_table_subset_class(table_name: str, columns: List[Tuple[str, Dict[str, Any]]], required: List[str]) -> str:
+def _render_table_subset_class(
+    table_name: str, columns: List[Tuple[str, Dict[str, Any]]], required: List[str]
+) -> str:
     # Generate class which can match any subset of a table row
     lines = [f"class {table_name}Subset(TypedDict):"]
 
     for name, schema in columns:
-        type_str = _get_column_type_str(f"_{table_name}Row{name}", schema, name in required)
+        type_str = _get_column_type_str(
+            f"_{table_name}Row{name}", schema, name in required
+        )
         lines.append(f"    {name}: NotRequired[{type_str}]")
 
     return "\n".join(lines)
 
 
-def _render_table_where_class(table_name: str, columns: List[Tuple[str, Dict[str, Any]]], required: List[str]) -> str:
+def _render_table_where_class(
+    table_name: str, columns: List[Tuple[str, Dict[str, Any]]], required: List[str]
+) -> str:
     # Generate class for the 'where' part of the query
     lines = [f"class {table_name}WhereFilter(TypedDict):"]
 
     for name, schema in columns:
         ftype_str = ""
-        type_str = _get_column_type_str(f"_{table_name}Row{name}", schema, True) # force required to avoid wrapping type in Optional[]
+        type_str = _get_column_type_str(
+            f"_{table_name}Row{name}", schema, True
+        )  # force required to avoid wrapping type in Optional[]
         is_required = name in required
         if type_str == "bool":
             ftype_str = "BooleanFilter" if is_required else "NullableBooleanFilter"
@@ -445,24 +508,34 @@ def _render_table_where_class(table_name: str, columns: List[Tuple[str, Dict[str
         if ftype_str:
             lines.append(f"    {name}: NotRequired[Union[{type_str}, {ftype_str}]]")
 
-    lines.append(f'    AND: NotRequired[Union["{table_name}WhereFilter", List["{table_name}WhereFilter"]]]')
+    lines.append(
+        f'    AND: NotRequired[Union["{table_name}WhereFilter", List["{table_name}WhereFilter"]]]'
+    )
     lines.append(f'    OR: NotRequired[List["{table_name}WhereFilter"]]')
-    lines.append(f'    NOT: NotRequired[Union["{table_name}WhereFilter", List["{table_name}WhereFilter"]]]')
+    lines.append(
+        f'    NOT: NotRequired[Union["{table_name}WhereFilter", List["{table_name}WhereFilter"]]]'
+    )
 
     return "\n".join(lines)
 
 
 def _render_table(table: TableSpecDto) -> str:
     columns = list(table["schema"]["properties"].items())
-    required_colunms = table["schema"].get("required", [])
+    required_columns = table["schema"].get("required", [])
 
-    table_columns = ",".join([ f'"{k}"' for k,_ in columns])
+    table_columns = ",".join([f'"{k}"' for k, _ in columns])
     table_row_classes = _render_table_row_classes(table["name"], table["schema"])
-    table_row_subset_class = _render_table_subset_class(table["name"], columns, required_colunms)
-    table_where_class = _render_table_where_class(table["name"], columns, required_colunms)
+    table_row_subset_class = _render_table_subset_class(
+        table["name"], columns, required_columns
+    )
+    table_where_class = _render_table_where_class(
+        table["name"], columns, required_columns
+    )
     if table.get("description", ""):
-        table_description =  '\n    """'
-        table_description += '\n       '.join(table["description"].replace('"', "'").split("\n"))
+        table_description = '\n    """'
+        table_description += "\n       ".join(
+            table["description"].replace('"', "'").split("\n")
+        )
         table_description += '\n    """'
     else:
         table_description = ""
@@ -502,12 +575,7 @@ def _create_table(table: TableSpecDto) -> None:
 
     init_path = os.path.join(full_path, "__init__.py")
 
-    imports = "\n".join([
-        "from typing_extensions import NotRequired, TypedDict",
-        "from typing import Union, List, Dict, Any, Literal, Optional, Required, overload",
-        "from polyapi.poly_tables import execute_query, first_result, transform_query",
-        "from polyapi.typedefs import Table, PolyCountResult, PolyDeleteResults, SortOrder, StringFilter, NullableStringFilter, NumberFilter, NullableNumberFilter, BooleanFilter, NullableBooleanFilter, NullableObjectFilter",
-    ])
+    imports = TABI_MODULE_IMPORTS
     table_contents = _render_table(table)
 
     file_contents = ""