polyapi-python 0.3.15__tar.gz → 0.3.16.dev2__tar.gz

{polyapi_python-0.3.15/polyapi_python.egg-info → polyapi_python-0.3.16.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.15
+Version: 0.3.16.dev2
 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.15 → polyapi_python-0.3.16.dev2}/polyapi/generate.py

@@ -16,7 +16,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 .utils import add_import_to_init, get_auth_headers, init_the_init, print_green, to_func_namespace
+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
 from . import http_client
@@ -506,8 +506,10 @@ def add_function_file(
             with open(init_path, "r", encoding='utf-8') as f:
                 init_content = f.read()
         
-        # Prepare new content to append to __init__.py
-        new_init_content = init_content + f"\n\nfrom . import {func_namespace}\n\n{func_str}"
+        # Import the generated type module under a private alias so PascalCase function
+        # names do not shadow their own module symbol in __init__.py.
+        type_module_alias = to_type_module_alias(function_name)
+        new_init_content = init_content + f"\n\nfrom . import {func_namespace} as {type_module_alias}\n\n{func_str}"
         
         # Use temporary files for atomic writes
         # Write to __init__.py atomically

{polyapi_python-0.3.15 → polyapi_python-0.3.16.dev2}/polyapi/http_client.py

@@ -3,6 +3,7 @@ import httpx
 
 _sync_client: httpx.Client | None = None
 _async_client: httpx.AsyncClient | None = None
+_async_client_loop: asyncio.AbstractEventLoop | None = None
 
 
 def _get_sync_client() -> httpx.Client:
@@ -13,9 +14,11 @@ def _get_sync_client() -> httpx.Client:
 
 
 def _get_async_client() -> httpx.AsyncClient:
-    global _async_client
-    if _async_client is None:
+    global _async_client, _async_client_loop
+    current_loop = asyncio.get_running_loop()
+    if _async_client is None or _async_client_loop is not current_loop:
         _async_client = httpx.AsyncClient(timeout=None)
+        _async_client_loop = current_loop
     return _async_client
 
 
@@ -66,8 +69,15 @@ def close():
         _sync_client = None
 
 async def close_async():
-    global _sync_client, _async_client
+    global _sync_client, _async_client, _async_client_loop
     close()
-    if _async_client is not None:
-        await _async_client.aclose()
-        _async_client = None
+    client = _async_client
+    client_loop = _async_client_loop
+    _async_client = None
+    _async_client_loop = None
+    if client is None:
+        return
+
+    current_loop = asyncio.get_running_loop()
+    if client_loop is current_loop:
+        await client.aclose()

{polyapi_python-0.3.15 → polyapi_python-0.3.16.dev2}/polyapi/utils.py

@@ -71,11 +71,17 @@ def print_red(s: str):
     print(Fore.RED + s + Style.RESET_ALL)
 
 
+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"
+
+
 def add_type_import_path(function_name: str, arg: str) -> str:
     """if not basic type, coerce to camelCase and add the import path"""
     # 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]
+    type_module_alias = to_type_module_alias(function_name)
     
     if arg.startswith("Callable"):
         inner = arg[len("Callable["):-1]  # strip outer Callable[...]
@@ -84,7 +90,7 @@ def add_type_import_path(function_name: str, arg: str) -> str:
         for p in parts:
             clean = p.strip("[] ")
             if clean and clean not in BASIC_PYTHON_TYPES:
-                replacement = f"{to_func_namespace(function_name)}.{camelCase(clean)}"
+                replacement = f"{type_module_alias}.{camelCase(clean)}"
                 p = p.replace(clean, replacement)
             qualified.append(p)
         return "Callable[" + ",".join(qualified) + "]"
@@ -100,11 +106,11 @@ def add_type_import_path(function_name: str, arg: str) -> str:
         else:
             if '"' in sub:
                 sub = sub.replace('"', "")
-                return f'List["{to_func_namespace(function_name)}.{camelCase(sub)}"]'
+                return f'List["{type_module_alias}.{camelCase(sub)}"]'
             else:
-                return f"List[{to_func_namespace(function_name)}.{camelCase(sub)}]"
+                return f"List[{type_module_alias}.{camelCase(sub)}]"
 
-    return f"{to_func_namespace(function_name)}.{camelCase(arg)}"
+    return f"{type_module_alias}.{camelCase(arg)}"
 
 
 def get_type_and_def(
@@ -352,4 +358,4 @@ def return_type_already_defined_in_args(return_type_name: str, args_def: str) ->
     basic_match = bool(re.search(basic_pattern, args_def, re.MULTILINE))
     class_pattern = rf"^class {re.escape(return_type_name)}\(TypedDict"
     class_match = bool(re.search(class_pattern, args_def, re.MULTILINE))
-    return basic_match or class_match
+    return basic_match or class_match

{polyapi_python-0.3.15 → polyapi_python-0.3.16.dev2/polyapi_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.15
+Version: 0.3.16.dev2
 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.15 → polyapi_python-0.3.16.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polyapi-python"
-version = "0.3.15"
+version = "0.3.16.dev2"
 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.15 → polyapi_python-0.3.16.dev2}/tests/test_api.py

@@ -1,7 +1,7 @@
 import unittest
 
 from polyapi.api import render_api_function
-from polyapi.utils import to_func_namespace
+from polyapi.utils import to_type_module_alias
 
 ACCUWEATHER = {
     "id": "f7588018-2364-4586-b60d",
@@ -236,7 +236,7 @@ class T(unittest.TestCase):
         )
         self.assertIn(ACCUWEATHER["id"], func_str)
         self.assertIn("locationId: int,", func_str)
-        self.assertIn(f"-> {to_func_namespace(name)}.{name}Response", func_str)
+        self.assertIn(f"-> {to_type_module_alias(name)}.{name}Response", func_str)
 
     def test_render_function_zillow(self):
         name = ZILLOW["name"]
@@ -250,7 +250,7 @@ class T(unittest.TestCase):
         )
         self.assertIn(ZILLOW["id"], func_str)
         self.assertIn("locationId: int,", func_str)
-        self.assertIn(f"-> {to_func_namespace(name)}.{name}Response", func_str)
+        self.assertIn(f"-> {to_type_module_alias(name)}.{name}Response", func_str)
 
     def test_render_function_twilio_api(self):
         name = TWILIO["name"]
@@ -265,7 +265,7 @@ class T(unittest.TestCase):
         self.assertIn(TWILIO["id"], func_str)
         self.assertIn("conversationSID: str", func_str)
         self.assertIn("authToken: str", func_str)
-        self.assertIn(f"-> {to_func_namespace(name)}.{name}Response", func_str)
+        self.assertIn(f"-> {to_type_module_alias(name)}.{name}Response", func_str)
 
     def test_render_function_twilio_get_details(self):
         # same test but try it as a serverFunction rather than an apiFunction
@@ -279,6 +279,6 @@ class T(unittest.TestCase):
             TWILIO_GET_DETAILS["function"]["returnType"],
         )
         self.assertIn(TWILIO_GET_DETAILS["id"], func_str)
