polyapi-python 0.3.20.dev1__tar.gz → 0.3.20.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev1
+Version: 0.3.20.dev3
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -84,6 +84,32 @@ POLY_API_KEY='your_key'
 POLY_API_BASE_URL='your_server'  # e.g. na1.polyapi.io
 ```
 
+### HTTP Client Configuration
+
+The SDK reuses one synchronous HTTP client per process and one asynchronous
+client per event loop. New clients read these optional environment variables:
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `POLY_HTTP_MAX_CONNECTIONS` | `200` | Maximum connections per client |
+| `POLY_HTTP_MAX_KEEPALIVE_CONNECTIONS` | `none` | Maximum idle keep-alive connections per client |
+| `POLY_HTTP_KEEPALIVE_EXPIRY` | `30` | Idle keep-alive expiry in seconds |
+| `POLY_HTTP_CONNECT_TIMEOUT` | `none` | Connection timeout in seconds |
+| `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 |
+
+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.
+
+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
+before closing their client. Clients on standard asyncio loops are closed
+automatically when the loop closes. If a custom event-loop implementation
+reports that its close hook could not be installed, explicitly await
+`close_async()` before closing that loop.
+
 ### 3. Test
 
 That's it! Now open up a test file and you can run some code like so:

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

@@ -43,6 +43,32 @@ POLY_API_KEY='your_key'
 POLY_API_BASE_URL='your_server'  # e.g. na1.polyapi.io
 ```
 
+### HTTP Client Configuration
+
+The SDK reuses one synchronous HTTP client per process and one asynchronous
+client per event loop. New clients read these optional environment variables:
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `POLY_HTTP_MAX_CONNECTIONS` | `200` | Maximum connections per client |
+| `POLY_HTTP_MAX_KEEPALIVE_CONNECTIONS` | `none` | Maximum idle keep-alive connections per client |
+| `POLY_HTTP_KEEPALIVE_EXPIRY` | `30` | Idle keep-alive expiry in seconds |
+| `POLY_HTTP_CONNECT_TIMEOUT` | `none` | Connection timeout in seconds |
+| `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 |
+
+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.
+
+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
+before closing their client. Clients on standard asyncio loops are closed
+automatically when the loop closes. If a custom event-loop implementation
+reports that its close hook could not be installed, explicitly await
+`close_async()` before closing that loop.
+
 ### 3. Test
 
 That's it! Now open up a test file and you can run some code like so:
@@ -156,4 +182,4 @@ Of course all this is in addition to the changes passing through normal unittest
 ## Support
 
 If you run into any issues or want help getting started with this project, please contact support@polyapi.io
-.
+.

{polyapi_python-0.3.20.dev1 → polyapi_python-0.3.20.dev3}/polyapi/__init__.py

@@ -1,25 +1,36 @@
 import copy
+import importlib
 import os
-import sys
 from contextvars import ContextVar, Token
 from dataclasses import dataclass
-from typing import Any, Dict, Literal, Optional, overload
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, overload
 
 import truststore
 from typing_extensions import TypedDict
 
-from .cli_constants import CLI_COMMANDS
-
 truststore.inject_into_ssl()
 
 __all__ = ["poly"]
 
+if TYPE_CHECKING:
+    poly: ModuleType
+
 
-if len(sys.argv) > 1 and sys.argv[1] not in CLI_COMMANDS:
+def _load_generated_poly() -> ModuleType:
     currdir = os.path.dirname(os.path.abspath(__file__))
     if not os.path.isdir(os.path.join(currdir, "poly")):
-        print("No 'poly' found. Please run 'python3 -m polyapi generate' to generate the 'poly' library for your tenant.")
-        sys.exit(1)
+        raise ModuleNotFoundError(
+            "No 'poly' found. Please run 'python3 -m polyapi generate' "
+            "to generate the 'poly' library for your tenant."
+        )
+    return importlib.import_module(".poly", __name__)
+
+
+def __getattr__(name: str) -> ModuleType:
+    if name == "poly":
+        return _load_generated_poly()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
 class PolyCustomDict(TypedDict, total=False):

{polyapi_python-0.3.20.dev1 → polyapi_python-0.3.20.dev3}/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.dev3/polyapi/http_client.py

