| private PyObject_GetAttr ( IntPtr pointer, IntPtr name ) : IntPtr | ||
| pointer | IntPtr | |
| name | IntPtr | |
| 리턴 | IntPtr | |
/// <summary>
/// SetError Method
/// </summary>
/// <remarks>
/// Sets the current Python exception given a CLR exception
/// object. The CLR exception instance is wrapped as a Python
/// object, allowing it to be handled naturally from Python.
/// </remarks>
public static void SetError(Exception e)
{
// Because delegates allow arbitrary nesting of Python calling
// managed calling Python calling... etc. it is possible that we
// might get a managed exception raised that is a wrapper for a
// Python exception. In that case we'd rather have the real thing.
var pe = e as PythonException;
if (pe != null)
{
Runtime.XIncref(pe.PyType);
Runtime.XIncref(pe.PyValue);
Runtime.XIncref(pe.PyTB);
Runtime.PyErr_Restore(pe.PyType, pe.PyValue, pe.PyTB);
return;
}
IntPtr op = CLRObject.GetInstHandle(e);
IntPtr etype = Runtime.PyObject_GetAttr(op, PyIdentifier.__class__);
Runtime.PyErr_SetObject(new BorrowedReference(etype), new BorrowedReference(op));
Runtime.XDecref(etype);
Runtime.XDecref(op);
}
/// <summary>
/// GetAttr Method
/// </summary>
/// <remarks>
/// Returns the named attribute of the Python object or raises a
/// PythonException if the attribute access fails. The name argument
/// is a PyObject wrapping a Python string or unicode object.
/// </remarks>
public PyObject GetAttr(PyObject name)
{
IntPtr op = Runtime.PyObject_GetAttr(obj, name.obj);
if (op == IntPtr.Zero)
{
throw new PythonException();
}
return(new PyObject(op));
}
/// <summary>
/// GetAttr Method
/// </summary>
/// <remarks>
/// Returns the named attribute of the Python object, or the given
/// default object if the attribute access fails. The name argument
/// is a PyObject wrapping a Python string or unicode object.
/// </remarks>
public PyObject GetAttr(PyObject name, PyObject _default)
{
IntPtr op = Runtime.PyObject_GetAttr(obj, name.obj);
if (op == IntPtr.Zero)
{
Runtime.PyErr_Clear();
return(_default);
}
return(new PyObject(op));
}
public override ValueType Execute(ValueType arg)
{
const string code = @"
from Python.EmbeddingTest.Domain import MyClass
def test_obj_call():
obj = MyClass()
obj.Method()
obj.StaticMethod()
obj.Property = 1
obj.Field = 10
test_obj_call()
";
const string name = "test_domain_reload_mod";
using (Py.GIL())
{
// Create a new module
IntPtr module = PyRuntime.PyModule_New(name);
Assert.That(module != IntPtr.Zero);
IntPtr globals = PyRuntime.PyObject_GetAttr(module, PyIdentifier.__dict__);
Assert.That(globals != IntPtr.Zero);
try
{
// import builtins
// module.__dict__[__builtins__] = builtins
int res = PyRuntime.PyDict_SetItem(globals, PyIdentifier.__builtins__,
PyRuntime.PyEval_GetBuiltins());
PythonException.ThrowIfIsNotZero(res);
// Execute the code in the module's scope
PythonEngine.Exec(code, globals);
// import sys
// modules = sys.modules
IntPtr modules = PyRuntime.PyImport_GetModuleDict();
// modules[name] = module
res = PyRuntime.PyDict_SetItemString(modules, name, module);
PythonException.ThrowIfIsNotZero(res);
}
catch
{
PyRuntime.XDecref(module);
throw;
}
finally
{
PyRuntime.XDecref(globals);
}
return(module);
}
}
/// <summary>
/// GetAttr Method
/// </summary>
/// <remarks>
/// Returns the named attribute of the Python object or raises a
/// PythonException if the attribute access fails. The name argument
/// is a PyObject wrapping a Python string or unicode object.
/// </remarks>
public PyObject GetAttr(PyObject name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
IntPtr op = Runtime.PyObject_GetAttr(obj, name.obj);
if (op == IntPtr.Zero)
{
throw new PythonException();
}
return(new PyObject(op));
}
/// <summary>
/// GetAttr Method
/// </summary>
/// <remarks>
/// Returns the named attribute of the Python object, or the given
/// default object if the attribute access fails. The name argument
/// is a PyObject wrapping a Python string or unicode object.
/// </remarks>
public PyObject GetAttr(PyObject name, PyObject _default)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
IntPtr op = Runtime.PyObject_GetAttr(obj, name.obj);
if (op == IntPtr.Zero)
{
Runtime.PyErr_Clear();
return(_default);
}
return(new PyObject(op));
}
/// <summary>
/// Initialize just the __import__ hook itself.
/// </summary>
static void InitImport()
{
// We replace the built-in Python __import__ with our own: first
// look in CLR modules, then if we don't find any call the default
// Python __import__.
IntPtr builtins = Runtime.GetBuiltins();
py_import = Runtime.PyObject_GetAttr(builtins, PyIdentifier.__import__);
PythonException.ThrowIfIsNull(py_import);
hook = new MethodWrapper(typeof(ImportHook), "__import__", "TernaryFunc");
int res = Runtime.PyObject_SetAttr(builtins, PyIdentifier.__import__, hook.ptr);
PythonException.ThrowIfIsNotZero(res);
Runtime.XDecref(builtins);
}
/// <summary>
/// Initializes given object, or returns <c>false</c> and sets Python error on failure
/// </summary>
public virtual bool Init(BorrowedReference obj, BorrowedReference args, BorrowedReference kw)
{
// this just calls obj.__init__(*args, **kw)
using var init = Runtime.PyObject_GetAttr(obj, PyIdentifier.__init__);
Runtime.PyErr_Clear();
if (!init.IsNull())
{
using var result = Runtime.PyObject_Call(init.Borrow(), args, kw);
if (result.IsNull())
{
return(false);
}
}
return(true);
}
public static IntPtr tp_repr(IntPtr ob)
{
var co = GetManagedObject(ob) as CLRObject;
if (co == null)
{
return(Exceptions.RaiseTypeError("invalid object"));
}
try
{
//if __repr__ is defined, use it
var instType = co.inst.GetType();
System.Reflection.MethodInfo methodInfo = instType.GetMethod("__repr__");
if (methodInfo != null && methodInfo.IsPublic)
{
var reprString = methodInfo.Invoke(co.inst, null) as string;
return(Runtime.PyString_FromString(reprString));
}
//otherwise use the standard object.__repr__(inst)
IntPtr args = Runtime.PyTuple_New(1);
Runtime.XIncref(ob);
Runtime.PyTuple_SetItem(args, 0, ob);
IntPtr reprFunc = Runtime.PyObject_GetAttr(Runtime.PyBaseObjectType, PyIdentifier.__repr__);
var output = Runtime.PyObject_Call(reprFunc, args, IntPtr.Zero);
Runtime.XDecref(args);
Runtime.XDecref(reprFunc);
return(output);
}
catch (Exception e)
{
if (e.InnerException != null)
{
e = e.InnerException;
}
Exceptions.SetError(e);
return(IntPtr.Zero);
}
}
private static IntPtr CallInit(IntPtr obj, IntPtr args, IntPtr kw)
{
var init = Runtime.PyObject_GetAttr(obj, PyIdentifier.__init__);
Runtime.PyErr_Clear();
if (init != IntPtr.Zero)
{
IntPtr result = Runtime.PyObject_Call(init, args, kw);
Runtime.XDecref(init);
if (result == IntPtr.Zero)
{
Runtime.XDecref(obj);
return(IntPtr.Zero);
}
Runtime.XDecref(result);
}
return(obj);
}
/// <summary>
/// Restore the __import__ hook.
/// </summary>
static void RestoreImport()
{
IntPtr builtins = Runtime.GetBuiltins();
IntPtr existing = Runtime.PyObject_GetAttr(builtins, PyIdentifier.__import__);
Runtime.XDecref(existing);
if (existing != hook.ptr)
{
throw new NotSupportedException("Unable to restore original __import__.");
}
int res = Runtime.PyObject_SetAttr(builtins, PyIdentifier.__import__, py_import);
PythonException.ThrowIfIsNotZero(res);
Runtime.XDecref(py_import);
py_import = IntPtr.Zero;
hook.Release();
hook = null;
Runtime.XDecref(builtins);
}
/// <summary>
/// Metatype __call__ implementation. This is needed to ensure correct
/// initialization (__init__ support), because the tp_call we inherit
/// from PyType_Type won't call __init__ for metatypes it doesn't know.
/// </summary>
public static IntPtr tp_call(IntPtr tp, IntPtr args, IntPtr kw)
{
IntPtr func = Marshal.ReadIntPtr(tp, TypeOffset.tp_new);
if (func == IntPtr.Zero)
{
return(Exceptions.RaiseTypeError("invalid object"));
}
IntPtr obj = NativeCall.Call_3(func, tp, args, kw);
if (obj == IntPtr.Zero)
{
return(IntPtr.Zero);
}
var init = Runtime.PyObject_GetAttr(obj, PyIdentifier.__init__);
Runtime.PyErr_Clear();
if (init != IntPtr.Zero)
{
IntPtr result = Runtime.PyObject_Call(init, args, kw);
Runtime.XDecref(init);
if (result == IntPtr.Zero)
{
Runtime.XDecref(obj);
return(IntPtr.Zero);
}
Runtime.XDecref(result);
}
return(obj);
}
