DynamoDS
diff --git a/‎src/DynamoUtilities/DataMarshaler.cs
Copy file name to clipboard
+4-2Lines changed: 4 additions & 2 deletions b/‎src/DynamoUtilities/DataMarshaler.cs
Copy file name to clipboard
+4-2Lines changed: 4 additions & 2 deletions
diff --git a/‎src/Libraries/DSIronPython/DSIronPython.csproj
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions b/‎src/Libraries/DSIronPython/DSIronPython.csproj
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions
diff --git a/‎src/Libraries/DSIronPython/IronPythonEvaluator.cs
Copy file name to clipboard
+13-1Lines changed: 13 additions & 1 deletion b/‎src/Libraries/DSIronPython/IronPythonEvaluator.cs
Copy file name to clipboard
+13-1Lines changed: 13 additions & 1 deletion
diff --git a/‎test/DynamoCoreTests/DSEvaluationUnitTestBase.cs
Copy file name to clipboard
+44-15Lines changed: 44 additions & 15 deletions b/‎test/DynamoCoreTests/DSEvaluationUnitTestBase.cs
Copy file name to clipboard
+44-15Lines changed: 44 additions & 15 deletions
diff --git a/‎test/Libraries/DynamoPythonTests/PythonEditTests.cs
Copy file name to clipboard
+39-1Lines changed: 39 additions & 1 deletion b/‎test/Libraries/DynamoPythonTests/PythonEditTests.cs
Copy file name to clipboard
+39-1Lines changed: 39 additions & 1 deletion
@@ -18,11 +18,13 @@ public class DataMarshaler
 
         public DataMarshaler()
         {
-            //RegisterMarshaler((IEnumerable e) => e.Cast<object>().Select(Marshal));
             RegisterMarshaler((IList e) => e.Cast<object>().Select(Marshal).ToList());
             RegisterMarshaler(
                 (IDictionary dict) =>
-                    dict.Cast<dynamic>().ToDictionary(x => Marshal(x.Key), x => Marshal(x.Value)));
+                {
+                    // Dictionary<TKey, TValue> and IronPython.Runtime.PythonDictionary both implement IDictionary
+                    return dict.Keys.Cast<object>().ToDictionary(key => Marshal(key), key => Marshal(dict[key]));
+                });
         }
 
         /// <summary>
 
@@ -97,6 +97,10 @@
       <Name>DynamoServices</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\DesignScriptBuiltin\DesignScriptBuiltin.csproj">
+      <Project>{c0d6dee5-5532-4345-9c66-4c00d7fdb8be}</Project>
+      <Name>DesignScriptBuiltin</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
@@ -107,10 +111,6 @@
     <ItemGroup>
       <PythonStdLib Include="$(ProjectDir)..\..\packages\IronPython.StdLib.2.7.8.1\contentFiles\any\any\Lib\**\*.*" />
     </ItemGroup>
-    <Copy 
-      SourceFiles="@(PythonStdLib)"
-      DestinationFiles="@(PythonStdLib->'$(TargetDir)IronPython.StdLib.2.7.8\%(RecursiveDir)%(Filename)%(Extension)')"
-      SkipUnchangedFiles="true"
-    />
+    <Copy SourceFiles="@(PythonStdLib)" DestinationFiles="@(PythonStdLib->'$(TargetDir)IronPython.StdLib.2.7.8\%(RecursiveDir)%(Filename)%(Extension)')" SkipUnchangedFiles="true" />
   </Target>
 </Project>
@@ -9,6 +9,7 @@
 using IronPython.Hosting;
 
 using Microsoft.Scripting.Hosting;
+using Microsoft.Scripting.Utils;
 
 namespace DSIronPython
 {
@@ -54,7 +55,8 @@ private static string pythonStandardLibPath()
             // Return the standard library path
             if (!string.IsNullOrEmpty(dynamoCorePath))
             { return dynamoCorePath + @"\IronPython.StdLib.2.7.8"; }
-            else { return null; }
+
+            return null;
         }
 
         /// <summary>
