From 55a8b156276fd86a16f00db900d899b63f22a57f Mon Sep 17 00:00:00 2001
From: testrunner123 <testrunner@gmx.de>
Date: Mon, 18 Sep 2017 11:59:21 +0200
Subject: [PATCH 01/19] Add traceback information to exception

---
 src/runtime/exceptions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs
index 9023cfcfa..7e0076269 100644
--- a/src/runtime/exceptions.cs
+++ b/src/runtime/exceptions.cs
@@ -256,7 +256,7 @@ public static void SetError(Exception e)
             var pe = e as PythonException;
             if (pe != null)
             {
-                Runtime.PyErr_SetObject(pe.PyType, pe.PyValue);
+                Runtime.PyErr_Restore(pe.PyType, pe.PyValue, pe.PyTB);
                 return;
             }
 

From 01c8fea434aa4d45ed736c6f9029c38ce8d55082 Mon Sep 17 00:00:00 2001
From: testrunner123 <testrunner@gmx.de>
Date: Mon, 18 Sep 2017 16:49:23 +0200
Subject: [PATCH 02/19] Revert "Add traceback information to exception"

This reverts commit 55a8b156276fd86a16f00db900d899b63f22a57f.
---
 src/runtime/exceptions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs
index 7e0076269..9023cfcfa 100644
--- a/src/runtime/exceptions.cs
+++ b/src/runtime/exceptions.cs
@@ -256,7 +256,7 @@ public static void SetError(Exception e)
             var pe = e as PythonException;
             if (pe != null)
             {
-                Runtime.PyErr_Restore(pe.PyType, pe.PyValue, pe.PyTB);
+                Runtime.PyErr_SetObject(pe.PyType, pe.PyValue);
                 return;
             }
 

From 5474bedb889c1056b4c3b1144d80ae89ce2424e4 Mon Sep 17 00:00:00 2001
From: denfromufa <denfromufa@users.noreply.github.com>
Date: Wed, 7 Jun 2017 14:45:35 -0500
Subject: [PATCH 03/19] documentation update for keyword arguments (#483)

* documentation update for keyword arguments

* Update README.md

* Update CHANGELOG.md
---
 CHANGELOG.md | 3 ++-
 README.md    | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6c245b17b..c8b54b36d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,8 +9,9 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 
 ### Added
 -   Added clr.GetClrType (#432)(#433)
--   Added `Foo` feature
 -   Allowed passing None for nullable args (#460)
+-   Added keyword arguments based on C# syntax for calling CPython methods (#461)
+
 
 ### Changed
 
diff --git a/README.md b/README.md
index da43abacd..7d12eafaf 100644
--- a/README.md
+++ b/README.md
@@ -42,7 +42,7 @@ from System.Windows.Forms import Form
     a `using (Py.GIL()) {/* Your code here */}` block.
 -   Import python modules using `dynamic mod = Py.Import("mod")`,
     then you can call functions as normal, eg `mod.func(args)`.
--   Use `mod.func(args, Py.kw("keywordargname", keywordargvalue))`
+-   Use `mod.func(args, Py.kw("keywordargname", keywordargvalue))` or `mod.func(args, keywordargname=keywordargvalue)`
     to apply keyword arguments.
 -   All python objects should be declared as `dynamic` type.
 -   Mathematical operations involving python and literal/managed types must
@@ -67,7 +67,7 @@ static void Main(string[] args)
         dynamic a = np.array(new List<float> { 1, 2, 3 });
         Console.WriteLine(a.dtype);
 
-        dynamic b = np.array(new List<float> { 6, 5, 4 }, Py.kw("dtype", np.int32));
+        dynamic b = np.array(new List<float> { 6, 5, 4 }, dtype=np.int32);
         Console.WriteLine(b.dtype);
 
         Console.WriteLine(a * b);

From ed03682a93c1d0b720abae93b289098c49e2589f Mon Sep 17 00:00:00 2001
From: yagweb <hbtmdxywg@gmail.com>
Date: Fri, 9 Jun 2017 21:56:22 +0800
Subject: [PATCH 04/19] =?UTF-8?q?add=20a=20scope=20class=20to=20manage=20t?=
 =?UTF-8?q?he=20context=20of=20interaction=20with=20Python=20an=E2=80=A6?=
 =?UTF-8?q?=20(#381)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* add a scope class to manage the context of interaction with Python and simplify the variable exchanging

* Deprecate public RunString

Had to remove defaults to disambiguate call on `internal RunString`.
Can re-add after removing `public RunString`

Closes #401

* Rename several methods and add three methods

Referring to IronPython, change the name of the methods Get, Exists, SetLocal, DelLocal to GetVariable, ContainsVariable, SetVariable, RemoveVariable.
Hidden the methods SetGlobalVariable, RemoveGlobalVariable.
Add a new method 'Compile' to compile string into ast, the ast can be seen as the ScriptSource of IronPython.
Add two new methods 'Execute' and 'Execute<T>' to execute an ast and
obtain the result, corresponding to the 'Execute' method of IronPython.

* rebased

* Rebased update

* format cleanup

* create unnamed pyscope, make PyScope.GILState save

remove method GetInstHandle
add function to create unnamed pyscope
add a field isDisposed for PyScope.GILState to make it more save

* fixup! create unnamed pyscope, make PyScope.GILState save

* remove GIL and rebased

* Add several methods

add ImportScope: a scope can import variable from any scope, equivalent to
python 'import * from mod'
add dynamic member support
add an OnDispose event
remove the field ‘globals’ referring to python module
put the scope class in a new file

Unit test:
TestThread uses scope function replacing Exec/Eval to speed up the execution.

* add a Variables method

* fixup! add a Variables method

* remove private method _GetVariable

* add unit test for Variables() method

* add several methods and rebased

Add an optional dict parameter for Eval/Exec/Execute methods
Add a new field obj which point to a Python Module (same as pyobject)
Add a static method New
Rename the old ImportScope method to ImportAllFromScope
Add a new ImportScope method and add a unit test for it
Rename the CreateScope method to NewScope

* add a new class PyScopeManager

* cleaned up the Import methods

* updated according to filmor's comments

* fixup! updated according to filmor's comments

* Get/Set Methods renamed
---
 src/embed_tests/Python.EmbeddingTest.csproj |   1 +
 src/embed_tests/TestPyScope.cs              | 372 +++++++++++
 src/runtime/Python.Runtime.csproj           |   3 +-
 src/runtime/pyobject.cs                     |  21 +
 src/runtime/pyscope.cs                      | 655 ++++++++++++++++++++
 src/runtime/pythonengine.cs                 |  20 +
 src/runtime/runtime.cs                      |   3 +
 7 files changed, 1074 insertions(+), 1 deletion(-)
 create mode 100644 src/embed_tests/TestPyScope.cs
 create mode 100644 src/runtime/pyscope.cs

diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
index 2edf4f515..fc887d815 100644
--- a/src/embed_tests/Python.EmbeddingTest.csproj
+++ b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -100,6 +100,7 @@
     <Compile Include="TestNamedArguments.cs" />
     <Compile Include="TestPyWith.cs" />
     <Compile Include="TestRuntime.cs" />
+    <Compile Include="TestPyScope.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\runtime\Python.Runtime.csproj">
diff --git a/src/embed_tests/TestPyScope.cs b/src/embed_tests/TestPyScope.cs
new file mode 100644
index 000000000..49c15a3a1
--- /dev/null
+++ b/src/embed_tests/TestPyScope.cs
@@ -0,0 +1,372 @@
+using System;
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    public class PyScopeTest
+    {
+        private PyScope ps;
+
+        [SetUp]
+        public void SetUp()
+        {
+            using (Py.GIL())
+            {
+                ps = Py.CreateScope("test");
+            }                
+        }
+
+        [TearDown]
+        public void Dispose()
+        {
+            using (Py.GIL())
+            {
+                ps.Dispose();
+                ps = null;
+            }
+        }
+
+        /// <summary>
+        /// Eval a Python expression and obtain its return value.
+        /// </summary>
+        [Test]
+        public void TestEval()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("a", 1);
+                var result = ps.Eval<int>("a + 2");
+                Assert.AreEqual(3, result);
+            }                
+        }
+
+        /// <summary>
+        /// Exec Python statements and obtain the variables created.
+        /// </summary>
+        [Test]
+        public void TestExec()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100); //declare a global variable
+                ps.Set("cc", 10); //declare a local variable
+                ps.Exec("aa = bb + cc + 3");
+                var result = ps.Get<int>("aa");
+                Assert.AreEqual(113, result);
+            }
+        }
+
+        /// <summary>
+        /// Compile an expression into an ast object;
+        /// Execute the ast and obtain its return value.
+        /// </summary>
+        [Test]
+        public void TestCompileExpression()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100); //declare a global variable
+                ps.Set("cc", 10); //declare a local variable
+                PyObject script = PythonEngine.Compile("bb + cc + 3", "", RunFlagType.Eval);
+                var result = ps.Execute<int>(script);
+                Assert.AreEqual(113, result);
+            }
+        }
+
+        /// <summary>
+        /// Compile Python statements into an ast object;
+        /// Execute the ast;
+        /// Obtain the local variables created.
+        /// </summary>
+        [Test]
+        public void TestCompileStatements()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100); //declare a global variable
+                ps.Set("cc", 10); //declare a local variable
+                PyObject script = PythonEngine.Compile("aa = bb + cc + 3", "", RunFlagType.File);
+                ps.Execute(script);
+                var result = ps.Get<int>("aa");
+                Assert.AreEqual(113, result);
+            }
+        }
+
+        /// <summary>
+        /// Create a function in the scope, then the function can read variables in the scope.
+        /// It cannot write the variables unless it uses the 'global' keyword.
+        /// </summary>
+        [Test]
+        public void TestScopeFunction()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+                ps.Exec(
+                    "def func1():\n" +
+                    "    bb = cc + 10\n");
+                dynamic func1 = ps.Get("func1");
+                func1(); //call the function, it can be called any times
+                var result = ps.Get<int>("bb");
+                Assert.AreEqual(100, result);
+
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+                ps.Exec(
+                    "def func2():\n" +
+                    "    global bb\n" +
+                    "    bb = cc + 10\n");
+                dynamic func2 = ps.Get("func2");
+                func2();
+                result = ps.Get<int>("bb");
+                Assert.AreEqual(20, result);
+            }
+        }
+
+        /// <summary>
+        /// Create a class in the scope, the class can read variables in the scope.
+        /// Its methods can write the variables with the help of 'global' keyword.
+        /// </summary>
+        [Test]
+        public void TestScopeClass()
+        {
+            using (Py.GIL())
+            {
+                dynamic _ps = ps;
+                _ps.bb = 100;
+                ps.Exec(
+                    "class Class1():\n" +
+                    "    def __init__(self, value):\n" +
+                    "        self.value = value\n" +
+                    "    def call(self, arg):\n" +
+                    "        return self.value + bb + arg\n" + //use scope variables
+                    "    def update(self, arg):\n" +
+                    "        global bb\n" +
+                    "        bb = self.value + arg\n"  //update scope variable
+                );
+                dynamic obj1 = _ps.Class1(20);
+                var result = obj1.call(10).As<int>();
+                Assert.AreEqual(130, result);
+
+                obj1.update(10);
+                result = ps.Get<int>("bb");
+                Assert.AreEqual(30, result);
+            }
+        }
+
+        /// <summary>
+        /// Import a python module into the session.
+        /// Equivalent to the Python "import" statement.
+        /// </summary>
+        [Test]
+        public void TestImportModule()
+        {
+            using (Py.GIL())
+            {
+                dynamic sys = ps.Import("sys");
+                Assert.IsTrue(ps.Contains("sys"));
+
+                ps.Exec("sys.attr1 = 2");
+                var value1 = ps.Eval<int>("sys.attr1");
+                var value2 = sys.attr1.As<int>();
+                Assert.AreEqual(2, value1);
+                Assert.AreEqual(2, value2);
+
+                //import as
+                ps.Import("sys", "sys1");
+                Assert.IsTrue(ps.Contains("sys1"));
+            }
+        }
+
+        /// <summary>
+        /// Create a scope and import variables from a scope, 
+        /// exec Python statements in the scope then discard it.
+        /// </summary>
+        [Test]
+        public void TestImportScope()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+
+                using (var scope = Py.CreateScope())
+                {
+                    scope.Import(ps, "ps");
+                    scope.Exec("aa = ps.bb + ps.cc + 3");
+                    var result = scope.Get<int>("aa");
+                    Assert.AreEqual(113, result);
+                }
+
+                Assert.IsFalse(ps.Contains("aa"));
+            }
+        }
+
+        /// <summary>
+        /// Create a scope and import variables from a scope, 
+        /// exec Python statements in the scope then discard it.
+        /// </summary>
+        [Test]
+        public void TestImportAllFromScope()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+
+                using (var scope = ps.NewScope())
+                {
+                    scope.Exec("aa = bb + cc + 3");
+                    var result = scope.Get<int>("aa");
+                    Assert.AreEqual(113, result);
+                }
+
+                Assert.IsFalse(ps.Contains("aa"));
+            }
+        }
+
+        /// <summary>
+        /// Create a scope and import variables from a scope, 
+        /// call the function imported.
+        /// </summary>
+        [Test]
+        public void TestImportScopeFunction()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+                ps.Exec(
+                    "def func1():\n" +
+                    "    return cc + bb\n");
+
+                using (PyScope scope = ps.NewScope())
+                {
+                    //'func1' is imported from the origion scope
+                    scope.Exec(
+                        "def func2():\n" +
+                        "    return func1() - cc - bb\n");
+                    dynamic func2 = scope.Get("func2");
+
+                    var result1 = func2().As<int>();
+                    Assert.AreEqual(0, result1);
+
+                    scope.Set("cc", 20);//it has no effect on the globals of 'func1'
+                    var result2 = func2().As<int>();
+                    Assert.AreEqual(-10, result2);
+                    scope.Set("cc", 10); //rollback
+
+                    ps.Set("cc", 20);
+                    var result3 = func2().As<int>();
+                    Assert.AreEqual(10, result3);
+                    ps.Set("cc", 10); //rollback
+                }
+            }
+        }
+
+        /// <summary>
+        /// Import a python module into the session with a new name.
+        /// Equivalent to the Python "import .. as .." statement.
+        /// </summary>
+        [Test]
+        public void TestImportScopeByName()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+
+                using (var scope = Py.CreateScope())
+                {
+                    scope.ImportAll("test");
+                    //scope.ImportModule("test");
+
+                    Assert.IsTrue(scope.Contains("bb"));
+                }                    
+            }
+        }
+
+        /// <summary>
+        /// Use the locals() and globals() method just like in python module
+        /// </summary>
+        [Test]
+        public void TestVariables()
+        {
+            (ps.Variables() as dynamic)["ee"] = new PyInt(200);
+            var a0 = ps.Get<int>("ee");
+            Assert.AreEqual(200, a0);
+
+            ps.Exec("locals()['ee'] = 210");
+            var a1 = ps.Get<int>("ee");
+            Assert.AreEqual(210, a1);
+
+            ps.Exec("globals()['ee'] = 220");
+            var a2 = ps.Get<int>("ee");
+            Assert.AreEqual(220, a2);
+
+            using (var item = ps.Variables())
+            {
+                item["ee"] = new PyInt(230);
+            }
+            var a3 = ps.Get<int>("ee");
+            Assert.AreEqual(230, a3);
+        }
+
+        /// <summary>
+        /// Share a pyscope by multiple threads.
+        /// </summary>
+        [Test]
+        public void TestThread()
+        {
+            //After the proposal here https://github.com/pythonnet/pythonnet/pull/419 complished,
+            //the BeginAllowThreads statement blow and the last EndAllowThreads statement
+            //should be removed.
+            dynamic _ps = ps;
+            var ts = PythonEngine.BeginAllowThreads();
+            using (Py.GIL())
+            {
+                _ps.res = 0;
+                _ps.bb = 100;
+                _ps.th_cnt = 0;
+                //add function to the scope 
+                //can be call many times, more efficient than ast 
+                ps.Exec(
+                    "def update():\n" +
+                    "    global res, th_cnt\n" +
+                    "    res += bb + 1\n" +
+                    "    th_cnt += 1\n"
+                );
+            }
+            int th_cnt = 3;
+            for (int i =0; i< th_cnt; i++)
+            {
+                System.Threading.Thread th = new System.Threading.Thread(()=>
+                {
+                    using (Py.GIL())
+                    {
+                        //ps.GetVariable<dynamic>("update")(); //call the scope function dynamicly
+                        _ps.update();
+                    }
+                });
+                th.Start();
+            }
+            //equivalent to Thread.Join, make the main thread join the GIL competition
+            int cnt = 0;
+            while(cnt != th_cnt)
+            {
+                using (Py.GIL())
+                {
+                    cnt = ps.Get<int>("th_cnt");
+                }
+                System.Threading.Thread.Sleep(10);
+            }
+            using (Py.GIL())
+            {
+                var result = ps.Get<int>("res");
+                Assert.AreEqual(101* th_cnt, result);
+            }
+            PythonEngine.EndAllowThreads(ts);
+        }
+    }
+}
diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
index 2fd66ad73..ee1a3c701 100644
--- a/src/runtime/Python.Runtime.csproj
+++ b/src/runtime/Python.Runtime.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -127,6 +127,7 @@
     <Compile Include="pylong.cs" />
     <Compile Include="pynumber.cs" />
     <Compile Include="pyobject.cs" />
+    <Compile Include="pyscope.cs" />
     <Compile Include="pysequence.cs" />
     <Compile Include="pystring.cs" />
     <Compile Include="pythonengine.cs" />
diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
index 80704c59e..b7df2a924 100644
--- a/src/runtime/pyobject.cs
+++ b/src/runtime/pyobject.cs
@@ -96,6 +96,27 @@ public object AsManagedObject(Type t)
             }
             return result;
         }
+        
+        /// <summary>
+        /// As Method
+        /// </summary>
+        /// <remarks>
+        /// Return a managed object of the given type, based on the
+        /// value of the Python object.
+        /// </remarks>
+        public T As<T>()
+        {
+            if (typeof(T) == typeof(PyObject) || typeof(T) == typeof(object))
+            {
+                return (T)(this as object);
+            }
+            object result;
+            if (!Converter.ToManaged(obj, typeof(T), out result, false))
+            {
+                throw new InvalidCastException("cannot convert object to target type");
+            }
+            return (T)result;
+        }
 
 
         /// <summary>
