pythonnet
diff --git a/src/embed_tests/GlobalTestsSetup.cs b/src/embed_tests/GlobalTestsSetup.cs
@@ -7,7 +7,7 @@ namespace Python.EmbeddingTest
     // As the SetUpFixture, the OneTimeTearDown of this class is executed after
     // all tests have run.
     [SetUpFixture]
-    public class GlobalTestsSetup
+    public partial class GlobalTestsSetup
     {
         [OneTimeTearDown]
         public void FinalCleanup()

diff --git a/src/embed_tests/TestFinalizer.cs b/src/embed_tests/TestFinalizer.cs
@@ -101,7 +101,17 @@ public void CollectOnShutdown()
 
             PythonEngine.Shutdown();
             garbage = Finalizer.Instance.GetCollectedObjects();
-            Assert.IsEmpty(garbage);
+
+            if (garbage.Count > 0)
+            {
+                PythonEngine.Initialize();
+                string objects = string.Join("\n", garbage.Select(ob =>
+                {
+                    var obj = new PyObject(new BorrowedReference(ob));
+                    return $"{obj} [{obj.GetPythonType()}@{obj.Handle}]";
+                }));
+                Assert.Fail("Garbage is not empty:\n" + objects);
+            }
         }
 
         [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] // ensure lack of references to obj
