/// <summary> /// PyList Constructor /// </summary> /// <remarks> /// Creates a new empty Python list object. /// </remarks> public PyList() : base(Runtime.PyList_New(0)) { if (obj == IntPtr.Zero) { throw PythonException.ThrowLastAsClrException(); } }
protected override void OnSave(InterDomainContext context) { base.OnSave(context); System.Diagnostics.Debug.Assert(dict == GetObjectDict(pyHandle)); foreach (var attr in cache.Values) { Runtime.XIncref(attr.pyHandle); } // Decref twice in tp_clear, equilibrate them. Runtime.XIncref(dict); Runtime.XIncref(dict); // destroy the cache(s) foreach (var pair in cache) { if ((Runtime.PyDict_DelItemString(DictRef, pair.Key) == -1) && (Exceptions.ExceptionMatches(Exceptions.KeyError))) { // Trying to remove a key that's not in the dictionary // raises an error. We don't care about it. Runtime.PyErr_Clear(); } else if (Exceptions.ErrorOccurred()) { throw PythonException.ThrowLastAsClrException(); } pair.Value.DecrRefCount(); } cache.Clear(); }
/// <summary> /// AsTuple Method /// </summary> /// <remarks> /// Convert a Python object to a Python tuple if possible, raising /// a PythonException if the conversion is not possible. This is /// equivalent to the Python expression "tuple(object)". /// </remarks> public static PyTuple AsTuple(PyObject value) { IntPtr op = Runtime.PySequence_Tuple(value.obj); PythonException.ThrowIfIsNull(op); return(new PyTuple(op)); }
private static IntPtr FromString(string s) { IntPtr val = Runtime.PyString_FromString(s); PythonException.ThrowIfIsNull(val); return(val); }
private static IntPtr FromDouble(double value) { IntPtr val = Runtime.PyLong_FromDouble(value); PythonException.ThrowIfIsNull(val); return(val); }
/// <summary> /// Reloads the module, and returns the updated object /// </summary> public PyModule Reload() { NewReference op = Runtime.PyImport_ReloadModule(this.Reference); PythonException.ThrowIfIsNull(op); return(new PyModule(ref op)); }
/// <summary> /// Shortcut for (pointer == NULL) -> throw PythonException /// </summary> /// <param name="pointer">Pointer to a Python object</param> internal static void ErrorCheck(BorrowedReference pointer) { if (pointer.IsNull) { throw PythonException.ThrowLastAsClrException(); } }
/// <summary> /// Set the 'args' slot on a python exception object that wraps /// a CLR exception. This is needed for pickling CLR exceptions as /// BaseException_reduce will only check the slots, bypassing the /// __getattr__ implementation, and thus dereferencing a NULL /// pointer. /// </summary> internal static void SetArgsAndCause(BorrowedReference ob, Exception e) { IntPtr args; if (!string.IsNullOrEmpty(e.Message)) { args = Runtime.PyTuple_New(1); IntPtr msg = Runtime.PyString_FromString(e.Message); Runtime.PyTuple_SetItem(args, 0, msg); } else { args = Runtime.PyTuple_New(0); } using var argsTuple = NewReference.DangerousFromPointer(args); if (Runtime.PyObject_SetAttrString(ob, "args", argsTuple) != 0) { throw PythonException.ThrowLastAsClrException(); } if (e.InnerException != null) { // Note: For an AggregateException, InnerException is only the first of the InnerExceptions. using var cause = CLRObject.GetReference(e.InnerException); Runtime.PyException_SetCause(ob, cause.Steal()); } }
/// <summary> /// Shortcut for (pointer == NULL or ErrorOccurred()) -> throw PythonException /// </summary> internal static void ErrorOccurredCheck(IntPtr pointer) { if (pointer == IntPtr.Zero || ErrorOccurred()) { throw PythonException.ThrowLastAsClrException(); } }
private static IntPtr FromLong(long value) { IntPtr val = Runtime.PyInt_FromInt64(value); PythonException.ThrowIfIsNull(val); return(val); }
private static IntPtr FromInt(int value) { IntPtr val = Runtime.PyLong_FromLong(value); PythonException.ThrowIfIsNull(val); return(val); }
private void Exec(string code, BorrowedReference _globals, BorrowedReference _locals) { using NewReference reference = Runtime.PyRun_String( code, RunFlagType.File, _globals, _locals ); PythonException.ThrowIfIsNull(reference); }
private static IntPtr FromULong(ulong value) { IntPtr val = Runtime.PyLong_FromUnsignedLongLong(value); PythonException.ThrowIfIsNull(val); return(val); }
static void SetupImportHook() { // Create the import hook module using var import_hook_module = Runtime.PyModule_New("clr.loader"); BorrowedReference mod_dict = Runtime.PyModule_GetDict(import_hook_module.BorrowOrThrow()); Debug.Assert(mod_dict != null); // Run the python code to create the module's classes. var builtins = Runtime.PyEval_GetBuiltins(); var exec = Runtime.PyDict_GetItemString(builtins, "exec"); using var args = Runtime.PyTuple_New(2); PythonException.ThrowIfIsNull(args); using var codeStr = Runtime.PyString_FromString(LoaderCode); Runtime.PyTuple_SetItem(args.Borrow(), 0, codeStr.StealOrThrow()); // reference not stolen due to overload incref'ing for us. Runtime.PyTuple_SetItem(args.Borrow(), 1, mod_dict); Runtime.PyObject_Call(exec, args.Borrow(), default).Dispose(); // Set as a sub-module of clr. if (Runtime.PyModule_AddObject(ClrModuleReference, "loader", import_hook_module.Steal()) != 0) { throw PythonException.ThrowLastAsClrException(); } // Finally, add the hook to the meta path var findercls = Runtime.PyDict_GetItemString(mod_dict, "DotNetFinder"); using var finderCtorArgs = Runtime.PyTuple_New(0); using var finder_inst = Runtime.PyObject_CallObject(findercls, finderCtorArgs.Borrow()); var metapath = Runtime.PySys_GetObject("meta_path"); PythonException.ThrowIfIsNotZero(Runtime.PyList_Append(metapath, finder_inst.BorrowOrThrow())); }
private static IntPtr FromString(string s) { IntPtr val = Runtime.PyUnicode_FromUnicode(s, s.Length); PythonException.ThrowIfIsNull(val); return(val); }
static void SetupImportHook() { // Create the import hook module var import_hook_module = Runtime.PyModule_New("clr.loader"); // Run the python code to create the module's classes. var builtins = Runtime.PyEval_GetBuiltins(); var exec = Runtime.PyDict_GetItemString(builtins, "exec"); using var args = NewReference.DangerousFromPointer(Runtime.PyTuple_New(2)); var codeStr = NewReference.DangerousFromPointer(Runtime.PyString_FromString(LoaderCode)); Runtime.PyTuple_SetItem(args, 0, codeStr); var mod_dict = Runtime.PyModule_GetDict(import_hook_module); // reference not stolen due to overload incref'ing for us. Runtime.PyTuple_SetItem(args, 1, mod_dict); Runtime.PyObject_Call(exec, args, default).Dispose(); // Set as a sub-module of clr. if (Runtime.PyModule_AddObject(ClrModuleReference, "loader", import_hook_module.DangerousGetAddress()) != 0) { Runtime.XDecref(import_hook_module.DangerousGetAddress()); throw PythonException.ThrowLastAsClrException(); } // Finally, add the hook to the meta path var findercls = Runtime.PyDict_GetItemString(mod_dict, "DotNetFinder"); var finderCtorArgs = NewReference.DangerousFromPointer(Runtime.PyTuple_New(0)); var finder_inst = Runtime.PyObject_CallObject(findercls, finderCtorArgs); var metapath = Runtime.PySys_GetObject("meta_path"); Runtime.PyList_Append(metapath, finder_inst); }
private static IntPtr FromString(string value) { IntPtr val = Runtime.PyLong_FromString(value, IntPtr.Zero, 0); PythonException.ThrowIfIsNull(val); return(val); }
/// <summary> /// AsLong Method /// </summary> /// <remarks> /// Convert a Python object to a Python long if possible, raising /// a PythonException if the conversion is not possible. This is /// equivalent to the Python expression "long(object)". /// </remarks> public static PyLong AsLong(PyObject value) { IntPtr op = Runtime.PyNumber_Long(value.obj); PythonException.ThrowIfIsNull(op); return(new PyLong(op)); }
/// <summary> /// TryGet Method /// </summary> /// <remarks> /// Returns the value of the variable, local variable first. /// If the variable does not exist, return null. /// </remarks> public bool TryGet(string name, out PyObject value) { Check(); using (var pyKey = new PyString(name)) { if (Runtime.PyMapping_HasKey(variables, pyKey.obj) != 0) { IntPtr op = Runtime.PyObject_GetItem(variables, pyKey.obj); if (op == IntPtr.Zero) { throw PythonException.ThrowLastAsClrException(); } if (op == Runtime.PyNone) { Runtime.XDecref(op); value = null; return(true); } value = new PyObject(op); return(true); } else { value = null; return(false); } } }
/// <summary> /// AsFloat Method /// </summary> /// <remarks> /// Convert a Python object to a Python float if possible, raising /// a PythonException if the conversion is not possible. This is /// equivalent to the Python expression "float(object)". /// </remarks> public static PyFloat AsFloat(PyObject value) { IntPtr op = Runtime.PyNumber_Float(value.obj); PythonException.ThrowIfIsNull(op); return(new PyFloat(op)); }
unsafe internal PyBuffer(PyObject exporter, PyBUF flags) { _view = new Py_buffer(); if (Runtime.PyObject_GetBuffer(exporter.Handle, ref _view, (int)flags) < 0) { throw PythonException.ThrowLastAsClrException(); } _exporter = exporter; var intPtrBuf = new IntPtr[_view.ndim]; if (_view.shape != IntPtr.Zero) { Marshal.Copy(_view.shape, intPtrBuf, 0, (int)_view.len * sizeof(IntPtr)); Shape = intPtrBuf.Select(x => (long)x).ToArray(); } if (_view.strides != IntPtr.Zero) { Marshal.Copy(_view.strides, intPtrBuf, 0, (int)_view.len * sizeof(IntPtr)); Strides = intPtrBuf.Select(x => (long)x).ToArray(); } if (_view.suboffsets != IntPtr.Zero) { Marshal.Copy(_view.suboffsets, intPtrBuf, 0, (int)_view.len * sizeof(IntPtr)); SubOffsets = intPtrBuf.Select(x => (long)x).ToArray(); } }
/// <summary> /// ReloadModule Method /// </summary> /// <remarks> /// Given a PyObject representing a previously loaded module, reload /// the module. /// </remarks> public static PyObject ReloadModule(PyObject module) { IntPtr op = Runtime.PyImport_ReloadModule(module.Handle); PythonException.ThrowIfIsNull(op); return(new PyObject(op)); }
internal static IntPtr FromLong(long value) { IntPtr val = Runtime.PyLong_FromLongLong(value); PythonException.ThrowIfIsNull(val); return(val); }
/// <summary> /// Given a module or package name, import the /// module and return the resulting module object as a <see cref="PyModule"/>. /// </summary> /// <param name="name">Fully-qualified module or package name</param> public static PyModule Import(string name) { NewReference op = Runtime.PyImport_ImportModule(name); PythonException.ThrowIfIsNull(op); return(new PyModule(ref op)); }
/// <summary> /// ImportModule Method /// </summary> /// <remarks> /// Given a fully-qualified module or package name, import the /// module and return the resulting module object as a PyObject /// or null if an exception is raised. /// </remarks> public static PyObject ImportModule(string name) { IntPtr op = Runtime.PyImport_ImportModule(name); PythonException.ThrowIfIsNull(op); return(new PyObject(op)); }
/// <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 nestings 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. PythonException pe = e as PythonException; if (pe != null) { Runtime.PyErr_SetObject(pe.PyType, pe.PyValue); return; } IntPtr op = CLRObject.GetInstHandle(e); // XXX - hack to raise a compatible old-style exception ;( if (Runtime.wrap_exceptions) { op = GetExceptionInstanceWrapper(op); } IntPtr etype = Runtime.PyObject_GetAttrString(op, "__class__"); Runtime.PyErr_SetObject(etype, op); Runtime.Decref(etype); Runtime.Decref(op); }
public static void With(PyObject obj, Action <dynamic> Body) { // Behavior described here: // https://docs.python.org/2/reference/datamodel.html#with-statement-context-managers IntPtr type = Runtime.PyNone; IntPtr val = Runtime.PyNone; IntPtr traceBack = Runtime.PyNone; PythonException ex = null; try { PyObject enterResult = obj.InvokeMethod("__enter__"); Body(enterResult); } catch (PythonException e) { ex = e; type = ex.PyType.Coalesce(type); val = ex.PyValue.Coalesce(val); traceBack = ex.PyTB.Coalesce(traceBack); } Runtime.XIncref(type); Runtime.XIncref(val); Runtime.XIncref(traceBack); var exitResult = obj.InvokeMethod("__exit__", new PyObject(type), new PyObject(val), new PyObject(traceBack)); if (ex != null && !exitResult.IsTrue()) { throw ex; } }
/// <summary> /// Utility method to allocate a type object & do basic initialization. /// </summary> internal static IntPtr AllocateTypeObject(string name, IntPtr metatype) { IntPtr type = Runtime.PyType_GenericAlloc(metatype, 0); PythonException.ThrowIfIsNull(type); // Clr type would not use __slots__, // and the PyMemberDef after PyHeapTypeObject will have other uses(e.g. type handle), // thus set the ob_size to 0 for avoiding slots iterations. Marshal.WriteIntPtr(type, TypeOffset.ob_size, IntPtr.Zero); // Cheat a little: we'll set tp_name to the internal char * of // the Python version of the type name - otherwise we'd have to // allocate the tp_name and would have no way to free it. IntPtr temp = Runtime.PyUnicode_FromString(name); IntPtr raw = Runtime.PyUnicode_AsUTF8(temp); Marshal.WriteIntPtr(type, TypeOffset.tp_name, raw); Marshal.WriteIntPtr(type, TypeOffset.name, temp); Runtime.XIncref(temp); Marshal.WriteIntPtr(type, TypeOffset.qualname, temp); temp = type + TypeOffset.nb_add; Marshal.WriteIntPtr(type, TypeOffset.tp_as_number, temp); temp = type + TypeOffset.sq_length; Marshal.WriteIntPtr(type, TypeOffset.tp_as_sequence, temp); temp = type + TypeOffset.mp_length; Marshal.WriteIntPtr(type, TypeOffset.tp_as_mapping, temp); temp = type + TypeOffset.bf_getbuffer; Marshal.WriteIntPtr(type, TypeOffset.tp_as_buffer, temp); return(type); }
public static PyObject Compile(string code, string filename = "", RunFlagType mode = RunFlagType.File) { var flag = (int)mode; IntPtr ptr = Runtime.Py_CompileString(code, filename, flag); PythonException.ThrowIfIsNull(ptr); return(new PyObject(ptr)); }
internal static IntPtr ErrorCheckIfNull(IntPtr pointer) { if (pointer == IntPtr.Zero && ErrorOccurred()) { throw PythonException.ThrowLastAsClrException(); } return(pointer); }
public void TestNoError() { PythonException e = new PythonException(); //There is no PyErr to fetch Assert.AreEqual("", e.Message); }
public object TrueDispatch(ArrayList args) { MethodInfo method = dtype.GetMethod("Invoke"); ParameterInfo[] pi = method.GetParameters(); IntPtr pyargs = Runtime.PyTuple_New(pi.Length); Type rtype = method.ReturnType; for (int i = 0; i < pi.Length; i++) { // Here we own the reference to the Python value, and we // give the ownership to the arg tuple. IntPtr arg = Converter.ToPython(args[i], pi[i].ParameterType); Runtime.PyTuple_SetItem(pyargs, i, arg); } IntPtr op = Runtime.PyObject_Call(target, pyargs, IntPtr.Zero); Runtime.Decref(pyargs); if (op == IntPtr.Zero) { PythonException e = new PythonException(); throw e; } if (rtype == typeof(void)) { return null; } Object result = null; if (!Converter.ToManaged(op, rtype, out result, false)) { string s = "could not convert Python result to " + rtype.ToString(); Runtime.Decref(op); throw new ConversionException(s); } Runtime.Decref(op); return result; }