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); }