polyapi-python 0.3.20.dev3__py3-none-any.whl → 0.3.20.dev4__py3-none-any.whl

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.dist-info → polyapi_python-0.3.20.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev3
+Version: 0.3.20.dev4
 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.dist-info → polyapi_python-0.3.20.dev4.dist-info}/RECORD

@@ -14,7 +14,7 @@ polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
 polyapi/execute.py,sha256=4jLkQely6cM7pNN9pYpGZTbEis-DfwENi5Fl07xSiig,8966
 polyapi/function_cli.py,sha256=gJE72lRvuWnGl6CG9GpqL78TOnUzxVe4kJMvg0PQixw,4493
 polyapi/generate.py,sha256=U8JQ_XR2gJI_eYNnmvXReILUxapj95QKoBronqMFkyE,22403
-polyapi/http_client.py,sha256=x2pBXjETq1YlDgCoM87PTr6holfTnA_FXpa_br_Yf3k,12194
+polyapi/http_client.py,sha256=5N-zWSsjdMCPnrICR45EJWtXtBNyMP42L6Q8_Bh7n1A,15198
 polyapi/parser.py,sha256=t3jJI6g5F7Qg_tirPOzSkQ02VLkSVhnqs9YGapyHx2k,21901
 polyapi/poly_schemas.py,sha256=JGMQbELPFw4V_0nA0o71WJKFTdxjCGoKqJvIid_Y-a4,10759
 polyapi/poly_tables.py,sha256=SlP7ZwqS3nIji2uGR2VJQH6IdddZ832rRItcmoYdIBc,20293
@@ -28,8 +28,8 @@ polyapi/typedefs.py,sha256=UeAdyYrgqxrvBRkjisK_xgzQmuTePPvOM74HKf1y0II,5656
 polyapi/utils.py,sha256=LUqTkbb0b7y3gjsOU-WO1LVYaTMyExTGpYjKY8wVKg8,16300
 polyapi/variables.py,sha256=hfSDPGQK6YphNCa9MqE0W88WIFfqCQWgpBDWkExMq-A,7582
 polyapi/webhook.py,sha256=0ceLwHNjNd2Yx_8MX5jOIxiQ5Lwhy2pe81ProAuKon0,5108
-polyapi_python-0.3.20.dev3.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
-polyapi_python-0.3.20.dev3.dist-info/METADATA,sha256=r1r6mN2pdcMXBav1GktbhEUPRGgpe_a1VlFsj91QrhQ,7300
-polyapi_python-0.3.20.dev3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-polyapi_python-0.3.20.dev3.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
-polyapi_python-0.3.20.dev3.dist-info/RECORD,,
+polyapi_python-0.3.20.dev4.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
+polyapi_python-0.3.20.dev4.dist-info/METADATA,sha256=wYIJAgguqGC3FNXxYZHtQcLtumtopR5vf29f4X7W9rI,7737
+polyapi_python-0.3.20.dev4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+polyapi_python-0.3.20.dev4.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
+polyapi_python-0.3.20.dev4.dist-info/RECORD,,