PowerToys/Pythonnet.Runtime/exceptions.cs

// ==========================================================================
// This software is subject to the provisions of the Zope Public License,
// Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
// THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
// WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
// FOR A PARTICULAR PURPOSE.
// ==========================================================================

using System;
using System.Reflection;
using System.Collections;
using System.Runtime.InteropServices;


namespace Python.Runtime {

    /// <summary>
    /// Base class for Python types that reflect managed exceptions based on
    /// System.Exception
    /// </summary>
    /// <remarks>
    /// The Python wrapper for managed exceptions LIES about its inheritance
    /// tree. Although the real System.Exception is a subclass of 
    /// System.Object the Python type for System.Exception does NOT claim that
    /// it subclasses System.Object. Instead TypeManager.CreateType() uses 
    /// Python's exception.Exception class as base class for System.Exception.
    /// </remarks>
    internal class ExceptionClassObject : ClassObject {

        internal ExceptionClassObject(Type tp) : base(tp) {
        }

#if (PYTHON25 || PYTHON26 || PYTHON27)
        internal static Exception ToException(IntPtr ob) {
            CLRObject co = GetManagedObject(ob) as CLRObject;
            if (co == null) {
                return null;
            }
            Exception e = co.inst as Exception;
            if (e == null) {
                return null;
            }
            return e;
        }

        //====================================================================
        // Exception __str__ implementation
        //====================================================================
        
        public new static IntPtr tp_str(IntPtr ob) {
            Exception e = ToException(ob);
            if (e == null) {
                return Exceptions.RaiseTypeError("invalid object");
            }

            string message = String.Empty;
            if (e.Message != String.Empty) {
                message = e.Message;
            }
            if ((e.StackTrace != null) && (e.StackTrace != String.Empty)) {
                message = message + "\n" + e.StackTrace;
            }
            return Runtime.PyUnicode_FromString(message);
        }

        //====================================================================
        // Exception __repr__ implementation.
        //====================================================================

        public static IntPtr tp_repr(IntPtr ob) {
            Exception e = ToException(ob);
            if (e == null) {
                return Exceptions.RaiseTypeError("invalid object");
            }
            string name = e.GetType().Name;
            string message;
            if (e.Message != String.Empty) {
                message = String.Format("{0}('{1}',)", name, e.Message);
            } else {
                message = String.Format("{0}()", name);
            }
            return Runtime.PyUnicode_FromString(message);
        }
        //====================================================================
        // Exceptions __getattribute__ implementation. 
        // handles Python's args and message attributes
        //====================================================================

        public static IntPtr tp_getattro(IntPtr ob, IntPtr key)
        {
            if (!Runtime.PyString_Check(key)) {
                Exceptions.SetError(Exceptions.TypeError, "string expected");
                return IntPtr.Zero;
            }

            string name = Runtime.GetManagedString(key);
            if (name == "args") {
                Exception e = ToException(ob);
                IntPtr args;
                if (e.Message != String.Empty) {
                    args = Runtime.PyTuple_New(1);
                    IntPtr msg = Runtime.PyUnicode_FromString(e.Message);
                    Runtime.PyTuple_SetItem(args, 0, msg);
                } else {
                    args = Runtime.PyTuple_New(0);
                }
                return args;
            }

            if (name == "message") {
                return ExceptionClassObject.tp_str(ob);
            }

            return Runtime.PyObject_GenericGetAttr(ob, key);
        }
#endif      // (PYTHON25 || PYTHON26 || PYTHON27)
    }

    /// <summary>
    /// Encapsulates the Python exception APIs.
    /// </summary>
    /// <remarks>
    /// Readability of the Exceptions class improvements as we look toward version 2.7 ...
    /// </remarks>

    public class Exceptions {

        internal static IntPtr warnings_module;
        internal static IntPtr exceptions_module;

        private Exceptions() {}

        //===================================================================
        // Initialization performed on startup of the Python runtime.
        //===================================================================

