|
static private ToPython ( Object value, |
||
| value | Object | |
| type | ||
| return | ||
public static PyObject ToPython(this object o)
{
return(new PyObject(Converter.ToPython(o, o?.GetType())));
}
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);
}
}
internal static IntPtr CreateSubType(IntPtr py_name, IntPtr py_base_type, IntPtr py_dict)
{
// Utility to create a subtype of a managed type with the ability for the
// a python subtype able to override the managed implementation
string name = Runtime.GetManagedString(py_name);
// the derived class can have class attributes __assembly__ and __module__ which
// control the name of the assembly and module the new type is created in.
object assembly = null;
object namespaceStr = null;
var disposeList = new List <PyObject>();
try
{
var assemblyKey = new PyObject(Converter.ToPython("__assembly__", typeof(string)));
disposeList.Add(assemblyKey);
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))
{
throw new InvalidCastException("Couldn't convert __assembly__ value to string");
}
}
var namespaceKey = new PyObject(Converter.ToPythonImplicit("__namespace__"));
disposeList.Add(namespaceKey);
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))
{
throw new InvalidCastException("Couldn't convert __namespace__ value to string");
}
}
}
finally
{
foreach (PyObject o in disposeList)
{
o.Dispose();
}
}
// create the new managed type subclassing the base managed type
var baseClass = ManagedType.GetManagedObject(py_base_type) as ClassBase;
if (null == baseClass)
{
return(Exceptions.RaiseTypeError("invalid base class, expected CLR class type"));
}
try
{
Type subType = ClassDerivedObject.CreateDerivedType(name,
baseClass.type,
py_dict,
(string)namespaceStr,
(string)assembly);
// create the new ManagedType and python type
ClassBase subClass = ClassManager.GetClass(subType);
IntPtr py_type = GetTypeHandle(subClass, subType);
// by default the class dict will have all the C# methods in it, but as this is a
// derived class we want the python overrides in there instead if they exist.
IntPtr cls_dict = Marshal.ReadIntPtr(py_type, TypeOffset.tp_dict);
Runtime.PyDict_Update(cls_dict, py_dict);
Runtime.XIncref(py_type);
// 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)
{
return(Exceptions.RaiseTypeError(e.Message));
}
}
internal virtual IntPtr Invoke(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, MethodInfo[] methodinfo)
{
// No valid methods, nothing to bind.
if (GetMethods().Length == 0)
{
var msg = new StringBuilder("The underlying C# method(s) have been deleted");
if (list.Count > 0 && list[0].Name != null)
{
msg.Append($": {list[0]}");
}
return(Exceptions.RaiseTypeError(msg.ToString()));
}
Binding binding = Bind(inst, args, kw, info, methodinfo);
object result;
IntPtr ts = IntPtr.Zero;
if (binding == null)
{
var value = new StringBuilder("No method matches given arguments");
if (methodinfo != null && methodinfo.Length > 0)
{
value.Append($" for {methodinfo[0].Name}");
}
else if (list.Count > 0 && list[0].Valid)
{
value.Append($" for {list[0].Value.Name}");
}
value.Append(": ");
AppendArgumentTypes(to: value, args);
Exceptions.RaiseTypeError(value.ToString());
return(IntPtr.Zero);
}
if (allow_threads)
{
ts = PythonEngine.BeginAllowThreads();
}
try
{
result = binding.info.Invoke(binding.inst, BindingFlags.Default, null, binding.args, null);
}
catch (Exception e)
{
if (e.InnerException != null)
{
e = e.InnerException;
}
if (allow_threads)
{
PythonEngine.EndAllowThreads(ts);
}
Exceptions.SetError(e);
return(IntPtr.Zero);
}
if (allow_threads)
{
PythonEngine.EndAllowThreads(ts);
}
// If there are out parameters, we return a tuple containing
// the result, if any, followed by the out parameters. If there is only
// one out parameter and the return type of the method is void,
// we return the out parameter as the result to Python (for
// code compatibility with ironpython).
var mi = (MethodInfo)binding.info;
if (binding.outs > 0)
{
ParameterInfo[] pi = mi.GetParameters();
int c = pi.Length;
var n = 0;
bool isVoid = mi.ReturnType == typeof(void);
int tupleSize = binding.outs + (isVoid ? 0 : 1);
IntPtr t = Runtime.PyTuple_New(tupleSize);
if (!isVoid)
{
IntPtr v = Converter.ToPython(result, mi.ReturnType);
Runtime.PyTuple_SetItem(t, n, v);
n++;
}
for (var i = 0; i < c; i++)
{
Type pt = pi[i].ParameterType;
if (pt.IsByRef)
{
IntPtr v = Converter.ToPython(binding.args[i], pt.GetElementType());
Runtime.PyTuple_SetItem(t, n, v);
n++;
}
}
if (binding.outs == 1 && mi.ReturnType == typeof(void))
{
IntPtr v = Runtime.PyTuple_GetItem(t, 0);
Runtime.XIncref(v);
Runtime.XDecref(t);
return(v);
}
return(t);
}
return(Converter.ToPython(result, mi.ReturnType));
}
internal virtual IntPtr Invoke(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, MethodInfo[] methodinfo)
{
Binding binding = Bind(inst, args, kw, info, methodinfo);
object result;
IntPtr ts = IntPtr.Zero;
if (binding == null)
{
var value = new StringBuilder("No method matches given arguments");
if (methodinfo != null && methodinfo.Length > 0)
{
value.Append($" for {methodinfo[0].Name}");
}
long argCount = Runtime.PyTuple_Size(args);
value.Append(": (");
for (long argIndex = 0; argIndex < argCount; argIndex++)
{
var arg = Runtime.PyTuple_GetItem(args, argIndex);
if (arg != IntPtr.Zero)
{
var type = Runtime.PyObject_Type(arg);
if (type != IntPtr.Zero)
{
try {
var description = Runtime.PyObject_Unicode(type);
if (description != IntPtr.Zero)
{
value.Append(Runtime.GetManagedString(description));
Runtime.XDecref(description);
}
} finally {
Runtime.XDecref(type);
}
}
}
if (argIndex + 1 < argCount)
{
value.Append(", ");
}
}
value.Append(')');
Exceptions.SetError(Exceptions.TypeError, value.ToString());
return(IntPtr.Zero);
}
if (allow_threads)
{
ts = PythonEngine.BeginAllowThreads();
}
try
{
result = binding.info.Invoke(binding.inst, BindingFlags.Default, null, binding.args, null);
}
catch (Exception e)
{
if (e.InnerException != null)
{
e = e.InnerException;
}
if (allow_threads)
{
PythonEngine.EndAllowThreads(ts);
}
Exceptions.SetError(e);
return(IntPtr.Zero);
}
if (allow_threads)
{
PythonEngine.EndAllowThreads(ts);
}
// If there are out parameters, we return a tuple containing
// the result followed by the out parameters. If there is only
// one out parameter and the return type of the method is void,
// we return the out parameter as the result to Python (for
// code compatibility with ironpython).
var mi = (MethodInfo)binding.info;
if (binding.outs == 1 && mi.ReturnType == typeof(void))
{
}
if (binding.outs > 0)
{
ParameterInfo[] pi = mi.GetParameters();
int c = pi.Length;
var n = 0;
IntPtr t = Runtime.PyTuple_New(binding.outs + 1);
IntPtr v = Converter.ToPython(result, mi.ReturnType);
Runtime.PyTuple_SetItem(t, n, v);
n++;
for (var i = 0; i < c; i++)
{
Type pt = pi[i].ParameterType;
if (pi[i].IsOut || pt.IsByRef)
{
v = Converter.ToPython(binding.args[i], pt);
Runtime.PyTuple_SetItem(t, n, v);
n++;
}
}
if (binding.outs == 1 && mi.ReturnType == typeof(void))
{
v = Runtime.PyTuple_GetItem(t, 1);
Runtime.XIncref(v);
Runtime.XDecref(t);
return(v);
}
return(t);
}
return(Converter.ToPython(result, mi.ReturnType));
}
internal virtual IntPtr Invoke(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, MethodInfo[] methodinfo)
{
Binding binding = Bind(inst, args, kw, info, methodinfo);
object result;
IntPtr ts = IntPtr.Zero;
if (binding == null)
{
Exceptions.SetError(Exceptions.TypeError, "No method matches given arguments");
return(IntPtr.Zero);
}
if (allow_threads)
{
ts = PythonEngine.BeginAllowThreads();
}
try
{
result = binding.info.Invoke(binding.inst, BindingFlags.Default, null, binding.args, null);
}
catch (Exception e)
{
if (e.InnerException != null)
{
e = e.InnerException;
}
if (allow_threads)
{
PythonEngine.EndAllowThreads(ts);
}
Exceptions.SetError(e);
return(IntPtr.Zero);
}
if (allow_threads)
{
PythonEngine.EndAllowThreads(ts);
}
// If there are out parameters, we return a tuple containing
// the result followed by the out parameters. If there is only
// one out parameter and the return type of the method is void,
// we return the out parameter as the result to Python (for
// code compatibility with ironpython).
var mi = (MethodInfo)binding.info;
if (binding.outs == 1 && mi.ReturnType == typeof(void))
{
}
if (binding.outs > 0)
{
ParameterInfo[] pi = mi.GetParameters();
int c = pi.Length;
var n = 0;
IntPtr t = Runtime.PyTuple_New(binding.outs + 1);
IntPtr v = Converter.ToPython(result, mi.ReturnType);
Runtime.PyTuple_SetItem(t, n, v);
n++;
for (var i = 0; i < c; i++)
{
Type pt = pi[i].ParameterType;
if (pi[i].IsOut || pt.IsByRef)
{
v = Converter.ToPython(binding.args[i], pt);
Runtime.PyTuple_SetItem(t, n, v);
n++;
}
}
if (binding.outs == 1 && mi.ReturnType == typeof(void))
{
v = Runtime.PyTuple_GetItem(t, 1);
Runtime.XIncref(v);
Runtime.XDecref(t);
return(v);
}
return(t);
}
return(Converter.ToPython(result, mi.ReturnType));
}
private object?TrueDispatch(object?[] args)
{
MethodInfo method = dtype.GetMethod("Invoke");
ParameterInfo[] pi = method.GetParameters();
Type rtype = method.ReturnType;
NewReference callResult;
using (var pyargs = Runtime.PyTuple_New(pi.Length))
{
for (var i = 0; i < pi.Length; i++)
{
// Here we own the reference to the Python value, and we
// give the ownership to the arg tuple.
using var arg = Converter.ToPython(args[i], pi[i].ParameterType);
int res = Runtime.PyTuple_SetItem(pyargs.Borrow(), i, arg.StealOrThrow());
if (res != 0)
{
throw PythonException.ThrowLastAsClrException();
}
}
callResult = Runtime.PyObject_Call(target, pyargs.Borrow(), null);
}
if (callResult.IsNull())
{
throw PythonException.ThrowLastAsClrException();
}
using (callResult)
{
BorrowedReference op = callResult.Borrow();
int byRefCount = pi.Count(parameterInfo => parameterInfo.ParameterType.IsByRef);
if (byRefCount > 0)
{
// By symmetry with MethodBinder.Invoke, when there are out
// parameters we expect to receive a tuple containing
// the result, if any, followed by the out parameters. If there is only
// one out parameter and the return type of the method is void,
// we instead receive the out parameter as the result from Python.
bool isVoid = rtype == typeof(void);
int tupleSize = byRefCount + (isVoid ? 0 : 1);
if (isVoid && byRefCount == 1)
{
// The return type is void and there is a single out parameter.
for (int i = 0; i < pi.Length; i++)
{
Type t = pi[i].ParameterType;
if (t.IsByRef)
{
if (!Converter.ToManaged(op, t, out args[i], true))
{
Exceptions.RaiseTypeError($"The Python function did not return {t.GetElementType()} (the out parameter type)");
throw PythonException.ThrowLastAsClrException();
}
break;
}
}
return(null);
}
else if (Runtime.PyTuple_Check(op) && Runtime.PyTuple_Size(op) == tupleSize)
{
int index = isVoid ? 0 : 1;
for (int i = 0; i < pi.Length; i++)
{
Type t = pi[i].ParameterType;
if (t.IsByRef)
{
BorrowedReference item = Runtime.PyTuple_GetItem(op, index++);
if (!Converter.ToManaged(item, t, out args[i], true))
{
Exceptions.RaiseTypeError($"The Python function returned a tuple where element {i} was not {t.GetElementType()} (the out parameter type)");
throw PythonException.ThrowLastAsClrException();
}
}
}
if (isVoid)
{
return(null);
}
BorrowedReference item0 = Runtime.PyTuple_GetItem(op, 0);
if (!Converter.ToManaged(item0, rtype, out object?result0, true))
{
Exceptions.RaiseTypeError($"The Python function returned a tuple where element 0 was not {rtype} (the return type)");
throw PythonException.ThrowLastAsClrException();
}
return(result0);
}
else
{
string tpName = Runtime.PyObject_GetTypeName(op);
if (Runtime.PyTuple_Check(op))
{
tpName += $" of size {Runtime.PyTuple_Size(op)}";
}
StringBuilder sb = new StringBuilder();
if (!isVoid)
{
sb.Append(rtype.FullName);
}
for (int i = 0; i < pi.Length; i++)
{
Type t = pi[i].ParameterType;
if (t.IsByRef)
{
if (sb.Length > 0)
{
sb.Append(",");
}
sb.Append(t.GetElementType().FullName);
}
}
string returnValueString = isVoid ? "" : "the return value and ";
Exceptions.RaiseTypeError($"Expected a tuple ({sb}) of {returnValueString}the values for out and ref parameters, got {tpName}.");
throw PythonException.ThrowLastAsClrException();
}
}
if (rtype == typeof(void))
{
return(null);
}
if (!Converter.ToManaged(op, rtype, out object?result, true))
{
throw PythonException.ThrowLastAsClrException();
}
return(result);
}
}
/// <summary>
/// Implements __getitem__ for array types.
/// </summary>
public static IntPtr mp_subscript(IntPtr ob, IntPtr idx)
{
var obj = (CLRObject)GetManagedObject(ob);
var items = obj.inst as Array;
Type itemType = obj.inst.GetType().GetElementType();
int rank = items.Rank;
int index;
object value;
// Note that CLR 1.0 only supports int indexes - methods to
// support long indices were introduced in 1.1. We could
// support long indices automatically, but given that long
// indices are not backward compatible and a relative edge
// case, we won't bother for now.
// Single-dimensional arrays are the most common case and are
// cheaper to deal with than multi-dimensional, so check first.
if (rank == 1)
{
index = Runtime.PyInt_AsLong(idx);
if (Exceptions.ErrorOccurred())
{
return(Exceptions.RaiseTypeError("invalid index value"));
}
if (index < 0)
{
index = items.Length + index;
}
try
{
value = items.GetValue(index);
}
catch (IndexOutOfRangeException)
{
Exceptions.SetError(Exceptions.IndexError, "array index out of range");
return(IntPtr.Zero);
}
return(Converter.ToPython(value, itemType));
}
// Multi-dimensional arrays can be indexed a la: list[1, 2, 3].
if (!Runtime.PyTuple_Check(idx))
{
Exceptions.SetError(Exceptions.TypeError, "invalid index value");
return(IntPtr.Zero);
}
int count = Runtime.PyTuple_Size(idx);
var args = new int[count];
for (var i = 0; i < count; i++)
{
IntPtr op = Runtime.PyTuple_GetItem(idx, i);
index = Runtime.PyInt_AsLong(op);
if (Exceptions.ErrorOccurred())
{
return(Exceptions.RaiseTypeError("invalid index value"));
}
if (index < 0)
{
index = items.GetLength(i) + index;
}
args.SetValue(index, i);
}
try
{
value = items.GetValue(args);
}
catch (IndexOutOfRangeException)
{
Exceptions.SetError(Exceptions.IndexError, "array index out of range");
return(IntPtr.Zero);
}
return(Converter.ToPython(value, itemType));
}
/// <summary>
/// Descriptor __get__ implementation. This method returns the
/// value of the field on the given object. The returned value
/// is converted to an appropriately typed Python object.
/// </summary>
public static IntPtr tp_descr_get(IntPtr ds, IntPtr ob, IntPtr tp)
{
var self = (FieldObject)GetManagedObject(ds);
object result;
if (self == null)
{
return(IntPtr.Zero);
}
else if (!self.info.Valid)
{
Exceptions.SetError(Exceptions.AttributeError, self.info.DeletedMessage);
return(IntPtr.Zero);
}
FieldInfo info = self.info.Value;
if (ob == IntPtr.Zero || ob == Runtime.PyNone)
{
if (!info.IsStatic)
{
Exceptions.SetError(Exceptions.TypeError,
"instance attribute must be accessed through a class instance");
return(IntPtr.Zero);
}
try
{
// Fasterflect does not support constant fields
if (info.IsLiteral && !info.IsInitOnly)
{
result = info.GetValue(null);
}
else
{
result = self.GetMemberGetter(info.DeclaringType)(info.DeclaringType);
}
return(Converter.ToPython(result, info.FieldType));
}
catch (Exception e)
{
Exceptions.SetError(Exceptions.TypeError, e.Message);
return(IntPtr.Zero);
}
}
try
{
var co = (CLRObject)GetManagedObject(ob);
if (co == null)
{
Exceptions.SetError(Exceptions.TypeError, "instance is not a clr object");
return(IntPtr.Zero);
}
// Fasterflect does not support constant fields
if (info.IsLiteral && !info.IsInitOnly)
{
result = info.GetValue(co.inst);
}
else
{
var type = co.inst.GetType();
result = self.GetMemberGetter(type)(self.IsValueType(type) ? co.inst.WrapIfValueType() : co.inst);
}
return(Converter.ToPython(result, info.FieldType));
}
catch (Exception e)
{
Exceptions.SetError(Exceptions.TypeError, e.Message);
return(IntPtr.Zero);
}
}
/// <summary>
/// Descriptor __get__ implementation. This method returns the
/// value of the property on the given object. The returned value
/// is converted to an appropriately typed Python object.
/// </summary>
public static IntPtr tp_descr_get(IntPtr ds, IntPtr ob, IntPtr tp)
{
var self = (PropertyObject)GetManagedObject(ds);
MethodInfo getter = self.getter;
object result;
IntPtr ts = IntPtr.Zero;
if (getter == null)
{
return(Exceptions.RaiseTypeError("property cannot be read"));
}
if (ob == IntPtr.Zero || ob == Runtime.PyNone)
{
if (!getter.IsStatic)
{
Exceptions.SetError(Exceptions.TypeError,
"instance property must be accessed through a class instance");
return(IntPtr.Zero);
}
ts = PythonEngine.BeginAllowThreads();
try
{
result = self.info.GetValue(null, null);
PythonEngine.EndAllowThreads(ts);
return(Converter.ToPython(result, self.info.PropertyType));
}
catch (Exception e)
{
PythonEngine.EndAllowThreads(ts);
return(Exceptions.RaiseTypeError(e.Message));
}
}
var co = GetManagedObject(ob) as CLRObject;
if (co == null)
{
return(Exceptions.RaiseTypeError("invalid target"));
}
ts = PythonEngine.BeginAllowThreads();
try
{
result = self.info.GetValue(co.inst, null);
PythonEngine.EndAllowThreads(ts);
return(Converter.ToPython(result, self.info.PropertyType));
}
catch (Exception e)
{
if (e.InnerException != null)
{
e = e.InnerException;
}
PythonEngine.EndAllowThreads(ts);
Exceptions.SetError(e);
return(IntPtr.Zero);
}
}
/// <summary>
/// Descriptor __get__ implementation. This method returns the
/// value of the property on the given object. The returned value
/// is converted to an appropriately typed Python object.
/// </summary>
public static IntPtr tp_descr_get(IntPtr ds, IntPtr ob, IntPtr tp)
{
var self = (PropertyObject)GetManagedObject(ds);
if (!self.info.Valid)
{
return(Exceptions.RaiseTypeError(self.info.DeletedMessage));
}
var info = self.info.Value;
MethodInfo getter = self.getter.UnsafeValue;
object result;
if (getter == null)
{
return(Exceptions.RaiseTypeError("property cannot be read"));
}
if (ob == IntPtr.Zero || ob == Runtime.PyNone)
{
if (!getter.IsStatic)
{
Exceptions.SetError(Exceptions.TypeError,
"instance property must be accessed through a class instance");
return(IntPtr.Zero);
}
try
{
result = self.GetMemberGetter(info.DeclaringType)(info.DeclaringType);
return(Converter.ToPython(result, info.PropertyType));
}
catch (Exception e)
{
return(Exceptions.RaiseTypeError(e.Message));
}
}
var co = GetManagedObject(ob) as CLRObject;
if (co == null)
{
return(Exceptions.RaiseTypeError("invalid target"));
}
try
{
var type = co.inst.GetType();
result = self.GetMemberGetter(type)(self.IsValueType(type) ? co.inst.WrapIfValueType() : co.inst);
return(Converter.ToPython(result, info.PropertyType));
}
catch (Exception e)
{
if (e.InnerException != null)
{
e = e.InnerException;
}
Exceptions.SetError(e);
return(IntPtr.Zero);
}
}