Forward Python stdout/stderr to Apple unified logging

Added SeriousPythonLogForwarder to capture and forward Python stdout and stderr to Apple's unified logging system on iOS/macOS. This enables Python output to appear in flutter run and Xcode logs. The feature can be disabled by setting SERIOUS_PYTHON_FORWARD_STDIO=0 in environmentVariables. Updated README with usage details.

Author: FeodorFitsner

src/serious_python/README.md

@@ -181,6 +181,12 @@ Use `--verbose` flag to enabled detailed logging:
 dart run serious_python:main package app/src -p Darwin --verbose
 ```
 
+### iOS/macOS Python output
+
+On Darwin (iOS/macOS), Python `stdout`/`stderr` is forwarded into Apple’s unified logging, so it’s visible in `flutter run` and Xcode logs.
+
+To disable forwarding, set `SERIOUS_PYTHON_FORWARD_STDIO=0` in `environmentVariables`.
+
 ## Examples
 
 [Python REPL with Flask backend](src/serious_python/example/flask_example).

src/serious_python_darwin/darwin/Classes/SeriousPythonPlugin.swift

@@ -5,7 +5,11 @@ import UIKit
 import FlutterMacOS
 #endif
 
+import Foundation
+import Dispatch
+import Darwin
 import Python
+import os.log
 
 public class SeriousPythonPlugin: NSObject, FlutterPlugin {
 
@@ -110,6 +114,7 @@ public class SeriousPythonPlugin: NSObject, FlutterPlugin {
     }
 
     @objc func runPythonFile(appPath: String) {
+        SeriousPythonLogForwarder.shared.beginCapturing()
         Py_Initialize()
 
         // run app
@@ -120,9 +125,11 @@ public class SeriousPythonPlugin: NSObject, FlutterPlugin {
         }
 
         Py_Finalize()
+        SeriousPythonLogForwarder.shared.endCapturing()
     }
 
     @objc func runPythonScript(script: String) {
+        SeriousPythonLogForwarder.shared.beginCapturing()
         Py_Initialize()
 
         // run app
@@ -132,5 +139,144 @@ public class SeriousPythonPlugin: NSObject, FlutterPlugin {
         }
 
         Py_Finalize()
+        SeriousPythonLogForwarder.shared.endCapturing()
+    }
+}
+
+private final class SeriousPythonLogForwarder {
+    static let shared = SeriousPythonLogForwarder()
+    
+    private let lock = NSLock()
+    private var captureCount = 0
+    private let enableEnvVar = "SERIOUS_PYTHON_FORWARD_STDIO"
+    
+    private var originalStdout: Int32 = -1
+    private var originalStderr: Int32 = -1
+    private var pipeReadFD: Int32 = -1
+    private var source: DispatchSourceRead?
+    
+    private let queue = DispatchQueue(label: "serious_python.log_forwarder")
+    private var buffer = Data()
+    private let log = OSLog(subsystem: "dev.flet.serious_python", category: "python")
+    
+    func beginCapturing() {
+        lock.lock()
+        defer { lock.unlock() }
+        
+        if let v = ProcessInfo.processInfo.environment[enableEnvVar]?.lowercased(),
+           v == "0" || v == "false" || v == "no" {
+            return
+        }
+        
+        captureCount += 1
+        guard captureCount == 1 else { return }
+        
+        var fds: [Int32] = [0, 0]
+        guard pipe(&fds) == 0 else {
+            os_log("serious_python: failed to create pipe: errno=%d", log: log, type: .error, errno)
+            captureCount = 0
+            return
+        }
+        
+        originalStdout = dup(STDOUT_FILENO)
+        originalStderr = dup(STDERR_FILENO)
+        
+        fflush(stdout)
+        fflush(stderr)
+        setbuf(stdout, nil)
+        setbuf(stderr, nil)
+        
+        _ = dup2(fds[1], STDOUT_FILENO)
+        _ = dup2(fds[1], STDERR_FILENO)
+        close(fds[1])
+        
+        pipeReadFD = fds[0]
+        _ = fcntl(pipeReadFD, F_SETFL, O_NONBLOCK)
+        
+        let src = DispatchSource.makeReadSource(fileDescriptor: pipeReadFD, queue: queue)
+        src.setEventHandler { [weak self] in
+            self?._drain()
+        }
+        src.setCancelHandler { [weak self] in
+            guard let self else { return }
+            if self.pipeReadFD >= 0 {
+                close(self.pipeReadFD)
+                self.pipeReadFD = -1
+            }
+        }
+        source = src
+        src.resume()
+    }
+    
+    func endCapturing() {
+        lock.lock()
+        defer { lock.unlock() }
+        
+        guard captureCount > 0 else { return }
+        captureCount -= 1
+        guard captureCount == 0 else { return }
+        
+        fflush(stdout)
+        fflush(stderr)
+        queue.sync { self._drain() }
+        
+        if originalStdout >= 0 {
+            _ = dup2(originalStdout, STDOUT_FILENO)
+            close(originalStdout)
+            originalStdout = -1
+        }
+        
+        if originalStderr >= 0 {
+            _ = dup2(originalStderr, STDERR_FILENO)
+            close(originalStderr)
+            originalStderr = -1
+        }
+        
+        queue.sync { self._drain() }
+        
+        source?.cancel()
+        source = nil
+        
+        if !buffer.isEmpty {
+            _emit(String(decoding: buffer, as: UTF8.self))
+            buffer.removeAll(keepingCapacity: false)
+        }
+    }
+    
+    private func _drain() {
+        guard pipeReadFD >= 0 else { return }
+        
+        var chunk = [UInt8](repeating: 0, count: 4096)
+        while true {
+            let n = read(pipeReadFD, &chunk, chunk.count)
+            if n > 0 {
+                buffer.append(contentsOf: chunk[0..<n])
+                _flushLines()
+                if buffer.count > 32 * 1024 {
+                    _emit(String(decoding: buffer, as: UTF8.self))
+                    buffer.removeAll(keepingCapacity: true)
+                }
+            } else if n == 0 {
+                break
+            } else {
+                if errno == EAGAIN || errno == EWOULDBLOCK { break }
+                os_log("serious_python: read() failed: errno=%d", log: log, type: .error, errno)
+                break
+            }
+        }
+    }
+    
+    private func _flushLines() {
+        while let newlineIndex = buffer.firstIndex(of: 0x0A) {
+            let lineData = buffer.subdata(in: 0..<newlineIndex)
+            buffer.removeSubrange(0...newlineIndex)
+            _emit(String(decoding: lineData, as: UTF8.self))
+        }
+    }
+    
+    private func _emit(_ message: String) {
+        let trimmed = message.trimmingCharacters(in: .newlines)
+        guard !trimmed.isEmpty else { return }
+        os_log("%{public}@", log: log, type: .default, trimmed)
     }
 }