        internal static void Initialize() {
            exceptions_module = Runtime.PyImport_ImportModule("exceptions");
            Exceptions.ErrorCheck(exceptions_module);
            warnings_module = Runtime.PyImport_ImportModule("warnings");
            Exceptions.ErrorCheck(warnings_module);
            Type type = typeof(Exceptions);
            foreach (FieldInfo fi in type.GetFields(BindingFlags.Public | 
                                                    BindingFlags.Static)) {
                IntPtr op = Runtime.PyObject_GetAttrString(exceptions_module, fi.Name);
                if (op != IntPtr.Zero) {
                    fi.SetValue(type, op);
                }
                else {
                    fi.SetValue(type, IntPtr.Zero);
                    DebugUtil.Print("Unknown exception: " + fi.Name);
                }
            }
            Runtime.PyErr_Clear();
            if (Runtime.wrap_exceptions) {
                SetupExceptionHack();
            }
        }


        //===================================================================
        // Cleanup resources upon shutdown of the Python runtime.
        //===================================================================

        internal static void Shutdown() {
            Type type = typeof(Exceptions);
            foreach (FieldInfo fi in type.GetFields(BindingFlags.Public | 
                                                    BindingFlags.Static)) {
                IntPtr op = (IntPtr)fi.GetValue(type);
                if (op != IntPtr.Zero) {
                      Runtime.Decref(op);
                }
            }
            Runtime.Decref(exceptions_module);
            Runtime.Decref(warnings_module);
        }

        /// <summary>
        ///  Shortcut for (pointer == NULL) -> throw PythonException
        /// </summary>
        /// <param name="pointer">Pointer to a Python object</param>
        internal unsafe static void ErrorCheck(IntPtr pointer) {
            if (pointer == IntPtr.Zero) {
                throw new PythonException();
            }
        }

        /// <summary>
        ///  Shortcut for (pointer == NULL or ErrorOccurred()) -> throw PythonException
        /// </summary>
        ///  Shortcut for (pointer == NULL) -> throw PythonException
        internal unsafe static void ErrorOccurredCheck(IntPtr pointer) {
            if ((pointer == IntPtr.Zero) || Exceptions.ErrorOccurred()) {
                throw new PythonException();
            }
        }

        // Versions of CPython up to 2.4 do not allow exceptions to be
        // new-style classes. To get around that restriction and provide
        // a consistent user experience for programmers, we wrap managed
        // exceptions in an old-style class that (through some dont-try-
        // this-at-home hackery) delegates to the managed exception and
        // obeys the conventions of both Python and managed exceptions.

        /// <remarks>
        /// Conditionally initialized variables!
        /// </remarks>
        static IntPtr ns_exc; // new-style class for System.Exception
        static IntPtr os_exc; // old-style class for System.Exception
        static Hashtable cache;

