fix(toolbox-core): Attempt to close underlying managed session during gc

Author: anubhav756

packages/toolbox-core/src/toolbox_core/client.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 
+from asyncio import get_running_loop
 from types import MappingProxyType
 from typing import Any, Awaitable, Callable, Mapping, Optional, Union
 
@@ -140,6 +141,22 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         """
         await self.close()
 
+    def __del__(self):
+        # This method is a "best-effort" safety net.
+        # It should NOT be relied upon for guaranteed resource cleanup.
+        # Explicitly using "async with" or calling "await client.close()" is the correct way.
+        if self.__manage_session:
+            try:
+                loop = get_running_loop()
+            except RuntimeError:
+                loop = None
+
+            if loop and loop.is_running():
+                # If a loop is running, try to schedule the close operation.
+                # This is "fire-and-forget"; there's no guarantee it will complete
+                # before the loop or interpreter shuts down.
+                loop.create_task(self.__session.close())
+
     async def close(self):
         """
         Asynchronously closes the underlying client session. Doing so will cause
@@ -148,7 +165,7 @@ async def close(self):
         If the session was provided externally during initialization, the caller
         is responsible for its lifecycle.
         """
-        if self.__manage_session:
+        if self.__manage_session and not self.__session.closed:
             await self.__session.close()
 
     async def load_tool(

packages/toolbox-core/src/toolbox_core/sync_client.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 
-import asyncio
+from asyncio import AbstractEventLoop, new_event_loop, run_coroutine_threadsafe
 from threading import Thread
 from typing import Any, Awaitable, Callable, Mapping, Optional, Union
 
@@ -29,7 +29,7 @@ class ToolboxSyncClient:
     service endpoint.
     """
 
-    __loop: Optional[asyncio.AbstractEventLoop] = None
+    __loop: Optional[AbstractEventLoop] = None
     __thread: Optional[Thread] = None
 
     def __init__(
@@ -49,7 +49,7 @@ def __init__(
         # Running a loop in a background thread allows us to support async
         # methods from non-async environments.
         if self.__class__.__loop is None:
-            loop = asyncio.new_event_loop()
+            loop = new_event_loop()
             thread = Thread(target=loop.run_forever, daemon=True)
             thread.start()
             self.__class__.__thread = thread
@@ -58,7 +58,7 @@ def __init__(
         async def create_client():
             return ToolboxClient(url, client_headers=client_headers)
 
-        self.__async_client = asyncio.run_coroutine_threadsafe(
+        self.__async_client = run_coroutine_threadsafe(
             create_client(), self.__class__.__loop
         ).result()
 
@@ -67,8 +67,12 @@ def close(self):
         Synchronously closes the underlying client session. Doing so will cause
         any tools created by this Client to cease to function.
         """
-        coro = self.__async_client.close()
-        asyncio.run_coroutine_threadsafe(coro, self.__loop).result()
+        if not self.__async_client.__session.closed:
+            coro = self.__async_client.close()
+            run_coroutine_threadsafe(coro, self.__loop).result()
+
+    def __del__(self):
+        self.close()
 
     def load_tool(
         self,
@@ -104,7 +108,7 @@ def load_tool(
         if not self.__loop or not self.__thread:
             raise ValueError("Background loop or thread cannot be None.")
 
-        async_tool = asyncio.run_coroutine_threadsafe(coro, self.__loop).result()
+        async_tool = run_coroutine_threadsafe(coro, self.__loop).result()
         return ToolboxSyncTool(async_tool, self.__loop, self.__thread)
 
     def load_toolset(
@@ -147,7 +151,7 @@ def load_toolset(
         if not self.__loop or not self.__thread:
             raise ValueError("Background loop or thread cannot be None.")
 
-        async_tools = asyncio.run_coroutine_threadsafe(coro, self.__loop).result()
+        async_tools = run_coroutine_threadsafe(coro, self.__loop).result()
         return [
             ToolboxSyncTool(async_tool, self.__loop, self.__thread)
             for async_tool in async_tools