Add unit test

pythonnet · joaompneves · Jul 17, 2024 · Jul 18, 2024 · Jul 18, 2024 · Jul 18, 2024
commit 37c4d049a3cf81cfa5c14a0bcf19b363a14e3519
diff --git a/src/embed_tests/CodecGroups.cs b/src/embed_tests/CodecGroups.cs
@@ -48,12 +48,12 @@ public void Encodes()
                 encoder2,
             };
 
-            var uri = group.TryEncode(new Uri("data:"), typeof(Uri));
+            var uri = group.TryEncode(new Uri("data:"));
             var clrObject = (CLRObject)ManagedType.GetManagedObject(uri);
             Assert.AreSame(encoder1, clrObject.inst);
             Assert.AreNotSame(encoder2, clrObject.inst);
 
-            var tuple = group.TryEncode(Tuple.Create(1), typeof(Tuple<int>));
+            var tuple = group.TryEncode(Tuple.Create(1));
             clrObject = (CLRObject)ManagedType.GetManagedObject(tuple);
             Assert.AreSame(encoder0, clrObject.inst);
         }

diff --git a/src/embed_tests/Codecs.cs b/src/embed_tests/Codecs.cs
@@ -71,7 +71,7 @@ public void TupleRoundtripObject()
         static void TupleRoundtripObject<T, TTuple>()
         {
             var tuple = Activator.CreateInstance(typeof(T), 42.0, "42", new object());
-            using var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple, typeof(T));
+            using var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple);
             Assert.IsTrue(TupleCodec<TTuple>.Instance.TryDecode(pyTuple, out object restored));
             Assert.AreEqual(expected: tuple, actual: restored);
         }
@@ -85,7 +85,7 @@ public void TupleRoundtripGeneric()
         static void TupleRoundtripGeneric<T, TTuple>()
         {
             var tuple = Activator.CreateInstance(typeof(T), 42, "42", new object());
-            using var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple, typeof(T));
+            using var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple);
             Assert.IsTrue(TupleCodec<TTuple>.Instance.TryDecode(pyTuple, out T restored));
             Assert.AreEqual(expected: tuple, actual: restored);
         }
@@ -339,6 +339,26 @@ public void ExceptionDecoded()
             Assert.AreEqual(TestExceptionMessage, error.Message);
         }
 
+        [Test]
+        public void ExplicitObjectInterfaceEncoded()
+        {
+            var obj = new ExplicitInterfaceObject();
+
+            // explicitly pass an interface (but not a generic type argument) to simulate a scenario where the type is not know at build time
+            // var encoder = new InterfaceEncoder(typeof(IObjectInterface));
+            // PyObjectConversions.RegisterEncoder(encoder);
+
+            using var scope = Py.CreateScope();
+            scope.Exec(@"
+def call(obj):
+  return dir(obj)
+");
+            var callFunc = scope.Get("call");
+            var members = callFunc.Invoke(obj.ToPythonAs(typeof(IObjectInterface))).As<string[]>();
+            CollectionAssert.Contains(members, nameof(IObjectInterface.MemberFromInterface));
+            CollectionAssert.DoesNotContain(members, nameof(ExplicitInterfaceObject.MemberFromObject));
+        }
+
         [Test]
         public void DateTimeDecoded()
         {
@@ -438,7 +458,7 @@ public bool TryDecode<T>(PyObject pyObj, out T value)
                 return true;
             }
 
-            public PyObject TryEncode(object value, Type type)
+            public PyObject TryEncode(object value)
             {
                 var error = (ValueErrorWrapper)value;
                 return PythonEngine.Eval("ValueError").Invoke(error.Message.ToPython());
@@ -478,7 +498,7 @@ public bool TryDecode<T>(PyObject pyObj, out T value)
     class ObjectToEncoderInstanceEncoder<T> : IPyObjectEncoder
     {
         public bool CanEncode(Type type) => type == typeof(T);
-        public PyObject TryEncode(object value, Type type) => PyObject.FromManagedObject(this);
+        public PyObject TryEncode(object value) => PyObject.FromManagedObject(this);
     }
 
     /// <summary>
@@ -533,4 +553,16 @@ public bool TryDecode<T>(PyObject pyObj, out T value)
             return true;
         }
     }
+
+    interface IObjectInterface
+    {
+        int MemberFromInterface { get; }
+    }
+
+    class ExplicitInterfaceObject : IObjectInterface
+    {
+        int IObjectInterface.MemberFromInterface { get; }
+
+        public int MemberFromObject { get; }
+    }
 }
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>net472;net6.0</TargetFrameworks>
+    <RollForward>LatestMajor</RollForward>
     <AssemblyOriginatorKeyFile>..\pythonnet.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
   </PropertyGroup>

