xoscar 0.7.17__tar.gz → 0.8.0rc1__tar.gz

{xoscar-0.7.17 → xoscar-0.8.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xoscar
-Version: 0.7.17
+Version: 0.8.0rc1
 Summary: Python actor framework for heterogeneous computing.
 Home-page: http://github.com/xorbitsai/xoscar
 Author: Qin Xuye

{xoscar-0.7.17 → xoscar-0.8.0rc1}/pyproject.toml

@@ -51,6 +51,6 @@ log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(linen
 log_cli_date_format = "%Y-%m-%d %H:%M:%S"
 
 [tool.cibuildwheel]
-build = ["cp39-*", "cp310-*", "cp311-*", "cp312-*"]
-skip = "pp* *musllinux* *i686 cp36* cp38-win32 cp39-win32 cp310-win32 cp311-win32 cp312-win32"
+build = ["cp39-*", "cp310-*", "cp311-*", "cp312-*", "cp313-*"]
+skip = "pp* *musllinux* *i686 cp38-win32 cp39-win32 cp310-win32 cp311-win32 cp312-win32 cp313-win32"
 manylinux-x86_64-image = "manylinux2014"

{xoscar-0.7.17 → xoscar-0.8.0rc1}/xoscar/backends/communication/socket.py

@@ -31,7 +31,7 @@ from urllib.parse import urlparse
 from ..._utils import to_binary
 from ...constants import XOSCAR_CONNECT_TIMEOUT, XOSCAR_UNIX_SOCKET_DIR
 from ...serialization import AioDeserializer, AioSerializer, deserialize
-from ...utils import classproperty, implements, is_py_312, is_v6_ip
+from ...utils import classproperty, implements, is_py_312, is_py_312_or_above, is_v6_ip
 from .base import Channel, ChannelType, Client, Server
 from .core import register_client, register_server
 from .errors import ChannelClosed
@@ -192,9 +192,9 @@ class _BaseSocketServer(Server, metaclass=ABCMeta):
     @implements(Server.stop)
     async def stop(self):
         self._aio_server.close()
-        # Python 3.12: # https://github.com/python/cpython/issues/104344
-        # `wait_closed` leads to hang
-        if not is_py_312():
+        # Python 3.12+: # https://github.com/python/cpython/issues/104344
+        # `wait_closed` leads to hang in Python 3.12 and 3.13
+        if not is_py_312_or_above():
             await self._aio_server.wait_closed()
         # close all channels
         await asyncio.gather(

{xoscar-0.7.17 → xoscar-0.8.0rc1}/xoscar/backends/core.py

@@ -244,7 +244,27 @@ def _cancel_all_tasks(loop):
     for task in to_cancel:
         task.cancel()
 
-    loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True))
+    # In Python 3.13+, we need to use a different approach to avoid deadlocks
+    # when shutting down event loops in threads
+    if hasattr(asyncio, "run"):
+        # For Python 3.13+, use a more robust approach
+        async def _gather_cancelled():
+            await asyncio.gather(*to_cancel, return_exceptions=True)
+
+        try:
+            # Try to run the gather in the current loop context
+            if loop.is_running():
+                # If loop is running, schedule the gather
+                asyncio.run_coroutine_threadsafe(_gather_cancelled(), loop)
+            else:
+                # If loop is not running, we can run it directly
+                loop.run_until_complete(_gather_cancelled())
+        except RuntimeError:
+            # If we can't run the gather, just log and continue
+            logger.debug("Could not gather cancelled tasks during shutdown")
+    else:
+        # For older Python versions, use the original approach
+        loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True))
 
     for task in to_cancel:
         if task.cancelled():
@@ -263,8 +283,15 @@ def _safe_run_forever(loop):
     try:
         loop.run_forever()
     finally:
-        _cancel_all_tasks(loop)
-        loop.stop()
+        try:
+            _cancel_all_tasks(loop)
+        except Exception as e:
+            logger.debug("Error during task cancellation: %s", e)
+        finally:
+            try:
+                loop.stop()
+            except Exception as e:
+                logger.debug("Error stopping loop: %s", e)
 
 
 class ActorCaller:
@@ -273,12 +300,31 @@ class ActorCaller:
     class _RefHolder:
         pass
 