@@ -155,6 +157,16 @@ public static DataMarshaler InputMarshaler
                             }
                             return pyList;
                         });
+                    inputMarshaler.RegisterMarshaler(
+                        delegate (DesignScript.Builtin.Dictionary dict)
+                        {
+                            var pyDict = new IronPython.Runtime.PythonDictionary();
+                            foreach (var key in dict.Keys)
+                            {
+                                pyDict.Add(inputMarshaler.Marshal(key), inputMarshaler.Marshal(dict.ValueAtKey(key)));
+                            }
+                            return pyDict;
+                        });
                 }
                 return inputMarshaler;
             }
 
@@ -155,7 +155,7 @@ protected void AssertValue(MirrorData data, object value)
             {
                 if (!(value is IEnumerable))
                 {
-                    Assert.Fail("Data is collection but expected vlaue is not.");
+                    Assert.Fail("Data is collection but expected value is not.");
                 }
                 AssertCollection(data, value as IEnumerable);
             }
@@ -180,7 +180,7 @@ protected void AssertValue(MirrorData data, object value)
                 try
                 {
                     double mirrorData = Convert.ToDouble(data.Data);
-                    Assert.AreEqual((double)value, Convert.ToDouble(data.Data), 0.00001);
+                    Assert.AreEqual((double)value, mirrorData, 0.00001);
                 }
                 catch (Exception e)
                 {
@@ -191,30 +191,59 @@ protected void AssertValue(MirrorData data, object value)
             {
                 Assert.AreEqual(data.Class.ClassName, value);
             }
-            else if (data.IsPointer && value is DesignScript.Builtin.Dictionary)
+            else if (data.IsDictionary) 
             {
                 var thisData = data.Data as DesignScript.Builtin.Dictionary;
 
-                if (thisData == null)
+                if (value is DesignScript.Builtin.Dictionary)
                 {
-                    Assert.Fail("Data is expected to be DS Dictionary but is not.");
-                }
-                var otherVal = (DesignScript.Builtin.Dictionary) value;
+                    var otherVal = (DesignScript.Builtin.Dictionary) value;
 
-                if (otherVal.Count != thisData.Count)
-                {
-                    Assert.Fail("Data and expected value are 2 different dictionaries.");
+                    if (otherVal.Count != thisData.Count)
+                    {
+                        Assert.Fail("Data and expected value are 2 different dictionaries.");
+                    }
+
+                    foreach (var key in otherVal.Keys)
+                    {
+                        var val = thisData.ValueAtKey(key);
+                        if (val == null)
+                        {
+                            Assert.Fail("Data and expected value are 2 different dictionaries.");
+                        }
+
+                        if (val.GetType().IsValueType)
+                        {
+                            Assert.AreEqual(val, thisData.ValueAtKey(key));
+                        }
+                    }
                 }
-                foreach (var key in otherVal.Keys)
+                else if (value is IDictionary)
                 {
-                    var val = thisData.ValueAtKey(key);
-                    if (val == null)
+                    var otherVal = (IDictionary)value;
+
+                    if (otherVal.Count != thisData.Count)
                     {
                         Assert.Fail("Data and expected value are 2 different dictionaries.");
                     }
-                    if (val.GetType().IsValueType)
+
+                    foreach (var key in otherVal.Keys)
                     {
-                        Assert.AreEqual(val, thisData.ValueAtKey(key));
+                        if (!(key is string))
+                        {
+                            Assert.Fail("Expected value is a dictionary with non-string key(s).");
+                        }
+                        var strKey = (string) key;
+                        var val = thisData.ValueAtKey(strKey);
+                        if (val == null)
+                        {
+                            Assert.Fail("Data and expected value are 2 different dictionaries.");
+                        }
+
+                        if (val.GetType().IsValueType)
+                        {
+                            Assert.AreEqual(val, thisData.ValueAtKey(strKey));
+                        }
                     }
                 }
             }
 
@@ -16,6 +16,7 @@ public class PythonEditTests : DynamoViewModelUnitTest
     {
         protected override void GetLibrariesToPreload(List<string> libraries)
         {
+            libraries.Add("DesignScriptBuiltin.dll");
             libraries.Add("DSIronPython.dll");
             base.GetLibrariesToPreload(libraries);
         }
@@ -159,7 +160,7 @@ public void VerifyPythonLoadsFromCore()
             foreach(NodeModel node in allNodes) {
                 var guid = node.GUID.ToString();
 
-                // if node is a test node, verify truthy value
+                // if node is a test node, verify truth value
                 if (testingNodeGUIDS.Contains(guid) ) {
                     AssertPreviewValue(guid, true);
                 }
@@ -169,6 +170,43 @@ public void VerifyPythonLoadsFromCore()
             Assert.NotNull(pynode);
         }
 
+        [Test]
+        public void ReturnPythonDictionary_AsDynamoDictionary()
+        {
+            // open test graph
+            var examplePath = Path.Combine(TestDirectory, @"core\python", "python_dict.dyn");
+            ViewModel.OpenCommand.Execute(examplePath);
+
+            var guid = "490a8d54d0fa4782ae18c81f6eef8306";
+
+            AssertPreviewValue(guid, new Dictionary<string, int> { { "abc", 123 }, { "def", 345 } });
+        }
+
+        [Test]
+        public void InputDynamoDictionary_AsPythonDictionary()
+        {
+            // open test graph
+            var examplePath = Path.Combine(TestDirectory, @"core\python", "python_dict2.dyn");
+            ViewModel.OpenCommand.Execute(examplePath);
+
+            var guid = "490a8d54d0fa4782ae18c81f6eef8306";
+
+            AssertPreviewValue(guid,
+                new List<object> {new Dictionary<string, int> {{"abcd", 123}}, new List<int> {1, 2, 3, 4, 5, 6, 7, 8, 9}});
+        }
+
+        [Test]
+        public void ReturnIronPythonDictionary_AsDynamoDictionary()
+        {
+            // open test graph
+            var examplePath = Path.Combine(TestDirectory, @"core\python", "netDict_from_python.dyn");
+            ViewModel.OpenCommand.Execute(examplePath);
+
+            var guid = "490a8d54d0fa4782ae18c81f6eef8306";
+
+            AssertPreviewValue(guid, new Dictionary<string, int> {{"abc", 123}, {"def", 10}});
+        }
+
         private void UpdatePythonNodeContent(ModelBase pythonNode, string value)
         {
             var command = new DynCmd.UpdateModelValueCommand(
Original file line number	Diff line number	Diff line change
`@@ -18,11 +18,13 @@ public class DataMarshaler`
`18`	`18`
`19`	`19`	`public DataMarshaler()`
`20`	`20`	`{`
`21`		`- //RegisterMarshaler((IEnumerable e) => e.Cast<object>().Select(Marshal));`
`22`	`21`	`RegisterMarshaler((IList e) => e.Cast<object>().Select(Marshal).ToList());`
`23`	`22`	`RegisterMarshaler(`
`24`	`23`	`(IDictionary dict) =>`
`25`		`- dict.Cast<dynamic>().ToDictionary(x => Marshal(x.Key), x => Marshal(x.Value)));`
	`24`	`+ {`
	`25`	`+ // Dictionary<TKey, TValue> and IronPython.Runtime.PythonDictionary both implement IDictionary`
	`26`	`+ return dict.Keys.Cast<object>().ToDictionary(key => Marshal(key), key => Marshal(dict[key]));`
	`27`	`+ });`
`26`	`28`	`}`
`27`	`29`
`28`	`30`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ protected void AssertValue(MirrorData data, object value)`
`155`	`155`	`{`
`156`	`156`	`if (!(value is IEnumerable))`
`157`	`157`	`{`
`158`		`- Assert.Fail("Data is collection but expected vlaue is not.");`
	`158`	`+ Assert.Fail("Data is collection but expected value is not.");`
`159`	`159`	`}`
`160`	`160`	`AssertCollection(data, value as IEnumerable);`
`161`	`161`	`}`
`@@ -180,7 +180,7 @@ protected void AssertValue(MirrorData data, object value)`
`180`	`180`	`try`
`181`	`181`	`{`
`182`	`182`	`double mirrorData = Convert.ToDouble(data.Data);`
`183`		`- Assert.AreEqual((double)value, Convert.ToDouble(data.Data), 0.00001);`
	`183`	`+ Assert.AreEqual((double)value, mirrorData, 0.00001);`
`184`	`184`	`}`
`185`	`185`	`catch (Exception e)`
`186`	`186`	`{`
`@@ -191,30 +191,59 @@ protected void AssertValue(MirrorData data, object value)`
`191`	`191`	`{`
`192`	`192`	`Assert.AreEqual(data.Class.ClassName, value);`
`193`	`193`	`}`
`194`		`- else if (data.IsPointer && value is DesignScript.Builtin.Dictionary)`
	`194`	`+ else if (data.IsDictionary)`
`195`	`195`	`{`
`196`	`196`	`var thisData = data.Data as DesignScript.Builtin.Dictionary;`
`197`	`197`
`198`		`- if (thisData == null)`
	`198`	`+ if (value is DesignScript.Builtin.Dictionary)`
`199`	`199`	`{`
`200`		`- Assert.Fail("Data is expected to be DS Dictionary but is not.");`
`201`		`- }`
`202`		`- var otherVal = (DesignScript.Builtin.Dictionary) value;`
	`200`	`+ var otherVal = (DesignScript.Builtin.Dictionary) value;`
`203`	`201`
`204`		`- if (otherVal.Count != thisData.Count)`
`205`		`- {`
`206`		`- Assert.Fail("Data and expected value are 2 different dictionaries.");`
	`202`	`+ if (otherVal.Count != thisData.Count)`
	`203`	`+ {`
	`204`	`+ Assert.Fail("Data and expected value are 2 different dictionaries.");`
	`205`	`+ }`
	`206`	`+`
	`207`	`+ foreach (var key in otherVal.Keys)`
	`208`	`+ {`
	`209`	`+ var val = thisData.ValueAtKey(key);`
	`210`	`+ if (val == null)`
	`211`	`+ {`
	`212`	`+ Assert.Fail("Data and expected value are 2 different dictionaries.");`
	`213`	`+ }`
	`214`	`+`
	`215`	`+ if (val.GetType().IsValueType)`
	`216`	`+ {`
	`217`	`+ Assert.AreEqual(val, thisData.ValueAtKey(key));`
	`218`	`+ }`
	`219`	`+ }`
`207`	`220`	`}`
`208`		`- foreach (var key in otherVal.Keys)`
	`221`	`+ else if (value is IDictionary)`
`209`	`222`	`{`
`210`		`- var val = thisData.ValueAtKey(key);`
`211`		`- if (val == null)`
	`223`	`+ var otherVal = (IDictionary)value;`
	`224`	`+`
	`225`	`+ if (otherVal.Count != thisData.Count)`
`212`	`226`	`{`
`213`	`227`	`Assert.Fail("Data and expected value are 2 different dictionaries.");`
`214`	`228`	`}`
`215`		`- if (val.GetType().IsValueType)`
	`229`	`+`
	`230`	`+ foreach (var key in otherVal.Keys)`
`216`	`231`	`{`
`217`		`- Assert.AreEqual(val, thisData.ValueAtKey(key));`
	`232`	`+ if (!(key is string))`
	`233`	`+ {`
	`234`	`+ Assert.Fail("Expected value is a dictionary with non-string key(s).");`
	`235`	`+ }`
	`236`	`+ var strKey = (string) key;`
	`237`	`+ var val = thisData.ValueAtKey(strKey);`
	`238`	`+ if (val == null)`
	`239`	`+ {`
	`240`	`+ Assert.Fail("Data and expected value are 2 different dictionaries.");`
	`241`	`+ }`
	`242`	`+`
	`243`	`+ if (val.GetType().IsValueType)`
	`244`	`+ {`
	`245`	`+ Assert.AreEqual(val, thisData.ValueAtKey(strKey));`
	`246`	`+ }`
`218`	`247`	`}`
`219`	`248`	`}`
`220`	`249`	`}`