-        self.assertIn(f"-> {to_func_namespace(name)}.{name}Response", func_str)
+        self.assertIn(f"-> {to_type_module_alias(name)}.{name}Response", func_str)
         self.assertIn("class SubresourceUris", func_type_defs)
         # self.assertIn('Required["SubresourceUris"]', func_type_defs)

{polyapi_python-0.3.15 → polyapi_python-0.3.16.dev2}/tests/test_async_proof.py

@@ -56,10 +56,12 @@ class TestHttpClientPairing:
         # Reset singletons so each test starts fresh
         http_client._sync_client = None
         http_client._async_client = None
+        http_client._async_client_loop = None
 
     def teardown_method(self):
         http_client._sync_client = None
         http_client._async_client = None
+        http_client._async_client_loop = None
 
     @patch.object(httpx.Client, "post", return_value=_fake_response())
     def test_sync_post_uses_sync_client(self, mock_post):
@@ -79,6 +81,90 @@ class TestHttpClientPairing:
         mock_post.assert_called_once()
         assert resp.status_code == 200
         assert http_client._async_client is not None
+        assert http_client._async_client_loop is not None
+
+    def test_async_post_reuses_client_within_same_loop(self):
+        first_client = MagicMock()
+        first_client.post = AsyncMock(return_value=_fake_response())
+
+        with patch("polyapi.http_client.httpx.AsyncClient", return_value=first_client) as mock_async_client:
+            async def _run():
+                first_response = await http_client.async_post("https://example.com/first", json={})
+                second_response = await http_client.async_post("https://example.com/second", json={})
+                return first_response, second_response, asyncio.get_running_loop()
+
+            first_response, second_response, current_loop = asyncio.run(_run())
+
+        assert first_response.status_code == 200
+        assert second_response.status_code == 200
+        assert mock_async_client.call_count == 1
+        assert first_client.post.await_count == 2
+        assert http_client._async_client is first_client
+        assert http_client._async_client_loop is current_loop
+
+    def test_async_post_recreates_client_after_loop_change(self):
+        first_client = MagicMock()
+        first_client.post = AsyncMock(return_value=_fake_response())
+        second_client = MagicMock()
+        second_client.post = AsyncMock(return_value=_fake_response())
+
+        with patch(
+            "polyapi.http_client.httpx.AsyncClient",
+            side_effect=[first_client, second_client],
+        ) as mock_async_client:
+            async def _run_once(url: str):
+                response = await http_client.async_post(url, json={})
+                return response, http_client._async_client, asyncio.get_running_loop()
+
+            first_response, first_cached_client, first_loop = asyncio.run(_run_once("https://example.com/first"))
+            second_response, second_cached_client, second_loop = asyncio.run(_run_once("https://example.com/second"))
+
+        assert first_response.status_code == 200
+        assert second_response.status_code == 200
+        assert mock_async_client.call_count == 2
+        assert first_client.post.await_count == 1
+        assert second_client.post.await_count == 1
+        assert first_cached_client is first_client
+        assert second_cached_client is second_client
+        assert first_loop is not second_loop
+        assert http_client._async_client is second_client
+        assert http_client._async_client_loop is second_loop
+
+    def test_close_async_clears_cached_client_for_current_loop(self):
+        async def _run():
+            cached_client = MagicMock()
+            cached_client.aclose = AsyncMock()
+            http_client._async_client = cached_client
+            http_client._async_client_loop = asyncio.get_running_loop()
+
+            await http_client.close_async()
+
+            return cached_client
+
+        cached_client = asyncio.run(_run())
+
+        cached_client.aclose.assert_awaited_once()
+        assert http_client._async_client is None
+        assert http_client._async_client_loop is None
+
+    def test_close_async_drops_stale_client_without_cross_loop_close(self):
+        stale_client = MagicMock()
+        stale_client.aclose = AsyncMock()
+
+        async def _seed_stale_client():
+            http_client._async_client = stale_client
+            http_client._async_client_loop = asyncio.get_running_loop()
+
+        asyncio.run(_seed_stale_client())
+
+        async def _close_on_new_loop():
+            await http_client.close_async()
+
+        asyncio.run(_close_on_new_loop())
+
+        stale_client.aclose.assert_not_awaited()
+        assert http_client._async_client is None
+        assert http_client._async_client_loop is None
 
     @patch.object(httpx.Client, "get", return_value=_fake_response())
     def test_sync_get(self, mock_get):

