polyapi-python 0.3.6.dev0__tar.gz → 0.3.7__tar.gz

{polyapi_python-0.3.6.dev0/polyapi_python.egg-info → polyapi_python-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.6.dev0
+Version: 0.3.7
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License

polyapi_python-0.3.7/polyapi/__init__.py

@@ -0,0 +1,101 @@
+import os
+import sys
+import copy
+import truststore
+from typing import Any, Dict, Optional, overload, Literal
+from typing_extensions import TypedDict
+truststore.inject_into_ssl()
+from .cli import CLI_COMMANDS
+
+__all__ = ["poly"]
+
+
+if len(sys.argv) > 1 and sys.argv[1] not in CLI_COMMANDS:
+    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)
+
+
+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_python-0.3.6.dev0 → polyapi_python-0.3.7}/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_python-0.3.6.dev0 → polyapi_python-0.3.7}/polyapi/config.py

@@ -8,6 +8,10 @@ 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
 
 
@@ -104,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_python-0.3.6.dev0 → polyapi_python-0.3.7}/polyapi/execute.py

@@ -1,22 +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
     """
     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, 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_python-0.3.6.dev0 → polyapi_python-0.3.7}/polyapi/function_cli.py

@@ -86,13 +86,12 @@ 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}")
         if generate:
-            contexts=generate_contexts.split(",") if generate_contexts else None
-            generate_library(contexts=contexts)
+            generate_library()
     else:
         print("Error adding function.")
         print(resp.status_code)

{polyapi_python-0.3.6.dev0 → polyapi_python-0.3.7}/polyapi/generate.py

@@ -14,7 +14,7 @@ from .api import render_api_function
 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 .config import get_api_key_and_url
+from .config import get_api_key_and_url, get_direct_execute_config
 
 SUPPORTED_FUNCTION_TYPES = {
     "apiFunction",
@@ -46,6 +46,10 @@ def get_specs(contexts=Optional[List[str]], no_types: bool = False) -> List:
     if contexts:
         params["contexts"] = contexts
 
+    # Add apiFunctionDirectExecute parameter if direct execute is enabled
+    if get_direct_execute_config():
+        params["apiFunctionDirectExecute"] = "true"
+
     resp = requests.get(url, headers=headers, params=params)
     if resp.status_code == 200:
         return resp.json()
@@ -125,24 +129,26 @@ def parse_function_specs(
 ) -> List[SpecificationDto]:
     functions = []
     for spec in specs:
-        if not spec or "function" not in spec:
-            continue
-
-        if not spec["function"]:
-            continue
-
-        if limit_ids and spec["id"] not in limit_ids:
+        if not spec:
             continue
 
+        # For no_types mode, we might not have function data, but we still want to include the spec
+        # if it's a supported function type
         if spec["type"] not in SUPPORTED_FUNCTION_TYPES:
             continue
 
-        if spec["type"] == "customFunction" and spec["language"] != "python":
-            # poly libraries only support client functions of same language
+        # Skip if we have a limit and this spec is not in it
+        if limit_ids and spec.get("id") not in limit_ids:
             continue
 
+        # For customFunction, check language if we have function data
+        if spec["type"] == "customFunction":
+            if spec.get("language") and spec["language"] != "python":
+                # poly libraries only support client functions of same language
+                continue
+
         # Functions with serverSideAsync True will always return a Dict with execution ID
-        if spec.get('serverSideAsync'):
+        if spec.get('serverSideAsync') and spec.get("function"):
             spec['function']['returnType'] = {'kind': 'plain', 'value': 'object'}
 
         functions.append(spec)
@@ -201,6 +207,63 @@ def remove_old_library():
         shutil.rmtree(path)
 
 
+def create_empty_schemas_module():
+    """Create an empty schemas module for no-types mode so user code can still import from polyapi.schemas"""
+    currdir = os.path.dirname(os.path.abspath(__file__))
+    schemas_path = os.path.join(currdir, "schemas")
+    
+    # Create the schemas directory
+    if not os.path.exists(schemas_path):
+        os.makedirs(schemas_path)
+    
+    # Create an __init__.py file with dynamic schema resolution
+    init_path = os.path.join(schemas_path, "__init__.py")
+    with open(init_path, "w") as f:
+        f.write('''"""Empty schemas module for no-types mode"""
+from typing import Any, Dict
+
+class _GenericSchema(Dict[str, Any]):
+    """Generic schema type that acts like a Dict for no-types mode"""
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+class _SchemaModule:
+    """Dynamic module that returns itself for attribute access, allowing infinite nesting"""
+    
+    def __getattr__(self, name: str):
+        # For callable access (like schemas.Response()), return the generic schema class
+        # For further attribute access (like schemas.random.random2), return self to allow nesting
+        return _NestedSchemaAccess()
+    
+    def __call__(self, *args, **kwargs):
+        # If someone tries to call the module itself, return a generic schema
+        return _GenericSchema(*args, **kwargs)
+    
+    def __dir__(self):
+        # Return common schema names for introspection
+        return ['Response', 'Request', 'Error', 'Data', 'Result']
+
+class _NestedSchemaAccess:
+    """Handles nested attribute access and final callable resolution"""
+    
+    def __getattr__(self, name: str):
+        # Continue allowing nested access
+        return _NestedSchemaAccess()
+    
+    def __call__(self, *args, **kwargs):
+        # When finally called, return a generic schema instance
+        return _GenericSchema(*args, **kwargs)
+    
+    def __class_getitem__(cls, item):
+        # Support type annotations like schemas.Response[str]
+        return _GenericSchema
+
+# Replace this module with our dynamic module
+import sys
+sys.modules[__name__] = _SchemaModule()
+''')
+
+
 def generate(contexts: Optional[List[str]] = None, no_types: bool = False) -> None:
     generate_msg = f"Generating Poly Python SDK for contexts ${contexts}..." if contexts else "Generating Poly Python SDK..."
     print(generate_msg, end="", flush=True)
@@ -212,14 +275,23 @@ def generate(contexts: Optional[List[str]] = None, no_types: bool = False) -> No
     limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
     functions = parse_function_specs(specs, limit_ids=limit_ids)
 
-    schemas = get_schemas()
-    schema_index = build_schema_index(schemas)
-    if schemas:
-        schema_limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
-        schemas = replace_poly_refs_in_schemas(schemas, schema_index)
-        generate_schemas(schemas, limit_ids=schema_limit_ids)
-
-    functions = replace_poly_refs_in_functions(functions, schema_index)
+    # Only process schemas if no_types is False
+    if not no_types:
+        schemas = get_schemas()
+        schema_index = build_schema_index(schemas)
+        if schemas:
+            schema_limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
+            schemas = replace_poly_refs_in_schemas(schemas, schema_index)
+            generate_schemas(schemas, limit_ids=schema_limit_ids)
+        
+        functions = replace_poly_refs_in_functions(functions, schema_index)
+    else:
+        # When no_types is True, we still need to process functions but without schema resolution
+        # Use an empty schema index to avoid poly-ref resolution
+        schema_index = {}
+        
+        # Create an empty schemas module so user code can still import from polyapi.schemas
+        create_empty_schemas_module()
 
     if functions:
         generate_functions(functions)
@@ -229,10 +301,11 @@ def generate(contexts: Optional[List[str]] = None, no_types: bool = False) -> No
         )
         exit()
 
-    variables = get_variables()
-    if variables:
-        generate_variables(variables)
-
+    # Only process variables if no_types is False
+    if not no_types:
+        variables = get_variables()
+        if variables:
+            generate_variables(variables)
 
     # indicator to vscode extension that this is a polyapi-python project
     file_path = os.path.join(os.getcwd(), ".polyapi-python")
@@ -262,11 +335,19 @@ def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
 
     arguments: List[PropertySpecification] = []
     return_type = {}
-    if spec["function"]:
-        arguments = [
-            arg for arg in spec["function"]["arguments"]
-        ]
-        return_type = spec["function"]["returnType"]
+    if spec.get("function"):
+        # Handle cases where arguments might be missing or None
+        if spec["function"].get("arguments"):
+            arguments = [
+                arg for arg in spec["function"]["arguments"]
+            ]
+        
+        # Handle cases where returnType might be missing or None
+        if spec["function"].get("returnType"):
+            return_type = spec["function"]["returnType"]
+        else:
+            # Provide a fallback return type when missing
+            return_type = {"kind": "any"}
 
     if function_type == "apiFunction":
         func_str, func_type_defs = render_api_function(
@@ -280,7 +361,7 @@ def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
     elif function_type == "customFunction":
         func_str, func_type_defs = render_client_function(
             function_name,
-            spec["code"],
+            spec.get("code", ""),
             arguments,
             return_type,
         )

{polyapi_python-0.3.6.dev0 → polyapi_python-0.3.7}/polyapi/schema.py

@@ -126,4 +126,8 @@ def clean_title(title: str) -> str:
 
 def map_primitive_types(type_: str) -> str:
     # Define your mapping logic here
-    return JSONSCHEMA_TO_PYTHON_TYPE_MAP.get(type_, "Any")
+    return JSONSCHEMA_TO_PYTHON_TYPE_MAP.get(type_, "Any")
+
+
+def is_primitive(type_: str) -> bool:
+    return type_ in JSONSCHEMA_TO_PYTHON_TYPE_MAP

{polyapi_python-0.3.6.dev0 → polyapi_python-0.3.7}/polyapi/utils.py

@@ -11,12 +11,13 @@ from polyapi.schema import (
     wrapped_generate_schema_types,
     clean_title,
     map_primitive_types,
+    is_primitive
 )
 
 
 # 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\nfrom polyapi.execute import execute, execute_post, variable_get, variable_update\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_post, variable_get, variable_update, direct_execute\n\n"
 
 
 def init_the_init(full_path: str, code_imports="") -> None:
@@ -97,20 +98,32 @@ def get_type_and_def(
 ) -> Tuple[str, str]:
     """ returns type and type definition for a given PropertyType
     """
+    # Handle cases where type_spec might be None or empty
+    if not type_spec:
+        return "Any", ""
+    
+    # Handle cases where kind might be missing
+    if "kind" not in type_spec:
+        return "Any", ""
+    
     if type_spec["kind"] == "plain":
-        value = type_spec["value"]
+        value = type_spec.get("value", "")
         if value.endswith("[]"):
             primitive = map_primitive_types(value[:-2])
             return f"List[{primitive}]", ""
         else:
             return map_primitive_types(value), ""
     elif type_spec["kind"] == "primitive":
-        return map_primitive_types(type_spec["type"]), ""
+        return map_primitive_types(type_spec.get("type", "any")), ""
     elif type_spec["kind"] == "array":
         if type_spec.get("items"):
             items = type_spec["items"]
             if items.get("$ref"):
-                return wrapped_generate_schema_types(type_spec, "ResponseType", "Dict")  # type: ignore
+                # For no-types mode, avoid complex schema generation
+                try:
+                    return wrapped_generate_schema_types(type_spec, "ResponseType", "Dict")  # type: ignore
+                except:
+                    return "List[Dict]", ""
             else:
                 item_type, _ = get_type_and_def(items)
                 title = f"List[{item_type}]"
@@ -128,15 +141,28 @@ def get_type_and_def(
                 # TODO fix me
                 # we don't use ReturnType as name for the list type here, we use _ReturnTypeItem
                 return "List", ""
+            elif title and title == "ReturnType" and schema.get("type"):
+                assert isinstance(title, str)
+                schema_type = schema.get("type", "Any")
+                root_type, generated_code = wrapped_generate_schema_types(schema, schema_type, "Dict")  # type: ignore
+                return (map_primitive_types(root_type), "") if is_primitive(root_type) else (root_type, generated_code)  # type: ignore
             elif title:
                 assert isinstance(title, str)
-                return wrapped_generate_schema_types(schema, title, "Dict")  # type: ignore
+                # For no-types mode, avoid complex schema generation
+                try:
+                    root_type, generated_code = wrapped_generate_schema_types(schema, title, "Dict")  # type: ignore
+                    return ("Any", "") if root_type == "ReturnType" else wrapped_generate_schema_types(schema, title, "Dict")  # type: ignore
+                except:
+                    return "Dict", ""
             elif schema.get("allOf") and len(schema["allOf"]):
                 # we are in a case of a single allOf, lets strip off the allOf and move on!
                 # our library doesn't handle allOf well yet
                 allOf = schema["allOf"][0]
                 title = allOf.get("title", allOf.get("name", title_fallback))
-                return wrapped_generate_schema_types(allOf, title, "Dict")
+                try:
+                    return wrapped_generate_schema_types(allOf, title, "Dict")
+                except:
+                    return "Dict", ""
             elif schema.get("items"):
                 # fallback to schema $ref name if no explicit title
                 items = schema.get("items")  # type: ignore
@@ -150,9 +176,15 @@ def get_type_and_def(
                     return "List", ""
 
                 title = f"List[{title}]"
-                return wrapped_generate_schema_types(schema, title, "List")
+                try:
+                    return wrapped_generate_schema_types(schema, title, "List")
+                except:
+                    return "List[Dict]", ""
+            elif schema.get("properties"):
+                result = wrapped_generate_schema_types(schema, "ResponseType", "Dict")  # type: ignore
+                return result
             else:
-                return "Any", ""
+                return "Dict", ""
         else:
             return "Dict", ""
     elif type_spec["kind"] == "function":
@@ -187,12 +219,22 @@ def get_type_and_def(
 
 
 def _maybe_add_fallback_schema_name(a: PropertySpecification):
-    if a["type"]["kind"] == "object" and a["type"].get("schema"):
+    # Handle cases where type might be missing
+    if not a.get("type"):
+        return
+    
+    if a["type"].get("kind") == "object" and a["type"].get("schema"):
         schema = a["type"].get("schema", {})
-        if not schema.get("title") and not schema.get("name") and a["name"]:
+        if not schema.get("title") and not schema.get("name") and a.get("name"):
             schema["title"] = a["name"].title()
 
 
+def _clean_description(text: str) -> str:
+    """Flatten new-lines and collapse excess whitespace."""
+    text = text.replace("\\n", " ").replace("\n", " ")
+    return re.sub(r"\s+", " ", text).strip()
+
+
 def parse_arguments(
     function_name: str, arguments: List[PropertySpecification]
 ) -> Tuple[str, str]:
@@ -200,18 +242,27 @@ def parse_arguments(
     arg_string = ""
     for idx, a in enumerate(arguments):
         _maybe_add_fallback_schema_name(a)
-        arg_type, arg_def = get_type_and_def(a["type"])
+        
+        # Handle cases where type might be missing
+        arg_type_spec = a.get("type", {"kind": "any"})
+        arg_type, arg_def = get_type_and_def(arg_type_spec)
         if arg_def:
             args_def.append(arg_def)
-        a["name"] = rewrite_arg_name(a["name"])
+        
+        # Handle cases where name might be missing
+        arg_name = a.get("name", f"arg{idx}")
+        a["name"] = rewrite_arg_name(arg_name)
+        
         arg_string += (
             f"    {a['name']}: {add_type_import_path(function_name, arg_type)}"
         )
-        if not a["required"]:
+        
+        # Handle cases where required might be missing
+        if not a.get("required", True):
             arg_string += " = None"
 
-        description = a.get("description", "")
-        description = description.replace("\n", " ")
+        description = _clean_description(a.get("description", ""))
+
         if description:
             if idx == len(arguments) - 1:
                 arg_string += f"  # {description}\n"

{polyapi_python-0.3.6.dev0 → polyapi_python-0.3.7}/polyapi/webhook.py

@@ -65,6 +65,7 @@ async def {function_name}(
                     "data": resp,
                     "statusCode": polyCustom.get("responseStatusCode", 200),
                     "contentType": polyCustom.get("responseContentType", None),
+                    "headers": polyCustom.get("responseHeaders", {{}}),
                 }},
             }}, namespace="/events")
 

{polyapi_python-0.3.6.dev0 → polyapi_python-0.3.7/polyapi_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.6.dev0
+Version: 0.3.7
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License

{polyapi_python-0.3.6.dev0 → polyapi_python-0.3.7}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.2", "wheel"]
 
 [project]
 name = "polyapi-python"
-version = "0.3.6.dev0"
+version = "0.3.7"
 description = "The Python Client for PolyAPI, the IPaaS by Developers for Developers"
 authors = [{ name = "Dan Fellin", email = "dan@polyapi.io" }]
 dependencies = [

polyapi_python-0.3.7/tests/test_generate.py

@@ -0,0 +1,289 @@
+import unittest
+import os
+import shutil
+import importlib.util
+from polyapi.utils import get_type_and_def, rewrite_reserved
+from polyapi.generate import render_spec, create_empty_schemas_module
+
+OPENAPI_FUNCTION = {
+    "kind": "function",
+    "spec": {
+        "arguments": [
+            {
+                "name": "event",
+                "required": False,
+                "type": {
+                    "kind": "object",
+                    "schema": {
+                        "$schema": "http://json-schema.org/draft-06/schema#",
+                        "type": "array",
+                        "items": {"$ref": "#/definitions/WebhookEventTypeElement"},
+                        "definitions": {
+                            "WebhookEventTypeElement": {
+                                "type": "object",
+                                "additionalProperties": False,
+                                "properties": {
+                                    "title": {"type": "string"},
+                                    "manufacturerName": {"type": "string"},
+                                    "carType": {"type": "string"},
+                                    "id": {"type": "integer"},
+                                },
+                                "required": [
+                                    "carType",
+                                    "id",
+                                    "manufacturerName",
+                                    "title",
+                                ],
+                                "title": "WebhookEventTypeElement",
+                            }
+                        },
+                    },
+                },
+            },
+            {
+                "name": "headers",
+                "required": False,
+                "type": {"kind": "object", "typeName": "Record<string, any>"},
+            },
+            {
+                "name": "params",
+                "required": False,
+                "type": {"kind": "object", "typeName": "Record<string, any>"},
+            },
+            {
+                "name": "polyCustom",
+                "required": False,
+                "type": {
+                    "kind": "object",
+                    "properties": [
+                        {
+                            "name": "responseStatusCode",
+                            "type": {"type": "number", "kind": "primitive"},
+                            "required": True,
+                        },
+                        {
+                            "name": "responseContentType",
+                            "type": {"type": "string", "kind": "primitive"},
+                            "required": True,
+                            "nullable": True,
+                        },
+                    ],
+                },
+            },
+        ],
+        "returnType": {"kind": "void"},
+        "synchronous": True,
+    },
+}
+
+# Test spec with missing function data (simulating no_types=true)
+NO_TYPES_SPEC = {
+    "id": "test-id-123",
+    "type": "serverFunction",
+    "context": "test",
+    "name": "testFunction",
+    "description": "A test function for no-types mode",
+    # Note: no "function" field, simulating no_types=true response
+}
+
+# Test spec with minimal function data
+MINIMAL_FUNCTION_SPEC = {
+    "id": "test-id-456",
+    "type": "apiFunction",
+    "context": "test",
+    "name": "minimalFunction",
+    "description": "A minimal function spec",
+    "function": {
+        # Note: no "arguments" or "returnType" fields
+    }
+}
+
+
+class T(unittest.TestCase):
+    def test_get_type_and_def(self):
+        arg_type, arg_def = get_type_and_def(OPENAPI_FUNCTION)
+        self.assertEqual(arg_type, "Callable[[List[WebhookEventTypeElement], Dict, Dict, Dict], None]")
+
+    def test_rewrite_reserved(self):
+        rv = rewrite_reserved("from")
+        self.assertEqual(rv, "_from")
+
+    def test_render_spec_no_function_data(self):
+        """Test that render_spec handles specs with no function data gracefully"""
+        func_str, func_type_defs = render_spec(NO_TYPES_SPEC)
+        
+        # Should generate a function even without function data
+        self.assertIsNotNone(func_str)
+        self.assertIsNotNone(func_type_defs)
+        self.assertIn("testFunction", func_str)
+        self.assertIn("test-id-123", func_str)
+
+    def test_render_spec_minimal_function_data(self):
+        """Test that render_spec handles specs with minimal function data"""
+        func_str, func_type_defs = render_spec(MINIMAL_FUNCTION_SPEC)
+        
+        # Should generate a function with fallback types
+        self.assertIsNotNone(func_str)
+        self.assertIsNotNone(func_type_defs)
+        self.assertIn("minimalFunction", func_str)
+        self.assertIn("test-id-456", func_str)
+        # Should use Any as fallback return type in the type definitions
+        self.assertIn("Any", func_type_defs)
+
+    def test_create_empty_schemas_module(self):
+        """Test that create_empty_schemas_module creates the necessary files"""
+        # Clean up any existing schemas directory
+        schemas_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "polyapi", "schemas")
+        if os.path.exists(schemas_path):
+            shutil.rmtree(schemas_path)
+        
+        # Create empty schemas module
+        create_empty_schemas_module()
+        
+        # Verify the directory and __init__.py file were created
+        self.assertTrue(os.path.exists(schemas_path))
+        init_path = os.path.join(schemas_path, "__init__.py")
+        self.assertTrue(os.path.exists(init_path))
+        
+        # Verify the content of __init__.py includes dynamic schema handling
+        with open(init_path, "r") as f:
+            content = f.read()
+            self.assertIn("Empty schemas module for no-types mode", content)
+            self.assertIn("_GenericSchema", content)
+            self.assertIn("_SchemaModule", content)
+            self.assertIn("__getattr__", content)
+        
+        # Clean up
+        shutil.rmtree(schemas_path)
+
+    def test_no_types_workflow(self):
+        """Test the complete no-types workflow including schema imports and function parsing"""
+        import tempfile
+        import sys
+        from unittest.mock import patch
+        
+        # Clean up any existing schemas directory
+        schemas_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "polyapi", "schemas")
+        if os.path.exists(schemas_path):
+            shutil.rmtree(schemas_path)
+        
+        # Mock get_specs to return empty list (simulating no functions)
+        with patch('polyapi.generate.get_specs', return_value=[]):
+            try:
+                # This should exit with SystemExit due to no functions
+                from polyapi.generate import generate
+                generate(no_types=True)
+            except SystemExit:
+                pass  # Expected when no functions exist
+        
+        # Verify schemas module was created
+        self.assertTrue(os.path.exists(schemas_path))
+        init_path = os.path.join(schemas_path, "__init__.py")
+        self.assertTrue(os.path.exists(init_path))
+        
+        # Test that we can import schemas and use arbitrary schema names
+        from polyapi import schemas
+        
+        # Test various schema access
+        Response = schemas.Response
+        CustomType = schemas.CustomType
+        AnyName = schemas.SomeArbitrarySchemaName
+        
+        # All should return the same generic schema class type
+        self.assertEqual(type(Response).__name__, '_NestedSchemaAccess')
+        self.assertEqual(type(CustomType).__name__, '_NestedSchemaAccess')
+        self.assertEqual(type(AnyName).__name__, '_NestedSchemaAccess')
+        
+        # Test creating instances
+        response_instance = Response()
+        custom_instance = CustomType()
+        
+        self.assertIsInstance(response_instance, dict)
+        self.assertIsInstance(custom_instance, dict)
+        
+        # Test that function code with schema references can be parsed
+        test_code = '''
+from polyapi import polyCustom, schemas
+
+def test_function() -> schemas.Response:
+    polyCustom["executionId"] = "123"
+    return polyCustom
+'''
+        
+        # Create a temporary file with the test code
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write(test_code)
+            temp_file = f.name
+        
+        try:
+            # Test that the parser can handle this code
+            from polyapi.parser import parse_function_code
+            result = parse_function_code(test_code, 'test_function', 'test_context')
+            
+            self.assertEqual(result['name'], 'test_function')
+            self.assertEqual(result['context'], 'test_context')
+            # Return type should be Any since we're in no-types mode
+            self.assertEqual(result['types']['returns']['type'], 'Any')
+            
+        finally:
+            # Clean up temp file
+            os.unlink(temp_file)
+        
+        # Clean up schemas directory
+        shutil.rmtree(schemas_path)
+
+    def test_nested_schema_access(self):
+        """Test that nested schema access like schemas.random.random2.random3 works"""
+        # Clean up any existing schemas directory
+        schemas_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "polyapi", "schemas")
+        if os.path.exists(schemas_path):
+            shutil.rmtree(schemas_path)
+        
+        # Create empty schemas module
+        create_empty_schemas_module()
+        
+        # Test that we can import and use nested schemas
+        from polyapi import schemas
+        
+        # Test various levels of nesting
+        simple = schemas.Response
+        nested = schemas.random.random2
+        deep_nested = schemas.api.v1.user.profile.data
+        very_deep = schemas.some.very.deep.nested.schema.access
+        
+        # All should be _NestedSchemaAccess instances
+        self.assertEqual(type(simple).__name__, '_NestedSchemaAccess')
+        self.assertEqual(type(nested).__name__, '_NestedSchemaAccess')
+        self.assertEqual(type(deep_nested).__name__, '_NestedSchemaAccess')
+        self.assertEqual(type(very_deep).__name__, '_NestedSchemaAccess')
+        
+        # Test that they can be called and return generic schemas
+        simple_instance = simple()
+        nested_instance = nested()
+        deep_instance = deep_nested()
+        very_deep_instance = very_deep()
+        
+        # All should be dictionaries
+        self.assertIsInstance(simple_instance, dict)
+        self.assertIsInstance(nested_instance, dict)
+        self.assertIsInstance(deep_instance, dict)
+        self.assertIsInstance(very_deep_instance, dict)
+        
+        # Test that function code with nested schemas can be parsed
+        test_code = '''
+from polyapi import polyCustom, schemas
+
+def test_nested_function() -> schemas.api.v1.user.profile:
+    return schemas.api.v1.user.profile()
+'''
+        
+        from polyapi.parser import parse_function_code
+        result = parse_function_code(test_code, 'test_nested_function', 'test_context')
+        
+        self.assertEqual(result['name'], 'test_nested_function')
+        self.assertEqual(result['context'], 'test_context')
+        # Return type should be Any since we're in no-types mode
+        self.assertEqual(result['types']['returns']['type'], 'Any')
+        
+        # Clean up schemas directory
+        shutil.rmtree(schemas_path)

polyapi_python-0.3.6.dev0/polyapi/__init__.py

@@ -1,23 +0,0 @@
-import os
-import sys
-import truststore
-from typing import Dict, Any
-truststore.inject_into_ssl()
-from .cli import CLI_COMMANDS
-
-__all__ = ["poly"]
-
-
-if len(sys.argv) > 1 and sys.argv[1] not in CLI_COMMANDS:
-    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)
-
-
-polyCustom: Dict[str, Any] = {
-    "executionId": None,
-    "executionApiKey": None,
-    "responseStatusCode": 200,
-    "responseContentType": None,
-}

polyapi_python-0.3.6.dev0/tests/test_generate.py

@@ -1,83 +0,0 @@
-import unittest
-from polyapi.utils import get_type_and_def, rewrite_reserved
-
-OPENAPI_FUNCTION = {
-    "kind": "function",
-    "spec": {
-        "arguments": [
-            {
-                "name": "event",
-                "required": False,
-                "type": {
-                    "kind": "object",
-                    "schema": {
-                        "$schema": "http://json-schema.org/draft-06/schema#",
-                        "type": "array",
-                        "items": {"$ref": "#/definitions/WebhookEventTypeElement"},
-                        "definitions": {
-                            "WebhookEventTypeElement": {
-                                "type": "object",
-                                "additionalProperties": False,
-                                "properties": {
-                                    "title": {"type": "string"},
-                                    "manufacturerName": {"type": "string"},
-                                    "carType": {"type": "string"},
-                                    "id": {"type": "integer"},
-                                },
-                                "required": [
-                                    "carType",
-                                    "id",
-                                    "manufacturerName",
-                                    "title",
-                                ],
-                                "title": "WebhookEventTypeElement",
-                            }
-                        },
-                    },
-                },
-            },
-            {
-                "name": "headers",
-                "required": False,
-                "type": {"kind": "object", "typeName": "Record<string, any>"},
-            },
-            {
-                "name": "params",
-                "required": False,
-                "type": {"kind": "object", "typeName": "Record<string, any>"},
-            },
-            {
-                "name": "polyCustom",
-                "required": False,
-                "type": {
-                    "kind": "object",
-                    "properties": [
-                        {
-                            "name": "responseStatusCode",
-                            "type": {"type": "number", "kind": "primitive"},
-                            "required": True,
-                        },
-                        {
-                            "name": "responseContentType",
-                            "type": {"type": "string", "kind": "primitive"},
-                            "required": True,
-                            "nullable": True,
-                        },
-                    ],
-                },
-            },
-        ],
-        "returnType": {"kind": "void"},
-        "synchronous": True,
-    },
-}
-
-
-class T(unittest.TestCase):
-    def test_get_type_and_def(self):
-        arg_type, arg_def = get_type_and_def(OPENAPI_FUNCTION)
-        self.assertEqual(arg_type, "Callable[[List[WebhookEventTypeElement], Dict, Dict, Dict], None]")
-
-    def test_rewrite_reserved(self):
-        rv = rewrite_reserved("from")
-        self.assertEqual(rv, "_from")