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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.19.dev3
-Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
+Version: 0.3.20
+Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
         
@@ -84,6 +84,39 @@ 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 |
+| `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
+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.19.dev3 → polyapi_python-0.3.20}/README.md

@@ -43,6 +43,39 @@ 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 |
+| `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
+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 +189,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.19.dev3 → polyapi_python-0.3.20}/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/polyapi/ai_function.py

@@ -0,0 +1,96 @@
+from typing import Any, Dict, List, Tuple, cast
+
+from polyapi.typedefs import PropertySpecification, PropertyType
+from polyapi.utils import add_type_import_path, parse_arguments, get_type_and_def, return_type_already_defined_in_args, rewrite_arg_name
+
+AI_DEFS_TEMPLATE = """
+from typing import List, Dict, Any, TypedDict, Callable
+{args_def}
+{return_type_def}
+"""
+
+AI_FUNCTION_TEMPLATE = """
+def {function_name}(
+{args}
+) -> {return_type_name}:
+    \"""{function_description}
+
+    Function ID: {function_id}
+    \"""
+    resp = execute("{function_type}", "{function_id}", {data})
+    try:
+        return {return_action}
+    except:
+        return resp.text  # type: ignore # fallback for debugging
+
+
+async def {function_name}_async(
+{args}
+) -> {return_type_name}:
+    \"""{function_description}
+
+    Function ID: {function_id}
+    \"""
+    resp = await execute_async("{function_type}", "{function_id}", {data})
+    try:
+        return {return_action}
+    except:
+        return resp.text  # type: ignore # fallback for debugging
+
+
+"""
+
+
+def render_ai_function(
+    function_type: str,
+    function_name: str,
+    function_id: str,
+    function_description: str,
+    arguments: List[PropertySpecification],
+    return_type: Dict[str, Any],
+) -> Tuple[str, str]:
+    arg_names = [a["name"] for a in arguments]
+    args, args_def = parse_arguments(function_name, arguments)
+    return_type_name, return_type_def = get_type_and_def(cast(PropertyType, return_type), "ReturnType")
+
+    if return_type_def and return_type_already_defined_in_args(return_type_name, args_def):
+        return_type_def = ""
+
+    data = "{" + ", ".join([f"'{arg}': {rewrite_arg_name(arg)}" for arg in arg_names]) + "}"
+    func_type_defs = AI_DEFS_TEMPLATE.format(
+        args_def=args_def,
+        return_type_def=return_type_def,
+    )
+    func_str = AI_FUNCTION_TEMPLATE.format(
+        return_type_name=_normalize_return_type_for_annotation(function_name, return_type_name),
+        function_type="ai",
+        function_name=function_name,
+        function_id=function_id,
+        function_description=function_description.replace('"', "'"),
+        args=args,
+        return_action=_get_ai_return_action(return_type_name),
+        data=data,
+    )
+    return func_str, func_type_defs
+
+
+def _normalize_return_type_for_annotation(function_name: str, return_type_name: str) -> str:
+    if return_type_name == "ReturnType":
+        return "ReturnType"
+    return add_type_import_path(function_name, return_type_name)
+
+
+def _get_ai_return_action(return_type_name: str) -> str:
+    normalized_type = return_type_name.replace(" ", "")
+
+    if normalized_type in {"str", "Optional[str]"}:
+        return_action = "resp.text"
+    elif "|" in normalized_type:
+        union_parts = {part for part in normalized_type.split("|") if part}
+        if union_parts == {"str", "None"}:
+            return_action = "resp.text"
+        else:
+            return_action = "resp.json()"
+    else:
+        return_action = "resp.json()"
+    return return_action

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

@@ -17,6 +17,7 @@ from .webhook import render_webhook_handle
 from .typedefs import PropertySpecification, SchemaSpecDto, SpecificationDto, VariableSpecDto, TableSpecDto
 from .api import render_api_function
 from .server import render_server_function
+from .ai_function import render_ai_function
 from .utils import add_import_to_init, get_auth_headers, init_the_init, print_green, to_func_namespace, to_type_module_alias
 from .variables import generate_variables
 from .poly_tables import generate_tables
@@ -29,6 +30,7 @@ SUPPORTED_FUNCTION_TYPES = {
     "customFunction",  # client function - this is badly named in /specs atm
     "serverFunction",
     "webhookHandle",
+    "aiFunction",
 }
 
 SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable", "schema", "snippet", "table"}
@@ -51,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
@@ -98,7 +100,7 @@ def resolve_poly_refs(obj, schema_index):
 def replace_poly_refs_in_functions(specs: List[SpecificationDto], schema_index):
     spec_idxs_to_remove = []
     for idx, spec in enumerate(specs):
-        if spec.get("type") in ("apiFunction", "customFunction", "serverFunction"):
+        if spec.get("type") in ("apiFunction", "customFunction", "serverFunction", "aiFunction"):
             func = spec.get("function")
             if func:
                 try:
@@ -501,6 +503,15 @@ def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
             arguments,
             return_type,
         )
+    elif function_type == "aiFunction":
+        func_str, func_type_defs = render_ai_function(
+            function_type,
+            function_name,
+            function_id,
+            function_description,
+            arguments,
+            return_type,
+        )
 
     if X_POLY_REF_WARNING in func_type_defs:
         # this indicates that jsonschema_gentypes has detected an x-poly-ref