added RawProxyEncoder

lostmsu · lostmsu · commit a0fed9a39a97 · 2020-04-23T11:21:08.000-07:00
Now Python host can force raw encoding for autoconverted .NET types. Enables workaround for #514
diff --git a/src/embed_tests/Codecs.cs b/src/embed_tests/Codecs.cs
@@ -88,10 +88,9 @@ static void TupleRoundtripGeneric<T, TTuple>() {
     /// "Decodes" only objects of exact type <typeparamref name="T"/>.
     /// Result is just a raw Python object proxy.
     /// </summary>
-    class ObjectToRawProxyEncoder<T> : IPyObjectEncoder
+    class ObjectToRawProxyEncoder<T> : RawProxyEncoder
     {
-        public bool CanEncode(Type type) => type == typeof(T);
-        public PyObject TryEncode(object value) => this.GetRawPythonProxy();
+        public override bool CanEncode(Type type) => type == typeof(T);
     }
 
     /// <summary>
diff --git a/src/runtime/Codecs/RawProxyEncoder.cs b/src/runtime/Codecs/RawProxyEncoder.cs
@@ -0,0 +1,20 @@
+using System;
+
+namespace Python.Runtime.Codecs
+{
+    /// <summary>
+    /// A .NET object encoder, that returns raw proxies (e.g. no conversion to Python types).
+    /// <para>You must inherit from this class and override <see cref="CanEncode"/>.</para>
+    /// </summary>
+    [Obsolete(Util.UnstableApiMessage)]
+    public abstract class RawProxyEncoder: IPyObjectEncoder
+    {
+        public PyObject TryEncode(object value)
+        {
+            if (value is null) throw new ArgumentNullException(nameof(value));
+
+            return value.GetRawPythonProxy();
+        }
+        public abstract bool CanEncode(Type type);
+    }
+}
diff --git a/src/testing/conversiontest.cs b/src/testing/conversiontest.cs
@@ -1,7 +1,9 @@
 namespace Python.Test
 {
+    using System.Collections.Generic;
+
     /// <summary>
-    /// Supports units tests for field access.
+    /// Supports unit tests for field access.
     /// </summary>
     public class ConversionTest
     {
@@ -32,6 +34,7 @@ public ConversionTest()
 
         public byte[] ByteArrayField;
         public sbyte[] SByteArrayField;
+        public readonly List<int> ListField = new List<int>();
 
         public T? Echo<T>(T? arg) where T: struct {
             return arg;
diff --git a/src/tests/test_conversion.py b/src/tests/test_conversion.py
@@ -6,6 +6,8 @@
 import System
 import pytest
 from Python.Test import ConversionTest, UnicodeString
+from Python.Runtime import PyObjectConversions
+from Python.Runtime.Codecs import RawProxyEncoder
 
 from ._compat import indexbytes, long, unichr, text_type, PY2, PY3
 
@@ -700,3 +702,18 @@ def test_sbyte_array_conversion():
     array = ob.SByteArrayField
     for i, _ in enumerate(value):
         assert array[i] == indexbytes(value, i)
+
+def test_codecs():
+    """Test codec registration from Python"""
+    class ListAsRawEncoder(RawProxyEncoder):
+        def CanEncode(self, clr_type):
+            return clr_type.Name == "List`1" and clr_type.Namespace == "System.Collections.Generic"
+
+    list_raw_encoder = ListAsRawEncoder()
+    PyObjectConversions.RegisterEncoder(list_raw_encoder)
+
+    ob = ConversionTest()
+
+    l = ob.ListField
+    l.Add(42)
+    assert ob.ListField.Count == 1

Original file line number	Diff line number	Diff line change
`@@ -88,10 +88,9 @@ static void TupleRoundtripGeneric<T, TTuple>() {`
`88`	`88`	`/// "Decodes" only objects of exact type <typeparamref name="T"/>.`
`89`	`89`	`/// Result is just a raw Python object proxy.`
`90`	`90`	`/// </summary>`
`91`		`- class ObjectToRawProxyEncoder<T> : IPyObjectEncoder`
	`91`	`+ class ObjectToRawProxyEncoder<T> : RawProxyEncoder`
`92`	`92`	`{`
`93`		`- public bool CanEncode(Type type) => type == typeof(T);`
`94`		`- public PyObject TryEncode(object value) => this.GetRawPythonProxy();`
	`93`	`+ public override bool CanEncode(Type type) => type == typeof(T);`
`95`	`94`	`}`
`96`	`95`
`97`	`96`	`/// <summary>`