Road to R23 🚀

.gitignore

@@ -1,7 +1,5 @@
-.env
-.env*
-.venv/
-.venv/*
+*env
+*venv
 .DS_Store
 
 # Pip

polyapi/__init__.py

@@ -1,7 +1,9 @@
 import os
 import sys
+import copy
 import truststore
-from typing import Dict, Any
+from typing import Any, Dict, Optional, overload, Literal
+from typing_extensions import TypedDict
 truststore.inject_into_ssl()
 from .cli import CLI_COMMANDS
 
@@ -15,9 +17,85 @@
         sys.exit(1)
 
 
-polyCustom: Dict[str, Any] = {
-    "executionId": None,
-    "executionApiKey": None,
-    "responseStatusCode": 200,
-    "responseContentType": None,
-}
+class PolyCustomDict(TypedDict, total=False):
+    """Type definition for polyCustom dictionary."""
+    executionId: Optional[str]  # Read-only
+    executionApiKey: Optional[str]
+    responseStatusCode: 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
+
+    def set_once(self, key: str, value: Any) -> None:
+        if key == "executionId" and self._execution_id_locked:
+            # Silently ignore attempts to overwrite locked executionId
+            return
+        self._internal_store[key] = value
+        if key == "executionId":
+            # Lock executionId after setting it
+            self.lock_execution_id()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._internal_store.get(key, default)
+
+    def lock_execution_id(self) -> None:
+        self._execution_id_locked = True
+
+    def unlock_execution_id(self) -> None:
+        self._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: ...
+
+    @overload
+    def __getitem__(self, key: Literal["responseContentType"]) -> Optional[str]: ...
+
+    @overload
+    def __getitem__(self, key: Literal["responseHeaders"]) -> Dict[str, str]: ...
+
+    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["responseStatusCode"], value: 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: str, value: Any) -> None:
+        self.set_once(key, value)
+
+    def __repr__(self) -> str:
+        return f"PolyCustom({self._internal_store})"
+
+    def copy(self) -> '_PolyCustom':
+        new = _PolyCustom()
+        new._internal_store = copy.deepcopy(self._internal_store)
+        new._execution_id_locked = self._execution_id_locked
+        return new
+
+
+polyCustom: PolyCustomDict = _PolyCustom()

polyapi/api.py

@@ -23,8 +23,16 @@ def {function_name}(
 
     Function ID: {function_id}
     \"""
-    resp = execute("{function_type}", "{function_id}", {data})
-    return {api_response_type}(resp.json())  # type: ignore
+    if get_direct_execute_config():
+        resp = direct_execute("{function_type}", "{function_id}", {data})
+        return {api_response_type}({{
+            "status": resp.status_code,
+            "headers": dict(resp.headers),
+            "data": resp.json()
+        }})  # type: ignore
+    else:
+        resp = execute("{function_type}", "{function_id}", {data})
+        return {api_response_type}(resp.json())  # type: ignore
 
 
 """

polyapi/cli.py

@@ -44,10 +44,13 @@ def setup(args):
     ###########################################################################
     # Generate command
     generate_parser = subparsers.add_parser("generate", help="Generates Poly library")
+    generate_parser.add_argument("--no-types", action="store_true", help="Generate SDK without type definitions")
+    generate_parser.add_argument("--contexts", type=str, required=False, help="Contexts to generate")
 
     def generate_command(args):
         initialize_config()
-        generate()
+        contexts = args.contexts.split(",") if args.contexts else None
+        generate(contexts=contexts, no_types=args.no_types)
 
     generate_parser.set_defaults(command=generate_command)
 
@@ -68,6 +71,7 @@ def generate_command(args):
     fn_add_parser.add_argument("--logs", choices=["enabled", "disabled"], default=None, help="Enable or disable logs for the function.")
     fn_add_parser.add_argument("--execution-api-key", required=False, default="", help="API key for execution (for server functions only).")
     fn_add_parser.add_argument("--disable-ai", "--skip-generate", action="store_true", help="Pass --disable-ai skip AI generation of missing descriptions")
+    fn_add_parser.add_argument("--generate-contexts", type=str, help="Server function only – only include certain contexts to speed up function execution")
 
     def add_function(args):
         initialize_config()
@@ -79,6 +83,8 @@ def add_function(args):
             err = "You must specify `--server` or `--client`."
         elif logs_enabled and not args.server:
             err = "Option `logs` is only for server functions (--server)."
+        elif args.generate_contexts and not args.server:
+            err = "Option `generate-contexts` is only for server functions (--server)."
 
         if err:
             print_red("ERROR")
@@ -94,7 +100,8 @@ def add_function(args):
             server=args.server,
             logs_enabled=logs_enabled,
             generate=not args.disable_ai,
-            execution_api_key=args.execution_api_key
+            execution_api_key=args.execution_api_key,
+            generate_contexts=args.generate_contexts
         )
 
     fn_add_parser.set_defaults(command=add_function)

polyapi/config.py

@@ -3,11 +3,15 @@
 import configparser
 from typing import Tuple
 
-from polyapi.utils import is_valid_polyapi_url, is_valid_uuid, print_green, print_yellow
+from polyapi.utils import is_valid_polyapi_url, print_green, print_yellow
 
 # cached values
 API_KEY = None
 API_URL = None
+API_FUNCTION_DIRECT_EXECUTE = None
+MTLS_CERT_PATH = None
+MTLS_KEY_PATH = None
+MTLS_CA_PATH = None
 
 
 def get_config_file_path() -> str:
@@ -45,6 +49,13 @@ def get_api_key_and_url() -> Tuple[str | None, str | None]:
         API_KEY = key
         API_URL = url
 
+        # Read and cache MTLS and direct execute settings
+        global API_FUNCTION_DIRECT_EXECUTE, MTLS_CERT_PATH, MTLS_KEY_PATH, MTLS_CA_PATH
+        API_FUNCTION_DIRECT_EXECUTE = config.get("polyapi", "api_function_direct_execute", fallback="false").lower() == "true"
+        MTLS_CERT_PATH = config.get("polyapi", "mtls_cert_path", fallback=None)
+        MTLS_KEY_PATH = config.get("polyapi", "mtls_key_path", fallback=None)
+        MTLS_CA_PATH = config.get("polyapi", "mtls_ca_path", fallback=None)
+
     return key, url
 
 
@@ -78,8 +89,6 @@ def initialize_config(force=False):
             errors = []
             if not is_valid_polyapi_url(url):
                 errors.append(f"{url} is not a valid Poly API Base URL")
-            if not is_valid_uuid(key):
-                errors.append(f"{key} is not a valid Poly App Key or User Key")
             if errors:
                 print_yellow("\n".join(errors))
                 sys.exit(1)
@@ -106,4 +115,22 @@ def clear_config():
 
     path = get_config_file_path()
     if os.path.exists(path):
-        os.remove(path)
+        os.remove(path)
+
+
+def get_mtls_config() -> Tuple[bool, str | None, str | None, str | None]:
+    """Return MTLS configuration settings"""
+    global MTLS_CERT_PATH, MTLS_KEY_PATH, MTLS_CA_PATH
+    if MTLS_CERT_PATH is None or MTLS_KEY_PATH is None or MTLS_CA_PATH is None:
+        # Force a config read if values aren't cached
+        get_api_key_and_url()
+    return bool(MTLS_CERT_PATH and MTLS_KEY_PATH and MTLS_CA_PATH), MTLS_CERT_PATH, MTLS_KEY_PATH, MTLS_CA_PATH
+
+
+def get_direct_execute_config() -> bool:
+    """Return whether direct execute is enabled"""
+    global API_FUNCTION_DIRECT_EXECUTE
+    if API_FUNCTION_DIRECT_EXECUTE is None:
+        # Force a config read if value isn't cached
+        get_api_key_and_url()
+    return bool(API_FUNCTION_DIRECT_EXECUTE)

polyapi/execute.py

@@ -1,26 +1,68 @@
-from typing import Dict
+from typing import Dict, Optional
 import requests
 from requests import Response
-from polyapi.config import get_api_key_and_url
+from polyapi.config import get_api_key_and_url, get_mtls_config
 from polyapi.exceptions import PolyApiException
 
+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:
+        raise PolyApiException(f"{endpoint_info.status_code}: {endpoint_info.content.decode('utf-8', errors='ignore')}")
+
+    endpoint_info_data = endpoint_info.json()
+    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
+
+    has_mtls, cert_path, key_path, ca_path = get_mtls_config()
+
+    if has_mtls:
+        resp = requests.request(
+            url=endpoint_info_data["url"],
+            cert=(cert_path, key_path),
+            verify=ca_path,
+            **request_params
+        )
+    else:
+        resp = requests.request(
+            url=endpoint_info_data["url"],
+            verify=False,
+            **request_params
+        )
+
+    if resp.status_code < 200 or resp.status_code >= 300:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
+
+    return resp
 
 def execute(function_type, function_id, data) -> Response:
     """ execute a specific function id/type
     """
-    data_without_None = data
-    if isinstance(data, Dict):
-        data_without_None = {k: v for k, v in data.items() if v is not None}
-
     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 = requests.post(url, json=data_without_None, headers=headers)
-    # print(resp.status_code)
-    # print(resp.headers["content-type"])
+
+    # Make the request
+    resp = requests.post(
+        url, 
+        json=data, 
+        headers=headers,
+    )
+
     if resp.status_code < 200 or resp.status_code >= 300:
         error_content = resp.content.decode("utf-8", errors="ignore")
         raise PolyApiException(f"{resp.status_code}: {error_content}")
+
     return resp
 
 

polyapi/function_cli.py

@@ -24,6 +24,7 @@ def function_add_or_update(
     client: bool,
     server: bool,
     logs_enabled: Optional[bool],
+    generate_contexts: Optional[str],
     generate: bool = True,
     execution_api_key: str = ""
 ):
@@ -59,6 +60,9 @@ def function_add_or_update(
         "logsEnabled": logs_enabled,
     }
 
+    if generate_contexts:
+        data["generateContexts"] = generate_contexts.split(",")
+
     if server and parsed["dependencies"]:
         print_yellow(
             "\nPlease note that deploying your functions will take a few minutes because it makes use of libraries other than polyapi."
@@ -82,7 +86,7 @@ def function_add_or_update(
 
     headers = get_auth_headers(api_key)
     resp = requests.post(url, headers=headers, json=data)
-    if resp.status_code == 201:
+    if resp.status_code in [200, 201]:
         print_green("DEPLOYED")
         function_id = resp.json()["id"]
         print(f"Function ID: {function_id}")