-    _close_loop = asyncio.new_event_loop()
-    _close_thread = threading.Thread(
-        target=_safe_run_forever, args=(_close_loop,), daemon=True
-    )
-    _close_thread.start()
-    atexit.register(_close_loop.call_soon_threadsafe, _close_loop.stop)
+    _close_loop = None
+    _close_thread = None
+    _initialized = False
+
+    @classmethod
+    def _ensure_initialized(cls):
+        if not cls._initialized:
+            cls._close_loop = asyncio.new_event_loop()
+            cls._close_thread = threading.Thread(
+                target=_safe_run_forever, args=(cls._close_loop,), daemon=True
+            )
+            cls._close_thread.start()
+            atexit.register(cls._cleanup)
+            cls._initialized = True
+
+    @classmethod
+    def _cleanup(cls):
+        if cls._close_loop and cls._close_loop.is_running():
+            try:
+                cls._close_loop.call_soon_threadsafe(cls._close_loop.stop)
+                # Give the loop a moment to stop
+                if cls._close_thread:
+                    cls._close_thread.join(timeout=0.5)  # Shorter timeout for tests
+            except Exception as e:
+                logger.debug("Error during cleanup: %s", e)
 
     def __init__(self):
         self._thread_local = threading.local()
@@ -294,6 +340,8 @@ class ActorCaller:
             # If the thread exit, we clean the related actor callers and channels.
 
             def _cleanup():
+                self._ensure_initialized()
+                # Use the background thread for cleanup
                 asyncio.run_coroutine_threadsafe(actor_caller.stop(), self._close_loop)
                 logger.debug(
                     "Clean up the actor caller due to thread exit: %s", thread_info

{xoscar-0.7.17 → xoscar-0.8.0rc1}/xoscar/backends/indigen/pool.py

@@ -418,26 +418,70 @@ class MainActorPool(MainActorPoolBase):
     async def kill_sub_pool(
         self, process: asyncio.subprocess.Process, force: bool = False
     ):
+        # First, try to terminate the process gracefully
+        if not force:
+            try:
+                process.terminate()
+                # Wait for graceful termination
+                try:
+                    await asyncio.wait_for(process.wait(), timeout=2.0)
+                except asyncio.TimeoutError:
+                    # Process didn't terminate gracefully, force kill
+                    force = True
+            except ProcessLookupError:
+                # Process already terminated
+                pass
+
+        # Force kill if needed or if graceful termination failed
+        if force:
+            try:
+                process.kill()
+            except ProcessLookupError:
+                # Process already dead
+                pass
+
+        # Ensure process is completely terminated and cleaned up
         try:
-            p = psutil.Process(process.pid)
-        except psutil.NoSuchProcess:
-            return
+            # Wait for process to complete
+            if process.returncode is None:
+                try:
+                    await asyncio.wait_for(process.wait(), timeout=5.0)
+                except asyncio.TimeoutError:
+                    pass
+        except ProcessLookupError:
+            # Process already terminated
+            pass
 
-        if not force:  # pragma: no cover
-            p.terminate()
+        # Python 3.13 specific cleanup for waitpid threads
+        if sys.version_info >= (3, 13):
             try:
-                p.wait(5)
-            except psutil.TimeoutExpired:
+                # Close the transport to clean up waitpid thread
+                if hasattr(process, "_transport") and process._transport:
+                    process._transport.close()
+                # Also try to close the pipe transport if it exists
+                if hasattr(process, "_pipes") and process._pipes:
+                    for pipe in process._pipes.values():
+                        if hasattr(pipe, "close"):
+                            pipe.close()
+            except Exception:
+                # Ignore errors during cleanup
                 pass
 
-        count = 0
-        while p.is_running() and count < 3:
-            count += 1
-            p.kill()
-            if not p.is_running():
-                return
-            logger.info("Sub pool can't be killed: %s", p)
-            time.sleep(0.1)
+        # Additional cleanup using psutil to ensure process tree is terminated
+        try:
+            p = psutil.Process(process.pid)
+            if p.is_running():
+                # Kill the entire process tree
+                for child in p.children(recursive=True):
+                    try:
+                        child.kill()
+                    except psutil.NoSuchProcess:
+                        pass
+                p.kill()
+                p.wait(timeout=2.0)
+        except (psutil.NoSuchProcess, psutil.TimeoutExpired):
+            # Process already dead or couldn't be killed
+            pass
 
     async def is_sub_pool_alive(self, process: asyncio.subprocess.Process):
         return process.returncode is None

{xoscar-0.7.17 → xoscar-0.8.0rc1}/xoscar/backends/pool.py

@@ -1337,7 +1337,9 @@ class MainActorPoolBase(ActorPoolBase):
         return pool
 
     async def start_monitor(self):
-        if self._monitor_task is None:
+        # Only start monitor if there are sub processes to monitor
+        # This prevents hanging when n_process=0
+        if self._monitor_task is None and self.sub_processes:
             self._monitor_task = asyncio.create_task(self.monitor_sub_pools())
         return self._monitor_task
 
@@ -1351,7 +1353,12 @@ class MainActorPoolBase(ActorPoolBase):
         self._auto_recover = False
         self._stopped.set()
         if self._monitor_task and not self._monitor_task.done():
-            await self._monitor_task
+            # Cancel the monitor task to ensure it exits immediately
+            self._monitor_task.cancel()
+            try:
+                await self._monitor_task
+            except asyncio.CancelledError:
+                pass  # Expected when cancelling the task
             self._monitor_task = None
         await self.stop_sub_pools()
         await super().stop()
@@ -1406,19 +1413,17 @@ class MainActorPoolBase(ActorPoolBase):
         )
         try:
             if timeout is None:
-                message = await self.call(address, stop_message)
-                if isinstance(message, ErrorMessage):  # pragma: no cover
-                    raise message.as_instanceof_cause()
-            else:
-                call = asyncio.create_task(self.call(address, stop_message))
-                try:
-                    await asyncio.wait_for(call, timeout)
-                except (futures.TimeoutError, asyncio.TimeoutError):  # pragma: no cover
-                    # timeout, just let kill to finish it
-                    force = True
-        except (ConnectionError, ServerClosed):  # pragma: no cover
+                # Use a short timeout for graceful shutdown to avoid hanging
+                timeout = 2.0
+
+            call = asyncio.create_task(self.call(address, stop_message))
+            try:
+                await asyncio.wait_for(call, timeout)
+            except (futures.TimeoutError, asyncio.TimeoutError):
+                force = True
+        except (ConnectionError, ServerClosed):
             # process dead maybe, ignore it
-            pass
+            force = True
         # kill process
         await self.kill_sub_pool(process, force=force)
 

{xoscar-0.7.17 → xoscar-0.8.0rc1}/xoscar/backends/test/pool.py

@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import asyncio
+import sys
 from typing import Any, Optional
 
 from ..communication import DummyServer, gen_local_address
@@ -153,9 +154,44 @@ class TestMainActorPool(MainActorPool):
     async def kill_sub_pool(
         self, process: asyncio.subprocess.Process, force: bool = False
     ):
-        pass
+        # Test pool uses None for processes, so skip if process is None
+        if process is None:
+            return
+
+        if force:
+            try:
+                process.kill()
+            except ProcessLookupError:
+                pass
+
+        # Ensure process is completely terminated and cleaned up
+        try:
+            # Wait for process to complete
+            if process.returncode is None:
+                try:
+                    await asyncio.wait_for(process.wait(), timeout=5.0)
+                except asyncio.TimeoutError:
+                    pass
+        except ProcessLookupError:
+            pass
+
+        # Python 3.13 specific cleanup for waitpid threads
+        if sys.version_info >= (3, 13):
+            try:
+                # Close the transport to clean up waitpid thread
+                if hasattr(process, "_transport") and process._transport:
+                    process._transport.close()
+                # Also try to close the pipe transport if it exists
+                if hasattr(process, "_pipes") and process._pipes:
+                    for pipe in process._pipes.values():
+                        if hasattr(pipe, "close"):
+                            pipe.close()
+            except Exception:
+                # Ignore errors during cleanup
+                pass
 
     async def is_sub_pool_alive(self, process: asyncio.subprocess.Process):
+        # Test pool uses None for processes, so always return True
         return True
 
 

{xoscar-0.7.17 → xoscar-0.8.0rc1}/xoscar/utils.py

@@ -470,6 +470,11 @@ def is_py_312():
     return sys.version_info[:2] == (3, 12)
 
 
+@lru_cache
+def is_py_312_or_above():
+    return sys.version_info[:2] >= (3, 12)
+
+
 def is_v4_zero_ip(ip_port_addr: str) -> bool:
     return ip_port_addr.split("://")[-1].startswith("0.0.0.0:")
 

{xoscar-0.7.17 → xoscar-0.8.0rc1}/xoscar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xoscar
-Version: 0.7.17
+Version: 0.8.0rc1
 Summary: Python actor framework for heterogeneous computing.
 Home-page: http://github.com/xorbitsai/xoscar
 Author: Qin Xuye