polyapi-python 0.3.13.dev3__py3-none-any.whl → 0.3.14__py3-none-any.whl

polyapi/__init__.py

@@ -1,11 +1,16 @@
+import copy
 import os
 import sys
-import copy
+from contextvars import ContextVar, Token
+from dataclasses import dataclass
+from typing import Any, Dict, Literal, Optional, overload
+
 import truststore
-from typing import Any, Dict, Optional, overload, Literal
 from typing_extensions import TypedDict
+
+from .cli_constants import CLI_COMMANDS
+
 truststore.inject_into_ssl()
-from .cli import CLI_COMMANDS
 
 __all__ = ["poly"]
 
@@ -19,83 +24,140 @@ if len(sys.argv) > 1 and sys.argv[1] not in CLI_COMMANDS:
 
 class PolyCustomDict(TypedDict, total=False):
     """Type definition for polyCustom dictionary."""
-    executionId: Optional[str]  # Read-only
+
+    executionId: Optional[str]  # Read-only unless explicitly unlocked
     executionApiKey: Optional[str]
-    responseStatusCode: int
+    userSessionId: Optional[str]
+    responseStatusCode: Optional[int]
     responseContentType: Optional[str]
-    responseHeaders: Dict[str, str]
-
-
-class _PolyCustom:
-    def __init__(self):
-        self._internal_store = {
-            "executionId": None,
-            "executionApiKey": None,
-            "responseStatusCode": 200,
-            "responseContentType": None,
-            "responseHeaders": {},
-        }
-        self._execution_id_locked = False
+    responseHeaders: Dict[str, Any]
+
+
+@dataclass
+class _PolyCustomState:
+    internal_store: Dict[str, Any]
+    execution_id_locked: bool = False
+
+
+class PolyCustom:
+    def __init__(self) -> None:
+        object.__setattr__(
+            self,
+            "_default_store",
+            {
+                "executionId": None,
+                "executionApiKey": None,
+                "userSessionId": None,
+                "responseStatusCode": 200,
+                "responseContentType": None,
+                "responseHeaders": {},
+            },
+        )
+        object.__setattr__(self, "_state_var", ContextVar("_poly_custom_state", default=None))
+
+    def _make_state(self) -> _PolyCustomState:
+        return _PolyCustomState(internal_store=copy.deepcopy(self._default_store))
+
+    def _get_state(self) -> _PolyCustomState:
+        state = self._state_var.get()
+        if state is None:
+            state = self._make_state()
+            self._state_var.set(state)
+        return state
+
+    def push_scope(self, initial_values: Optional[Dict[str, Any]] = None) -> Token:
+        state = self._make_state()
+        if initial_values:
+            state.internal_store.update(copy.deepcopy(initial_values))
+            if state.internal_store.get("executionId") is not None:
+                state.execution_id_locked = True
+        return self._state_var.set(state)
+
+    def pop_scope(self, token: Token) -> None:
+        self._state_var.reset(token)
 
     def set_once(self, key: str, value: Any) -> None:
-        if key == "executionId" and self._execution_id_locked:
-            # Silently ignore attempts to overwrite locked executionId
+        state = self._get_state()
+        if key == "executionId" and state.execution_id_locked:
             return
-        self._internal_store[key] = value
+        state.internal_store[key] = value
         if key == "executionId":
-            # Lock executionId after setting it
-            self.lock_execution_id()
+            state.execution_id_locked = True
 
     def get(self, key: str, default: Any = None) -> Any:
-        return self._internal_store.get(key, default)
+        return self._get_state().internal_store.get(key, default)
 
     def lock_execution_id(self) -> None:
-        self._execution_id_locked = True
+        self._get_state().execution_id_locked = True
 
     def unlock_execution_id(self) -> None:
-        self._execution_id_locked = False
+        self._get_state().execution_id_locked = False
 
     @overload
     def __getitem__(self, key: Literal["executionId"]) -> Optional[str]: ...
-    
+
     @overload
     def __getitem__(self, key: Literal["executionApiKey"]) -> Optional[str]: ...
-    
+
     @overload
-    def __getitem__(self, key: Literal["responseStatusCode"]) -> int: ...
-    
+    def __getitem__(self, key: Literal["userSessionId"]) -> Optional[str]: ...
+
+    @overload
+    def __getitem__(self, key: Literal["responseStatusCode"]) -> Optional[int]: ...
+
     @overload
     def __getitem__(self, key: Literal["responseContentType"]) -> Optional[str]: ...
 
     @overload
-    def __getitem__(self, key: Literal["responseHeaders"]) -> Dict[str, str]: ...
-    
+    def __getitem__(self, key: Literal["responseHeaders"]) -> Dict[str, Any]: ...
+
     def __getitem__(self, key: str) -> Any:
         return self.get(key)
 
     @overload
     def __setitem__(self, key: Literal["executionApiKey"], value: Optional[str]) -> None: ...
-    
+
+    @overload
+    def __setitem__(self, key: Literal["userSessionId"], value: Optional[str]) -> None: ...
+
     @overload
-    def __setitem__(self, key: Literal["responseStatusCode"], value: int) -> None: ...
-    
+    def __setitem__(self, key: Literal["responseStatusCode"], value: Optional[int]) -> None: ...
+
     @overload
     def __setitem__(self, key: Literal["responseContentType"], value: Optional[str]) -> None: ...
 
     @overload
