Simplify python initialization

Author: intitni

ExtensionService/InitializePython.swift

@@ -2,38 +2,37 @@ import Foundation
 import Python
 import PythonHelper
 import PythonKit
+import Logger
 
+@MainActor
 func initializePython() {
     guard let sitePackagePath = Bundle.main.path(forResource: "site-packages", ofType: nil),
           let stdLibPath = Bundle.main.path(forResource: "python-stdlib", ofType: nil),
           let libDynloadPath = Bundle.main.path(
               forResource: "python-stdlib/lib-dynload",
               ofType: nil
           )
-    else { return }
-
-    setenv("PYTHONHOME", stdLibPath, 1)
-    setenv("PYTHONPATH", "\(stdLibPath):\(libDynloadPath):\(sitePackagePath)", 1)
-
-    // Initialize python
-    Py_Initialize()
-
-    // Immediately release the thread, so that we can ensure the GIL state later.
-    // We may not recover the thread because all future tasks will be done in the Python Thread.
-    _ = PyEval_SaveThread()
+    else {
+        Logger.service.info("Python is not installed!")
+        return
+    }
 
-    // Setup GIL state guard.
-    PythonHelper.gilStateEnsure = { PyGILState_Ensure() }
-    PythonHelper.gilStateRelease = { gilState in PyGILState_Release(gilState as! PyGILState_STATE) }
+    PythonHelper.initializePython(
+        sitePackagePath: sitePackagePath,
+        stdLibPath: stdLibPath,
+        libDynloadPath: libDynloadPath,
+        Py_Initialize: Py_Initialize,
+        PyEval_SaveThread: PyEval_SaveThread,
+        PyGILState_Ensure: PyGILState_Ensure,
+        PyGILState_Release: PyGILState_Release
+    )
 
     Task {
         // All future task should run inside runPython.
         try runPython {
             let sys = Python.import("sys")
-            print("Python Version: \(sys.version_info.major).\(sys.version_info.minor)")
+            Logger.service.info("Python Version: \(sys.version_info.major).\(sys.version_info.minor)")
         }
     }
 }
 
-let queue = DispatchQueue(label: "")
-

Tool/Sources/PythonHelper/RunPython.swift

@@ -1,8 +1,8 @@
 import Foundation
 import PythonKit
 
-public var gilStateEnsure: (() -> Any)!
-public var gilStateRelease: ((Any) -> Void)!
+var gilStateEnsure: (() -> Any)!
+var gilStateRelease: ((Any) -> Void)!
 func gilStateGuard<T>(_ closure: @escaping () throws -> T) throws -> T {
     let state = gilStateEnsure()
     do {
@@ -15,6 +15,32 @@ func gilStateGuard<T>(_ closure: @escaping () throws -> T) throws -> T {
     }
 }
 
+@MainActor
+var isPythonInitialized = false
+@MainActor
+public func initializePython<GilState, ThreadState>(
+    sitePackagePath: String,
+    stdLibPath: String,
+    libDynloadPath: String,
+    Py_Initialize: () -> Void,
+    PyEval_SaveThread: () -> ThreadState,
+    PyGILState_Ensure: @escaping () -> GilState,
+    PyGILState_Release: @escaping (GilState) -> Void
+) {
+    guard !isPythonInitialized else { return }
+    setenv("PYTHONHOME", stdLibPath, 1)
+    setenv("PYTHONPATH", "\(stdLibPath):\(libDynloadPath):\(sitePackagePath)", 1)
+    isPythonInitialized = true
+    // Initialize python
+    Py_Initialize()
+    // Immediately release the thread, so that we can ensure the GIL state later.
+    // We may not recover the thread because all future tasks will be done in the other threads.
+    _ = PyEval_SaveThread()
+    // Setup GIL state guard.
+    gilStateEnsure = { PyGILState_Ensure() }
+    gilStateRelease = { gilState in PyGILState_Release(gilState as! GilState) }
+}
+
 public func runPython<T>(
     usePythonThread: Bool = false,
     _ closure: @escaping () throws -> T