allow decoders to override conversion of types derived from primitives when target type is System.Object

lostmsu · lostmsu · commit 782a0e5e01bd · 2022-10-24T09:56:23.000-07:00
useful to be able to change what numpy.float64 is converted to related to pythonnet#1957 this is an alternative to pythonnet#1958
diff --git a/src/embed_tests/Codecs.cs b/src/embed_tests/Codecs.cs
@@ -355,6 +355,19 @@ from datetime import datetime
             scope.Exec("Codecs.AcceptsDateTime(datetime(2021, 1, 22))");
         }
 
+        [Test]
+        public void FloatDerivedDecoded()
+        {
+            using var scope = Py.CreateScope();
+            scope.Exec(@"class FloatDerived(float): pass");
+            using var floatDerived = scope.Eval("FloatDerived");
+            var decoder = new DecoderReturningPredefinedValue<object>(floatDerived, 42);
+            PyObjectConversions.RegisterDecoder(decoder);
+            using var result = scope.Eval("FloatDerived()");
+            object decoded = result.As<object>();
+            Assert.AreEqual(42, decoded);
+        }
+
         [Test]
         public void ExceptionDecodedNoInstance()
         {
diff --git a/src/runtime/Converter.cs b/src/runtime/Converter.cs
@@ -361,28 +361,44 @@ internal static bool ToManagedValue(BorrowedReference value, Type obType,
             // conversions (Python string -> managed string).
             if (obType == objectType)
             {
-                if (Runtime.PyString_Check(value))
+                if (Runtime.PyString_CheckExact(value))
                 {
                     return ToPrimitive(value, stringType, out result, setError);
                 }
 
-                if (Runtime.PyBool_Check(value))
+                if (Runtime.PyBool_CheckExact(value))
                 {
                     return ToPrimitive(value, boolType, out result, setError);
                 }
 
-                if (Runtime.PyFloat_Check(value))
+                if (Runtime.PyFloat_CheckExact(value))
                 {
                     return ToPrimitive(value, doubleType, out result, setError);
                 }
 
-                // give custom codecs a chance to take over conversion of ints and sequences
+                // give custom codecs a chance to take over conversion
+                // of ints, sequences, and types derived from primitives
                 BorrowedReference pyType = Runtime.PyObject_TYPE(value);
                 if (PyObjectConversions.TryDecode(value, pyType, obType, out result))
                 {
                     return true;
                 }
 
+                if (Runtime.PyString_Check(value))
+                {
+                    return ToPrimitive(value, stringType, out result, setError);
+                }
+
+                if (Runtime.PyBool_Check(value))
+                {
+                    return ToPrimitive(value, boolType, out result, setError);
+                }
+
+                if (Runtime.PyFloat_Check(value))
+                {
+                    return ToPrimitive(value, doubleType, out result, setError);
+                }
+
                 if (Runtime.PyInt_Check(value))
                 {
                     result = new PyInt(value);

Original file line number	Diff line number	Diff line change
`@@ -361,28 +361,44 @@ internal static bool ToManagedValue(BorrowedReference value, Type obType,`
`361`	`361`	`// conversions (Python string -> managed string).`
`362`	`362`	`if (obType == objectType)`
`363`	`363`	`{`
`364`		`- if (Runtime.PyString_Check(value))`
	`364`	`+ if (Runtime.PyString_CheckExact(value))`
`365`	`365`	`{`
`366`	`366`	`return ToPrimitive(value, stringType, out result, setError);`
`367`	`367`	`}`
`368`	`368`
`369`		`- if (Runtime.PyBool_Check(value))`
	`369`	`+ if (Runtime.PyBool_CheckExact(value))`
`370`	`370`	`{`
`371`	`371`	`return ToPrimitive(value, boolType, out result, setError);`
`372`	`372`	`}`
`373`	`373`
`374`		`- if (Runtime.PyFloat_Check(value))`
	`374`	`+ if (Runtime.PyFloat_CheckExact(value))`
`375`	`375`	`{`
`376`	`376`	`return ToPrimitive(value, doubleType, out result, setError);`
`377`	`377`	`}`
`378`	`378`
`379`		`- // give custom codecs a chance to take over conversion of ints and sequences`
	`379`	`+ // give custom codecs a chance to take over conversion`
	`380`	`+ // of ints, sequences, and types derived from primitives`
`380`	`381`	`BorrowedReference pyType = Runtime.PyObject_TYPE(value);`
`381`	`382`	`if (PyObjectConversions.TryDecode(value, pyType, obType, out result))`
`382`	`383`	`{`
`383`	`384`	`return true;`
`384`	`385`	`}`
`385`	`386`
	`387`	`+ if (Runtime.PyString_Check(value))`
	`388`	`+ {`
	`389`	`+ return ToPrimitive(value, stringType, out result, setError);`
	`390`	`+ }`
	`391`	`+`
	`392`	`+ if (Runtime.PyBool_Check(value))`
	`393`	`+ {`
	`394`	`+ return ToPrimitive(value, boolType, out result, setError);`
	`395`	`+ }`
	`396`	`+`
	`397`	`+ if (Runtime.PyFloat_Check(value))`
	`398`	`+ {`
	`399`	`+ return ToPrimitive(value, doubleType, out result, setError);`
	`400`	`+ }`
	`401`	`+`
`386`	`402`	`if (Runtime.PyInt_Check(value))`
`387`	`403`	`{`
`388`	`404`	`result = new PyInt(value);`