-    def __setitem__(self, key: Literal["responseHeaders"], value: Dict[str, str]) -> None: ...
-    
+    def __setitem__(self, key: Literal["responseHeaders"], value: Dict[str, Any]) -> None: ...
+
     def __setitem__(self, key: str, value: Any) -> None:
         self.set_once(key, value)
 
-    def __repr__(self) -> str:
-        return f"PolyCustom({self._internal_store})"
+    def __getattr__(self, key: str) -> Any:
+        if key in self._default_store:
+            return self.get(key)
+        raise AttributeError(f"{type(self).__name__!r} object has no attribute {key!r}")
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if key.startswith("_"):
+            object.__setattr__(self, key, value)
+            return
+        self.set_once(key, value)
 
-    def copy(self) -> '_PolyCustom':
-        new = _PolyCustom()
-        new._internal_store = copy.deepcopy(self._internal_store)
-        new._execution_id_locked = self._execution_id_locked
+    def __repr__(self) -> str:
+        return f"PolyCustom({self._get_state().internal_store})"
+
+    def copy(self) -> "PolyCustom":
+        new = PolyCustom()
+        state = self._get_state()
+        new._state_var.set(
+            _PolyCustomState(
+                internal_store=copy.deepcopy(state.internal_store),
+                execution_id_locked=state.execution_id_locked,
+            )
+        )
         return new
 
 
-polyCustom: PolyCustomDict = _PolyCustom()
+_PolyCustom = PolyCustom
+
+polyCustom: PolyCustom = PolyCustom()

polyapi/api.py