diff --git a/src/runtime/Codecs/EncoderGroup.cs b/src/runtime/Codecs/EncoderGroup.cs
@@ -28,13 +28,13 @@ public void Add(IPyObjectEncoder item)
         /// <inheritdoc />
         public bool CanEncode(Type type) => this.encoders.Any(encoder => encoder.CanEncode(type));
         /// <inheritdoc />
-        public PyObject? TryEncode(object value, Type type)
+        public PyObject? TryEncode(object value)
         {
             if (value is null) throw new ArgumentNullException(nameof(value));
 
             foreach (var encoder in this.GetEncoders(value.GetType()))
             {
-                var result = encoder.TryEncode(value, type);
+                var result = encoder.TryEncode(value);
                 if (result != null)
                 {
                     return result;

diff --git a/src/runtime/Codecs/EnumPyIntCodec.cs b/src/runtime/Codecs/EnumPyIntCodec.cs
@@ -46,11 +46,11 @@ public bool TryDecode<T>(PyObject pyObj, out T? value)
             return false;
         }
 
-        public PyObject? TryEncode(object value, Type type)
+        public PyObject? TryEncode(object value)
         {
             if (value is null) return null;
-            
-            if (!type.IsEnum) return null;
+
+            if (!value.GetType().IsEnum) return null;
 
             try
             {

diff --git a/src/runtime/Codecs/IPyObjectEncoder.cs b/src/runtime/Codecs/IPyObjectEncoder.cs
@@ -13,7 +13,6 @@ public interface IPyObjectEncoder
     bool CanEncode(Type type);
     /// <summary>
     /// Attempts to encode CLR object <paramref name="value"/> into Python object
-    /// using the specified <paramref name="type"/>
     /// </summary>
-    PyObject? TryEncode(object value, Type type);
+    PyObject? TryEncode(object value);
 }
diff --git a/src/runtime/Codecs/PyObjectConversions.cs b/src/runtime/Codecs/PyObjectConversions.cs
@@ -54,7 +54,7 @@ public static void RegisterDecoder(IPyObjectDecoder decoder)
 
             foreach (var encoder in clrToPython.GetOrAdd(type, GetEncoders))
             {
-                var result = encoder.TryEncode(obj, type);
+                var result = encoder.TryEncode(obj);
                 if (result != null) return result;
             }
 

diff --git a/src/runtime/Codecs/RawProxyEncoder.cs b/src/runtime/Codecs/RawProxyEncoder.cs
@@ -8,11 +8,11 @@ namespace Python.Runtime.Codecs
     /// </summary>
     public class RawProxyEncoder: IPyObjectEncoder
     {
-        public PyObject TryEncode(object value, Type type)
+        public PyObject TryEncode(object value)
         {
             if (value is null) throw new ArgumentNullException(nameof(value));
 
-            return PyObject.FromManagedObject(value);
+            return PyObject.FromManagedObject(value, value.GetType());
         }
 
         public virtual bool CanEncode(Type type) => false;

diff --git a/src/runtime/Codecs/TupleCodecs.cs b/src/runtime/Codecs/TupleCodecs.cs
@@ -18,10 +18,11 @@ public bool CanEncode(Type type)
                    && type.Name.StartsWith(typeof(TTuple).Name + '`');
         }
 
-        public PyObject? TryEncode(object value, Type type)
+        public PyObject? TryEncode(object value)
         {
             if (value == null) return null;
 
+            var type = value.GetType();
             if (type == typeof(object)) return null;
             if (!this.CanEncode(type)) return null;
             if (type == typeof(TTuple)) return new PyTuple();

diff --git a/src/runtime/PythonTypes/PyObject.cs b/src/runtime/PythonTypes/PyObject.cs
@@ -25,7 +25,7 @@ public partial class PyObject : DynamicObject, IDisposable, ISerializable
         /// Trace stack for PyObject's construction
         /// </summary>
         public StackTrace Traceback { get; } = new StackTrace(1);
-#endif  
+#endif
 
         protected IntPtr rawPtr = IntPtr.Zero;
         internal readonly int run = Runtime.GetRun();
@@ -136,14 +136,14 @@ public IntPtr Handle
         /// Given an arbitrary managed object, return a Python instance that
         /// reflects the managed object.
         /// </remarks>
-        public static PyObject FromManagedObject(object ob)
+        public static PyObject FromManagedObject(object ob, Type? type = null)
         {
             // Special case: if ob is null, we return None.
             if (ob == null)
             {
                 return new PyObject(Runtime.PyNone);
             }
-            return CLRObject.GetReference(ob).MoveToPyObject();
+            return CLRObject.GetReference(ob, type ?? ob.GetType()).MoveToPyObject();
         }
 
         /// <summary>
@@ -235,7 +235,7 @@ public void Dispose()
         {
             GC.SuppressFinalize(this);
             Dispose(true);
-            
+
         }
 
         internal StolenReference Steal()