polyapi-python 0.3.20.dev2__tar.gz → 0.3.20.dev4__tar.gz

{polyapi_python-0.3.20.dev2 → polyapi_python-0.3.20.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev2
+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.dev2 → polyapi_python-0.3.20.dev4}/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.dev2 → polyapi_python-0.3.20.dev4}/polyapi/generate.py

@@ -53,7 +53,7 @@ def get_specs(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
     params: Any = {"noTypes": str(no_types).lower()}
 
     if contexts:
-        params["contexts"] = contexts
+        params["contexts"] = ",".join(contexts)
     
     if names:
         params["names"] = names

{polyapi_python-0.3.20.dev2 → polyapi_python-0.3.20.dev4}/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.dev2 → polyapi_python-0.3.20.dev4}/polyapi_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev2
+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.dev2 → polyapi_python-0.3.20.dev4}/pyproject.toml

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

{polyapi_python-0.3.20.dev2 → polyapi_python-0.3.20.dev4}/tests/test_generate.py

@@ -10,7 +10,7 @@ from typing import cast
 from unittest.mock import patch, MagicMock
 from polyapi.typedefs import SpecificationDto
 from polyapi.utils import get_type_and_def, rewrite_reserved, to_type_module_alias
-from polyapi.generate import render_spec, create_empty_schemas_module, generate_functions, create_function, add_function_file
+from polyapi.generate import render_spec, create_empty_schemas_module, generate_functions, create_function, add_function_file, get_specs
 from polyapi.poly_schemas import generate_schemas, create_schema
 from polyapi.variables import generate_variables, create_variable
 
@@ -247,6 +247,26 @@ MEWS_HEADERS_SPECS = [
 
 
 class T(unittest.TestCase):
+    @patch("polyapi.generate.get_direct_execute_config", return_value=False)
+    @patch("polyapi.generate.get_auth_headers", return_value={"Authorization": "Bearer api-key"})
+    @patch("polyapi.generate.get_api_key_and_url", return_value=("api-key", "https://api.example.com"))
+    @patch("polyapi.generate.http_client.get")
+    def test_get_specs_serializes_more_than_twenty_contexts_as_one_parameter(
+        self,
+        mock_get,
+        _mock_api_config,
+        _mock_headers,
+        _mock_direct_execute,
+    ):
+        contexts = [f"context{index}" for index in range(21)]
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = []
+
+        self.assertEqual(get_specs(contexts=contexts), [])
+
+        params = mock_get.call_args.kwargs["params"]
+        self.assertEqual(params["contexts"], ",".join(contexts))
+
     def test_get_type_and_def(self):
         arg_type, arg_def = get_type_and_def(OPENAPI_FUNCTION)
         self.assertEqual(arg_type, "Callable[[List[WebhookEventTypeElement], Dict, Dict, Dict], None]")