pythonnet · lostmsu · Mar 28, 2019 · Mar 28, 2019 · Mar 28, 2019 · Mar 29, 2019
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -13,6 +13,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   Added function that sets Py_NoSiteFlag to 1.
 -   Added support for Jetson Nano.
 -   Added support for __len__ for .NET classes that implement ICollection
+-   Added `IPyArgumentConverter` interface and `PyArgConverter` attribute, that control custom argument marshaling from Python to .NET (#835)
 
 ### Changed
 

diff --git a/src/embed_tests/TestCustomArgMarshal.cs b/src/embed_tests/TestCustomArgMarshal.cs
@@ -0,0 +1,88 @@
+using System;
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    class TestCustomArgMarshal
+    {
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        [Test]
+        public void CustomArgMarshaller()
+        {
+            var obj = new CustomArgMarshaling();
+            using (Py.GIL()) {
+                dynamic callWithInt = PythonEngine.Eval("lambda o: o.CallWithInt('42')");
+                callWithInt(obj.ToPython());
+            }
+            Assert.AreEqual(expected: 42, actual: obj.LastArgument);
+        }
+
+        [Test]
+        public void MarshallerOverride() {
+            var obj = new DerivedMarshaling();
+            using (Py.GIL()) {
+                dynamic callWithInt = PythonEngine.Eval("lambda o: o.CallWithInt({ 'value': 42 })");
+                callWithInt(obj.ToPython());
+            }
+            Assert.AreEqual(expected: 42, actual: obj.LastArgument);
+        }
+    }
+
+    [PyArgConverter(typeof(CustomArgConverter))]
+    class CustomArgMarshaling {
+        public object LastArgument { get; protected set; }
+        public virtual void CallWithInt(int value) => this.LastArgument = value;
+    }
+
+    // this should override original custom marshaling behavior for any new methods
+    [PyArgConverter(typeof(CustomArgConverter2))]
+    class DerivedMarshaling : CustomArgMarshaling {
+        public override void CallWithInt(int value) {
+            base.CallWithInt(value);
+        }
+    }
+
+    class CustomArgConverter : DefaultPyArgumentConverter {
+        public override bool TryConvertArgument(IntPtr pyarg, Type parameterType, bool needsResolution,
+                                                out object arg, out bool isOut) {
+            if (parameterType != typeof(int))
+                return base.TryConvertArgument(pyarg, parameterType, needsResolution, out arg, out isOut);
+
+            bool isString = base.TryConvertArgument(pyarg, typeof(string), needsResolution,
+                out arg, out isOut);
+            if (!isString) return false;
+
+            int number;
+            if (!int.TryParse((string)arg, out number)) return false;
+            arg = number;
+            return true;
+        }
+    }
+
+    class CustomArgConverter2 : DefaultPyArgumentConverter {
+        public override bool TryConvertArgument(IntPtr pyarg, Type parameterType, bool needsResolution,
+            out object arg, out bool isOut) {
+            if (parameterType != typeof(int))
+                return base.TryConvertArgument(pyarg, parameterType, needsResolution, out arg, out isOut);
+            bool isPyObject = base.TryConvertArgument(pyarg, typeof(PyObject), needsResolution,
+                out arg, out isOut);
+            if (!isPyObject) return false;
+            var dict = new PyDict((PyObject)arg);
+            int number = (dynamic)dict["value"];
+            arg = number;
+            return true;
+        }
+    }
+}
diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
@@ -94,6 +94,7 @@
     <Compile Include="converter.cs" />
     <Compile Include="CustomMarshaler.cs" />
     <Compile Include="debughelper.cs" />
+    <Compile Include="defaultpyargconverter.cs" />
     <Compile Include="delegatemanager.cs" />
     <Compile Include="delegateobject.cs" />
     <Compile Include="eventbinding.cs" />
@@ -122,6 +123,7 @@
     <Compile Include="overload.cs" />
     <Compile Include="propertyobject.cs" />
     <Compile Include="pyansistring.cs" />
