polyapi-python 0.3.19.dev4__tar.gz → 0.3.20.dev1__tar.gz

{polyapi_python-0.3.19.dev4 → polyapi_python-0.3.20.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.19.dev4
+Version: 0.3.20.dev1
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License

polyapi_python-0.3.20.dev1/polyapi/ai_function.py

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

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

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

{polyapi_python-0.3.19.dev4 → polyapi_python-0.3.20.dev1}/polyapi/typedefs.py

@@ -35,7 +35,7 @@ class SpecificationDto(TypedDict):
     description: str
     # function is none (or function key not present) if this is actually VariableSpecDto
     function: NotRequired[FunctionSpecification | None]
-    type: Literal['apiFunction', 'customFunction', 'serverFunction', 'authFunction', 'webhookHandle', 'serverVariable', 'table']
+    type: Literal['apiFunction', 'customFunction', 'serverFunction', 'authFunction', 'webhookHandle', 'serverVariable', 'table', 'aiFunction']
     code: NotRequired[str]
     language: str
 

{polyapi_python-0.3.19.dev4 → polyapi_python-0.3.20.dev1}/polyapi/utils.py

@@ -1,7 +1,7 @@
 import keyword
 import re
 import os
-from urllib.parse import urlparse
+from urllib.parse import unquote, urlparse
 from typing import Tuple, List, Optional, cast
 from colorama import Fore, Style
 from polyapi.constants import BASIC_PYTHON_TYPES
@@ -299,11 +299,29 @@ def _maybe_add_fallback_schema_name(a: PropertySpecification):
     # 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.get("name"):
-            schema["title"] = a["name"].title()
+        title = schema.get("title") or schema.get("name")
+        if not title and a.get("name"):
+            title = a["name"].title()
+            schema["title"] = title
+
+        reference = schema.get("$ref")
+        definitions = schema.get("definitions")
+        reference_prefix = "#/definitions/"
+        if not isinstance(title, str):
+            return
+        if not isinstance(reference, str) or not reference.startswith(reference_prefix):
+            return
+        if not isinstance(definitions, dict):
+            return
+
+        definition_name = unquote(reference[len(reference_prefix):])
+        definition_name = definition_name.replace("~1", "/").replace("~0", "~")
+        definition = definitions.get(definition_name)
+        if isinstance(definition, dict):
+            definition.setdefault("title", title)
 
 
 def _clean_description(text: str) -> str:

{polyapi_python-0.3.19.dev4 → polyapi_python-0.3.20.dev1}/polyapi_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.19.dev4
+Version: 0.3.20.dev1
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License

{polyapi_python-0.3.19.dev4 → polyapi_python-0.3.20.dev1}/polyapi_python.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 polyapi/__init__.py
 polyapi/__main__.py
+polyapi/ai_function.py
 polyapi/api.py
 polyapi/auth.py
 polyapi/cli.py

{polyapi_python-0.3.19.dev4 → polyapi_python-0.3.20.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polyapi-python"
-version = "0.3.19.dev4"
+version = "0.3.20.dev1"
 description = "The Python SDK for the integration platform PolyAPI"
 authors = [{ name = "PolyAPI", email = "support@polyapi.io" }]
 dependencies = [

{polyapi_python-0.3.19.dev4 → polyapi_python-0.3.20.dev1}/tests/test_generate.py

@@ -1,8 +1,12 @@
 import unittest
+import copy
 import os
 import shutil
 import importlib.util
+import subprocess
+import sys
 import tempfile
+from typing import cast
 from unittest.mock import patch, MagicMock
 from polyapi.typedefs import SpecificationDto
 from polyapi.utils import get_type_and_def, rewrite_reserved, to_type_module_alias
@@ -103,6 +107,144 @@ MINIMAL_FUNCTION_SPEC = {
     }
 }
 
+MEWS_HEADERS_SPECS = [
+    (
+        {
+            "id": "6979c3e1-4d59-4867-91b7-4d394fe9e34a",
+            "type": "serverFunction",
+            "context": "gha.mews.v1",
+            "name": "generalEvents",
+            "description": "Sanitized Mews headers regression fixture",
+            "language": "javascript",
+            "function": {
+                "arguments": [
+                    {
+                        "name": "headers",
+                        "description": "",
+                        "required": True,
+                        "type": {
+                            "kind": "object",
+                            "schema": {
+                                "$ref": "#/definitions/Gha.Mews.V1.GeneralEvents%24Headers.Argument",
+                                "$schema": "http://json-schema.org/draft-07/schema#",
+                                "definitions": {
+                                    "Gha.Mews.V1.GeneralEvents$Headers.Argument": {
+                                        "type": "object",
+                                        "additionalProperties": {},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ],
+                "returnType": {"kind": "void"},
+            },
+        },
+        "Headers",
+        "Headers = dict[str, str | int | float | dict[str, Any] | list[Any] | bool | None]",
+    ),
+    (
+        {
+            "id": "d8230ba3-b1da-4d2f-8e47-97114d8a3f37",
+            "type": "serverFunction",
+            "context": "gha.mews.v1",
+            "name": "membersSearch",
+            "description": "Sanitized Mews headers regression fixture",
+            "language": "javascript",
+            "function": {
+                "arguments": [
+                    {
+                        "name": "_headers",
+                        "description": "",
+                        "required": True,
+                        "type": {
+                            "kind": "object",
+                            "schema": {
+                                "$ref": "#/definitions/Gha.Mews.V1.MembersSearch%24Headers.Argument",
+                                "$schema": "http://json-schema.org/draft-07/schema#",
+                                "definitions": {
+                                    "Gha.Mews.V1.MembersSearch$Headers.Argument": {
+                                        "type": "object",
+                                        "additionalProperties": {},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ],
+                "returnType": {"kind": "void"},
+            },
+        },
+        "_Headers",
+        "_Headers = dict[str, str | int | float | dict[str, Any] | list[Any] | bool | None]",
+    ),
+    (
+        {
+            "id": "3037a373-291f-4b87-9966-b3d125ffee26",
+            "type": "serverFunction",
+            "context": "gha.mews.v1",
+            "name": "membershipsCreate",
+            "description": "Sanitized Mews headers regression fixture",
+            "language": "javascript",
+            "function": {
+                "arguments": [
+                    {
+                        "name": "_headers",
+                        "description": "",
+                        "required": True,
+                        "type": {
+                            "kind": "object",
+                            "schema": {
+                                "$ref": "#/definitions/Gha.Mews.V1.MembershipsCreate%24Headers.Argument",
+                                "$schema": "http://json-schema.org/draft-07/schema#",
+                                "definitions": {
+                                    "Gha.Mews.V1.MembershipsCreate$Headers.Argument": {
+                                        "type": "object",
+                                        "additionalProperties": {"type": "string"},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ],
+                "returnType": {"kind": "void"},
+            },
+        },
+        "_Headers",
+        "_Headers = dict[str, str]",
+    ),
+    (
+        {
+            "id": "63c65574-26bf-4b10-a301-06ce02dad548",
+            "type": "serverFunction",
+            "context": "gha.mews.v1",
+            "name": "membershipsList",
+            "description": "Sanitized Mews headers regression fixture",
+            "language": "javascript",
+            "function": {
+                "arguments": [
+                    {
+                        "name": "_headers",
+                        "description": "",
+                        "required": True,
+                        "type": {
+                            "kind": "object",
+                            "schema": {
+                                "$schema": "http://json-schema.org/draft-07/schema#",
+                                "type": "object",
+                                "additionalProperties": {},
+                            },
+                        },
+                    },
+                ],
+                "returnType": {"kind": "void"},
+            },
+        },
+        "_Headers",
+        "_Headers = dict[str, str | int | float | dict[str, Any] | list[Any] | bool | None]",
+    ),
+]
+
 
 class T(unittest.TestCase):
     def test_get_type_and_def(self):
@@ -704,3 +846,54 @@ def test_nested_function() -> schemas.api.v1.user.profile:
                 f"-> {type_module_alias}.{spec['name']}Response",
                 init_content,
             )
+
+    def test_mews_headers_schemas_generate_referenced_type_aliases(self):
+        for fixture, expected_symbol, expected_definition in MEWS_HEADERS_SPECS:
+            with self.subTest(function=fixture["name"]):
+                spec = copy.deepcopy(fixture)
+                func_str, func_type_defs = render_spec(cast(SpecificationDto, spec))
+                type_module_alias = to_type_module_alias(spec["name"])
+
+                self.assertIn(
+                    f"{spec['function']['arguments'][0]['name']}: "
+                    f"{type_module_alias}.{expected_symbol}",
+                    func_str,
+                )
+                self.assertIn(expected_definition, func_type_defs)
+
+    def test_mews_headers_reference_preserves_explicit_definition_title(self):
+        spec = copy.deepcopy(MEWS_HEADERS_SPECS[1][0])
+        schema = spec["function"]["arguments"][0]["type"]["schema"]
+        definition = schema["definitions"]["Gha.Mews.V1.MembersSearch$Headers.Argument"]
+        definition["title"] = "ExistingTitle"
+
+        render_spec(cast(SpecificationDto, spec))
+
+        self.assertEqual(definition["title"], "ExistingTitle")
+
+    def test_mews_headers_generated_package_imports_in_fresh_process(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            package_name = "generated_mews"
+            package_dir = os.path.join(temp_dir, package_name)
+            os.makedirs(package_dir)
+
+            for fixture, _, _ in MEWS_HEADERS_SPECS:
+                spec = copy.deepcopy(fixture)
+                add_function_file(
+                    package_dir,
+                    spec["name"],
+                    cast(SpecificationDto, spec),
+                )
+
+            repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            result = subprocess.run(
+                [sys.executable, "-c", f"import {package_name}"],
+                cwd=temp_dir,
+                env={
+                    "PYTHONPATH": os.pathsep.join([temp_dir, repo_root]),
+                },
+                capture_output=True,
+                text=True,
+            )
+
+            self.assertEqual(result.returncode, 0, result.stderr)