polyapi-python 0.3.20.dev3__tar.gz → 0.3.21__tar.gz

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev3
+Version: 0.3.21
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -28,15 +28,23 @@ 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.32.3
+Requires-Dist: requests==2.33.0
 Requires-Dist: typing_extensions==4.15.0
 Requires-Dist: jsonschema-gentypes==2.13.0
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: stdlib_list==0.11.1
 Requires-Dist: colorama==0.4.4
-Requires-Dist: python-socketio[asyncio_client]==5.11.1
+Requires-Dist: python-socketio[asyncio_client]==5.16.2
 Requires-Dist: truststore==0.9.1
 Requires-Dist: httpx==0.28.1
+Provides-Extra: dev
+Requires-Dist: mock==5.2.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: flask==3.1.3; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: types-colorama; extra == "dev"
+Requires-Dist: pip-audit; extra == "dev"
 Dynamic: license-file
 
 # PolyAPI Python Library
@@ -98,10 +106,17 @@ client per event loop. New clients read these optional environment variables:
 | `POLY_HTTP_READ_TIMEOUT` | `none` | Read timeout in seconds |
 | `POLY_HTTP_WRITE_TIMEOUT` | `none` | Write timeout in seconds |
 | `POLY_HTTP_POOL_TIMEOUT` | `none` | Connection-pool timeout in seconds |
+| `POLY_HTTP_CLOSE_TIMEOUT` | `5` | Deadline in seconds for closing a client's pool |
 
 An empty value, `none`, or `null` means unbounded. Limits are per client, so
 processes with multiple event loops can create one configured pool per loop.
 
+`POLY_HTTP_CLOSE_TIMEOUT` is read at shutdown rather than at client creation.
+It bounds pool teardown so a single unresponsive socket cannot stall shutdown:
+if the deadline passes, the SDK logs a warning, abandons the remaining
+connections to the operating system, and retires the client so it is never
+reused. Set it to `none` to wait indefinitely.
+
 Call `polyapi.http_client.close()` during synchronous shutdown or await
 `polyapi.http_client.close_async()` on each owning event loop during
 asynchronous shutdown. The shutdown functions wait for active SDK requests

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/README.md

@@ -57,10 +57,17 @@ client per event loop. New clients read these optional environment variables:
 | `POLY_HTTP_READ_TIMEOUT` | `none` | Read timeout in seconds |
 | `POLY_HTTP_WRITE_TIMEOUT` | `none` | Write timeout in seconds |
 | `POLY_HTTP_POOL_TIMEOUT` | `none` | Connection-pool timeout in seconds |
+| `POLY_HTTP_CLOSE_TIMEOUT` | `5` | Deadline in seconds for closing a client's pool |
 
 An empty value, `none`, or `null` means unbounded. Limits are per client, so
 processes with multiple event loops can create one configured pool per loop.
 
+`POLY_HTTP_CLOSE_TIMEOUT` is read at shutdown rather than at client creation.
+It bounds pool teardown so a single unresponsive socket cannot stall shutdown:
+if the deadline passes, the SDK logs a warning, abandons the remaining
+connections to the operating system, and retires the client so it is never
+reused. Set it to `none` to wait indefinitely.
+
 Call `polyapi.http_client.close()` during synchronous shutdown or await
 `polyapi.http_client.close_async()` on each owning event loop during
 asynchronous shutdown. The shutdown functions wait for active SDK requests

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/ai_function.py