+    <Compile Include="pyargconverter.cs" />
     <Compile Include="pydict.cs" />
     <Compile Include="pyfloat.cs" />
     <Compile Include="pyint.cs" />

diff --git a/src/runtime/defaultpyargconverter.cs b/src/runtime/defaultpyargconverter.cs
@@ -0,0 +1,111 @@
+namespace Python.Runtime {
+    using System;
+
+    /// <summary>
+    /// The implementation of <see cref="T:Python.Runtime.IPyArgumentConverter" /> used by default
+    /// </summary>
+    public class DefaultPyArgumentConverter: IPyArgumentConverter
+    {
+        /// <summary>
+        /// Gets the singleton instance.
+        /// </summary>
+        public static DefaultPyArgumentConverter Instance { get; } = new DefaultPyArgumentConverter();
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Attempts to convert an argument passed by Python to the specified parameter type.
+        /// </summary>
+        /// <param name="pyarg">Unmanaged pointer to the Python argument value</param>
+        /// <param name="parameterType">The expected type of the parameter</param>
+        /// <param name="needsResolution"><c>true</c> if the method is overloaded</param>
+        /// <param name="arg">This parameter will receive the converted value, matching the specified type</param>
+        /// <param name="isOut">This parameter will be set to <c>true</c>,
+        /// if the final type needs to be marshaled as an out argument.</param>
+        /// <returns><c>true</c>, if the object matches requested type,
+        /// and conversion was successful, otherwise <c>false</c></returns>
+        public virtual bool TryConvertArgument(
+            IntPtr pyarg, Type parameterType, bool needsResolution,
+            out object arg, out bool isOut)
+        {
+            arg = null;
+            isOut = false;
+            Type clrType = TryComputeClrArgumentType(parameterType, pyarg, needsResolution: needsResolution);
+            if (clrType == null)
+            {
+                return false;
+            }
+
+            if (!Converter.ToManaged(pyarg, clrType, out arg, false))
+            {
+                Exceptions.Clear();
+                return false;
+            }
+
+            isOut = clrType.IsByRef;
+            return true;
+        }
+
+        static Type TryComputeClrArgumentType(Type parameterType, IntPtr argument, bool needsResolution)
+        {
+            // this logic below handles cases when multiple overloading methods
+            // are ambiguous, hence comparison between Python and CLR types
+            // is necessary
+            Type clrType = null;
+            IntPtr pyArgType;
+            if (needsResolution)
+            {
+                // HACK: each overload should be weighted in some way instead
+                pyArgType = Runtime.PyObject_Type(argument);
+                Exceptions.Clear();
+                if (pyArgType != IntPtr.Zero)
+                {
+                    clrType = Converter.GetTypeByAlias(pyArgType);
+                }
+                Runtime.XDecref(pyArgType);
+            }
+
+            if (clrType != null)
+            {
+                if ((parameterType != typeof(object)) && (parameterType != clrType))
+                {
+                    IntPtr pyParamType = Converter.GetPythonTypeByAlias(parameterType);
+                    pyArgType = Runtime.PyObject_Type(argument);
+                    Exceptions.Clear();
+
+                    bool typeMatch = false;
+                    if (pyArgType != IntPtr.Zero && pyParamType == pyArgType)
+                    {
+                        typeMatch = true;
+                        clrType = parameterType;
+                    }
+                    if (!typeMatch)
+                    {
+                        // this takes care of enum values
+                        TypeCode argTypeCode = Type.GetTypeCode(parameterType);
+                        TypeCode paramTypeCode = Type.GetTypeCode(clrType);
+                        if (argTypeCode == paramTypeCode)
+                        {
+                            typeMatch = true;
+                            clrType = parameterType;
+                        }
+                    }
+                    Runtime.XDecref(pyArgType);
+                    if (!typeMatch)
+                    {
+                        return null;
+                    }
+                }
+                else
+                {
+                    clrType = parameterType;
+                }
+            }
+            else
+            {
+                clrType = parameterType;
+            }
+
+            return clrType;
+        }
+    }
+}