Jun 1, 2021 · May 5, 2020 · Feb 25, 2020 · May 5, 2020 · May 5, 2020 · May 5, 2020
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
        run: |
          python -m pythonnet.find_libpython --export | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append

      - name: Embedding tests
        run: dotnet test --runtime any-${{ matrix.platform }} src/embed_tests/

      - name: Python Tests (Mono)
        if: ${{ matrix.os != 'windows' }}
        run: pytest --runtime mono
        if: ${{ matrix.os == 'windows' }}
        run: pytest --runtime netfx

      - name: Embedding tests
        run: dotnet test --runtime any-${{ matrix.platform }} src/embed_tests/

      - name: Python tests run from .NET
        run: dotnet test --runtime any-${{ matrix.platform }} src/python_tests_runner/

diff --git a/CHANGELOG.md b/CHANGELOG.md
 -   Add GetPythonThreadID and Interrupt methods in PythonEngine
 -   Ability to implement delegates with `ref` and `out` parameters in Python, by returning the modified parameter values in a tuple. ([#1355][i1355])
 -   `PyType` - a wrapper for Python type objects, that also permits creating new heap types from `TypeSpec`
 -    Improved exception handling:
  -  exceptions can now be converted with codecs
  -  `InnerException` and `__cause__` are propagated properly

 ### Changed
 -   Drop support for Python 2, 3.4, and 3.5
 -   Sign Runtime DLL with a strong name
 -   Implement loading through `clr_loader` instead of the included `ClrModule`, enables
    support for .NET Core
 -   .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.

 ### Fixed

 ### Removed

 -   implicit assembly loading (you have to explicitly `clr.AddReference` before doing import)
 -   messages in `PythonException` no longer start with exception type
 -   support for .NET Framework 4.0-4.6; Mono before 5.4. Python.NET now requires .NET Standard 2.0
 (see [the matrix](https://docs.microsoft.com/en-us/dotnet/standard/net-standard#net-implementation-support))

diff --git a/src/embed_tests/Codecs.cs b/src/embed_tests/Codecs.cs

            PythonEngine.Exec(PyCode);
        }

        const string TestExceptionMessage = "Hello World!";
        [Test]
        public void ExceptionEncoded()
        {
            PyObjectConversions.RegisterEncoder(new ValueErrorCodec());
            void CallMe() => throw new ValueErrorWrapper(TestExceptionMessage);
            var callMeAction = new Action(CallMe);
            using var _ = Py.GIL();
            using var scope = Py.CreateScope();
            scope.Exec(@"
 def call(func):
  try:
    func()
  except ValueError as e:
    return str(e)
 ");
            var callFunc = scope.Get("call");
            string message = callFunc.Invoke(callMeAction.ToPython()).As<string>();
            Assert.AreEqual(TestExceptionMessage, message);
        }

        [Test]
        public void ExceptionDecoded()
        {
            PyObjectConversions.RegisterDecoder(new ValueErrorCodec());
            using var _ = Py.GIL();
            using var scope = Py.CreateScope();
            var error = Assert.Throws<ValueErrorWrapper>(()
                => PythonEngine.Exec($"raise ValueError('{TestExceptionMessage}')"));
            Assert.AreEqual(TestExceptionMessage, error.Message);
        }

        class ValueErrorWrapper : Exception
        {
            public ValueErrorWrapper(string message) : base(message) { }
        }

        class ValueErrorCodec : IPyObjectEncoder, IPyObjectDecoder
        {
            public bool CanDecode(PyObject objectType, Type targetType)
                => this.CanEncode(targetType) && objectType.Equals(PythonEngine.Eval("ValueError"));

            public bool CanEncode(Type type) => type == typeof(ValueErrorWrapper)
                                                || typeof(ValueErrorWrapper).IsSubclassOf(type);

            public bool TryDecode<T>(PyObject pyObj, out T value)
            {
                var message = pyObj.GetAttr("args")[0].As<string>();
                value = (T)(object)new ValueErrorWrapper(message);
                return true;
            }

            public PyObject TryEncode(object value)
            {
                var error = (ValueErrorWrapper)value;
                return PythonEngine.Eval("ValueError").Invoke(error.Message.ToPython());
            }
        }
    }

    /// <summary>
diff --git a/src/embed_tests/TestCallbacks.cs b/src/embed_tests/TestCallbacks.cs
            using (Py.GIL()) {
                dynamic callWith42 = PythonEngine.Eval("lambda f: f([42])");
                var error =  Assert.Throws<PythonException>(() => callWith42(aFunctionThatCallsIntoPython.ToPython()));
                Assert.AreEqual("TypeError", error.PythonTypeName);
                Assert.AreEqual("TypeError", error.Type.Name);
                string expectedArgTypes = "(<class 'list'>)";
                StringAssert.EndsWith(expectedArgTypes, error.Message);
            }
diff --git a/src/embed_tests/TestPyFloat.cs b/src/embed_tests/TestPyFloat.cs

            var ex = Assert.Throws<PythonException>(() => a = new PyFloat(i));

            StringAssert.StartsWith("ValueError :could not convert string to float", ex.Message);
            StringAssert.StartsWith("could not convert string to float", ex.Message);
            Assert.IsNull(a);
        }

            PyFloat a = null;

            var ex = Assert.Throws<PythonException>(() => a = PyFloat.AsFloat(s));
            StringAssert.StartsWith("ValueError :could not convert string to float", ex.Message);
            StringAssert.StartsWith("could not convert string to float", ex.Message);
            Assert.IsNull(a);
        }
    }
