Add function of passing an arbitrary .NET object as the value of an

yagweb · yagweb · commit d914a8984cf5 · 2017-02-15T13:43:01.000+08:00
attribute of PyObject by dynamic type
diff --git a/AUTHORS.md b/AUTHORS.md
@@ -29,6 +29,7 @@
 -   Sean Freitag ([@cowboygneox](https://github.com/cowboygneox))
 -   Serge Weinstock ([@sweinst](https://github.com/sweinst))
 -   Virgil Dupras ([@hsoft](https://github.com/hsoft))
+-   Wenguang Yang ([@yagweb](https://github.com/yagweb))
 -   Xavier Dupré ([@sdpython](https://github.com/sdpython))
 -   Zane Purvis ([@zanedp](https://github.com/zanedp))
 -   ([@ArvidJB](https://github.com/ArvidJB))
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,6 +14,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   Added XML Documentation (#349)
 -   Added Embedded tests on Appveyor (#353)
 -   Added PY3 settings to configuration-manager (#346)
+-   Added function of passing an arbitrary .NET object as the value of an attribute of PyObject (#370)(#373)
 
 ### Changed
 
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -76,6 +76,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="pyinitialize.cs" />
+    <Compile Include="dynamic.cs" />
     <Compile Include="pyimport.cs" />
     <Compile Include="pyiter.cs" />
     <Compile Include="pylong.cs" />
diff --git a/src/embed_tests/dynamic.cs b/src/embed_tests/dynamic.cs
@@ -0,0 +1,177 @@
+using System;
+using System.Text;
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    [TestFixture]
+    public class dynamicTest
+    {
+        private IntPtr gs;
+        private outstream stream;
+
+        [SetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+            gs = PythonEngine.AcquireLock();
+
+            /* redirect sys.stdout to a .NET object */
+            stream = new outstream();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            PythonEngine.ReleaseLock(gs);
+            PythonEngine.Shutdown();
+        }
+
+        /// <summary>
+        /// Set the attribute of a pyobject to null.
+        /// </summary>
+        [Test]
+        public void AssignNone()
+        {
+            dynamic sys = Py.Import("sys");
+            sys.stderr = null;
+            Assert.IsNull(sys.stderr);
+        }
+
+        /// <summary>
+        /// Set the attribute of a pyobject with a .NET object.
+        /// </summary>
+        [Test]
+        public void AssignObject()
+        {
+            dynamic sys = Py.Import("sys");
+            sys.stdout = stream;
+            // Check whether there are the same object.
+            Assert.AreEqual(sys.stdout, stream);
+
+            stream.clear();
+            PythonEngine.RunSimpleString("print('Hello!')");
+            Assert.AreEqual(stream.getvalue(), "Hello!\n");
+        }
+
+        /// <summary>
+        /// When the .NET object was created and used in Python side.
+        /// </summary>
+        /// <remarks>
+        /// Needs Pull Request #376 in order for the exception below to show up.
+        /// </remarks>
+        [Test]
+        [Ignore("System.ArgumentException : Cannot pass a GCHandle across AppDomains")]
+        public void AssignObjectInPython()
+        {
+            PythonEngine.RunSimpleString(
+                "import sys\n" +
+                "from Python.EmbeddingTest import outstream\n" +
+                "sys.stdout = outstream()\n"
+            );
+            dynamic sys = Py.Import("sys");
+            dynamic obj = sys.stdout;
+            Assert.IsTrue(obj is outstream);
+        }
+
+        /// <summary>
+        /// Check whether we can get the attr of a python object when the value of attr is a PyObject.
+        /// </summary>
+        [Test]
+        public void AssignPyObject()
+        {
+            dynamic sys = Py.Import("sys");
+            dynamic io = Py.Import("io");
+            sys.stderr = io.StringIO();
+            dynamic bb = sys.stderr; //Get the PyObject
+            bb.write("Hello!");
+            Assert.AreEqual(bb.getvalue().ToString(), "Hello!");
+        }
+
+        /// <summary>
+        /// Pass the .NET object in Python side.
+        /// </summary>
+        [Test]
+        public void PassObjectInPython()
+        {
+            dynamic sys = Py.Import("sys");
+            sys.stdout = stream;
+
+            //Pass the .NET object in Python side
+            PythonEngine.RunSimpleString(
+                "import sys\n" +
+                "from io import StringIO\n" +
+                "sys.stderr = sys.stdout\n"
+            );
+
+            //Compare in Python
+            stream.clear();
+            PythonEngine.RunSimpleString(
+                "import sys\n" +
+                "print((sys.stderr is sys.stdout))\n"
+            );
+            Assert.AreEqual(stream.getvalue(), "True\n");
+
+            //Compare in .NET
+            Assert.AreEqual(sys.stdout, sys.stderr);
+        }
+
+        /// <summary>
+        /// Pass the PyObject in .NET side
+        /// </summary>
+        [Test]
+        public void PassPyObjectInNet()
+        {
+            dynamic sys = Py.Import("sys");
+            sys.stdout = stream;
+            sys.stderr = sys.stdout;
+
+            //Compare in Python
+            PyObject res = PythonEngine.RunString(
+                "import sys\n" +
+                "print(sys.stderr is sys.stdout)\n"
+            );
+            Assert.AreEqual(sys.stdout.getvalue().ToString(), "False\n");
+
+            //Compare in .NET
+            Assert.AreEqual(sys.stdout, sys.stderr);
+        }
+    }
+
+    /// <summary>
+    /// Implement the interface of the sys.stdout redirection
+    /// </summary>
+    public class outstream
+    {
+        private StringBuilder buffer;
+
+        public outstream()
+        {
+            buffer = new StringBuilder();
+        }
+
+        public void write(string str)
+        {
+            buffer.Append(str);
+        }
+
+        public void flush()
+        {
+        }
+
+        public void close()
+        {
+        }
+
+        public void clear()
+        {
+            buffer.Clear();
+        }
+
+        public string getvalue()
+        {
+            return buffer.ToString();
+        }
+    }
+}
diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
@@ -183,6 +183,31 @@ public bool HasAttr(PyObject name)
         }
 
 
+        /// <summary>
+        /// GetAttr Method For Dynamic Type
+        /// </summary>
+        /// <remarks>
+        /// Returns the named attribute of the Python object, or raises a
+        /// PythonException if the attribute access fails.
+        /// </remarks>
+        public object GetAttrDynamic(string name)
+        {
+            IntPtr op = Runtime.PyObject_GetAttrString(obj, name);
+            if (op == IntPtr.Zero)
+            {
+                throw new PythonException();
+            }
+            if (ManagedType.IsManagedType(op))
+            {
+                ManagedType managedMethod = ManagedType.GetManagedObject(op);
+                if (managedMethod is CLRObject)
+                {
+                    return ((CLRObject)managedMethod).inst;
+                }
+            }
+            return CheckNone(new PyObject(op));
+        }
+
         /// <summary>
         /// GetAttr Method
         /// </summary>
@@ -275,6 +300,26 @@ public void SetAttr(string name, PyObject value)
             }
         }
 
+        public void SetAttrDynamic(string name, object value)
+        {
+            if (value == null)
+            {
+                int r = Runtime.PyObject_SetAttrString(obj, name, Runtime.PyNone);
+                if (r < 0)
+                {
+                    throw new PythonException();
+                }
+            }
+            else if (value is PyObject)
+            {
+                this.SetAttr(name, (PyObject)value);
+            }
+            else
+            {
+                var ptr = Converter.ToPython(value, value.GetType());
+                this.SetAttr(name, new PyObject(ptr));
+            }
+        }
 
         /// <summary>
         /// SetAttr Method
@@ -891,7 +936,7 @@ public override bool TryGetMember(GetMemberBinder binder, out object result)
         {
             if (this.HasAttr(binder.Name))
             {
-                result = CheckNone(this.GetAttr(binder.Name));
+                result = this.GetAttrDynamic(binder.Name);
                 return true;
             }
             else
@@ -904,7 +949,7 @@ public override bool TrySetMember(SetMemberBinder binder, object value)
         {
             if (this.HasAttr(binder.Name))
             {
-                this.SetAttr(binder.Name, (PyObject)value);
+                this.SetAttrDynamic(binder.Name, value);
                 return true;
             }
             else