@@ -35,6 +35,25 @@ def {function_name}(
         return {api_response_type}(resp.json())  # type: ignore
 
 
+async def {function_name}_async(
+{args}
+) -> {api_response_type}:
+    \"""{function_description}
+
+    Function ID: {function_id}
+    \"""
+    if get_direct_execute_config():
+        resp = await direct_execute_async("{function_type}", "{function_id}", {data})
+        return {api_response_type}({{
+            "status": resp.status_code,
+            "headers": dict(resp.headers),
+            "data": resp.json()
+        }})  # type: ignore
+    else:
+        resp = await execute_async("{function_type}", "{function_id}", {data})
+        return {api_response_type}(resp.json())  # type: ignore
+
+
 """
 
 

polyapi/auth.py

@@ -117,6 +117,16 @@ def introspectToken(token: str) -> AuthFunctionResponse:
     url = "/auth-providers/{function_id}/introspect"
     resp = execute_post(url, {{"token": token}})
     return resp.json()
+
+
+async def introspectToken_async(token: str) -> AuthFunctionResponse:
+    \"""{description}
+
+    Function ID: {function_id}
+    \"""
+    url = "/auth-providers/{function_id}/introspect"
+    resp = await execute_post_async(url, {{"token": token}})
+    return resp.json()
 """
 
 REFRESH_TOKEN_TEMPLATE = """
@@ -128,6 +138,16 @@ def refreshToken(token: str) -> AuthFunctionResponse:
     url = "/auth-providers/{function_id}/refresh"
     resp = execute_post(url, {{"token": token}})
     return resp.json()
+
+
+async def refreshToken_async(token: str) -> AuthFunctionResponse:
+    \"""{description}
+
+    Function ID: {function_id}
+    \"""
+    url = "/auth-providers/{function_id}/refresh"
+    resp = await execute_post_async(url, {{"token": token}})
+    return resp.json()
 """
 
 REVOKE_TOKEN_TEMPLATE = """
@@ -142,6 +162,19 @@ def revokeToken(token: str) -> Optional[AuthFunctionResponse]:
         return resp.json()
     except:
         return None
+
+
+async def revokeToken_async(token: str) -> Optional[AuthFunctionResponse]:
+    \"""{description}
+
+    Function ID: {function_id}
+    \"""
+    url = "/auth-providers/{function_id}/revoke"
+    resp = await execute_post_async(url, {{"token": token}})
+    try:
+        return resp.json()
+    except:
+        return None
 """
 
 

polyapi/cli.py

@@ -3,6 +3,7 @@ import argparse
 
 from polyapi.utils import print_green, print_red
 
+from .cli_constants import CLI_COMMANDS
 from .config import initialize_config, set_api_key_and_url
 from .generate import generate, clear
 from .function_cli import function_add_or_update, function_execute
@@ -11,9 +12,6 @@ from .prepare import prepare_deployables
 from .sync import sync_deployables
 
 
-CLI_COMMANDS = ["setup", "generate", "function", "clear", "help", "update_rendered_spec"]
-
-
 def _get_version_string():
     """Get the version string for the package."""
     try:

polyapi/cli_constants.py

@@ -0,0 +1,10 @@
+CLI_COMMANDS = (
+    "setup",
+    "generate",
+    "function",
+    "clear",
+    "help",
+    "update_rendered_spec",
+    "prepare",
+    "sync",
+)

polyapi/constants.py

@@ -3,8 +3,8 @@ JSONSCHEMA_TO_PYTHON_TYPE_MAP = {
     "number": "float",
     "string": "str",
     "boolean": "bool",
-    "array": "List",
-    "object": "Dict",
+    "array": "list",
+    "object": "dict",
     "function": "Callable",
     "void": "None",
 }
@@ -15,10 +15,13 @@ PYTHON_TO_JSONSCHEMA_TYPE_MAP = {
     "float": "number",
     "str": "string",
     "bool": "boolean",
-    "List": "array",
-    "Dict": "object",
+    "list": "array",
+    "dict": "object",
     "Callable": "function",
     "None": "void",
+    # Keep uppercase aliases for backwards compatibility
+    "List": "array",
+    "Dict": "object",
 }
 
 BASIC_PYTHON_TYPES = set(PYTHON_TO_JSONSCHEMA_TYPE_MAP.keys())

polyapi/execute.py

@@ -1,109 +1,224 @@
-from typing import Dict, Optional
-import requests
+import httpx
 import os
 import logging
-from requests import Response
 from polyapi.config import get_api_key_and_url, get_mtls_config
 from polyapi.exceptions import PolyApiException
+from polyapi import http_client
 
 logger = logging.getLogger("poly")
 
-def direct_execute(function_type, function_id, data) -> Response:
-    """ execute a specific function id/type
-    """
-    api_key, api_url = get_api_key_and_url()
-    headers = {"Authorization": f"Bearer {api_key}"}
-    url = f"{api_url}/functions/{function_type}/{function_id}/direct-execute"
-    
-    endpoint_info = requests.post(url, json=data, headers=headers)
-    if endpoint_info.status_code < 200 or endpoint_info.status_code >= 300:
-        error_content = endpoint_info.content.decode("utf-8", errors="ignore")
+def _check_response_error(resp, function_type, function_id, data):
+    if resp.status_code < 200 or resp.status_code >= 300:
+        error_content = resp.content.decode("utf-8", errors="ignore")
         if function_type == 'api' and os.getenv("LOGS_ENABLED"):
-            raise PolyApiException(f"Error executing api function with id: {function_id}. Status code: {endpoint_info.status_code}. Request data: {data}, Response: {error_content}")
+            logger.error(f"Error executing api function with id: {function_id}. Status code: {resp.status_code}. Request data: {data}, Response: {error_content}")
         elif function_type != 'api':
-            raise PolyApiException(f"{endpoint_info.status_code}: {error_content}")
-    
-    endpoint_info_data = endpoint_info.json()
+            raise PolyApiException(f"{resp.status_code}: {error_content}")
+
+
+def _check_endpoint_error(resp, function_type, function_id, data):
+    if resp.status_code < 200 or resp.status_code >= 300:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        if function_type == 'api' and os.getenv("LOGS_ENABLED"):
+            raise PolyApiException(f"Error executing api function with id: {function_id}. Status code: {resp.status_code}. Request data: {data}, Response: {error_content}")
+        elif function_type != 'api':
+            raise PolyApiException(f"{resp.status_code}: {error_content}")
+
+
+def _build_direct_execute_params(endpoint_info_data):
     request_params = endpoint_info_data.copy()
     request_params.pop("url", None)
-    
     if "maxRedirects" in request_params:
-        request_params["allow_redirects"] = request_params.pop("maxRedirects") > 0
-    
+        request_params["follow_redirects"] = request_params.pop("maxRedirects") > 0
+    return request_params
+
+
+def _sync_direct_execute(function_type, function_id, data) -> httpx.Response:
+    api_key, api_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{api_url}/functions/{function_type}/{function_id}/direct-execute"
+
+    endpoint_info = http_client.post(url, json=data, headers=headers)
+    _check_endpoint_error(endpoint_info, function_type, function_id, data)
+
+    endpoint_info_data = endpoint_info.json()
+    request_params = _build_direct_execute_params(endpoint_info_data)
+
     has_mtls, cert_path, key_path, ca_path = get_mtls_config()
-    
+
+    # Direct-execute hits URL that may need custom TLS
+    # settings (mTLS certs or disabled verification). httpx Client.request()
+    # doesn't accept per-request transport kwargs, so use one-off calls.
     if has_mtls:
-        resp = requests.request(
+        resp = httpx.request(
             url=endpoint_info_data["url"],
             cert=(cert_path, key_path),
             verify=ca_path,
+            timeout=None,
             **request_params
         )
     else:
-        resp = requests.request(
+        resp = httpx.request(
             url=endpoint_info_data["url"],
             verify=False,
+            timeout=None,
             **request_params
         )
 
-    if (resp.status_code < 200 or resp.status_code >= 300):
-        error_content = resp.content.decode("utf-8", errors="ignore")
-        if function_type == 'api' and os.getenv("LOGS_ENABLED"):
-            logger.error(f"Error executing api function with id: {function_id}. Status code: {resp.status_code}. Request data: {data}, Response: {error_content}")
-        elif function_type != 'api':   
-            raise PolyApiException(f"{resp.status_code}: {error_content}")    
-    
+    _check_response_error(resp, function_type, function_id, data)
+    return resp
+
+
+async def _async_direct_execute(function_type, function_id, data) -> httpx.Response:
+    api_key, api_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{api_url}/functions/{function_type}/{function_id}/direct-execute"
+
+    endpoint_info = await http_client.async_post(url, json=data, headers=headers)
+    _check_endpoint_error(endpoint_info, function_type, function_id, data)
+
+    endpoint_info_data = endpoint_info.json()
+    request_params = _build_direct_execute_params(endpoint_info_data)
+
+    has_mtls, cert_path, key_path, ca_path = get_mtls_config()
+
+    # One-off async client for custom TLS settings on external URLs.
+    if has_mtls:
+        async with httpx.AsyncClient(
+            cert=(cert_path, key_path), verify=ca_path, timeout=None
+        ) as client:
+            resp = await client.request(
+                url=endpoint_info_data["url"], **request_params
+            )
+    else:
+        async with httpx.AsyncClient(verify=False, timeout=None) as client:
+            resp = await client.request(
+                url=endpoint_info_data["url"], **request_params
+            )
+
+    _check_response_error(resp, function_type, function_id, data)
     return resp
 
-def execute(function_type, function_id, data) -> Response:
-    """ execute a specific function id/type
+
+def direct_execute(function_type, function_id, data) -> httpx.Response:
+    """ execute a specific function id/type (sync)
     """
+    return _sync_direct_execute(function_type, function_id, data)
+
+
+async def direct_execute_async(function_type, function_id, data) -> httpx.Response:
+    """ execute a specific function id/type (async)
+    """
+    return await _async_direct_execute(function_type, function_id, data)
+
+
+def _sync_execute(function_type, function_id, data) -> httpx.Response:
     api_key, api_url = get_api_key_and_url()
     headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{api_url}/functions/{function_type}/{function_id}/execute"
 
+    resp = http_client.post(url, json=data, headers=headers)
+    _check_response_error(resp, function_type, function_id, data)
+    return resp
+
+
+async def _async_execute(function_type, function_id, data) -> httpx.Response:
+    api_key, api_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
     url = f"{api_url}/functions/{function_type}/{function_id}/execute"
-    
-    # Make the request
-    resp = requests.post(
-        url, 
-        json=data, 
-        headers=headers,
-    )
-
-    if (resp.status_code < 200 or resp.status_code >= 300) and os.getenv("LOGS_ENABLED"):
-        error_content = resp.content.decode("utf-8", errors="ignore")
-        if function_type == 'api' and os.getenv("LOGS_ENABLED"):
-            logger.error(f"Error executing api function with id: {function_id}. Status code: {resp.status_code}. Request data: {data}, Response: {error_content}")
-        elif function_type != 'api':
-            raise PolyApiException(f"{resp.status_code}: {error_content}")
 
+    resp = await http_client.async_post(url, json=data, headers=headers)
+    _check_response_error(resp, function_type, function_id, data)
     return resp
 
 
-def execute_post(path, data):
+def execute(function_type, function_id, data) -> httpx.Response:
+    """ execute a specific function id/type (sync)
+    """
+    return _sync_execute(function_type, function_id, data)
+
+
+async def execute_async(function_type, function_id, data) -> httpx.Response:
+    """ execute a specific function id/type (async)
+    """
+    return await _async_execute(function_type, function_id, data)
+
+
+def _sync_execute_post(path, data):
+    api_key, api_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    return http_client.post(api_url + path, json=data, headers=headers)
+
+
+async def _async_execute_post(path, data):
     api_key, api_url = get_api_key_and_url()
     headers = {"Authorization": f"Bearer {api_key}"}
-    resp = requests.post(api_url + path, json=data, headers=headers)
+    return await http_client.async_post(api_url + path, json=data, headers=headers)
+
+
+def execute_post(path, data):
+    return _sync_execute_post(path, data)
+
+
+async def execute_post_async(path, data):
+    return await _async_execute_post(path, data)
+
+
+def _sync_variable_get(variable_id: str) -> httpx.Response:
+    api_key, base_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{base_url}/variables/{variable_id}/value"
+    resp = http_client.get(url, headers=headers)
+    if resp.status_code != 200 and resp.status_code != 201:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
     return resp
 
 
-def variable_get(variable_id: str) -> Response:
+async def _async_variable_get(variable_id: str) -> httpx.Response:
     api_key, base_url = get_api_key_and_url()
     headers = {"Authorization": f"Bearer {api_key}"}
     url = f"{base_url}/variables/{variable_id}/value"
-    resp = requests.get(url, headers=headers)
+    resp = await http_client.async_get(url, headers=headers)
     if resp.status_code != 200 and resp.status_code != 201:
         error_content = resp.content.decode("utf-8", errors="ignore")
         raise PolyApiException(f"{resp.status_code}: {error_content}")
     return resp
 
 
-def variable_update(variable_id: str, value) -> Response:
+def variable_get(variable_id: str) -> httpx.Response:
+    return _sync_variable_get(variable_id)
+
+
+async def variable_get_async(variable_id: str) -> httpx.Response:
+    return await _async_variable_get(variable_id)
+
+
+def _sync_variable_update(variable_id: str, value) -> httpx.Response:
     api_key, base_url = get_api_key_and_url()
     headers = {"Authorization": f"Bearer {api_key}"}
     url = f"{base_url}/variables/{variable_id}"
-    resp = requests.patch(url, data={"value": value}, headers=headers)
+    resp = http_client.patch(url, data={"value": value}, headers=headers)
     if resp.status_code != 200 and resp.status_code != 201:
         error_content = resp.content.decode("utf-8", errors="ignore")
         raise PolyApiException(f"{resp.status_code}: {error_content}")
-    return resp
+    return resp
+
+
+async def _async_variable_update(variable_id: str, value) -> httpx.Response:
+    api_key, base_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{base_url}/variables/{variable_id}"
+    resp = await http_client.async_patch(url, data={"value": value}, headers=headers)
+    if resp.status_code != 200 and resp.status_code != 201:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
+    return resp
+
+
+def variable_update(variable_id: str, value) -> httpx.Response:
+    return _sync_variable_update(variable_id, value)
+
+
+async def variable_update_async(variable_id: str, value) -> httpx.Response:
+    return await _async_variable_update(variable_id, value)

polyapi/function_cli.py

@@ -1,7 +1,6 @@
 import sys
 from typing import Any, List, Optional
-import requests
-
+from polyapi import http_client
 from polyapi.config import get_api_key_and_url
 from polyapi.utils import get_auth_headers, print_green, print_red, print_yellow
 from polyapi.parser import parse_function_code, get_jsonschema_type
@@ -87,7 +86,7 @@ def function_add_or_update(
         sys.exit(1)
 
     headers = get_auth_headers(api_key)
-    resp = requests.post(url, headers=headers, json=data)
+    resp = http_client.post(url, headers=headers, json=data)
     if resp.status_code in [200, 201]:
         print_green("DEPLOYED")
         function_id = resp.json()["id"]
@@ -126,5 +125,5 @@ def spec_delete(function_type: str, function_id: str):
         print(f"Unknown function type: {function_type}")
         sys.exit(1)
     headers = get_auth_headers(api_key)
-    resp = requests.delete(url, headers=headers)
+    resp = http_client.delete(url, headers=headers)
     return resp

polyapi/generate.py

@@ -1,5 +1,4 @@
 import json
-import requests
 import os
 import uuid
 import shutil
@@ -20,6 +19,7 @@ from .server import render_server_function
 from .utils import add_import_to_init, get_auth_headers, init_the_init, print_green, to_func_namespace
 from .variables import generate_variables
 from .poly_tables import generate_tables
+from . import http_client
 from .config import get_api_key_and_url, get_direct_execute_config, get_cached_generate_args
 
 SUPPORTED_FUNCTION_TYPES = {
@@ -62,7 +62,7 @@ def get_specs(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
     if get_direct_execute_config():
         params["apiFunctionDirectExecute"] = "true"
 
-    resp = requests.get(url, headers=headers, params=params)
+    resp = http_client.get(url, headers=headers, params=params)
     if resp.status_code == 200:
         return resp.json()
     else:

polyapi/http_client.py

@@ -0,0 +1,73 @@
+import asyncio
+import httpx
+
+_sync_client: httpx.Client | None = None
+_async_client: httpx.AsyncClient | None = None
+
+
+def _get_sync_client() -> httpx.Client:
+    global _sync_client
+    if _sync_client is None:
+        _sync_client = httpx.Client(timeout=None)
+    return _sync_client
+
+
+def _get_async_client() -> httpx.AsyncClient:
+    global _async_client
+    if _async_client is None:
+        _async_client = httpx.AsyncClient(timeout=None)
+    return _async_client
+
+
+def post(url, **kwargs) -> httpx.Response:
+    return _get_sync_client().post(url, **kwargs)
+
+
+async def async_post(url, **kwargs) -> httpx.Response:
+    return await _get_async_client().post(url, **kwargs)
+
+
+def get(url, **kwargs) -> httpx.Response:
+    return _get_sync_client().get(url, **kwargs)
+
+
+async def async_get(url, **kwargs) -> httpx.Response:
+    return await _get_async_client().get(url, **kwargs)
+
+
+def patch(url, **kwargs) -> httpx.Response:
+    return _get_sync_client().patch(url, **kwargs)
+
+
+async def async_patch(url, **kwargs) -> httpx.Response:
+    return await _get_async_client().patch(url, **kwargs)
+
+
+def delete(url, **kwargs) -> httpx.Response:
+    return _get_sync_client().delete(url, **kwargs)
+
+
+async def async_delete(url, **kwargs) -> httpx.Response:
+    return await _get_async_client().delete(url, **kwargs)
+
+
+def request(method, url, **kwargs) -> httpx.Response:
+    return _get_sync_client().request(method, url, **kwargs)
+
+
+async def async_request(method, url, **kwargs) -> httpx.Response:
+    return await _get_async_client().request(method, url, **kwargs)
+
+
+def close():
+    global _sync_client
+    if _sync_client is not None:
+        _sync_client.close()
+        _sync_client = None
+
+async def close_async():
+    global _sync_client, _async_client
+    close()
+    if _async_client is not None:
+        await _async_client.aclose()
+        _async_client = None

polyapi/poly_tables.py

@@ -1,5 +1,5 @@
 import os
-import requests
+from polyapi import http_client
 from typing_extensions import NotRequired, TypedDict
 from typing import (
     List,
@@ -88,7 +88,7 @@ def execute_query(table_id, method, query):
         headers = {"x-poly-execution-id": polyCustom.get("executionId")}
         if auth_key:
             headers["Authorization"] = f"Bearer {auth_key}"
-        response = requests.post(url, json=query, headers=headers)
+        response = http_client.post(url, json=query, headers=headers)
         response.raise_for_status()
         return response.json()
     except Exception as e:

polyapi/prepare.py

@@ -2,8 +2,7 @@ import os
 import sys
 import subprocess
 from typing import List, Tuple, Literal
-import requests
-
+from polyapi import http_client
 from polyapi.utils import get_auth_headers
 from polyapi.config import get_api_key_and_url
 from polyapi.parser import parse_function_code
@@ -32,7 +31,7 @@ def get_server_function_description(description: str, arguments, code: str) -> s
     api_key, api_url = get_api_key_and_url()
     headers = get_auth_headers(api_key)
     data = {"description": description, "arguments": arguments, "code": code}
-    response = requests.post(f"{api_url}/functions/server/description-generation", headers=headers, json=data)
+    response = http_client.post(f"{api_url}/functions/server/description-generation", headers=headers, json=data)
     return response.json()
 
 def get_client_function_description(description: str, arguments, code: str) -> str:
@@ -40,7 +39,7 @@ def get_client_function_description(description: str, arguments, code: str) -> s
     headers = get_auth_headers(api_key)
     # Simulated API call to generate client function descriptions
     data = {"description": description, "arguments": arguments, "code": code}
-    response = requests.post(f"{api_url}/functions/client/description-generation", headers=headers, json=data)
+    response = http_client.post(f"{api_url}/functions/client/description-generation", headers=headers, json=data)
     return response.json()
 
 def fill_in_missing_function_details(deployable: DeployableRecord, code: str) -> DeployableRecord:

polyapi/rendered_spec.py

@@ -1,7 +1,7 @@
 import os
 from typing import Optional
 
-import requests
+from polyapi import http_client
 from polyapi.config import get_api_key_and_url
 from polyapi.generate import read_cached_specs, render_spec
 from polyapi.typedefs import SpecificationDto
@@ -31,7 +31,7 @@ def update_rendered_spec(spec: SpecificationDto):
 
     url = f"{base_url}/functions/rendered-specs"
     headers = {"Authorization": f"Bearer {api_key}"}
-    resp = requests.post(url, json=data, headers=headers)
+    resp = http_client.post(url, json=data, headers=headers)
     assert resp.status_code == 201, (resp.text, resp.status_code)
 
 
@@ -40,7 +40,7 @@ def _get_spec(spec_id: str, no_types: bool = False) -> Optional[SpecificationDto
     url = f"{base_url}/specs"
     headers = {"Authorization": f"Bearer {api_key}"}
     params = {"noTypes": str(no_types).lower()}
-    resp = requests.get(url, headers=headers, params=params)
+    resp = http_client.get(url, headers=headers, params=params)
     if resp.status_code == 200:
         specs = resp.json()
         for spec in specs:

polyapi/server.py

@@ -24,6 +24,20 @@ def {function_name}(
         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
+
+
 """
 
 

polyapi/sync.py

@@ -2,8 +2,7 @@ import os
 from datetime import datetime
 from typing import List, Dict
 from typing_extensions import cast # type: ignore
-import requests
-
+from polyapi import http_client
 from polyapi.utils import get_auth_headers
 from polyapi.config import get_api_key_and_url
 from polyapi.parser import get_jsonschema_type
@@ -35,10 +34,10 @@ def remove_deployable_function(deployable: SyncDeployment) -> bool:
         raise Exception("Missing api key!")
     headers = get_auth_headers(api_key)
     url = f'{deployable["instance"]}/functions/{deployable["type"].replace("-function", "")}/{deployable["id"]}'
-    response = requests.get(url, headers=headers)
+    response = http_client.get(url, headers=headers)
     if response.status_code != 200:
         return False
-    requests.delete(url, headers=headers)
+    http_client.delete(url, headers=headers)
     return True
 
 def remove_deployable(deployable: SyncDeployment) -> bool:
@@ -65,7 +64,7 @@ def sync_function_and_get_id(deployable: SyncDeployment, code: str) -> str:
         "returnTypeSchema": deployable["types"]["returns"]["typeSchema"],
         "arguments": [{**p, "key": p["name"], "type": get_jsonschema_type(p["type"])  } for p in deployable["types"]["params"]],
     }
-    response = requests.post(url, headers=headers, json=payload)
+    response = http_client.post(url, headers=headers, json=payload)
     response.raise_for_status()
     return response.json()['id']
 

polyapi/utils.py

@@ -16,7 +16,7 @@ from polyapi.schema import (
 
 # this string should be in every __init__ file.
 # it contains all the imports needed for the function or variable code to run
-CODE_IMPORTS = "from typing import List, Dict, Any, Optional, Callable\nfrom typing_extensions import TypedDict, NotRequired\nimport logging\nimport requests\nimport socketio  # type: ignore\nfrom polyapi.config import get_api_key_and_url, get_direct_execute_config\nfrom polyapi.execute import execute, execute_post, variable_get, variable_update, direct_execute\n\n"
+CODE_IMPORTS = "from typing import List, Dict, Any, Optional, Callable\nfrom typing_extensions import TypedDict, NotRequired\nimport logging\nimport requests\nimport socketio  # type: ignore\nfrom polyapi.config import get_api_key_and_url, get_direct_execute_config\nfrom polyapi.execute import execute, execute_async, execute_post, execute_post_async, variable_get, variable_get_async, variable_update, variable_update_async, direct_execute, direct_execute_async\n\n"
 
 
 def init_the_init(full_path: str, code_imports: Optional[str] = None) -> None:
@@ -73,7 +73,6 @@ def print_red(s: str):
 
 def add_type_import_path(function_name: str, arg: str) -> str:
     """if not basic type, coerce to camelCase and add the import path"""
-    # outdated og comment - for now, just treat Callables as basic types 
     # from now, we start qualifying non-basic types :)) 
     # e.g. Callable[[EmailAddress, Dict, Dict, Dict], None]
         # becomes Callable[[Set_profile_email.EmailAddress, Dict, Dict, Dict], None]

polyapi/variables.py

@@ -15,6 +15,11 @@ GET_TEMPLATE = """
     def get() -> {variable_type}:
         resp = variable_get("{variable_id}")
         return resp.text
+
+    @staticmethod
+    async def get_async() -> {variable_type}:
+        resp = await variable_get_async("{variable_id}")
+        return resp.text
 """
 
 
@@ -30,6 +35,11 @@ class {variable_name}:{get_method}
         resp = variable_update("{variable_id}", value)
         return resp.json()
 
+    @staticmethod
+    async def update_async(value: {variable_type}):
+        resp = await variable_update_async("{variable_id}", value)
+        return resp.json()
+
     @classmethod
     async def onUpdate(cls, callback):
         api_key, base_url = get_api_key_and_url()

{polyapi_python-0.3.13.dev3.dist-info → polyapi_python-0.3.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.13.dev3
+Version: 0.3.14
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
@@ -30,12 +30,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.32.3
 Requires-Dist: typing_extensions>=4.12.2
-Requires-Dist: jsonschema-gentypes==2.6.0
-Requires-Dist: pydantic>=2.8.0
-Requires-Dist: stdlib_list>=0.10.0
+Requires-Dist: jsonschema-gentypes==2.10.0
+Requires-Dist: pydantic<3.0.0,>=2.8.0
+Requires-Dist: stdlib_list<1.0.0,>=0.10.0
 Requires-Dist: colorama==0.4.4
 Requires-Dist: python-socketio[asyncio_client]==5.11.1
 Requires-Dist: truststore>=0.8.0
+Requires-Dist: httpx>=0.28.1
 Dynamic: license-file
 
 # PolyAPI Python Library
@@ -185,6 +186,14 @@ This script is handy for checking for any mypy types:
 
 Please ignore \[name-defined\] errors for now. This is a known bug we are working to fix!
 
+## Strategies for QA'ing Changes To Generate Or Other Core Functionality
+
+Our https://na1.polyapi.io has a large OOB catalog (as does eu1/na2). We also have several big internal PolyAPI projects with Python (message @eupharis if you need a pointer to which ones).
+
+Running `python -m polyapi generate` in all these projects and then checking the flake8 and check_mypy steps above is a great way to build confidence that the `generate` changes has no gotchas.
+
+Of course all this is in addition to the changes passing through normal unittests and integration tests!
+
 ## Support
 
 If you run into any issues or want help getting started with this project, please contact support@polyapi.io

polyapi_python-0.3.14.dist-info/RECORD

@@ -0,0 +1,34 @@
+polyapi/__init__.py,sha256=vV1N9xtIMtpi4o-2jAI3775LkzRbC9JUo87MAnW9zgo,5201
+polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
+polyapi/api.py,sha256=CzqX99GekhQJVqAAWlL03hUenIi_5iTln9cWgQzz6Ko,2784
+polyapi/auth.py,sha256=l0pGAoYvEWqa2TMsrM9GS8imXu3GsWvpn4eFPy1vksI,6195
+polyapi/cli.py,sha256=lWHm2yNx8LELtCqUQOY_N7e8QTa7fM0ZZgC5d2h3E3E,11055
+polyapi/cli_constants.py,sha256=eZnAqAo8HLxHH3cdAoGWbrsALAtEWJFXRdSS2lvQvzE,144
+polyapi/client.py,sha256=DW6ljG_xCwAo2yz23A9QfLooE6ZUDvSpdA4e_dCQjiQ,1418
+polyapi/config.py,sha256=dnowfPKEau5sA4zwBzLK_dYAHA-Wi3AOnMtDNsYwUmM,7520
+polyapi/constants.py,sha256=i3j0-ptd7XEs6ovnYegEhiP0BRs1JSKAq1oE5CWbDVo,707
+polyapi/deployables.py,sha256=njmqTU0W7d3JdDWhjjjr2UOghEv4bTKUN-3ztJvcC7o,12233
+polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
+polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
+polyapi/execute.py,sha256=MeAmc5qsMQfnQPiHJK9Khkn_wrBxMoyMYYqmuFFPsRg,8779
+polyapi/function_cli.py,sha256=kKrecKCDNMmYtcOOCVF2KKOGjFUfWD2TbiVsyYQ84y8,4323
+polyapi/generate.py,sha256=TjMlxxjWN1WnFEmOjSygFcl9RkHCZeCq79R-K_7GYRU,21059
+polyapi/http_client.py,sha256=dfsfFzHlhScQgYMf3zJshJJCwgJGQqM8B5peY9O4NPU,1872
+polyapi/parser.py,sha256=pAkeuwp1Kn6bHXiIoj-DuXQ518PztQThIa8vztgsKLQ,21525
+polyapi/poly_schemas.py,sha256=fZ6AGvHcOKQJtlrzSuzeBNed5DxPMA2dJGdJvuFCHWM,9066
+polyapi/poly_tables.py,sha256=T07j4H-HdcIFP5HwUq0uljpzzYzMtJvdqYvOdC0oZ4I,19728
+polyapi/prepare.py,sha256=DBlrQu_A0PqdaQ3KlMs-C6PkV3qncatkAiBlC7j2hnk,7441
+polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polyapi/rendered_spec.py,sha256=J2Num7MXnW_mKAe2MSVIL1coWopNYZ-6nNNwQRfseV0,2262
+polyapi/schema.py,sha256=-mtRV5iL3CV0X3phXhGYFV8sLz0KouTACOKWyGO9Pwc,5309
+polyapi/server.py,sha256=35l3f9d6jWaa60MfX5n7KF4UCAQR-Xg8WLc0NL9dlfY,2479
+polyapi/sync.py,sha256=t0Khh8B5GylxB7KWRP_xvkrvkuyVarSLCOvtmaz7lcc,6766
+polyapi/typedefs.py,sha256=mfll-KrngOW0wzbvDNiIDaDkFMwbsT-MY5y5hzWj9RE,5642
+polyapi/utils.py,sha256=VN8n_jvphderplI5MDYjSutxVnYbJjHhJznYkwjgstw,13349
+polyapi/variables.py,sha256=hfSDPGQK6YphNCa9MqE0W88WIFfqCQWgpBDWkExMq-A,7582
+polyapi/webhook.py,sha256=0ceLwHNjNd2Yx_8MX5jOIxiQ5Lwhy2pe81ProAuKon0,5108
+polyapi_python-0.3.14.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
+polyapi_python-0.3.14.dist-info/METADATA,sha256=izYlYFrUE0QxKGNOyl72BBMHXa5a2go9gRX7KCa50JQ,5923
+polyapi_python-0.3.14.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+polyapi_python-0.3.14.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
+polyapi_python-0.3.14.dist-info/RECORD,,

{polyapi_python-0.3.13.dev3.dist-info → polyapi_python-0.3.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.0)
+Generator: setuptools (82.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

polyapi_python-0.3.13.dev3.dist-info/RECORD

@@ -1,32 +0,0 @@
-polyapi/__init__.py,sha256=hw7x4j9JNJfPdkIOZqV0X9pbYcw3_5AH1iQFdSogH-c,3235
-polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
-polyapi/api.py,sha256=2nds6ZdNe9OHvCba4IjOPga0CAYIsib2SbhEyDDCmd8,2188
-polyapi/auth.py,sha256=EGstBjTSdAydI5hGAHeRRc1GcmHshogudb3sxCgO6zA,5341
-polyapi/cli.py,sha256=3M6XpMhpvQSHq4X8tBsq7N93YEwyVIqNFkz1tx_6aSs,11107
-polyapi/client.py,sha256=DW6ljG_xCwAo2yz23A9QfLooE6ZUDvSpdA4e_dCQjiQ,1418
-polyapi/config.py,sha256=dnowfPKEau5sA4zwBzLK_dYAHA-Wi3AOnMtDNsYwUmM,7520
-polyapi/constants.py,sha256=sc-FnS0SngBLvSu1ZWMs0UCf9EYD1u1Yhfr-sZXGLns,607
-polyapi/deployables.py,sha256=njmqTU0W7d3JdDWhjjjr2UOghEv4bTKUN-3ztJvcC7o,12233
-polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
-polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
-polyapi/execute.py,sha256=q4xtV6rYO8f-8hULlFTlVgoTVQSahvlMu3FHkFzYpMs,4423
-polyapi/function_cli.py,sha256=W30yL2i152iZCr6zAU1CHKlDp_tt7kB2cGIXIxmWumk,4302
-polyapi/generate.py,sha256=0zVDEnKVZnbMNZ6O0SWAuDLHrBrkW01vFkjpf9wrQZo,21046
-polyapi/parser.py,sha256=pAkeuwp1Kn6bHXiIoj-DuXQ518PztQThIa8vztgsKLQ,21525
-polyapi/poly_schemas.py,sha256=fZ6AGvHcOKQJtlrzSuzeBNed5DxPMA2dJGdJvuFCHWM,9066
-polyapi/poly_tables.py,sha256=jwJpd_QBoIaFPcQRpCaxdwr82fIPHnTjj2-a9knNmJs,19709
-polyapi/prepare.py,sha256=NQzpMIoakNovStvOGOmqSYIpTwiWXaweNSE9se10A2E,7420
-polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polyapi/rendered_spec.py,sha256=nJEj2vRgG3N20fU4s-ThRtOIwAuTzXwXuOBIkXljDVc,2240
-polyapi/schema.py,sha256=-mtRV5iL3CV0X3phXhGYFV8sLz0KouTACOKWyGO9Pwc,5309
-polyapi/server.py,sha256=YXWxhYBx-hluwDQ8Jvfpy2s8ogz0GsNTMcZVNcP5ca8,2147
-polyapi/sync.py,sha256=52ODc82jBJpbNYTB9zXlrVZLR39iwDPW3cuIC3P8dbM,6742
-polyapi/typedefs.py,sha256=mfll-KrngOW0wzbvDNiIDaDkFMwbsT-MY5y5hzWj9RE,5642
-polyapi/utils.py,sha256=CZdGusrLOA-e4zb9aZ4aI-UkDPBoyu0-euWj7EE0Vk8,13323
-polyapi/variables.py,sha256=SJv106ePpQP5mx7Iiafl_shtFlE8FoaO9Q8lvw-3IRg,7270
-polyapi/webhook.py,sha256=0ceLwHNjNd2Yx_8MX5jOIxiQ5Lwhy2pe81ProAuKon0,5108
-polyapi_python-0.3.13.dev3.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
-polyapi_python-0.3.13.dev3.dist-info/METADATA,sha256=mMara9mTQNrc7bNgKRQpSkkeCUzBx0YfXM3SXhO5W94,5318
-polyapi_python-0.3.13.dev3.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-polyapi_python-0.3.13.dev3.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
-polyapi_python-0.3.13.dev3.dist-info/RECORD,,