diff --git a/src/embed_tests/TestPyInt.cs b/src/embed_tests/TestPyInt.cs

            var ex = Assert.Throws<PythonException>(() => a = new PyInt(i));

            StringAssert.StartsWith("ValueError :invalid literal for int", ex.Message);
            StringAssert.StartsWith("invalid literal for int", ex.Message);
            Assert.IsNull(a);
        }

            PyInt a = null;

            var ex = Assert.Throws<PythonException>(() => a = PyInt.AsInt(s));
            StringAssert.StartsWith("ValueError :invalid literal for int", ex.Message);
            StringAssert.StartsWith("invalid literal for int", ex.Message);
            Assert.IsNull(a);
        }

diff --git a/src/embed_tests/TestPyList.cs b/src/embed_tests/TestPyList.cs

            var ex = Assert.Throws<PythonException>(() => t = PyList.AsList(i));

            Assert.AreEqual("TypeError :'int' object is not iterable", ex.Message);
            Assert.AreEqual("'int' object is not iterable", ex.Message);
            Assert.IsNull(t);
        }

diff --git a/src/embed_tests/TestPyLong.cs b/src/embed_tests/TestPyLong.cs

            var ex = Assert.Throws<PythonException>(() => a = new PyLong(i));

            StringAssert.StartsWith("ValueError :invalid literal", ex.Message);
            StringAssert.StartsWith("invalid literal", ex.Message);
            Assert.IsNull(a);
        }

            PyLong a = null;

            var ex = Assert.Throws<PythonException>(() => a = PyLong.AsLong(s));
            StringAssert.StartsWith("ValueError :invalid literal", ex.Message);
            StringAssert.StartsWith("invalid literal", ex.Message);
            Assert.IsNull(a);
        }

diff --git a/src/embed_tests/TestPyTuple.cs b/src/embed_tests/TestPyTuple.cs

            var ex = Assert.Throws<PythonException>(() => t.Concat(s));

            StringAssert.StartsWith("TypeError :can only concatenate tuple", ex.Message);
            StringAssert.StartsWith("can only concatenate tuple", ex.Message);
            Assert.AreEqual(0, t.Length());
            Assert.IsEmpty(t);
        }

            var ex = Assert.Throws<PythonException>(() => t = PyTuple.AsTuple(i));

            Assert.AreEqual("TypeError :'int' object is not iterable", ex.Message);
            Assert.AreEqual("'int' object is not iterable", ex.Message);
            Assert.IsNull(t);
        }
    }
