pythonnet · filmor · Jun 18, 2021 · Jan 15, 2021 · Jan 15, 2021 · Jan 15, 2021
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -50,6 +50,7 @@ One must now either use enum members (e.g. `MyEnum.Option`), or use enum constru
 -   .NET and Python exceptions are preserved when crossing Python/.NET boundary
 -   BREAKING: custom encoders are no longer called for instances of `System.Type`
 -   `PythonException.Restore` no longer clears `PythonException` instance.
+-   Replaced the old `__import__` hook hack with a PEP302-style Meta Path Loader
 
 ### Fixed
 

diff --git a/src/embed_tests/TestPythonException.cs b/src/embed_tests/TestPythonException.cs
@@ -178,6 +178,7 @@ public void TestPythonException_Normalize_ThrowsWhenErrorSet()
             var pythonException = PythonException.FetchCurrentRaw();
             Exceptions.SetError(Exceptions.TypeError, "Another error");
             Assert.Throws<InvalidOperationException>(() => pythonException.Normalize());
+            Exceptions.Clear();
         }
     }
 }
diff --git a/src/runtime/BorrowedReference.cs b/src/runtime/BorrowedReference.cs
@@ -9,6 +9,7 @@ readonly ref struct BorrowedReference
     {
         readonly IntPtr pointer;
         public bool IsNull => this.pointer == IntPtr.Zero;
+        public bool IsNone => this.pointer == Runtime.PyNone;
 
         /// <summary>Gets a raw pointer to the Python object</summary>
         public IntPtr DangerousGetAddress()

diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -37,7 +37,6 @@ internal class AssemblyManager
         // modified from event handlers below, potentially triggered from different .NET threads
         private static ConcurrentQueue<Assembly> assemblies;
         internal static List<string> pypath;
-
         private AssemblyManager()
         {
         }
@@ -312,6 +311,15 @@ public static bool IsValidNamespace(string name)
             return !string.IsNullOrEmpty(name) && namespaces.ContainsKey(name);
         }
 
+        /// <summary>
+        /// Returns an IEnumerable<string> containing the namepsaces exported
+        /// by loaded assemblies in the current app domain.
+        /// </summary>
+        public static IEnumerable<string> GetNamespaces ()
+        {
+            return namespaces.Keys;
+        }
+
         /// <summary>
         /// Returns list of assemblies that declare types in a given namespace
         /// </summary>

diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs
@@ -202,6 +202,14 @@ internal static IntPtr ToPython(object value, Type type)
                     return ClassDerivedObject.ToPython(pyderived);
             }
 
+            // ModuleObjects are created in a way that their wrapping them as
+            // a CLRObject fails, the ClassObject has no tpHandle. Return the
+            // pyHandle as is, do not convert.
+            if (value is ModuleObject modobj)
+            {
+                return modobj.pyHandle;
+            }
+
             // hmm - from Python, we almost never care what the declared
             // type is. we'd rather have the object bound to the actual
             // implementing class.

diff --git a/src/runtime/extensiontype.cs b/src/runtime/extensiontype.cs
@@ -83,7 +83,7 @@ public static int tp_setattro(IntPtr ob, IntPtr key, IntPtr val)
             {
                 message = "readonly attribute";
             }
-            Exceptions.SetError(Exceptions.TypeError, message);
+            Exceptions.SetError(Exceptions.AttributeError, message);
             return -1;
         }