@@ -0,0 +1,350 @@
+import asyncio
+import logging
+import os
+import threading
+import httpx
+
+logger = logging.getLogger("poly")
+
+# Connx pool + timeout defaults for the shared clients.
+# All overridable via POLY_HTTP_* env vars so operators can tune limits or
+# opt into timeouts without editing callers. Empty / "none" parses to None (unbounded).
+
+
+def _env_opt_int(name: str, default: "int | None") -> "int | None":
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    raw = raw.strip()
+    return None if raw == "" or raw.lower() in ("none", "null") else int(raw)
+
+
+def _env_opt_float(name: str, default: "float | None") -> "float | None":
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    raw = raw.strip()
+    return None if raw == "" or raw.lower() in ("none", "null") else float(raw)
+
+
+def _build_limits() -> httpx.Limits:
+    return httpx.Limits(
+        max_connections=_env_opt_int("POLY_HTTP_MAX_CONNECTIONS", 200),
+        max_keepalive_connections=_env_opt_int("POLY_HTTP_MAX_KEEPALIVE_CONNECTIONS", None),
+        keepalive_expiry=_env_opt_float("POLY_HTTP_KEEPALIVE_EXPIRY", 30.0),
+    )
+
+
+def _build_timeout() -> httpx.Timeout:
+    # Default to the SDK's original unbounded timeout; bound per-phase only via env.
+    return httpx.Timeout(
+        connect=_env_opt_float("POLY_HTTP_CONNECT_TIMEOUT", None),
+        read=_env_opt_float("POLY_HTTP_READ_TIMEOUT", None),
+        write=_env_opt_float("POLY_HTTP_WRITE_TIMEOUT", None),
+        pool=_env_opt_float("POLY_HTTP_POOL_TIMEOUT", None),
+    )
+
+
+# Import-time snapshot for reference/config surface. Clients re-read env at creation
+DEFAULT_LIMITS = _build_limits()
+DEFAULT_TIMEOUT = _build_timeout()
+# PID that owns the clients below; a fork resets it
+_owner_pid: int = os.getpid()
+_sync_client: httpx.Client | None = None
+# Coordinate lazy creation, active requests, and shutdown of _sync_client.
+_sync_client_lock = threading.Lock()
+_sync_client_condition = threading.Condition(_sync_client_lock)
+_sync_inflight = 0
+_sync_closing = False
+# One async client per event loop.
+_async_clients: "dict[asyncio.AbstractEventLoop, httpx.AsyncClient]" = {}
+# In-flight request count per async client, so close_async can drain before aclose.
+_async_inflight: "dict[httpx.AsyncClient, int]" = {}
+# Event loops whose close() already wrapped
+_hooked_loops: "set[asyncio.AbstractEventLoop]" = set()
+# Shared close operation per event loop. New requests wait for it so they do not
+# race a replacement client into the pool mid-close.
+_closing_loops: "dict[asyncio.AbstractEventLoop, asyncio.Task[None]]" = {}
+
+
+def _after_fork_in_child() -> None:
+    """Reset all shared client state in a forked child
+    """
+    global _owner_pid, _sync_client, _sync_client_lock, _sync_client_condition
+    global _sync_inflight, _sync_closing
+    _sync_client_lock = threading.Lock()
+    _sync_client_condition = threading.Condition(_sync_client_lock)
+    _sync_client = None
+    _sync_inflight = 0
+    _sync_closing = False
+    _async_clients.clear()
+    _async_inflight.clear()
+    _hooked_loops.clear()
+    _closing_loops.clear()
+    _owner_pid = os.getpid()
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(after_in_child=_after_fork_in_child)
+
+
+def _reset_if_forked() -> None:
+    """Drop clients inherited across os.fork() so childisolated
+    Clear not close the inherited refs - child makes its own."""
+    global _owner_pid, _sync_client, _sync_client_lock, _sync_client_condition
+    global _sync_inflight, _sync_closing
+    current_pid = os.getpid()
+    if current_pid != _owner_pid:
+        _sync_client_lock = threading.Lock()
+        _sync_client_condition = threading.Condition(_sync_client_lock)
+        _sync_client = None
+        _sync_inflight = 0
+        _sync_closing = False
+        _async_clients.clear()
+        _async_inflight.clear()
+        _hooked_loops.clear()
+        _closing_loops.clear()
+        _owner_pid = current_pid
+
+
+def _get_or_create_sync_client() -> httpx.Client:
+    global _sync_client
+    if _sync_client is None:
+        _sync_client = httpx.Client(limits=_build_limits(), timeout=_build_timeout())
+    return _sync_client
+
+
+def _get_sync_client() -> httpx.Client:
+    _reset_if_forked()
+    with _sync_client_condition:
+        while _sync_closing:
+            _sync_client_condition.wait()
+        return _get_or_create_sync_client()
+
+
+def _dispatch_sync(method_name: str, *args, **kwargs) -> httpx.Response:
+    global _sync_inflight
+    _reset_if_forked()
+    with _sync_client_condition:
+        while _sync_closing:
+            _sync_client_condition.wait()
+        client = _get_or_create_sync_client()
+        _sync_inflight += 1
+    try:
+        return getattr(client, method_name)(*args, **kwargs)
+    finally:
+        with _sync_client_condition:
+            _sync_inflight -= 1
+            if _sync_inflight == 0:
+                _sync_client_condition.notify_all()
+
+
+def _retire_async_client(
+    client: httpx.AsyncClient | None,
+    loop: asyncio.AbstractEventLoop | None,
+) -> None:
+    """Best-effort close of an async client whose event loop is being dumped.
+    """
+    if client is None:
+        return
+    try:
+        if loop is not None and loop.is_running():
+            loop.call_soon_threadsafe(lambda: loop.create_task(client.aclose()))
+            logger.debug(f"Scheduled aclose of async client id={id(client)} pid={os.getpid()} loop={id(loop)}")
+        else:
+            loop_closed = None if loop is None else loop.is_closed()
+            logger.debug(f"Dropping async client id={id(client)} pid={os.getpid()} loop={id(loop)} loop_closed={loop_closed}")
+    except Exception:
+        logger.warning(f"Failed to retire async client id={id(client)} pid={os.getpid()} loop={id(loop)}", exc_info=True)
+
+
+def _sweep_dead_loops() -> None:
+    """Wipe clients whose event loop has been closed.
+    """
+    for loop in list(_async_clients):
+        if loop.is_closed():
+            _retire_async_client(_async_clients.pop(loop, None), loop)
+
+
+def _register_loop_close_hook(loop: asyncio.AbstractEventLoop) -> None:
+    """aclose the loop's async client right before the loop is torn down.
+    """
+    if loop in _hooked_loops:
+        return
+    original_close = loop.close
+
+    def _close_with_cleanup(*args, **kwargs):
+        _hooked_loops.discard(loop)
+        cached = _async_clients.pop(loop, None)
+        if cached is not None and not loop.is_closed():
+            try:
+                loop.run_until_complete(cached.aclose())
+            except Exception:
+                logger.warning(
+                    f"Failed to aclose async client id={id(cached)} pid={os.getpid()} "
+                    f"loop={id(loop)} on teardown", exc_info=True)
+        return original_close(*args, **kwargs)
+
+    try:
+        loop.close = _close_with_cleanup  # type: ignore[method-assign]
+        _hooked_loops.add(loop)
+    except (AttributeError, TypeError):
+        logger.warning(
+            f"Could not hook loop.close pid={os.getpid()} loop={id(loop)}; "
+            "await close_async() before closing this event loop"
+        )
+
+
+def _get_async_client() -> httpx.AsyncClient:
+    _reset_if_forked()
+    current_loop = asyncio.get_running_loop()
+    client = _async_clients.get(current_loop)
+    if client is None:
+        _sweep_dead_loops()
+        limits = _build_limits()
+        client = httpx.AsyncClient(limits=limits, timeout=_build_timeout())
+        _async_clients[current_loop] = client
+        _register_loop_close_hook(current_loop)
+        logger.debug(
+            f"Created async client id={id(client)} pid={os.getpid()} loop={id(current_loop)} "
+            f"max_connections={limits.max_connections} "
+            f"max_keepalive={limits.max_keepalive_connections} "
+            f"keepalive_expiry={limits.keepalive_expiry}"
+        )
+    return client
+
+
+async def _dispatch_async(method_name: str, *args, **kwargs) -> httpx.Response:
+    # If a shutdown is closing this loop's client, wait so a replacement is not
+    # published mid-close. The shutdown caller owns any close error.
+    closing = _closing_loops.get(asyncio.get_running_loop())
+    if closing is not None:
+        try:
+            await asyncio.shield(closing)
+        except Exception:
+            pass
+    # Track in-flight requests per client so close_async can drain before aclose.
+    client = _get_async_client()
+    _async_inflight[client] = _async_inflight.get(client, 0) + 1
+    try:
+        return await getattr(client, method_name)(*args, **kwargs)
+    finally:
+        remaining = _async_inflight.get(client, 1) - 1
+        if remaining <= 0:
+            _async_inflight.pop(client, None)
+        else:
+            _async_inflight[client] = remaining
+
+
+async def _drain_inflight(client: httpx.AsyncClient) -> None:
+    # Preserve the SDK's unbounded request behavior during shutdown. The shared
+    # close operation retains ownership until every active request finishes.
+    while _async_inflight.get(client, 0) > 0:
+        await asyncio.sleep(0.05)
+
+
+async def _wait_for_close_task(close_task: "asyncio.Task[None]") -> None:
+    """Wait for shared cleanup before propagating caller cancellation."""
+    caller_cancelled = False
+    while not close_task.done():
+        try:
+            await asyncio.shield(close_task)
+        except asyncio.CancelledError:
+            caller_cancelled = True
+    close_task.result()
+    if caller_cancelled:
+        raise asyncio.CancelledError()
+
+
+async def _close_clients_for_loop(
+    current_loop: asyncio.AbstractEventLoop,
+) -> None:
+    """Close shared clients while retaining ownership through completion."""
+    try:
+        await asyncio.to_thread(close)
+        client = _async_clients.get(current_loop)
+        if client is None:
+            return
+
+        await _drain_inflight(client)
+        try:
+            await client.aclose()
+        finally:
+            if _async_clients.get(current_loop) is client:
+                _async_clients.pop(current_loop, None)
+            _async_inflight.pop(client, None)
+    finally:
+        if _closing_loops.get(current_loop) is asyncio.current_task():
+            _closing_loops.pop(current_loop, None)
+        _sweep_dead_loops()
+
+
+def post(url, **kwargs) -> httpx.Response:
+    return _dispatch_sync("post", url, **kwargs)
+
+
+async def async_post(url, **kwargs) -> httpx.Response:
+    return await _dispatch_async("post", url, **kwargs)
+
+
+def get(url, **kwargs) -> httpx.Response:
+    return _dispatch_sync("get", url, **kwargs)
+
+
+async def async_get(url, **kwargs) -> httpx.Response:
+    return await _dispatch_async("get", url, **kwargs)
+
+
+def patch(url, **kwargs) -> httpx.Response:
+    return _dispatch_sync("patch", url, **kwargs)
+
+
+async def async_patch(url, **kwargs) -> httpx.Response:
+    return await _dispatch_async("patch", url, **kwargs)
+
+
+def delete(url, **kwargs) -> httpx.Response:
+    return _dispatch_sync("delete", url, **kwargs)
+
+
+async def async_delete(url, **kwargs) -> httpx.Response:
+    return await _dispatch_async("delete", url, **kwargs)
+
+
+def request(method, url, **kwargs) -> httpx.Response:
+    return _dispatch_sync("request", method, url, **kwargs)
+
+
+async def async_request(method, url, **kwargs) -> httpx.Response:
+    return await _dispatch_async("request", method, url, **kwargs)
+
+
+def close():
+    global _sync_client, _sync_closing
+    _reset_if_forked()
+    with _sync_client_condition:
+        while _sync_closing:
+            _sync_client_condition.wait()
+        if _sync_client is None:
+            return
+        _sync_closing = True
+        while _sync_inflight > 0:
+            _sync_client_condition.wait()
+        client = _sync_client
+    try:
+        client.close()
+    finally:
+        with _sync_client_condition:
+            if _sync_client is client:
+                _sync_client = None
+            _sync_closing = False
+            _sync_client_condition.notify_all()
+
+
+async def close_async():
+    current_loop = asyncio.get_running_loop()
+    close_task = _closing_loops.get(current_loop)
+    if close_task is None:
+        close_task = asyncio.create_task(_close_clients_for_loop(current_loop))
+        _closing_loops[current_loop] = close_task
+    await _wait_for_close_task(close_task)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev1
+Version: 0.3.20.dev3
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -84,6 +84,32 @@ POLY_API_KEY='your_key'
 POLY_API_BASE_URL='your_server'  # e.g. na1.polyapi.io
 ```
 
+### HTTP Client Configuration
+
+The SDK reuses one synchronous HTTP client per process and one asynchronous
+client per event loop. New clients read these optional environment variables:
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `POLY_HTTP_MAX_CONNECTIONS` | `200` | Maximum connections per client |
+| `POLY_HTTP_MAX_KEEPALIVE_CONNECTIONS` | `none` | Maximum idle keep-alive connections per client |
+| `POLY_HTTP_KEEPALIVE_EXPIRY` | `30` | Idle keep-alive expiry in seconds |
+| `POLY_HTTP_CONNECT_TIMEOUT` | `none` | Connection timeout in seconds |
+| `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 |
+
+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.
+
+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
+before closing their client. Clients on standard asyncio loops are closed
+automatically when the loop closes. If a custom event-loop implementation
+reports that its close hook could not be installed, explicitly await
+`close_async()` before closing that loop.
+
 ### 3. Test
 
 That's it! Now open up a test file and you can run some code like so:

{polyapi_python-0.3.20.dev1 → polyapi_python-0.3.20.dev3}/polyapi_python.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ tests/test_cli.py
 tests/test_dependency_pins.py
 tests/test_deployables.py
 tests/test_generate.py
+tests/test_generated_poly_boundary.py
 tests/test_parser.py
 tests/test_poly_custom.py
 tests/test_poly_schemas.py

{polyapi_python-0.3.20.dev1 → polyapi_python-0.3.20.dev3}/pyproject.toml

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