diff --git a/src/embed_tests/TestPyType.cs b/src/embed_tests/TestPyType.cs

            using var type = new PyType(spec);
            Assert.AreEqual(name, type.GetAttr("__name__").As<string>());
            Assert.AreEqual(name, type.Name);
            Assert.AreEqual(docStr, type.GetAttr("__doc__").As<string>());
        }
    }
diff --git a/src/embed_tests/TestPyWith.cs b/src/embed_tests/TestPyWith.cs
            catch (PythonException e)
            {
                TestContext.Out.WriteLine(e.Message);
                Assert.IsTrue(e.Message.Contains("ZeroDivisionError"));
                Assert.IsTrue(e.Type.Name =="ZeroDivisionError");
            }
        }

diff --git a/src/embed_tests/TestPythonException.cs b/src/embed_tests/TestPythonException.cs

            var ex = Assert.Throws<PythonException>(() => foo = list[0]);

            Assert.AreEqual("IndexError : list index out of range", ex.Message);
            Assert.AreEqual("list index out of range", ex.Message);
            Assert.IsNull(foo);
        }

        [Test]
        public void TestType()
        {
            var list = new PyList();
            PyObject foo = null;

            var ex = Assert.Throws<PythonException>(() => foo = list[0]);

            Assert.AreEqual("IndexError", ex.Type.Name);
            Assert.IsNull(foo);
        }

        [Test]
        public void TestNoError()
        {
            var e = new PythonException(); // There is no PyErr to fetch
            Assert.AreEqual("", e.Message);
            // There is no PyErr to fetch
            Assert.Throws<InvalidOperationException>(() => PythonException.FetchCurrentRaw());
            var currentError = PythonException.FetchCurrentOrNullRaw();
            Assert.IsNull(currentError);
        }

        [Test]
        public voidTestPythonErrorTypeName()
        public voidTestNestedExceptions()
        {
            try
            {
                var module = PyModule.Import("really____unknown___module");
                Assert.Fail("Unknown module should not be loaded");
                PythonEngine.Exec(@"
 try:
  raise Exception('inner')
 except Exception as ex:
  raise Exception('outer') from ex
 ");
            }
            catch (PythonException ex)
            {
                Assert.That(ex.PythonTypeName, Is.EqualTo("ModuleNotFoundError").Or.EqualTo("ImportError"));
                Assert.That(ex.InnerException, Is.InstanceOf<PythonException>());
                Assert.That(ex.InnerException.Message, Is.EqualTo("inner"));
            }
        }

        [Test]
        public void InnerIsEmptyWithNoCause()
        {
            var list = new PyList();
            PyObject foo = null;

            var ex = Assert.Throws<PythonException>(() => foo = list[0]);

            Assert.IsNull(ex.InnerException);
        }

        [Test]
        public void TestPythonExceptionFormat()
        {
            }
        }

        [Test]
        public void TestPythonExceptionFormatNoError()
        {
            var ex = new PythonException();
            Assert.AreEqual(ex.StackTrace, ex.Format());
        }

        [Test]
        public void TestPythonExceptionFormatNoTraceback()
        {
                Assert.IsTrue(scope.TryGet("TestException", out PyObject type));

                PyObject str = "dummy string".ToPython();
                IntPtr typePtr = type.Handle;
                IntPtr strPtr = str.Handle;
                IntPtr tbPtr = Runtime.Runtime.None.Handle;
                Runtime.Runtime.XIncref(typePtr);
                Runtime.Runtime.XIncref(strPtr);
                Runtime.Runtime.XIncref(tbPtr);
                var typePtr = new NewReference(type.Reference);
                var strPtr = new NewReference(str.Reference);
                var tbPtr = new NewReference(Runtime.Runtime.None.Reference);
                Runtime.Runtime.PyErr_NormalizeException(ref typePtr, ref strPtr, ref tbPtr);

                using(PyObject typeObj =new PyObject(typePtr), strObj = new PyObject(strPtr), tbObj = new PyObject(tbPtr))
 {
    // the type returned from PyErr_NormalizeException should not be the same type since a new
    // exception was raised by initializingtheexception
    Assert.AreNotEqual(type.Handle, typePtr);
    // the message should now be the string from the throw exception during normalization
    Assert.AreEqual("invalid literal for int() with base 10: 'dummy string'", strObj.ToString());
 }
                usingvar typeObj = typePtr.MoveToPyObject();
 using var strObj = strPtr.MoveToPyObject();
 using var tbObj = tbPtr.MoveToPyObject();
 // the type returned from PyErr_NormalizeException should not bethesame type since a new
 // exception was raised by initializing the exception
 Assert.AreNotEqual(type.Handle, typeObj.Handle);
 // the message should now be the string from the throw exception during normalization
 Assert.AreEqual("invalid literal for int() with base 10: 'dummy string'", strObj.ToString());
            }
        }

        [Test]
        public void TestPythonException_Normalize_ThrowsWhenErrorSet()
        {
            Exceptions.SetError(Exceptions.TypeError, "Error!");
            var pythonException =newPythonException();
            var pythonException = PythonException.FetchCurrentRaw();
            Exceptions.SetError(Exceptions.TypeError, "Another error");
            Assert.Throws<InvalidOperationException>(() => pythonException.Normalize());
        }
