Enable C# parameters of type object accept any argument, passed from Python (#889)

lostmsu · web-flow · commit 8ad10620a5a7 · 2020-03-03T09:27:46.000+01:00
* added a regression test for #881 * when converting to object, wrap values of unknown type into PyObject instead of failing This enables overload resolution with object parameters to behave the same way PyObject parameters behave - e.g. allow any Python object to be passed as PyObject as fallback. Resolves #811 * fixed ObjectField conversion test * fixed test_object_indexer to pass on custom class key * use object() instance in OverloadResolution_UnknownToObject test
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -58,6 +58,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   Reattach python exception traceback information (#545)
 -   PythonEngine.Intialize will now call `Py_InitializeEx` with a default value of 0, so signals will not be configured by default on embedding. This is different from the previous behaviour, where `Py_Initialize` was called instead, which sets initSigs to 1. ([#449][i449])
 -   Refactored MethodBinder.Bind in preparation to make it extensible (#829)
+-   When calling C# from Python, enable passing argument of any type to a parameter of C# type `object` by wrapping it into `PyObject` instance. ([#881][i881])
 -   Look for installed Windows 10 sdk's during installation instead of relying on specific versions.
 
 ### Fixed
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -94,6 +94,7 @@
     <Compile Include="TestDomainReload.cs" />
     <Compile Include="TestExample.cs" />
     <Compile Include="TestFinalizer.cs" />
+    <Compile Include="TestInstanceWrapping.cs" />
     <Compile Include="TestPyAnsiString.cs" />
     <Compile Include="TestPyFloat.cs" />
     <Compile Include="TestPyInt.cs" />
diff --git a/src/embed_tests/TestInstanceWrapping.cs b/src/embed_tests/TestInstanceWrapping.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Globalization;
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    public class TestInstanceWrapping
+    {
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        // regression test for https://github.com/pythonnet/pythonnet/issues/811
+        [Test]
+        public void OverloadResolution_UnknownToObject()
+        {
+            var overloaded = new Overloaded();
+            using (Py.GIL())
+            {
+                var o = overloaded.ToPython();
+
+                dynamic callWithSelf = PythonEngine.Eval("lambda o: o.ObjOrClass(object())");
+                callWithSelf(o);
+                Assert.AreEqual(Overloaded.Object, overloaded.Value);
+            }
+        }
+
+        class Base {}
+        class Derived: Base { }
+
+        class Overloaded: Derived
+        {
+            public int Value { get; set; }
+            public void IntOrStr(int arg) => this.Value = arg;
+            public void IntOrStr(string arg) =>
+                this.Value = int.Parse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture);
+
+            public const int Object = 1;
+            public const int ConcreteClass = 2;
+            public void ObjOrClass(object _) => this.Value = Object;
+            public void ObjOrClass(Overloaded _) => this.Value = ConcreteClass;
+
+            public const int Base = ConcreteClass + 1;
+            public const int Derived = Base + 1;
+            public void BaseOrDerived(Base _) => this.Value = Base;
+            public void BaseOrDerived(Derived _) => this.Value = Derived;
+        }
+    }
+}
diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs
@@ -398,12 +398,9 @@ internal static bool ToManagedValue(IntPtr value, Type obType,
                     return ToArray(value, typeof(object[]), out result, setError);
                 }
 
-                if (setError)
-                {
-                    Exceptions.SetError(Exceptions.TypeError, "value cannot be converted to Object");
-                }
-
-                return false;
+                Runtime.XIncref(value); // PyObject() assumes ownership
+                result = new PyObject(value);
+                return true;
             }
 
             // Conversion to 'Type' is done using the same mappings as above for objects.
diff --git a/src/tests/test_conversion.py b/src/tests/test_conversion.py
@@ -595,11 +595,10 @@ def test_object_conversion():
 
     # need to test subclass here
 
-    with pytest.raises(TypeError):
-        class Foo(object):
-            pass
-        ob = ConversionTest()
-        ob.ObjectField = Foo
+    class Foo(object):
+        pass
+    ob.ObjectField = Foo
+    assert ob.ObjectField == Foo
 
 
 def test_enum_conversion():
diff --git a/src/tests/test_indexer.py b/src/tests/test_indexer.py
@@ -438,13 +438,13 @@ def test_object_indexer():
     ob[long(1)] = "long"
     assert ob[long(1)] == "long"
 
-    with pytest.raises(TypeError):
-        class Eggs(object):
-            pass
+    class Eggs(object):
+        pass
 
-        key = Eggs()
-        ob = Test.ObjectIndexerTest()
-        ob[key] = "wrong"
+    key = Eggs()
+    ob = Test.ObjectIndexerTest()
+    ob[key] = "eggs_key"
+    assert ob[key] == "eggs_key"
 
 
 def test_interface_indexer():

Original file line number	Diff line number	Diff line change
`@@ -398,12 +398,9 @@ internal static bool ToManagedValue(IntPtr value, Type obType,`
`398`	`398`	`return ToArray(value, typeof(object[]), out result, setError);`
`399`	`399`	`}`
`400`	`400`
`401`		`- if (setError)`
`402`		`- {`
`403`		`- Exceptions.SetError(Exceptions.TypeError, "value cannot be converted to Object");`
`404`		`- }`
`405`		`-`
`406`		`- return false;`
	`401`	`+ Runtime.XIncref(value); // PyObject() assumes ownership`
	`402`	`+ result = new PyObject(value);`
	`403`	`+ return true;`
`407`	`404`	`}`
`408`	`405`
`409`	`406`	`// Conversion to 'Type' is done using the same mappings as above for objects.`