[GR-16816] Improve pandas support

PullRequest: graalpython/577

Author: timfel

CHANGELOG.md

@@ -3,6 +3,20 @@
 This changelog summarizes major changes between GraalVM versions of the Python
 language runtime. The main focus is on user-observable behavior of the engine.
 
+## Version 19.2.0
+
+* Implement PyStructSequence_* C API functions
+* Implement `_functools.partial` as a class instead of a function
+* Implement `type.__base__`
+* Implement reading C API type attributes `nb_inplace_add`, `nb_remainder`, `nb_subtract`, and `nb_floor_divide` for builtin types
+* Implement C API functions `_PyObject_CallFunction_SizeT`, `PyEval_InitThreads`, and `PyEval_ThreadsInitialized`
+* Implement writing to a function's `__dict__` field
+* Implement the C API thread state fields `overflowed` and `recursion_depth`
+* Fix printing of errors in the REPL
+* Fix printing full paths in traceback
+* Support the C API varargs functions with arbitrary numbers of arguments instead of imposing an upper limit
+* Improve performance of attribute reads and reading closure variables
+
 ## Version 19.1.0
 
 * Add `java.add_to_classpath` API to dynamically extend the host class path

graalpython/com.oracle.graal.python.cext/include/ceval.h

@@ -94,13 +94,8 @@ PyAPI_FUNC(int) Py_MakePendingCalls(void);
 PyAPI_FUNC(void) Py_SetRecursionLimit(int);
 PyAPI_FUNC(int) Py_GetRecursionLimit(void);
 
