public static void Finalize(IPythonDerivedType obj)
{
FieldInfo fi = obj.GetType().GetField("__pyobj__");
CLRObject self = (CLRObject)fi.GetValue(obj);
// If python's been terminated then just free the gchandle.
lock (Runtime.IsFinalizingLock)
{
if (0 == Runtime.Py_IsInitialized() || Runtime.IsFinalizing)
{
self.gcHandle.Free();
return;
}
}
// delete the python object in an asnyc task as we may not be able to acquire
// the GIL immediately and we don't want to block the GC thread.
var t = Task.Factory.StartNew(() =>
{
lock (Runtime.IsFinalizingLock)
{
// If python's been terminated then just free the gchandle.
if (0 == Runtime.Py_IsInitialized() || Runtime.IsFinalizing)
{
self.gcHandle.Free();
return;
}
IntPtr gs = Runtime.PyGILState_Ensure();
try
{
// the C# object is being destroyed which must mean there are no more
// references to the Python object as well so now we can dealloc the
// python object.
IntPtr dict = Marshal.ReadIntPtr(self.pyHandle, ObjectOffset.DictOffset(self.pyHandle));
if (dict != IntPtr.Zero)
{
Runtime.Decref(dict);
}
Runtime.PyObject_GC_Del(self.pyHandle);
self.gcHandle.Free();
}
finally
{
Runtime.PyGILState_Release(gs);
}
}
});
}
public static void InvokeSetProperty <T>(IPythonDerivedType obj, string propertyName, T value)
{
FieldInfo fi = obj.GetType().GetField("__pyobj__");
var self = (CLRObject)fi.GetValue(obj);
if (null == self)
{
throw new NullReferenceException("Instance must be specified when setting a property");
}
IntPtr gs = Runtime.PyGILState_Ensure();
try {
Runtime.XIncref(self.pyHandle);
using (var pyself = new PyObject(self.pyHandle))
using (var pyvalue = new PyObject(Converter.ToPythonImplicit(value))) {
pyself.SetAttr(propertyName, pyvalue);
}
}
finally {
Runtime.PyGILState_Release(gs);
}
}
public static T InvokeGetProperty <T>(IPythonDerivedType obj, string propertyName)
{
FieldInfo fi = obj.GetType().GetField("__pyobj__");
var self = (CLRObject)fi.GetValue(obj);
if (null == self)
{
throw new NullReferenceException("Instance must be specified when getting a property");
}
IntPtr gs = Runtime.PyGILState_Ensure();
try {
Runtime.XIncref(self.pyHandle);
using (var pyself = new PyObject(self.pyHandle))
using (PyObject pyvalue = pyself.GetAttr(propertyName)) {
return((T)pyvalue.AsManagedObject(typeof(T)));
}
}
finally {
Runtime.PyGILState_Release(gs);
}
}
public static void InvokeCtor(IPythonDerivedType obj, string origCtorName, object[] args)
{
// call the base constructor
obj.GetType().InvokeMember(origCtorName,
BindingFlags.InvokeMethod,
null,
obj,
args);
CLRObject self = null;
IntPtr gs = Runtime.PyGILState_Ensure();
try
{
// create the python object
BorrowedReference type = TypeManager.GetTypeReference(obj.GetType());
self = new CLRObject(obj, type);
// set __pyobj__ to self and deref the python object which will allow this
// object to be collected.
FieldInfo fi = obj.GetType().GetField("__pyobj__");
fi.SetValue(obj, self);
}
finally
{
// 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.
if (null != self)
{
Runtime.XDecref(self.pyHandle);
}
Runtime.PyGILState_Release(gs);
}
}
public static void InvokeMethodVoid(IPythonDerivedType obj, string methodName, string origMethodName,
object[] args)
{
FieldInfo fi = obj.GetType().GetField("__pyobj__");
var self = (CLRObject)fi.GetValue(obj);
if (null != self)
{
var disposeList = new List <PyObject>();
IntPtr gs = Runtime.PyGILState_Ensure();
try
{
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);
PyObject method = pyself.GetAttr(methodName, pynone);
disposeList.Add(method);
if (method.Handle != Runtime.PyNone)
{
// if the method hasn't been overridden then it will be a managed object
ManagedType managedMethod = ManagedType.GetManagedObject(method.Handle);
if (null == managedMethod)
{
var pyargs = new PyObject[args.Length];
for (var i = 0; i < args.Length; ++i)
{
pyargs[i] = new PyObject(Converter.ToPythonImplicit(args[i]));
disposeList.Add(pyargs[i]);
}
PyObject py_result = method.Invoke(pyargs);
disposeList.Add(py_result);
return;
}
}
}
finally
{
foreach (PyObject x in disposeList)
{
x?.Dispose();
}
Runtime.PyGILState_Release(gs);
}
}
if (origMethodName == null)
{
throw new NotImplementedException($"Python object does not have a '{methodName}' method");
}
obj.GetType().InvokeMember(origMethodName,
BindingFlags.InvokeMethod,
null,
obj,
args);
}
public static void InvokeCtor(IPythonDerivedType obj, string origCtorName, Object[] args)
{
// call the base constructor
obj.GetType().InvokeMember(origCtorName,
BindingFlags.InvokeMethod,
null,
obj,
args);
List <PyObject> disposeList = new List <PyObject>();
CLRObject self = null;
IntPtr gs = Runtime.PyGILState_Ensure();
try
{
// create the python object
IntPtr type = TypeManager.GetTypeHandle(obj.GetType());
self = new CLRObject(obj, type);
// set __pyobj__ to self and deref the python object which will allow this
// object to be collected.
FieldInfo fi = obj.GetType().GetField("__pyobj__");
fi.SetValue(obj, self);
Runtime.Incref(self.pyHandle);
PyObject pyself = new PyObject(self.pyHandle);
disposeList.Add(pyself);
Runtime.Incref(Runtime.PyNone);
PyObject 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 overriden then it will be a managed object
ManagedType managedMethod = ManagedType.GetManagedObject(init.Handle);
if (null == managedMethod)
{
PyObject[] pyargs = new PyObject[args.Length];
for (int 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)
{
if (x != null)
{
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.
if (null != self)
{
Runtime.Decref(self.pyHandle);
}
Runtime.PyGILState_Release(gs);
}
}
//====================================================================
// This is the implementaion of the overriden methods in the derived
// type. It looks for a python method with the same name as the method
// on the managed base class and if it exists and isn't the managed
// method binding (ie it has been overriden in the derived python
// class) it calls it, otherwise it calls the base method.
//====================================================================
public static T InvokeMethod <T>(IPythonDerivedType obj, string methodName, string origMethodName, Object[] args)
{
FieldInfo fi = obj.GetType().GetField("__pyobj__");
CLRObject self = (CLRObject)fi.GetValue(obj);
if (null != self)
{
List <PyObject> disposeList = new List <PyObject>();
IntPtr gs = Runtime.PyGILState_Ensure();
try
{
Runtime.Incref(self.pyHandle);
PyObject pyself = new PyObject(self.pyHandle);
disposeList.Add(pyself);
Runtime.Incref(Runtime.PyNone);
PyObject pynone = new PyObject(Runtime.PyNone);
disposeList.Add(pynone);
PyObject method = pyself.GetAttr(methodName, pynone);
disposeList.Add(method);
if (method.Handle != Runtime.PyNone)
{
// if the method hasn't been overriden then it will be a managed object
ManagedType managedMethod = ManagedType.GetManagedObject(method.Handle);
if (null == managedMethod)
{
PyObject[] pyargs = new PyObject[args.Length];
for (int i = 0; i < args.Length; ++i)
{
pyargs[i] = new PyObject(Converter.ToPythonImplicit(args[i]));
disposeList.Add(pyargs[i]);
}
PyObject py_result = method.Invoke(pyargs);
disposeList.Add(py_result);
return((T)py_result.AsManagedObject(typeof(T)));
}
}
}
finally
{
foreach (PyObject x in disposeList)
{
if (x != null)
{
x.Dispose();
}
}
Runtime.PyGILState_Release(gs);
}
}
if (origMethodName == null)
{
throw new NullReferenceException("Python object does not have a '" + methodName + "' method");
}
return((T)obj.GetType().InvokeMember(origMethodName,
BindingFlags.InvokeMethod,
null,
obj,
args));
}
internal static IntPtr ToPython(Object value, Type type)
{
IntPtr result = IntPtr.Zero;
// Null always converts to None in Python.
if (value == null)
{
result = Runtime.PyNone;
Runtime.Incref(result);
return(result);
}
// it the type is a python subclass of a managed type then return the
// underying python object rather than construct a new wrapper object.
IPythonDerivedType pyderived = value as IPythonDerivedType;
if (null != pyderived)
{
return(ClassDerivedObject.ToPython(pyderived));
}
// hmm - from Python, we almost never care what the declared
// type is. we'd rather have the object bound to the actual
// implementing class.
type = value.GetType();
TypeCode tc = Type.GetTypeCode(type);
switch (tc)
{
case TypeCode.Object:
result = CLRObject.GetInstHandle(value, type);
// XXX - hack to make sure we convert new-style class based
// managed exception instances to wrappers ;(
if (Runtime.wrap_exceptions)
{
Exception e = value as Exception;
if (e != null)
{
return(Exceptions.GetExceptionInstanceWrapper(result));
}
}
return(result);
case TypeCode.String:
return(Runtime.PyUnicode_FromString((string)value));
case TypeCode.Int32:
return(Runtime.PyInt_FromInt32((int)value));
case TypeCode.Boolean:
if ((bool)value)
{
Runtime.Incref(Runtime.PyTrue);
return(Runtime.PyTrue);
}
Runtime.Incref(Runtime.PyFalse);
return(Runtime.PyFalse);
case TypeCode.Byte:
return(Runtime.PyInt_FromInt32((int)((byte)value)));
case TypeCode.Char:
return(Runtime.PyUnicode_FromOrdinal((int)((char)value)));
case TypeCode.Int16:
return(Runtime.PyInt_FromInt32((int)((short)value)));
case TypeCode.Int64:
return(Runtime.PyLong_FromLongLong((long)value));
case TypeCode.Single:
// return Runtime.PyFloat_FromDouble((double)((float)value));
string ss = ((float)value).ToString(nfi);
IntPtr ps = Runtime.PyString_FromString(ss);
IntPtr op = Runtime.PyFloat_FromString(ps, IntPtr.Zero);
Runtime.Decref(ps);
return(op);
case TypeCode.Double:
return(Runtime.PyFloat_FromDouble((double)value));
case TypeCode.SByte:
return(Runtime.PyInt_FromInt32((int)((sbyte)value)));
case TypeCode.UInt16:
return(Runtime.PyInt_FromInt32((int)((ushort)value)));
case TypeCode.UInt32:
return(Runtime.PyLong_FromUnsignedLong((uint)value));
case TypeCode.UInt64:
return(Runtime.PyLong_FromUnsignedLongLong((ulong)value));
default:
if (value is IEnumerable)
{
using (var resultlist = new PyList())
{
foreach (object o in (IEnumerable)value)
{
using (var p = new PyObject(ToPython(o, o.GetType())))
resultlist.Append(p);
}
Runtime.Incref(resultlist.Handle);
return(resultlist.Handle);
}
}
result = CLRObject.GetInstHandle(value, type);
return(result);
}
}
