Decode Python Dictionary in function calls (#10868)

mmisol · web-flow · commit b58f0d94e63f · 2020-07-10T10:12:23.000-04:00
Allows to decode Python dict to .NET IDictionary by using a Python.NET
decoder. Both generic and non-generic dictionaries are supported.
diff --git a/src/Libraries/DSCPython/CPythonEvaluator.cs b/src/Libraries/DSCPython/CPythonEvaluator.cs
@@ -111,8 +111,12 @@ public static object EvaluatePythonScript(
         /// </summary>
         private static void InitializeEncoders()
         {
-            var encoders = new IPyObjectEncoder[] { new BigIntegerEncoder(), new ListEncoder() };
-            var decoders = encoders.Cast<IPyObjectDecoder>().ToArray();
+            var shared = new object[] { new BigIntegerEncoderDecoder(), new ListEncoderDecoder() };
+            var encoders = shared.Cast<IPyObjectEncoder>().ToArray();
+            var decoders = shared.Cast<IPyObjectDecoder>().Concat(new IPyObjectDecoder[]
+            {
+                new DictionaryDecoder()
+            }).ToArray();
             Array.ForEach(encoders, e => PyObjectConversions.RegisterEncoder(e));
             Array.ForEach(decoders, d => PyObjectConversions.RegisterDecoder(d));
         }
diff --git a/src/Libraries/DSCPython/DSCPython.csproj b/src/Libraries/DSCPython/DSCPython.csproj
@@ -61,9 +61,10 @@
     <Compile Include="..\..\AssemblySharedInfoGenerator\AssemblySharedInfo.cs">
       <Link>Properties\AssemblySharedInfo.cs</Link>
     </Compile>
-    <Compile Include="Encoders\BigIntegerEncoder.cs" />
+    <Compile Include="Encoders\BigIntegerEncoderDecoder.cs" />
     <Compile Include="CPythonEvaluator.cs" />
-    <Compile Include="Encoders\ListEncoder.cs" />
+    <Compile Include="Encoders\DictionaryDecoder.cs" />
+    <Compile Include="Encoders\ListEncodeDecoder.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
diff --git a/src/Libraries/DSCPython/Encoders/BigIntegerEncoderDecoder.cs b/src/Libraries/DSCPython/Encoders/BigIntegerEncoderDecoder.cs
@@ -4,7 +4,7 @@
 
 namespace DSCPython.Encoders
 {
-    internal class BigIntegerEncoder : IPyObjectEncoder, IPyObjectDecoder
+    internal class BigIntegerEncoderDecoder : IPyObjectEncoder, IPyObjectDecoder
     {
         public bool CanDecode(PyObject objectType, Type targetType)
         {
diff --git a/src/Libraries/DSCPython/Encoders/DictionaryDecoder.cs b/src/Libraries/DSCPython/Encoders/DictionaryDecoder.cs
@@ -0,0 +1,48 @@
+﻿using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Dynamo.Utilities;
+using Python.Runtime;
+
+namespace DSCPython.Encoders
+{
+    internal class DictionaryDecoder : IPyObjectDecoder
+    {
+        private static readonly Type[] decodableTypes = new Type[]
+        {
+            typeof(IDictionary<,>), typeof(Dictionary<,>),
+            typeof(IDictionary), typeof(Hashtable)
+        };
+
+        public bool CanDecode(PyObject objectType, Type targetType)
+        {
+            if (targetType.IsGenericType)
+            {
+                targetType = targetType.GetGenericTypeDefinition();
+            }
+            return decodableTypes.IndexOf(targetType) >= 0;
+        }
+
+        public bool TryDecode<T>(PyObject pyObj, out T value)
+        {
+            if (!PyDict.IsDictType(pyObj))
+            {
+                value = default;
+                return false;
+            }
+            using (var pyDict = new PyDict(pyObj))
+            {
+                if (typeof(T).IsGenericType)
+                {
+                    value = pyDict.ToDictionary<T>();
+                }
+                else
+                {
+                    value = (T)pyDict.ToDictionary();
+                }
+                return true;
+            }
+        }
+    }
+}
diff --git a/src/Libraries/DSCPython/Encoders/ListEncodeDecoder.cs b/src/Libraries/DSCPython/Encoders/ListEncodeDecoder.cs
@@ -6,7 +6,7 @@
 
 namespace DSCPython.Encoders
 {
-    internal class ListEncoder : IPyObjectEncoder, IPyObjectDecoder
+    internal class ListEncoderDecoder : IPyObjectEncoder, IPyObjectDecoder
     {
         private static readonly Type[] decodableTypes = new Type[]
         {
diff --git a/test/Libraries/DynamoPythonTests/PythonEvalTestsWithLibraries.cs b/test/Libraries/DynamoPythonTests/PythonEvalTestsWithLibraries.cs
@@ -176,8 +176,7 @@ from DSCore import List
         }
 
         [Test]
-        [Category("Failure")]
-        public void TestDictionaryEncoding()
+        public void TestDictionaryDecodingCPython()
         {
             string code = @"
 import sys
@@ -188,25 +187,35 @@ from DesignScript.Builtin import Dictionary
 from FFITarget import DummyCollection
 
 d = {'one': 1, 'two': 2, 'three': 3}
-# Python dict => DS Dictionary - Does not work in either engine
-# d2 = Dictionary.SetValueAtKeys(d, ['four'], [4])
 
-# Python dict => .NET IDictionary - Does not work in CPython
-d = DummyCollection.AcceptIDictionary(d)
-# .NET IDictionary => Python dict - Works in IronPython. Could not test in CPython due to previous bug
-d['five'] = 5
+# Python dict => .NET IDictionary
+untypedDictionary = DummyCollection.AcceptIDictionary(d)
+untypedDictionary['four'] = 4
 
-OUT = d
+# Python dict => .NET IDictionary<> - Does not work in IronPython
+typedDictionary = DummyCollection.AcceptDictionary(d)
+typedDictionary['four'] = 4
+
+OUT = untypedDictionary, typedDictionary
 ";
             var empty = new ArrayList();
             var expected = new Dictionary<string, int> {
-                { "one", 1 }, { "two", 2 }, { "three", 3 }, { "five", 5 }
+                { "one", 1 }, { "two", 2 }, { "three", 3 }, { "four", 4 }
             };
-            foreach (var pythonEvaluator in Evaluators)
+            var result = DSCPython.CPythonEvaluator.EvaluatePythonScript(code, empty, empty);
+            Assert.IsTrue(result is IList);
+            foreach (var dict in result as IList)
             {
-                var result = pythonEvaluator(code, empty, empty);
-                Assert.IsTrue(result is IDictionary);
-                CollectionAssert.AreEquivalent(expected, result as IDictionary);
+                DictionaryAssert(expected, dict as IDictionary);
+            }
+        }
+
+        private void DictionaryAssert(IDictionary expected, IDictionary actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            foreach (var key in expected.Keys)
+            {
+                Assert.AreEqual(expected[key], actual[key]);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace DSCPython.Encoders`
`6`	`6`	`{`
`7`		`- internal class BigIntegerEncoder : IPyObjectEncoder, IPyObjectDecoder`
	`7`	`+ internal class BigIntegerEncoderDecoder : IPyObjectEncoder, IPyObjectDecoder`
`8`	`8`	`{`
`9`	`9`	`public bool CanDecode(PyObject objectType, Type targetType)`
`10`	`10`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`namespace DSCPython.Encoders`
`8`	`8`	`{`
`9`		`- internal class ListEncoder : IPyObjectEncoder, IPyObjectDecoder`
	`9`	`+ internal class ListEncoderDecoder : IPyObjectEncoder, IPyObjectDecoder`
`10`	`10`	`{`
`11`	`11`	`private static readonly Type[] decodableTypes = new Type[]`
`12`	`12`	`{`