enabled an ability to override Python to .NET argument coversion usin…

…g PyArgConverter attribute
pythonnet · lostmsu · Mar 28, 2019 · Mar 28, 2019 · Mar 28, 2019 · Mar 29, 2019
commit b5cae6cd361d2357474527761103b25222140744
diff --git a/src/embed_tests/TestCustomArgMarshal.cs b/src/embed_tests/TestCustomArgMarshal.cs
@@ -0,0 +1,55 @@
+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);
+        }
+    }
+
+[PyArgConverter(typeof(CustomArgConverter))]
+class CustomArgMarshaling {
+    public object LastArgument { get; private set; }
+    public void CallWithInt(int value) => this.LastArgument = 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;
+        }
+    }
+}
diff --git a/src/runtime/methodbinder.cs b/src/runtime/methodbinder.cs
@@ -1,12 +1,15 @@
 using System;
 using System.Collections;
+using System.Diagnostics;
 using System.Reflection;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace Python.Runtime
 {
+    using System.Linq;
+
     /// <summary>
     /// A MethodBinder encapsulates information about a (possibly overloaded)
     /// managed method, and is responsible for selecting the right method given
@@ -19,16 +22,16 @@ internal class MethodBinder
         public MethodBase[] methods;
         public bool init = false;
         public bool allow_threads = true;
-        readonly IPyArgumentConverter pyArgumentConverter = DefaultPyArgumentConverter.Instance;
+        IPyArgumentConverter pyArgumentConverter;
 
         internal MethodBinder()
         {
             list = new ArrayList();
         }
 
-        internal MethodBinder(MethodInfo mi)
+        internal MethodBinder(MethodInfo mi): this()
         {
-            list = new ArrayList { mi };
+            this.AddMethod(mi);
         }
 
         public int Count
@@ -38,6 +41,7 @@ public int Count
 
         internal void AddMethod(MethodBase m)
         {
+            Debug.Assert(!init);
             list.Add(m);
         }
 
@@ -165,11 +169,40 @@ internal MethodBase[] GetMethods()
                 // I'm sure this could be made more efficient.
                 list.Sort(new MethodSorter());
                 methods = (MethodBase[])list.ToArray(typeof(MethodBase));
+                pyArgumentConverter = this.GetArgumentConverter();
                 init = true;
             }
             return methods;
         }
 
+        IPyArgumentConverter GetArgumentConverter() {
+            IPyArgumentConverter converter = null;
+            Type converterType = null;
+            foreach (MethodBase method in this.methods)
+            {
+                var attribute = method.DeclaringType?
+                      .GetCustomAttributes(typeof(PyArgConverterAttribute), inherit: false)
+                      .OfType<PyArgConverterAttribute>()
+                      .SingleOrDefault()
+                    ?? method.DeclaringType?.Assembly
+                      .GetCustomAttributes(typeof(PyArgConverterAttribute), inherit: false)
+                      .OfType<PyArgConverterAttribute>()
+                      .SingleOrDefault();
+                if (converterType == null)
+                {
+                    if (attribute == null) continue;
+
+                    converterType = attribute.ConverterType;
+                    converter = attribute.Converter;
+                } else if (converterType != attribute?.ConverterType)
+                {
+                    throw new NotSupportedException("All methods must have the same IPyArgumentConverter");
+                }
+            }
+
+            return converter ?? DefaultPyArgumentConverter.Instance;
+        }
+
         /// <summary>
         /// Precedence algorithm largely lifted from Jython - the concerns are
         /// generally the same so we'll start with this and tweak as necessary.

diff --git a/src/runtime/pyargconverter.cs b/src/runtime/pyargconverter.cs
@@ -21,8 +21,14 @@ bool TryConvertArgument(IntPtr pyarg, Type parameterType,
             bool needsResolution, out object arg, out bool isOut);
     }
 
+    /// <summary>
+    /// The implementation of <see cref="IPyArgumentConverter"/> used by default
+    /// </summary>
     public class DefaultPyArgumentConverter: IPyArgumentConverter {
-        public static DefaultPyArgumentConverter Instance { get; }= new DefaultPyArgumentConverter();
+        /// <summary>
+        /// Gets the singleton instance.
+        /// </summary>
+        public static DefaultPyArgumentConverter Instance { get; } = new DefaultPyArgumentConverter();
 
         /// <summary>
         /// Attempts to convert an argument passed by Python to the specified parameter type.
@@ -44,4 +50,40 @@ public virtual bool TryConvertArgument(
                 out arg, out isOut);
         }
     }
+
+    /// <summary>
+    /// Specifies an argument converter to be used, when methods in this class/assembly are called from Python.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct)]
+    public class PyArgConverterAttribute : Attribute
+    {
+        static readonly Type[] EmptyArgTypeList = new Type[0];
+        static readonly object[] EmptyArgList = new object[0];
+
+        /// <summary>
+        /// Gets the instance of the converter, that will be used when calling methods
+        /// of this class/assembly from Python
+        /// </summary>
+        public IPyArgumentConverter Converter { get; }
+        /// <summary>
+        /// Gets the type of the converter, that will be used when calling methods
+        /// of this class/assembly from Python
+        /// </su
6167
mmary>
+        public Type ConverterType { get; }
+
+        /// <summary>
+        /// Specifies an argument converter to be used, when methods
+        /// in this class/assembly are called from Python.
+        /// </summary>
+        /// <param name="converterType">Type of the converter to use.
+        /// Must implement <see cref="IPyArgumentConverter"/>.</param>
+        public PyArgConverterAttribute(Type converterType)
+        {
+            if (converterType == null) throw new ArgumentNullException(nameof(converterType));
+            var ctor = converterType.GetConstructor(EmptyArgTypeList);
+            if (ctor == null) throw new ArgumentException("Specified converter must have public parameterless constructor");
+            this.Converter = (IPyArgumentConverter)ctor.Invoke(EmptyArgList);
+            this.ConverterType = converterType;
+        }
+    }
 }