        /// <remarks>
        /// the lines
        /// // XXX - hack to raise a compatible old-style exception ;(
        /// if (Runtime.wrap_exceptions) {
        ///     CallOneOfTheseMethods();
        ///  
        /// </remarks>
        internal static void SetupExceptionHack() {
            ns_exc = ClassManager.GetClass(typeof(Exception)).pyHandle;
            cache = new Hashtable();

            string code = 
            "import exceptions\n" +
            "class Exception(exceptions.Exception):\n" +
            "    _class = None\n" +
            "    _inner = None\n" +
            "    \n" +
            "    #@property\n" +
            "    def message(self):\n" +
            "        return self.Message\n" +
            "    message = property(message)\n" +
            "    \n" +
            "    def __init__(self, *args, **kw):\n" +
            "        inst = self.__class__._class(*args, **kw)\n" +
            "        self.__dict__['_inner'] = inst\n" +
            "        exceptions.Exception.__init__(self, *args, **kw)\n" +
            "\n" +
            "    def __getattr__(self, name, _marker=[]):\n" +
            "        inner = self.__dict__['_inner']\n" +
            "        v = getattr(inner, name, _marker)\n" +
            "        if v is not _marker:\n" +
            "            return v\n" +
            "        v = self.__dict__.get(name, _marker)\n" +
            "        if v is not _marker:\n" +
            "            return v\n" +
            "        raise AttributeError(name)\n" +
            "\n" +
            "    def __setattr__(self, name, value):\n" +
            "        inner = self.__dict__['_inner']\n" +
            "        setattr(inner, name, value)\n" +
            "\n" +
            "    def __str__(self):\n" +
            "        inner = self.__dict__.get('_inner')\n" +
            "        msg = getattr(inner, 'Message', '')\n" +
            "        st = getattr(inner, 'StackTrace', '')\n" +
            "        st = st and '\\n' + st or ''\n" +
            "        return msg + st\n" +
            "    \n" + 
            "    def __repr__(self):\n" +
            "        inner = self.__dict__.get('_inner')\n" +
            "        msg = getattr(inner, 'Message', '')\n" +
            "        name = self.__class__.__name__\n" +
            "        return '%s(\\'%s\\',)' % (name, msg) \n" +
            "\n";

            IntPtr dict = Runtime.PyDict_New();

            IntPtr builtins = Runtime.PyEval_GetBuiltins();
            Runtime.PyDict_SetItemString(dict, "__builtins__", builtins);

            IntPtr namestr = Runtime.PyString_FromString("System");
            Runtime.PyDict_SetItemString(dict, "__name__", namestr);
            Runtime.Decref(namestr);

            Runtime.PyDict_SetItemString(dict, "__file__", Runtime.PyNone);
            Runtime.PyDict_SetItemString(dict, "__doc__", Runtime.PyNone);

            IntPtr flag = Runtime.Py_file_input;
            IntPtr result = Runtime.PyRun_String(code, flag, dict, dict);
            Exceptions.ErrorCheck(result);
            Runtime.Decref(result);

            os_exc = Runtime.PyDict_GetItemString(dict, "Exception");
            Runtime.PyObject_SetAttrString(os_exc, "_class", ns_exc);
            Runtime.PyErr_Clear();
        }


        internal static IntPtr GenerateExceptionClass(IntPtr real) {
            if (real == ns_exc) {
                return os_exc;
            }

            IntPtr nbases = Runtime.PyObject_GetAttrString(real, "__bases__");
            if (Runtime.PyTuple_Size(nbases) != 1) {
                throw new SystemException("Invalid __bases__");
            }
            IntPtr nsbase = Runtime.PyTuple_GetItem(nbases, 0);
            Runtime.Decref(nbases);

            IntPtr osbase = GetExceptionClassWrapper(nsbase);
            IntPtr baselist = Runtime.PyTuple_New(1);
            Runtime.Incref(osbase);
            Runtime.PyTuple_SetItem(baselist, 0, osbase);
            IntPtr name = Runtime.PyObject_GetAttrString(real, "__name__");

            IntPtr dict = Runtime.PyDict_New();
            IntPtr mod = Runtime.PyObject_GetAttrString(real, "__module__");
            Runtime.PyDict_SetItemString(dict, "__module__", mod);
            Runtime.Decref(mod);

            IntPtr subc = Runtime.PyClass_New(baselist, dict, name);
            Runtime.Decref(baselist);
            Runtime.Decref(dict);
            Runtime.Decref(name);

            Runtime.PyObject_SetAttrString(subc, "_class", real);
            return subc;
        }

        internal static IntPtr GetExceptionClassWrapper(IntPtr real) {
            // Given the pointer to a new-style class representing a managed
            // exception, return an appropriate old-style class wrapper that
            // maintains all of the expectations and delegates to the wrapped
            // class.
            object ob = cache[real];
            if (ob == null) {
                IntPtr op = GenerateExceptionClass(real);
                cache[real] = op;
                return op;
            }
            return (IntPtr)ob;
        }

        internal static IntPtr GetExceptionInstanceWrapper(IntPtr real) {
            // Given the pointer to a new-style class instance representing a 
            // managed exception, return an appropriate old-style class 
            // wrapper instance that delegates to the wrapped instance.
            IntPtr tp = Runtime.PyObject_TYPE(real);
            if (Runtime.PyObject_TYPE(tp) == Runtime.PyInstanceType) {
                return real;
            }
            // Get / generate a class wrapper, instantiate it and set its
            // _inner attribute to the real new-style exception instance.
            IntPtr ct = GetExceptionClassWrapper(tp);
            Exceptions.ErrorCheck(ct);
            IntPtr op = Runtime.PyInstance_NewRaw(ct, IntPtr.Zero);
            Exceptions.ErrorCheck(op);
            IntPtr d = Runtime.PyObject_GetAttrString(op, "__dict__");
            Exceptions.ErrorCheck(d);
            Runtime.PyDict_SetItemString(d, "_inner", real);
            Runtime.Decref(d);
            return op;
        }

