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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev3
+Version: 0.3.21.dev0
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -98,10 +98,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.dev0}/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.dev0}/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.dev0}/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.dev0}/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)
 
 

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

@@ -102,7 +102,8 @@ def normalize_cross_language_type(type_name: str) -> str:
         normalized = [normalize_cross_language_type(part) for part in parts]
         return " | ".join(normalized) if normalized else "Any"
 
-    if value == "ReturnType" or value.startswith("ReturnType<") or "typeof" in value:
+    # Only TS's ReturnType<...>/typeof syntax falls back to Any, not our own "ReturnType" name.
+    if value.startswith("ReturnType<") or "typeof" in value:
         return "Any"
 
     return primitive_map.get(value, value)
@@ -220,8 +221,12 @@ def get_type_and_def(  # noqa: C901
                 return "List", ""
             elif title and title == "ReturnType" and schema.get("type"):
                 assert isinstance(title, str)
-                schema_type = schema.get("type", "Any")
-                root_type, generated_code = wrapped_generate_schema_types(schema, schema_type, "Dict")  # type: ignore
+                # Use `title` as the class name, not schema["type"] (e.g. "object" collides with dict).
+                root_type, generated_code = wrapped_generate_schema_types(schema, title, "Dict")  # type: ignore
+                if f"class {root_type}(" not in generated_code:
+                    # A property-less object schema (e.g. bare {"type": "object"}) generates no
+                    # class at all, so root_type would reference a name that doesn't exist.
+                    return "Dict", ""
                 return (map_primitive_types(root_type), "") if is_primitive(root_type) else (root_type, generated_code)  # type: ignore
             elif title:
                 assert isinstance(title, str)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev3
+Version: 0.3.21.dev0
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -98,10 +98,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.dev0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polyapi-python"
-version = "0.3.20.dev3"
+version = "0.3.21.dev0"
 description = "The Python SDK for the integration platform PolyAPI"
 authors = [{ name = "PolyAPI", email = "support@polyapi.io" }]
 dependencies = [

{polyapi_python-0.3.20.dev3 → polyapi_python-0.3.21.dev0}/tests/test_server.py

@@ -151,8 +151,9 @@ class T(unittest.TestCase):
 #         self.assertIn(expected_return_type, func_str)
 
 
-    def test_render_function_return_type_name_collision_does_not_reference_module_attr(self):
+    def test_render_function_return_type_name_collision_uses_qualified_reference(self):
         return_type = RETURN_TYPE_NAMED_RETURN_TYPE["function"]["returnType"]
+        name = RETURN_TYPE_NAMED_RETURN_TYPE["name"]
         func_str, func_type_defs = render_server_function(
             RETURN_TYPE_NAMED_RETURN_TYPE["type"],
             RETURN_TYPE_NAMED_RETURN_TYPE["name"],
@@ -161,9 +162,10 @@ class T(unittest.TestCase):
             RETURN_TYPE_NAMED_RETURN_TYPE["function"]["arguments"],
             return_type,
         )
-        self.assertIn("-> dict", func_str)
-        self.assertNotIn(".returnType", func_str)
-        self.assertNotIn(".ReturnType", func_str)
+        # The real "ReturnType" class must be generated and referenced via its
+        # qualified module alias, not collapsed to a generic "dict".
+        self.assertIn(f"-> {to_type_module_alias(name)}.ReturnType", func_str)
+        self.assertIn("class ReturnType(", func_type_defs)
 
     def test_render_function_string_union_returns_text(self):
         function_name = "getMaybeName"