@@ -75,8 +75,7 @@ def render_ai_function(
 
 
 def _normalize_return_type_for_annotation(function_name: str, return_type_name: str) -> str:
-    if return_type_name == "ReturnType":
-        return "ReturnType"
+    # "ReturnType" lives in a separate module, so it must be qualified (e.g. _SFX.ReturnType).
     return add_type_import_path(function_name, return_type_name)
 
 

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/cli.py

@@ -9,7 +9,6 @@ from .cli_constants import CLI_COMMANDS
 from .config import initialize_config, set_api_key_and_url
 from .generate import generate, clear
 from .function_cli import function_add_or_update, function_execute
-from .rendered_spec import get_and_update_rendered_spec
 from .prepare import prepare_deployables
 from .sync import sync_deployables
 
@@ -196,22 +195,6 @@ def execute_from_cli():
     clear_parser.set_defaults(command=clear_command)
 
 
-    ###########################################################################
-    # Update rendered spec command
-    update_spec_parser = subparsers.add_parser("update_rendered_spec", help="Update the rendered spec file")
-    update_spec_parser.add_argument("spec", help="Specification file to update")
-
-    def update_rendered_spec(args):
-        updated = get_and_update_rendered_spec(args.spec)
-        if updated:
-            print("Updated rendered spec!")
-        else:
-            print("Failed to update rendered spec!")
-            exit(1)
-
-    update_spec_parser.set_defaults(command=update_rendered_spec)
-
-
     ###########################################################################
     # Prepare command
     prepare_parser = subparsers.add_parser('prepare', help="Find and prepare all Poly deployables")

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/cli_constants.py

@@ -4,7 +4,6 @@ CLI_COMMANDS = (
     "function",
     "clear",
     "help",
-    "update_rendered_spec",
     "prepare",
     "sync",
 )

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/deployables.py

@@ -51,7 +51,7 @@ class DeployableFunctionTypes(TypedDict):
     params: List[DeployableFunctionParam]
     returns: DeployableFunctionParamBase
 
-class DeployableRecord(ParsedDeployableConfig, total=False):
+class DeployableRecord(ParsedDeployableConfig):
     gitRevision: str
     fileRevision: str
     file: str
@@ -64,7 +64,7 @@ class DeployableRecord(ParsedDeployableConfig, total=False):
     docEndIndex: int
     dirty: Optional[bool]
 
-class SyncDeployment(TypedDict, total=False):
+class SyncDeployment(TypedDict):
     context: str
     name: str
     description: str
@@ -195,30 +195,12 @@ def write_cache_revision(git_revision: Optional[str] = None) -> None:
     with open(CACHE_VERSION_FILE, 'w', encoding='utf-8') as file:
         file.write(git_revision)
 
-def is_cache_up_to_date() -> bool:
-    if not Path(CACHE_VERSION_FILE).exists():
-        return False
-    with open(CACHE_VERSION_FILE, 'r', encoding='utf-8') as file:
-        cached_revision = file.read().strip()
-    git_revision = get_git_revision()
-    return cached_revision == git_revision
-
 def is_cache_up_to_date() -> bool:
     """Check if the cached revision matches the current Git revision."""
     cached_revision = get_cache_deployments_revision()
     git_revision = get_git_revision()  # This function needs to be defined or imported
     return cached_revision == git_revision
 
-def write_deploy_comments(deployments: List[Dict]) -> str:
-    """Generate a string of deployment comments for each deployment."""
-    canopy_path = 'polyui/collections' if 'localhost' in os.getenv('POLY_API_BASE_URL', '') else 'canopy/polyui/collections'
-    comments = []
-    for d in deployments:
-        instance_url = d['instance'].replace(':8000', ':3000') if d['instance'].endswith(':8000') else d['instance']
-        comment = f"# Poly deployed @ {d['deployed']} - {d['context']}.{d['name']} - {instance_url}/{canopy_path}/{d['type']}s/{d['id']} - {d['fileRevision']}"
-        comments.append(comment)
-    return '\n'.join(comments)
-
 def print_docstring_function_comment(description: str, args: list, returns: dict) -> str:
     docstring = f'"""{description}\n\n'
     if args:
@@ -243,7 +225,7 @@ def print_docstring_function_comment(description: str, args: list, returns: dict
     return docstring
 
 
-def update_deployment_comments(file_content: str, deployable: dict) -> str:
+def update_deployment_comments(file_content: str, deployable: DeployableRecord) -> str:
     """
     Remove old deployment comments based on the provided ranges and add new ones.
     """
@@ -255,7 +237,7 @@ def update_deployment_comments(file_content: str, deployable: dict) -> str:
         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:
+def update_deployable_function_comments(file_content: str, deployable: DeployableRecord, disable_docs: bool = False) -> str:
     """
     Update the docstring in the file content based on the deployable's documentation data.
     """
@@ -263,7 +245,7 @@ def update_deployable_function_comments(file_content: str, deployable: dict, dis
         docstring = print_docstring_function_comment(
             deployable['types']['description'],
             deployable['types']['params'],
-            deployable['types']['returns']
+            deployable['types']['returns'] # pyright: ignore[reportArgumentType]
         )
         if deployable["docStartIndex"] == deployable["docEndIndex"]:
             # Function doesn't yet have any docstrings so we need to add additional whitespace
@@ -272,7 +254,7 @@ def update_deployable_function_comments(file_content: str, deployable: dict, dis
         return f"{file_content[:deployable['docStartIndex']]}{docstring}{file_content[deployable['docEndIndex']:]}"
     return file_content
 
-def write_updated_deployable(deployable: dict, disable_docs: bool = False) -> dict:
+def write_updated_deployable(deployable: DeployableRecord, disable_docs: bool = False) -> DeployableRecord:
     """
     Read the deployable's file, update its comments and docstring, and write back to the file.
     """

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/error_handler.py

@@ -42,7 +42,8 @@ async def unregister_all():
     _, base_url = get_api_key_and_url()
     # need to reconnect because maybe socketio client disconnected after Ctrl+C?
     try:
-        await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
+        if client:
+            await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
     except ConnectionError:
         pass
     await asyncio.gather(*[unregister(handler) for handler in active_handlers])
@@ -63,10 +64,11 @@ async def on(
     data["apiKey"] = api_key
 
     def registerCallback(id: int):
-        nonlocal handler_id
-        handler_id = id
-        client.on(f"handleError:{handler_id}", callback, namespace="/events")
-        active_handlers.append({"path": path, "id": handler_id, "apiKey": api_key})
+        if client:
+            nonlocal handler_id
+            handler_id = id
+            client.on(f"handleError:{handler_id}", callback, namespace="/events")
+            active_handlers.append({"path": path, "id": handler_id, "apiKey": api_key})
 
     await client.emit("registerErrorHandler", data, "/events", registerCallback)
 

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/generate.py

@@ -7,7 +7,7 @@ import tempfile
 import stat
 
 from copy import deepcopy
-from typing import Any, List, Optional, Tuple, cast
+from typing import Any, Dict, List, Optional, Tuple, cast
 
 from .auth import render_auth_function
 from .client import render_client_function
@@ -104,7 +104,7 @@ def replace_poly_refs_in_functions(specs: List[SpecificationDto], schema_index):
             func = spec.get("function")
             if func:
                 try:
-                    spec["function"] = resolve_poly_refs(func, schema_index)
+                    spec["function"] = resolve_poly_refs(func, schema_index) # pyright: ignore[reportGeneralTypeIssues]
                 except Exception:
                     # print()
                     # print(f"{spec['context']}.{spec['name']} (id: {spec['id']}) failed to resolve poly refs, skipping!")
@@ -123,7 +123,7 @@ def replace_poly_refs_in_schemas(specs: List[SchemaSpecDto], schema_index):
     spec_idxs_to_remove = []
     for idx, spec in enumerate(specs):
         try:
-            spec["definition"] = resolve_poly_refs(spec["definition"], schema_index)
+            spec["definition"] = cast(Dict[str, Any], resolve_poly_refs(spec["definition"], schema_index))
         except Exception:
             # print()
             print(f"{spec['context']}.{spec['name']} (id: {spec['id']}) failed to resolve poly refs, skipping!")
@@ -445,16 +445,16 @@ def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
     arguments: List[PropertySpecification] = []
     return_type: Any = {}
     if spec.get("function"):
-        assert spec["function"]
+        function_spec = cast(Dict[str, Any], spec["function"]) # pyright: ignore[reportTypedDictNotRequiredAccess]
         # Handle cases where arguments might be missing or None
-        if spec["function"].get("arguments"):
+        if function_spec.get("arguments"):
             arguments = [
-                arg for arg in spec["function"]["arguments"]
+                arg for arg in function_spec["arguments"]
             ]
-        
+
         # Handle cases where returnType might be missing or None
-        if spec["function"].get("returnType"):
-            return_type = spec["function"]["returnType"]
+        if function_spec.get("returnType"):
+            return_type = function_spec["returnType"]
         else:
             # Provide a fallback return type when missing
             return_type = {"kind": "any"}

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/http_client.py

@@ -45,6 +45,12 @@ def _build_timeout() -> httpx.Timeout:
     )
 
 
+def _close_deadline() -> "float | None":
+    # Bound pool teardown so one wedged socket cannot hang invocation exit.
+    # None (POLY_HTTP_CLOSE_TIMEOUT=none) restores the old unbounded wait.
+    return _env_opt_float("POLY_HTTP_CLOSE_TIMEOUT", 5.0)
+
+
 # Import-time snapshot for reference/config surface. Clients re-read env at creation
 DEFAULT_LIMITS = _build_limits()
 DEFAULT_TIMEOUT = _build_timeout()
@@ -166,6 +172,40 @@ def _sweep_dead_loops() -> None:
             _retire_async_client(_async_clients.pop(loop, None), loop)
 
 
+def _abandon_close_task(
+    close_task: "asyncio.Future[None]",
+    client: httpx.AsyncClient,
+    loop: asyncio.AbstractEventLoop,
+    deadline: "float | None",
+    context: str = "",
+) -> None:
+    """Detach a pool close that blew its deadline.
+
+    The task is cancelled and dropped rather than awaited: waiting for an
+    unresponsive pool to unwind is the stall the deadline exists to prevent.
+    Cancelling is what keeps loop shutdown bounded too, since asyncio.run()
+    tears down by cancelling every task and gathering them; a cancelled close
+    completes there instead of blocking. Whatever stays open is released when
+    the coroutine is collected, and by the OS at exit.
+    """
+    def _swallow(finished: "asyncio.Future[None]") -> None:
+        # Retrieve the result so a late failure is not reported as an
+        # unretrieved task exception.
+        if finished.cancelled():
+            return
+        error = finished.exception()
+        if error is not None:
+            logger.debug(
+                f"Abandoned aclose later failed with {error!r} id={id(client)} "
+                f"pid={os.getpid()} loop={id(loop)}")
+
+    close_task.add_done_callback(_swallow)
+    close_task.cancel()
+    logger.warning(
+        f"aclose exceeded {deadline}s deadline; abandoning pool "
+        f"id={id(client)} pid={os.getpid()} loop={id(loop)}{context}")
+
+
 def _register_loop_close_hook(loop: asyncio.AbstractEventLoop) -> None:
     """aclose the loop's async client right before the loop is torn down.
     """
@@ -177,8 +217,21 @@ def _register_loop_close_hook(loop: asyncio.AbstractEventLoop) -> None:
         _hooked_loops.discard(loop)
         cached = _async_clients.pop(loop, None)
         if cached is not None and not loop.is_closed():
+            deadline = _close_deadline()
             try:
-                loop.run_until_complete(cached.aclose())
+                # asyncio.wait returns at the deadline without cancelling, so
+                # loop.close() proceeds even if the pool ignores cancellation.
+                close_task = loop.create_task(cached.aclose())
+                loop.run_until_complete(
+                    asyncio.wait({close_task}, timeout=deadline))
+                if close_task.done():
+                    # Surface real aclose failures, including a TimeoutError
+                    # raised by aclose itself, rather than treating them as
+                    # our deadline.
+                    close_task.result()
+                else:
+                    _abandon_close_task(
+                        close_task, cached, loop, deadline, " on teardown")
             except Exception:
                 logger.warning(
                     f"Failed to aclose async client id={id(cached)} pid={os.getpid()} "
@@ -267,8 +320,19 @@ async def _close_clients_for_loop(
             return
 
         await _drain_inflight(client)
+        deadline = _close_deadline()
+        close_task = asyncio.ensure_future(client.aclose())
         try:
-            await client.aclose()
+            # asyncio.wait returns at the deadline without cancelling the
+            # close, so the bound holds even when the pool never processes
+            # cancellation. wait_for would block on that unwind instead.
+            await asyncio.wait({close_task}, timeout=deadline)
+            if close_task.done():
+                # Real aclose errors, including a TimeoutError raised by aclose
+                # itself, still propagate to the close_async caller.
+                close_task.result()
+            else:
+                _abandon_close_task(close_task, client, current_loop, deadline)
         finally:
             if _async_clients.get(current_loop) is client:
                 _async_clients.pop(current_loop, None)

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/parser.py

@@ -5,13 +5,18 @@ import sys
 import re
 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 typing_extensions import TypedDict, _TypedDictMeta, cast # type: ignore
 from stdlib_list import stdlib_list
 from pydantic import TypeAdapter
 from importlib.metadata import packages_distributions
 from polyapi.constants import PYTHON_TO_JSONSCHEMA_TYPE_MAP
 from polyapi.utils import print_red
-from polyapi.deployables import Deployment, DeployableRecord, get_deployable_file_revision
+from polyapi.deployables import (
+    Deployment,
+    DeployableRecord,
+    DeployableTypes,
+    get_deployable_file_revision,
+)
 
 
 # these libraries are already installed in the base docker image
@@ -116,15 +121,53 @@ def _parse_sphinx_docstring(docstring: str) -> Dict[str, Any]:
     }
 
 
-def _parse_google_docstring(docstring: str) -> Dict[str, Any]:
+class _GoogleParamState(TypedDict):
+    name: str
+    type: str
+    description: List[str]
+
+
+class _GoogleReturnsState(TypedDict):
+    type: str
+    description: List[str]
+
+
+class GoogleDocstringParam(TypedDict):
+    name: str
+    type: str
+    typeSchema: Optional[Dict[str, Any]]
+    description: str
+
+
+class GoogleDocstringReturns(TypedDict):
+    type: str
+    typeSchema: Optional[Dict[str, Any]]
+    description: str
+
+
+class GoogleDocstring(TypedDict):
+    description: str
+    params: List[GoogleDocstringParam]
+    returns: GoogleDocstringReturns
+    raises: Dict[str, str]
+
+
+class _GoogleDocstringState(TypedDict):
+    description: List[str]
+    params: Dict[str, _GoogleParamState]
+    returns: _GoogleReturnsState
+    raises: Dict[str, str]
+
+
+def _parse_google_docstring(docstring: str) -> GoogleDocstring:
     import re
     lines = docstring.split('\n')
     mode = None
-    params = {}
-    parsed = {
+    params: Dict[str, _GoogleParamState] = {}
+    parsed: _GoogleDocstringState = {
         'description': [],
-        'params': [],
-        'returns': {'description': []},
+        'params': params,
+        'returns': {'type': '', 'description': []},
         'raises': {}
     }
     current_key = None
@@ -169,12 +212,25 @@ def _parse_google_docstring(docstring: str) -> Dict[str, Any]:
         elif mode is None:
             parsed['description'].append(line.strip())
 
-    # Consolidate descriptions
-    parsed['description'] = ' '.join(parsed['description']).strip()
-    parsed['returns']['description'] = ' '.join(parsed['returns']['description']).strip()
-    parsed['params'] = [{ **v, 'description': ' '.join(v['description']).strip() } for v in params.values()]
+    parsed_result: GoogleDocstring = {
+        'description': ' '.join(parsed['description']).strip(),
+        'params': [
+            {
+                **value,
+                'typeSchema': None,
+                'description': ' '.join(value['description']).strip(),
+            }
+            for value in params.values()
+        ],
+        'returns': {
+            'type': parsed['returns']['type'],
+            'typeSchema': None,
+            'description': ' '.join(parsed['returns']['description']).strip(),
+        },
+        'raises': parsed['raises'],
+    }
 
-    return parsed
+    return parsed_result
 
 
 def _get_schemas(code: str) -> List[Dict]:
@@ -299,12 +355,12 @@ def _parse_deploy_comment(comment: str) -> Optional[Deployment]:
 
     # Local development puts canopy on a different port than the poly-server
     if instance.endswith("localhost:3000"):
-        instance = instance.replace(":3000', ':8000")
+        instance = instance.replace(":3000", ":8000")
 
     return {
         "name": name,
         "context": context,
-        "type": deploy_type,
+        "type": DeployableTypes(deploy_type),
         "id": id,
         "deployed": deployed,
         "fileRevision": file_revision,
@@ -398,9 +454,9 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
             ):
                 # We've found a polyConfig dictionary assignment
                 if node.annotation.id == "PolyServerFunction":
-                    deployable["type"] = "server-function"
+                    deployable["type"] = "server-function" # pyright: ignore[reportGeneralTypeIssues]
                 elif node.annotation.id == "PolyClientFunction":
-                    deployable["type"] = "client-function"
+                    deployable["type"] = "client-function" # pyright: ignore[reportGeneralTypeIssues]
                 else:
                     print_red("ERROR")
                     print(f"Unsupported polyConfig type '${node.annotation.id}'")
@@ -466,7 +522,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
                 if deployment:
                     start = self._line_offsets[i]
                     deployable["deployments"].append(deployment)
-                    deployable["deploymentCommentRanges"].append([start, start + len(line)])
+                    deployable["deploymentCommentRanges"].append((start, start + len(line)))
 
         def visit_Import(self, node: ast.Import):
             # TODO maybe handle `import foo.bar` case?
@@ -539,7 +595,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
 
         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
+                self._current_offset = self._line_offsets[node.lineno - 1] + node.col_offset # pyright: ignore[reportAttributeAccessIssue]
             super().generic_visit(node)
 
     tree = ast.parse(code)

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/poly_tables.py

@@ -74,7 +74,12 @@ def scrub_keys(e: Exception) -> Dict[str, Any]:
 
 def execute_query(table_id, method, query):
     from polyapi import polyCustom
-    from polyapi.poly.client_id import client_id
+
+    client_id: Optional[str] = None
+    try:
+        from polyapi.poly.client_id import client_id  # pyright: ignore[reportMissingImports]
+    except ImportError:
+        pass
 
     try:
         api_key, base_url = get_api_key_and_url()
@@ -84,7 +89,9 @@ def execute_query(table_id, method, query):
             )
 
         auth_key = polyCustom.get("executionApiKey") or api_key
-        url = f"{base_url.rstrip('/')}/tables/{table_id}/{method}?clientId={client_id}"
+        url = f"{base_url.rstrip('/')}/tables/{table_id}/{method}"
+        if client_id:
+            url += f"?clientId={client_id}"
         headers = {"x-poly-execution-id": polyCustom.get("executionId") or ""}
         if auth_key:
             headers["Authorization"] = f"Bearer {auth_key}"

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/prepare.py

@@ -1,7 +1,7 @@
 import os
 import sys
 import subprocess
-from typing import List, Tuple, Literal
+from typing import Any, Dict, List, Tuple, Literal, TypeGuard
 from polyapi import http_client
 from polyapi.utils import get_auth_headers
 from polyapi.config import get_api_key_and_url
@@ -10,7 +10,7 @@ from polyapi.deployables import (
     prepare_deployable_directory, write_cache_revision,
     save_deployable_records, get_all_deployable_files,
     is_cache_up_to_date, get_git_revision,
-    write_updated_deployable, DeployableRecord
+    write_updated_deployable, DeployableRecord, PolyDeployConfig
 )
 
 class FunctionArgumentDto:
@@ -19,7 +19,15 @@ class FunctionArgumentDto:
         self.type = type
         self.description = description
 
-def get_function_description(deploy_type: Literal["server-function", "client-function"], description: str, arguments, code: str) -> str:
+
+FunctionDeployType = Literal["server-function", "client-function"]
+
+
+def _is_function_deploy_type(deploy_type: str) -> TypeGuard[FunctionDeployType]:
+    return deploy_type in ("server-function", "client-function")
+
+
+def get_function_description(deploy_type: FunctionDeployType, description: str, arguments, code: str) -> Dict[str, Any]:
     if deploy_type == "server-function":
         return get_server_function_description(description, arguments, code)
     elif deploy_type == "client-function":
@@ -27,14 +35,14 @@ def get_function_description(deploy_type: Literal["server-function", "client-fun
     else:
         raise ValueError("Unsupported deployable type")
 
-def get_server_function_description(description: str, arguments, code: str) -> str:
+def get_server_function_description(description: str, arguments, code: str) -> Dict[str, Any]:
     api_key, api_url = get_api_key_and_url()
     headers = get_auth_headers(api_key)
     data = {"description": description, "arguments": arguments, "code": code}
     response = http_client.post(f"{api_url}/functions/server/description-generation", headers=headers, json=data)
     return response.json()
 
-def get_client_function_description(description: str, arguments, code: str) -> str:
+def get_client_function_description(description: str, arguments, code: str) -> Dict[str, Any]:
     api_key, api_url = get_api_key_and_url()
     headers = get_auth_headers(api_key)
     # Simulated API call to generate client function descriptions
@@ -50,8 +58,12 @@ def fill_in_missing_function_details(deployable: DeployableRecord, code: str) ->
     )
     if is_missing_descriptions:
         try:
+            deploy_type = deployable["type"]
+            if not _is_function_deploy_type(deploy_type):
+                raise ValueError(f'Unsupported deployable type: "{deploy_type}"')
+
             ai_generated = get_function_description(
-                deployable["type"],
+                deploy_type,
                 deployable["types"]["description"], 
                 [{"name": p["name"], "type": p["type"], "description": p.get("description")} for p in deployable["types"]["params"]],
                 code
@@ -84,7 +96,13 @@ def get_base_url() -> str:
 def get_all_deployables(disable_docs: bool, disable_ai: bool, git_revision: str) -> List[DeployableRecord]:
     print("Searching for poly deployables.")
     base_url = get_base_url() or "."
-    possible_deployables = get_all_deployable_files({"includeDirs": [base_url]})
+    deployable_search_config: PolyDeployConfig = {
+        "type_names": [],
+        "include_dirs": [base_url],
+        "include_files_or_extensions": [],
+        "exclude_dirs": [],
+    }
+    possible_deployables = get_all_deployable_files(deployable_search_config)
     print(f'Found {len(possible_deployables)} possible deployable file{"s" if len(possible_deployables) != 1 else ""}.')
 
     found = {}

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21}/polyapi/server.py

@@ -75,8 +75,7 @@ def render_server_function(
 
 
 def _normalize_return_type_for_annotation(function_name: str, return_type_name: str) -> str:
-    if return_type_name == "ReturnType":
-        return "ReturnType"
+    # "ReturnType" lives in a separate module, so it must be qualified (e.g. _SFX.ReturnType).
     return add_type_import_path(function_name, return_type_name)