polyapi-python 0.3.17.dev1__tar.gz → 0.3.18__tar.gz

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.17.dev1
+Version: 0.3.18
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
-Author-email: Dan Fellin <dan@polyapi.io>
+Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
         
         Copyright (c) 2025 PolyAPI Inc.
@@ -28,15 +28,15 @@ Project-URL: Homepage, https://github.com/polyapi/polyapi-python
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.32.3
-Requires-Dist: typing_extensions>=4.12.2
+Requires-Dist: requests==2.32.3
+Requires-Dist: typing_extensions==4.12.2
 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: pydantic==2.8.0
+Requires-Dist: stdlib_list==0.11.1
 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
+Requires-Dist: truststore==0.9.1
+Requires-Dist: httpx==0.28.1
 Dynamic: license-file
 
 # PolyAPI Python Library

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi/cli.py

@@ -1,4 +1,6 @@
 import os
+import sys
+import tempfile
 import argparse
 
 from polyapi.utils import print_green, print_red
@@ -23,6 +25,16 @@ def _get_version_string():
 
 
 def execute_from_cli():
+    # Redirect __pycache__ out of generated dirs to avoid window file-locking
+    # failures when rmtree dels on generate.
+    if 'PYTHONPYCACHEPREFIX' not in os.environ:
+        cache_dir = os.path.join(tempfile.gettempdir(), 'polyapi_pycache')
+        os.makedirs(cache_dir, exist_ok=True)
+        # here for children just in case
+        os.environ['PYTHONPYCACHEPREFIX'] = cache_dir
+        # For the startup py_initialize issue 
+        sys.pycache_prefix = cache_dir
+
     # First we setup all our argument parsing logic
     # Then we parse the arguments (waaay at the bottom)
     parser = argparse.ArgumentParser(
@@ -114,7 +126,7 @@ def execute_from_cli():
     fn_add_parser.add_argument("--client", action="store_true", help="Marks the function as a client function")
     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("--skip-generate", action="store_true", help="Skip running generate after function add command, especially useful if you are deploying a bunch of functions at once. Run generate manually at the end!")
     fn_add_parser.add_argument("--generate-contexts", type=str, help="Server function only – only include certain contexts to speed up function execution")
     fn_add_parser.add_argument("--visibility", type=str, default="environment", help="Specifies the visibility of a function. Options: PUBLIC, TENANT, ENVIRONMENT. Case insensitive")
 
@@ -147,7 +159,7 @@ def execute_from_cli():
             client=args.client,
             server=args.server,
             logs_enabled=logs_enabled,
-            generate=not args.disable_ai,
+            generate=not args.skip_generate,
             execution_api_key=args.execution_api_key,
             generate_contexts=args.generate_contexts,
             visibility=visibility

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi/generate.py

@@ -4,6 +4,7 @@ import uuid
 import shutil
 import logging
 import tempfile
+import stat
 
 from copy import deepcopy
 from typing import Any, List, Optional, Tuple, cast
@@ -209,23 +210,33 @@ def get_tables(specs: List[SpecificationDto]) -> List[TableSpecDto]:
     return [cast(TableSpecDto, spec) for spec in specs if spec["type"] == "table"]
 
 
+def _rmtree_readonly_handler(func, path, exc):
+    # Windows marks __pycache__ .pyc files read-only; clear the bit and retry.
+    os.chmod(path, stat.S_IWRITE)
+    func(path)
+
+
+def _rmtree(path):
+    shutil.rmtree(path, onerror=_rmtree_readonly_handler)
+
+
 def remove_old_library():
     currdir = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(currdir, "poly")
     if os.path.exists(path):
-        shutil.rmtree(path)
+        _rmtree(path)
 
     path = os.path.join(currdir, "vari")
     if os.path.exists(path):
-        shutil.rmtree(path)
+        _rmtree(path)
 
     path = os.path.join(currdir, "schemas")
     if os.path.exists(path):
-        shutil.rmtree(path)
+        _rmtree(path)
 
     path = os.path.join(currdir, "tabi")
     if os.path.exists(path):
-        shutil.rmtree(path)
+        _rmtree(path)
 
 
 def create_empty_schemas_module():
@@ -399,7 +410,21 @@ def clear() -> None:
 
 def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
     function_type = spec["type"]
-    function_description = spec["description"]
+    raw_description = spec.get("description", "")
+    def _flatten_description(value: Any) -> List[str]:
+        if value is None:
+            return []
+        if isinstance(value, list):
+            flat: List[str] = []
+            for item in value:
+                flat.extend(_flatten_description(item))
+            return flat
+        return [str(value)]
+
+    if isinstance(raw_description, str):
+        function_description = raw_description
+    else:
+        function_description = "\n".join(_flatten_description(raw_description))
     function_name = spec["name"]
     function_context = spec["context"]
     function_id = spec["id"]

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi/poly_schemas.py

@@ -1,8 +1,9 @@
 import os
+import re
 import logging
 import tempfile
 import shutil
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 from polyapi.schema import wrapped_generate_schema_types
 from polyapi.utils import add_import_to_init, init_the_init, to_func_namespace
@@ -23,7 +24,7 @@ FALLBACK_SPEC_TEMPLATE = """class {name}(TypedDict, total=False):
 """
 
 
-def generate_schemas(specs: List[SchemaSpecDto], limit_ids: List[str] = None):
+def generate_schemas(specs: List[SchemaSpecDto], limit_ids: Optional[List[str]] = None):
     failed_schemas = []
     successful_schemas = []
     if limit_ids:
@@ -209,6 +210,44 @@ def add_schema_to_init(full_path: str, spec: SchemaSpecDto):
         f.write(render_poly_schema(spec) + "\n\n")
 
 
+def _fix_typed_dict_imports(code: str) -> str:
+    """Move TypedDict/NotRequired from `typing` to `typing_extensions` in generated code.
+
+    jsonschema_gentypes spits out `from typing import ..., TypedDict, ...` which makes
+    typing._TypedDictMeta instances. The deploy validator wants typing_extensions.TypedDict,
+    so let's rewrite the imports here before writing schema files to disk.
+    """
+    lines = code.split('\n')
+    new_lines = []
+    has_te_import = False
+
+    for line in lines:
+        if re.match(r'from\s+typing_extensions\s+import', line):
+            has_te_import = True
+            # Ensure TypedDict and NotRequired are in the existing typing_extensions line
+            name_set = {n.strip() for n in line.split('import', 1)[1].split(',')}
+            name_set |= {'TypedDict', 'NotRequired'}
+            new_lines.append(f"from typing_extensions import {', '.join(sorted(name_set))}")
+            continue
+
+        if re.match(r'from\s+typing\s+import', line):
+            # Strip TypedDict and NotRequired from the typing import
+            names_str = line.split('import', 1)[1]
+            names: list[str] = [n.strip() for n in names_str.split(',')]
+            names = [n for n in names if n not in ('TypedDict', 'NotRequired', '')]
+            if names:
+                new_lines.append(f"from typing import {', '.join(names)}")
+            # drop the line entirely if nothing is left
+            continue
+
+        new_lines.append(line)
+
+    result = '\n'.join(new_lines)
+    if not has_te_import:
+        result = 'from typing_extensions import NotRequired, TypedDict\n' + result
+    return result
+
+
 def render_poly_schema(spec: SchemaSpecDto) -> str:
     definition = spec["definition"]
     if not definition.get("type"):
@@ -216,5 +255,5 @@ def render_poly_schema(spec: SchemaSpecDto) -> str:
     root, schema_types = wrapped_generate_schema_types(
         definition, root=spec["name"], fallback_type=Dict
     )
-    return schema_types
+    return _fix_typed_dict_imports(schema_types)
     # return FALLBACK_SPEC_TEMPLATE.format(name=spec["name"])

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi/poly_tables.py

@@ -531,10 +531,27 @@ def _render_table(table: TableSpecDto) -> str:
     table_where_class = _render_table_where_class(
         table["name"], columns, required_columns
     )
-    if table.get("description", ""):
+    raw_description = table.get("description", "")
+
+    def _flatten_description(value: Any) -> List[str]:
+        if value is None:
+            return []
+        if isinstance(value, list):
+            flat: List[str] = []
+            for item in value:
+                flat.extend(_flatten_description(item))
+            return flat
+        return [str(value)]
+
+    if isinstance(raw_description, str):
+        normalized_description = raw_description
+    else:
+        normalized_description = "\n".join(_flatten_description(raw_description))
+
+    if normalized_description:
         table_description = '\n    """'
         table_description += "\n       ".join(
-            table["description"].replace('"', "'").split("\n")
+            normalized_description.replace('"', "'").split("\n")
         )
         table_description += '\n    """'
     else:

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi/schema.py

@@ -50,6 +50,13 @@ def wrapped_generate_schema_types(type_spec: dict, root, fallback_type):
             # if we have no root, just add "My"
             root = "My" + root
 
+    if isinstance(root, list):
+        root = "_".join([str(x) for x in root if x is not None]) or fallback_type
+    elif root is None:
+        root = fallback_type
+    elif not isinstance(root, str):
+        root = str(root)
+
     root = clean_title(root)
 
     try:
@@ -150,10 +157,19 @@ def clean_title(title: str) -> str:
     """ used by library generation, sometimes functions can be added with spaces in the title
     or other nonsense. fix them!
     """
+    if isinstance(title, list):
+        title = "_".join([str(x) for x in title if x is not None])
+    elif title is None:
+        title = ""
+    elif not isinstance(title, str):
+        title = str(title)
+
     title = title.replace(" ", "")
     # certain reserved words cant be titles, let's replace them
     if title == "List":
         title = "List_"
+    if not title:
+        title = "Dict"
     return title
 
 

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi/server.py

@@ -62,7 +62,7 @@ def render_server_function(
         return_type_def=return_type_def,
     )
     func_str = SERVER_FUNCTION_TEMPLATE.format(
-        return_type_name=add_type_import_path(function_name, return_type_name),
+        return_type_name=_normalize_return_type_for_annotation(function_name, return_type_name),
         function_type="server",
         function_name=function_name,
         function_id=function_id,
@@ -74,9 +74,23 @@ def render_server_function(
     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_server_return_action(return_type_name: str) -> str:
-    if return_type_name == "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
+    return return_action

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi/utils.py

@@ -71,6 +71,43 @@ def print_red(s: str):
     print(Fore.RED + s + Style.RESET_ALL)
 
 
+def normalize_cross_language_type(type_name: str) -> str:
+    value = (type_name or "").strip()
+    if not value:
+        return "Any"
+
+    primitive_map = {
+        "string": "str",
+        "number": "float",
+        "integer": "int",
+        "boolean": "bool",
+        "null": "None",
+        "void": "None",
+        "any": "Any",
+        "object": "Dict",
+    }
+
+    if value.startswith("Promise<") and value.endswith(">"):
+        return normalize_cross_language_type(value[len("Promise<"):-1])
+
+    if value.startswith("Awaited<") and value.endswith(">"):
+        return normalize_cross_language_type(value[len("Awaited<"):-1])
+
+    if value.endswith("[]"):
+        item_type = normalize_cross_language_type(value[:-2])
+        return f"List[{item_type}]"
+
+    if "|" in value:
+        parts = [p.strip() for p in value.split("|") if p.strip()]
+        normalized = [normalize_cross_language_type(part) for part in parts]
+        return " | ".join(normalized) if normalized else "Any"
+
+    if value == "ReturnType" or value.startswith("ReturnType<") or "typeof" in value:
+        return "Any"
+
+    return primitive_map.get(value, value)
+
+
 def to_type_module_alias(function_name: str) -> str:
     """Return the internal alias used for a function's generated type module."""
     return f"_{to_func_namespace(function_name)}_types"
@@ -81,6 +118,14 @@ def add_type_import_path(function_name: str, arg: str) -> str:
     # 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]
+    arg = normalize_cross_language_type(arg)
+
+    if "|" in arg:
+        return " | ".join(
+            add_type_import_path(function_name, token.strip())
+            for token in arg.split("|")
+            if token.strip()
+        )
     type_module_alias = to_type_module_alias(function_name)
     
     if arg.startswith("Callable"):
@@ -96,7 +141,7 @@ def add_type_import_path(function_name: str, arg: str) -> str:
         return "Callable[" + ",".join(qualified) + "]"
         # return arg
 
-    if arg in BASIC_PYTHON_TYPES:
+    if arg == "Any" or arg in BASIC_PYTHON_TYPES:
         return arg
 
     if arg.startswith("List["):
@@ -127,14 +172,23 @@ def get_type_and_def(
         return "Any", ""
     
     if type_spec["kind"] == "plain":
-        value = type_spec.get("value", "")
+        value = normalize_cross_language_type(type_spec.get("value", ""))
+
+        if "|" in value or value in BASIC_PYTHON_TYPES:
+            return value, ""
+
         if value.endswith("[]"):
-            primitive = map_primitive_types(value[:-2])
+            primitive = normalize_cross_language_type(value[:-2])
+            if primitive not in BASIC_PYTHON_TYPES:
+                primitive = map_primitive_types(primitive)
             return f"List[{primitive}]", ""
         else:
             return map_primitive_types(value), ""
     elif type_spec["kind"] == "primitive":
-        return map_primitive_types(type_spec.get("type", "any")), ""
+        primitive = normalize_cross_language_type(type_spec.get("type", "any"))
+        if primitive in BASIC_PYTHON_TYPES:
+            return primitive, ""
+        return map_primitive_types(primitive), ""
     elif type_spec["kind"] == "array":
         if type_spec.get("items"):
             items = type_spec["items"]

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi_python.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.17.dev1
+Version: 0.3.18
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
-Author-email: Dan Fellin <dan@polyapi.io>
+Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
         
         Copyright (c) 2025 PolyAPI Inc.
@@ -28,15 +28,15 @@ Project-URL: Homepage, https://github.com/polyapi/polyapi-python
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.32.3
-Requires-Dist: typing_extensions>=4.12.2
+Requires-Dist: requests==2.32.3
+Requires-Dist: typing_extensions==4.12.2
 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: pydantic==2.8.0
+Requires-Dist: stdlib_list==0.11.1
 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
+Requires-Dist: truststore==0.9.1
+Requires-Dist: httpx==0.28.1
 Dynamic: license-file
 
 # PolyAPI Python Library

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/polyapi_python.egg-info/SOURCES.txt

@@ -38,10 +38,12 @@ polyapi_python.egg-info/top_level.txt
 tests/test_api.py
 tests/test_async_proof.py
 tests/test_auth.py
+tests/test_dependency_pins.py
 tests/test_deployables.py
 tests/test_generate.py
 tests/test_parser.py
 tests/test_poly_custom.py
+tests/test_poly_schemas.py
 tests/test_rendered_spec.py
 tests/test_schema.py
 tests/test_server.py

polyapi_python-0.3.18/polyapi_python.egg-info/requires.txt

@@ -0,0 +1,9 @@
+requests==2.32.3
+typing_extensions==4.12.2
+jsonschema-gentypes==2.10.0
+pydantic==2.8.0
+stdlib_list==0.11.1
+colorama==0.4.4
+python-socketio[asyncio_client]==5.11.1
+truststore==0.9.1
+httpx==0.28.1

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/pyproject.toml

@@ -4,19 +4,19 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polyapi-python"
-version = "0.3.17.dev1"
+version = "0.3.18"
 description = "The Python Client for PolyAPI, the IPaaS by Developers for Developers"
-authors = [{ name = "Dan Fellin", email = "dan@polyapi.io" }]
+authors = [{ name = "PolyAPI", email = "support@polyapi.io" }]
 dependencies = [
-    "requests>=2.32.3",
-    "typing_extensions>=4.12.2",
+    "requests==2.32.3",
+    "typing_extensions==4.12.2",
     "jsonschema-gentypes==2.10.0",
-    "pydantic>=2.8.0,<3.0.0",
-    "stdlib_list>=0.10.0,<1.0.0",
+    "pydantic==2.8.0",
+    "stdlib_list==0.11.1",
     "colorama==0.4.4",
     "python-socketio[asyncio_client]==5.11.1",
-    "truststore>=0.8.0",
-    "httpx>=0.28.1"
+    "truststore==0.9.1",
+    "httpx==0.28.1"
 ]
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -32,4 +32,4 @@ exclude = ["polyapi/poly*", "polyapi/vari*", "polyapi/.config.env", "polyapi/cac
 [tool.mypy]
 # for now redef errors happen sometimes, we will clean this up in the future!
 disable_error_code = "no-redef,name-defined"
-implicit_optional = true
+implicit_optional = true

polyapi_python-0.3.18/tests/test_dependency_pins.py

@@ -0,0 +1,33 @@
+import re
+import sys
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+TRUSTSTORE_MINIMUM_PYTHON_313_VERSION = (0, 9, 1)
+
+
+def _parse_requirement_version(requirement: str) -> tuple[int, ...]:
+    match = re.fullmatch(r"truststore==(\d+)\.(\d+)\.(\d+)", requirement)
+    assert match is not None
+    return tuple(int(part) for part in match.groups())
+
+
+def test_truststore_pin_matches_between_dependency_surfaces():
+    requirements_lines = (REPO_ROOT / "requirements.txt").read_text(encoding="utf-8").splitlines()
+    requirements_pin = next(line for line in requirements_lines if line.startswith("truststore=="))
+
+    pyproject_text = (REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8")
+    pyproject_match = re.search(r'"(truststore==\d+\.\d+\.\d+)"', pyproject_text)
+    assert pyproject_match is not None
+    pyproject_pin = pyproject_match.group(1)
+
+    assert requirements_pin == pyproject_pin
+
+
+def test_truststore_pin_supports_python_313_ssl_chain_api():
+    requirements_lines = (REPO_ROOT / "requirements.txt").read_text(encoding="utf-8").splitlines()
+    requirements_pin = next(line for line in requirements_lines if line.startswith("truststore=="))
+
+    if sys.version_info >= (3, 13):
+        assert _parse_requirement_version(requirements_pin) >= TRUSTSTORE_MINIMUM_PYTHON_313_VERSION

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/tests/test_poly_custom.py

@@ -7,7 +7,16 @@ from concurrent.futures import ThreadPoolExecutor
 def _reload_polyapi():
     sys.modules.pop("polyapi", None)
     sys.modules.pop("polyapi.cli", None)
-    return importlib.import_module("polyapi")
+    polyapi = importlib.import_module("polyapi")
+
+    for module_name, module in list(sys.modules.items()):
+        if not module_name.startswith("polyapi.") or module_name == "polyapi.cli":
+            continue
+        submodule_name = module_name.removeprefix("polyapi.")
+        if "." not in submodule_name:
+            setattr(polyapi, submodule_name, module)
+
+    return polyapi
 
 
 def test_import_polyapi_does_not_import_cli():
@@ -24,6 +33,14 @@ def test_cli_constants_shared_between_runtime_and_cli():
     assert tuple(cli_module.CLI_COMMANDS) == cli_constants.CLI_COMMANDS
 
 
+def test_reload_preserves_existing_submodule_bindings():
+    rendered_spec = importlib.import_module("polyapi.rendered_spec")
+
+    polyapi = _reload_polyapi()
+
+    assert polyapi.rendered_spec is rendered_spec
+
+
 def test_poly_custom_nested_scopes_restore_previous_state():
     polyapi = _reload_polyapi()
     poly_custom = polyapi.polyCustom

polyapi_python-0.3.18/tests/test_poly_schemas.py

@@ -0,0 +1,124 @@
+import unittest
+
+from polyapi.poly_schemas import _fix_typed_dict_imports
+
+
+class TestFixTypedDictImports(unittest.TestCase):
+    """Tests for _fix_typed_dict_imports, which rewrites TypedDict/NotRequired
+    from `typing` to `typing_extensions` in jsonschema_gentypes output."""
+
+    # TypedDict moved out of `typing`
+
+    def test_typeddict_removed_from_typing_import(self):
+        code = "from typing import Union, List, TypedDict\n\nclass Foo(TypedDict):\n    x: int"
+        result = _fix_typed_dict_imports(code)
+        self.assertNotIn("from typing import Union, List, TypedDict", result)
+        self.assertNotIn("TypedDict", result.split("from typing_extensions")[0].split("from typing")[-1] if "from typing import" in result else "")
+
+    def test_typeddict_present_in_typing_extensions(self):
+        code = "from typing import Union, List, TypedDict\n\nclass Foo(TypedDict):\n    x: int"
+        result = _fix_typed_dict_imports(code)
+        self.assertIn("from typing_extensions import", result)
+        self.assertIn("TypedDict", result)
+
+    def test_notrequired_removed_from_typing_import(self):
+        code = "from typing import Union, List, TypedDict, NotRequired\n\nclass Foo(TypedDict):\n    x: int"
+        result = _fix_typed_dict_imports(code)
+        # NotRequired must NOT appear in a `from typing import` line
+        for line in result.splitlines():
+            if line.startswith("from typing import"):
+                self.assertNotIn("NotRequired", line)
+
+    def test_notrequired_present_in_typing_extensions(self):
+        code = "from typing import Union, TypedDict, NotRequired\n\nclass Foo(TypedDict):\n    x: NotRequired[int]"
+        result = _fix_typed_dict_imports(code)
+        self.assertIn("NotRequired", result)
+        te_line = next(l for l in result.splitlines() if "from typing_extensions import" in l)
+        self.assertIn("NotRequired", te_line)
+
+    # Remaining typing imports preserved
+
+    def test_other_typing_names_kept(self):
+        code = "from typing import Union, List, TypedDict, Optional"
+        result = _fix_typed_dict_imports(code)
+        typing_line = next((l for l in result.splitlines() if l.startswith("from typing import")), "")
+        self.assertIn("Union", typing_line)
+        self.assertIn("List", typing_line)
+        self.assertIn("Optional", typing_line)
+
+    def test_typing_line_dropped_when_only_typeddict(self):
+        # If TypedDict was the only import, the `from typing import` line should be gone
+        code = "from typing import TypedDict\n\nclass Foo(TypedDict):\n    pass"
+        result = _fix_typed_dict_imports(code)
+        self.assertNotIn("from typing import", result)
+
+    # Existing typing_extensions import is merged, not duplicated
+
+    def test_existing_te_import_gets_typeddict_merged(self):
+        code = (
+            "from typing import Union, TypedDict\n"
+            "from typing_extensions import NotRequired\n"
+            "\nclass Foo(TypedDict):\n    x: NotRequired[int]"
+        )
+        result = _fix_typed_dict_imports(code)
+        te_lines = [l for l in result.splitlines() if "from typing_extensions import" in l]
+        self.assertEqual(len(te_lines), 1, "Should have exactly one typing_extensions import line")
+        self.assertIn("TypedDict", te_lines[0])
+        self.assertIn("NotRequired", te_lines[0])
+
+    def test_no_duplicate_typing_extensions_line(self):
+        code = (
+            "from typing_extensions import NotRequired\n"
+            "from typing import List, TypedDict\n"
+        )
+        result = _fix_typed_dict_imports(code)
+        te_lines = [l for l in result.splitlines() if "from typing_extensions import" in l]
+        self.assertEqual(len(te_lines), 1)
+
+    # No existing typing_extensions import — one is prepended
+
+    def test_te_import_prepended_when_absent(self):
+        code = "from typing import Union, TypedDict\n\nclass Foo(TypedDict):\n    pass"
+        result = _fix_typed_dict_imports(code)
+        first_meaningful = next(l for l in result.splitlines() if l.strip())
+        self.assertIn("from typing_extensions import", first_meaningful)
+
+    # Code with no TypedDict at all is left structurally intact
+
+    def test_code_without_typeddict_unchanged_structure(self):
+        code = "from typing import Union, List\n\nx: List[int] = []"
+        result = _fix_typed_dict_imports(code)
+        # typing_extensions is prepended (no existing te import)
+        self.assertIn("from typing_extensions import", result)
+        # original typing import preserved
+        self.assertIn("from typing import Union, List", result)
+        # original assignment preserved
+        self.assertIn("x: List[int] = []", result)
+
+    def test_code_with_no_imports_gets_te_prepended(self):
+        code = "x = 1\ny = 2"
+        result = _fix_typed_dict_imports(code)
+        self.assertTrue(result.startswith("from typing_extensions import"))
+
+    # The rewrite doesn't break class bodies that use TypedDict
+
+    def test_typeddict_class_body_preserved(self):
+        code = (
+            "from typing import Union, List, TypedDict\n"
+            "\nclass Item(TypedDict):\n"
+            "    name: str\n"
+            "    value: Union[int, None]\n"
+        )
+        result = _fix_typed_dict_imports(code)
+        self.assertIn("class Item(TypedDict):", result)
+        self.assertIn("name: str", result)
+        self.assertIn("value: Union[int, None]", result)
+
+    def test_empty_string_input(self):
+        result = _fix_typed_dict_imports("")
+        # Should at minimum prepend the typing_extensions import
+        self.assertIn("from typing_extensions import", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/tests/test_server.py

@@ -66,6 +66,34 @@ LIST_RECOMMENDATIONS = {
 }
 
 
+RETURN_TYPE_NAMED_RETURN_TYPE = {
+    "id": "ret-1234",
+    "type": "serverFunction",
+    "context": "mixed",
+    "name": "fooFunc",
+    "description": "Return type name collision regression test.",
+    "requirements": [],
+    "function": {
+        "arguments": [],
+        "returnType": {
+            "kind": "object",
+            "schema": {
+                "title": "ReturnType",
+                "type": "object",
+                "properties": {
+                    "value": {"type": "string"},
+                },
+                "required": ["value"],
+            },
+        },
+        "synchronous": True,
+    },
+    "code": "",
+    "language": "javascript",
+    "visibilityMetadata": {"visibility": "ENVIRONMENT"},
+}
+
+
 class T(unittest.TestCase):
     def test_render_function_twilio_server(self):
         # same test but try it as a serverFunction rather than an apiFunction
@@ -117,3 +145,67 @@ class T(unittest.TestCase):
 # stay_date: Required[str]
 # """ Required property """'''
 #         self.assertIn(expected_return_type, func_str)
+
+
+    def test_render_function_return_type_name_collision_does_not_reference_module_attr(self):
+        return_type = RETURN_TYPE_NAMED_RETURN_TYPE["function"]["returnType"]
+        func_str, func_type_defs = render_server_function(
+            RETURN_TYPE_NAMED_RETURN_TYPE["type"],
+            RETURN_TYPE_NAMED_RETURN_TYPE["name"],
+            RETURN_TYPE_NAMED_RETURN_TYPE["id"],
+            RETURN_TYPE_NAMED_RETURN_TYPE["description"],
+            RETURN_TYPE_NAMED_RETURN_TYPE["function"]["arguments"],
+            return_type,
+        )
+        self.assertIn("-> dict", func_str)
+        self.assertNotIn(".returnType", func_str)
+        self.assertNotIn(".ReturnType", func_str)
+
+    def test_render_function_string_union_returns_text(self):
+        function_name = "getMaybeName"
+        return_type = {"kind": "plain", "value": "Promise<string | null>"}
+
+        func_str, _ = render_server_function(
+            "serverFunction",
+            function_name,
+            "ret-str-null-1",
+            "",
+            [],
+            return_type,
+        )
+
+        self.assertIn("-> str | None", func_str)
+        self.assertIn("try:\n        return resp.text", func_str)
+        self.assertNotIn("return resp.json()", func_str)
+
+    def test_render_function_mixed_string_union_returns_json(self):
+        function_name = "getMaybePayload"
+        return_type = {"kind": "plain", "value": "string | object"}
+
+        func_str, _ = render_server_function(
+            "serverFunction",
+            function_name,
+            "ret-str-obj-1",
+            "",
+            [],
+            return_type,
+        )
+
+        self.assertIn("-> str | Dict", func_str)
+        self.assertIn("try:\n        return resp.json()", func_str)
+
+    def test_render_function_number_nullable_returns_json(self):
+        function_name = "getMaybeCount"
+        return_type = {"kind": "plain", "value": "number | null"}
+
+        func_str, _ = render_server_function(
+            "serverFunction",
+            function_name,
+            "ret-num-null-1",
+            "",
+            [],
+            return_type,
+        )
+
+        self.assertIn("-> float | None", func_str)
+        self.assertIn("try:\n        return resp.json()", func_str)

{polyapi_python-0.3.17.dev1 → polyapi_python-0.3.18}/tests/test_utils.py

@@ -1,5 +1,5 @@
 import unittest
-from polyapi.utils import get_type_and_def, rewrite_reserved
+from polyapi.utils import add_type_import_path, get_type_and_def, rewrite_reserved
 
 OPENAPI_FUNCTION = {
     "kind": "function",
@@ -84,3 +84,26 @@ class T(unittest.TestCase):
     def test_rewrite_reserved(self):
         rv = rewrite_reserved("from")
         self.assertEqual(rv, "_from")
+
+    def test_plain_return_type_utility_normalizes_to_any(self):
+        arg_type, arg_def = get_type_and_def({"kind": "plain", "value": "ReturnType<typeof fooFunc>"})
+        self.assertEqual(arg_type, "Any")
+        self.assertEqual(arg_def, "")
+
+    def test_plain_promise_union_normalizes_to_python_union(self):
+        arg_type, arg_def = get_type_and_def({"kind": "plain", "value": "Promise<string | null>"})
+        self.assertEqual(arg_type, "str | None")
+        self.assertEqual(arg_def, "")
+
+    def test_add_type_import_path_never_qualifies_return_type_utility(self):
+        arg_type = add_type_import_path("fooFunc", "ReturnType<typeof fooFunc>")
+        self.assertEqual(arg_type, "Any")
+
+    def test_plain_promise_array_union_normalizes_to_python_union(self):
+        arg_type, arg_def = get_type_and_def({"kind": "plain", "value": "Promise<string[] | null>"})
+        self.assertEqual(arg_type, "List[str] | None")
+        self.assertEqual(arg_def, "")
+
+    def test_add_type_import_path_keeps_array_union_primitives_valid(self):
+        arg_type = add_type_import_path("fooFunc", "Promise<string[] | null>")
+        self.assertEqual(arg_type, "List[str] | None")

polyapi_python-0.3.17.dev1/polyapi_python.egg-info/requires.txt

@@ -1,9 +0,0 @@
-requests>=2.32.3
-typing_extensions>=4.12.2
-jsonschema-gentypes==2.10.0
-pydantic<3.0.0,>=2.8.0
-stdlib_list<1.0.0,>=0.10.0
-colorama==0.4.4
-python-socketio[asyncio_client]==5.11.1
-truststore>=0.8.0
-httpx>=0.28.1