-#define Py_EnterRecursiveCall(where)  \
-            (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
-             _Py_CheckRecursiveCall(where))
-#define Py_LeaveRecursiveCall()                         \
-    do{ if(_Py_MakeEndRecCheck(PyThreadState_GET()->recursion_depth))  \
-      PyThreadState_GET()->overflowed = 0;  \
-    } while(0)
+#define Py_EnterRecursiveCall(where) 0
+#define Py_LeaveRecursiveCall()
 PyAPI_FUNC(int) _Py_CheckRecursiveCall(const char *where);
 
 /* Due to the macros in which it's used, _Py_CheckRecursionLimit is in
@@ -130,13 +125,9 @@ PyAPI_DATA(int) _Py_CheckRecursionLimit;
 #define _Py_MakeEndRecCheck(x) \
     (--(x) < _Py_RecursionLimitLowerWaterMark(_Py_CheckRecursionLimit))
 
-#define Py_ALLOW_RECURSION \
-  do { unsigned char _old = PyThreadState_GET()->recursion_critical;\
-    PyThreadState_GET()->recursion_critical = 1;
+#define Py_ALLOW_RECURSION
 
-#define Py_END_ALLOW_RECURSION \
-    PyThreadState_GET()->recursion_critical = _old; \
-  } while(0);
+#define Py_END_ALLOW_RECURSION
 
 PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);
 PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *);

graalpython/com.oracle.graal.python.cext/src/ceval.c

@@ -50,6 +50,14 @@ PyObject* PyEval_CallObjectWithKeywords(PyObject *func, PyObject *args, PyObject
     return PyObject_Call(func, args, kwargs);
 }
 
+void PyEval_InitThreads() {
+    // Nothing to do
+}
+
+int PyEval_ThreadsInitialized() {
+    return 1;
+}
+
 PyThreadState* PyEval_SaveThread() {
     return NULL;
 }

graalpython/com.oracle.graal.python.cext/src/object.c

@@ -238,6 +238,19 @@ PyObject* PyObject_CallFunction(PyObject* callable, const char* fmt, ...) {
     return PyObject_CallObject(callable, args);
 }
 
+PyObject* _PyObject_CallFunction_SizeT(PyObject* callable, const char* fmt, ...) {
+    PyObject* args;
+    CALL_WITH_VARARGS(args, Py_BuildValue, 2, fmt);
+    if (strlen(fmt) < 2) {
+        PyObject* singleArg = args;
+        args = PyTuple_New(strlen(fmt));
+        if (strlen(fmt) == 1) {
+            PyTuple_SetItem(args, 0, singleArg);
+        }
+    }
+    return PyObject_CallObject(callable, args);
+}
+
 PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ...) {
     // the arguments are given as a variable list followed by NULL
     PyObject* args = PyTuple_New(polyglot_get_arg_count() - 2);

graalpython/com.oracle.graal.python.cext/src/typeobject.c

@@ -440,7 +440,8 @@ int PyType_Ready(PyTypeObject* cls) {
         ADD_SLOT("__sub__", numbers->nb_subtract, -2);
         ADD_SLOT_CONV("__rsub__", wrap_reverse_binop, numbers->nb_subtract, -2);
         ADD_SLOT("__mul__", numbers->nb_multiply, -2);
-        ADD_SLOT("__rem__", numbers->nb_remainder, -2);
+        ADD_SLOT("__mod__", numbers->nb_remainder, -2);
+        ADD_SLOT_CONV("__rmod__", wrap_reverse_binop, numbers->nb_remainder, -2);
         ADD_SLOT("__divmod__", numbers->nb_divmod, -2);
         ADD_SLOT_CONV("__pow__", wrap_pow, numbers->nb_power, -3);
         ADD_SLOT("__neg__", numbers->nb_negative, -1);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/PythonLanguage.java

@@ -408,30 +408,32 @@ protected SourceSection findSourceLocation(PythonContext context, Object value)
 
     @Override
     protected String toString(PythonContext context, Object value) {
-        final PythonModule builtins = context.getBuiltins();
-        if (builtins != null) {
-            // may be null during initialization
-            Object reprAttribute = builtins.getAttribute(BuiltinNames.REPR);
-            if (reprAttribute instanceof PBuiltinMethod) {
-                // may be false if e.g. someone accessed our builtins reflectively
-                Object reprFunction = ((PBuiltinMethod) reprAttribute).getFunction();
-                if (reprFunction instanceof PBuiltinFunction) {
-                    // may be false if our builtins were tampered with
-                    Object[] userArgs = PArguments.create(2);
-                    PArguments.setArgument(userArgs, 0, PNone.NONE);
-                    PArguments.setArgument(userArgs, 1, value);
-                    try {
-                        Object result = InvokeNode.invokeUncached((PBuiltinFunction) reprFunction, userArgs);
-                        if (result instanceof String) {
-                            return (String) result;
-                        } else if (result instanceof PString) {
-                            return ((PString) result).getValue();
-                        } else {
-                            // This is illegal for a repr implementation, we ignore the result.
-                            // At this point it's probably difficult to report this properly.
+        if (PythonOptions.getFlag(context, PythonOptions.UseReprForPrintString)) {
+            final PythonModule builtins = context.getBuiltins();
+            if (builtins != null) {
+                // may be null during initialization
+                Object reprAttribute = builtins.getAttribute(BuiltinNames.REPR);
+                if (reprAttribute instanceof PBuiltinMethod) {
+                    // may be false if e.g. someone accessed our builtins reflectively
+                    Object reprFunction = ((PBuiltinMethod) reprAttribute).getFunction();
+                    if (reprFunction instanceof PBuiltinFunction) {
+                        // may be false if our builtins were tampered with
+                        Object[] userArgs = PArguments.create(2);
+                        PArguments.setArgument(userArgs, 0, PNone.NONE);
+                        PArguments.setArgument(userArgs, 1, value);
+                        try {
+                            Object result = InvokeNode.invokeUncached((PBuiltinFunction) reprFunction, userArgs);
+                            if (result instanceof String) {
+                                return (String) result;
+                            } else if (result instanceof PString) {
+                                return ((PString) result).getValue();
+                            } else {
+                                // This is illegal for a repr implementation, we ignore the result.
+                                // At this point it's probably difficult to report this properly.
+                            }
+                        } catch (PException e) {
+                            // Fall through to default
                         }
-                    } catch (PException e) {
-                        // Fall through to default
                     }
                 }
             }
@@ -440,8 +442,12 @@ protected String toString(PythonContext context, Object value) {
         // return a String
         if (value instanceof PythonAbstractObject) {
             return ((PythonAbstractObject) value).toString();
+        } else if (value instanceof String) {
+            return (String) value;
+        } else if (value instanceof Number) {
+            return ((Number) value).toString();
         } else {
-            return "illegal object";
+            return "not a Python object";
         }
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeMemberNames.java

@@ -105,11 +105,15 @@ public final class NativeMemberNames {
     public static final String BUF_DELEGATE = "buf_delegate";
     public static final String BUF_READONLY = "readonly";
     public static final String NB_ADD = "nb_add";
+    public static final String NB_SUBTRACT = "nb_subtract";
+    public static final String NB_REMAINDER = "nb_remainder";
     public static final String NB_AND = "nb_and";
     public static final String NB_INDEX = "nb_index";
     public static final String NB_POW = "nb_power";
     public static final String NB_TRUE_DIVIDE = "nb_true_divide";
+    public static final String NB_FLOOR_DIVIDE = "nb_floor_divide";
     public static final String NB_MULTIPLY = "nb_multiply";
+    public static final String NB_INPLACE_ADD = "nb_inplace_add";
     public static final String NB_INPLACE_MULTIPLY = "nb_inplace_multiply";
     public static final String OB_FVAL = "ob_fval";
     public static final String START = "start";