polyapi-python 0.3.13.dev2__tar.gz → 0.3.14.dev1__tar.gz

{polyapi_python-0.3.13.dev2/polyapi_python.egg-info → polyapi_python-0.3.14.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.13.dev2
+Version: 0.3.14.dev1
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
@@ -36,6 +36,7 @@ Requires-Dist: stdlib_list>=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.13.dev2 → polyapi_python-0.3.14.dev1}/README.md

@@ -145,6 +145,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.13.dev2 → polyapi_python-0.3.14.dev1}/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_python-0.3.13.dev2 → polyapi_python-0.3.14.dev1}/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_python-0.3.14.dev1/polyapi/execute.py

@@ -0,0 +1,224 @@
+import httpx
+import os
+import logging
+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 _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"):
+            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}")
+
+
+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["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 = httpx.request(
+            url=endpoint_info_data["url"],
+            cert=(cert_path, key_path),
+            verify=ca_path,
+            timeout=None,
+            **request_params
+        )
+    else:
+        resp = httpx.request(
+            url=endpoint_info_data["url"],
+            verify=False,
+            timeout=None,
+            **request_params
+        )
+
+    _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 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"
+
+    resp = await http_client.async_post(url, json=data, headers=headers)
+    _check_response_error(resp, function_type, function_id, data)
+    return resp
+
+
+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}"}
+    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
+
+
+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 = 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_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 = 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
+
+
+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_python-0.3.13.dev2 → polyapi_python-0.3.14.dev1}/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_python-0.3.13.dev2 → polyapi_python-0.3.14.dev1}/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_python-0.3.14.dev1/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