CPython engine marshals python classes to lists when the expectation is to get a handle. (#10974)

mjkkirschner · web-flow · commit 0348ed023fb8 · 2020-08-10T11:26:53.000-04:00
* return handles for pyobjs marked with do not convert

* add test

* review coments

* review comments
diff --git a/src/Libraries/DSCPython/CPythonEvaluator.cs b/src/Libraries/DSCPython/CPythonEvaluator.cs
@@ -144,6 +144,7 @@ public enum EvaluationState { Begin, Success, Failed }
     [IsVisibleInDynamoLibrary(false)]
     public static class CPythonEvaluator
     {
+        private const string DynamoSkipAttributeName = "__dynamoskipconversion__";
         static PyScope globalScope;
         internal static readonly string globalScopeName = "global";
         static CPythonEvaluator()
@@ -384,6 +385,12 @@ public static DataMarshaler OutputMarshaler
                             {
                                 return outputMarshaler.Marshal(clrObj);
                             }
+
+                            if (IsMarkedToSkipConversion(pyObj))
+                            {
+                                return GetDynamoCPythonHandle(pyObj);
+                            }
+
                             // Dictionaries are iterable, so they should come first
                             if (PyDict.IsDictType(pyObj))
                             {
@@ -436,11 +443,7 @@ public static DataMarshaler OutputMarshaler
                                 {
                                     if (unmarshalled.Equals(pyObj))
                                     {
-                                        var globalScope = PyScopeManager.Global.Get(globalScopeName);
-                                        //try moving object to global scope
-                                        globalScope.Set(pyObj.Handle.ToString(), pyObj);
-
-                                        return new DynamoCPythonHandle(pyObj.Handle);
+                                        return GetDynamoCPythonHandle(pyObj);
                                     }
                                     else
                                     {
@@ -456,6 +459,18 @@ public static DataMarshaler OutputMarshaler
             }
         }
 
+        private static DynamoCPythonHandle GetDynamoCPythonHandle(PyObject pyObj)
+        {
+            var globalScope = PyScopeManager.Global.Get(globalScopeName);
+            globalScope.Set(pyObj.Handle.ToString(), pyObj);
+            return new DynamoCPythonHandle(pyObj.Handle);
+        }
+
+        private static bool IsMarkedToSkipConversion(PyObject pyObj)
+        {
+            return pyObj.HasAttr(DynamoSkipAttributeName);
+        }
+
         private static DataMarshaler inputMarshaler;
         private static DataMarshaler outputMarshaler;
 
diff --git a/test/Libraries/DynamoPythonTests/PythonEvalTests.cs b/test/Libraries/DynamoPythonTests/PythonEvalTests.cs
@@ -2,6 +2,8 @@
 using System.Collections;
 using System.Collections.Generic;
 using NUnit.Framework;
+using System.Linq;
+using ProtoCore.Lang;
 
 namespace DSPythonTests
 {
@@ -212,6 +214,48 @@ def __str__(self):
             });
         }
 
+        [Test]
+        public void PythonObjectWithDynamoSkipisNotMarshaled()
+        {
+            var code = @"
+
+class iterable:
+    def __str__(self):
+        return 'I want to participate in conversion'
+    def __iter__(self):
+        return iter([0,1,2,3])
+    def __getitem__(self,key):
+        return key
+
+o = iterable()
+OUT = o
+";
+
+            var code2 = @"
+
+class notiterable:
+    def __dynamoskipconversion__(self):
+        pass
+    def __str__(self):
+        return 'I want to skip in conversion'
+    def __iter__(self):
+        return iter([0,1,2,3])
+    def __getitem__(self,key):
+        return key
+
+o = notiterable()
+OUT = o
+";
+            var empty = new ArrayList();
+            var result1 = DSCPython.CPythonEvaluator.EvaluatePythonScript(code, empty, empty);
+            var result2 = DSCPython.CPythonEvaluator.EvaluatePythonScript(code2, empty, empty);
+            Assert.IsInstanceOf(typeof(IList), result1);
+            Assert.IsTrue(new List<object>() { 0L, 1L, 2L, 3L }
+                .SequenceEqual((IEnumerable<Object>)result1));
+            Assert.IsInstanceOf(typeof(DSCPython.DynamoCPythonHandle),result2 );
+
+        }
+
         [Test]
         public void NonListIterablesCanBeOutput()
         {

Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,7 @@ public enum EvaluationState { Begin, Success, Failed }`
`144`	`144`	`[IsVisibleInDynamoLibrary(false)]`
`145`	`145`	`public static class CPythonEvaluator`
`146`	`146`	`{`
	`147`	`+ private const string DynamoSkipAttributeName = "__dynamoskipconversion__";`
`147`	`148`	`static PyScope globalScope;`
`148`	`149`	`internal static readonly string globalScopeName = "global";`
`149`	`150`	`static CPythonEvaluator()`
`@@ -384,6 +385,12 @@ public static DataMarshaler OutputMarshaler`
`384`	`385`	`{`
`385`	`386`	`return outputMarshaler.Marshal(clrObj);`
`386`	`387`	`}`
	`388`	`+`
	`389`	`+ if (IsMarkedToSkipConversion(pyObj))`
	`390`	`+ {`
	`391`	`+ return GetDynamoCPythonHandle(pyObj);`
	`392`	`+ }`
	`393`	`+`
`387`	`394`	`// Dictionaries are iterable, so they should come first`
`388`	`395`	`if (PyDict.IsDictType(pyObj))`
`389`	`396`	`{`
`@@ -436,11 +443,7 @@ public static DataMarshaler OutputMarshaler`
`436`	`443`	`{`
`437`	`444`	`if (unmarshalled.Equals(pyObj))`
`438`	`445`	`{`
`439`		`- var globalScope = PyScopeManager.Global.Get(globalScopeName);`
`440`		`- //try moving object to global scope`
`441`		`- globalScope.Set(pyObj.Handle.ToString(), pyObj);`
`442`		`-`
`443`		`- return new DynamoCPythonHandle(pyObj.Handle);`
	`446`	`+ return GetDynamoCPythonHandle(pyObj);`
`444`	`447`	`}`
`445`	`448`	`else`
`446`	`449`	`{`
`@@ -456,6 +459,18 @@ public static DataMarshaler OutputMarshaler`
`456`	`459`	`}`
`457`	`460`	`}`
`458`	`461`
	`462`	`+ private static DynamoCPythonHandle GetDynamoCPythonHandle(PyObject pyObj)`
	`463`	`+ {`
	`464`	`+ var globalScope = PyScopeManager.Global.Get(globalScopeName);`
	`465`	`+ globalScope.Set(pyObj.Handle.ToString(), pyObj);`
	`466`	`+ return new DynamoCPythonHandle(pyObj.Handle);`
	`467`	`+ }`
	`468`	`+`
	`469`	`+ private static bool IsMarkedToSkipConversion(PyObject pyObj)`
	`470`	`+ {`
	`471`	`+ return pyObj.HasAttr(DynamoSkipAttributeName);`
	`472`	`+ }`
	`473`	`+`
`459`	`474`	`private static DataMarshaler inputMarshaler;`
`460`	`475`	`private static DataMarshaler outputMarshaler;`
`461`	`476`