-
Notifications
You must be signed in to change notification settings - Fork 327
/
python.cpp
4654 lines (3708 loc) · 130 KB
/
python.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#include "libpython.h"
#define RCPP_NO_MODULES
#define RCPP_NO_SUGAR
#include <Rcpp.h>
using namespace Rcpp;
#include "signals.h"
#include "reticulate_types.h"
#include "common.h"
#include "event_loop.h"
#include "tinythread.h"
#include "pending_py_calls_notifier.h"
#include <fstream>
#include <time.h>
#ifndef _WIN32
#include <dlfcn.h>
#else
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
using namespace reticulate::libpython;
int _Py_Check(PyObject* o) {
// default impl we assign to some Python api functions until we've initialized Python;
return 0;
}
PyGILState_STATE _initialize_python_and_PyGILState_Ensure() {
Function initialize_python = Environment::namespace_env("reticulate")["ensure_python_initialized"];
initialize_python();
return PyGILState_Ensure();
}
SEXP sym_pyobj;
SEXP sym_py_object;
SEXP sym_simple;
SEXP sym_convert;
SEXP ns_reticulate;
SEXP r_func_py_filter_classes;
SEXP r_func_get_r_trace;
SEXP r_func_py_callable_as_function;
SEXP r_func_r_to_py;
SEXP r_func_py_to_r;
SEXP r_func_py_to_r_wrapper;
tthread::thread::id s_main_thread = 0;
// [[Rcpp::init]]
void reticulate_init(DllInfo *dll) {
// before python is initialized, make these symbols safe to call (always return false)
PyIter_Check = &_Py_Check;
PyCallable_Check = &_Py_Check;
PyGILState_Ensure = &_initialize_python_and_PyGILState_Ensure;
// Py_MakePendingCallsRun = &_Py_Check;
sym_py_object = Rf_install("py_object");
sym_simple = Rf_install("simple");
sym_convert = Rf_install("convert");
sym_pyobj = Rf_install("pyobj");
ns_reticulate = Rf_findVarInFrame(R_NamespaceRegistry, Rf_install("reticulate"));
r_func_py_filter_classes = Rf_findVar(Rf_install("py_filter_classes"), ns_reticulate);
r_func_py_callable_as_function = Rf_findVar(Rf_install("py_callable_as_function"), ns_reticulate);
r_func_r_to_py = Rf_findVar(Rf_install("r_to_py"), ns_reticulate);
r_func_py_to_r = Rf_findVar(Rf_install("py_to_r"), ns_reticulate);
r_func_py_to_r_wrapper = Rf_findVar(Rf_install("py_to_r_wrapper"), ns_reticulate);
r_func_get_r_trace = Rf_findVar(Rf_install("get_r_trace"), ns_reticulate);
s_main_thread = tthread::this_thread::get_id();
}
inline
bool is_main_thread() {
return s_main_thread == tthread::this_thread::get_id();
}
// track whether we are using python 3 (set during py_initialize)
bool s_isPython3 = false;
// [[Rcpp::export]]
bool is_python3() {
return s_isPython3;
}
// track whether this is an interactive session
bool s_isInteractive = false;
bool is_interactive() {
return s_isInteractive;
}
// track whether we have required numpy
std::string s_numpy_load_error;
bool haveNumPy() {
return s_numpy_load_error.empty();
}
bool requireNumPy() {
if (!haveNumPy())
stop("Required version of NumPy not available: " + s_numpy_load_error);
return true;
}
bool isPyArray(PyObject* object) {
if (!haveNumPy()) return false;
return PyArray_Check(object);
}
bool isPyArrayScalar(PyObject* object) {
if (!haveNumPy()) return false;
return PyArray_CheckScalar(object);
}
// static buffers for Py_SetProgramName / Py_SetPythonHome
std::string s_python;
std::wstring s_python_v3;
std::string s_pythonhome;
std::wstring s_pythonhome_v3;
// helper to convert std::string to std::wstring
std::wstring to_wstring(const std::string& str) {
std::wstring ws = std::wstring(str.size(), L' ');
ws.resize(std::mbstowcs(&ws[0], str.c_str(), str.size()));
return ws;
}
// helper to convert std::wstring to std::string
std::string to_string(const std::wstring& ws) {
int maxnchar = ws.size() * 4;
char *buffer = (char*) malloc(sizeof(char) * maxnchar);
int nchar = wcstombs(buffer, ws.c_str(), maxnchar);
std::string s(buffer, nchar);
free(buffer);
return s;
}
// forward declare error handling utility
SEXP py_fetch_error(bool maybe_reuse_cached_r_trace = false);
const char *r_object_string = "r_object";
// wrap an R object in a longer-lived python object "capsule"
SEXP py_capsule_read(PyObject* capsule) {
SEXP object = (SEXP) PyCapsule_GetPointer(capsule, r_object_string);
if (object == NULL)
throw PythonException(py_fetch_error());
// Rcpp_precious_preserve() returns a cell of a doubly linked list
// with the original object preserved in the cell TAG().
return TAG(object);
}
int free_sexp(void* sexp) {
// wrap Rcpp_precious_remove() to satisfy
// Py_AddPendingCall() signature and return value requirements
Rcpp_precious_remove((SEXP) sexp);
return 0;
}
void Rcpp_precious_remove_main_thread(SEXP object) {
if (is_main_thread()) {
return Rcpp_precious_remove(object);
}
// #Py_AddPendingCall can fail sometimes, so we retry a few times
const size_t wait_ms = 100;
size_t waited_ms = 0;
while (Py_AddPendingCall(free_sexp, object) != 0) {
tthread::this_thread::sleep_for(tthread::chrono::milliseconds(wait_ms));
// increment total wait time and print a warning every 60 seconds
waited_ms += wait_ms;
if ((waited_ms % 60000) == 0)
PySys_WriteStderr("Waiting to schedule object finalizer on main R interpeter thread...\n");
else if (waited_ms > 60000 * 2) {
// if we've waited more than 2 minutes, something is wrong
PySys_WriteStderr("Error: unable to register R object finalizer on main thread\n");
return;
}
}
}
void py_capsule_free(PyObject* capsule) {
SEXP object = (SEXP)PyCapsule_GetPointer(capsule, r_object_string);
if (object == NULL)
throw PythonException(py_fetch_error());
// the R api access must be from the main thread
Rcpp_precious_remove_main_thread(object);
}
PyObject* py_capsule_new(SEXP object) {
if(TYPEOF(object) == EXTPTRSXP &&
R_ExternalPtrAddr(object) == NULL)
stop("Invalid pointer");
// if object == R_NilValue, this is a no-op, R_NilValue is reflected back.
object = Rcpp_precious_preserve(object);
return PyCapsule_New((void *)object, r_object_string, py_capsule_free);
}
PyObject* py_get_attr(PyObject* object, const std::string& name) {
PyObject* attr = PyObject_GetAttrString(object, name.c_str());
if(attr == NULL)
PyErr_Clear();
return attr;
}
bool is_r_object_capsule(PyObject* capsule) {
return PyCapsule_IsValid(capsule, r_object_string);
}
// helper class for ensuring decref of PyObject in the current scope
template <typename T>
class PyPtr {
public:
// attach on creation, decref on destruction
PyPtr()
: object_(NULL)
{
}
explicit PyPtr(T* object)
: object_(object)
{
}
virtual ~PyPtr()
{
if (object_ != NULL) {
Py_DecRef((PyObject*) object_);
}
}
operator T*() const
{
return object_;
}
T* get() const
{
return object_;
}
void assign(T* object)
{
object_ = object;
}
T* detach()
{
T* object = object_;
object_ = NULL;
return object;
}
bool is_null() const
{
return object_ == NULL;
}
private:
// prevent copying
PyPtr(const PyPtr&);
PyPtr& operator=(const PyPtr&);
// underlying object
T* object_;
};
typedef PyPtr<PyObject> PyObjectPtr;
typedef PyPtr<PyArray_Descr> PyArray_DescrPtr;
inline PyObject* PyUnicode_AsBytes(PyObject* str) {
return PyUnicode_AsEncodedString(str, /* encoding = */ NULL, /* errors = */ "ignore");
// encoding = NULL is fastpath to "utf-8"
}
PyObject* as_python_str(const std::string& str);
std::string as_std_string(PyObject* str) {
// conver to bytes if its unicode
PyObjectPtr pStr;
if (PyUnicode_Check(str) || isPyArrayScalar(str)) {
str = PyUnicode_AsBytes(str);
pStr.assign(str);
}
char* buffer;
Py_ssize_t length;
int res = is_python3() ?
PyBytes_AsStringAndSize(str, &buffer, &length) :
PyString_AsStringAndSize(str, &buffer, &length);
if (res == -1)
throw PythonException(py_fetch_error());
return std::string(buffer, length);
}
#define as_utf8_r_string(str) Rcpp::String(as_std_string(str))
PyObject* as_python_str(SEXP strSEXP, bool handle_na=false) {
if (handle_na && strSEXP == NA_STRING) {
Py_IncRef(Py_None);
return Py_None;
}
if (is_python3()) {
// python3 doesn't have PyString and all strings are unicode so
// make sure we get a unicode representation from R
const char * value = Rf_translateCharUTF8(strSEXP);
return PyUnicode_FromString(value);
} else {
const char * value = Rf_translateChar(strSEXP);
return PyString_FromString(value);
}
}
PyObject* as_python_str(const std::string& str) {
if (is_python3()) {
return PyUnicode_FromString(str.c_str());
} else {
return PyString_FromString(str.c_str());
}
}
bool has_null_bytes(PyObject* str) {
char* buffer;
int res = PyString_AsStringAndSize(str, &buffer, NULL);
if (res == -1) {
py_fetch_error();
return true;
} else {
return false;
}
}
// helpers to narrow python array type to something convertable from R,
// guaranteed to return NPY_BOOL, NPY_LONG, NPY_DOUBLE, NPY_CDOUBLE,
// or -1 if it's unable to return one of these types.
int narrow_array_typenum(int typenum) {
switch(typenum) {
// logical
case NPY_BOOL:
typenum = NPY_BOOL;
break;
// integer
case NPY_BYTE:
case NPY_UBYTE:
case NPY_SHORT:
case NPY_USHORT:
case NPY_INT:
typenum = NPY_LONG;
break;
// double
case NPY_UINT:
case NPY_ULONG:
case NPY_ULONGLONG:
case NPY_LONG:
case NPY_LONGLONG:
case NPY_HALF:
case NPY_FLOAT:
case NPY_DOUBLE:
case NPY_DATETIME: // needs some additional special handling
typenum = NPY_DOUBLE;
break;
// complex
case NPY_CFLOAT:
case NPY_CDOUBLE:
typenum = NPY_CDOUBLE;
break;
// string/object (leave these alone)
case NPY_STRING:
case NPY_UNICODE:
case NPY_OBJECT:
case NPY_VSTRING:
break;
// unsupported
default:
typenum = -1;
break;
}
return typenum;
}
int narrow_array_typenum(PyArrayObject* array) {
return narrow_array_typenum(PyArray_TYPE(array));
}
int narrow_array_typenum(PyArray_Descr* descr) {
return narrow_array_typenum(descr->type_num);
}
bool is_numpy_str(PyObject* x) {
if (!isPyArrayScalar(x))
return false; // ndarray or other, not string
PyArray_DescrPtr descrPtr(PyArray_DescrFromScalar(x));
int typenum = narrow_array_typenum(descrPtr);
return (typenum == NPY_STRING || typenum == NPY_UNICODE);
}
bool is_python_str(PyObject* x) {
if (PyUnicode_Check(x))
return true;
// python3 doesn't have PyString_* so mask it out (all strings in
// python3 will get caught by PyUnicode_Check, we'll ignore
// PyBytes entirely and let it remain a python object)
else if (!is_python3() && PyString_Check(x) && !has_null_bytes(x))
return true;
else if (is_numpy_str(x))
return true;
else
return false;
}
// check whether a PyObject is None
bool py_is_none(PyObject* object) {
return object == Py_None;
}
// convenience wrapper for PyImport_Import
PyObject* py_import(const std::string& module) {
PyObjectPtr module_str(as_python_str(module));
return PyImport_Import(module_str);
}
class PyErrorScopeGuard {
private:
PyObject *er_type, *er_value, *er_traceback;
bool pending_restore;
public:
PyErrorScopeGuard() {
PyErr_Fetch(&er_type, &er_value, &er_traceback);
pending_restore = true;
}
void release(bool restore = false) {
if (restore)
PyErr_Restore(er_type, er_value, er_traceback);
pending_restore = false;
}
~PyErrorScopeGuard() {
if (pending_restore)
PyErr_Restore(er_type, er_value, er_traceback);
}
};
// copied directly from purrr; used to call rlang::trace_back() in
// py_fetch_error() in such a way that it doesn't introduce a new
// frame in returned traceback
SEXP current_env(void) {
static SEXP call = []() {
// `sys.frame(sys.nframe())` doesn't work because `sys.nframe()`
// returns the number of the frame in which evaluation occurs. It
// doesn't return the number of frames on the stack. So we'd need
// to evaluate it in the last frame on the stack which is what we
// are looking for to begin with. We use instead this workaround:
// Call `sys.frame()` from a closure to push a new frame on the
// stack, and use negative indexing to get the previous frame.
SEXP fn = PROTECT(R_ParseEvalString("function() sys.frame(-1)", R_BaseEnv));
SEXP call = Rf_lang1(fn);
R_PreserveObject(call);
UNPROTECT(1);
return call;
}();
// Rf_PrintValue(get_r_trace(false, false));
return Rf_eval(call, R_BaseEnv);
}
static inline
SEXP eval_call(SEXP r_func, SEXP arg) {
RObject cl(Rf_lang2(r_func, arg));
return Rcpp_fast_eval(cl, ns_reticulate);
}
static inline
SEXP eval_call_fast_unsafe(SEXP r_func, SEXP arg) {
SEXP cl = PROTECT(Rf_lang2(r_func, arg));
SEXP res = Rf_eval(cl, ns_reticulate);
UNPROTECT(1);
return res;
}
static inline
SEXP eval_call(SEXP r_func, SEXP arg1, SEXP arg2) {
RObject cl(Rf_lang3(r_func, arg1, arg2));
return Rcpp_fast_eval(cl, ns_reticulate);
}
// static inline
// SEXP eval_call(SEXP r_func, SEXP arg1, bool arg2) {
// return eval_call(r_func, arg1, Rf_ScalarLogical(arg2));
// }
// static inline
// SEXP eval_call_in_userenv(SEXP r_func, SEXP arg) {
// RObject cl(Rf_lang2(r_func, arg));
// return Rcpp_fast_eval(cl, current_env());
// // this sometimes returns the reticulate ns env
// // we need a new func, current_user_env(), that walks the frames, skipping reticulate ns frames.
// }
// static inline
// SEXP eval_call_in_userenv(SEXP r_func, SEXP arg1, SEXP arg2) {
// SEXP cl = Rf_lang3(r_func, arg1, arg2);
// RObject cl_(cl); // protect
// return Rcpp_fast_eval(cl, current_env());
// }
bool s_is_python_initialized = false;
bool s_was_python_initialized_by_reticulate = false;
// [[Rcpp::export]]
bool was_python_initialized_by_reticulate() {
return s_was_python_initialized_by_reticulate;
}
std::string as_r_class(PyObject* classPtr) {
PyObjectPtr namePtr(PyObject_GetAttrString(classPtr, "__name__"));
std::ostringstream ostr;
std::string module;
PyObjectPtr modulePtr(PyObject_GetAttrString(classPtr, "__module__"));
if (modulePtr) {
module = as_std_string(modulePtr) + ".";
std::string builtin("__builtin__"); // python2 only?
if (module.find(builtin) == 0)
module.replace(0, builtin.length(), "python.builtin");
std::string builtins("builtins");
if (module.find(builtins) == 0)
module.replace(0, builtins.length(), "python.builtin");
} else {
PyErr_Clear();
module = "python.builtin.";
}
ostr << module << as_std_string(namePtr);
return ostr.str();
}
SEXP py_class_names(PyObject* object, bool exception) {
// Py_TYPE() usually returns a borrowed reference to object.__class__
// but can differ if __class__ was modified after the object was created.
// (e.g., wrapt.ObjectProxy(dict()), as encountered in
// tensorflow.python.trackable.data_structures._DictWrapper)
// In CPython, the definition of Py_TYPE() changed in Python 3.10
// from a macro with no return type to a inline static function returning PyTypeObject*.
// for back compat, we continue to define Py_TYPE as a macro in reticulate/src/libpython.h
PyObject* type = (PyObject*) Py_TYPE(object);
if (type == NULL)
// this code path gets heavily excercised by py_fetch_error()
// Something going wrong here, then py_fetch_error() will be of no help.
// Fortunatly, an Exception here should be an exceedingly rare occurance.
Rcpp::stop("Unable to resolve PyObject type.");
// throw PythonException(py_fetch_error());
// call inspect.getmro to get the class and it's bases in
// method resolution order
static PyObject* getmro = NULL;
if (getmro == NULL) {
PyObjectPtr inspect(py_import("inspect"));
if (inspect.is_null())
throw PythonException(py_fetch_error());
getmro = PyObject_GetAttrString(inspect, "getmro");
if (getmro == NULL)
throw PythonException(py_fetch_error());
}
PyObjectPtr classes(PyObject_CallFunctionObjArgs(getmro, type, NULL));
if (classes.is_null())
Rcpp::stop("Exception raised by 'inspect.getmro(<pyobj>)'; unable to build R 'class' attribute");
// throw PythonException(py_fetch_error());
// start adding class names
std::vector<std::string> classNames;
Py_ssize_t len = PyTuple_Size(classes);
classNames.reserve(len+2);
// +2 to possibly add python.builtin.object and python.builtin.iterator,
// or "error" and "condition"
// add the bases to the R class attribute
for (Py_ssize_t i = 0; i < len; i++) {
PyObject* base = PyTuple_GetItem(classes, i); // borrowed
classNames.push_back(as_r_class(base));
}
// add python.builtin.object if we don't already have it
if (classNames.empty() || classNames.back() != "python.builtin.object") {
// typically already there for exceptions (most objects, actually)
classNames.push_back("python.builtin.object");
}
// if it's an iterator, include python.builtin.iterator, before python.builtin.object
if(PyIter_Check(object))
classNames.insert(classNames.end() - 1, "python.builtin.iterator");
// if it's a BaseException instance, append "error"/"interrupt" and "condition"
if (exception) {
if (PyErr_GivenExceptionMatches(type, PyExc_KeyboardInterrupt))
classNames.push_back("interrupt");
else
classNames.push_back("error");
classNames.push_back("condition");
}
RObject classNames_robj = Rcpp::wrap(classNames); // convert + protect
RObject out = eval_call(r_func_py_filter_classes, (SEXP) classNames_robj);
return out;
}
SEXP py_class_names(PyObject* object) {
return py_class_names(object, (bool) PyExceptionInstance_Check(object));
}
// needs to be defined here, though only used in reticulate_types.h
SEXP new_refenv() {
#if defined(R_VERSION) && R_VERSION >= R_Version(4, 1, 0)
return R_NewEnv(/*enclos =*/ R_EmptyEnv, /*hash =*/ false, /*size =*/ 0);
#else
// R_NewEnv() C func introducted in R 4.1.
// Prior to that, we need to call R func new.env()
static SEXP call = []() {
SEXP call = Rf_lang3(Rf_findFun(Rf_install("new.env"), R_BaseEnv),
/*hash =*/ Rf_ScalarLogical(FALSE),
/*parent =*/ R_EmptyEnv);
R_PreserveObject(call);
return call;
}();
return Rf_eval(call, R_BaseEnv);
#endif
}
// wrap a PyObject
// this steals a reference
PyObjectRef py_ref(PyObject* object, bool convert)
{
// wrap
PyObjectRef ref(object, convert);
return ref;
}
static inline
bool inherits2(SEXP object, const char* name) {
// like inherits in R, but iterates over the class STRSXP vector
// in reverse, since python.builtin.object is typically at the tail.
SEXP klass = Rf_getAttrib(object, R_ClassSymbol);
if (TYPEOF(klass) == STRSXP) {
for (int i = Rf_length(klass)-1; i >= 0; i--) {
if (strcmp(CHAR(STRING_ELT(klass, i)), name) == 0)
return true;
}
}
return false;
}
bool inherits2(SEXP object, const char* name1, const char* name2) {
// like inherits in R, but iterates over the class STRSXP vector
// in reverse, since python.builtin.object is typically at the tail.
SEXP klass = Rf_getAttrib(object, R_ClassSymbol);
if (TYPEOF(klass) == STRSXP) {
int i = Rf_length(klass)-1;
for (; i >= 0; i--) {
if (strcmp(CHAR(STRING_ELT(klass, i)), name2) == 0) {
// found name2, now look for name1
for (i--; i >= 0; i--)
if (strcmp(CHAR(STRING_ELT(klass, i)), name1) == 0)
return true; // found name1 also
break; // did not find name1
}
}
}
return false;
}
//' Check if a Python object is a null externalptr
//'
//' @param x Python object
//'
//' @return Logical indicating whether the object is a null externalptr
//'
//' @details When Python objects are serialized within a persisted R
//' environment (e.g. .RData file) they are deserialized into null
//' externalptr objects (since the Python session they were originally
//' connected to no longer exists). This function allows you to safely
//' check whether whether a Python object is a null externalptr.
//'
//' The `py_validate` function is a convenience function which calls
//' `py_is_null_xptr` and throws an error in the case that the xptr
//' is `NULL`.
//'
//' @export
// [[Rcpp::export]]
bool py_is_null_xptr(PyObjectRef x) {
return x.is_null_xptr();
}
//' @rdname py_is_null_xptr
//' @export
// [[Rcpp::export]]
void py_validate_xptr(PyObjectRef x)
{
if (!x.is_null_xptr())
return;
if (inherits2(x, "python.builtin.module"))
{
if (try_py_resolve_module_proxy(x.get_refenv()))
if (!x.is_null_xptr())
return;
}
stop("Object is a null externalptr (it may have been disconnected from "
"the session where it was created)");
}
bool option_is_true(const std::string& name) {
SEXP valueSEXP = Rf_GetOption(Rf_install(name.c_str()), R_BaseEnv);
return Rf_isLogical(valueSEXP) && (as<bool>(valueSEXP) == true);
}
bool traceback_enabled() {
Environment pkgEnv = Environment::namespace_env("reticulate");
Function func = pkgEnv["traceback_enabled"];
return as<bool>(func());
}
SEXP get_current_call(void) {
static SEXP call = []() {
SEXP fn = PROTECT(R_ParseEvalString("function() sys.call(-1)", R_BaseEnv));
SEXP call = Rf_lang1(fn);
R_PreserveObject(call);
UNPROTECT(1);
return call;
}();
return Rf_eval(call, R_BaseEnv);
}
SEXP get_r_trace(bool maybe_use_cached = false) {
// should this be eval_call_in_userenv()?
return eval_call(r_func_get_r_trace,
Rf_ScalarLogical(maybe_use_cached),
/*trim_tail = */ Rf_ScalarInteger(true));
}
SEXP py_fetch_error(bool maybe_reuse_cached_r_trace) {
// TODO: we need to add a guardrail to catch cases when
// this is being invoked from not the main thread
if(!is_main_thread()) {
GILScope _gil;
PyErr_Print();
PySys_WriteStderr("\nUnable to fetch R backtrace from Python thread\n"); // TODO:
return R_NilValue;
}
PyObject *excType, *excValue, *excTraceback;
PyErr_Fetch(&excType, &excValue, &excTraceback); // we now own the PyObjects
if (!excType) {
Rcpp::stop("Unknown Python error.");
}
if (PyErr_GivenExceptionMatches(excType, PyExc_KeyboardInterrupt)) {
// Technically, we can safely delete this if branch and let the
// KeyboardInterrupt fall through the standard exception raising codepath.
// Meaning, we can treat it as a regular Exception, augment it with a
// traceback, and then signal it as an interrupt condition that also
// inherits from "python.builtin.KeyBoardInterrupt" (signaled via
// base::stop(<cond>) in the Rcpp wrapper).
//
// We intercept early here just to avoid the overhead.
if (excTraceback) Py_DecRef(excTraceback);
if (excValue) Py_DecRef(excValue);
Py_DecRef(excType);
throw Rcpp::internal::InterruptedException();
}
PyErr_NormalizeException(&excType, &excValue, &excTraceback);
if (excTraceback != NULL && excValue != NULL && s_isPython3) {
PyException_SetTraceback(excValue, excTraceback);
Py_DecRef(excTraceback);
}
PyObjectPtr pExcType(excType); // decref on exit
if (!PyObject_HasAttrString(excValue, "call")) {
// check if this exception originated in python using the `raise from`
// statement with an exception that we've already augmented with the full
// r_trace. (or similarly, raised a new exception inside an `except:` block
// while it is catching an Exception that contains an r_trace). If we find
// r_trace/r_call in a __context__ Exception, pull them forward to this
// topmost exception.
PyObject *context = NULL, *r_call = NULL, *r_trace = NULL;
PyObject *excValue_tmp = excValue;
while ((context = PyObject_GetAttrString(excValue_tmp, "__context__"))) {
if ((r_call = PyObject_GetAttrString(context, "call"))) {
PyObject_SetAttrString(excValue, "call", r_call);
Py_DecRef(r_call);
}
if ((r_trace = PyObject_GetAttrString(context, "trace"))) {
PyObject_SetAttrString(excValue, "trace", r_trace);
Py_DecRef(r_trace);
}
excValue_tmp = context;
Py_DecRef(context);
if(r_call || r_trace) {
break;
}
}
}
// make sure the exception object has some some attrs: call, trace
if (!PyObject_HasAttrString(excValue, "trace")) {
SEXP r_trace = PROTECT(get_r_trace(maybe_reuse_cached_r_trace));
PyObject* r_trace_capsule(py_capsule_new(r_trace));
PyObject_SetAttrString(excValue, "trace", r_trace_capsule);
Py_DecRef(r_trace_capsule);
UNPROTECT(1);
}
// Otherwise, try to capture the current call.
// A first draft of this tried using: SEXP r_call = get_last_call();
// with get_last_call() defined in Rcpp headers. Unfortunately, that would
// skip over the actual call of interest, and frequently return NULL
// for shallow call stacks. So we fetch the call directly
// using the R API.
if (!PyObject_HasAttrString(excValue, "call")) {
// Technically we don't need to protect call, since
// it would already be protected by it's inclusion in the R callstack,
// but rchk flags it anyway, and so ...
RObject r_call( get_current_call() );
PyObject* r_call_capsule(py_capsule_new(r_call));
PyObject_SetAttrString(excValue, "call", r_call_capsule);
Py_DecRef(r_call_capsule);
}
// get the cppstack, r_cppstack
// FIXME: this doesn't seem to work, always returns NULL
// SEXP r_cppstack = PROTECT(rcpp_get_stack_trace());
// PyObject* r_cppstack_capsule(py_capsule_new(r_cppstack));
// UNPROTECT(1);
// PyObject_SetAttrString(excValue, "r_cppstack", r_cppstack_capsule);
// Py_DecRef(r_cppstack_capsule);
PyObjectRef cond(excValue, true);
static SEXP sym_py_last_exception = Rf_install("py_last_exception");
static SEXP pkg_globals = Rf_eval(Rf_install(".globals"), ns_reticulate); // eval to force PROMSXP
Rf_defineVar(sym_py_last_exception, cond, pkg_globals);
if (flush_std_buffers() == -1)
warning(
"Error encountered when flushing python buffers sys.stderr and "
"sys.stdout");
return cond;
}
// [[Rcpp::export]]
SEXP py_flush_output() {
if(s_is_python_initialized) {
GILScope _gil;
flush_std_buffers();
}
return R_NilValue;
}
class PyFlushOutputOnScopeExit {
public:
~PyFlushOutputOnScopeExit() {
if (flush_std_buffers() == -1)
warning(
"Error encountered when flushing python buffers sys.stderr and "
"sys.stdout");
}
};
std::string conditionMessage_from_py_exception(PyObject* exc) {
// invoke 'traceback.format_exception_only(<traceback>)'
static PyObject* format_exception_only = []() {
PyObjectPtr tb_module(py_import("traceback"));
if (tb_module.is_null()) {
PyErr_Print();
Rcpp::stop("Failed to format Python Exception; could not import traceback module");
}
PyObject* format_exception_only = PyObject_GetAttrString(tb_module, "format_exception_only");
if (format_exception_only == NULL) {
PyErr_Print();
Rcpp::stop("Failed to format Python Exception; could not get traceback.format_exception_only");
}
return format_exception_only;
}();
PyObjectPtr formatted(PyObject_CallFunctionObjArgs(
format_exception_only, Py_TYPE(exc), exc, NULL));
if (formatted.is_null()) {
PyErr_Print();
Rcpp::stop("Failed to format Python Exception; traceback.format_exception_only() raised an Exception");
}
// build error text
std::ostringstream oss;
// PyList_GetItem() returns a borrowed reference, no need to decref.
for (Py_ssize_t i = 0, n = PyList_Size(formatted); i < n; i++)
oss << as_std_string(PyList_GetItem(formatted, i));
static std::string hint = []() {
Environment pkg_env(Environment::namespace_env("reticulate"));
Function hint_fn = pkg_env[".py_last_error_hint"];
CharacterVector r_result = hint_fn();
return Rcpp::as<std::string>(r_result[0]);