python 增加对Namespace的检查

Author: realybin

unity/Assets/core/upm/Runtime/Src/Backends/BackendPython.cs

@@ -69,7 +69,7 @@ import types
 from importlib import machinery
 
 _csTypeCache_ = dict()
-
+_p_loader = scriptEnv.GetLoader()
 
 class PesapiLoader(importlib.abc.Loader):
 
@@ -78,7 +78,14 @@ def exec_module(self, mod):
 
     def create_module(self, spec: machinery.ModuleSpec):
         type_name = spec.name
-        return puerts.load_type(type_name)
+        if _p_loader.get_NamespaceManager().IsValidNamespace(type_name):
+            return NameSpaceProxy(type_name)
+        else:
+            result = puerts.load_type(type_name)
+            if result is not None:
+                return result
+            else:
+                raise ModuleNotFoundError(f'No namespace or type named {type_name}')
 
 
 class PesapiFinder(importlib.abc.MetaPathFinder):
@@ -94,16 +101,24 @@ def __init__(self, namespace_name: str):
         self.__p_namespace_name = namespace_name
 
     def __getattr__(self, attr: str):
-        return puerts.load_type(self.__p_namespace_name + '.' + attr)
+        full_name = self.__p_namespace_name + '.' + attr
+        result = puerts.load_type(full_name)
+        if result is not None:
+            return result
+        else:
+            if _p_loader.get_NamespaceManager().IsValidNamespace(full_name):
+                return NameSpaceProxy(full_name)
+            else:
+                raise ModuleNotFoundError(f'No namespace or type named {full_name}')
 
 
 class puerts:
     @staticmethod
     def load_type(type_name: str):
         """"""
-        Load a C# class or generic type definition, or return a namespace proxy if the type is not found.
+        Load a C# class or generic type definition, or return None if the type is not found.
         :param type_name: The full name of the C# type to load. If the type is generic, use the format 'TypeName__Tn' where n is the number of generic parameters.
-        :return: The loaded C# class or generic type definition, or a namespace proxy if the type is not found.
+        :return: The loaded C# class or generic type definition, or None if the type is not found.
         """"""
         generic_tick_index = type_name.find('__T')
         if generic_tick_index != -1:
@@ -114,7 +129,8 @@ def load_type(type_name: str):
             return _csTypeCache_[type_name]
         cs_type = scriptEnv.GetTypeByString(type_name)
         if cs_type is None:
-            return NameSpaceProxy(type_name)
+            print('Type not found: ' + type_name)
+            return None
         if cs_type.IsGenericTypeDefinition:
             # cache generic type definitions directly
             _csTypeCache_[type_name] = cs_type

unity/Assets/core/upm/Runtime/Src/Loaders/PythonLoader.cs

@@ -6,11 +6,16 @@
 */
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 
 namespace Puerts
 {
     public class PythonLoader : ILoader
     {
+        public static NamespaceManager NamespaceManager { get; } = new NamespaceManager();
+
         public bool FileExists(string filepath)
         {
             throw new NotImplementedException();
@@ -22,6 +27,83 @@ public string ReadFile(string filepath, out string debugpath)
         }
     }
 
+    public class NamespaceManager
+    {
+        private readonly HashSet<string> _namespaces = new HashSet<string>();
+        private static readonly object _lock = new object();
+
+        public NamespaceManager()
+        {
+            AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoad;
+            LoadNamespacesFromLoadedAssemblies();
+        }
+
+        private void LoadNamespacesFromLoadedAssemblies()
+        {
+            lock (_lock)
+            {
+                var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+                foreach (var assembly in assemblies)
+                {
+                    AddNamespacesFromAssembly(assembly);
+                }
+            }
+        }
+
+        private void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
+        {
+            lock (_lock)
+            {
+                AddNamespacesFromAssembly(args.LoadedAssembly);
+            }
+        }
+
+        private void AddNamespacesFromAssembly(Assembly assembly)
+        {
+            try
+            {
+                var types = assembly.GetTypes();
+                foreach (var type in types)
+                {
+                    if (!string.IsNullOrEmpty(type.Namespace))
+                    {
+                        _namespaces.Add(type.Namespace);
+                    }
+                }
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                foreach (var type in ex.Types)
+                {
+                    if (type != null && !string.IsNullOrEmpty(type.Namespace))
+                    {
+                        _namespaces.Add(type.Namespace);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error on loading assembly {assembly.FullName}: {ex.Message}");
+            }
+        }
+
+        public IEnumerable<string> GetAllNamespaces()
+        {
+            lock (_lock)
+            {
+                return _namespaces.OrderBy(ns => ns).ToList();
+            }
+        }
+
+        public bool IsValidNamespace(string namespaceName)
+        {
+            lock (_lock)
+            {
+                return _namespaces.Contains(namespaceName);
+            }
+        }
+    }
+
     public class PythonDefaultLoader : PythonLoader
     {
     }

unity/test/Src/Cases/Python/CSharpModuleTest.cs

@@ -87,6 +87,74 @@ public void AccessInnerClass()
             Assert.AreEqual(3, result);
             pythonEnv.Dispose();
         }
+
+        [Test]
+        public void NameSpaceAccessTest()
+        {
+            var pythonEnv = new ScriptEnv(new BackendPython());
+            // 1 level namespace
+            pythonEnv.Eval(@"
+exec('''
+import System.Console
+''')
+");
+            // 2 level namespace
+            pythonEnv.Eval(@"
+exec('''
+import System.Diagnostics
+''')
+");
+            // 2 level namespace with class
+            pythonEnv.Eval(@"
+exec('''
+import System.Diagnostics.Debug
+''')
+");
+            // 2 level namespace with NameSpaceProxy Access
+            pythonEnv.Eval(@"
+exec('''
+import System.Diagnostics
+System.Diagnostics.Debug.WriteLine('Test')
+''')
+");
+
+            // 2 level namespace with NameSpaceProxy Access
+            pythonEnv.Eval(@"
+exec('''
+import System.Diagnostics as Diagnostics
+Diagnostics.Debug.WriteLine('Test')
+''')
+");
+
+            try
+            {
+                pythonEnv.Eval(@"
+exec('''
+import System.Diagnostics
+System.Diagnostics.Hello
+''')
+");
+            }
+            catch (Exception e)
+            {
+                Assert.True(e.Message.Contains("ModuleNotFoundError: No namespace or type named System.Diagnostics.Hello"), "Unexpected error message" + e.Message);
+            }
+
+            try
+            {
+                pythonEnv.Eval(@"
+exec('''
+import System.Diagnostics as Diagnostics
+Diagnostics.Hello
+''')
+");
+            }
+            catch (Exception e)
+            {
+                Assert.True(e.Message.Contains("ModuleNotFoundError: No namespace or type named System.Diagnostics.Hello"), "Unexpected error message" + e.Message);
+            }
+            pythonEnv.Dispose();
+        }
         /*
         [Test]
         public void GenericMethodTest()