        internal static IntPtr UnwrapExceptionClass(IntPtr op) {
            // In some cases its necessary to recognize an exception *class*,
            // and obtain the inner (wrapped) exception class. This method
            // returns the inner class if found, or a null pointer.

            IntPtr d = Runtime.PyObject_GetAttrString(op, "__dict__");
            if (d == IntPtr.Zero) {
                Exceptions.Clear();
                return IntPtr.Zero;
            }
            IntPtr c = Runtime.PyDict_GetItemString(d, "_class");
            Runtime.Decref(d);
            if (c == IntPtr.Zero) {
                Exceptions.Clear();
            }
            return c;
        }

        /// <summary>
        /// GetException Method
        /// </summary>
        ///
        /// <remarks>
        /// Retrieve Python exception information as a PythonException
        /// instance. The properties of the PythonException may be used
        /// to access the exception type, value and traceback info.
        /// </remarks>

        public static PythonException GetException() {
            return null;
        }

        /// <summary>
        /// ExceptionMatches Method
        /// </summary>
        ///
        /// <remarks>
        /// Returns true if the current Python exception matches the given
        /// Python object. This is a wrapper for PyErr_ExceptionMatches.
        /// </remarks>

        public static bool ExceptionMatches(IntPtr ob) {
            return Runtime.PyErr_ExceptionMatches(ob) != 0;
        }

        /// <summary>
        /// ExceptionMatches Method
        /// </summary>
        ///
        /// <remarks>
        /// Returns true if the given Python exception matches the given
        /// Python object. This is a wrapper for PyErr_GivenExceptionMatches.
        /// </remarks>

        public static bool ExceptionMatches(IntPtr exc, IntPtr ob) {
            int i = Runtime.PyErr_GivenExceptionMatches(exc, ob);
            return (i != 0);
        }

        /// <summary>
        /// SetError Method
        /// </summary>
        ///
        /// <remarks>
        /// Sets the current Python exception given a native string.
        /// This is a wrapper for the Python PyErr_SetString call.
        /// </remarks>

        public static void SetError(IntPtr ob, string value) {
            Runtime.PyErr_SetString(ob, value);
        }

        /// <summary>
        /// SetError Method
        /// </summary>
        ///
        /// <remarks>
        /// Sets the current Python exception given a Python object.
        /// This is a wrapper for the Python PyErr_SetObject call.
        /// </remarks>

        public static void SetError(IntPtr ob, IntPtr value) {
            Runtime.PyErr_SetObject(ob, value);
        }

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

        /// <summary>
        /// ErrorOccurred Method
        /// </summary>
        ///
        /// <remarks>
        /// Returns true if an exception occurred in the Python runtime.
        /// This is a wrapper for the Python PyErr_Occurred call.
        /// </remarks>

        public static bool ErrorOccurred() {
            return Runtime.PyErr_Occurred() != 0;
        }

        /// <summary>
        /// Clear Method
        /// </summary>
        ///
        /// <remarks>
        /// Clear any exception that has been set in the Python runtime.
        /// </remarks>

        public static void Clear() {
            Runtime.PyErr_Clear();
        }

        //====================================================================
        // helper methods for raising warnings
        //====================================================================

