polyapi-python 0.3.18.dev3__tar.gz → 0.3.18.dev5__tar.gz

{polyapi_python-0.3.18.dev3 → polyapi_python-0.3.18.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.18.dev3
+Version: 0.3.18.dev5
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -32,7 +32,7 @@ Requires-Dist: requests==2.32.3
 Requires-Dist: typing_extensions==4.12.2
 Requires-Dist: jsonschema-gentypes==2.10.0
 Requires-Dist: pydantic==2.8.0
-Requires-Dist: stdlib_list==0.10.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

{polyapi_python-0.3.18.dev3 → polyapi_python-0.3.18.dev5}/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.18.dev3 → polyapi_python-0.3.18.dev5}/polyapi_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.18.dev3
+Version: 0.3.18.dev5
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -32,7 +32,7 @@ Requires-Dist: requests==2.32.3
 Requires-Dist: typing_extensions==4.12.2
 Requires-Dist: jsonschema-gentypes==2.10.0
 Requires-Dist: pydantic==2.8.0
-Requires-Dist: stdlib_list==0.10.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

{polyapi_python-0.3.18.dev3 → polyapi_python-0.3.18.dev5}/polyapi_python.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ 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.dev3 → polyapi_python-0.3.18.dev5}/polyapi_python.egg-info/requires.txt

@@ -2,7 +2,7 @@ requests==2.32.3
 typing_extensions==4.12.2
 jsonschema-gentypes==2.10.0
 pydantic==2.8.0
-stdlib_list==0.10.0
+stdlib_list==0.11.1
 colorama==0.4.4
 python-socketio[asyncio_client]==5.11.1
 truststore==0.8.0

{polyapi_python-0.3.18.dev3 → polyapi_python-0.3.18.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polyapi-python"
-version = "0.3.18.dev3"
+version = "0.3.18.dev5"
 description = "The Python Client for PolyAPI, the IPaaS by Developers for Developers"
 authors = [{ name = "PolyAPI", email = "support@polyapi.io" }]
 dependencies = [
@@ -12,7 +12,7 @@ dependencies = [
     "typing_extensions==4.12.2",
     "jsonschema-gentypes==2.10.0",
     "pydantic==2.8.0",
-    "stdlib_list==0.10.0",
+    "stdlib_list==0.11.1",
     "colorama==0.4.4",
     "python-socketio[asyncio_client]==5.11.1",
     "truststore==0.8.0",

{polyapi_python-0.3.18.dev3 → polyapi_python-0.3.18.dev5}/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.dev5/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()