Implemented async APIs. Updated sample code to reflect it

budgetdevv · budgetdevv · commit 3489897fab93 · 2024-03-22T15:44:03.000+08:00
diff --git a/PythonNETExtensions/Core/RawPython.cs b/PythonNETExtensions/Core/RawPython.cs
@@ -3,7 +3,10 @@
 using System.Runtime.CompilerServices;
 using System.Text;
 using Python.Runtime;
+using PythonNETExtensions.AsyncIO;
+using PythonNETExtensions.Core.Handles;
 using PythonNETExtensions.Helpers;
+using PythonNETExtensions.Modules;
 
 namespace PythonNETExtensions.Core
 {
@@ -19,15 +22,26 @@ public enum CompilationOption
         public interface IRunOptions
         {
             public static abstract CompilationOption CompilationOption { get; }
+            
             public static abstract bool UseCachedScope { get; }
         }
+        
+        public interface IAsyncRunOptions: IRunOptions
+        {
+            static bool IRunOptions.UseCachedScope => false;
+        }
 
         public struct DefaultRunOptions: IRunOptions
         {
             public static CompilationOption CompilationOption => CompilationOption.Auto;
             public static bool UseCachedScope => false;
         }
         
+        public struct DefaultAsyncRunOptions : IAsyncRunOptions
+        {
+            public static CompilationOption CompilationOption { get; }
+        }
+        
         public struct CachedScopeRunOptions: IRunOptions
         {
             public static CompilationOption CompilationOption => CompilationOption.Auto;
@@ -141,43 +155,76 @@ public override string ToString()
             }
         }
 
+        private static readonly AsyncIOModule ASYNC_IO_MODULE = PythonExtensions.GetConcretePythonModule<AsyncIOModule>();
+        
         private static readonly ConcurrentDictionary<string, PyObject> CODE_TO_COMPILATION_MAP = new(); 
         
         private const string RET_VAR_NAME = "py_ret";
-
+        
         public static void Run(CodeInterpolator<DefaultRunOptions> code)
         {
-            Run<NoRet, DefaultRunOptions>(code);
+            RunInternal<NoRet, DefaultRunOptions>(code, isAsync: false);
         }
         
         public static void RunWithCachedScope(CodeInterpolator<CachedScopeRunOptions> code)
         {
-            Run<NoRet, CachedScopeRunOptions>(code);
+            RunInternal<NoRet, CachedScopeRunOptions>(code, isAsync: false);
         }
         
         public static RetT Run<RetT>(CodeInterpolator<DefaultRunOptions> code)
         {
-            return Run<RetT, DefaultRunOptions>(code);
+            return RunInternal<RetT, DefaultRunOptions>(code, isAsync: false);
         }
         
         public static RetT RunWithCachedScope<RetT>(CodeInterpolator<CachedScopeRunOptions> code)
         {
-            return Run<RetT, CachedScopeRunOptions>(code);
+            return RunInternal<RetT, CachedScopeRunOptions>(code, isAsync: false);
         }
-        
+
         public static RetT Run<RetT, OptsT>(CodeInterpolator<OptsT> code)
+            where OptsT : IRunOptions
+        {
+            return RunInternal<RetT, OptsT>(code, isAsync: false);
+        }
+        
+        public static AsyncIOCoroutineAwaiter RunAsync(CodeInterpolator<DefaultAsyncRunOptions> code, AsyncPythonHandle handle)
+        {
+            return ASYNC_IO_MODULE.RunCoroutine(RunInternal<dynamic, DefaultAsyncRunOptions>(code, isAsync: true), handle);
+        }
+        
+        public static AsyncIOCoroutineAwaiter RunAsync<OptsT>(CodeInterpolator<OptsT> code, AsyncPythonHandle handle)
+            where OptsT : IAsyncRunOptions
+        {
+            return ASYNC_IO_MODULE.RunCoroutine(RunInternal<dynamic, OptsT>(code, isAsync: true), handle);
+        }
+        
+        public static AsyncIOCoroutineAwaiter<RetT> RunAsync<RetT>(CodeInterpolator<DefaultAsyncRunOptions> code, AsyncPythonHandle handle)
+        {
+            return ASYNC_IO_MODULE.RunCoroutine<RetT>(RunInternal<dynamic, DefaultAsyncRunOptions>(code, isAsync: true), handle);
+        }
+        
+        public static AsyncIOCoroutineAwaiter<RetT> RunAsync<RetT, OptsT>(CodeInterpolator<OptsT> code, AsyncPythonHandle handle)
+            where OptsT : IAsyncRunOptions
+        {
+            return ASYNC_IO_MODULE.RunCoroutine<RetT>(RunInternal<dynamic, OptsT>(code, isAsync: true), handle);
+        }
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static RetT RunInternal<RetT, OptsT>(CodeInterpolator<OptsT> code, bool isAsync)
             where OptsT: IRunOptions
         {
             var hasRet = typeof(RetT) != typeof(NoRet);
             
             var codeText = code.ToString();
 
             const string METHOD_WRAPPER_NAME = "py_wrapper_method";
-            
+
+            var asyncModifer = isAsync ? "async " : string.Empty;
+
             // TODO: Somehow optimize performance of this
             codeText = hasRet ?
             $"""
-            def {METHOD_WRAPPER_NAME}():
+            {asyncModifer}def {METHOD_WRAPPER_NAME}():
             {codeText.IndentCode()}
                 
             {RET_VAR_NAME} = {METHOD_WRAPPER_NAME}();
@@ -217,15 +264,30 @@ public static RetT Run<RetT, OptsT>(CodeInterpolator<OptsT> code)
             {
                 scope.Exec(codeText);
             }
-            
-            var ret = scope.Get<RetT>(RET_VAR_NAME);
 
-            if (OptsT.UseCachedScope)
+            var variables = scope.Variables();
+
+            if (hasRet)
             {
-                scope.Variables().Clear();
+                var ret = scope.Get<RetT>(RET_VAR_NAME);
+
+                if (OptsT.UseCachedScope)
+                {
+                    variables.Clear();
+                }
+
+                return ret;
             }
 
-            return ret;
+            else
+            {
+                if (OptsT.UseCachedScope)
+                {
+                    variables.Clear();
+                }
+
+                return default;
+            }
         }
     }
 }
diff --git a/SampleCode/Program.cs b/SampleCode/Program.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using PythonNETExtensions.Config;
@@ -60,22 +61,18 @@ private static async Task Sample()
             
                 var asyncIO = PythonExtensions.GetConcretePythonModule<AsyncIOModule>();
 
-                const int DELAY_SECONDS = 3;
+                const int DELAY_SECONDS = 2;
                 
-                var asyncCoroutine = RawPython.Run<dynamic>
+                Debug.Assert(DELAY_SECONDS >= 2);
+                
+                var awaiter = RawPython.RunAsync
                 (
                 $"""
-                async def async_coroutine():
-                   print("{nameof(asyncIO)} is running!");
-                   await {asyncIO.Sleep(DELAY_SECONDS):py};
-                    
-                return async_coroutine();
-                """
-                 );
-                 
-                var task = asyncIO.RunCoroutine(asyncCoroutine, handle);
-                
-                await task;
+                print("{nameof(asyncIO)} is running!");
+                await {asyncIO.Sleep(DELAY_SECONDS):py};
+                """, handle);
+
+                await awaiter;
             
                 Console.WriteLine($"Hello after {DELAY_SECONDS} seconds");
 
