Use long-lived isolate for Python execution

Introduces a single, persistent isolate to run Python code, ensuring the 'main thread' identity is preserved across invocations. Adds signal handling patch for non-main threads to prevent errors with libraries like asyncio. Refactors run logic to serialize all Python runs on one thread for consistency.

Author: FeodorFitsner

src/serious_python_android/lib/src/cpython.dart

@@ -11,6 +11,11 @@ import 'gen.dart';
 export 'gen.dart';
 
 CPython? _cpython;
+// Keep a single, long-lived isolate/thread for running Python to preserve the
+// "main thread" identity across invocations.
+Isolate? _pythonIsolate;
+SendPort? _pythonSendPort;
+bool _signalPatched = false;
 
 void _pyLog(String msg) {
   debugPrint("[PY] ${DateTime.now().toIso8601String()} $msg");
@@ -22,23 +27,45 @@ CPython getCPython(String dynamicLibPath) {
 
 Future<String> runPythonProgramFFI(bool sync, String dynamicLibPath,
     String pythonProgramPath, String script) async {
-  final receivePort = ReceivePort();
   if (sync) {
-    // sync run
+    // sync run on current isolate/thread
+    final rp = ReceivePort();
     return await runPythonProgramInIsolate(
-        [receivePort.sendPort, dynamicLibPath, pythonProgramPath, script]);
-  } else {
-    var completer = Completer<String>();
-    // async run
-    final isolate = await Isolate.spawn(runPythonProgramInIsolate,
-        [receivePort.sendPort, dynamicLibPath, pythonProgramPath, script]);
-    receivePort.listen((message) {
-      receivePort.close();
-      isolate.kill();
-      completer.complete(message);
-    });
-    return completer.future;
+        [rp.sendPort, dynamicLibPath, pythonProgramPath, script]);
+  }
+
+  // Ensure a single long-lived isolate/thread to keep Python "main thread" consistent.
+  if (_pythonIsolate == null || _pythonSendPort == null) {
+    final readyPort = ReceivePort();
+    _pythonIsolate =
+        await Isolate.spawn(_pythonIsolateMain, readyPort.sendPort);
+    _pythonSendPort = await readyPort.first as SendPort;
+    readyPort.close();
   }
+
+  final response = ReceivePort();
+  _pythonSendPort!
+      .send([response.sendPort, dynamicLibPath, pythonProgramPath, script]);
+  final result = await response.first as String;
+  response.close();
+  return result;
+}
+
+// Long-lived isolate entry point to serialize all Python runs on one thread.
+void _pythonIsolateMain(SendPort readyPort) {
+  final commandPort = ReceivePort();
+  readyPort.send(commandPort.sendPort);
+  commandPort.listen((message) async {
+    final args = message as List<Object>;
+    final sendPort = args[0] as SendPort;
+    final dynamicLibPath = args[1] as String;
+    final pythonProgramPath = args[2] as String;
+    final script = args[3] as String;
+    final result = await runPythonProgramInIsolate(
+        [sendPort, dynamicLibPath, pythonProgramPath, script]);
+    // runPythonProgramInIsolate already sends the result, but return anyway.
+    sendPort.send(result);
+  });
 }
 
 Future<String> runPythonProgramInIsolate(List<Object> arguments) async {
@@ -72,6 +99,19 @@ Future<String> runPythonProgramInIsolate(List<Object> arguments) async {
   final gilState = cpython.PyGILState_Ensure();
   _pyLog("PyGILState_Ensure -> $gilState");
 
+  // Patch signal handling if we're not on the interpreter's main thread; some
+  // libraries (e.g., asyncio) call signal.signal which would otherwise raise.
+  if (!_signalPatched) {
+    const patch = """
+import threading, signal
+if threading.current_thread() is not threading.main_thread():
+    signal.signal = lambda *args, **kwargs: None
+""";
+    _pyLog("patching signal.signal for non-main thread use");
+    cpython.PyRun_SimpleString(patch.toNativeUtf8().cast());
+    _signalPatched = true;
+  }
+
   try {
     if (script != "") {
       // run script