@@ -173,7 +183,7 @@ public void SimpleTestMemory()
             bool oldState = Finalizer.Instance.Enable;
             try
             {
-                using (PyObject gcModule = PythonEngine.ImportModule("gc"))
+                using (PyModule gcModule = PyModule.Import("gc"))
                 using (PyObject pyCollect = gcModule.GetAttr("collect"))
                 {
                     long span1 = CompareWithFinalizerOn(pyCollect, false);

diff --git a/src/embed_tests/TestNativeTypeOffset.cs b/src/embed_tests/TestNativeTypeOffset.cs
@@ -9,7 +9,7 @@
 
 using Python.Runtime;
 
-namespace Python.EmbeddingPythonTest
+namespace Python.EmbeddingTest
 {
     public class TestNativeTypeOffset
     {

diff --git a/src/embed_tests/TestPythonException.cs b/src/embed_tests/TestPythonException.cs
@@ -46,7 +46,7 @@ public void TestPythonErrorTypeName()
         {
             try
             {
-                var module = PythonEngine.ImportModule("really____unknown___module");
+                var module = PyModule.Import("really____unknown___module");
                 Assert.Fail("Unknown module should not be loaded");
             }
             catch (PythonException ex)
@@ -95,7 +95,7 @@ public void TestPythonExceptionFormatNoTraceback()
         {
             try
             {
-                var module = PythonEngine.ImportModule("really____unknown___module");
+                var module = PyModule.Import("really____unknown___module");
                 Assert.Fail("Unknown module should not be loaded");
             }
             catch (PythonException ex)

diff --git a/src/embed_tests/TestRuntime.cs b/src/embed_tests/TestRuntime.cs
@@ -96,7 +96,7 @@ public static void PyCheck_Iter_PyObject_IsIterable_ThreadingLock_Test()
             // TypeFlags.HaveIter set in Python 2. This tests a different code path in PyObject_IsIterable and PyIter_Check.
             var threading = Runtime.Runtime.PyImport_ImportModule("threading");
             Exceptions.ErrorCheck(threading);
-            var threadingDict = Runtime.Runtime.PyModule_GetDict(new BorrowedReference(threading));
+            var threadingDict = Runtime.Runtime.PyModule_GetDict(threading);
             Exceptions.ErrorCheck(threadingDict);
             var lockType = Runtime.Runtime.PyDict_GetItemString(threadingDict, "Lock");
             if (lockType.IsNull)
@@ -110,6 +110,8 @@ public static void PyCheck_Iter_PyObject_IsIterable_ThreadingLock_Test()
             Assert.IsFalse(Runtime.Runtime.PyObject_IsIterable(lockInstance));
             Assert.IsFalse(Runtime.Runtime.PyIter_Check(lockInstance));
 
+            threading.Dispose();
+
             Runtime.Runtime.Py_Finalize();
         }
     }

diff --git a/src/embed_tests/pyimport.cs b/src/embed_tests/pyimport.cs
@@ -52,7 +52,7 @@ public void Dispose()
         [Test]
         public void TestDottedName()
         {
-            PyObject module = PythonEngine.ImportModule("PyImportTest.test.one");
+            var module = PyModule.Import("PyImportTest.test.one");
             Assert.IsNotNull(module);
         }
 
@@ -62,7 +62,7 @@ public void TestDottedName()
         [Test]
         public void TestSysArgsImportException()
         {
-            PyObject module = PythonEngine.ImportModule("PyImportTest.sysargv");
+            var module = PyModule.Import("PyImportTest.sysargv");
             Assert.IsNotNull(module);
         }
 

diff --git a/src/embed_tests/pyinitialize.cs b/src/embed_tests/pyinitialize.cs
@@ -175,7 +175,8 @@ public static void TestRunExitFuncs()
             {
                 called = true;
             };
-            atexit.InvokeMethod("register", callback.ToPython());
+            atexit.InvokeMethod("register", callback.ToPython()).Dispose();
+            atexit.Dispose();
             Runtime.Runtime.Shutdown();
             Assert.True(called);
         }

diff --git a/src/runtime/BorrowedReference.cs b/src/runtime/BorrowedReference.cs
@@ -28,6 +28,14 @@ public BorrowedReference(IntPtr pointer)
             => a.pointer == b.pointer;
         public static bool operator !=(BorrowedReference a, BorrowedReference b)
             => a.pointer != b.pointer;
+        public static bool operator ==(BorrowedReference reference, NullOnly @null)
+            => reference.IsNull;
+        public static bool operator !=(BorrowedReference reference, NullOnly @null)
+            => !reference.IsNull;
+        public static bool operator ==(NullOnly @null, BorrowedReference reference)
+            => reference.IsNull;
+        public static bool operator !=(NullOnly @null, BorrowedReference reference)
+            => !reference.IsNull;
 
         public override bool Equals(object obj) {
             if (obj is IntPtr ptr)

diff --git a/src/runtime/CustomMarshaler.cs b/src/runtime/CustomMarshaler.cs
@@ -189,49 +189,4 @@ public static ICustomMarshaler GetInstance(string cookie)
             return Instance;
         }
     }
-
-
-    /// <summary>
-    /// Custom Marshaler to deal with Managed String to Native
-    /// conversion on UTF-8. Use on functions that expect UTF-8 encoded
-    /// strings like `PyUnicode_FromStringAndSize`
-    /// </summary>
-    /// <remarks>
-    /// If instead we used `MarshalAs(UnmanagedType.LPWStr)` the output to
-    /// `foo` would be `f\x00o\x00o\x00`.
-    /// </remarks>
-    internal class Utf8Marshaler : MarshalerBase
-    {
-        private static readonly MarshalerBase Instance = new Utf8Marshaler();
-        private static readonly Encoding PyEncoding = Encoding.UTF8;
-
-        public override IntPtr MarshalManagedToNative(object managedObj)
-        {
-            var s = managedObj as string;
-
-            if (s == null)
-            {
-                return IntPtr.Zero;
-            }
-
-            byte[] bStr = PyEncoding.GetBytes(s + "\0");
-            IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
-            try
-            {
-                Marshal.Copy(bStr, 0, mem, bStr.Length);
-            }
-            catch (Exception)
-            {
-                Marshal.FreeHGlobal(mem);
-                throw;
-            }
-
-            return mem;
-        }
-
-        public static ICustomMarshaler GetInstance(string cookie)
-        {
-            return Instance;
-        }
-    }
 }
diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs
@@ -95,24 +95,21 @@ internal static Exception ToException(IntPtr ob)
     /// </remarks>
     public static class Exceptions
     {
-        internal static IntPtr warnings_module;
-        internal static IntPtr exceptions_module;
+        internal static PyModule warnings_module;
+        internal static PyModule exceptions_module;
 
         /// <summary>
         /// Initialization performed on startup of the Python runtime.
         /// </summary>
         internal static void Initialize()
         {
             string exceptionsModuleName = "builtins";
-            exceptions_module = Runtime.PyImport_ImportModule(exceptionsModuleName);
-
-            Exceptions.ErrorCheck(exceptions_module);
-            warnings_module = Runtime.PyImport_ImportModule("warnings");
-            Exceptions.ErrorCheck(warnings_module);
+            exceptions_module = PyModule.Import(exceptionsModuleName);
+            warnings_module = PyModule.Import("warnings");
             Type type = typeof(Exceptions);
             foreach (FieldInfo fi in type.GetFields(BindingFlags.Public | BindingFlags.Static))
             {
-                IntPtr op = Runtime.PyObject_GetAttrString(exceptions_module, fi.Name);
+                IntPtr op = Runtime.PyObject_GetAttrString(exceptions_module.obj, fi.Name);
                 if (op != IntPtr.Zero)
                 {
                     fi.SetValue(type, op);
@@ -147,8 +144,8 @@ internal static void Shutdown()
                 Runtime.XDecref(op);
                 fi.SetValue(null, IntPtr.Zero);
             }
-            Runtime.Py_CLEAR(ref exceptions_module);
-            Runtime.Py_CLEAR(ref warnings_module);
+            exceptions_module.Dispose();
+            warnings_module.Dispose();
         }
 
         /// <summary>
@@ -348,9 +345,7 @@ public static void warn(string message, IntPtr exception, int stacklevel)
                 Exceptions.RaiseTypeError("Invalid exception");
             }
 
-            Runtime.XIncref(warnings_module);
-            IntPtr warn = Runtime.PyObject_GetAttrString(warnings_module, "warn");
-            Runtime.XDecref(warnings_module);
+            IntPtr warn = Runtime.PyObject_GetAttrString(warnings_module.obj, "warn");
             Exceptions.ErrorCheck(warn);
 
             IntPtr args = Runtime.PyTuple_New(3);

diff --git a/src/runtime/importhook.cs b/src/runtime/importhook.cs
@@ -155,7 +155,7 @@ public static unsafe NewReference GetCLRModule(BorrowedReference fromList = defa
 
             // find any items from the from list and get them from the root if they're not
             // already in the module dictionary
-            if (fromList != null && fromList != default)
+            if (fromList != null)
             {
                 if (Runtime.PyTuple_Check(fromList))
                 {
@@ -224,7 +224,7 @@ public static IntPtr __import__(IntPtr self, IntPtr argsRaw, IntPtr kw)
             if (num_args >= 4)
             {
                 fromList = Runtime.PyTuple_GetItem(args, 3);
-                if (fromList != default &&
+                if (fromList != null &&
                     Runtime.PyObject_IsTrue(fromList) == 1)
                 {
                     fromlist = true;
@@ -297,7 +297,7 @@ public static IntPtr __import__(IntPtr self, IntPtr argsRaw, IntPtr kw)
             BorrowedReference modules = Runtime.PyImport_GetModuleDict();
             BorrowedReference module = Runtime.PyDict_GetItem(modules, py_mod_name);
 
-            if (module != default)
+            if (module != null)
             {
                 if (fromlist)
                 {

diff --git a/src/runtime/pymodule.cs b/src/runtime/pymodule.cs
@@ -0,0 +1,41 @@
+using System;
+
+namespace Python.Runtime
+{
+    public class PyModule : PyScope
+    {
+        internal PyModule(ref NewReference reference) : base(ref reference, PyScopeManager.Global) { }
+        public PyModule(PyObject o) : base(o.Reference, PyScopeManager.Global) { }
+
+        /// <summary>
+        /// Given a module or package name, import the
+        /// module and return the resulting module object as a <see cref="PyModule"/>.
+        /// </summary>
+        /// <param name="name">Fully-qualified module or package name</param>
+        public static PyModule Import(string name)
+        {
+            NewReference op = Runtime.PyImport_ImportModule(name);
+            PythonException.ThrowIfIsNull(op);
+            return new PyModule(ref op);
+        }
+
+        /// <summary>
+        /// Reloads the module, and returns the updated object
+        /// </summary>
+        public PyModule Reload()
+        {
+            NewReference op = Runtime.PyImport_ReloadModule(this.Reference);
+            PythonException.ThrowIfIsNull(op);
+            return new PyModule(ref op);
+        }
+
+        public static PyModule FromString(string name, string code)
+        {
+            using NewReference c = Runtime.Py_CompileString(code, "none", (int)RunFlagType.File);
+            PythonException.ThrowIfIsNull(c);
+            NewReference m = Runtime.PyImport_ExecCodeModule(name, c);
+            PythonException.ThrowIfIsNull(m);
+            return new PyModule(ref m);
+        }
+    }
+}