- Added PythonException.Format method to format exceptions the same as traceback.format_exception

- Added Runtime.None to be able to pass None as parameter into Python from .NET

- Added PyObject.IsNone() to check if a Python object is None in .NET.

- Support for Python 3.8

- Added support for kwarg parameters when calling .NET methods from Python

- Changed method for finding MSBuild using vswhere

- Reworked `Finalizer`. Now objects drop into its queue upon finalization, which is periodically drained when new objects are created.

- Marked `Runtime.OperatingSystemName` and `Runtime.MachineName` as `Obsolete`, should never have been `public` in the first place. They also don't necessarily return a result that matches the `platform` module's.

- Fixes bug where delegates get casts (dotnetcore)

- Determine size of interpreter longs at runtime

- Handling exceptions ocurred in ModuleObject's getattribute

- Fill `__classcell__` correctly for Python subclasses of .NET types

CODECOV_ENV: PYTHON_VERSION, PLATFORM

matrix:

- PYTHON_VERSION: 3.8

BUILD_OPTS: --xplat

- PYTHON_VERSION: 3.7

BUILD_OPTS: --xplat

- PYTHON_VERSION: 3.6

BUILD_OPTS: --xplat

- PYTHON_VERSION: 3.5

BUILD_OPTS: --xplat

- PYTHON_VERSION: 2.7

BUILD_OPTS: --xplat

- PYTHON_VERSION: 3.8

- PYTHON_VERSION: 3.7

- PYTHON_VERSION: 3.6

- PYTHON_VERSION: 3.5

- PYTHON_VERSION: 2.7

init:

# Update Environment Variables based on matrix/platform

Runtime.Runtime.Initialize();

Assert.That(Runtime.Runtime.Machine, Is.Not.EqualTo(MachineType.Other));

Assert.That(Runtime.Runtime.OperatingSystem, Is.Not.EqualTo(OperatingSystemType.Other));

// Don't shut down the runtime: if the python engine was initialized

// but not shut down by another test, we'd end up in a bad state.

using System.Reflection.Emit;

using System;

using System.Diagnostics.Contracts;

using System.Runtime.InteropServices;

{ "Linux", OperatingSystemType.Linux },

};

[Obsolete]

public static string OperatingSystemName => OperatingSystem.ToString();

[Obsolete]

public static string MachineName => Machine.ToString();

/// <summary>

/// Gets the operating system as reported by python's platform.system().

/// </summary>

public static OperatingSystemType OperatingSystem { get; private set; }

/// <summary>

/// Map lower-case version of the python machine name to the processor

/// </summary>

public static MachineType Machine { get; private set; }/* set in Initialize using python's platform.machine */

internal static bool IsPython2 = pyversionnumber < 30;

internal static bool IsPython3 = pyversionnumber >= 30;

/// </summary>

private static void InitializePlatformData()

{

#if !NETSTANDARD

IntPtr op;

IntPtr fn;

IntPtr platformModule = PyImport_ImportModule("platform");

IntPtr emptyTuple = PyTuple_New(0);

fn = PyObject_GetAttrString(platformModule, "system");

op = PyObject_Call(fn, emptyTuple, IntPtr.Zero);

string operatingSystemName = GetManagedString(op);

XDecref(op);

XDecref(fn);

fn = PyObject_GetAttrString(platformModule, "machine");

op = PyObject_Call(fn, emptyTuple, IntPtr.Zero);

string machineName = GetManagedString(op);

XDecref(op);

XDecref(fn);

// Now convert the strings into enum values so we can do switch

// statements rather than constant parsing.

OperatingSystemType OSType;

if (!OperatingSystemTypeMapping.TryGetValue(operatingSystemName, out OSType))

{

OSType = OperatingSystemType.Other;

}

OperatingSystem = OSType;

MachineType MType;

if (!MachineTypeMapping.TryGetValue(machineName.ToLower(), out MType))

{

MType = MachineType.Other;

}

Machine = MType;

#else

if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))

OperatingSystem = OperatingSystemType.Linux;

else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))

OperatingSystem = OperatingSystemType.Darwin;

else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

OperatingSystem = OperatingSystemType.Windows;

else

OperatingSystem = OperatingSystemType.Other;

switch (RuntimeInformation.ProcessArchitecture)

{

case Architecture.X86:

Machine = MachineType.i386;

break;

case Architecture.X64:

Machine = MachineType.x86_64;

break;

case Architecture.Arm:

Machine = MachineType.armv7l;

break;

case Architecture.Arm64:

Machine = MachineType.aarch64;

break;

default:

Machine = MachineType.Other;

break;

}

#endif

}

internal static void Shutdown()

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyErr_Print();

//====================================================================

// Cell API

//====================================================================

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern NewReference PyCell_Get(BorrowedReference cell);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyCell_Set(BorrowedReference cell, IntPtr value);

//====================================================================

// Miscellaneous

IntPtr cls_dict = Marshal.ReadIntPtr(py_type, TypeOffset.tp_dict);

Runtime.PyDict_Update(cls_dict, py_dict);

// Update the __classcell__ if it exists

var cell = new BorrowedReference(Runtime.PyDict_GetItemString(cls_dict, "__classcell__"));

if (!cell.IsNull)

{

Runtime.PyCell_Set(cell, py_type);

Runtime.PyDict_DelItemString(cls_dict, "__classcell__");

}

return py_type;

}

catch (Exception e)

case OperatingSystemType.Linux:

return 0x20;

default:

throw new NotImplementedException(

$"mmap is not supported on {Runtime.OperatingSystem}"

);

}

}

}

case OperatingSystemType.Windows:

return new WindowsMemoryMapper();

default:

throw new NotImplementedException(

$"No support for {Runtime.OperatingSystem}"

);

}

}