diff --git a/src/embed_tests/TestRuntime.cs b/src/embed_tests/TestRuntime.cs
 using System.Collections.Generic;
 using NUnit.Framework;
 using Python.Runtime;
 using Python.Runtime.Platform;

 namespace Python.EmbeddingTest
 {
                Exceptions.ErrorCheck(threadingDict);
                var lockType = Runtime.Runtime.PyDict_GetItemString(threadingDict, "Lock");
                if (lockType.IsNull)
                    thrownewPythonException();
                    throw PythonException.ThrowLastAsClrException();

                using var args = NewReference.DangerousFromPointer(Runtime.Runtime.PyTuple_New(0));
                using var lockInstance = Runtime.Runtime.PyObject_CallObject(lockType, args);
diff --git a/src/embed_tests/pyimport.cs b/src/embed_tests/pyimport.cs
 clr.AddReference('{path}')
 ";

            var error = Assert.Throws<PythonException>(() => PythonEngine.Exec(code));
            Assert.AreEqual(nameof(FileLoadException), error.PythonTypeName);
            Assert.Throws<FileLoadException>(() => PythonEngine.Exec(code));
        }
    }
 }
diff --git a/src/embed_tests/pyinitialize.cs b/src/embed_tests/pyinitialize.cs
            catch (PythonException e)
            {
                string msg = e.ToString();
                bool isImportError = e.Is(Exceptions.ImportError);
                Runtime.Runtime.Shutdown();

                if (e.IsMatches(Exceptions.ImportError))
                if (isImportError)
                {
                    Assert.Ignore("no atexit module");
                }
diff --git a/src/runtime/BorrowedReference.cs b/src/runtime/BorrowedReference.cs
        /// <summary>Gets a raw pointer to the Python object</summary>
        public IntPtr DangerousGetAddressOrNull() => this.pointer;

        public static BorrowedReference Null => new BorrowedReference();

        /// <summary>
        /// Creates new instance of <see cref="BorrowedReference"/> from raw pointer. Unsafe.
        /// </summary>
Original file line number	Diff line number	Diff line change
Expand Up		@@ -56,6 +56,9 @@ jobs:
		run: \|
		python -m pythonnet.find_libpython --export \| Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append

		- name: Embedding tests
		run: dotnet test --runtime any-${{ matrix.platform }} src/embed_tests/

		- name: Python Tests (Mono)
		if: ${{ matrix.os != 'windows' }}
		run: pytest --runtime mono
Expand All		@@ -67,9 +70,6 @@ jobs:
		if: ${{ matrix.os == 'windows' }}
		run: pytest --runtime netfx

		- name: Embedding tests
		run: dotnet test --runtime any-${{ matrix.platform }} src/embed_tests/

		- name: Python tests run from .NET
		run: dotnet test --runtime any-${{ matrix.platform }} src/python_tests_runner/

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -14,6 +14,9 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
		- Add GetPythonThreadID and Interrupt methods in PythonEngine
		- Ability to implement delegates with `ref` and `out` parameters in Python, by returning the modified parameter values in a tuple. ([#1355][i1355])
		- `PyType` - a wrapper for Python type objects, that also permits creating new heap types from `TypeSpec`
		- Improved exception handling:
		- exceptions can now be converted with codecs
		- `InnerException` and `__cause__` are propagated properly

		### Changed
		- Drop support for Python 2, 3.4, and 3.5
Expand DownExpand Up		@@ -44,7 +47,9 @@ One must now either use enum members (e.g. `MyEnum.Option`), or use enum constru
		- Sign Runtime DLL with a strong name
		- Implement loading through `clr_loader` instead of the included `ClrModule`, enables
		support for .NET Core
		- .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.

		### Fixed

Expand All		@@ -70,6 +75,7 @@ One must now either use enum members (e.g. `MyEnum.Option`), or use enum constru
		### Removed

		- implicit assembly loading (you have to explicitly `clr.AddReference` before doing import)
		- messages in `PythonException` no longer start with exception type
		- support for .NET Framework 4.0-4.6; Mono before 5.4. Python.NET now requires .NET Standard 2.0
		(see [the matrix](https://docs.microsoft.com/en-us/dotnet/standard/net-standard#net-implementation-support))

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -322,6 +322,65 @@ def CanEncode(self, clr_type):

		PythonEngine.Exec(PyCode);
		}

		const string TestExceptionMessage = "Hello World!";
		[Test]
		public void ExceptionEncoded()
		{
		PyObjectConversions.RegisterEncoder(new ValueErrorCodec());
		void CallMe() => throw new ValueErrorWrapper(TestExceptionMessage);
		var callMeAction = new Action(CallMe);
		using var _ = Py.GIL();
		using var scope = Py.CreateScope();
		scope.Exec(@"
		def call(func):
		try:
		func()
		except ValueError as e:
		return str(e)
		");
		var callFunc = scope.Get("call");
		string message = callFunc.Invoke(callMeAction.ToPython()).As<string>();
		Assert.AreEqual(TestExceptionMessage, message);
		}

		[Test]
		public void ExceptionDecoded()
		{
		PyObjectConversions.RegisterDecoder(new ValueErrorCodec());
		using var _ = Py.GIL();
		using var scope = Py.CreateScope();
		var error = Assert.Throws<ValueErrorWrapper>(()
		=> PythonEngine.Exec($"raise ValueError('{TestExceptionMessage}')"));
		Assert.AreEqual(TestExceptionMessage, error.Message);
		}

		class ValueErrorWrapper : Exception
		{
		public ValueErrorWrapper(string message) : base(message) { }
		}

		class ValueErrorCodec : IPyObjectEncoder, IPyObjectDecoder
		{
		public bool CanDecode(PyObject objectType, Type targetType)
		=> this.CanEncode(targetType) && objectType.Equals(PythonEngine.Eval("ValueError"));

		public bool CanEncode(Type type) => type == typeof(ValueErrorWrapper)
		\|\| typeof(ValueErrorWrapper).IsSubclassOf(type);

		public bool TryDecode<T>(PyObject pyObj, out T value)
		{
		var message = pyObj.GetAttr("args")[0].As<string>();
		value = (T)(object)new ValueErrorWrapper(message);
		return true;
		}

		public PyObject TryEncode(object value)
		{
		var error = (ValueErrorWrapper)value;
		return PythonEngine.Eval("ValueError").Invoke(error.Message.ToPython());
		}
		}
		}

		/// <summary>
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -24,7 +24,7 @@ public void TestNoOverloadException() {
		using (Py.GIL()) {
		dynamic callWith42 = PythonEngine.Eval("lambda f: f([42])");
		var error = Assert.Throws<PythonException>(() => callWith42(aFunctionThatCallsIntoPython.ToPython()));
		Assert.AreEqual("TypeError", error.PythonTypeName);
		Assert.AreEqual("TypeError", error.Type.Name);
		string expectedArgTypes = "(<class 'list'>)";
		StringAssert.EndsWith(expectedArgTypes, error.Message);
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -95,7 +95,7 @@ public void StringBadCtor()

		var ex = Assert.Throws<PythonException>(() => a = new PyFloat(i));

		StringAssert.StartsWith("ValueError :could not convert string to float", ex.Message);
		StringAssert.StartsWith("could not convert string to float", ex.Message);
		Assert.IsNull(a);
		}

Expand DownExpand Up		@@ -132,7 +132,7 @@ public void AsFloatBad()
		PyFloat a = null;

		var ex = Assert.Throws<PythonException>(() => a = PyFloat.AsFloat(s));
		StringAssert.StartsWith("ValueError :could not convert string to float", ex.Message);
		StringAssert.StartsWith("could not convert string to float", ex.Message);
		Assert.IsNull(a);
		}
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -128,7 +128,7 @@ public void TestCtorBadString()

		var ex = Assert.Throws<PythonException>(() => a = new PyInt(i));

		StringAssert.StartsWith("ValueError :invalid literal for int", ex.Message);
		StringAssert.StartsWith("invalid literal for int", ex.Message);
		Assert.IsNull(a);
		}

Expand DownExpand Up		@@ -161,7 +161,7 @@ public void TestAsIntBad()
		PyInt a = null;

		var ex = Assert.Throws<PythonException>(() => a = PyInt.AsInt(s));
		StringAssert.StartsWith("ValueError :invalid literal for int", ex.Message);
		StringAssert.StartsWith("invalid literal for int", ex.Message);
		Assert.IsNull(a);
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -41,7 +41,7 @@ public void TestStringAsListType()

		var ex = Assert.Throws<PythonException>(() => t = PyList.AsList(i));

		Assert.AreEqual("TypeError :'int' object is not iterable", ex.Message);
		Assert.AreEqual("'int' object is not iterable", ex.Message);
		Assert.IsNull(t);
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -144,7 +144,7 @@ public void TestCtorBadString()

		var ex = Assert.Throws<PythonException>(() => a = new PyLong(i));

		StringAssert.StartsWith("ValueError :invalid literal", ex.Message);
		StringAssert.StartsWith("invalid literal", ex.Message);
		Assert.IsNull(a);
		}

Expand DownExpand Up		@@ -177,7 +177,7 @@ public void TestAsLongBad()
		PyLong a = null;

		var ex = Assert.Throws<PythonException>(() => a = PyLong.AsLong(s));
		StringAssert.StartsWith("ValueError :invalid literal", ex.Message);
		StringAssert.StartsWith("invalid literal", ex.Message);
		Assert.IsNull(a);
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -104,7 +104,7 @@ public void TestPyTupleInvalidAppend()

		var ex = Assert.Throws<PythonException>(() => t.Concat(s));

		StringAssert.StartsWith("TypeError :can only concatenate tuple", ex.Message);
		StringAssert.StartsWith("can only concatenate tuple", ex.Message);
		Assert.AreEqual(0, t.Length());
		Assert.IsEmpty(t);
		}
Expand DownExpand Up		@@ -164,7 +164,7 @@ public void TestInvalidAsTuple()

		var ex = Assert.Throws<PythonException>(() => t = PyTuple.AsTuple(i));

		Assert.AreEqual("TypeError :'int' object is not iterable", ex.Message);
		Assert.AreEqual("'int' object is not iterable", ex.Message);
		Assert.IsNull(t);
		}
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -40,6 +40,7 @@ public void CanCreateHeapType()

		using var type = new PyType(spec);
		Assert.AreEqual(name, type.GetAttr("__name__").As<string>());
		Assert.AreEqual(name, type.Name);
		Assert.AreEqual(docStr, type.GetAttr("__doc__").As<string>());
		}
		}
Expand Down