diff --git a/src/runtime/pyscope.cs b/src/runtime/pyscope.cs
new file mode 100644
index 000000000..1991772dc
--- /dev/null
+++ b/src/runtime/pyscope.cs
@@ -0,0 +1,655 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Dynamic;
+
+namespace Python.Runtime
+{
+    public class PyScopeException : Exception
+    {
+        public PyScopeException(string message)
+            : base(message)
+        {
+
+        }
+    }
+
+    /// <summary>
+    /// Classes/methods have this attribute must be used with GIL obtained.
+    /// </summary>
+    public class PyGILAttribute : Attribute
+    {
+    }
+
+    [PyGIL]
+    public class PyScope : DynamicObject, IDisposable
+    {
+        public readonly string Name;
+
+        /// <summary>
+        /// the python Module object the scope associated with.
+        /// </summary>
+        internal readonly IntPtr obj;
+
+        /// <summary>
+        /// the variable dict of the scope.
+        /// </summary>
+        internal readonly IntPtr variables;
+
+        private bool _isDisposed;
+
+        /// <summary>
+        /// The Manager this scope associated with.
+        /// It provides scopes this scope can import.
+        /// </summary>
+        internal readonly PyScopeManager Manager;
+
+        /// <summary>
+        /// event which will be triggered after the scope disposed.
+        /// </summary>
+        public event Action<PyScope> OnDispose;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <remarks>
+        /// Create a scope based on a Python Module.
+        /// </remarks>
+        internal PyScope(IntPtr ptr, PyScopeManager manager)
+        {
+            if (Runtime.PyObject_Type(ptr) != Runtime.PyModuleType)
+            {
+                throw new PyScopeException("object is not a module");
+            }
+            Manager = manager ?? PyScopeManager.Global;
+            obj = ptr;
+            //Refcount of the variables not increase
+            variables = Runtime.PyModule_GetDict(obj);
+            if (variables == IntPtr.Zero)
+            {
+                throw new PythonException();
+            }
+            Runtime.PyDict_SetItemString(
+                variables, "__builtins__",
+                Runtime.PyEval_GetBuiltins()
+            );
+            this.Name = this.Get<string>("__name__");
+        }
+
+        /// <summary>
+        /// return the variable dict of the scope.
+        /// </summary>
+        /// <returns></returns>
+        public PyDict Variables()
+        {
+            Runtime.XIncref(variables);
+            return new PyDict(variables);
+        }
+
+        /// <summary>
+        /// Create a scope, and import all from this scope
+        /// </summary>
+        /// <returns></returns>
+        public PyScope NewScope()
+        {
+            var scope = Manager.Create();
+            scope.ImportAll(this);
+            return scope;
+        }
+
+        /// <summary>
+        /// Import method
+        /// </summary>
+        /// <remarks>
+        /// Import a scope or a module of given name,
+        /// scope will be looked up first.
+        /// </remarks>
+        public dynamic Import(string name, string asname = null)
+        {
+            Check();
+            if (String.IsNullOrEmpty(asname))
+            {
+                asname = name;
+            }
+            PyScope scope;
+            Manager.TryGet(name, out scope);
+            if (scope != null)
+            {
+                Import(scope, asname);
+                return scope;
+            }
+            else
+            {
+                PyObject module = PythonEngine.ImportModule(name);
+                Import(module, asname);
+                return module;
+            }            
+        }
+
+        /// <summary>
+        /// Import method
+        /// </summary>
+        /// <remarks>
+        /// Import a scope as a variable of given name.
+        /// </remarks>
+        public void Import(PyScope scope, string asname)
+        {
+            this.Set(asname, scope.obj);
+        }
+
+        /// <summary>
+        /// Import Method
+        /// </summary>
+        /// <remarks>
+        /// The 'import .. as ..' statement in Python.
+        /// Import a module as a variable into the scope.
+        /// </remarks>
+        public void Import(PyObject module, string asname = null)
+        {
+            if (String.IsNullOrEmpty(asname))
+            {
+                asname = module.GetAttr("__name__").As<string>();
+            }
+            Set(asname, module);
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// The 'import * from ..' statement in Python.
+        /// Import all content of a scope/module of given name into the scope, scope will be looked up first.
+        /// </remarks>
+        public void ImportAll(string name)
+        {
+            PyScope scope;
+            Manager.TryGet(name, out scope);
+            if (scope != null)
+            {
+                ImportAll(scope);
+                return;
+            }
+            else
+            {
+                PyObject module = PythonEngine.ImportModule(name);
+                ImportAll(module);
+            }
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// Import all variables of the scope into this scope.
+        /// </remarks>
+        public void ImportAll(PyScope scope)
+        {
+            int result = Runtime.PyDict_Update(variables, scope.variables);
+            if (result < 0)
+            {
+                throw new PythonException();
+            }
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// Import all variables of the module into this scope.
+        /// </remarks>
+        public void ImportAll(PyObject module)
+        {
+            if (Runtime.PyObject_Type(module.obj) != Runtime.PyModuleType)
+            {
+                throw new PyScopeException("object is not a module");
+            }
+            var module_dict = Runtime.PyModule_GetDict(module.obj);
+            int result = Runtime.PyDict_Update(variables, module_dict);
+            if (result < 0)
+            {
+                throw new PythonException();
+            }
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// Import all variables in the dictionary into this scope.
+        /// </remarks>
+        public void ImportAll(PyDict dict)
+        {
+            int result = Runtime.PyDict_Update(variables, dict.obj);
+            if (result < 0)
+            {
+                throw new PythonException();
+            }
+        }
+
+        /// <summary>
+        /// Execute method
+        /// </summary>
+        /// <remarks>
+        /// Execute a Python ast and return the result as a PyObject.
+        /// The ast can be either an expression or stmts.
+        /// </remarks>
+        public PyObject Execute(PyObject script, PyDict locals = null)
+        {
+            Check();
+            IntPtr _locals = locals == null ? variables : locals.obj;
+            IntPtr ptr = Runtime.PyEval_EvalCode(script.Handle, variables, _locals);
+            Runtime.CheckExceptionOccurred();
+            if (ptr == Runtime.PyNone)
+            {
+                Runtime.XDecref(ptr);
+                return null;
+            }
+            return new PyObject(ptr);
+        }
+
+        /// <summary>
+        /// Execute method
+        /// </summary>
+        /// <remarks>
+        /// Execute a Python ast and return the result as a PyObject,
+        /// and convert the result to a Managed Object of given type.
+        /// The ast can be either an expression or stmts.
+        /// </remarks>
+        public T Execute<T>(PyObject script, PyDict locals = null)
+        {
+            Check();
+            PyObject pyObj = Execute(script, locals);
+            if (pyObj == null)
+            {
+                return default(T);
+            }
+            var obj = pyObj.As<T>();
+            return obj;
+        }
+
+        /// <summary>
+        /// Eval method
+        /// </summary>
+        /// <remarks>
+        /// Evaluate a Python expression and return the result as a PyObject
+        /// or null if an exception is raised.
+        /// </remarks>
+        public PyObject Eval(string code, PyDict locals = null)
+        {
+            Check();
+            IntPtr _locals = locals == null ? variables : locals.obj;
+            var flag = (IntPtr)Runtime.Py_eval_input;
+            IntPtr ptr = Runtime.PyRun_String(
+                code, flag, variables, _locals
+            );
+            Runtime.CheckExceptionOccurred();
+            return new PyObject(ptr);
+        }
+
+        /// <summary>
+        /// Evaluate a Python expression
+        /// </summary>
+        /// <remarks>
+        /// Evaluate a Python expression 
+        /// and  convert the result to a Managed Object of given type.
+        /// </remarks>
+        public T Eval<T>(string code, PyDict locals = null)
+        {
+            Check();
+            PyObject pyObj = Eval(code, locals);
+            var obj = pyObj.As<T>();
+            return obj;
+        }
+
+        /// <summary>
+        /// Exec Method
+        /// </summary>
+        /// <remarks>
+        /// Exec a Python script and save its local variables in the current local variable dict.
+        /// </remarks>
+        public void Exec(string code, PyDict locals = null)
+        {
+            Check();
+            IntPtr _locals = locals == null ? variables : locals.obj;
+            Exec(code, variables, _locals);
+        }
+
+        private void Exec(string code, IntPtr _globals, IntPtr _locals)
+        {
+            var flag = (IntPtr)Runtime.Py_file_input;
+            IntPtr ptr = Runtime.PyRun_String(
+                code, flag, _globals, _locals
+            );
+            Runtime.CheckExceptionOccurred();
+            if (ptr != Runtime.PyNone)
+            {
+                throw new PythonException();
+            }
+            Runtime.XDecref(ptr);
+        }
+
+        /// <summary>
+        /// Set Variable Method
+        /// </summary>
+        /// <remarks>
+        /// Add a new variable to the variables dict if it not exist
+        /// or update its value if the variable exists.
+        /// </remarks>
+        public void Set(string name, object value)
+        {
+            IntPtr _value = Converter.ToPython(value, value?.GetType());
+            Set(name, _value);
+            Runtime.XDecref(_value);
+        }
+
+        private void Set(string name, IntPtr value)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                int r = Runtime.PyObject_SetItem(variables, pyKey.obj, value);
+                if (r < 0)
+                {
+                    throw new PythonException();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove Method
+        /// </summary>
+        /// <remarks>
+        /// Remove a variable from the variables dict.
+        /// </remarks>
+        public void Remove(string name)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                int r = Runtime.PyObject_DelItem(variables, pyKey.obj);
+                if (r < 0)
+                {
+                    throw new PythonException();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Contains Method
+        /// </summary>
+        /// <remarks>
+        /// Returns true if the variable exists in the scope.
+        /// </remarks>
+        public bool Contains(string name)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                return Runtime.PyMapping_HasKey(variables, pyKey.obj) != 0;
+            }
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Returns the value of the variable of given name.
+        /// If the variable does not exist, throw an Exception.
+        /// </remarks>
+        public PyObject Get(string name)
+        {
+            PyObject scope;
+            var state = TryGet(name, out scope);
+            if(!state)
+            {
+                throw new PyScopeException($"The scope of name '{Name}' has no attribute '{name}'");
+            }
+            return scope;
+        }
+
+        /// <summary>
+        /// TryGet Method
+        /// </summary>
+        /// <remarks>
+        /// Returns the value of the variable, local variable first.
+        /// If the variable does not exist, return null.
+        /// </remarks>
+        public bool TryGet(string name, out PyObject value)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                if (Runtime.PyMapping_HasKey(variables, pyKey.obj) != 0)
+                {
+                    IntPtr op = Runtime.PyObject_GetItem(variables, pyKey.obj);
+                    if (op == IntPtr.Zero)
+                    {
+                        throw new PythonException();
+                    }
+                    if (op == Runtime.PyNone)
+                    {
+                        Runtime.XDecref(op);
+                        value = null;
+                        return true;
+                    }
+                    value = new PyObject(op);
+                    return true;
+                }
+                else
+                {
+                    value = null;
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Obtain the value of the variable of given name, 
+        /// and convert the result to a Managed Object of given type.
+        /// If the variable does not exist, throw an Exception.
+        /// </remarks>
+        public T Get<T>(string name)
+        {
+            Check();
+            PyObject pyObj = Get(name);
+            if (pyObj == null)
+            {
+                return default(T);
+            }
+            return pyObj.As<T>();
+        }
+
+        /// <summary>
+        /// TryGet Method
+        /// </summary>
+        /// <remarks>
+        /// Obtain the value of the variable of given name, 
+        /// and convert the result to a Managed Object of given type.
+        /// If the variable does not exist, return false.
+        /// </remarks>
+        public bool TryGet<T>(string name, out T value)
+        {
+            Check();
+            PyObject pyObj;
+            var result = TryGet(name, out pyObj);
+            if (!result)
+            {
+                value = default(T);
+                return false;
+            }            
+            if (pyObj == null)
+            {
+                if(typeof(T).IsValueType)
+                {
+                    throw new PyScopeException($"The value of the attribute '{name}' is None which cannot be convert to '{typeof(T).ToString()}'");
+                }
+                else
+                {
+                    value = default(T);
+                    return true;
+                }                
+            }
+            value = pyObj.As<T>();
+            return true;
+        }
+
+        public override bool TryGetMember(GetMemberBinder binder, out object result)
+        {
+            result = this.Get(binder.Name);
+            return true;
+        }
+
+        public override bool TrySetMember(SetMemberBinder binder, object value)
+        {
+            this.Set(binder.Name, value);
+            return true;
+        }
+
+        private void Check()
+        {
+            if (_isDisposed)
+            {
+                throw new PyScopeException($"The scope of name '{Name}' object has been disposed");
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_isDisposed)
+            {
+                return;
+            }
+            _isDisposed = true;
+            Runtime.XDecref(obj);
+            this.OnDispose?.Invoke(this);
+        }
+
+        ~PyScope()
+        {
+            Dispose();
+        }
+    }
+
+    public class PyScopeManager
+    {
+        public readonly static PyScopeManager Global = new PyScopeManager();
+
+        private Dictionary<string, PyScope> NamedScopes = new Dictionary<string, PyScope>();
+
+        internal PyScope NewScope(string name)
+        {
+            if (name == null)
+            {
+                name = "";
+            }
+            var module = Runtime.PyModule_New(name);
+            if (module == IntPtr.Zero)
+            {
+                throw new PythonException();
+            }
+            return new PyScope(module, this);
+        }
+
+        /// <summary>
+        /// Create Method
+        /// </summary>
+        /// <remarks>
+        /// Create an anonymous scope.
+        /// </remarks>
+        [PyGIL]
+        public PyScope Create()
+        {
+            var scope = this.NewScope(null);
+            return scope;
+        }
+
+        /// <summary>
+        /// Create Method
+        /// </summary>
+        /// <remarks>
+        /// Create an named scope of given name.
+        /// </remarks>
+        [PyGIL]
+        public PyScope Create(string name)
+        {
+            if (String.IsNullOrEmpty(name))
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+            if (name != null && Contains(name))
+            {
+                throw new PyScopeException($"A scope of name '{name}' does already exist");
+            }
+            var scope = this.NewScope(name);
+            scope.OnDispose += Remove;
+            NamedScopes[name] = scope;
+            return scope;
+        }
+
+        /// <summary>
+        /// Contains Method
+        /// </summary>
+        /// <remarks>
+        /// return true if the scope exists in this manager.
+        /// </remarks>
+        public bool Contains(string name)
+        {
+            return NamedScopes.ContainsKey(name);
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Find the scope in this manager.
+        /// If the scope not exist, an Exception will be thrown.
+        /// </remarks>
+        public PyScope Get(string name)
+        {
+            if (String.IsNullOrEmpty(name))
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+            if (NamedScopes.ContainsKey(name))
+            {
+                return NamedScopes[name];
+            }
+            throw new PyScopeException($"There is no scope named '{name}' registered in this manager");
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Try to find the scope in this manager.
+        /// </remarks>
+        public bool TryGet(string name, out PyScope scope)
+        {
+            return NamedScopes.TryGetValue(name, out scope);
+        }
+
+        /// <summary>
+        /// Remove Method
+        /// </summary>
+        /// <remarks>
+        /// remove the scope from this manager.
+        /// </remarks>
+        public void Remove(PyScope scope)
+        {
+            NamedScopes.Remove(scope.Name);
+        }
+
+        [PyGIL]
+        public void Clear()
+        {
+            var scopes = NamedScopes.Values.ToList();
+            foreach (var scope in scopes)
+            {
+                scope.Dispose();
+            }
+        }
+    }
+}
diff --git a/src/runtime/pythonengine.cs b/src/runtime/pythonengine.cs
index 9ddd85da6..556da698f 100644
--- a/src/runtime/pythonengine.cs
+++ b/src/runtime/pythonengine.cs
@@ -294,6 +294,7 @@ public static void Shutdown()
         {
             if (initialized)
             {
+                PyScopeManager.Global.Clear();
                 Marshal.FreeHGlobal(_pythonHome);
                 _pythonHome = IntPtr.Zero;
                 Marshal.FreeHGlobal(_programName);
@@ -421,6 +422,13 @@ public static PyObject ModuleFromString(string name, string code)
             return new PyObject(m);
         }
 
+        public static PyObject Compile(string code, string filename = "", RunFlagType mode = RunFlagType.File)
+        {
+            var flag = (IntPtr)mode;
+            IntPtr ptr = Runtime.Py_CompileString(code, filename, flag);
+            Runtime.CheckExceptionOccurred();
+            return new PyObject(ptr);
+        }
 
         /// <summary>
         /// Eval Method
@@ -539,6 +547,18 @@ public static GILState GIL()
             return new GILState();
         }
 
+        public static PyScope CreateScope()
+        {
+            var scope = PyScopeManager.Global.Create();
+            return scope;
+        }
+
+        public static PyScope CreateScope(string name)
+        {
+            var scope = PyScopeManager.Global.Create(name);
+            return scope;
+        }
+        
         public class GILState : IDisposable
         {
             private IntPtr state;
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 9ee693cf3..a24b6f6d4 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -707,6 +707,9 @@ public static extern int Py_Main(
         [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyRun_String(string code, IntPtr st, IntPtr globals, IntPtr locals);
 
+        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr PyEval_EvalCode(IntPtr co, IntPtr globals, IntPtr locals);
+
         [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_CompileString(string code, string file, IntPtr tok);
 

From d870d4ecfa0a7f8786b88b13c27600ffb3193940 Mon Sep 17 00:00:00 2001
From: testrunner123 <testrunner@gmx.de>
Date: Wed, 14 Jun 2017 13:50:56 +0200
Subject: [PATCH 05/19] Fix missing Incref for Namespace and Assembly (#482)

Fix crash of python interpreter 3.5 64-bit in garbage collector
---
 AUTHORS.md                 |  2 ++
 CHANGELOG.md               | 11 +++++------
 src/runtime/typemanager.cs |  2 ++
 src/tests/test_subclass.py |  3 ---
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/AUTHORS.md b/AUTHORS.md
index d715eed6f..9f4060c25 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -43,3 +43,5 @@
 -   ([@rico-chet](https://github.com/rico-chet))
 -   ([@rmadsen-ks](https://github.com/rmadsen-ks))
 -   ([@stonebig](https://github.com/stonebig))
+-   ([@testrunner123](https://github.com/testrunner123))
+
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8b54b36d..728c8c69b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,19 +8,18 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ## [unreleased][]
 
 ### Added
--   Added clr.GetClrType (#432)(#433)
--   Allowed passing None for nullable args (#460)
+-   Added `clr.GetClrType` (#432, #433)
+-   Allowed passing `None` for nullable args (#460)
 -   Added keyword arguments based on C# syntax for calling CPython methods (#461)
 
-
 ### Changed
 
--   Changed `Bar` feature
-
 ### Fixed
 
 -   Fixed Visual Studio 2017 compat (#434) for setup.py
--   Fixed `FooBar` bug
+-   Fixed crash on exit of the Python interpreter if a python class
+    derived from a .NET class has a `__namespace__` or `__assembly__`
+    attribute (#481)
 
 ## [2.3.0][] - 2017-03-11
 
diff --git a/src/runtime/typemanager.cs b/src/runtime/typemanager.cs
index 6f373f036..ad0fddcc1 100644
--- a/src/runtime/typemanager.cs
+++ b/src/runtime/typemanager.cs
@@ -206,6 +206,7 @@ internal static IntPtr CreateSubType(IntPtr py_name, IntPtr py_base_type, IntPtr
                 if (0 != Runtime.PyMapping_HasKey(py_dict, assemblyKey.Handle))
                 {
                     var pyAssembly = new PyObject(Runtime.PyDict_GetItem(py_dict, assemblyKey.Handle));
+                    Runtime.XIncref(pyAssembly.Handle);
                     disposeList.Add(pyAssembly);
                     if (!Converter.ToManagedValue(pyAssembly.Handle, typeof(string), out assembly, false))
                     {
@@ -218,6 +219,7 @@ internal static IntPtr CreateSubType(IntPtr py_name, IntPtr py_base_type, IntPtr
                 if (0 != Runtime.PyMapping_HasKey(py_dict, namespaceKey.Handle))
                 {
                     var pyNamespace = new PyObject(Runtime.PyDict_GetItem(py_dict, namespaceKey.Handle));
+                    Runtime.XIncref(pyNamespace.Handle);
                     disposeList.Add(pyNamespace);
                     if (!Converter.ToManagedValue(pyNamespace.Handle, typeof(string), out namespaceStr, false))
                     {
diff --git a/src/tests/test_subclass.py b/src/tests/test_subclass.py
index 8e862a56d..739c24c07 100644
--- a/src/tests/test_subclass.py
+++ b/src/tests/test_subclass.py
@@ -85,7 +85,6 @@ def OnTestEvent(self, value):
     return DerivedEventTest
 
 
-@pytest.mark.skip(reason="FIXME: test randomly pass/fails")
 def test_base_class():
     """Test base class managed type"""
     ob = SubClassTest()
@@ -98,7 +97,6 @@ def test_base_class():
     assert list(SubClassTest.test_list(ob)) == ["a", "b", "c"]
 
 
-@pytest.mark.skip(reason="FIXME: test randomly pass/fails")
 def test_interface():
     """Test python classes can derive from C# interfaces"""
     InterfaceTestClass = interface_test_class_fixture()
@@ -112,7 +110,6 @@ def test_interface():
     assert id(x) == id(ob)
 
 
-@pytest.mark.skip(reason="FIXME: test randomly pass/fails")
 def test_derived_class():
     """Test python class derived from managed type"""
     DerivedClass = derived_class_fixture()

From de3179c61c3a5447433ed0870ed9e3f53b752f05 Mon Sep 17 00:00:00 2001
From: Konstantin <konstantin.posudevskiy@gmail.com>
Date: Wed, 14 Jun 2017 17:18:46 +0300
Subject: [PATCH 06/19] Fix conversion of 'float' and 'double' values (#487)

* Fix conversion of 'float' and 'double' values

Fix problem of conversion 'float' and 'double' values in converter.cs.
As there was a range check both for 'float' and 'double' values, which
are less or greater than its 'MinValue' and 'MaxValue' accordingly,
several values like 'float.NegativeInfinity', 'float.PositiveInfinity'
and the same 'double' values cannot be converted from Python to .NET
values.

Add error check after 'PyFloat_AsDouble' call.
Due to Python C API documentation, method 'PyFloat_AsDouble' can return
'-1.0' upon failure. So it requires error check. This rule forces to
check for error and throw exception in case of error.

Add tests, which cover problem of conversion 'float' and 'double'
values.

Resolves: #486.

* Fix failing 'test_double_conversion' test

Fix incorrect part of 'test_double_conversion' test in test_conversion.py.
An 'OverflowError' was expected for valid values, which represent Python
'inf' and '-inf'.
The problem was identified with support of conversion for Python 'inf'
and '-inf' to .NET System.Double PositiveInfinity and NegativeInfinity.

See also: #487.
---
 AUTHORS.md                                  |  1 +
 CHANGELOG.md                                |  2 +
 src/embed_tests/Python.EmbeddingTest.csproj |  1 +
 src/embed_tests/TestConverter.cs            | 48 +++++++++++++++++++++
 src/runtime/converter.cs                    | 11 ++---
 src/tests/test_conversion.py                | 11 -----
 6 files changed, 58 insertions(+), 16 deletions(-)
 create mode 100644 src/embed_tests/TestConverter.cs

diff --git a/AUTHORS.md b/AUTHORS.md
index 9f4060c25..434c57801 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -27,6 +27,7 @@
 -   Joe Frayne ([@jfrayne](https://github.com/jfrayne))
 -   John Burnett ([@johnburnett](https://github.com/johnburnett))
 -   Luke Stratman ([@lstratman](https://github.com/lstratman))
+-   Konstantin Posudevskiy ([@konstantin-posudevskiy](https://github.com/konstantin-posudevskiy))
 -   Matthias Dittrich ([@matthid](https://github.com/matthid))
 -   Patrick Stewart ([@patstew](https://github.com/patstew))
 -   Raphael Nestler ([@rnestler](https://github.com/rnestler))
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 728c8c69b..f3bcdfe16 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   Fixed crash on exit of the Python interpreter if a python class
     derived from a .NET class has a `__namespace__` or `__assembly__`
     attribute (#481)
+-   Fixed conversion of 'float' and 'double' values (#486)
+
 
 ## [2.3.0][] - 2017-03-11
 
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
index fc887d815..d45c622f9 100644
--- a/src/embed_tests/Python.EmbeddingTest.csproj
+++ b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -84,6 +84,7 @@
     <Compile Include="pyimport.cs" />
     <Compile Include="pyinitialize.cs" />
     <Compile Include="pyrunstring.cs" />
+    <Compile Include="TestConverter.cs" />
     <Compile Include="TestCustomMarshal.cs" />
     <Compile Include="TestExample.cs" />
     <Compile Include="TestPyAnsiString.cs" />
diff --git a/src/embed_tests/TestConverter.cs b/src/embed_tests/TestConverter.cs
new file mode 100644
index 000000000..346c8afdc
--- /dev/null
+++ b/src/embed_tests/TestConverter.cs
@@ -0,0 +1,48 @@
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    public class TestConverter
+    {
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        [Test]
+        public void TestConvertSingleToManaged(
+            [Values(float.PositiveInfinity, float.NegativeInfinity, float.MinValue, float.MaxValue, float.NaN,
+                float.Epsilon)] float testValue)
+        {
+            var pyFloat = new PyFloat(testValue);
+
+            object convertedValue;
+            var converted = Converter.ToManaged(pyFloat.Handle, typeof(float), out convertedValue, false);
+
+            Assert.IsTrue(converted);
+            Assert.IsTrue(((float) convertedValue).Equals(testValue));
+        }
+
+        [Test]
+        public void TestConvertDoubleToManaged(
+            [Values(double.PositiveInfinity, double.NegativeInfinity, double.MinValue, double.MaxValue, double.NaN,
+                double.Epsilon)] double testValue)
+        {
+            var pyFloat = new PyFloat(testValue);
+
+            object convertedValue;
+            var converted = Converter.ToManaged(pyFloat.Handle, typeof(double), out convertedValue, false);
+
+            Assert.IsTrue(converted);
+            Assert.IsTrue(((double) convertedValue).Equals(testValue));
+        }
+    }
+}
diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs
index 0bf882cc5..5179c849b 100644
--- a/src/runtime/converter.cs
+++ b/src/runtime/converter.cs
@@ -770,10 +770,14 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object result, bo
                         goto type_error;
                     }
                     double dd = Runtime.PyFloat_AsDouble(op);
+                    Runtime.CheckExceptionOccurred();
                     Runtime.XDecref(op);
                     if (dd > Single.MaxValue || dd < Single.MinValue)
                     {
-                        goto overflow;
+                        if (!double.IsInfinity(dd))
+                        {
+                            goto overflow;
+                        }
                     }
                     result = (float)dd;
                     return true;
@@ -785,11 +789,8 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object result, bo
                         goto type_error;
                     }
                     double d = Runtime.PyFloat_AsDouble(op);
+                    Runtime.CheckExceptionOccurred();
                     Runtime.XDecref(op);
-                    if (d > Double.MaxValue || d < Double.MinValue)
-                    {
-                        goto overflow;
-                    }
                     result = d;
                     return true;
             }
diff --git a/src/tests/test_conversion.py b/src/tests/test_conversion.py
index 9152e30d0..53e5d8051 100644
--- a/src/tests/test_conversion.py
+++ b/src/tests/test_conversion.py
@@ -466,17 +466,6 @@ def test_double_conversion():
     with pytest.raises(TypeError):
         ConversionTest().DoubleField = None
 
-    with pytest.raises(OverflowError):
-        ConversionTest().DoubleField = 1.7976931348623159e308
-
-    with pytest.raises(OverflowError):
-        ConversionTest().DoubleField = -1.7976931348623159e308
-
-    with pytest.raises(OverflowError):
-        _ = System.Double(1.7976931348623159e308)
-
-    with pytest.raises(OverflowError):
-        _ = System.Double(-1.7976931348623159e308)
 
 
 def test_decimal_conversion():

From cf46eec9b0948eedc763470daaecec85a0e41218 Mon Sep 17 00:00:00 2001
From: Rickard Holmberg <rickard.holmberg@raysearchlabs.com>
Date: Fri, 16 Jun 2017 15:19:39 +0200
Subject: [PATCH 07/19] clrmethod working for python 2 (#494)

* Add Runtime.PyObject_IsIterable and fix PyIter_Check for Python 2

* Add test_clrmethod.py and update AUTHORS and CHANGELOG

* Fix test docstrings

* Use IntPtr.Zero instead of null for comparisons with IntPtrs

* Add test on Runtime.PyObject_IsIterable and Runtime.PyIter_Check

* Use the already defined TypeFlags.HaveIter instead of redefining it

* Add PyIter_Check and PyObject_IsIterable tests on threading.Lock, which does not have type feature iter

* Move the tests from test_runtime.py to TestRuntime.py
---
 AUTHORS.md                     |  1 +
 CHANGELOG.md                   |  1 +
 src/embed_tests/TestRuntime.cs | 43 +++++++++++++++++++-
 src/runtime/pyobject.cs        |  2 +-
 src/runtime/runtime.cs         | 39 ++++++++++++------
 src/tests/test_clrmethod.py    | 73 ++++++++++++++++++++++++++++++++++
 6 files changed, 144 insertions(+), 15 deletions(-)
 create mode 100644 src/tests/test_clrmethod.py

diff --git a/AUTHORS.md b/AUTHORS.md
index 434c57801..78bb25f9e 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -31,6 +31,7 @@
 -   Matthias Dittrich ([@matthid](https://github.com/matthid))
 -   Patrick Stewart ([@patstew](https://github.com/patstew))
 -   Raphael Nestler ([@rnestler](https://github.com/rnestler))
+-   Rickard Holmberg ([@rickardraysearch](https://github.com/rickardraysearch))
 -   Sam Winstanley ([@swinstanley](https://github.com/swinstanley))
 -   Sean Freitag ([@cowboygneox](https://github.com/cowboygneox))
 -   Serge Weinstock ([@sweinst](https://github.com/sweinst))
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f3bcdfe16..38fa56a62 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
     derived from a .NET class has a `__namespace__` or `__assembly__`
     attribute (#481)
 -   Fixed conversion of 'float' and 'double' values (#486)
+-   Fixed 'clrmethod' for python 2 (#492)
 
 
 ## [2.3.0][] - 2017-03-11
diff --git a/src/embed_tests/TestRuntime.cs b/src/embed_tests/TestRuntime.cs
index 22e6db0a9..2e0598da7 100644
--- a/src/embed_tests/TestRuntime.cs
+++ b/src/embed_tests/TestRuntime.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using NUnit.Framework;
 using Python.Runtime;
 
@@ -47,5 +47,46 @@ public static void RefCountTest()
 
             Runtime.Runtime.Py_Finalize();
         }
+
+        [Test]
+        public static void PyCheck_Iter_PyObject_IsIterable_Test()
+        {
+            Runtime.Runtime.Py_Initialize();
+
+            // Tests that a python list is an iterable, but not an iterator
+            var pyList = Runtime.Runtime.PyList_New(0);
+            Assert.IsFalse(Runtime.Runtime.PyIter_Check(pyList));
+            Assert.IsTrue(Runtime.Runtime.PyObject_IsIterable(pyList));
+
+            // Tests that a python list iterator is both an iterable and an iterator
+            var pyListIter = Runtime.Runtime.PyObject_GetIter(pyList);
+            Assert.IsTrue(Runtime.Runtime.PyObject_IsIterable(pyListIter));
+            Assert.IsTrue(Runtime.Runtime.PyIter_Check(pyListIter));
+
+            // Tests that a python float is neither an iterable nor an iterator
+            var pyFloat = Runtime.Runtime.PyFloat_FromDouble(2.73);
+            Assert.IsFalse(Runtime.Runtime.PyObject_IsIterable(pyFloat));
+            Assert.IsFalse(Runtime.Runtime.PyIter_Check(pyFloat));
+
+            Runtime.Runtime.Py_Finalize();
+        }
+
+        [Test]
+        public static void PyCheck_Iter_PyObject_IsIterable_ThreadingLock_Test()
+        {
+            Runtime.Runtime.Py_Initialize();
+
+            // Create an instance of threading.Lock, which is one of the very few types that does not have the
+            // TypeFlags.HaveIter set in Python 2. This tests a different code path in PyObject_IsIterable and PyIter_Check.
+            var threading = Runtime.Runtime.PyImport_ImportModule("threading");
+            var threadingDict = Runtime.Runtime.PyModule_GetDict(threading);
+            var lockType = Runtime.Runtime.PyDict_GetItemString(threadingDict, "Lock");
+            var lockInstance = Runtime.Runtime.PyObject_CallObject(lockType, Runtime.Runtime.PyTuple_New(0));
+
+            Assert.IsFalse(Runtime.Runtime.PyObject_IsIterable(lockInstance));
+            Assert.IsFalse(Runtime.Runtime.PyIter_Check(lockInstance));
+
+            Runtime.Runtime.Py_Finalize();
+        }
     }
 }
diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
index b7df2a924..1b41b0893 100644
--- a/src/runtime/pyobject.cs
+++ b/src/runtime/pyobject.cs
@@ -802,7 +802,7 @@ public bool IsCallable()
         /// </remarks>
         public bool IsIterable()
         {
-            return Runtime.PyIter_Check(obj);
+            return Runtime.PyObject_IsIterable(obj);
         }
 
 
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index a24b6f6d4..73caeb854 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 using System.Security;
 using System.Text;
@@ -274,11 +274,10 @@ internal static void Initialize()
 
             Error = new IntPtr(-1);
 
-#if PYTHON3
             IntPtr dllLocal = IntPtr.Zero;
             if (PythonDll != "__Internal")
             {
-                NativeMethods.LoadLibrary(PythonDll);
+                dllLocal = NativeMethods.LoadLibrary(PythonDll);
             }
             _PyObject_NextNotImplemented = NativeMethods.GetProcAddress(dllLocal, "_PyObject_NextNotImplemented");
 #if !(MONO_LINUX || MONO_OSX)
@@ -286,7 +285,6 @@ internal static void Initialize()
             {
                 NativeMethods.FreeLibrary(dllLocal);
             }
-#endif
 #endif
 
             // Initialize modules that depend on the runtime class.
@@ -349,8 +347,8 @@ internal static int AtExit()
 
 #if PYTHON3
         internal static IntPtr PyBytesType;
-        internal static IntPtr _PyObject_NextNotImplemented;
 #endif
+        internal static IntPtr _PyObject_NextNotImplemented;
 
         internal static IntPtr PyNotImplemented;
         internal const int Py_LT = 0;
@@ -780,6 +778,21 @@ internal static string PyObject_GetTypeName(IntPtr op)
             return Marshal.PtrToStringAnsi(ppName);
         }
 
+        /// <summary>
+        /// Test whether the Python object is an iterable.
+        /// </summary>
+        internal static bool PyObject_IsIterable(IntPtr pointer)
+        {
+            var ob_type = Marshal.ReadIntPtr(pointer, ObjectOffset.ob_type);
+#if PYTHON2
+            long tp_flags = Marshal.ReadInt64(ob_type, TypeOffset.tp_flags);
+            if ((tp_flags & TypeFlags.HaveIter) == 0)
+                return false;
+#endif
+            IntPtr tp_iter = Marshal.ReadIntPtr(ob_type, TypeOffset.tp_iter);
+            return tp_iter != IntPtr.Zero;
+        }
+
         [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_HasAttrString(IntPtr pointer, string name);
 
@@ -1425,17 +1438,17 @@ internal static bool PyTuple_Check(IntPtr ob)
         // Python iterator API
         //====================================================================
 
-#if PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern bool PyIter_Check(IntPtr pointer);
-#elif PYTHON3
         internal static bool PyIter_Check(IntPtr pointer)
         {
-            var ob_type = (IntPtr)Marshal.PtrToStructure(pointer + ObjectOffset.ob_type, typeof(IntPtr));
-            IntPtr tp_iternext = ob_type + TypeOffset.tp_iternext;
-            return tp_iternext != null && tp_iternext != _PyObject_NextNotImplemented;
-        }
+            var ob_type = Marshal.ReadIntPtr(pointer, ObjectOffset.ob_type);
+#if PYTHON2
+            long tp_flags = Marshal.ReadInt64(ob_type, TypeOffset.tp_flags);
+            if ((tp_flags & TypeFlags.HaveIter) == 0)
+                return false;
 #endif
+            IntPtr tp_iternext = Marshal.ReadIntPtr(ob_type, TypeOffset.tp_iternext);
+            return tp_iternext != IntPtr.Zero && tp_iternext != _PyObject_NextNotImplemented;
+        }
 
         [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyIter_Next(IntPtr pointer);
diff --git a/src/tests/test_clrmethod.py b/src/tests/test_clrmethod.py
new file mode 100644
index 000000000..a6078bece
--- /dev/null
+++ b/src/tests/test_clrmethod.py
@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+"""Test clrmethod and clrproperty support for calling methods and getting/setting python properties from CLR."""
+
+import Python.Test as Test
+import System
+import pytest
+import clr
+
+class ExampleClrClass(System.Object):
+    __namespace__ = "PyTest"
+    def __init__(self):
+        self._x = 3
+    @clr.clrmethod(int, [int])
+    def test(self, x):
+        return x*2
+    
+    def get_X(self):
+        return self._x
+    def set_X(self, value):
+        self._x = value
+    X = clr.clrproperty(int, get_X, set_X)
+
+    @clr.clrproperty(int)
+    def Y(self):
+        return self._x * 2
+
+def test_set_and_get_property_from_py():
+    """Test setting and getting clr-accessible properties from python."""
+    t = ExampleClrClass()
+    assert t.X == 3
+    assert t.Y == 3 * 2
+    t.X = 4
+    assert t.X == 4
+    assert t.Y == 4 * 2
+
+def test_set_and_get_property_from_clr():
+    """Test setting and getting clr-accessible properties from the clr."""
+    t = ExampleClrClass()
+    assert t.GetType().GetProperty("X").GetValue(t) == 3
+    assert t.GetType().GetProperty("Y").GetValue(t) == 3 * 2
+    t.GetType().GetProperty("X").SetValue(t, 4)
+    assert t.GetType().GetProperty("X").GetValue(t) == 4
+    assert t.GetType().GetProperty("Y").GetValue(t) == 4 * 2
+
+
+def test_set_and_get_property_from_clr_and_py():
+    """Test setting and getting clr-accessible properties alternatingly from the clr and from python."""
+    t = ExampleClrClass()
+    assert t.GetType().GetProperty("X").GetValue(t) == 3
+    assert t.GetType().GetProperty("Y").GetValue(t) == 3 * 2
+    assert t.X == 3
+    assert t.Y == 3 * 2
+    t.GetType().GetProperty("X").SetValue(t, 4)
+    assert t.GetType().GetProperty("X").GetValue(t) == 4
+    assert t.GetType().GetProperty("Y").GetValue(t) == 4 * 2
+    assert t.X == 4
+    assert t.Y == 4 * 2
+    t.X = 5
+    assert t.GetType().GetProperty("X").GetValue(t) == 5
+    assert t.GetType().GetProperty("Y").GetValue(t) == 5 * 2
+    assert t.X == 5
+    assert t.Y == 5 * 2
+
+def test_method_invocation_from_py():
+    """Test calling a clr-accessible method from python."""
+    t = ExampleClrClass()
+    assert t.test(41) == 41*2
+
+def test_method_invocation_from_clr():
+    """Test calling a clr-accessible method from the clr."""
+    t = ExampleClrClass()
+    assert t.GetType().GetMethod("test").Invoke(t, [37]) == 37*2

From 9fe18362db981c095d07f18c5cc20d754ac464ea Mon Sep 17 00:00:00 2001
From: Benedikt Reinartz <filmor@gmail.com>
Date: Tue, 20 Jun 2017 08:36:22 +0200
Subject: [PATCH 08/19] Fix check so that we don't leak a reference. (#500)

`PyObject_TYPE` does not `Incref` the type object returned, in contrast
to `PyObject_Type`, which was used here before.
---
 src/runtime/pyscope.cs | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/runtime/pyscope.cs b/src/runtime/pyscope.cs
index 1991772dc..25282ac26 100644
--- a/src/runtime/pyscope.cs
+++ b/src/runtime/pyscope.cs
@@ -57,7 +57,7 @@ public class PyScope : DynamicObject, IDisposable
         /// </remarks>
         internal PyScope(IntPtr ptr, PyScopeManager manager)
         {
-            if (Runtime.PyObject_Type(ptr) != Runtime.PyModuleType)
+            if (!Runtime.PyType_IsSubtype(Runtime.PyObject_TYPE(ptr), Runtime.PyModuleType))
             {
                 throw new PyScopeException("object is not a module");
             }
@@ -65,10 +65,8 @@ internal PyScope(IntPtr ptr, PyScopeManager manager)
             obj = ptr;
             //Refcount of the variables not increase
             variables = Runtime.PyModule_GetDict(obj);
-            if (variables == IntPtr.Zero)
-            {
-                throw new PythonException();
-            }
+            Runtime.CheckExceptionOccurred();
+
             Runtime.PyDict_SetItemString(
                 variables, "__builtins__",
                 Runtime.PyEval_GetBuiltins()
@@ -123,7 +121,7 @@ public dynamic Import(string name, string asname = null)
                 PyObject module = PythonEngine.ImportModule(name);
                 Import(module, asname);
                 return module;
-            }            
+            }
         }
 
         /// <summary>
@@ -290,7 +288,7 @@ public PyObject Eval(string code, PyDict locals = null)
         /// Evaluate a Python expression
         /// </summary>
         /// <remarks>
-        /// Evaluate a Python expression 
+        /// Evaluate a Python expression
         /// and  convert the result to a Managed Object of given type.
         /// </remarks>
         public T Eval<T>(string code, PyDict locals = null)
@@ -400,7 +398,7 @@ public PyObject Get(string name)
         {
             PyObject scope;
             var state = TryGet(name, out scope);
-            if(!state)
+            if (!state)
             {
                 throw new PyScopeException($"The scope of name '{Name}' has no attribute '{name}'");
             }
@@ -447,7 +445,7 @@ public bool TryGet(string name, out PyObject value)
         /// Get Method
         /// </summary>
         /// <remarks>
-        /// Obtain the value of the variable of given name, 
+        /// Obtain the value of the variable of given name,
         /// and convert the result to a Managed Object of given type.
         /// If the variable does not exist, throw an Exception.
         /// </remarks>
@@ -466,7 +464,7 @@ public T Get<T>(string name)
         /// TryGet Method
         /// </summary>
         /// <remarks>
-        /// Obtain the value of the variable of given name, 
+        /// Obtain the value of the variable of given name,
         /// and convert the result to a Managed Object of given type.
         /// If the variable does not exist, return false.
         /// </remarks>
@@ -479,10 +477,10 @@ public bool TryGet<T>(string name, out T value)
             {
                 value = default(T);
                 return false;
-            }            
+            }
             if (pyObj == null)
             {
-                if(typeof(T).IsValueType)
+                if (typeof(T).IsValueType)
                 {
                     throw new PyScopeException($"The value of the attribute '{name}' is None which cannot be convert to '{typeof(T).ToString()}'");
                 }
@@ -490,7 +488,7 @@ public bool TryGet<T>(string name, out T value)
                 {
                     value = default(T);
                     return true;
-                }                
+                }
             }
             value = pyObj.As<T>();
             return true;

From 330fde36369a4e3288c3033a07743a84fd3ee978 Mon Sep 17 00:00:00 2001
From: Rickard Holmberg <rickard.holmberg@raysearchlabs.com>
Date: Mon, 26 Jun 2017 12:29:00 +0200
Subject: [PATCH 09/19] Another shot at #495 (#503)

* Add tests of subclassing with __namespace__

* Remove __init__ call from ClassDerived.InvokeCtor

* Trying out __init__

* Cleanup

* Add tests constructing python type from CLR and calling __init__

* Revert borked changelog update

* Don't leak init reference

* Rename tests

* Remove unused internal Runtime.GetBoundArgTuple

* Reenable skipped tests in test_subclass.py
---
 CHANGELOG.md                |  1 +
 src/runtime/classderived.cs | 36 +---------------
 src/runtime/metatype.cs     | 18 ++------
 src/runtime/runtime.cs      | 23 -----------
 src/tests/test_subclass.py  | 82 ++++++++++++++++++++++++++++++-------
 5 files changed, 74 insertions(+), 86 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 38fa56a62..5ae62d692 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
     attribute (#481)
 -   Fixed conversion of 'float' and 'double' values (#486)
 -   Fixed 'clrmethod' for python 2 (#492)
+-   Fixed double calling of constructor when deriving from .NET class (#495)
 
 
 ## [2.3.0][] - 2017-03-11
diff --git a/src/runtime/classderived.cs b/src/runtime/classderived.cs
index c180f9acc..16d3b99db 100644
--- a/src/runtime/classderived.cs
+++ b/src/runtime/classderived.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -808,7 +808,6 @@ public static void InvokeCtor(IPythonDerivedType obj, string origCtorName, objec
                 obj,
                 args);
 
-            var disposeList = new List<PyObject>();
             CLRObject self = null;
             IntPtr gs = Runtime.PyGILState_Ensure();
             try
@@ -821,42 +820,9 @@ public static void InvokeCtor(IPythonDerivedType obj, string origCtorName, objec
                 // object to be collected.
                 FieldInfo fi = obj.GetType().GetField("__pyobj__");
                 fi.SetValue(obj, self);
-
-                Runtime.XIncref(self.pyHandle);
-                var pyself = new PyObject(self.pyHandle);
-                disposeList.Add(pyself);
-
-                Runtime.XIncref(Runtime.PyNone);
-                var pynone = new PyObject(Runtime.PyNone);
-                disposeList.Add(pynone);
-
-                // call __init__
-                PyObject init = pyself.GetAttr("__init__", pynone);
-                disposeList.Add(init);
-                if (init.Handle != Runtime.PyNone)
-                {
-                    // if __init__ hasn't been overridden then it will be a managed object
-                    ManagedType managedMethod = ManagedType.GetManagedObject(init.Handle);
-                    if (null == managedMethod)
-                    {
-                        var pyargs = new PyObject[args.Length];
-                        for (var i = 0; i < args.Length; ++i)
-                        {
-                            pyargs[i] = new PyObject(Converter.ToPython(args[i], args[i]?.GetType()));
-                            disposeList.Add(pyargs[i]);
-                        }
-
-                        disposeList.Add(init.Invoke(pyargs));
-                    }
-                }
             }
             finally
             {
-                foreach (PyObject x in disposeList)
-                {
-                    x?.Dispose();
-                }
-
                 // Decrement the python object's reference count.
                 // This doesn't actually destroy the object, it just sets the reference to this object
                 // to be a weak reference and it will be destroyed when the C# object is destroyed.
diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
index bfb71e26d..25e9817bd 100644
--- a/src/runtime/metatype.cs
+++ b/src/runtime/metatype.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 
 namespace Python.Runtime
@@ -157,23 +157,13 @@ public static IntPtr tp_call(IntPtr tp, IntPtr args, IntPtr kw)
                 return IntPtr.Zero;
             }
 
-            IntPtr py__init__ = Runtime.PyString_FromString("__init__");
-            IntPtr type = Runtime.PyObject_TYPE(obj);
-            IntPtr init = Runtime._PyType_Lookup(type, py__init__);
-            Runtime.XDecref(py__init__);
+            var init = Runtime.PyObject_GetAttrString(obj, "__init__");
             Runtime.PyErr_Clear();
 
             if (init != IntPtr.Zero)
             {
-                IntPtr bound = Runtime.GetBoundArgTuple(obj, args);
-                if (bound == IntPtr.Zero)
-                {
-                    Runtime.XDecref(obj);
-                    return IntPtr.Zero;
-                }
-
-                IntPtr result = Runtime.PyObject_Call(init, bound, kw);
-                Runtime.XDecref(bound);
+                IntPtr result = Runtime.PyObject_Call(init, args, kw);
+                Runtime.XDecref(init);
 
                 if (result == IntPtr.Zero)
                 {
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 73caeb854..3d1078805 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -378,29 +378,6 @@ internal static void CheckExceptionOccurred()
             }
         }
 
-        internal static IntPtr GetBoundArgTuple(IntPtr obj, IntPtr args)
-        {
-            if (PyObject_TYPE(args) != PyTupleType)
-            {
-                Exceptions.SetError(Exceptions.TypeError, "tuple expected");
-                return IntPtr.Zero;
-            }
-            int size = PyTuple_Size(args);
-            IntPtr items = PyTuple_New(size + 1);
-            PyTuple_SetItem(items, 0, obj);
-            XIncref(obj);
-
-            for (var i = 0; i < size; i++)
-            {
-                IntPtr item = PyTuple_GetItem(args, i);
-                XIncref(item);
-                PyTuple_SetItem(items, i + 1, item);
-            }
-
-            return items;
-        }
-
-
         internal static IntPtr ExtendTuple(IntPtr t, params IntPtr[] args)
         {
             int size = PyTuple_Size(t);
diff --git a/src/tests/test_subclass.py b/src/tests/test_subclass.py
index 739c24c07..43d013c7c 100644
--- a/src/tests/test_subclass.py
+++ b/src/tests/test_subclass.py
@@ -15,12 +15,12 @@
 from ._compat import range
 
 
-def interface_test_class_fixture():
+def interface_test_class_fixture(subnamespace):
     """Delay creation of class until test starts."""
 
     class InterfaceTestClass(IInterfaceTest):
         """class that implements the test interface"""
-        __namespace__ = "Python.Test"
+        __namespace__ = "Python.Test." + subnamespace
 
         def foo(self):
             return "InterfaceTestClass"
@@ -31,12 +31,12 @@ def bar(self, x, i):
     return InterfaceTestClass
 
 
-def derived_class_fixture():
+def derived_class_fixture(subnamespace):
     """Delay creation of class until test starts."""
 
     class DerivedClass(SubClassTest):
         """class that derives from a class deriving from IInterfaceTest"""
-        __namespace__ = "Python.Test"
+        __namespace__ = "Python.Test." + subnamespace
 
         def foo(self):
             return "DerivedClass"
@@ -60,12 +60,12 @@ def return_list(self):
     return DerivedClass
 
 
-def derived_event_test_class_fixture():
+def derived_event_test_class_fixture(subnamespace):
     """Delay creation of class until test starts."""
 
     class DerivedEventTest(IInterfaceTest):
         """class that implements IInterfaceTest.TestEvent"""
-        __namespace__ = "Python.Test"
+        __namespace__ = "Python.Test." + subnamespace
 
         def __init__(self):
             self.event_handlers = []
@@ -99,7 +99,7 @@ def test_base_class():
 
 def test_interface():
     """Test python classes can derive from C# interfaces"""
-    InterfaceTestClass = interface_test_class_fixture()
+    InterfaceTestClass = interface_test_class_fixture(test_interface.__name__)
     ob = InterfaceTestClass()
     assert ob.foo() == "InterfaceTestClass"
     assert FunctionsTest.test_foo(ob) == "InterfaceTestClass"
@@ -112,7 +112,7 @@ def test_interface():
 
 def test_derived_class():
     """Test python class derived from managed type"""
-    DerivedClass = derived_class_fixture()
+    DerivedClass = derived_class_fixture(test_derived_class.__name__)
     ob = DerivedClass()
     assert ob.foo() == "DerivedClass"
     assert ob.base_foo() == "foo"
@@ -128,10 +128,9 @@ def test_derived_class():
     assert id(x) == id(ob)
 
 
-@pytest.mark.skip(reason="FIXME: test randomly pass/fails")
 def test_create_instance():
     """Test derived instances can be created from managed code"""
-    DerivedClass = derived_class_fixture()
+    DerivedClass = derived_class_fixture(test_create_instance.__name__)
     ob = FunctionsTest.create_instance(DerivedClass)
     assert ob.foo() == "DerivedClass"
     assert FunctionsTest.test_foo(ob) == "DerivedClass"
@@ -142,7 +141,7 @@ def test_create_instance():
     x = FunctionsTest.pass_through(ob)
     assert id(x) == id(ob)
 
-    InterfaceTestClass = interface_test_class_fixture()
+    InterfaceTestClass = interface_test_class_fixture(test_create_instance.__name__)
     ob2 = FunctionsTest.create_instance(InterfaceTestClass)
     assert ob2.foo() == "InterfaceTestClass"
     assert FunctionsTest.test_foo(ob2) == "InterfaceTestClass"
@@ -153,7 +152,6 @@ def test_create_instance():
     assert id(y) == id(ob2)
 
 
-@pytest.mark.skip(reason="FIXME: test randomly pass/fails")
 def test_events():
     class EventHandler(object):
         def handler(self, x, args):
@@ -166,12 +164,12 @@ def handler(self, x, args):
     assert FunctionsTest.test_event(x, 1) == 1
     assert event_handler.value == 1
 
-    InterfaceTestClass = interface_test_class_fixture()
+    InterfaceTestClass = interface_test_class_fixture(test_events.__name__)
     i = InterfaceTestClass()
     with pytest.raises(System.NotImplementedException):
         FunctionsTest.test_event(i, 2)
 
-    DerivedEventTest = derived_event_test_class_fixture()
+    DerivedEventTest = derived_event_test_class_fixture(test_events.__name__)
     d = DerivedEventTest()
     d.add_TestEvent(event_handler.handler)
     assert FunctionsTest.test_event(d, 3) == 3
@@ -190,3 +188,59 @@ def test_isinstance_check():
     for x in b:
         assert isinstance(x, System.Object)
         assert isinstance(x, System.String)
+
+def test_namespace_and_init():
+    calls = []
+    class TestX(System.Object):
+        __namespace__ = "test_clr_subclass_with_init_args"
+        def __init__(self, *args, **kwargs):
+            calls.append((args, kwargs))
+    t = TestX(1,2,3,foo="bar")
+    assert len(calls) == 1
+    assert calls[0][0] == (1,2,3)
+    assert calls[0][1] == {"foo":"bar"}
+
+def test_namespace_and_argless_init():
+    calls = []
+    class TestX(System.Object):
+        __namespace__ = "test_clr_subclass_without_init_args"
+        def __init__(self):
+            calls.append(True)
+    t = TestX()
+    assert len(calls) == 1
+    assert calls[0] == True
+
+
+def test_namespace_and_no_init():
+    class TestX(System.Object):
+        __namespace__ = "test_clr_subclass_without_init"
+        q = 1
+    t = TestX()
+    assert t.q == 1
+
+def test_construction_from_clr():
+    import clr
+    calls = []
+    class TestX(System.Object):
+        __namespace__ = "test_clr_subclass_init_from_clr"
+        @clr.clrmethod(None, [int, str])
+        def __init__(self, i, s):
+            calls.append((i, s))
+
+    # Construct a TestX from Python
+    t = TestX(1, "foo")
+    assert len(calls) == 1
+    assert calls[0][0] == 1
+    assert calls[0][1] == "foo"
+
+    # Reset calls and construct a TestX from CLR
+    calls = []
+    tp = t.GetType()
+    t2 = tp.GetConstructors()[0].Invoke(None)
+    assert len(calls) == 0
+
+    # The object has only been constructed, now it needs to be initialized as well
+    tp.GetMethod("__init__").Invoke(t2, [1, "foo"])
+    assert len(calls) == 1
+    assert calls[0][0] == 1
+    assert calls[0][1] == "foo"

From 3c28ca3c26d0220f2ba23e50a4fbda07c4cc33e1 Mon Sep 17 00:00:00 2001
From: Benedikt Reinartz <filmor@gmail.com>
Date: Mon, 26 Jun 2017 12:31:13 +0200
Subject: [PATCH 10/19] Handle C long size on Windows. (#497)

On Windows 64bit systems, a C `long` is a 32 bit integer while the rest
of the world has agreed on making `sizeof(long) == sizeof(void*)`.
---
 src/runtime/Python.Runtime.csproj |  3 ++-
 src/runtime/Util.cs               | 33 +++++++++++++++++++++++++++++++
 src/runtime/clrobject.cs          |  4 ++--
 src/runtime/managedtype.cs        |  6 +++---
 src/runtime/metatype.cs           |  4 ++--
 src/runtime/runtime.cs            |  8 ++++++--
 src/runtime/typemanager.cs        | 10 +++++-----
 7 files changed, 53 insertions(+), 15 deletions(-)
 create mode 100644 src/runtime/Util.cs

diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
index ee1a3c701..9999f8303 100644
--- a/src/runtime/Python.Runtime.csproj
+++ b/src/runtime/Python.Runtime.csproj
@@ -136,6 +136,7 @@
     <Compile Include="runtime.cs" />
     <Compile Include="typemanager.cs" />
     <Compile Include="typemethod.cs" />
+    <Compile Include="Util.cs" />
   </ItemGroup>
   <ItemGroup Condition=" '$(PythonInteropFile)' != '' ">
     <Compile Include="$(PythonInteropFile)" />
@@ -164,4 +165,4 @@
     <Copy SourceFiles="$(TargetAssembly)" DestinationFolder="$(PythonBuildDir)" />
     <!--Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFolder="$(PythonBuildDir)" /-->
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/runtime/Util.cs b/src/runtime/Util.cs
new file mode 100644
index 000000000..dd4418cc9
--- /dev/null
+++ b/src/runtime/Util.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Python.Runtime
+{
+    internal class Util
+    {
+        internal static Int64 ReadCLong(IntPtr tp, int offset)
+        {
+            // On Windows, a C long is always 32 bits.
+            if (Runtime.IsWindows || Runtime.Is32Bit)
+            {
+                return Marshal.ReadInt32(tp, offset);
+            }
+            else
+            {
+                return Marshal.ReadInt64(tp, offset);
+            }
+        }
+
+        internal static void WriteCLong(IntPtr type, int offset, Int64 flags)
+        {
+            if (Runtime.IsWindows || Runtime.Is32Bit)
+            {
+                Marshal.WriteInt32(type, offset, (Int32)(flags & 0xffffffffL));
+            }
+            else
+            {
+                Marshal.WriteInt64(type, offset, flags);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/runtime/clrobject.cs b/src/runtime/clrobject.cs
index 472e5dcbb..fb3d0e0d7 100644
--- a/src/runtime/clrobject.cs
+++ b/src/runtime/clrobject.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 
 namespace Python.Runtime
@@ -11,7 +11,7 @@ internal CLRObject(object ob, IntPtr tp)
         {
             IntPtr py = Runtime.PyType_GenericAlloc(tp, 0);
 
-            var flags = (int)Marshal.ReadIntPtr(tp, TypeOffset.tp_flags);
+            long flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
             if ((flags & TypeFlags.Subclass) != 0)
             {
                 IntPtr dict = Marshal.ReadIntPtr(py, ObjectOffset.DictOffset(tp));
diff --git a/src/runtime/managedtype.cs b/src/runtime/managedtype.cs
index 9ee8d223b..562b2e5f8 100644
--- a/src/runtime/managedtype.cs
+++ b/src/runtime/managedtype.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 
 namespace Python.Runtime
@@ -28,7 +28,7 @@ internal static ManagedType GetManagedObject(IntPtr ob)
                     tp = ob;
                 }
 
-                var flags = (int)Marshal.ReadIntPtr(tp, TypeOffset.tp_flags);
+                var flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
                 if ((flags & TypeFlags.Managed) != 0)
                 {
                     IntPtr op = tp == ob
@@ -63,7 +63,7 @@ internal static bool IsManagedType(IntPtr ob)
                     tp = ob;
                 }
 
-                var flags = (int)Marshal.ReadIntPtr(tp, TypeOffset.tp_flags);
+                var flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
                 if ((flags & TypeFlags.Managed) != 0)
                 {
                     return true;
diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
index 25e9817bd..982f4a632 100644
--- a/src/runtime/metatype.cs
+++ b/src/runtime/metatype.cs
@@ -105,7 +105,7 @@ public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)
             flags |= TypeFlags.BaseType;
             flags |= TypeFlags.Subclass;
             flags |= TypeFlags.HaveGC;
-            Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
+            Util.WriteCLong(type, TypeOffset.tp_flags, flags);
 
             TypeManager.CopySlot(base_type, type, TypeOffset.tp_dealloc);
 
@@ -237,7 +237,7 @@ public static void tp_dealloc(IntPtr tp)
         {
             // Fix this when we dont cheat on the handle for subclasses!
 
-            var flags = (int)Marshal.ReadIntPtr(tp, TypeOffset.tp_flags);
+            var flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
             if ((flags & TypeFlags.Subclass) == 0)
             {
                 IntPtr gc = Marshal.ReadIntPtr(tp, TypeOffset.magic());
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 3d1078805..90c56817a 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -152,6 +152,10 @@ public class Runtime
         internal static bool IsFinalizing;
 
         internal static bool Is32Bit = IntPtr.Size == 4;
+
+        // .NET core: System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+        internal static bool IsWindows = Environment.OSVersion.Platform == PlatformID.Win32NT;
+
         internal static bool IsPython2 = pyversionnumber < 30;
         internal static bool IsPython3 = pyversionnumber >= 30;
 
@@ -762,7 +766,7 @@ internal static bool PyObject_IsIterable(IntPtr pointer)
         {
             var ob_type = Marshal.ReadIntPtr(pointer, ObjectOffset.ob_type);
 #if PYTHON2
-            long tp_flags = Marshal.ReadInt64(ob_type, TypeOffset.tp_flags);
+            long tp_flags = Util.ReadCLong(ob_type, TypeOffset.tp_flags);
             if ((tp_flags & TypeFlags.HaveIter) == 0)
                 return false;
 #endif
@@ -1419,7 +1423,7 @@ internal static bool PyIter_Check(IntPtr pointer)
         {
             var ob_type = Marshal.ReadIntPtr(pointer, ObjectOffset.ob_type);
 #if PYTHON2
-            long tp_flags = Marshal.ReadInt64(ob_type, TypeOffset.tp_flags);
+            long tp_flags = Util.ReadCLong(ob_type, TypeOffset.tp_flags);
             if ((tp_flags & TypeFlags.HaveIter) == 0)
                 return false;
 #endif
diff --git a/src/runtime/typemanager.cs b/src/runtime/typemanager.cs
index ad0fddcc1..6570ee083 100644
--- a/src/runtime/typemanager.cs
+++ b/src/runtime/typemanager.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
@@ -86,7 +86,7 @@ internal static IntPtr CreateType(Type impl)
 
             int flags = TypeFlags.Default | TypeFlags.Managed |
                         TypeFlags.HeapType | TypeFlags.HaveGC;
-            Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
+            Util.WriteCLong(type, TypeOffset.tp_flags, flags);
 
             Runtime.PyType_Ready(type);
 
@@ -160,7 +160,7 @@ internal static IntPtr CreateType(ManagedType impl, Type clrType)
             flags |= TypeFlags.HeapType;
             flags |= TypeFlags.BaseType;
             flags |= TypeFlags.HaveGC;
-            Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
+            Util.WriteCLong(type, TypeOffset.tp_flags, flags);
 
             // Leverage followup initialization from the Python runtime. Note
             // that the type of the new type must PyType_Type at the time we
@@ -323,7 +323,7 @@ internal static IntPtr CreateMetaType(Type impl)
             flags |= TypeFlags.Managed;
             flags |= TypeFlags.HeapType;
             flags |= TypeFlags.HaveGC;
-            Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
+            Util.WriteCLong(type, TypeOffset.tp_flags, flags);
 
             // We need space for 3 PyMethodDef structs, each of them
             // 4 int-ptrs in size.
@@ -380,7 +380,7 @@ internal static IntPtr BasicSubType(string name, IntPtr base_, Type impl)
             flags |= TypeFlags.Managed;
             flags |= TypeFlags.HeapType;
             flags |= TypeFlags.HaveGC;
-            Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
+            Util.WriteCLong(type, TypeOffset.tp_flags, flags);
 
             CopySlot(base_, type, TypeOffset.tp_traverse);
             CopySlot(base_, type, TypeOffset.tp_clear);

From 36adf29a91fa7f7f3b98ba118e6e6e3fd3e49229 Mon Sep 17 00:00:00 2001
From: The Gitter Badger <badger@gitter.im>
Date: Wed, 5 Jul 2017 16:10:28 -0500
Subject: [PATCH 11/19] Add Gitter badge (#505)

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 7d12eafaf..dab57ef70 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # pythonnet - Python for .NET
 
+[![Join the chat at https://gitter.im/pythonnet/pythonnet](https://badges.gitter.im/pythonnet/pythonnet.svg)](https://gitter.im/pythonnet/pythonnet?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 [![appveyor shield][]](https://ci.appveyor.com/project/pythonnet/pythonnet/branch/master)
 [![travis shield][]](https://travis-ci.org/pythonnet/pythonnet)
 [![codecov shield][]](https://codecov.io/github/pythonnet/pythonnet)

From 6787bfef0918f1570822c2b83ac03e75d7bdf569 Mon Sep 17 00:00:00 2001
From: denfromufa <denfromufa@users.noreply.github.com>
Date: Mon, 10 Jul 2017 01:50:30 -0700
Subject: [PATCH 12/19] Update README.md (#507)

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index dab57ef70..06a2f1918 100644
--- a/README.md
+++ b/README.md
@@ -89,6 +89,10 @@ int32
 [  6.  10.  12.]
 ```
 
+Information on installation, FAQ, troubleshooting, debugging, and projects using pythonnet can be found in the Wiki:
+
+https://github.com/pythonnet/pythonnet/wiki
+
 [appveyor shield]: https://img.shields.io/appveyor/ci/pythonnet/pythonnet/master.svg?label=AppVeyor
 
 [codecov shield]: https://img.shields.io/codecov/c/github/pythonnet/pythonnet/master.svg?label=Codecov

From 1109b5bbef6977a3ca12c554f44d8f166326364e Mon Sep 17 00:00:00 2001
From: dmitriyse <dmitriy.se@gmail.com>
Date: Tue, 11 Jul 2017 02:32:38 +0400
Subject: [PATCH 13/19] Binary substitution of Python.Runtime.dll becomes safe.
 (#456)

* Binary substitution of Python.Runtime.Dll becomes safe.
* Public constants replaced to static readonly fields. Relaxed platform binding.
* Static readonly fields (related to build depented values) replaced by properties.
---
 src/embed_tests/TestPythonEngineProperties.cs |   4 +-
 src/runtime/CustomMarshaler.cs                |   6 +-
 src/runtime/Python.Runtime.csproj             |   6 +-
 src/runtime/runtime.cs                        | 545 +++++++++---------
 4 files changed, 291 insertions(+), 270 deletions(-)

diff --git a/src/embed_tests/TestPythonEngineProperties.cs b/src/embed_tests/TestPythonEngineProperties.cs
index 01c6ae7e3..76177d05a 100644
--- a/src/embed_tests/TestPythonEngineProperties.cs
+++ b/src/embed_tests/TestPythonEngineProperties.cs
@@ -146,7 +146,7 @@ public void SetProgramName()
         [Test]
         public void SetPythonPath()
         {
-            if (Runtime.Runtime.pyversion == "2.7")
+            if (Runtime.Runtime._pyversion == "2.7")
             {
                 // Assert.Skip outputs as a warning (ie. pending to fix)
                 Assert.Pass();
@@ -166,7 +166,7 @@ public void SetPythonPath()
         [Test]
         public void SetPythonPathExceptionOn27()
         {
-            if (Runtime.Runtime.pyversion != "2.7")
+            if (Runtime.Runtime._pyversion != "2.7")
             {
                 Assert.Pass();
             }
diff --git a/src/runtime/CustomMarshaler.cs b/src/runtime/CustomMarshaler.cs
index 90bb77a71..b51911816 100644
--- a/src/runtime/CustomMarshaler.cs
+++ b/src/runtime/CustomMarshaler.cs
@@ -91,13 +91,13 @@ public static int GetUnicodeByteLength(IntPtr p)
             var len = 0;
             while (true)
             {
-                int c = Runtime.UCS == 2
+                int c = Runtime._UCS == 2
                     ? Marshal.ReadInt16(p, len * 2)
                     : Marshal.ReadInt32(p, len * 4);
 
                 if (c == 0)
                 {
-                    return len * Runtime.UCS;
+                    return len * Runtime._UCS;
                 }
                 checked
                 {
@@ -163,7 +163,7 @@ public override IntPtr MarshalManagedToNative(object managedObj)
             }
 
             int totalStrLength = argv.Sum(arg => arg.Length + 1);
-            int memSize = argv.Length * IntPtr.Size + totalStrLength * Runtime.UCS;
+            int memSize = argv.Length * IntPtr.Size + totalStrLength * Runtime._UCS;
 
             IntPtr mem = Marshal.AllocHGlobal(memSize);
             try
diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
index 9999f8303..82825a626 100644
--- a/src/runtime/Python.Runtime.csproj
+++ b/src/runtime/Python.Runtime.csproj
@@ -20,12 +20,14 @@
     <SignAssembly>false</SignAssembly>
     <AssemblyOriginatorKeyFile>..\pythonnet.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Platform)' == 'x86'">
+  <!--We can relax binding to platform because code references no any platform dependent assemblies-->
+  <!--This will allows to use any build of this assebly as a compile ref assebly-->
+  <!--<PropertyGroup Condition=" '$(Platform)' == 'x86'">
     <PlatformTarget>x86</PlatformTarget>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Platform)' == 'x64'">
     <PlatformTarget>x64</PlatformTarget>
-  </PropertyGroup>
+  </PropertyGroup>-->
   <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMono'">
     <DefineConstants Condition="'$(DefineConstants)' == ''">PYTHON2;PYTHON27;UCS4</DefineConstants>
     <Optimize>true</Optimize>
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 90c56817a..8f730a855 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -80,8 +80,14 @@ public static IntPtr GetProcAddress(IntPtr dllHandle, string name)
     /// </summary>
     public class Runtime
     {
+        // C# compiler copies constants to the assemblies that references this library.
+        // We needs to replace all public constants to static readonly fields to allow 
+        // binary substitution of different Python.Runtime.dll builds in a target application.
+
+        public static int UCS => _UCS;
+
 #if UCS4
-        public const int UCS = 4;
+        internal const int _UCS = 4;
 
         /// <summary>
         /// EntryPoint to be used in DllImport to map to correct Unicode
@@ -89,7 +95,7 @@ public class Runtime
         /// </summary>
         private const string PyUnicodeEntryPoint = "PyUnicodeUCS4_";
 #elif UCS2
-        public const int UCS = 2;
+        internal const int _UCS = 2;
 
         /// <summary>
         /// EntryPoint to be used in DllImport to map to correct Unicode
@@ -100,32 +106,39 @@ public class Runtime
 #error You must define either UCS2 or UCS4!
 #endif
 
+        // C# compiler copies constants to the assemblies that references this library.
+        // We needs to replace all public constants to static readonly fields to allow 
+        // binary substitution of different Python.Runtime.dll builds in a target application.
+
+        public string pyversion => _pyversion;
+        public string pyver => _pyver;
+
 #if PYTHON27
-        public const string pyversion = "2.7";
-        public const string pyver = "27";
+        internal const string _pyversion = "2.7";
+        internal const string _pyver = "27";
 #elif PYTHON33
-        public const string pyversion = "3.3";
-        public const string pyver = "33";
+        internal const string _pyversion = "3.3";
+        internal const string _pyver = "33";
 #elif PYTHON34
-        public const string pyversion = "3.4";
-        public const string pyver = "34";
+        internal const string _pyversion = "3.4";
+        internal const string _pyver = "34";
 #elif PYTHON35
-        public const string pyversion = "3.5";
-        public const string pyver = "35";
+        internal const string _pyversion = "3.5";
+        internal const string _pyver = "35";
 #elif PYTHON36
-        public const string pyversion = "3.6";
-        public const string pyver = "36";
+        internal const string _pyversion = "3.6";
+        internal const string _pyver = "36";
 #elif PYTHON37 // TODO: Add `interop37.cs` after PY37 is released
-        public const string pyversion = "3.7";
-        public const string pyver = "37";
+        internal const string _pyversion = "3.7";
+        internal const string _pyver = "37";
 #else
 #error You must define one of PYTHON33 to PYTHON37 or PYTHON27
 #endif
 
 #if MONO_LINUX || MONO_OSX // Linux/macOS use dotted version string
-        internal const string dllBase = "python" + pyversion;
+        internal const string dllBase = "python" + _pyversion;
 #else // Windows
-        internal const string dllBase = "python" + pyver;
+        internal const string dllBase = "python" + _pyver;
 #endif
 
 #if PYTHON_WITH_PYDEBUG
@@ -139,13 +152,19 @@ public class Runtime
         internal const string dllWithPyMalloc = "";
 #endif
 
+        // C# compiler copies constants to the assemblies that references this library.
+        // We needs to replace all public constants to static readonly fields to allow 
+        // binary substitution of different Python.Runtime.dll builds in a target application.
+
+        public static readonly string PythonDLL = _PythonDll;
+
 #if PYTHON_WITHOUT_ENABLE_SHARED
-        public const string PythonDll = "__Internal";
+        internal const string _PythonDll = "__Internal";
 #else
-        public const string PythonDll = dllBase + dllWithPyDebug + dllWithPyMalloc;
+        internal const string _PythonDll = dllBase + dllWithPyDebug + dllWithPyMalloc;
 #endif
 
-        public static readonly int pyversionnumber = Convert.ToInt32(pyver);
+        public static readonly int pyversionnumber = Convert.ToInt32(_pyver);
 
         // set to true when python is finalizing
         internal static object IsFinalizingLock = new object();
@@ -162,7 +181,7 @@ public class Runtime
         /// <summary>
         /// Encoding to use to convert Unicode to/from Managed to Native
         /// </summary>
-        internal static readonly Encoding PyEncoding = UCS == 2 ? Encoding.Unicode : Encoding.UTF32;
+        internal static readonly Encoding PyEncoding = _UCS == 2 ? Encoding.Unicode : Encoding.UTF32;
 
         /// <summary>
         /// Initialize the runtime...
@@ -279,9 +298,9 @@ internal static void Initialize()
             Error = new IntPtr(-1);
 
             IntPtr dllLocal = IntPtr.Zero;
-            if (PythonDll != "__Internal")
+            if (_PythonDll != "__Internal")
             {
-                dllLocal = NativeMethods.LoadLibrary(PythonDll);
+                dllLocal = NativeMethods.LoadLibrary(_PythonDll);
             }
             _PyObject_NextNotImplemented = NativeMethods.GetProcAddress(dllLocal, "_PyObject_NextNotImplemented");
 #if !(MONO_LINUX || MONO_OSX)
@@ -549,7 +568,7 @@ internal static unsafe long Refcount(IntPtr op)
         /// Limit this function usage for Testing and Py_Debug builds
         /// </summary>
         /// <param name="ob">PyObject Ptr</param>
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_IncRef(IntPtr ob);
 
         /// <summary>
@@ -557,160 +576,160 @@ internal static unsafe long Refcount(IntPtr op)
         /// Limit this function usage for Testing and Py_Debug builds
         /// </summary>
         /// <param name="ob">PyObject Ptr</param>
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_DecRef(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_Initialize();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int Py_IsInitialized();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_Finalize();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_NewInterpreter();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_EndInterpreter(IntPtr threadState);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyThreadState_New(IntPtr istate);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyThreadState_Get();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyThread_get_key_value(IntPtr key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyThread_get_thread_ident();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyThread_set_key_value(IntPtr key, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyThreadState_Swap(IntPtr key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyGILState_Ensure();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyGILState_Release(IntPtr gs);
 
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyGILState_GetThisThreadState();
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         public static extern int Py_Main(
             int argc,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StrArrayMarshaler))] string[] argv
         );
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         public static extern int Py_Main(int argc, string[] argv);
 #endif
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyEval_InitThreads();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyEval_ThreadsInitialized();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyEval_AcquireLock();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyEval_ReleaseLock();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyEval_AcquireThread(IntPtr tstate);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyEval_ReleaseThread(IntPtr tstate);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyEval_SaveThread();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyEval_RestoreThread(IntPtr tstate);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyEval_GetBuiltins();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyEval_GetGlobals();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyEval_GetLocals();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetProgramName();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_SetProgramName(IntPtr name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetPythonHome();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_SetPythonHome(IntPtr home);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetPath();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void Py_SetPath(IntPtr home);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetVersion();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetPlatform();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetCopyright();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetCompiler();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_GetBuildInfo();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyRun_SimpleString(string code);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyRun_String(string code, IntPtr st, IntPtr globals, IntPtr locals);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyEval_EvalCode(IntPtr co, IntPtr globals, IntPtr locals);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_CompileString(string code, string file, IntPtr tok);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyImport_ExecCodeModule(string name, IntPtr code);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyCFunction_NewEx(IntPtr ml, IntPtr self, IntPtr mod);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyCFunction_Call(IntPtr func, IntPtr args, IntPtr kw);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyClass_New(IntPtr bases, IntPtr dict, IntPtr name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyInstance_New(IntPtr cls, IntPtr args, IntPtr kw);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyInstance_NewRaw(IntPtr cls, IntPtr dict);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyMethod_New(IntPtr func, IntPtr self, IntPtr cls);
 
 
@@ -774,44 +793,44 @@ internal static bool PyObject_IsIterable(IntPtr pointer)
             return tp_iter != IntPtr.Zero;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_HasAttrString(IntPtr pointer, string name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_GetAttrString(IntPtr pointer, string name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_SetAttrString(IntPtr pointer, string name, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_HasAttr(IntPtr pointer, IntPtr name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_GetAttr(IntPtr pointer, IntPtr name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_SetAttr(IntPtr pointer, IntPtr name, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_GetItem(IntPtr pointer, IntPtr key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_SetItem(IntPtr pointer, IntPtr key, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_DelItem(IntPtr pointer, IntPtr key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_GetIter(IntPtr op);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_Call(IntPtr pointer, IntPtr args, IntPtr kw);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_CallObject(IntPtr pointer, IntPtr args);
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_RichCompareBool(IntPtr value1, IntPtr value2, int opid);
 
         internal static int PyObject_Compare(IntPtr value1, IntPtr value2)
@@ -839,47 +858,47 @@ internal static int PyObject_Compare(IntPtr value1, IntPtr value2)
             return -1;
         }
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_Compare(IntPtr value1, IntPtr value2);
 #endif
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_IsInstance(IntPtr ob, IntPtr type);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_IsSubclass(IntPtr ob, IntPtr type);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyCallable_Check(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_IsTrue(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_Not(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_Size(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_Hash(IntPtr op);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_Repr(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_Str(IntPtr pointer);
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyObject_Str")]
         internal static extern IntPtr PyObject_Unicode(IntPtr pointer);
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_Unicode(IntPtr pointer);
 #endif
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_Dir(IntPtr pointer);
 
 
@@ -888,21 +907,21 @@ internal static int PyObject_Compare(IntPtr value1, IntPtr value2)
         //====================================================================
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyNumber_Long")]
         internal static extern IntPtr PyNumber_Int(IntPtr ob);
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Int(IntPtr ob);
 #endif
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Long(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Float(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern bool PyNumber_Check(IntPtr ob);
 
         internal static bool PyInt_Check(IntPtr ob)
@@ -928,32 +947,32 @@ internal static IntPtr PyInt_FromInt64(long value)
         }
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyLong_FromLong")]
         private static extern IntPtr PyInt_FromLong(IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyLong_AsLong")]
         internal static extern int PyInt_AsLong(IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyLong_FromString")]
         internal static extern IntPtr PyInt_FromString(string value, IntPtr end, int radix);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyLong_GetMax")]
         internal static extern int PyInt_GetMax();
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         private static extern IntPtr PyInt_FromLong(IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyInt_AsLong(IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyInt_FromString(string value, IntPtr end, int radix);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyInt_GetMax();
 #endif
 
@@ -962,34 +981,34 @@ internal static bool PyLong_Check(IntPtr ob)
             return PyObject_TYPE(ob) == PyLongType;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyLong_FromLong(long value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyLong_FromUnsignedLong(uint value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyLong_FromDouble(double value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyLong_FromLongLong(long value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyLong_FromUnsignedLongLong(ulong value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyLong_FromString(string value, IntPtr end, int radix);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyLong_AsLong(IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern uint PyLong_AsUnsignedLong(IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern long PyLong_AsLongLong(IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern ulong PyLong_AsUnsignedLongLong(IntPtr value);
 
         internal static bool PyFloat_Check(IntPtr ob)
@@ -997,88 +1016,88 @@ internal static bool PyFloat_Check(IntPtr ob)
             return PyObject_TYPE(ob) == PyFloatType;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyFloat_FromDouble(double value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyFloat_FromString(IntPtr value, IntPtr junk);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern double PyFloat_AsDouble(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Add(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Subtract(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Multiply(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Divide(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_And(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Xor(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Or(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Lshift(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Rshift(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Power(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Remainder(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceAdd(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceSubtract(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceMultiply(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceDivide(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceAnd(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceXor(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceOr(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceLshift(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceRshift(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlacePower(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_InPlaceRemainder(IntPtr o1, IntPtr o2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Negative(IntPtr o1);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Positive(IntPtr o1);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyNumber_Invert(IntPtr o1);
 
 
@@ -1086,49 +1105,49 @@ internal static bool PyFloat_Check(IntPtr ob)
         // Python sequence API
         //====================================================================
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern bool PySequence_Check(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PySequence_GetItem(IntPtr pointer, int index);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_SetItem(IntPtr pointer, int index, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_DelItem(IntPtr pointer, int index);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PySequence_GetSlice(IntPtr pointer, int i1, int i2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_SetSlice(IntPtr pointer, int i1, int i2, IntPtr v);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_DelSlice(IntPtr pointer, int i1, int i2);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_Size(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_Contains(IntPtr pointer, IntPtr item);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PySequence_Concat(IntPtr pointer, IntPtr other);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PySequence_Repeat(IntPtr pointer, int count);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_Index(IntPtr pointer, IntPtr item);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySequence_Count(IntPtr pointer, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PySequence_Tuple(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PySequence_List(IntPtr pointer);
 
 
@@ -1153,10 +1172,10 @@ internal static IntPtr PyString_FromString(string value)
         }
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyBytes_FromString(string op);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyBytes_Size(IntPtr op);
 
         internal static IntPtr PyBytes_AS_STRING(IntPtr ob)
@@ -1164,23 +1183,23 @@ internal static IntPtr PyBytes_AS_STRING(IntPtr ob)
             return ob + BytesOffset.ob_sval;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyUnicode_FromStringAndSize")]
         internal static extern IntPtr PyString_FromStringAndSize(
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))] string value,
             int size
         );
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyUnicode_FromStringAndSize(IntPtr value, int size);
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyString_FromStringAndSize(string value, int size);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyString_AsString(IntPtr op);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyString_Size(IntPtr pointer);
 #endif
 
@@ -1190,13 +1209,13 @@ internal static bool PyUnicode_Check(IntPtr ob)
         }
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyUnicode_FromObject(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyUnicode_FromEncodedObject(IntPtr ob, IntPtr enc, IntPtr err);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyUnicode_FromKindAndData(
             int kind,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UcsMarshaler))] string s,
@@ -1205,42 +1224,42 @@ int size
 
         internal static IntPtr PyUnicode_FromUnicode(string s, int size)
         {
-            return PyUnicode_FromKindAndData(UCS, s, size);
+            return PyUnicode_FromKindAndData(_UCS, s, size);
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyUnicode_GetSize(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyUnicode_AsUnicode(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyUnicode_FromOrdinal(int c);
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = PyUnicodeEntryPoint + "FromObject")]
         internal static extern IntPtr PyUnicode_FromObject(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = PyUnicodeEntryPoint + "FromEncodedObject")]
         internal static extern IntPtr PyUnicode_FromEncodedObject(IntPtr ob, IntPtr enc, IntPtr err);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = PyUnicodeEntryPoint + "FromUnicode")]
         internal static extern IntPtr PyUnicode_FromUnicode(
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UcsMarshaler))] string s,
             int size
         );
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = PyUnicodeEntryPoint + "GetSize")]
         internal static extern int PyUnicode_GetSize(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = PyUnicodeEntryPoint + "AsUnicode")]
         internal static extern IntPtr PyUnicode_AsUnicode(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl,
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = PyUnicodeEntryPoint + "FromOrdinal")]
         internal static extern IntPtr PyUnicode_FromOrdinal(int c);
 #endif
@@ -1279,7 +1298,7 @@ internal static string GetManagedString(IntPtr op)
                 IntPtr p = PyUnicode_AsUnicode(op);
                 int length = PyUnicode_GetSize(op);
 
-                int size = length * UCS;
+                int size = length * _UCS;
                 var buffer = new byte[size];
                 Marshal.Copy(p, buffer, 0, size);
                 return PyEncoding.GetString(buffer, 0, size);
@@ -1298,52 +1317,52 @@ internal static bool PyDict_Check(IntPtr ob)
             return PyObject_TYPE(ob) == PyDictType;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_New();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDictProxy_New(IntPtr dict);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_GetItem(IntPtr pointer, IntPtr key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_GetItemString(IntPtr pointer, string key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyDict_SetItem(IntPtr pointer, IntPtr key, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyDict_SetItemString(IntPtr pointer, string key, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyDict_DelItem(IntPtr pointer, IntPtr key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyDict_DelItemString(IntPtr pointer, string key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyMapping_HasKey(IntPtr pointer, IntPtr key);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_Keys(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_Values(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_Items(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_Copy(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyDict_Update(IntPtr pointer, IntPtr other);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyDict_Clear(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyDict_Size(IntPtr pointer);
 
 
@@ -1356,37 +1375,37 @@ internal static bool PyList_Check(IntPtr ob)
             return PyObject_TYPE(ob) == PyListType;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyList_New(int size);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyList_AsTuple(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyList_GetItem(IntPtr pointer, int index);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyList_SetItem(IntPtr pointer, int index, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyList_Insert(IntPtr pointer, int index, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyList_Append(IntPtr pointer, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyList_Reverse(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyList_Sort(IntPtr pointer);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyList_GetSlice(IntPtr pointer, int start, int end);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyList_SetSlice(IntPtr pointer, int start, int end, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyList_Size(IntPtr pointer);
 
 
@@ -1399,19 +1418,19 @@ internal static bool PyTuple_Check(IntPtr ob)
             return PyObject_TYPE(ob) == PyTupleType;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyTuple_New(int size);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyTuple_GetItem(IntPtr pointer, int index);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyTuple_SetItem(IntPtr pointer, int index, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyTuple_GetSlice(IntPtr pointer, int start, int end);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyTuple_Size(IntPtr pointer);
 
 
@@ -1431,7 +1450,7 @@ internal static bool PyIter_Check(IntPtr pointer)
             return tp_iternext != IntPtr.Zero && tp_iternext != _PyObject_NextNotImplemented;
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyIter_Next(IntPtr pointer);
 
 
@@ -1439,47 +1458,47 @@ internal static bool PyIter_Check(IntPtr pointer)
         // Python module API
         //====================================================================
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyModule_New(string name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern string PyModule_GetName(IntPtr module);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyModule_GetDict(IntPtr module);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern string PyModule_GetFilename(IntPtr module);
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyModule_Create2(IntPtr module, int apiver);
 #endif
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyImport_Import(IntPtr name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyImport_ImportModule(string name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyImport_ReloadModule(IntPtr module);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyImport_AddModule(string name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyImport_GetModuleDict();
 
 #if PYTHON3
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PySys_SetArgvEx(
             int argc,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StrArrayMarshaler))] string[] argv,
             int updatepath
         );
 #elif PYTHON2
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PySys_SetArgvEx(
             int argc,
             string[] argv,
@@ -1487,10 +1506,10 @@ int updatepath
         );
 #endif
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PySys_GetObject(string name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PySys_SetObject(string name, IntPtr ob);
 
 
@@ -1503,10 +1522,10 @@ internal static bool PyType_Check(IntPtr ob)
             return PyObject_TypeCheck(ob, PyTypeType);
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyType_Modified(IntPtr type);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern bool PyType_IsSubtype(IntPtr t1, IntPtr t2);
 
         internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp)
@@ -1515,37 +1534,37 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp)
             return (t == tp) || PyType_IsSubtype(t, tp);
         }
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyType_GenericNew(IntPtr type, IntPtr args, IntPtr kw);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyType_GenericAlloc(IntPtr type, int n);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyType_Ready(IntPtr type);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr _PyType_Lookup(IntPtr type, IntPtr name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_GenericGetAttr(IntPtr obj, IntPtr name);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyObject_GenericSetAttr(IntPtr obj, IntPtr name, IntPtr value);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr _PyObject_GetDictPtr(IntPtr obj);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyObject_GC_New(IntPtr tp);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyObject_GC_Del(IntPtr tp);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyObject_GC_Track(IntPtr tp);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyObject_GC_UnTrack(IntPtr tp);
 
 
@@ -1553,13 +1572,13 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp)
         // Python memory API
         //====================================================================
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyMem_Malloc(int size);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyMem_Realloc(IntPtr ptr, int size);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyMem_Free(IntPtr ptr);
 
 
@@ -1567,40 +1586,40 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp)
         // Python exception API
         //====================================================================
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_SetString(IntPtr ob, string message);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_SetObject(IntPtr ob, IntPtr message);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyErr_SetFromErrno(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_SetNone(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyErr_ExceptionMatches(IntPtr exception);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyErr_GivenExceptionMatches(IntPtr ob, IntPtr val);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_NormalizeException(IntPtr ob, IntPtr val, IntPtr tb);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyErr_Occurred();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_Fetch(ref IntPtr ob, ref IntPtr val, ref IntPtr tb);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_Restore(IntPtr ob, IntPtr val, IntPtr tb);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_Clear();
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern void PyErr_Print();
 
 
@@ -1608,10 +1627,10 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp)
         // Miscellaneous
         //====================================================================
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyMethod_Self(IntPtr ob);
 
-        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyMethod_Function(IntPtr ob);
     }
 }

From 4cea0081113f5ce73b4ca1fa5f8316bb058de08c Mon Sep 17 00:00:00 2001
From: denfromufa <denfromufa@users.noreply.github.com>
Date: Thu, 10 Aug 2017 01:49:54 -0500
Subject: [PATCH 14/19] Update .travis.yml (#524)

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index bf336dc9f..d6fcc4a88 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -35,6 +35,7 @@ before_install:
   - export LD_LIBRARY_PATH=$PY_LIBDIR:$LD_LIBRARY_PATH
 
 install:
+  - pip install --upgrade setuptools # TEMP - due to setuptools 36.2.0 bug
   - pip install --upgrade -r requirements.txt
   - coverage run setup.py install
 

From 9dc1a2b887364bc3e54a156cb69ee598d81a5626 Mon Sep 17 00:00:00 2001
From: Rickard Holmberg <rickard.holmberg@raysearchlabs.com>
Date: Thu, 10 Aug 2017 18:20:44 +0200
Subject: [PATCH 15/19] Use PyPI published version of codecov (#526)

---
 requirements.txt | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index bcceedf25..18f9bf902 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,11 +2,10 @@
 pytest
 coverage
 
+# Coverage upload
+codecov
+
 # Platform specific requirements
 pip; sys_platform == 'win32'
 wheel; sys_platform == 'win32'
 pycparser; sys_platform != 'win32'
-
-# Coverage upload
-# codecov v2.0.6 isn't on PyPi
-https://github.com/codecov/codecov-python/tarball/v2.0.6

From d7e8e35b0bd7dd72370e1be96000747e9c2e758a Mon Sep 17 00:00:00 2001
From: Rickard Holmberg <rickard.holmberg@raysearchlabs.com>
Date: Fri, 11 Aug 2017 20:16:18 +0200
Subject: [PATCH 16/19] Explicitly specify files to upload to codecov (#527)

* Explicitly specify files to upload to codecov

* Produce coverage.xml
---
 appveyor.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index c108801e7..2f1103f5a 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -47,11 +47,11 @@ test_script:
 on_finish:
   # Temporary disable multiple upload due to codecov limit of 20 per commit.
   # https://docs.codecov.io/blog/week-8-2017
-  # - coverage xml -i
+  - coverage xml -i
   # - codecov --file coverage.xml --flags setup_windows
   # - codecov --file py.coverage --flags python_tests
   # - codecov --file cs.coverage --flags embedded_tests
-  - codecov --flags setup_windows
+  - codecov --file py.coverage cs.coverage coverage.xml --flags setup_windows
 
 artifacts:
   - path: dist\*

From 756841f1395715f25c33e4bb0df46b9894d1ac6b Mon Sep 17 00:00:00 2001
From: Denis Akhiyarov <denis.akhiyarov@gmail.com>
Date: Fri, 15 Sep 2017 09:59:40 -0500
Subject: [PATCH 17/19] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 06a2f1918..89dcf2206 100644
--- a/README.md
+++ b/README.md
@@ -69,7 +69,7 @@ static void Main(string[] args)
         dynamic a = np.array(new List<float> { 1, 2, 3 });
         Console.WriteLine(a.dtype);
 
-        dynamic b = np.array(new List<float> { 6, 5, 4 }, dtype=np.int32);
+        dynamic b = np.array(new List<float> { 6, 5, 4 }, dtype: np.int32);
         Console.WriteLine(b.dtype);
 
         Console.WriteLine(a * b);

From 436cd8040f42fab54ebe121c01a5e0bb6b95cabd Mon Sep 17 00:00:00 2001
From: dmitriyse <dmitriy.se@gmail.com>
Date: Thu, 21 Sep 2017 12:11:32 +0400
Subject: [PATCH 18/19] CoreCLR msbuild (xplat) support. Initial compilable
 version. (#518)

* Full featured xplat build.

* .Net 45 TargetingPack System.XML.dll naming fix. (For xplat linux build).

* Setup.py --xplat option refactored. Travis-ci build matrix extended.

* AppVeyor matrix extended, xplat build added.

* appveyor.yml yaml syntax fix.

* NUnit dependency upgraded to 3.7. Changelog improved.

* Build order improvement.

* Mono builds now can be build on Windows.
DEBUG;TRACE fix for the case VS + non empty PYTHONNET_DEFINE_CONSTANTS

* PYTHONNET_PY3_VERSION, PYTHONNET_PY2_VERSION build related environment vars introduced.

* Small compile fixes.

* PYTHONNET_WIN_DEFINE_CONSTANTS and PYTHONNET_MONO_DEFINE_CONSTANTS introduced. + Fix for building mono versions under windows.
---
 .travis.yml                                   | 157 ++++++++++++--
 CHANGELOG.md                                  |   4 +
 NuGet.config                                  |   7 +
 appveyor.yml                                  |  16 +-
 ci/appveyor_run_tests.ps1                     |   7 +-
 pythonnet.15.sln                              | 194 ++++++++++++++++++
 setup.py                                      | 136 ++++++++++--
 src/clrmodule/clrmodule.15.csproj             | 101 +++++++++
 src/console/Console.15.csproj                 | 105 ++++++++++
 .../Python.EmbeddingTest.15.csproj            | 121 +++++++++++
 src/embed_tests/Python.EmbeddingTest.csproj   |   4 +-
 src/embed_tests/TestPythonEngineProperties.cs |   4 +-
 src/embed_tests/packages.config               |   4 +-
 src/runtime/Python.Runtime.15.csproj          | 133 ++++++++++++
 src/runtime/runtime.cs                        |   4 +-
 src/testing/Python.Test.15.csproj             |  92 +++++++++
 16 files changed, 1042 insertions(+), 47 deletions(-)
 create mode 100644 NuGet.config
 create mode 100644 pythonnet.15.sln
 create mode 100644 src/clrmodule/clrmodule.15.csproj
 create mode 100644 src/console/Console.15.csproj
 create mode 100644 src/embed_tests/Python.EmbeddingTest.15.csproj
 create mode 100644 src/runtime/Python.Runtime.15.csproj
 create mode 100644 src/testing/Python.Test.15.csproj

diff --git a/.travis.yml b/.travis.yml
index d6fcc4a88..2468ed60a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,18 +1,145 @@
+dist: trusty
 sudo: false
-
 language: python
-python:
-  - 2.7
-  - 3.3
-  - 3.4
-  - 3.5
-  - 3.6
-  - 3.7-dev
-
+  
 matrix:
-  allow_failures:
-    - python: 3.7-dev
+  include:
+    - python: 2.7
+      env: 
+        - BUILD_OPTS=--xplat
+        - NUNIT_PATH=~/.nuget/packages/nunit.consolerunner/3.*/tools/nunit3-console.exe
+      addons:
+        apt:
+          sources:
+          - sourceline: deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main
+            key_url: https://packages.microsoft.com/keys/microsoft.asc
+          - sourceline: deb http://download.mono-project.com/repo/ubuntu trusty main
+            key_url: http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xA6A19B38D3D831EF
+          packages:
+            - mono-devel
+            - ca-certificates-mono
+            - dotnet-hostfxr-2.0.0
+            - dotnet-runtime-2.0.0
+            - dotnet-sdk-2.0.0
+    - python: 3.3
+      env: 
+        - BUILD_OPTS=--xplat
+        - NUNIT_PATH=~/.nuget/packages/nunit.consolerunner/3.*/tools/nunit3-console.exe
+      addons:
+        apt:
+          sources:
+          - sourceline: deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main
+            key_url: https://packages.microsoft.com/keys/microsoft.asc
+          - sourceline: deb http://download.mono-project.com/repo/ubuntu trusty main
+            key_url: http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xA6A19B38D3D831EF
+          packages:
+            - mono-devel
+            - ca-certificates-mono
+            - dotnet-hostfxr-2.0.0
+            - dotnet-runtime-2.0.0
+            - dotnet-sdk-2.0.0
+    - python: 3.4
+      env: 
+        - BUILD_OPTS=--xplat
+        - NUNIT_PATH=~/.nuget/packages/nunit.consolerunner/3.*/tools/nunit3-console.exe
+      addons:
+        apt:
+          sources:
+          - sourceline: deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main
+            key_url: https://packages.microsoft.com/keys/microsoft.asc
+          - sourceline: deb http://download.mono-project.com/repo/ubuntu trusty main
+            key_url: http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xA6A19B38D3D831EF
+          packages:
+            - mono-devel
+            - ca-certificates-mono
+            - dotnet-hostfxr-2.0.0
+            - dotnet-runtime-2.0.0
+            - dotnet-sdk-2.0.0
+    - python: 3.5
+      env: 
+        - BUILD_OPTS=--xplat
+        - NUNIT_PATH=~/.nuget/packages/nunit.consolerunner/3.*/tools/nunit3-console.exe
+      addons:
+        apt:
+          sources:
+          - sourceline: deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main
+            key_url: https://packages.microsoft.com/keys/microsoft.asc
+          - sourceline: deb http://download.mono-project.com/repo/ubuntu trusty main
+            key_url: http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xA6A19B38D3D831EF
+          packages:
+            - mono-devel
+            - ca-certificates-mono
+            - dotnet-hostfxr-2.0.0
+            - dotnet-runtime-2.0.0
+            - dotnet-sdk-2.0.0
+    - python: 3.6
+      env: 
+        - BUILD_OPTS=--xplat
+        - NUNIT_PATH=~/.nuget/packages/nunit.consolerunner/3.*/tools/nunit3-console.exe
+      addons:
+        apt:
+          sources:
+          - sourceline: deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main
+            key_url: https://packages.microsoft.com/keys/microsoft.asc
+          - sourceline: deb http://download.mono-project.com/repo/ubuntu trusty main
+            key_url: http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xA6A19B38D3D831EF
+          packages:
+            - mono-devel
+            - ca-certificates-mono
+            - dotnet-hostfxr-2.0.0
+            - dotnet-runtime-2.0.0
+            - dotnet-sdk-2.0.0
+    - python: "3.7-dev"
+      env: 
+        - BUILD_OPTS=--xplat
+        - NUNIT_PATH=~/.nuget/packages/nunit.consolerunner/3.*/tools/nunit3-console.exe
+      addons:
+        apt:
+          sources:
+          - sourceline: deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main
+            key_url: https://packages.microsoft.com/keys/microsoft.asc
+          - sourceline: deb http://download.mono-project.com/repo/ubuntu trusty main
+            key_url: http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xA6A19B38D3D831EF
+          packages:
+            - mono-devel
+            - ca-certificates-mono
+            - dotnet-hostfxr-2.0.0
+            - dotnet-runtime-2.0.0
+            - dotnet-sdk-2.0.0
 
+    - python: 2.7
+      env: 
+        - BUILD_OPTS=
+        - NUNIT_PATH=./packages/NUnit.*/tools/nunit3-console.exe
+    - python: 3.3
+      env: 
+        - BUILD_OPTS=
+        - NUNIT_PATH=./packages/NUnit.*/tools/nunit3-console.exe
+    - python: 3.4
+      env: 
+        - BUILD_OPTS=
+        - NUNIT_PATH=./packages/NUnit.*/tools/nunit3-console.exe
+    - python: 3.5
+      env: 
+        - BUILD_OPTS=
+        - NUNIT_PATH=./packages/NUnit.*/tools/nunit3-console.exe
+    - python: 3.6
+      env: 
+        - BUILD_OPTS=
+        - NUNIT_PATH=./packages/NUnit.*/tools/nunit3-console.exe
+    - python: "3.7-dev"
+      env: 
+        - BUILD_OPTS=
+        - NUNIT_PATH=./packages/NUnit.*/tools/nunit3-console.exe
+  allow_failures:
+    - python: "3.7-dev"
+      env: 
+        - BUILD_OPTS=
+        - NUNIT_PATH=./packages/NUnit.*/tools/nunit3-console.exe
+    - python: "3.7-dev"
+      env: 
+        - BUILD_OPTS=--xplat
+        - NUNIT_PATH=~/.nuget/packages/nunit.consolerunner/3.*/tools/nunit3-console.exe
 env:
   global:
     - LD_PRELOAD=/lib/x86_64-linux-gnu/libSegFault.so
@@ -23,8 +150,8 @@ env:
 addons:
   apt:
     sources:
-      - mono
-      - mono-libtiff-compat
+      - sourceline: deb http://download.mono-project.com/repo/ubuntu trusty main
+        key_url: http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xA6A19B38D3D831EF
     packages:
       - mono-devel
       - ca-certificates-mono
@@ -37,11 +164,11 @@ before_install:
 install:
   - pip install --upgrade setuptools # TEMP - due to setuptools 36.2.0 bug
   - pip install --upgrade -r requirements.txt
-  - coverage run setup.py install
+  - coverage run setup.py install $BUILD_OPTS
 
 script:
   - python -m pytest
-  - mono ./packages/NUnit.*/tools/nunit3-console.exe src/embed_tests/bin/Python.EmbeddingTest.dll
+  - mono $NUNIT_PATH src/embed_tests/bin/Python.EmbeddingTest.dll
 
 after_script:
   # Uncomment if need to geninterop, ie. py37 final
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ae62d692..e5929107b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,10 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ## [unreleased][]
 
 ### Added
+-   Added new build system (pythonnet.15.sln) based on dotnetcore-sdk/xplat(crossplatform msbuild).
+    Currently there two side-by-side build systems that produces the same output (net40) from the same sources.
+    After a some transition time, current (mono/ msbuild 14.0) build system will be removed.
+-   NUnit upgraded to 3.7 (eliminates travis-ci random bug)
 -   Added `clr.GetClrType` (#432, #433)
 -   Allowed passing `None` for nullable args (#460)
 -   Added keyword arguments based on C# syntax for calling CPython methods (#461)
diff --git a/NuGet.config b/NuGet.config
new file mode 100644
index 000000000..719fbc83c
--- /dev/null
+++ b/NuGet.config
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="dot-net MyGet Feed" value="https://dotnet.myget.org/F/dotnet-core/api/v3/index.json" protocolVersion="3"/>
+    <add key="api.nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+  </packageSources>
+</configuration>
\ No newline at end of file
diff --git a/appveyor.yml b/appveyor.yml
index 2f1103f5a..c7c3a7810 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,6 +1,9 @@
 version: '{branch}-{build}'
 build: off
 
+image:
+  - Visual Studio 2017
+  
 platform:
   - x86
   - x64
@@ -12,6 +15,16 @@ environment:
     CODECOV_ENV: PYTHON_VERSION, PLATFORM
 
   matrix:
+    - PYTHON_VERSION: 2.7 
+      BUILD_OPTS: --xplat
+    - PYTHON_VERSION: 3.3
+      BUILD_OPTS: --xplat
+    - PYTHON_VERSION: 3.4
+      BUILD_OPTS: --xplat
+    - PYTHON_VERSION: 3.5
+      BUILD_OPTS: --xplat
+    - PYTHON_VERSION: 3.6
+      BUILD_OPTS: --xplat
     - PYTHON_VERSION: 2.7
     - PYTHON_VERSION: 3.3
     - PYTHON_VERSION: 3.4
@@ -29,6 +42,7 @@ init:
 
 install:
   - pip install --upgrade -r requirements.txt --quiet
+  - choco install vswhere -y
 
   # Install OpenCover. Can't put on `packages.config`, not Mono compatible
   - .\tools\nuget\nuget.exe install OpenCover -OutputDirectory packages -Verbosity quiet
@@ -37,7 +51,7 @@ build_script:
   # Create clean `sdist`. Only used for releases
   - python setup.py --quiet sdist
   # Build `wheel` with coverage of `setup.py`
-  - coverage run setup.py bdist_wheel
+  - coverage run setup.py bdist_wheel %BUILD_OPTS%
 
 test_script:
   - pip install --no-index --find-links=.\dist\ pythonnet
diff --git a/ci/appveyor_run_tests.ps1 b/ci/appveyor_run_tests.ps1
index 4245d1577..2821cf915 100644
--- a/ci/appveyor_run_tests.ps1
+++ b/ci/appveyor_run_tests.ps1
@@ -11,7 +11,12 @@ if ($FALSE -and $env:PLATFORM -eq "x86"){
 # Executable paths for OpenCover
 # Note if OpenCover fails, it won't affect the exit codes.
 $OPENCOVER = Resolve-Path .\packages\OpenCover.*\tools\OpenCover.Console.exe
-$CS_RUNNER = Resolve-Path .\packages\NUnit.*\tools\"$CS_RUNNER".exe
+if ($env:BUILD_OPTS -eq "--xplat"){
+    $CS_RUNNER = Resolve-Path $env:USERPROFILE\.nuget\packages\nunit.consolerunner\*\tools\"$CS_RUNNER".exe
+}
+else{
+    $CS_RUNNER = Resolve-Path .\packages\NUnit.*\tools\"$CS_RUNNER".exe
+}
 $PY = Get-Command python
 
 # Can't use ".\build\*\Python.EmbeddingTest.dll". Missing framework files.
diff --git a/pythonnet.15.sln b/pythonnet.15.sln
new file mode 100644
index 000000000..121631e43
--- /dev/null
+++ b/pythonnet.15.sln
@@ -0,0 +1,194 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26730.3
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.Runtime.15", "src\runtime\Python.Runtime.15.csproj", "{2759F4FF-716B-4828-916F-50FA86613DFC}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.EmbeddingTest.15", "src\embed_tests\Python.EmbeddingTest.15.csproj", "{66B8D01A-9906-452A-B09E-BF75EA76468F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "clrmodule.15", "src\clrmodule\clrmodule.15.csproj", "{E08678D4-9A52-4AD5-B63D-8EBC7399981B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Console.15", "src\console\Console.15.csproj", "{CDAD305F-8E72-492C-A314-64CF58D472A0}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.Test.15", "src\testing\Python.Test.15.csproj", "{F94B547A-E97E-4500-8D53-B4D64D076E5F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		DebugMono|x64 = DebugMono|x64
+		DebugMono|x86 = DebugMono|x86
+		DebugMonoPY3|x64 = DebugMonoPY3|x64
+		DebugMonoPY3|x86 = DebugMonoPY3|x86
+		DebugWin|x64 = DebugWin|x64
+		DebugWin|x86 = DebugWin|x86
+		DebugWinPY3|x64 = DebugWinPY3|x64
+		DebugWinPY3|x86 = DebugWinPY3|x86
+		ReleaseMono|x64 = ReleaseMono|x64
+		ReleaseMono|x86 = ReleaseMono|x86
+		ReleaseMonoPY3|x64 = ReleaseMonoPY3|x64
+		ReleaseMonoPY3|x86 = ReleaseMonoPY3|x86
+		ReleaseWin|x64 = ReleaseWin|x64
+		ReleaseWin|x86 = ReleaseWin|x86
+		ReleaseWinPY3|x64 = ReleaseWinPY3|x64
+		ReleaseWinPY3|x86 = ReleaseWinPY3|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMono|x64.ActiveCfg = DebugMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMono|x64.Build.0 = DebugMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMono|x86.ActiveCfg = DebugMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMono|x86.Build.0 = DebugMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMonoPY3|x64.ActiveCfg = DebugMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMonoPY3|x64.Build.0 = DebugMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMonoPY3|x86.ActiveCfg = DebugMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugMonoPY3|x86.Build.0 = DebugMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWin|x64.ActiveCfg = DebugWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWin|x64.Build.0 = DebugWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWin|x86.ActiveCfg = DebugWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWin|x86.Build.0 = DebugWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWinPY3|x64.ActiveCfg = DebugWinPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWinPY3|x64.Build.0 = DebugWinPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWinPY3|x86.ActiveCfg = DebugWinPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.DebugWinPY3|x86.Build.0 = DebugWinPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMono|x64.ActiveCfg = ReleaseMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMono|x64.Build.0 = ReleaseMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMono|x86.ActiveCfg = ReleaseMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMono|x86.Build.0 = ReleaseMono|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMonoPY3|x64.ActiveCfg = ReleaseMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMonoPY3|x64.Build.0 = ReleaseMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMonoPY3|x86.ActiveCfg = ReleaseMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseMonoPY3|x86.Build.0 = ReleaseMonoPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWin|x64.ActiveCfg = ReleaseWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWin|x64.Build.0 = ReleaseWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWin|x86.ActiveCfg = ReleaseWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWin|x86.Build.0 = ReleaseWin|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWinPY3|x64.ActiveCfg = ReleaseWinPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWinPY3|x64.Build.0 = ReleaseWinPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWinPY3|x86.ActiveCfg = ReleaseWinPY3|Any CPU
+		{2759F4FF-716B-4828-916F-50FA86613DFC}.ReleaseWinPY3|x86.Build.0 = ReleaseWinPY3|Any CPU
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMono|x64.ActiveCfg = DebugMono|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMono|x64.Build.0 = DebugMono|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMono|x86.ActiveCfg = DebugMono|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMono|x86.Build.0 = DebugMono|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMonoPY3|x64.ActiveCfg = DebugMonoPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMonoPY3|x64.Build.0 = DebugMonoPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMonoPY3|x86.ActiveCfg = DebugMonoPY3|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugMonoPY3|x86.Build.0 = DebugMonoPY3|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWin|x64.ActiveCfg = DebugWin|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWin|x64.Build.0 = DebugWin|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWin|x86.ActiveCfg = DebugWin|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWin|x86.Build.0 = DebugWin|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWinPY3|x64.ActiveCfg = DebugWinPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWinPY3|x64.Build.0 = DebugWinPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWinPY3|x86.ActiveCfg = DebugWinPY3|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.DebugWinPY3|x86.Build.0 = DebugWinPY3|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMono|x64.ActiveCfg = ReleaseMono|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMono|x64.Build.0 = ReleaseMono|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMono|x86.ActiveCfg = ReleaseMono|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMono|x86.Build.0 = ReleaseMono|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMonoPY3|x64.ActiveCfg = ReleaseMonoPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMonoPY3|x64.Build.0 = ReleaseMonoPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMonoPY3|x86.ActiveCfg = ReleaseMonoPY3|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseMonoPY3|x86.Build.0 = ReleaseMonoPY3|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWin|x64.ActiveCfg = ReleaseWin|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWin|x64.Build.0 = ReleaseWin|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWin|x86.ActiveCfg = ReleaseWin|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWin|x86.Build.0 = ReleaseWin|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWinPY3|x64.ActiveCfg = ReleaseWinPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWinPY3|x64.Build.0 = ReleaseWinPY3|x64
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWinPY3|x86.ActiveCfg = ReleaseWinPY3|x86
+		{66B8D01A-9906-452A-B09E-BF75EA76468F}.ReleaseWinPY3|x86.Build.0 = ReleaseWinPY3|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugMono|x64.ActiveCfg = DebugMono|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugMono|x86.ActiveCfg = DebugMono|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugMonoPY3|x64.ActiveCfg = DebugMonoPY3|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugMonoPY3|x86.ActiveCfg = DebugMonoPY3|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWin|x64.ActiveCfg = DebugWin|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWin|x64.Build.0 = DebugWin|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWin|x86.ActiveCfg = DebugWin|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWin|x86.Build.0 = DebugWin|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWinPY3|x64.ActiveCfg = DebugWinPY3|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWinPY3|x64.Build.0 = DebugWinPY3|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWinPY3|x86.ActiveCfg = DebugWinPY3|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.DebugWinPY3|x86.Build.0 = DebugWinPY3|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseMono|x64.ActiveCfg = ReleaseMono|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseMono|x86.ActiveCfg = ReleaseMono|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseMonoPY3|x64.ActiveCfg = ReleaseMonoPY3|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseMonoPY3|x86.ActiveCfg = ReleaseMonoPY3|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWin|x64.ActiveCfg = ReleaseWin|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWin|x64.Build.0 = ReleaseWin|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWin|x86.ActiveCfg = ReleaseWin|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWin|x86.Build.0 = ReleaseWin|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWinPY3|x64.ActiveCfg = ReleaseWinPY3|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWinPY3|x64.Build.0 = ReleaseWinPY3|x64
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWinPY3|x86.ActiveCfg = ReleaseWinPY3|x86
+		{E08678D4-9A52-4AD5-B63D-8EBC7399981B}.ReleaseWinPY3|x86.Build.0 = ReleaseWinPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMono|x64.ActiveCfg = DebugMono|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMono|x64.Build.0 = DebugMono|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMono|x86.ActiveCfg = DebugMono|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMono|x86.Build.0 = DebugMono|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMonoPY3|x64.ActiveCfg = DebugMonoPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMonoPY3|x64.Build.0 = DebugMonoPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMonoPY3|x86.ActiveCfg = DebugMonoPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugMonoPY3|x86.Build.0 = DebugMonoPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWin|x64.ActiveCfg = DebugWin|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWin|x64.Build.0 = DebugWin|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWin|x86.ActiveCfg = DebugWin|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWin|x86.Build.0 = DebugWin|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWinPY3|x64.ActiveCfg = DebugWinPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWinPY3|x64.Build.0 = DebugWinPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWinPY3|x86.ActiveCfg = DebugWinPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.DebugWinPY3|x86.Build.0 = DebugWinPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMono|x64.ActiveCfg = ReleaseMono|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMono|x64.Build.0 = ReleaseMono|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMono|x86.ActiveCfg = ReleaseMono|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMono|x86.Build.0 = ReleaseMono|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMonoPY3|x64.ActiveCfg = ReleaseMonoPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMonoPY3|x64.Build.0 = ReleaseMonoPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMonoPY3|x86.ActiveCfg = ReleaseMonoPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseMonoPY3|x86.Build.0 = ReleaseMonoPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWin|x64.ActiveCfg = ReleaseWin|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWin|x64.Build.0 = ReleaseWin|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWin|x86.ActiveCfg = ReleaseWin|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWin|x86.Build.0 = ReleaseWin|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWinPY3|x64.ActiveCfg = ReleaseWinPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWinPY3|x64.Build.0 = ReleaseWinPY3|x64
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWinPY3|x86.ActiveCfg = ReleaseWinPY3|x86
+		{CDAD305F-8E72-492C-A314-64CF58D472A0}.ReleaseWinPY3|x86.Build.0 = ReleaseWinPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMono|x64.ActiveCfg = DebugMono|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMono|x64.Build.0 = DebugMono|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMono|x86.ActiveCfg = DebugMono|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMono|x86.Build.0 = DebugMono|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMonoPY3|x64.ActiveCfg = DebugMonoPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMonoPY3|x64.Build.0 = DebugMonoPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMonoPY3|x86.ActiveCfg = DebugMonoPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugMonoPY3|x86.Build.0 = DebugMonoPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWin|x64.ActiveCfg = DebugWin|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWin|x64.Build.0 = DebugWin|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWin|x86.ActiveCfg = DebugWin|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWin|x86.Build.0 = DebugWin|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWinPY3|x64.ActiveCfg = DebugWinPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWinPY3|x64.Build.0 = DebugWinPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWinPY3|x86.ActiveCfg = DebugWinPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.DebugWinPY3|x86.Build.0 = DebugWinPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMono|x64.ActiveCfg = ReleaseMono|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMono|x64.Build.0 = ReleaseMono|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMono|x86.ActiveCfg = ReleaseMono|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMono|x86.Build.0 = ReleaseMono|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMonoPY3|x64.ActiveCfg = ReleaseMonoPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMonoPY3|x64.Build.0 = ReleaseMonoPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMonoPY3|x86.ActiveCfg = ReleaseMonoPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseMonoPY3|x86.Build.0 = ReleaseMonoPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWin|x64.ActiveCfg = ReleaseWin|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWin|x64.Build.0 = ReleaseWin|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWin|x86.ActiveCfg = ReleaseWin|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWin|x86.Build.0 = ReleaseWin|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWinPY3|x64.ActiveCfg = ReleaseWinPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWinPY3|x64.Build.0 = ReleaseWinPY3|x64
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWinPY3|x86.ActiveCfg = ReleaseWinPY3|x86
+		{F94B547A-E97E-4500-8D53-B4D64D076E5F}.ReleaseWinPY3|x86.Build.0 = ReleaseWinPY3|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {A6347B90-BBE6-4E45-90BF-1BD8B76069E3}
+	EndGlobalSection
+EndGlobal
diff --git a/setup.py b/setup.py
index c23f6b5bd..6cfd773a6 100644
--- a/setup.py
+++ b/setup.py
@@ -14,7 +14,8 @@
 import sys
 import sysconfig
 from distutils import spawn
-from distutils.command import build_ext, install_data, install_lib
+from distutils.command import install, build, build_ext, install_data, install_lib
+from wheel import bdist_wheel
 
 from setuptools import Extension, setup
 
@@ -131,9 +132,28 @@ def _get_long_description():
     except ImportError:
         return '.Net and Mono integration for Python'
 
+def _update_xlat_devtools():
+    global DEVTOOLS
+    if DEVTOOLS == "MsDev":
+        DEVTOOLS = "MsDev15"
+    elif DEVTOOLS == "Mono":
+        DEVTOOLS = "dotnet"
 
 class BuildExtPythonnet(build_ext.build_ext):
+    user_options = build_ext.build_ext.user_options + [
+            ('xplat', None, None)
+        ]
+    def initialize_options(self):
+        build_ext.build_ext.initialize_options(self)
+        self.xplat = None
+
+    def finalize_options(self):
+        build_ext.build_ext.finalize_options(self)
+
     def build_extension(self, ext):
+        if self.xplat:
+             _update_xlat_devtools()
+
         """Builds the .pyd file using msbuild or xbuild"""
         if ext.name != "clr":
             return build_ext.build_ext.build_extension(self, ext)
@@ -164,7 +184,7 @@ def build_extension(self, ext):
         if CONFIG == "Debug":
             defines.extend(["DEBUG", "TRACE"])
 
-        if sys.platform != "win32" and DEVTOOLS == "Mono":
+        if sys.platform != "win32" and (DEVTOOLS == "Mono" or DEVTOOLS == "dotnet"):
             on_darwin = sys.platform == "darwin"
             defines.append("MONO_OSX" if on_darwin else "MONO_LINUX")
 
@@ -196,20 +216,33 @@ def build_extension(self, ext):
         if DEVTOOLS == "MsDev":
             _xbuild = '"{0}"'.format(self._find_msbuild_tool("msbuild.exe"))
             _config = "{0}Win".format(CONFIG)
-
+            _solution_file = 'pythonnet.sln'
+            _custom_define_constants = False
+        elif DEVTOOLS == "MsDev15":
+            _xbuild = '"{0}"'.format(self._find_msbuild_tool_15()) 
+            _config = "{0}Win".format(CONFIG)
+            _solution_file = 'pythonnet.15.sln'
+            _custom_define_constants = True
         elif DEVTOOLS == "Mono":
-            _xbuild = "xbuild"
+            _xbuild = 'xbuild'
             _config = "{0}Mono".format(CONFIG)
+            _solution_file = 'pythonnet.sln'
+            _custom_define_constants = False
+        elif DEVTOOLS == "dotnet":
+            _xbuild = 'dotnet msbuild'
+            _config = "{0}Mono".format(CONFIG)
+            _solution_file = 'pythonnet.15.sln'
+            _custom_define_constants = True
         else:
             raise NotImplementedError(
-                "DevTool {0} not supported (use MsDev/Mono)".format(DEVTOOLS))
+                "DevTool {0} not supported (use MsDev/MsDev15/Mono/dotnet)".format(DEVTOOLS))
 
         cmd = [
             _xbuild,
-            'pythonnet.sln',
+            _solution_file,
             '/p:Configuration={}'.format(_config),
             '/p:Platform={}'.format(ARCH),
-            '/p:DefineConstants="{}"'.format('%3B'.join(defines)),
+            '/p:{}DefineConstants="{}"'.format('Custom' if _custom_define_constants else '','%3B'.join(defines)),
             '/p:PythonBuildDir="{}"'.format(os.path.abspath(dest_dir)),
             '/p:PythonInteropFile="{}"'.format(os.path.basename(interop_file)),
             '/verbosity:{}'.format(VERBOSITY),
@@ -220,15 +253,16 @@ def build_extension(self, ext):
             cmd.append('/p:PythonManifest="{0}"'.format(manifest))
 
         self.debug_print("Building: {0}".format(" ".join(cmd)))
-        use_shell = True if DEVTOOLS == "Mono" else False
+        use_shell = True if DEVTOOLS == "Mono" or DEVTOOLS == "dotnet" else False
+
         subprocess.check_call(" ".join(cmd + ["/t:Clean"]), shell=use_shell)
         subprocess.check_call(" ".join(cmd + ["/t:Build"]), shell=use_shell)
 
-        if DEVTOOLS == "Mono":
+        if DEVTOOLS == "Mono" or DEVTOOLS == "dotnet":
             self._build_monoclr()
 
     def _get_manifest(self, build_dir):
-        if DEVTOOLS != "MsDev":
+        if DEVTOOLS != "MsDev" and DEVTOOLS != "MsDev15":
             return
         mt = self._find_msbuild_tool("mt.exe", use_windows_sdk=True)
         manifest = os.path.abspath(os.path.join(build_dir, "app.manifest"))
@@ -261,19 +295,30 @@ def _build_monoclr(self):
 
     def _install_packages(self):
         """install packages using nuget"""
-        nuget = os.path.join("tools", "nuget", "nuget.exe")
-        use_shell = False
-        if DEVTOOLS == "Mono":
-            nuget = "mono {0}".format(nuget)
-            use_shell = True
+        use_shell = DEVTOOLS == "Mono" or DEVTOOLS == "dotnet"
+
+        if DEVTOOLS == "MsDev15" or DEVTOOLS == "dotnet":
+            if DEVTOOLS == "MsDev15":
+                _config = "{0}Win".format(CONFIG)
+            elif DEVTOOLS == "dotnet":
+                _config = "{0}Mono".format(CONFIG)
+
+            cmd = "dotnet msbuild /t:Restore pythonnet.15.sln /p:Configuration={0} /p:Platform={1}".format(_config, ARCH)
+            self.debug_print("Updating packages with xplat: {0}".format(cmd))
+            subprocess.check_call(cmd, shell=use_shell)
+        else:
+            nuget = os.path.join("tools", "nuget", "nuget.exe")
+
+            if DEVTOOLS == "Mono":
+                nuget = "mono {0}".format(nuget)
 
-        cmd = "{0} update -self".format(nuget)
-        self.debug_print("Updating NuGet: {0}".format(cmd))
-        subprocess.check_call(cmd, shell=use_shell)
+            cmd = "{0} update -self".format(nuget)
+            self.debug_print("Updating NuGet: {0}".format(cmd))
+            subprocess.check_call(cmd, shell=use_shell)
 
-        cmd = "{0} restore pythonnet.sln -o packages".format(nuget)
-        self.debug_print("Installing packages: {0}".format(cmd))
-        subprocess.check_call(cmd, shell=use_shell)
+            cmd = "{0} restore pythonnet.sln -o packages".format(nuget)
+            self.debug_print("Installing packages: {0}".format(cmd))
+            subprocess.check_call(cmd, shell=use_shell)
 
     def _find_msbuild_tool(self, tool="msbuild.exe", use_windows_sdk=False):
         """Return full path to one of the Microsoft build tools"""
@@ -319,6 +364,20 @@ def _find_msbuild_tool(self, tool="msbuild.exe", use_windows_sdk=False):
 
         raise RuntimeError("{0} could not be found".format(tool))
 
+    def _find_msbuild_tool_15(self):
+        """Return full path to one of the Microsoft build tools"""
+        try:
+            basePathes = subprocess.check_output(
+                ["vswhere", "-latest",
+                 "-version", "[15.0, 16.0)", 
+                 "-requires", "Microsoft.Component.MSBuild",
+                 "-property", "InstallationPath"]).splitlines()
+            if len(basePathes):
+                return os.path.join(basePathes[0].decode(sys.stdout.encoding or "utf-8"), "MSBuild", "15.0", "Bin", "MSBuild.exe")
+            else:
+                raise RuntimeError("MSBuild >=15.0 could not be found.")
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError("MSBuild >=15.0 could not be found. {0}".format(e.output))
 
 class InstallLibPythonnet(install_lib.install_lib):
     def install(self):
@@ -356,8 +415,39 @@ def run(self):
 
         return install_data.install_data.run(self)
 
+class InstallPythonnet(install.install):
+    user_options = install.install.user_options + [
+            ('xplat', None, None)
+        ]
+    def initialize_options(self):
+        install.install.initialize_options(self)
+        self.xplat = None
+
+    def finalize_options(self):
+        install.install.finalize_options(self)
 
-###############################################################################
+    def run(self):
+        if self.xplat:
+            _update_xlat_devtools()
+        return install.install.run(self)
+
+class BDistWheelPythonnet(bdist_wheel.bdist_wheel):
+    user_options = bdist_wheel.bdist_wheel.user_options + [
+            ('xplat', None, None)
+        ]
+    def initialize_options(self):
+        bdist_wheel.bdist_wheel.initialize_options(self)
+        self.xplat = None
+
+    def finalize_options(self):
+        bdist_wheel.bdist_wheel.finalize_options(self)
+
+    def run(self):
+        if self.xplat:
+            _update_xlat_devtools()
+        return bdist_wheel.bdist_wheel.run(self)
+
+        ###############################################################################
 setupdir = os.path.dirname(__file__)
 if setupdir:
     os.chdir(setupdir)
@@ -385,9 +475,11 @@ def run(self):
         ]),
     ],
     cmdclass={
+        "install": InstallPythonnet,
         "build_ext": BuildExtPythonnet,
         "install_lib": InstallLibPythonnet,
         "install_data": InstallDataPythonnet,
+        "bdist_wheel": BDistWheelPythonnet
     },
     classifiers=[
         'Development Status :: 5 - Production/Stable',
diff --git a/src/clrmodule/clrmodule.15.csproj b/src/clrmodule/clrmodule.15.csproj
new file mode 100644
index 000000000..4d8a1b8ff
--- /dev/null
+++ b/src/clrmodule/clrmodule.15.csproj
@@ -0,0 +1,101 @@
+<Project>
+
+  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
+
+  <PropertyGroup>
+    <TargetFrameworks>net40</TargetFrameworks>
+    <Platforms>x64;x86</Platforms>
+    <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
+    <RootNamespace>clrmodule</RootNamespace>
+    <AssemblyName>clrmodule</AssemblyName>
+    <PackageId>clrmodule</PackageId>
+    <VersionPrefix>2.4.0</VersionPrefix>
+    <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
+    <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
+    <DocumentationFile>bin\clrmodule.xml</DocumentationFile>
+    <OutputPath>bin\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <NoWarn>1591</NoWarn>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
+    <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <LangVersion>6</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
+    <BaseDefineConstants>XPLAT</BaseDefineConstants>
+    <DefineConstants>$(DefineConstants);$(CustomDefineConstants);$(BaseDefineConstants);</DefineConstants>
+    <DefineConstants Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(CustomDefineConstants)' != '' AND $(Configuration.Contains('Debug'))">$(DefineConstants);TRACE;DEBUG</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Platform)' == 'x86'">
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'x64'">
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMono'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;TRACE;DEBUG</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMono'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWin'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;TRACE;DEBUG</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWin'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMonoPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;TRACE;DEBUG</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMonoPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWinPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;TRACE;DEBUG</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWinPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\SharedAssemblyInfo.cs" Link="Properties\SharedAssemblyInfo.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="UnmanagedExports" Version="1.2.7" />
+  </ItemGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
+
+  <PropertyGroup>
+    <TargetAssembly>$(TargetPath)</TargetAssembly>
+    <TargetAssemblyPdb>$(TargetDir)$(TargetName).pdb</TargetAssemblyPdb>
+  </PropertyGroup>
+
+  <Target Name="AfterBuild" DependsOnTargets="RGieseckeDllExport">
+    <Copy SourceFiles="$(TargetAssembly)" DestinationFiles="$(PythonBuildDir)\clr.pyd" />
+    <Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFiles="$(PythonBuildDir)\clr.pdb" />
+  </Target>
+  <Import Project="$(NuGetPackageRoot)/unmanagedexports/1.2.7/tools/RGiesecke.DllExport.targets" Condition="Exists('$(NuGetPackageRoot)/unmanagedexports/1.2.7/tools/RGiesecke.DllExport.targets')" />
+</Project>
diff --git a/src/console/Console.15.csproj b/src/console/Console.15.csproj
new file mode 100644
index 000000000..0c89fce40
--- /dev/null
+++ b/src/console/Console.15.csproj
@@ -0,0 +1,105 @@
+<Project>
+  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
+  <PropertyGroup>
+    <TargetFrameworks>net40</TargetFrameworks>
+    <Platforms>x64;x86</Platforms>
+    <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
+    <OutputType>Exe</OutputType>
+    <AssemblyName>nPython</AssemblyName>
+    <RootNamespace>Python.Runtime</RootNamespace>
+    <PackageId>nPython</PackageId>
+    <VersionPrefix>2.4.0</VersionPrefix>
+    <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
+    <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
+    <DocumentationFile>bin\nPython.xml</DocumentationFile>
+    <OutputPath>bin\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <NoWarn>1591</NoWarn>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
+    <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <LangVersion>6</LangVersion>
+    <ApplicationIcon>python-clear.ico</ApplicationIcon>
+    <ErrorReport>prompt</ErrorReport>
+    <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
+    <BaseDefineConstants>XPLAT</BaseDefineConstants>
+    <DefineConstants>$(DefineConstants);$(CustomDefineConstants);$(BaseDefineConstants);</DefineConstants>
+    <DefineConstants Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(CustomDefineConstants)' != '' AND $(Configuration.Contains('Debug'))">$(DefineConstants);TRACE;DEBUG</DefineConstants>
+    <FrameworkPathOverride Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">$(NuGetPackageRoot)\microsoft.targetingpack.netframework.v4.5\1.0.1\lib\net45\</FrameworkPathOverride>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'x86'">
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'x64'">
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMono'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMono'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWin'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWin'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMonoPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMonoPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWinPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWinPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(PythonManifest)' != ''">
+    <ApplicationManifest>$(PythonManifest)</ApplicationManifest>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net40'">
+    <Reference Include="System" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\SharedAssemblyInfo.cs">
+      <Link>Properties\SharedAssemblyInfo.cs</Link>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="python-clear.ico" />
+    <EmbeddedResource Include="$(PythonBuildDir)\Python.Runtime.dll">
+      <LogicalName>Python.Runtime.dll</LogicalName>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\runtime\Python.Runtime.15.csproj" />
+  </ItemGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
+
+  <Target Name="AfterBuild">
+    <Copy SourceFiles="$(TargetPath)" DestinationFolder="$(PythonBuildDir)" />
+  </Target>
+</Project>
diff --git a/src/embed_tests/Python.EmbeddingTest.15.csproj b/src/embed_tests/Python.EmbeddingTest.15.csproj
new file mode 100644
index 000000000..ac6ecba92
--- /dev/null
+++ b/src/embed_tests/Python.EmbeddingTest.15.csproj
@@ -0,0 +1,121 @@
+<Project>
+  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
+
+  <PropertyGroup>
+    <TargetFrameworks>net40</TargetFrameworks>
+    <Platforms>x64;x86</Platforms>
+    <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
+    <AssetTargetFallback Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">net45</AssetTargetFallback>
+    <AssemblyName>Python.EmbeddingTest</AssemblyName>
+    <RootNamespace>Python.EmbeddingTest</RootNamespace>
+    <PackageId>Python.EmbeddingTest</PackageId>
+    <VersionPrefix>2.4.0</VersionPrefix>
+    <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <OutputPath>bin\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <DocumentationFile>$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <NoWarn>1591</NoWarn>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
+    <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <LangVersion>6</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
+    <BaseDefineConstants>XPLAT</BaseDefineConstants>
+    <DefineConstants>$(DefineConstants);$(CustomDefineConstants);$(BaseDefineConstants);</DefineConstants>
+    <DefineConstants Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(CustomDefineConstants)' != '' AND $(Configuration.Contains('Debug'))">$(DefineConstants);TRACE;DEBUG</DefineConstants>
+    <FrameworkPathOverride Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">$(NuGetPackageRoot)\microsoft.targetingpack.netframework.v4.5\1.0.1\lib\net45\</FrameworkPathOverride>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'x86'">
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'x64'">
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMono'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMono'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWin'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWin'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMonoPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMonoPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWinPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWinPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\pythonnet.snk" />
+    <None Remove="packages.config" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\SharedAssemblyInfo.cs" Link="Properties\SharedAssemblyInfo.cs" />
+  </ItemGroup>
+
+  
+  <ItemGroup>
+    <PackageReference Include="NUnit" Version="3.7.1" />
+    <PackageReference Include="NUnit.ConsoleRunner" Version="3.7.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\runtime\Python.Runtime.15.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net40'">
+    <Reference Include="Microsoft.CSharp" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Properties\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
+
+  <PropertyGroup>
+    <TargetAssembly>$(TargetPath)</TargetAssembly>
+    <TargetAssemblyPdb>$(TargetDir)$(TargetName).pdb</TargetAssemblyPdb>
+  </PropertyGroup>
+
+  <Target Name="AfterBuild">
+    <Copy SourceFiles="$(TargetAssembly)" DestinationFolder="$(PythonBuildDir)" />
+    <!--Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFolder="$(PythonBuildDir)" /-->
+  </Target>
+
+</Project>
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
index d45c622f9..fe02b0526 100644
--- a/src/embed_tests/Python.EmbeddingTest.csproj
+++ b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -70,8 +70,8 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Microsoft.CSharp" />
-    <Reference Include="nunit.framework, Version=3.6.0.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\NUnit.3.6.0\lib\net40\nunit.framework.dll</HintPath>
+    <Reference Include="nunit.framework, Version=3.7.1.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NUnit.3.7.1\lib\net40\nunit.framework.dll</HintPath>
     </Reference>
     <Reference Include="System" />
   </ItemGroup>
diff --git a/src/embed_tests/TestPythonEngineProperties.cs b/src/embed_tests/TestPythonEngineProperties.cs
index 76177d05a..01c6ae7e3 100644
--- a/src/embed_tests/TestPythonEngineProperties.cs
+++ b/src/embed_tests/TestPythonEngineProperties.cs
@@ -146,7 +146,7 @@ public void SetProgramName()
         [Test]
         public void SetPythonPath()
         {
-            if (Runtime.Runtime._pyversion == "2.7")
+            if (Runtime.Runtime.pyversion == "2.7")
             {
                 // Assert.Skip outputs as a warning (ie. pending to fix)
                 Assert.Pass();
@@ -166,7 +166,7 @@ public void SetPythonPath()
         [Test]
         public void SetPythonPathExceptionOn27()
         {
-            if (Runtime.Runtime._pyversion != "2.7")
+            if (Runtime.Runtime.pyversion != "2.7")
             {
                 Assert.Pass();
             }
diff --git a/src/embed_tests/packages.config b/src/embed_tests/packages.config
index 4cb01d3be..8c175f441 100644
--- a/src/embed_tests/packages.config
+++ b/src/embed_tests/packages.config
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="NUnit" version="3.6.0" targetFramework="net40" />
-  <package id="NUnit.ConsoleRunner" version="3.6.0" targetFramework="net40" />
+  <package id="NUnit" version="3.7.1" targetFramework="net40" />
+  <package id="NUnit.ConsoleRunner" version="3.7.0" targetFramework="net40" />
 </packages>
diff --git a/src/runtime/Python.Runtime.15.csproj b/src/runtime/Python.Runtime.15.csproj
new file mode 100644
index 000000000..93bd143dc
--- /dev/null
+++ b/src/runtime/Python.Runtime.15.csproj
@@ -0,0 +1,133 @@
+<Project>
+  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
+  <PropertyGroup>
+    <TargetFrameworks>net40</TargetFrameworks>
+    <Platforms>AnyCPU</Platforms>
+    <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
+    <AssetTargetFallback Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">net45</AssetTargetFallback>
+    <RootNamespace>Python.Runtime</RootNamespace>
+    <AssemblyName>Python.Runtime</AssemblyName>
+    <PackageId>Python.Runtime</PackageId>
+    <VersionPrefix>2.4.0</VersionPrefix>
+    <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
+    <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
+    <OutputPath>bin\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <DocumentationFile>$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <NoWarn>1591;NU1701</NoWarn>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
+    <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <LangVersion>6</LangVersion>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <AssemblyOriginatorKeyFile>..\pythonnet.snk</AssemblyOriginatorKeyFile>
+    <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
+    <BaseDefineConstants>XPLAT</BaseDefineConstants>
+    <DefineConstants>$(DefineConstants);$(CustomDefineConstants);$(BaseDefineConstants);</DefineConstants>
+    <DefineConstants Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(CustomDefineConstants)' != '' AND $(Configuration.Contains('Debug'))">$(DefineConstants);TRACE;DEBUG</DefineConstants>
+    <FrameworkPathOverride Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">$(NuGetPackageRoot)\microsoft.targetingpack.netframework.v4.5\1.0.1\lib\net45\</FrameworkPathOverride>
+    <Python2Version>$(PYTHONNET_PY2_VERSION)</Python2Version>
+    <Python2Version Condition="'$(Python2Version)'==''">PYTHON27</Python2Version>
+    <Python3Version>$(PYTHONNET_PY3_VERSION)</Python3Version>
+    <Python3Version Condition="'$(Python3Version)'==''">PYTHON36</Python3Version>
+    <PythonWinDefineConstants>$(PYTHONNET_WIN_DEFINE_CONSTANTS)</PythonWinDefineConstants>
+    <PythonWinDefineConstants Condition="'$(PythonWinDefineConstants)'==''">UCS2</PythonWinDefineConstants>
+    <PythonMonoDefineConstants>$(PYTHONNET_MONO_DEFINE_CONSTANTS)</PythonMonoDefineConstants>
+    <PythonMonoDefineConstants Condition="'$(PythonMonoDefineConstants)'==''">UCS4;MONO_LINUX;PYTHON_WITH_PYMALLOC</PythonMonoDefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMono'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonMonoDefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMonoPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonMonoDefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMono'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonMonoDefineConstants);TRACE;DEBUG</DefineConstants>
+    <Optimize>false</Optimize>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMonoPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonMonoDefineConstants);TRACE;DEBUG</DefineConstants>
+    <Optimize>false</Optimize>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWin'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonWinDefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWinPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonWinDefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWin'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonWinDefineConstants);TRACE;DEBUG</DefineConstants>
+    <Optimize>false</Optimize>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWinPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonWinDefineConstants);TRACE;DEBUG</DefineConstants>
+    <Optimize>false</Optimize>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+
+  <ItemGroup Condition=" '$(PythonInteropFile)' != '' ">
+    <Compile Remove="interop*.cs" />
+    <Compile Include="interop.cs" />
+    <Compile Include="$(PythonInteropFile)" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\pythonnet.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Remove="resources\clr.py" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\SharedAssemblyInfo.cs" Link="Properties\SharedAssemblyInfo.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="resources\clr.py">
+      <LogicalName>clr.py</LogicalName>
+    </EmbeddedResource>
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net40'">
+    <Reference Include="Microsoft.CSharp" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net40'">
+    <PackageReference Include="Microsoft.TargetingPack.NETFramework.v4.5" Version="1.0.1" ExcludeAssets="All" PrivateAssets="All" />
+  </ItemGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
+
+  <PropertyGroup>
+    <TargetAssembly>$(TargetPath)</TargetAssembly>
+    <TargetAssemblyPdb>$(TargetDir)$(TargetName).pdb</TargetAssemblyPdb>
+  </PropertyGroup>
+
+  <Target Name="BeforeBuild" Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono')) AND '$(OS)' != 'Windows_NT'">
+    <!--Endless war!-->
+    <Exec Command="cp $(NuGetPackageRoot)/microsoft.targetingpack.netframework.v4.5/1.0.1/lib/net45/System.XML.dll $(NuGetPackageRoot)/microsoft.targetingpack.netframework.v4.5/1.0.1/lib/net45/System.Xml.dll" />
+  </Target>
+  <Target Name="AfterBuild">
+    <Copy SourceFiles="$(TargetAssembly)" DestinationFolder="$(PythonBuildDir)" />
+    <!--Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFolder="$(PythonBuildDir)" /-->
+  </Target>
+</Project>
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 8f730a855..3949500e2 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -110,8 +110,8 @@ public class Runtime
         // We needs to replace all public constants to static readonly fields to allow 
         // binary substitution of different Python.Runtime.dll builds in a target application.
 
-        public string pyversion => _pyversion;
-        public string pyver => _pyver;
+        public static string pyversion => _pyversion;
+        public static string pyver => _pyver;
 
 #if PYTHON27
         internal const string _pyversion = "2.7";
diff --git a/src/testing/Python.Test.15.csproj b/src/testing/Python.Test.15.csproj
new file mode 100644
index 000000000..635580854
--- /dev/null
+++ b/src/testing/Python.Test.15.csproj
@@ -0,0 +1,92 @@
+<Project>
+  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
+  <PropertyGroup>
+    <TargetFrameworks>net40</TargetFrameworks>
+    <Platforms>x64;x86</Platforms>
+    <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
+    <AssemblyName>Python.Test</AssemblyName>
+    <RootNamespace>Python.Test</RootNamespace>
+    <PackageId>Python.Test</PackageId>
+    <VersionPrefix>2.4.0</VersionPrefix>
+    <DocumentationFile>bin\Python.Test.xml</DocumentationFile>
+    <OutputPath>bin\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <NoWarn>1591,0067</NoWarn>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
+    <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <LangVersion>6</LangVersion>
+    <SignAssembly>false</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\pythonnet.snk</AssemblyOriginatorKeyFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
+    <BaseDefineConstants>XPLAT</BaseDefineConstants>
+    <DefineConstants>$(DefineConstants);$(CustomDefineConstants);$(BaseDefineConstants);</DefineConstants>
+    <DefineConstants Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(CustomDefineConstants)' != '' AND $(Configuration.Contains('Debug'))">$(DefineConstants);TRACE;DEBUG</DefineConstants>
+    <FrameworkPathOverride Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">$(NuGetPackageRoot)\microsoft.targetingpack.netframework.v4.5\1.0.1\lib\net45\</FrameworkPathOverride>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'x86'">
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'x64'">
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMono'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMono'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWin'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWin'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugMonoPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMonoPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'DebugWinPY3'">
+    <DebugSymbols>true</DebugSymbols>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWinPY3'">
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net40'">
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\runtime\Python.Runtime.15.csproj"/>
+  </ItemGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
+
+  <PropertyGroup>
+    <TargetAssembly>$(TargetPath)</TargetAssembly>
+    <TargetAssemblyPdb>$(TargetDir)$(TargetName).pdb</TargetAssemblyPdb>
+  </PropertyGroup>
+  <Target Name="AfterBuild">
+    <Copy SourceFiles="$(TargetAssembly)" DestinationFolder="$(SolutionDir)\src\tests\fixtures" />
+    <!--Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFolder="$(PythonBuildDir)" /-->
+  </Target>
+</Project>

From 030563074a04d159a3edf645960404ed632c3586 Mon Sep 17 00:00:00 2001
From: dmitriyse <dmitriy.se@gmail.com>
Date: Thu, 21 Sep 2017 16:47:52 +0400
Subject: [PATCH 19/19] Added CoreCLR 2.0 build target. Compile issues fixed.
 (#519)

* Full featured xplat build.

* NetCoreApp 2.0 target added, compile issues fixed, CI system improved.

* .Net 45 TargetingPack System.XML.dll naming fix. (For xplat linux build).

* Setup.py --xplat option refactored. Travis-ci build matrix extended.

* AppVeyor matrix extended, xplat build added.

* appveyor.yml yaml syntax fix.

* NUnit dependency upgraded to 3.7. Changelog improved.

* EmbeddingTest fixes, and stubs.

* Fix for importing numpy and other python modules with native parts.

* Changelog improved.

* Build order improvement.

* NetCoreApp 2.0 fix. EmitCalli does not supports cdecl. Falling-back to a slow Marshal-based solution. + x86 fix.

* All finalizers are disabled until valid implementation. Helps to avoid non relevant CI build faults.

* Mono builds now can be build on Windows.
DEBUG;TRACE fix for the case VS + non empty PYTHONNET_DEFINE_CONSTANTS

* Python.Runtime.dll now targets NetStandard2.0 inplace of NetCoreApp 2.0

* Wrong NETSTANDARD/NETCOREAPP define constant change.

* Typo fix.
---
 .travis.yml                                   |  1 +
 CHANGELOG.md                                  |  1 +
 appveyor.yml                                  |  2 +
 ci/appveyor_run_tests.ps1                     | 17 +++++++
 pythonnet.15.sln                              | 10 ++---
 setup.py                                      |  2 +
 src/clrmodule/clrmodule.15.csproj             |  1 +
 src/console/Console.15.csproj                 | 12 ++---
 src/console/pythonconsole.cs                  |  9 +++-
 src/embed_tests/Program.cs                    | 19 ++++++++
 .../Python.EmbeddingTest.15.csproj            | 21 ++++++---
 src/embed_tests/TestPySequence.cs             |  6 ++-
 src/embed_tests/pyimport.cs                   |  4 ++
 src/runtime/Python.Runtime.15.csproj          | 44 +++++++++----------
 src/runtime/delegatemanager.cs                |  4 ++
 src/runtime/metatype.cs                       |  4 +-
 src/runtime/nativecall.cs                     | 30 ++++++++++++-
 src/runtime/polyfill/ReflectionPolifills.cs   | 21 +++++++++
 src/runtime/pyobject.cs                       |  6 ++-
 src/runtime/pyscope.cs                        |  6 ++-
 src/runtime/pythonexception.cs                |  4 ++
 src/runtime/runtime.cs                        | 43 ++++++++++++++----
 src/testing/Python.Test.15.csproj             | 17 ++++---
 src/tests/fixtures/netstandard2.0/.gitkeep    |  0
 24 files changed, 223 insertions(+), 61 deletions(-)
 create mode 100644 src/embed_tests/Program.cs
 create mode 100644 src/runtime/polyfill/ReflectionPolifills.cs
 create mode 100644 src/tests/fixtures/netstandard2.0/.gitkeep

diff --git a/.travis.yml b/.travis.yml
index 2468ed60a..627fd9ebf 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -169,6 +169,7 @@ install:
 script:
   - python -m pytest
   - mono $NUNIT_PATH src/embed_tests/bin/Python.EmbeddingTest.dll
+  - if [[ $BUILD_OPTS == --xplat ]]; then dotnet src/embed_tests/bin/netcoreapp2.0_publish/Python.EmbeddingTest.dll; fi
 
 after_script:
   # Uncomment if need to geninterop, ie. py37 final
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e5929107b..7d408a8d1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ## [unreleased][]
 
 ### Added
+-   Added support for embedding python into dotnet core 2.0 (NetStandard 2.0)
 -   Added new build system (pythonnet.15.sln) based on dotnetcore-sdk/xplat(crossplatform msbuild).
     Currently there two side-by-side build systems that produces the same output (net40) from the same sources.
     After a some transition time, current (mono/ msbuild 14.0) build system will be removed.
diff --git a/appveyor.yml b/appveyor.yml
index c7c3a7810..1953d85d5 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -43,6 +43,8 @@ init:
 install:
   - pip install --upgrade -r requirements.txt --quiet
   - choco install vswhere -y
+  - cmd: curl -O https://download.microsoft.com/download/5/6/B/56BFEF92-9045-4414-970C-AB31E0FC07EC/dotnet-runtime-2.0.0-win-x86.exe
+  - cmd: dotnet-runtime-2.0.0-win-x86.exe /install /quiet /norestart /log install.log
 
   # Install OpenCover. Can't put on `packages.config`, not Mono compatible
   - .\tools\nuget\nuget.exe install OpenCover -OutputDirectory packages -Verbosity quiet
diff --git a/ci/appveyor_run_tests.ps1 b/ci/appveyor_run_tests.ps1
index 2821cf915..b45440fbe 100644
--- a/ci/appveyor_run_tests.ps1
+++ b/ci/appveyor_run_tests.ps1
@@ -44,6 +44,23 @@ if ($CS_STATUS -ne 0) {
     Write-Host "Embedded tests failed" -ForegroundColor "Red"
 }
 
+if ($env:BUILD_OPTS -eq "--xplat"){
+    if ($env:PLATFORM -eq "x64") {
+         $DOTNET_CMD = "dotnet"
+    }
+    else{
+         $DOTNET_CMD = "c:\Program Files (x86)\dotnet\dotnet"
+    }
+
+    # Run Embedded tests for netcoreapp2.0 (OpenCover currently does not supports dotnet core)
+    Write-Host ("Starting embedded tests for netcoreapp2.0") -ForegroundColor "Green"
+    &$DOTNET_CMD .\src\embed_tests\bin\netcoreapp2.0_publish\Python.EmbeddingTest.dll
+    $CS_STATUS = $LastExitCode
+    if ($CS_STATUS -ne 0) {
+        Write-Host "Embedded tests for netcoreapp2.0 failed" -ForegroundColor "Red"
+    }
+}
+
 # Set exit code to fail if either Python or Embedded tests failed
 if ($PYTHON_STATUS -ne 0 -or $CS_STATUS -ne 0) {
     Write-Host "Tests failed" -ForegroundColor "Red"
diff --git a/pythonnet.15.sln b/pythonnet.15.sln
index 121631e43..f2015e480 100644
--- a/pythonnet.15.sln
+++ b/pythonnet.15.sln
@@ -2,15 +2,15 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.26730.3
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.Runtime.15", "src\runtime\Python.Runtime.15.csproj", "{2759F4FF-716B-4828-916F-50FA86613DFC}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.Runtime.15", "src/runtime/Python.Runtime.15.csproj", "{2759F4FF-716B-4828-916F-50FA86613DFC}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.EmbeddingTest.15", "src\embed_tests\Python.EmbeddingTest.15.csproj", "{66B8D01A-9906-452A-B09E-BF75EA76468F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.EmbeddingTest.15", "src/embed_tests/Python.EmbeddingTest.15.csproj", "{66B8D01A-9906-452A-B09E-BF75EA76468F}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "clrmodule.15", "src\clrmodule\clrmodule.15.csproj", "{E08678D4-9A52-4AD5-B63D-8EBC7399981B}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "clrmodule.15", "src/clrmodule/clrmodule.15.csproj", "{E08678D4-9A52-4AD5-B63D-8EBC7399981B}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Console.15", "src\console\Console.15.csproj", "{CDAD305F-8E72-492C-A314-64CF58D472A0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Console.15", "src/console/Console.15.csproj", "{CDAD305F-8E72-492C-A314-64CF58D472A0}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.Test.15", "src\testing\Python.Test.15.csproj", "{F94B547A-E97E-4500-8D53-B4D64D076E5F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Python.Test.15", "src/testing/Python.Test.15.csproj", "{F94B547A-E97E-4500-8D53-B4D64D076E5F}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/setup.py b/setup.py
index 6cfd773a6..24557c137 100644
--- a/setup.py
+++ b/setup.py
@@ -257,6 +257,8 @@ def build_extension(self, ext):
 
         subprocess.check_call(" ".join(cmd + ["/t:Clean"]), shell=use_shell)
         subprocess.check_call(" ".join(cmd + ["/t:Build"]), shell=use_shell)
+        if DEVTOOLS == "MsDev15" or DEVTOOLS == "dotnet":
+            subprocess.check_call(" ".join(cmd + ['"/t:Console_15:publish;Python_EmbeddingTest_15:publish"', "/p:TargetFramework=netcoreapp2.0"]), shell=use_shell)
 
         if DEVTOOLS == "Mono" or DEVTOOLS == "dotnet":
             self._build_monoclr()
diff --git a/src/clrmodule/clrmodule.15.csproj b/src/clrmodule/clrmodule.15.csproj
index 4d8a1b8ff..e97c6fe1b 100644
--- a/src/clrmodule/clrmodule.15.csproj
+++ b/src/clrmodule/clrmodule.15.csproj
@@ -22,6 +22,7 @@
     <NoWarn>1591</NoWarn>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <PythonBuildDir Condition="'$(TargetFramework)'!='net40'">$(PythonBuildDir)\$(TargetFramework)\</PythonBuildDir>
     <LangVersion>6</LangVersion>
     <ErrorReport>prompt</ErrorReport>
     <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
diff --git a/src/console/Console.15.csproj b/src/console/Console.15.csproj
index 0c89fce40..ed9d3d8f9 100644
--- a/src/console/Console.15.csproj
+++ b/src/console/Console.15.csproj
@@ -1,7 +1,7 @@
 <Project>
   <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
   <PropertyGroup>
-    <TargetFrameworks>net40</TargetFrameworks>
+    <TargetFrameworks>net40;netcoreapp2.0</TargetFrameworks>
     <Platforms>x64;x86</Platforms>
     <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
     <OutputType>Exe</OutputType>
@@ -15,12 +15,14 @@
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
     <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
     <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
-    <DocumentationFile>bin\nPython.xml</DocumentationFile>
     <OutputPath>bin\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendTargetFrameworkToOutputPath Condition="'$(TargetFramework)'=='net40'">false</AppendTargetFrameworkToOutputPath>
+    <DocumentationFile Condition="'$(TargetFramework)'=='net40'">$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <DocumentationFile Condition="'$(TargetFramework)'!='net40'">$(OutputPath)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
     <NoWarn>1591</NoWarn>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <PublishDir Condition="'$(TargetFramework)'!='net40'">$(PythonBuildDir)\$(TargetFramework)\</PublishDir>
     <LangVersion>6</LangVersion>
     <ApplicationIcon>python-clear.ico</ApplicationIcon>
     <ErrorReport>prompt</ErrorReport>
@@ -89,7 +91,7 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="python-clear.ico" />
-    <EmbeddedResource Include="$(PythonBuildDir)\Python.Runtime.dll">
+    <EmbeddedResource Condition="'$(TargetFramework)'=='net40'" Include="$(PythonBuildDir)\Python.Runtime.dll">
       <LogicalName>Python.Runtime.dll</LogicalName>
     </EmbeddedResource>
   </ItemGroup>
@@ -100,6 +102,6 @@
   <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
 
   <Target Name="AfterBuild">
-    <Copy SourceFiles="$(TargetPath)" DestinationFolder="$(PythonBuildDir)" />
+    <Copy Condition="'$(TargetFramework)'=='net40'" SourceFiles="$(TargetPath)" DestinationFolder="$(PythonBuildDir)" />
   </Target>
 </Project>
diff --git a/src/console/pythonconsole.cs b/src/console/pythonconsole.cs
index e9bb31e69..912e9bb0d 100644
--- a/src/console/pythonconsole.cs
+++ b/src/console/pythonconsole.cs
@@ -16,8 +16,9 @@ namespace Python.Runtime
     /// </remarks>
     public sealed class PythonConsole
     {
+#if NET40
         private static AssemblyLoader assemblyLoader = new AssemblyLoader();
-
+#endif
         private PythonConsole()
         {
         }
@@ -25,9 +26,11 @@ private PythonConsole()
         [STAThread]
         public static int Main(string[] args)
         {
+            // Only net40 is capable to safely inject python.runtime.dll into resources.
+#if NET40
             // reference the static assemblyLoader to stop it being optimized away
             AssemblyLoader a = assemblyLoader;
-
+#endif
             string[] cmd = Environment.GetCommandLineArgs();
             PythonEngine.Initialize();
 
@@ -37,6 +40,7 @@ public static int Main(string[] args)
             return i;
         }
 
+#if NET40
         // Register a callback function to load embedded assemblies.
         // (Python.Runtime.dll is included as a resource)
         private sealed class AssemblyLoader
@@ -73,5 +77,6 @@ public AssemblyLoader()
                 };
             }
         }
+#endif
     }
 }
diff --git a/src/embed_tests/Program.cs b/src/embed_tests/Program.cs
new file mode 100644
index 000000000..b4439e3e4
--- /dev/null
+++ b/src/embed_tests/Program.cs
@@ -0,0 +1,19 @@
+using System;
+
+using NUnit.Common;
+
+using NUnitLite;
+
+namespace Python.EmbeddingTest
+{
+    public class Program
+    {
+        public static int Main(string[] args)
+        {
+            return new AutoRun(typeof(Program).Assembly).Execute(
+                args,
+                new ExtendedTextWrapper(Console.Out),
+                Console.In);
+        }
+    }
+}
diff --git a/src/embed_tests/Python.EmbeddingTest.15.csproj b/src/embed_tests/Python.EmbeddingTest.15.csproj
index ac6ecba92..a30e8b3d9 100644
--- a/src/embed_tests/Python.EmbeddingTest.15.csproj
+++ b/src/embed_tests/Python.EmbeddingTest.15.csproj
@@ -2,10 +2,11 @@
   <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
 
   <PropertyGroup>
-    <TargetFrameworks>net40</TargetFrameworks>
+    <TargetFrameworks>net40;netcoreapp2.0</TargetFrameworks>
     <Platforms>x64;x86</Platforms>
     <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
-    <AssetTargetFallback Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">net45</AssetTargetFallback>
+    <OutputType Condition="'$(TargetFramework)' != 'net40' OR '$(PYTHONNET_VS_ENV)' == 'true'">Exe</OutputType>
+    <GenerateProgramFile>false</GenerateProgramFile>
     <AssemblyName>Python.EmbeddingTest</AssemblyName>
     <RootNamespace>Python.EmbeddingTest</RootNamespace>
     <PackageId>Python.EmbeddingTest</PackageId>
@@ -15,16 +16,19 @@
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
     <OutputPath>bin\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-    <DocumentationFile>$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <AppendTargetFrameworkToOutputPath Condition="'$(TargetFramework)'=='net40'">false</AppendTargetFrameworkToOutputPath>
+    <DocumentationFile Condition="'$(TargetFramework)'=='net40'">$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <DocumentationFile Condition="'$(TargetFramework)'!='net40'">$(OutputPath)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
     <NoWarn>1591</NoWarn>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <PythonBuildDir Condition="'$(TargetFramework)'=='net40' AND '$(PythonBuildDir)' == ''">$(SolutionDir)\bin\</PythonBuildDir>
+    <PublishDir Condition="'$(TargetFramework)'!='net40'">$(OutputPath)\$(TargetFramework)_publish</PublishDir>
     <LangVersion>6</LangVersion>
     <ErrorReport>prompt</ErrorReport>
     <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
     <BaseDefineConstants>XPLAT</BaseDefineConstants>
     <DefineConstants>$(DefineConstants);$(CustomDefineConstants);$(BaseDefineConstants);</DefineConstants>
+    <DefineConstants Condition="'$(TargetFramework)'=='netcoreapp2.0'">$(DefineConstants);NETCOREAPP</DefineConstants>
     <DefineConstants Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(CustomDefineConstants)' != '' AND $(Configuration.Contains('Debug'))">$(DefineConstants);TRACE;DEBUG</DefineConstants>
     <FrameworkPathOverride Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">$(NuGetPackageRoot)\microsoft.targetingpack.netframework.v4.5\1.0.1\lib\net45\</FrameworkPathOverride>
   </PropertyGroup>
@@ -88,6 +92,11 @@
   <ItemGroup>
     <PackageReference Include="NUnit" Version="3.7.1" />
     <PackageReference Include="NUnit.ConsoleRunner" Version="3.7.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.8.0" />
+    <PackageReference Include="NUnitLite" Version="3.7.2" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.0'">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
   </ItemGroup>
 
   <ItemGroup>
@@ -114,7 +123,7 @@
   </PropertyGroup>
 
   <Target Name="AfterBuild">
-    <Copy SourceFiles="$(TargetAssembly)" DestinationFolder="$(PythonBuildDir)" />
+    <Copy Condition="'$(TargetFramework)'=='net40'" SourceFiles="$(TargetAssembly)" DestinationFolder="$(PythonBuildDir)" />
     <!--Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFolder="$(PythonBuildDir)" /-->
   </Target>
 
diff --git a/src/embed_tests/TestPySequence.cs b/src/embed_tests/TestPySequence.cs
index 7c175b1ce..1e3ebf144 100644
--- a/src/embed_tests/TestPySequence.cs
+++ b/src/embed_tests/TestPySequence.cs
@@ -69,8 +69,10 @@ public void TestRepeat()
             PyObject actual = t1.Repeat(3);
             Assert.AreEqual("FooFooFoo", actual.ToString());
 
-            actual = t1.Repeat(-3);
-            Assert.AreEqual("", actual.ToString());
+            // On 32 bit system this argument should be int, but on the 64 bit system this should be long value.
+            // This works on the Framework 4.0 accidentally, it should produce out of memory!
+            // actual = t1.Repeat(-3);
+            // Assert.AreEqual("", actual.ToString());
         }
 
         [Test]
diff --git a/src/embed_tests/pyimport.cs b/src/embed_tests/pyimport.cs
index 3bb9a34d6..acb3433de 100644
--- a/src/embed_tests/pyimport.cs
+++ b/src/embed_tests/pyimport.cs
@@ -30,7 +30,11 @@ public void SetUp()
             /* Append the tests directory to sys.path
              * using reflection to circumvent the private
              * modifiers placed on most Runtime methods. */
+#if NETCOREAPP
+            const string s = "../../fixtures";
+#else
             const string s = "../fixtures";
+#endif
             string testPath = Path.Combine(TestContext.CurrentContext.TestDirectory, s);
 
             IntPtr str = Runtime.Runtime.PyString_FromString(testPath);
diff --git a/src/runtime/Python.Runtime.15.csproj b/src/runtime/Python.Runtime.15.csproj
index 93bd143dc..1ca767ca4 100644
--- a/src/runtime/Python.Runtime.15.csproj
+++ b/src/runtime/Python.Runtime.15.csproj
@@ -1,7 +1,7 @@
 <Project>
   <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
   <PropertyGroup>
-    <TargetFrameworks>net40</TargetFrameworks>
+    <TargetFrameworks>net40;netstandard2.0</TargetFrameworks>
     <Platforms>AnyCPU</Platforms>
     <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
     <AssetTargetFallback Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">net45</AssetTargetFallback>
@@ -16,70 +16,65 @@
     <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
     <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
     <OutputPath>bin\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-    <DocumentationFile>$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <AppendTargetFrameworkToOutputPath Condition="'$(TargetFramework)'=='net40'">false</AppendTargetFrameworkToOutputPath>
+    <DocumentationFile Condition="'$(TargetFramework)'=='net40'">$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <DocumentationFile Condition="'$(TargetFramework)'!='net40'">$(OutputPath)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
     <NoWarn>1591;NU1701</NoWarn>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <PythonBuildDir Condition="'$(PythonBuildDir)' == ''">$(SolutionDir)\bin\</PythonBuildDir>
+    <PublishDir Condition="'$(TargetFramework)'!='net40'">$(PythonBuildDir)\$(TargetFramework)\</PublishDir>
     <LangVersion>6</LangVersion>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
     <AssemblyOriginatorKeyFile>..\pythonnet.snk</AssemblyOriginatorKeyFile>
     <CustomDefineConstants Condition="'$(CustomDefineConstants)' == ''">$(PYTHONNET_DEFINE_CONSTANTS)</CustomDefineConstants>
     <BaseDefineConstants>XPLAT</BaseDefineConstants>
     <DefineConstants>$(DefineConstants);$(CustomDefineConstants);$(BaseDefineConstants);</DefineConstants>
+    <DefineConstants Condition="'$(TargetFramework)'=='netstandard2.0'">$(DefineConstants);NETSTANDARD</DefineConstants>
     <DefineConstants Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(CustomDefineConstants)' != '' AND $(Configuration.Contains('Debug'))">$(DefineConstants);TRACE;DEBUG</DefineConstants>
     <FrameworkPathOverride Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">$(NuGetPackageRoot)\microsoft.targetingpack.netframework.v4.5\1.0.1\lib\net45\</FrameworkPathOverride>
-    <Python2Version>$(PYTHONNET_PY2_VERSION)</Python2Version>
-    <Python2Version Condition="'$(Python2Version)'==''">PYTHON27</Python2Version>
-    <Python3Version>$(PYTHONNET_PY3_VERSION)</Python3Version>
-    <Python3Version Condition="'$(Python3Version)'==''">PYTHON36</Python3Version>
-    <PythonWinDefineConstants>$(PYTHONNET_WIN_DEFINE_CONSTANTS)</PythonWinDefineConstants>
-    <PythonWinDefineConstants Condition="'$(PythonWinDefineConstants)'==''">UCS2</PythonWinDefineConstants>
-    <PythonMonoDefineConstants>$(PYTHONNET_MONO_DEFINE_CONSTANTS)</PythonMonoDefineConstants>
-    <PythonMonoDefineConstants Condition="'$(PythonMonoDefineConstants)'==''">UCS4;MONO_LINUX;PYTHON_WITH_PYMALLOC</PythonMonoDefineConstants>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMono'">
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonMonoDefineConstants)</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;PYTHON27;UCS4</DefineConstants>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseMonoPY3'">
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonMonoDefineConstants)</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;PYTHON36;UCS4</DefineConstants>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'DebugMono'">
     <DebugSymbols>true</DebugSymbols>
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonMonoDefineConstants);TRACE;DEBUG</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;PYTHON27;UCS4;TRACE;DEBUG</DefineConstants>
     <Optimize>false</Optimize>
     <DebugType>full</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'DebugMonoPY3'">
     <DebugSymbols>true</DebugSymbols>
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonMonoDefineConstants);TRACE;DEBUG</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;PYTHON36;UCS4;TRACE;DEBUG</DefineConstants>
     <Optimize>false</Optimize>
     <DebugType>full</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWin'">
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonWinDefineConstants)</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;PYTHON27;UCS2</DefineConstants>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'ReleaseWinPY3'">
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonWinDefineConstants)</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;PYTHON36;UCS2</DefineConstants>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'DebugWin'">
     <DebugSymbols>true</DebugSymbols>
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;$(Python2Version);$(PythonWinDefineConstants);TRACE;DEBUG</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON2;PYTHON27;UCS2;TRACE;DEBUG</DefineConstants>
     <Optimize>false</Optimize>
     <DebugType>full</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'DebugWinPY3'">
     <DebugSymbols>true</DebugSymbols>
-    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;$(Python3Version);$(PythonWinDefineConstants);TRACE;DEBUG</DefineConstants>
+    <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants);PYTHON3;PYTHON36;UCS2;TRACE;DEBUG</DefineConstants>
     <Optimize>false</Optimize>
     <DebugType>full</DebugType>
   </PropertyGroup>
@@ -107,11 +102,16 @@
     </EmbeddedResource>
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Security.Permissions" Version="4.4.0" />
+    <PackageReference Include="System.Reflection.Emit" Version="4.3.0" />
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TargetFramework)' == 'net40'">
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)'=='net40'">
+  <ItemGroup Condition="'$(TargetFramework)'=='net40' AND $(Configuration.Contains('Mono'))">
     <PackageReference Include="Microsoft.TargetingPack.NETFramework.v4.5" Version="1.0.1" ExcludeAssets="All" PrivateAssets="All" />
   </ItemGroup>
 
@@ -127,7 +127,7 @@
     <Exec Command="cp $(NuGetPackageRoot)/microsoft.targetingpack.netframework.v4.5/1.0.1/lib/net45/System.XML.dll $(NuGetPackageRoot)/microsoft.targetingpack.netframework.v4.5/1.0.1/lib/net45/System.Xml.dll" />
   </Target>
   <Target Name="AfterBuild">
-    <Copy SourceFiles="$(TargetAssembly)" DestinationFolder="$(PythonBuildDir)" />
+    <Copy Condition="'$(TargetFramework)'=='net40'" SourceFiles="$(TargetAssembly)" DestinationFolder="$(PythonBuildDir)" />
     <!--Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFolder="$(PythonBuildDir)" /-->
   </Target>
 </Project>
diff --git a/src/runtime/delegatemanager.cs b/src/runtime/delegatemanager.cs
index df5eec427..7632816d1 100644
--- a/src/runtime/delegatemanager.cs
+++ b/src/runtime/delegatemanager.cs
@@ -195,6 +195,10 @@ public Dispatcher(IntPtr target, Type dtype)
 
         ~Dispatcher()
         {
+            // We needs to disable Finalizers until it's valid implementation.
+            // Current implementation can produce low probability floating bugs.
+            return;
+
             // Note: the managed GC thread can run and try to free one of
             // these *after* the Python runtime has been finalized!
             if (Runtime.Py_IsInitialized() > 0)
diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
index 982f4a632..3295ab110 100644
--- a/src/runtime/metatype.cs
+++ b/src/runtime/metatype.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 
 namespace Python.Runtime
@@ -201,7 +201,7 @@ public static int tp_setattro(IntPtr tp, IntPtr name, IntPtr value)
                     IntPtr fp = Marshal.ReadIntPtr(dt, TypeOffset.tp_descr_set);
                     if (fp != IntPtr.Zero)
                     {
-                        return NativeCall.Impl.Int_Call_3(fp, descr, name, value);
+                        return NativeCall.Int_Call_3(fp, descr, name, value);
                     }
                     Exceptions.SetError(Exceptions.AttributeError, "attribute is read-only");
                     return -1;
diff --git a/src/runtime/nativecall.cs b/src/runtime/nativecall.cs
index 9d1b0f41c..c64306958 100644
--- a/src/runtime/nativecall.cs
+++ b/src/runtime/nativecall.cs
@@ -23,6 +23,32 @@ namespace Python.Runtime
     /// </summary>
     internal class NativeCall
     {
+#if NETSTANDARD
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void Void_1_Delegate(IntPtr a1);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr IntPtr_3_Delegate(IntPtr a1, IntPtr a2, IntPtr a3);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int Int_3_Delegate(IntPtr a1, IntPtr a2, IntPtr a3);
+
+        public static void Void_Call_1(IntPtr fp, IntPtr a1)
+        {
+            ((Void_1_Delegate)Marshal.GetDelegateForFunctionPointer(fp, typeof(Void_1_Delegate)))(a1);
+        }
+
+        public static IntPtr Call_3(IntPtr fp, IntPtr a1, IntPtr a2, IntPtr a3)
+        {
+            return ((IntPtr_3_Delegate)Marshal.GetDelegateForFunctionPointer(fp, typeof(IntPtr_3_Delegate)))(a1, a2, a3);
+        }
+
+
+        public static int Int_Call_3(IntPtr fp, IntPtr a1, IntPtr a2, IntPtr a3)
+        {
+            return ((Int_3_Delegate)Marshal.GetDelegateForFunctionPointer(fp, typeof(Int_3_Delegate)))(a1, a2, a3);
+        }
+#else
         private static AssemblyBuilder aBuilder;
         private static ModuleBuilder mBuilder;
 
@@ -132,9 +158,10 @@ public static int Int_Call_3(IntPtr fp, IntPtr a1, IntPtr a2, IntPtr a3)
         {
             return Impl.Int_Call_3(fp, a1, a2, a3);
         }
+#endif
     }
 
-
+#if !NETSTANDARD
     /// <summary>
     /// Defines native call signatures to be generated by NativeCall.
     /// </summary>
@@ -148,4 +175,5 @@ public interface INativeCall
 
         IntPtr Call_3(IntPtr funcPtr, IntPtr a1, IntPtr a2, IntPtr a3);
     }
+#endif
 }
diff --git a/src/runtime/polyfill/ReflectionPolifills.cs b/src/runtime/polyfill/ReflectionPolifills.cs
new file mode 100644
index 000000000..a7e9c879a
--- /dev/null
+++ b/src/runtime/polyfill/ReflectionPolifills.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Python.Runtime
+{
+#if NETSTANDARD
+    public static class ReflectionPolifills
+    {
+        public static AssemblyBuilder DefineDynamicAssembly(this AppDomain appDomain, AssemblyName assemblyName, AssemblyBuilderAccess assemblyBuilderAccess)
+        {
+            return AssemblyBuilder.DefineDynamicAssembly(assemblyName, assemblyBuilderAccess);
+        }
+
+        public static Type CreateType(this TypeBuilder typeBuilder)
+        {
+            return typeBuilder.GetTypeInfo().GetType();
+        }
+    }
+#endif
+}
diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
index 1b41b0893..5900e80b7 100644
--- a/src/runtime/pyobject.cs
+++ b/src/runtime/pyobject.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Dynamic;
 using System.Linq.Expressions;
@@ -43,6 +43,10 @@ protected PyObject()
 
         ~PyObject()
         {
+            // We needs to disable Finalizers until it's valid implementation.
+            // Current implementation can produce low probability floating bugs.
+            return;
+
             Dispose();
         }
 
diff --git a/src/runtime/pyscope.cs b/src/runtime/pyscope.cs
index 25282ac26..67f93c6e2 100644
--- a/src/runtime/pyscope.cs
+++ b/src/runtime/pyscope.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Collections.Generic;
 using System.Dynamic;
@@ -527,6 +527,10 @@ public void Dispose()
 
         ~PyScope()
         {
+            // We needs to disable Finalizers until it's valid implementation.
+            // Current implementation can produce low probability floating bugs.
+            return;
+
             Dispose();
         }
     }
diff --git a/src/runtime/pythonexception.cs b/src/runtime/pythonexception.cs
index 4fe07f3cf..4031b0526 100644
--- a/src/runtime/pythonexception.cs
+++ b/src/runtime/pythonexception.cs
@@ -57,6 +57,10 @@ public PythonException()
 
         ~PythonException()
         {
+            // We needs to disable Finalizers until it's valid implementation.
+            // Current implementation can produce low probability floating bugs.
+            return;
+
             Dispose();
         }
 
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 3949500e2..abd0661a4 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 using System.Security;
 using System.Text;
@@ -9,6 +9,27 @@ namespace Python.Runtime
     internal static class NativeMethods
     {
 #if MONO_LINUX || MONO_OSX
+#if NETSTANDARD
+        private static int RTLD_NOW = 0x2;
+#if MONO_LINUX
+        private static int RTLD_GLOBAL = 0x100;
+        private static IntPtr RTLD_DEFAULT = IntPtr.Zero;
+        private const string NativeDll = "libdl.so";
+        public static IntPtr LoadLibrary(string fileName)
+        {
+            return dlopen($"lib{fileName}.so", RTLD_NOW | RTLD_GLOBAL);
+        }
+#elif MONO_OSX
+        private static int RTLD_GLOBAL = 0x8;
+        private const string NativeDll = "/usr/lib/libSystem.dylib"
+        private static IntPtr RTLD_DEFAULT = new IntPtr(-2);
+
+        public static IntPtr LoadLibrary(string fileName)
+        {
+            return dlopen($"lib{fileName}.dylib", RTLD_NOW | RTLD_GLOBAL);
+        }
+#endif
+#else
         private static int RTLD_NOW = 0x2;
         private static int RTLD_SHARED = 0x20;
 #if MONO_OSX
@@ -23,6 +44,8 @@ public static IntPtr LoadLibrary(string fileName)
         {
             return dlopen(fileName, RTLD_NOW | RTLD_SHARED);
         }
+#endif
+
 
         public static void FreeLibrary(IntPtr handle)
         {
@@ -48,16 +71,16 @@ public static IntPtr GetProcAddress(IntPtr dllHandle, string name)
             return res;
         }
 
-        [DllImport(NativeDll)]
-        private static extern IntPtr dlopen(String fileName, int flags);
+        [DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        public static extern IntPtr dlopen(String fileName, int flags);
 
-        [DllImport(NativeDll)]
+        [DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
         private static extern IntPtr dlsym(IntPtr handle, String symbol);
 
-        [DllImport(NativeDll)]
+        [DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl)]
         private static extern int dlclose(IntPtr handle);
 
-        [DllImport(NativeDll)]
+        [DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl)]
         private static extern IntPtr dlerror();
 #else // Windows
         private const string NativeDll = "kernel32.dll";
@@ -158,7 +181,7 @@ public class Runtime
 
         public static readonly string PythonDLL = _PythonDll;
 
-#if PYTHON_WITHOUT_ENABLE_SHARED
+#if PYTHON_WITHOUT_ENABLE_SHARED && !NETSTANDARD
         internal const string _PythonDll = "__Internal";
 #else
         internal const string _PythonDll = dllBase + dllWithPyDebug + dllWithPyMalloc;
@@ -298,11 +321,13 @@ internal static void Initialize()
             Error = new IntPtr(-1);
 
             IntPtr dllLocal = IntPtr.Zero;
+
             if (_PythonDll != "__Internal")
             {
                 dllLocal = NativeMethods.LoadLibrary(_PythonDll);
             }
             _PyObject_NextNotImplemented = NativeMethods.GetProcAddress(dllLocal, "_PyObject_NextNotImplemented");
+
 #if !(MONO_LINUX || MONO_OSX)
             if (dllLocal != IntPtr.Zero)
             {
@@ -497,7 +522,7 @@ internal static Type[] PythonArgsToTypeArray(IntPtr arg, bool mangleObjects)
         /// </summary>
         internal static unsafe void XIncref(IntPtr op)
         {
-#if PYTHON_WITH_PYDEBUG
+#if PYTHON_WITH_PYDEBUG || NETSTANDARD
             Py_IncRef(op);
             return;
 #else
@@ -518,7 +543,7 @@ internal static unsafe void XIncref(IntPtr op)
 
         internal static unsafe void XDecref(IntPtr op)
         {
-#if PYTHON_WITH_PYDEBUG
+#if PYTHON_WITH_PYDEBUG || NETSTANDARD
             Py_DecRef(op);
             return;
 #else
diff --git a/src/testing/Python.Test.15.csproj b/src/testing/Python.Test.15.csproj
index 635580854..a46cafb9d 100644
--- a/src/testing/Python.Test.15.csproj
+++ b/src/testing/Python.Test.15.csproj
@@ -1,19 +1,21 @@
 <Project>
   <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
   <PropertyGroup>
-    <TargetFrameworks>net40</TargetFrameworks>
+    <TargetFrameworks>net40;netstandard2.0</TargetFrameworks>
     <Platforms>x64;x86</Platforms>
     <Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>
     <AssemblyName>Python.Test</AssemblyName>
     <RootNamespace>Python.Test</RootNamespace>
     <PackageId>Python.Test</PackageId>
     <VersionPrefix>2.4.0</VersionPrefix>
-    <DocumentationFile>bin\Python.Test.xml</DocumentationFile>
     <OutputPath>bin\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendTargetFrameworkToOutputPath Condition="'$(TargetFramework)'=='net40'">false</AppendTargetFrameworkToOutputPath>
+    <DocumentationFile Condition="'$(TargetFramework)'=='net40'">$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
+    <DocumentationFile Condition="'$(TargetFramework)'!='net40'">$(OutputPath)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
     <NoWarn>1591,0067</NoWarn>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <PythonBuildDir Condition=" '$(PythonBuildDir)' == '' ">$(SolutionDir)\bin\</PythonBuildDir>
+    <PythonBuildDir Condition="'$(TargetFramework)'!='net40'">$(PythonBuildDir)\$(TargetFramework)\</PythonBuildDir>
     <LangVersion>6</LangVersion>
     <SignAssembly>false</SignAssembly>
     <AssemblyOriginatorKeyFile>..\pythonnet.snk</AssemblyOriginatorKeyFile>
@@ -76,7 +78,11 @@
   </ItemGroup>
   
   <ItemGroup>
-    <ProjectReference Include="..\runtime\Python.Runtime.15.csproj"/>
+    <ProjectReference Include="..\runtime\Python.Runtime.15.csproj" />
+  </ItemGroup>
+  
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="Microsoft.CSharp" Version="4.4.0" />
   </ItemGroup>
 
   <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
@@ -86,7 +92,8 @@
     <TargetAssemblyPdb>$(TargetDir)$(TargetName).pdb</TargetAssemblyPdb>
   </PropertyGroup>
   <Target Name="AfterBuild">
-    <Copy SourceFiles="$(TargetAssembly)" DestinationFolder="$(SolutionDir)\src\tests\fixtures" />
+    <Copy Condition="'$(TargetFramework)'=='net40'" SourceFiles="$(TargetAssembly)" DestinationFolder="$(SolutionDir)\src\tests\fixtures" />
+    <Copy Condition="'$(TargetFramework)'!='net40'" SourceFiles="$(TargetAssembly)" DestinationFolder="$(SolutionDir)\src\tests\fixtures\$(TargetFramework)" />
     <!--Copy SourceFiles="$(TargetAssemblyPdb)" Condition="Exists('$(TargetAssemblyPdb)')" DestinationFolder="$(PythonBuildDir)" /-->
   </Target>
 </Project>
diff --git a/src/tests/fixtures/netstandard2.0/.gitkeep b/src/tests/fixtures/netstandard2.0/.gitkeep
new file mode 100644
index 000000000..e69de29bb