        /// <summary>
        /// Alias for Python's warnings.warn() function.
        /// </summary>
        public static void warn(string message, IntPtr exception, int stacklevel)
        {
            if ((exception == IntPtr.Zero) ||
                (Runtime.PyObject_IsSubclass(exception, Exceptions.Warning) != 1)) {
                    Exceptions.RaiseTypeError("Invalid exception");
            }

            Runtime.Incref(warnings_module);
            IntPtr warn = Runtime.PyObject_GetAttrString(warnings_module, "warn");
            Runtime.Decref(warnings_module);
            Exceptions.ErrorCheck(warn);

            IntPtr args = Runtime.PyTuple_New(3);
            IntPtr msg = Runtime.PyString_FromString(message);
            Runtime.Incref(exception); // PyTuple_SetItem steals a reference
            IntPtr level = Runtime.PyInt_FromInt32(stacklevel);
            Runtime.PyTuple_SetItem(args, 0, msg);
            Runtime.PyTuple_SetItem(args, 1, exception);
            Runtime.PyTuple_SetItem(args, 2, level);

            IntPtr result = Runtime.PyObject_CallObject(warn, args);
            Exceptions.ErrorCheck(result);

            Runtime.Decref(warn);
            Runtime.Decref(result);
            Runtime.Decref(args);
        }

        public static void warn(string message, IntPtr exception)
        {
            warn(message, exception, 1);
        }

        public static void deprecation(string message, int stacklevel)
        {
            warn(message, Exceptions.DeprecationWarning, stacklevel);
        }

        public static void deprecation(string message)
        {
            deprecation(message, 1);
        }

        //====================================================================
        // Internal helper methods for common error handling scenarios.
        //====================================================================

        internal static IntPtr RaiseTypeError(string message) {
            Exceptions.SetError(Exceptions.TypeError, message);
            return IntPtr.Zero;
        }

        // 2010-11-16: Arranged in python (2.6 & 2.7) source header file order
        /* Predefined exceptions are
           puplic static variables on the Exceptions class filled in from
           the python class using reflection in Initialize() looked up by
		   name, not posistion. */
#if (PYTHON25 || PYTHON26 || PYTHON27)
        public static IntPtr BaseException;
#endif
        public static IntPtr Exception;
        public static IntPtr StopIteration;
#if (PYTHON25 || PYTHON26 || PYTHON27)
        public static IntPtr GeneratorExit;
#endif
        public static IntPtr StandardError;
        public static IntPtr ArithmeticError;
        public static IntPtr LookupError;
        
        public static IntPtr AssertionError;
        public static IntPtr AttributeError;
        public static IntPtr EOFError;
        public static IntPtr FloatingPointError;
        public static IntPtr EnvironmentError;
        public static IntPtr IOError;
        public static IntPtr OSError;
        public static IntPtr ImportError;
        public static IntPtr IndexError;
        public static IntPtr KeyError;
        public static IntPtr KeyboardInterrupt;
        public static IntPtr MemoryError;
        public static IntPtr NameError;
        public static IntPtr OverflowError;
        public static IntPtr RuntimeError;
        public static IntPtr NotImplementedError;
        public static IntPtr SyntaxError;
        public static IntPtr IndentationError;
        public static IntPtr TabError;
        public static IntPtr ReferenceError;
        public static IntPtr SystemError;
        public static IntPtr SystemExit;
        public static IntPtr TypeError;
        public static IntPtr UnboundLocalError;
        public static IntPtr UnicodeError;
        public static IntPtr UnicodeEncodeError;
        public static IntPtr UnicodeDecodeError;
        public static IntPtr UnicodeTranslateError;
        public static IntPtr ValueError;
        public static IntPtr ZeroDivisionError;
//#ifdef MS_WINDOWS
        //public static IntPtr WindowsError;
//#endif
//#ifdef __VMS
        //public static IntPtr VMSError;
//#endif

        //PyAPI_DATA(PyObject *) PyExc_BufferError;

        //PyAPI_DATA(PyObject *) PyExc_MemoryErrorInst;
        //PyAPI_DATA(PyObject *) PyExc_RecursionErrorInst;


        /* Predefined warning categories */
        public static IntPtr Warning;
        public static IntPtr UserWarning;
        public static IntPtr DeprecationWarning;
        public static IntPtr PendingDeprecationWarning;
        public static IntPtr SyntaxWarning;
        public static IntPtr RuntimeWarning;
        public static IntPtr FutureWarning;
#if (PYTHON25 || PYTHON26 || PYTHON27)
        public static IntPtr ImportWarning;
        public static IntPtr UnicodeWarning;
        //PyAPI_DATA(PyObject *) PyExc_BytesWarning;
#endif
    }


}