Feb 3, 2021 · Feb 3, 2021 · Feb 4, 2021 · Feb 4, 2021 · Feb 4, 2021 · Feb 4, 2021
diff --git a/AUTHORS.md b/AUTHORS.md
 -   Christoph Gohlke ([@cgohlke](https://github.com/cgohlke))
 -   Christopher Bremner ([@chrisjbremner](https://github.com/chrisjbremner))
 -   Christopher Pow ([@christopherpow](https://github.com/christopherpow))
 -   Colton Sellers ([@C-SELLERS](https://github.com/C-SELLERS))
 -   Daniel Abrahamsson ([@danabr](https://github.com/danabr))
 -   Daniel Fernandez ([@fdanny](https://github.com/fdanny))
 -   Daniel Santana ([@dgsantana](https://github.com/dgsantana))
 -   Luke Stratman ([@lstratman](https://github.com/lstratman))
 -   Konstantin Posudevskiy ([@konstantin-posudevskiy](https://github.com/konstantin-posudevskiy))
 -   Matthias Dittrich ([@matthid](https://github.com/matthid))
 -   Martin Molinero ([@Martin-Molinero](https://github.com/Martin-Molinero))
 -   Meinrad Recheis ([@henon](https://github.com/henon))
 -   Mohamed Koubaa ([@koubaa](https://github.com/koubaa))
 -   Patrick Stewart ([@patstew](https://github.com/patstew))
diff --git a/CHANGELOG.md b/CHANGELOG.md
 details about the cause of the failure
 -   `clr.AddReference` no longer adds ".dll" implicitly
 -   `PyIter(PyObject)` constructor replaced with static `PyIter.GetIter(PyObject)` method
 -   BREAKING: Return values from .NET methods that return an interface are now automatically
     wrapped in that interface. This is a breaking change for users that rely on being
     able to access members that are part of the implementation class, but not the
     interface.  Use the new __implementation__ or __raw_implementation__ properties to
     if you need to "downcast" to the implementation class.
 -   BREAKING: Parameters marked with `ParameterAttributes.Out` are no longer returned in addition
     to the regular method return value (unless they are passed with `ref` or `out` keyword).
 -   BREAKING: Drop support for the long-deprecated CLR.* prefix.
diff --git a/src/embed_tests/TestConverter.cs b/src/embed_tests/TestConverter.cs
            PythonEngine.Shutdown();
        }

        [Test]
        public void ConvertListRoundTrip()
        {
            var list = new List<Type> { typeof(decimal), typeof(int) };
            var py = list.ToPython();
            object result;
            var converted = Converter.ToManaged(py.Handle, typeof(List<Type>), out result, false);

            Assert.IsTrue(converted);
            Assert.AreEqual(result, list);
        }

        [Test]
        public void ConvertPyListToArray()
        {
            var array = new List<Type> { typeof(decimal), typeof(int) };
            var py = array.ToPython();
            object result;
            var converted = Converter.ToManaged(py.Handle, typeof(Type[]), out result, false);

            Assert.IsTrue(converted);
            Assert.AreEqual(result, array);
        }

        [Test]
        public void ConvertTimeSpanRoundTrip()
        {
            var timespan = new TimeSpan(0, 1, 0, 0);
            var pyTimedelta = timespan.ToPython();

            object result;
            var converted = Converter.ToManaged(pyTimedelta.Handle, typeof(TimeSpan), out result, false);

            Assert.IsTrue(converted);
            Assert.AreEqual(result, timespan);
        }

        [Test]
        public void ConvertDateTimeRoundTrip()
        {
            var datetime = new DateTime(2000, 1, 1);
            var pyDatetime = datetime.ToPython();

            object result;
            var converted = Converter.ToManaged(pyDatetime.Handle, typeof(DateTime), out result, false);

            Assert.IsTrue(converted);
            Assert.AreEqual(result, datetime);
        }

        [Test]
        public void TestConvertSingleToManaged(
            [Values(float.PositiveInfinity, float.NegativeInfinity, float.MinValue, float.MaxValue, float.NaN,
            var proxiedHandle = pyObjectProxy.GetAttr("Handle").As<IntPtr>();
            Assert.AreEqual(pyObject.Handle, proxiedHandle);
        }

        [Test]
        public void PrimitiveIntConversion()
        {
            decimal value = 10;
            var pyValue = value.ToPython();

            // Try to convert python value to int
            var testInt = pyValue.As<int>();
            Assert.AreEqual(testInt , 10);
        }

    }
 }
diff --git a/src/embed_tests/TestInterfaceClasses.cs b/src/embed_tests/TestInterfaceClasses.cs
 using NUnit.Framework;
 using Python.Runtime;

 namespace Python.EmbeddingTest
 {
    public class TestInterfaceClasses
    {
        public string testCode = @"
 from clr import AddReference
 AddReference(""System"")
 AddReference(""Python.EmbeddingTest"")
 from Python.EmbeddingTest import *

 testModule = TestInterfaceClasses.GetInstance()
 print(testModule.Child.ChildBool)

 ";

        [OneTimeSetUp]
        public void SetUp()
        {
            PythonEngine.Initialize();
        }

        [OneTimeTearDown]
        public void Dispose()
        {
            PythonEngine.Shutdown();
        }

        [Test]
        public void TestInterfaceDerivedClassMembers()
        {
            // This test gets an instance of the CSharpTestModule in Python
            // and then attempts to access it's member "Child"'s bool that is
            // not defined in the interface.
            PythonEngine.Exec(testCode);
        }

        public interface IInterface
        {
            bool InterfaceBool { get; set; }
        }

        public class Parent : IInterface
        {
            public bool InterfaceBool { get; set; }
            public bool ParentBool { get; set; }
        }

        public class Child : Parent
        {
            public bool ChildBool { get; set; }
        }

        public class CSharpTestModule
        {
            public IInterface Child;

            public CSharpTestModule()
            {
                Child = new Child
                {
                    ChildBool = true,
                    ParentBool = true,
                    InterfaceBool = true
                };
            }
        }

        public static CSharpTestModule GetInstance()
        {
            return new CSharpTestModule();
        }
    }
 }
diff --git a/src/embed_tests/TestMethodBinder.cs b/src/embed_tests/TestMethodBinder.cs
 using System;

 using NUnit.Framework;

 using Python.Runtime;

 namespace Python.EmbeddingTest
 {
    public class TestMethodBinder
    {
        private static dynamic module;
        private static string testModule = @"
 from clr import AddReference
 AddReference(""System"")
 AddReference(""Python.EmbeddingTest"")
 from Python.EmbeddingTest import *
 class PythonModel(TestMethodBinder.CSharpModel):
    def TestA(self):
        return self.OnlyString(TestMethodBinder.TestImplicitConversion())
    def TestB(self):
            return self.OnlyClass('input string')
    def TestC(self):
        return self.InvokeModel('input string')
    def TestD(self):
        return self.InvokeModel(TestMethodBinder.TestImplicitConversion())
    def TestE(self, array):
        return array.Length == 2";


        [OneTimeSetUp]
        public void SetUp()
        {
            PythonEngine.Initialize();
            module = PythonEngine.ModuleFromString("module", testModule).GetAttr("PythonModel").Invoke();
        }

        [OneTimeTearDown]
        public void Dispose()
        {
            PythonEngine.Shutdown();
        }

        [Test]
        public void ImplicitConversionToString()
        {
            var data = (string)module.TestA();
            // we assert implicit conversion took place
            Assert.AreEqual("OnlyString impl: implicit to string", data);
        }

        [Test]
        public void ImplicitConversionToClass()
        {
            var data = (string)module.TestB();
            // we assert implicit conversion took place
            Assert.AreEqual("OnlyClass impl", data);
        }

        [Test]
        public void WillAvoidUsingImplicitConversionIfPossible_String()
        {
            var data = (string)module.TestC();
            // we assert no implicit conversion took place
            Assert.AreEqual("string impl: input string", data);
        }

        [Test]
        public void WillAvoidUsingImplicitConversionIfPossible_Class()
        {
            var data = (string)module.TestD();
            // we assert no implicit conversion took place
            Assert.AreEqual("TestImplicitConversion impl", data);

        }

        [Test]
        public void ArrayLength()
        {
            var array = new[] { "pepe", "pinocho" };
            var data = (bool)module.TestE(array);

            // Assert it is true
            Assert.AreEqual(true, data);
        }

        public class CSharpModel
        {
            public virtual string OnlyClass(TestImplicitConversion data)
            {
                return "OnlyClass impl";
            }

            public virtual string OnlyString(string data)
            {
                return "OnlyString impl: " + data;
            }

            public virtual string InvokeModel(string data)
            {
                return "string impl: " + data;
            }

            public virtual string InvokeModel(TestImplicitConversion data)
            {
                return "TestImplicitConversion impl";
            }
        }

        public class TestImplicitConversion
        {
            public static implicit operator string(TestImplicitConversion symbol)
            {
                return "implicit to string";
            }
            public static implicit operator TestImplicitConversion(string symbol)
            {
                return new TestImplicitConversion();
            }
        }
    }
 }
diff --git a/src/embed_tests/TestOperator.cs b/src/embed_tests/TestOperator.cs
 ");
        }

        [Test]
        public void OperatorInequality()
        {
            string name = string.Format("{0}.{1}",
                typeof(OperableObject).DeclaringType.Name,
                typeof(OperableObject).Name);
            string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;

            PythonEngine.Exec($@"
 from {module} import *
 cls = {name}
 b = cls(10)
 a = cls(2)


 c = a <= b
 assert c == (a.Num <= b.Num)

 c = a >= b
 assert c == (a.Num >= b.Num)
 ");
        }

        [Test]
        public void OperatorOverloadMissingArgument()
        {
diff --git a/src/runtime/arrayobject.cs b/src/runtime/arrayobject.cs
        public new static IntPtr mp_subscript(IntPtr ob, IntPtr idx)
        {
            var obj = (CLRObject)GetManagedObject(ob);
            var arrObj = (ArrayObject)GetManagedObjectType(ob);
            if (!arrObj.type.Valid)
            {
                return Exceptions.RaiseTypeError(arrObj.type.DeletedMessage);
            }
            var items = obj.inst as Array;
            Type itemType =arrObj.type.Value.GetElementType();
            Type itemType =obj.inst.GetType().GetElementType();
            int rank = items.Rank;
            int index;
            object value;
Original file line number	Diff line number	Diff line change
Expand Up		@@ -29,6 +29,7 @@
		- Christoph Gohlke ([@cgohlke](https://github.com/cgohlke))
		- Christopher Bremner ([@chrisjbremner](https://github.com/chrisjbremner))
		- Christopher Pow ([@christopherpow](https://github.com/christopherpow))
		- Colton Sellers ([@C-SELLERS](https://github.com/C-SELLERS))
		- Daniel Abrahamsson ([@danabr](https://github.com/danabr))
		- Daniel Fernandez ([@fdanny](https://github.com/fdanny))
		- Daniel Santana ([@dgsantana](https://github.com/dgsantana))
Expand All		@@ -52,6 +53,7 @@
		- Luke Stratman ([@lstratman](https://github.com/lstratman))
		- Konstantin Posudevskiy ([@konstantin-posudevskiy](https://github.com/konstantin-posudevskiy))
		- Matthias Dittrich ([@matthid](https://github.com/matthid))
		- Martin Molinero ([@Martin-Molinero](https://github.com/Martin-Molinero))
		- Meinrad Recheis ([@henon](https://github.com/henon))
		- Mohamed Koubaa ([@koubaa](https://github.com/koubaa))
		- Patrick Stewart ([@patstew](https://github.com/patstew))
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -21,11 +21,6 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
		details about the cause of the failure
		- `clr.AddReference` no longer adds ".dll" implicitly
		- `PyIter(PyObject)` constructor replaced with static `PyIter.GetIter(PyObject)` method
		- BREAKING: Return values from .NET methods that return an interface are now automatically
		wrapped in that interface. This is a breaking change for users that rely on being
		able to access members that are part of the implementation class, but not the
		interface. Use the new __implementation__ or __raw_implementation__ properties to
		if you need to "downcast" to the implementation class.
		- BREAKING: Parameters marked with `ParameterAttributes.Out` are no longer returned in addition
		to the regular method return value (unless they are passed with `ref` or `out` keyword).
		- BREAKING: Drop support for the long-deprecated CLR.* prefix.
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -34,6 +34,56 @@ public void Dispose()
		PythonEngine.Shutdown();
		}

		[Test]
		public void ConvertListRoundTrip()
		{
		var list = new List<Type> { typeof(decimal), typeof(int) };
		var py = list.ToPython();
		object result;
		var converted = Converter.ToManaged(py.Handle, typeof(List<Type>), out result, false);

		Assert.IsTrue(converted);
		Assert.AreEqual(result, list);
		}

		[Test]
		public void ConvertPyListToArray()
		{
		var array = new List<Type> { typeof(decimal), typeof(int) };
		var py = array.ToPython();
		object result;
		var converted = Converter.ToManaged(py.Handle, typeof(Type[]), out result, false);

		Assert.IsTrue(converted);
		Assert.AreEqual(result, array);
		}

		[Test]
		public void ConvertTimeSpanRoundTrip()
		{
		var timespan = new TimeSpan(0, 1, 0, 0);
		var pyTimedelta = timespan.ToPython();

		object result;
		var converted = Converter.ToManaged(pyTimedelta.Handle, typeof(TimeSpan), out result, false);

		Assert.IsTrue(converted);
		Assert.AreEqual(result, timespan);
		}

		[Test]
		public void ConvertDateTimeRoundTrip()
		{
		var datetime = new DateTime(2000, 1, 1);
		var pyDatetime = datetime.ToPython();

		object result;
		var converted = Converter.ToManaged(pyDatetime.Handle, typeof(DateTime), out result, false);

		Assert.IsTrue(converted);
		Assert.AreEqual(result, datetime);
		}

		[Test]
		public void TestConvertSingleToManaged(
		[Values(float.PositiveInfinity, float.NegativeInfinity, float.MinValue, float.MaxValue, float.NaN,
Expand DownExpand Up		@@ -136,5 +186,17 @@ public void RawPyObjectProxy()
		var proxiedHandle = pyObjectProxy.GetAttr("Handle").As<IntPtr>();
		Assert.AreEqual(pyObject.Handle, proxiedHandle);
		}

		[Test]
		public void PrimitiveIntConversion()
		{
		decimal value = 10;
		var pyValue = value.ToPython();

		// Try to convert python value to int
		var testInt = pyValue.As<int>();
		Assert.AreEqual(testInt , 10);
		}

		}
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,76 @@
		using NUnit.Framework;
		using Python.Runtime;

		namespace Python.EmbeddingTest
		{
		public class TestInterfaceClasses
		{
		public string testCode = @"
		from clr import AddReference
		AddReference(""System"")
		AddReference(""Python.EmbeddingTest"")
		from Python.EmbeddingTest import *

		testModule = TestInterfaceClasses.GetInstance()
		print(testModule.Child.ChildBool)

		";

		[OneTimeSetUp]
		public void SetUp()
		{
		PythonEngine.Initialize();
		}

		[OneTimeTearDown]
		public void Dispose()
		{
		PythonEngine.Shutdown();
		}

		[Test]
		public void TestInterfaceDerivedClassMembers()
		{
		// This test gets an instance of the CSharpTestModule in Python
		// and then attempts to access it's member "Child"'s bool that is
		// not defined in the interface.
		PythonEngine.Exec(testCode);
		}

		public interface IInterface
		{
		bool InterfaceBool { get; set; }
		}

		public class Parent : IInterface
		{
		public bool InterfaceBool { get; set; }
		public bool ParentBool { get; set; }
		}

		public class Child : Parent
		{
		public bool ChildBool { get; set; }
		}

		public class CSharpTestModule
		{
		public IInterface Child;

		public CSharpTestModule()
		{
		Child = new Child
		{
		ChildBool = true,
		ParentBool = true,
		InterfaceBool = true
		};
		}
		}

		public static CSharpTestModule GetInstance()
		{
		return new CSharpTestModule();
		}
		}
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,121 @@
		using System;

		using NUnit.Framework;

		using Python.Runtime;

		namespace Python.EmbeddingTest
		{
		public class TestMethodBinder
		{
		private static dynamic module;
		private static string testModule = @"
		from clr import AddReference
		AddReference(""System"")
		AddReference(""Python.EmbeddingTest"")
		from Python.EmbeddingTest import *
		class PythonModel(TestMethodBinder.CSharpModel):
		def TestA(self):
		return self.OnlyString(TestMethodBinder.TestImplicitConversion())
		def TestB(self):
		return self.OnlyClass('input string')
		def TestC(self):
		return self.InvokeModel('input string')
		def TestD(self):
		return self.InvokeModel(TestMethodBinder.TestImplicitConversion())
		def TestE(self, array):
		return array.Length == 2";


		[OneTimeSetUp]
		public void SetUp()
		{
		PythonEngine.Initialize();
		module = PythonEngine.ModuleFromString("module", testModule).GetAttr("PythonModel").Invoke();
		}

		[OneTimeTearDown]
		public void Dispose()
		{
		PythonEngine.Shutdown();
		}

		[Test]
		public void ImplicitConversionToString()
		{
		var data = (string)module.TestA();
		// we assert implicit conversion took place
		Assert.AreEqual("OnlyString impl: implicit to string", data);
		}

		[Test]
		public void ImplicitConversionToClass()
		{
		var data = (string)module.TestB();
		// we assert implicit conversion took place
		Assert.AreEqual("OnlyClass impl", data);
		}

		[Test]
		public void WillAvoidUsingImplicitConversionIfPossible_String()
		{
		var data = (string)module.TestC();
		// we assert no implicit conversion took place
		Assert.AreEqual("string impl: input string", data);
		}

		[Test]
		public void WillAvoidUsingImplicitConversionIfPossible_Class()
		{
		var data = (string)module.TestD();
		// we assert no implicit conversion took place
		Assert.AreEqual("TestImplicitConversion impl", data);

		}

		[Test]
		public void ArrayLength()
		{
		var array = new[] { "pepe", "pinocho" };
		var data = (bool)module.TestE(array);

		// Assert it is true
		Assert.AreEqual(true, data);
		}

		public class CSharpModel
		{
		public virtual string OnlyClass(TestImplicitConversion data)
		{
		return "OnlyClass impl";
		}

		public virtual string OnlyString(string data)
		{
		return "OnlyString impl: " + data;
		}

		public virtual string InvokeModel(string data)
		{
		return "string impl: " + data;
		}

		public virtual string InvokeModel(TestImplicitConversion data)
		{
		return "TestImplicitConversion impl";
		}
		}

		public class TestImplicitConversion
		{
		public static implicit operator string(TestImplicitConversion symbol)
		{
		return "implicit to string";
		}
		public static implicit operator TestImplicitConversion(string symbol)
		{
		return new TestImplicitConversion();
		}
		}
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -335,6 +335,29 @@ public void SymmetricalOperatorOverloads()
		");
		}

		[Test]
		public void OperatorInequality()
		{
		string name = string.Format("{0}.{1}",
		typeof(OperableObject).DeclaringType.Name,
		typeof(OperableObject).Name);
		string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;

		PythonEngine.Exec($@"
		from {module} import *
		cls = {name}
		b = cls(10)
		a = cls(2)


		c = a <= b
		assert c == (a.Num <= b.Num)

		c = a >= b
		assert c == (a.Num >= b.Num)
		");
		}

		[Test]
		public void OperatorOverloadMissingArgument()
		{
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -137,13 +137,8 @@ static NewReference NewInstance(Type elementType, BorrowedReference arrayPyType,
		public new static IntPtr mp_subscript(IntPtr ob, IntPtr idx)
		{
		var obj = (CLRObject)GetManagedObject(ob);
		var arrObj = (ArrayObject)GetManagedObjectType(ob);
		if (!arrObj.type.Valid)
		{
		return Exceptions.RaiseTypeError(arrObj.type.DeletedMessage);
		}
		var items = obj.inst as Array;
		Type itemType =arrObj.type.Value.GetElementType();
		Type itemType =obj.inst.GetType().GetElementType();
		int rank = items.Rank;
		int index;
		object value;
Expand Down