{polyapi_python-0.3.15 → polyapi_python-0.3.16.dev2}/tests/test_generate.py

@@ -2,9 +2,11 @@ import unittest
 import os
 import shutil
 import importlib.util
+import tempfile
 from unittest.mock import patch, MagicMock
-from polyapi.utils import get_type_and_def, rewrite_reserved
-from polyapi.generate import render_spec, create_empty_schemas_module, generate_functions, create_function
+from polyapi.typedefs import SpecificationDto
+from polyapi.utils import get_type_and_def, rewrite_reserved, to_type_module_alias
+from polyapi.generate import render_spec, create_empty_schemas_module, generate_functions, create_function, add_function_file
 from polyapi.poly_schemas import generate_schemas, create_schema
 from polyapi.variables import generate_variables, create_variable
 
@@ -660,3 +662,45 @@ def test_nested_function() -> schemas.api.v1.user.profile:
                     # The failed function directory should not exist
                     func_dir = os.path.join(context_dir, "failing_function")
                     self.assertFalse(os.path.exists(func_dir))
+
+    def test_add_function_file_aliases_pascal_case_type_module(self):
+        spec: SpecificationDto = {
+            "id": "test-func-id",
+            "name": "CreateAJsonPost",
+            "context": "test_context",
+            "type": "apiFunction",
+            "description": "Test function",
+            "language": "python",
+            "function": {
+                "arguments": [],
+                "returnType": {
+                    "kind": "object",
+                    "schema": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "integer"},
+                        },
+                        "required": ["id"],
+                        "title": "ReturnType",
+                    },
+                },
+            },
+        }
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            add_function_file(temp_dir, spec["name"], spec)
+
+            init_path = os.path.join(temp_dir, "__init__.py")
+            with open(init_path, "r", encoding="utf-8") as file:
+                init_content = file.read()
+
+            type_module_alias = to_type_module_alias(spec["name"])
+            self.assertIn(
+                f"from . import {spec['name']} as {type_module_alias}",
+                init_content,
+            )
+            self.assertIn(f"def {spec['name']}(", init_content)
+            self.assertIn(
+                f"-> {type_module_alias}.{spec['name']}Response",
+                init_content,
+            )

{polyapi_python-0.3.15 → polyapi_python-0.3.16.dev2}/tests/test_server.py

@@ -1,6 +1,6 @@
 import unittest
 
-from polyapi.utils import to_func_namespace
+from polyapi.utils import to_type_module_alias
 
 from .test_api import TWILIO
 from polyapi.server import render_server_function
@@ -81,7 +81,7 @@ class T(unittest.TestCase):
         self.assertIn(TWILIO["id"], func_str)
         self.assertIn("conversationSID: str", func_str)
         self.assertIn("authToken: str", func_str)
-        self.assertIn(f"-> {to_func_namespace(name)}.ResponseType", func_str)
+        self.assertIn(f"-> {to_type_module_alias(name)}.ResponseType", func_str)
 
     def test_render_function_get_products_count(self):
         return_type = GET_PRODUCTS_COUNT["function"]["returnType"]
@@ -116,4 +116,4 @@ class T(unittest.TestCase):
 
 # stay_date: Required[str]
 # """ Required property """'''
-#         self.assertIn(expected_return_type, func_str)
+#         self.assertIn(expected_return_type, func_str)