Merge branch 'master' into blender2.8
[blender.git] / source / blender / python / intern / bpy_interface.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Michel Selten, Willian P. Germano, Stephen Swaney,
19  * Chris Keith, Chris Want, Ken Hughes, Campbell Barton
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/python/intern/bpy_interface.c
25  *  \ingroup pythonintern
26  *
27  * This file deals with embedding the python interpreter within blender,
28  * starting and stopping python and exposing blender/python modules so they can
29  * be accesses from scripts.
30  */
31
32 #include <Python.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "CLG_log.h"
37
38 #include "BLI_utildefines.h"
39 #include "BLI_path_util.h"
40 #include "BLI_fileops.h"
41 #include "BLI_listbase.h"
42 #include "BLI_string.h"
43 #include "BLI_string_utf8.h"
44 #include "BLI_threads.h"
45
46 #include "RNA_types.h"
47
48 #include "bpy.h"
49 #include "gpu.h"
50 #include "bpy_rna.h"
51 #include "bpy_path.h"
52 #include "bpy_capi_utils.h"
53 #include "bpy_traceback.h"
54 #include "bpy_intern_string.h"
55
56 #include "bpy_app_translations.h"
57
58 #include "DNA_text_types.h"
59
60 #include "BKE_appdir.h"
61 #include "BKE_context.h"
62 #include "BKE_text.h"
63 #include "BKE_main.h"
64 #include "BKE_global.h" /* only for script checking */
65
66 #include "CCL_api.h"
67
68 #include "BPY_extern.h"
69
70 #include "../generic/bpy_internal_import.h"  /* our own imports */
71 #include "../generic/py_capi_utils.h"
72
73 /* inittab initialization functions */
74 #include "../generic/bgl.h"
75 #include "../generic/blf_py_api.h"
76 #include "../generic/idprop_py_api.h"
77 #include "../generic/imbuf_py_api.h"
78 #include "../gawain/gwn_py_api.h"
79 #include "../bmesh/bmesh_py_api.h"
80 #include "../mathutils/mathutils.h"
81
82 /* Logging types to use anywhere in the Python modules. */
83 CLG_LOGREF_DECLARE_GLOBAL(BPY_LOG_CONTEXT, "bpy.context");
84 CLG_LOGREF_DECLARE_GLOBAL(BPY_LOG_RNA, "bpy.rna");
85
86 /* for internal use, when starting and ending python scripts */
87
88 /* in case a python script triggers another python call, stop bpy_context_clear from invalidating */
89 static int py_call_level = 0;
90 BPy_StructRNA *bpy_context_module = NULL; /* for fast access */
91
92 // #define TIME_PY_RUN // simple python tests. prints on exit.
93
94 #ifdef TIME_PY_RUN
95 #include "PIL_time.h"
96 static int     bpy_timer_count = 0;
97 static double  bpy_timer;   /* time since python starts */
98 static double  bpy_timer_run;   /* time for each python script run */
99 static double  bpy_timer_run_tot;   /* accumulate python runs */
100 #endif
101
102 /* use for updating while a python script runs - in case of file load */
103 void BPY_context_update(bContext *C)
104 {
105         /* don't do this from a non-main (e.g. render) thread, it can cause a race
106          * condition on C->data.recursion. ideal solution would be to disable
107          * context entirely from non-main threads, but that's more complicated */
108         if (!BLI_thread_is_main())
109                 return;
110
111         BPy_SetContext(C);
112         bpy_import_main_set(CTX_data_main(C));
113         BPY_modules_update(C); /* can give really bad results if this isn't here */
114 }
115
116 void bpy_context_set(bContext *C, PyGILState_STATE *gilstate)
117 {
118         py_call_level++;
119
120         if (gilstate)
121                 *gilstate = PyGILState_Ensure();
122
123         if (py_call_level == 1) {
124                 BPY_context_update(C);
125
126 #ifdef TIME_PY_RUN
127                 if (bpy_timer_count == 0) {
128                         /* record time from the beginning */
129                         bpy_timer = PIL_check_seconds_timer();
130                         bpy_timer_run = bpy_timer_run_tot = 0.0;
131                 }
132                 bpy_timer_run = PIL_check_seconds_timer();
133
134
135                 bpy_timer_count++;
136 #endif
137         }
138 }
139
140 /* context should be used but not now because it causes some bugs */
141 void bpy_context_clear(bContext *UNUSED(C), PyGILState_STATE *gilstate)
142 {
143         py_call_level--;
144
145         if (gilstate)
146                 PyGILState_Release(*gilstate);
147
148         if (py_call_level < 0) {
149                 fprintf(stderr, "ERROR: Python context internal state bug. this should not happen!\n");
150         }
151         else if (py_call_level == 0) {
152                 /* XXX - Calling classes currently wont store the context :\,
153                  * cant set NULL because of this. but this is very flakey still. */
154 #if 0
155                 BPy_SetContext(NULL);
156                 bpy_import_main_set(NULL);
157 #endif
158
159 #ifdef TIME_PY_RUN
160                 bpy_timer_run_tot += PIL_check_seconds_timer() - bpy_timer_run;
161                 bpy_timer_count++;
162 #endif
163
164         }
165 }
166
167 void BPY_text_free_code(Text *text)
168 {
169         if (text->compiled) {
170                 PyGILState_STATE gilstate;
171                 bool use_gil = !PyC_IsInterpreterActive();
172
173                 if (use_gil)
174                         gilstate = PyGILState_Ensure();
175
176                 Py_DECREF((PyObject *)text->compiled);
177                 text->compiled = NULL;
178
179                 if (use_gil)
180                         PyGILState_Release(gilstate);
181         }
182 }
183
184 void BPY_modules_update(bContext *C)
185 {
186 #if 0  /* slow, this runs all the time poll, draw etc 100's of time a sec. */
187         PyObject *mod = PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
188         PyModule_AddObject(mod, "data", BPY_rna_module());
189         PyModule_AddObject(mod, "types", BPY_rna_types());  /* atm this does not need updating */
190 #endif
191
192         /* refreshes the main struct */
193         BPY_update_rna_module();
194         if (bpy_context_module)
195                 bpy_context_module->ptr.data = (void *)C;
196 }
197
198 void BPY_context_set(bContext *C)
199 {
200         BPy_SetContext(C);
201 }
202
203 /* defined in AUD_C-API.cpp */
204 extern PyObject *AUD_initPython(void);
205
206 #ifdef WITH_CYCLES
207 /* defined in cycles module */
208 static PyObject *CCL_initPython(void)
209 {
210         return (PyObject *)CCL_python_module_init();
211 }
212 #endif
213
214 static struct _inittab bpy_internal_modules[] = {
215         {"mathutils", PyInit_mathutils},
216 #if 0
217         {"mathutils.geometry", PyInit_mathutils_geometry},
218         {"mathutils.noise", PyInit_mathutils_noise},
219         {"mathutils.kdtree", PyInit_mathutils_kdtree},
220 #endif
221         {"_bpy_path", BPyInit__bpy_path},
222         {"_gawain", BPyInit_gawain},
223         {"bgl", BPyInit_bgl},
224         {"blf", BPyInit_blf},
225         {"imbuf", BPyInit_imbuf},
226         {"bmesh", BPyInit_bmesh},
227 #if 0
228         {"bmesh.types", BPyInit_bmesh_types},
229         {"bmesh.utils", BPyInit_bmesh_utils},
230         {"bmesh.utils", BPyInit_bmesh_geometry},
231 #endif
232 #ifdef WITH_AUDASPACE
233         {"aud", AUD_initPython},
234 #endif
235 #ifdef WITH_CYCLES
236         {"_cycles", CCL_initPython},
237 #endif
238         {"gpu", GPU_initPython},
239         {"idprop", BPyInit_idprop},
240         {NULL, NULL}
241 };
242
243 /* call BPY_context_set first */
244 void BPY_python_start(int argc, const char **argv)
245 {
246 #ifndef WITH_PYTHON_MODULE
247         PyThreadState *py_tstate = NULL;
248         const char *py_path_bundle = BKE_appdir_folder_id(BLENDER_SYSTEM_PYTHON, NULL);
249
250         /* not essential but nice to set our name */
251         static wchar_t program_path_wchar[FILE_MAX]; /* python holds a reference */
252         BLI_strncpy_wchar_from_utf8(program_path_wchar, BKE_appdir_program_path(), ARRAY_SIZE(program_path_wchar));
253         Py_SetProgramName(program_path_wchar);
254
255         /* must run before python initializes */
256         PyImport_ExtendInittab(bpy_internal_modules);
257
258         /* allow to use our own included python */
259         PyC_SetHomePath(py_path_bundle);
260
261         /* without this the sys.stdout may be set to 'ascii'
262          * (it is on my system at least), where printing unicode values will raise
263          * an error, this is highly annoying, another stumbling block for devs,
264          * so use a more relaxed error handler and enforce utf-8 since the rest of
265          * blender is utf-8 too - campbell */
266         Py_SetStandardStreamEncoding("utf-8", "surrogateescape");
267
268         /* Update, Py3.3 resolves attempting to parse non-existing header */
269 #if 0
270         /* Python 3.2 now looks for '2.xx/python/include/python3.2d/pyconfig.h' to
271          * parse from the 'sysconfig' module which is used by 'site',
272          * so for now disable site. alternatively we could copy the file. */
273         if (py_path_bundle) {
274                 Py_NoSiteFlag = 1;
275         }
276 #endif
277
278         Py_FrozenFlag = 1;
279
280         Py_Initialize();
281
282         // PySys_SetArgv(argc, argv);  /* broken in py3, not a huge deal */
283         /* sigh, why do python guys not have a (char **) version anymore? */
284         {
285                 int i;
286                 PyObject *py_argv = PyList_New(argc);
287                 for (i = 0; i < argc; i++) {
288                         /* should fix bug #20021 - utf path name problems, by replacing
289                          * PyUnicode_FromString, with this one */
290                         PyList_SET_ITEM(py_argv, i, PyC_UnicodeFromByte(argv[i]));
291                 }
292
293                 PySys_SetObject("argv", py_argv);
294                 Py_DECREF(py_argv);
295         }
296
297         /* Initialize thread support (also acquires lock) */
298         PyEval_InitThreads();
299 #else
300         (void)argc;
301         (void)argv;
302
303         /* must run before python initializes */
304         /* broken in py3.3, load explicitly below */
305         // PyImport_ExtendInittab(bpy_internal_modules);
306 #endif
307
308         bpy_intern_string_init();
309
310
311 #ifdef WITH_PYTHON_MODULE
312         {
313                 /* Manually load all modules */
314                 struct _inittab *inittab_item;
315                 PyObject *sys_modules = PyImport_GetModuleDict();
316
317                 for (inittab_item = bpy_internal_modules; inittab_item->name; inittab_item++) {
318                         PyObject *mod = inittab_item->initfunc();
319                         if (mod) {
320                                 PyDict_SetItemString(sys_modules, inittab_item->name, mod);
321                         }
322                         else {
323                                 PyErr_Print();
324                                 PyErr_Clear();
325                         }
326                         // Py_DECREF(mod); /* ideally would decref, but in this case we never want to free */
327                 }
328         }
329 #endif
330
331         /* bpy.* and lets us import it */
332         BPy_init_modules();
333
334         bpy_import_init(PyEval_GetBuiltins());
335
336         pyrna_alloc_types();
337
338 #ifndef WITH_PYTHON_MODULE
339         /* py module runs atexit when bpy is freed */
340         BPY_atexit_register(); /* this can init any time */
341
342         py_tstate = PyGILState_GetThisThreadState();
343         PyEval_ReleaseThread(py_tstate);
344 #endif
345 }
346
347 void BPY_python_end(void)
348 {
349         // fprintf(stderr, "Ending Python!\n");
350         PyGILState_STATE gilstate;
351
352         /* finalizing, no need to grab the state, except when we are a module */
353         gilstate = PyGILState_Ensure();
354
355         /* free other python data. */
356         pyrna_free_types();
357
358         /* clear all python data from structs */
359
360         bpy_intern_string_exit();
361
362         /* bpy.app modules that need cleanup */
363         BPY_app_translations_end();
364
365 #ifndef WITH_PYTHON_MODULE
366         BPY_atexit_unregister(); /* without this we get recursive calls to WM_exit */
367
368         Py_Finalize();
369
370         (void)gilstate;
371 #else
372         PyGILState_Release(gilstate);
373 #endif
374
375 #ifdef TIME_PY_RUN
376         /* measure time since py started */
377         bpy_timer = PIL_check_seconds_timer() - bpy_timer;
378
379         printf("*bpy stats* - ");
380         printf("tot exec: %d,  ", bpy_timer_count);
381         printf("tot run: %.4fsec,  ", bpy_timer_run_tot);
382         if (bpy_timer_count > 0)
383                 printf("average run: %.6fsec,  ", (bpy_timer_run_tot / bpy_timer_count));
384
385         if (bpy_timer > 0.0)
386                 printf("tot usage %.4f%%", (bpy_timer_run_tot / bpy_timer) * 100.0);
387
388         printf("\n");
389
390         // fprintf(stderr, "Ending Python Done!\n");
391
392 #endif
393
394 }
395
396 void BPY_python_reset(bContext *C)
397 {
398         /* unrelated security stuff */
399         G.f &= ~(G_SCRIPT_AUTOEXEC_FAIL | G_SCRIPT_AUTOEXEC_FAIL_QUIET);
400         G.autoexec_fail[0] = '\0';
401
402         BPY_driver_reset();
403         BPY_app_handlers_reset(false);
404         BPY_modules_load_user(C);
405 }
406
407 static void python_script_error_jump_text(struct Text *text)
408 {
409         int lineno;
410         int offset;
411         python_script_error_jump(text->id.name + 2, &lineno, &offset);
412         if (lineno != -1) {
413                 /* select the line with the error */
414                 txt_move_to(text, lineno - 1, INT_MAX, false);
415                 txt_move_to(text, lineno - 1, offset, true);
416         }
417 }
418
419 /* super annoying, undo _PyModule_Clear(), bug [#23871] */
420 #define PYMODULE_CLEAR_WORKAROUND
421
422 #ifdef PYMODULE_CLEAR_WORKAROUND
423 /* bad!, we should never do this, but currently only safe way I could find to keep namespace.
424  * from being cleared. - campbell */
425 typedef struct {
426         PyObject_HEAD
427         PyObject *md_dict;
428         /* omit other values, we only want the dict. */
429 } PyModuleObject;
430 #endif
431
432 static bool python_script_exec(
433         bContext *C, const char *fn, struct Text *text,
434         struct ReportList *reports, const bool do_jump)
435 {
436         Main *bmain_old = CTX_data_main(C);
437         PyObject *main_mod = NULL;
438         PyObject *py_dict = NULL, *py_result = NULL;
439         PyGILState_STATE gilstate;
440
441         BLI_assert(fn || text);
442
443         if (fn == NULL && text == NULL) {
444                 return 0;
445         }
446
447         bpy_context_set(C, &gilstate);
448
449         PyC_MainModule_Backup(&main_mod);
450
451         if (text) {
452                 char fn_dummy[FILE_MAXDIR];
453                 bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
454
455                 if (text->compiled == NULL) {   /* if it wasn't already compiled, do it now */
456                         char *buf;
457                         PyObject *fn_dummy_py;
458
459                         fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);
460
461                         buf = txt_to_buf(text);
462                         text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);
463                         MEM_freeN(buf);
464
465                         Py_DECREF(fn_dummy_py);
466
467                         if (PyErr_Occurred()) {
468                                 if (do_jump) {
469                                         python_script_error_jump_text(text);
470                                 }
471                                 BPY_text_free_code(text);
472                         }
473                 }
474
475                 if (text->compiled) {
476                         py_dict = PyC_DefaultNameSpace(fn_dummy);
477                         py_result =  PyEval_EvalCode(text->compiled, py_dict, py_dict);
478                 }
479
480         }
481         else {
482                 FILE *fp = BLI_fopen(fn, "r");
483
484                 if (fp) {
485                         py_dict = PyC_DefaultNameSpace(fn);
486
487 #ifdef _WIN32
488                         /* Previously we used PyRun_File to run directly the code on a FILE
489                          * object, but as written in the Python/C API Ref Manual, chapter 2,
490                          * 'FILE structs for different C libraries can be different and
491                          * incompatible'.
492                          * So now we load the script file data to a buffer.
493                          *
494                          * Note on use of 'globals()', it's important not copy the dictionary because
495                          * tools may inspect 'sys.modules["__main__"]' for variables defined in the code
496                          * where using a copy of 'globals()' causes code execution
497                          * to leave the main namespace untouched. see: T51444
498                          *
499                          * This leaves us with the problem of variables being included,
500                          * currently this is worked around using 'dict.__del__' it's ugly but works.
501                          */
502                         {
503                                 const char *pystring =
504                                         "with open(__file__, 'rb') as f:"
505                                         "exec(compile(f.read(), __file__, 'exec'), globals().__delitem__('f') or globals())";
506
507                                 fclose(fp);
508
509                                 py_result = PyRun_String(pystring, Py_file_input, py_dict, py_dict);
510                         }
511 #else
512                         py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
513                         fclose(fp);
514 #endif
515                 }
516                 else {
517                         PyErr_Format(PyExc_IOError,
518                                      "Python file \"%s\" could not be opened: %s",
519                                      fn, strerror(errno));
520                         py_result = NULL;
521                 }
522         }
523
524         if (!py_result) {
525                 if (text) {
526                         if (do_jump) {
527                                 /* ensure text is valid before use, the script may have freed its self */
528                                 Main *bmain_new = CTX_data_main(C);
529                                 if ((bmain_old == bmain_new) && (BLI_findindex(&bmain_new->text, text) != -1)) {
530                                         python_script_error_jump_text(text);
531                                 }
532                         }
533                 }
534                 BPy_errors_to_report(reports);
535         }
536         else {
537                 Py_DECREF(py_result);
538         }
539
540         if (py_dict) {
541 #ifdef PYMODULE_CLEAR_WORKAROUND
542                 PyModuleObject *mmod = (PyModuleObject *)PyDict_GetItem(
543                         PyThreadState_GET()->interp->modules, bpy_intern_str___main__);
544                 PyObject *dict_back = mmod->md_dict;
545                 /* freeing the module will clear the namespace,
546                  * gives problems running classes defined in this namespace being used later. */
547                 mmod->md_dict = NULL;
548                 Py_DECREF(dict_back);
549 #endif
550
551 #undef PYMODULE_CLEAR_WORKAROUND
552         }
553
554         PyC_MainModule_Restore(main_mod);
555
556         bpy_context_clear(C, &gilstate);
557
558         return (py_result != NULL);
559 }
560
561 /* Can run a file or text block */
562 bool BPY_execute_filepath(bContext *C, const char *filepath, struct ReportList *reports)
563 {
564         return python_script_exec(C, filepath, NULL, reports, false);
565 }
566
567
568 bool BPY_execute_text(bContext *C, struct Text *text, struct ReportList *reports, const bool do_jump)
569 {
570         return python_script_exec(C, NULL, text, reports, do_jump);
571 }
572
573 void BPY_DECREF(void *pyob_ptr)
574 {
575         PyGILState_STATE gilstate = PyGILState_Ensure();
576         Py_DECREF((PyObject *)pyob_ptr);
577         PyGILState_Release(gilstate);
578 }
579
580 void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
581 {
582         PyGILState_STATE gilstate = PyGILState_Ensure();
583         const int do_invalidate = (Py_REFCNT((PyObject *)pyob_ptr) > 1);
584         Py_DECREF((PyObject *)pyob_ptr);
585         if (do_invalidate) {
586                 pyrna_invalidate(pyob_ptr);
587         }
588         PyGILState_Release(gilstate);
589 }
590
591 /**
592  * \return success
593  */
594 bool BPY_execute_string_as_number(bContext *C, const char *expr, const bool verbose, double *r_value)
595 {
596         PyGILState_STATE gilstate;
597         bool ok = true;
598
599         if (!r_value || !expr) {
600                 return -1;
601         }
602
603         if (expr[0] == '\0') {
604                 *r_value = 0.0;
605                 return ok;
606         }
607
608         bpy_context_set(C, &gilstate);
609
610         ok = PyC_RunString_AsNumber(expr, "<blender button>", r_value);
611
612         if (ok == false) {
613                 if (verbose) {
614                         BPy_errors_to_report_ex(CTX_wm_reports(C), false, false);
615                 }
616                 else {
617                         PyErr_Clear();
618                 }
619         }
620
621         bpy_context_clear(C, &gilstate);
622
623         return ok;
624 }
625
626 /**
627  * \return success
628  */
629 bool BPY_execute_string_as_string(bContext *C, const char *expr, const bool verbose, char **r_value)
630 {
631         PyGILState_STATE gilstate;
632         bool ok = true;
633
634         if (!r_value || !expr) {
635                 return -1;
636         }
637
638         if (expr[0] == '\0') {
639                 *r_value = NULL;
640                 return ok;
641         }
642
643         bpy_context_set(C, &gilstate);
644
645         ok = PyC_RunString_AsString(expr, "<blender button>", r_value);
646
647         if (ok == false) {
648                 if (verbose) {
649                         BPy_errors_to_report_ex(CTX_wm_reports(C), false, false);
650                 }
651                 else {
652                         PyErr_Clear();
653                 }
654         }
655
656         bpy_context_clear(C, &gilstate);
657
658         return ok;
659 }
660
661
662 bool BPY_execute_string_ex(bContext *C, const char *expr, bool use_eval)
663 {
664         PyGILState_STATE gilstate;
665         PyObject *main_mod = NULL;
666         PyObject *py_dict, *retval;
667         bool ok = true;
668         Main *bmain_back; /* XXX, quick fix for release (Copy Settings crash), needs further investigation */
669
670         if (!expr) return -1;
671
672         if (expr[0] == '\0') {
673                 return ok;
674         }
675
676         bpy_context_set(C, &gilstate);
677
678         PyC_MainModule_Backup(&main_mod);
679
680         py_dict = PyC_DefaultNameSpace("<blender string>");
681
682         bmain_back = bpy_import_main_get();
683         bpy_import_main_set(CTX_data_main(C));
684
685         retval = PyRun_String(expr, use_eval ? Py_eval_input : Py_file_input, py_dict, py_dict);
686
687         bpy_import_main_set(bmain_back);
688
689         if (retval == NULL) {
690                 ok = false;
691
692                 BPy_errors_to_report(CTX_wm_reports(C));
693         }
694         else {
695                 Py_DECREF(retval);
696         }
697
698         PyC_MainModule_Restore(main_mod);
699
700         bpy_context_clear(C, &gilstate);
701
702         return ok;
703 }
704
705 bool BPY_execute_string(bContext *C, const char *expr)
706 {
707         return BPY_execute_string_ex(C, expr, true);
708 }
709
710 void BPY_modules_load_user(bContext *C)
711 {
712         PyGILState_STATE gilstate;
713         Main *bmain = CTX_data_main(C);
714         Text *text;
715
716         /* can happen on file load */
717         if (bmain == NULL)
718                 return;
719
720         /* update pointers since this can run from a nested script
721          * on file load */
722         if (py_call_level) {
723                 BPY_context_update(C);
724         }
725
726         bpy_context_set(C, &gilstate);
727
728         for (text = bmain->text.first; text; text = text->id.next) {
729                 if (text->flags & TXT_ISSCRIPT && BLI_path_extension_check(text->id.name + 2, ".py")) {
730                         if (!(G.f & G_SCRIPT_AUTOEXEC)) {
731                                 if (!(G.f & G_SCRIPT_AUTOEXEC_FAIL_QUIET)) {
732                                         G.f |= G_SCRIPT_AUTOEXEC_FAIL;
733                                         BLI_snprintf(G.autoexec_fail, sizeof(G.autoexec_fail), "Text '%s'", text->id.name + 2);
734
735                                         printf("scripts disabled for \"%s\", skipping '%s'\n", BKE_main_blendfile_path(bmain), text->id.name + 2);
736                                 }
737                         }
738                         else {
739                                 PyObject *module = bpy_text_import(text);
740
741                                 if (module == NULL) {
742                                         PyErr_Print();
743                                         PyErr_Clear();
744                                 }
745                                 else {
746                                         Py_DECREF(module);
747                                 }
748
749                                 /* check if the script loaded a new file */
750                                 if (bmain != CTX_data_main(C)) {
751                                         break;
752                                 }
753                         }
754                 }
755         }
756         bpy_context_clear(C, &gilstate);
757 }
758
759 int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
760 {
761         PyGILState_STATE gilstate;
762         bool use_gil = !PyC_IsInterpreterActive();
763
764         PyObject *pyctx;
765         PyObject *item;
766         PointerRNA *ptr = NULL;
767         bool done = false;
768
769         if (use_gil)
770                 gilstate = PyGILState_Ensure();
771
772         pyctx = (PyObject *)CTX_py_dict_get(C);
773         item = PyDict_GetItemString(pyctx, member);
774
775         if (item == NULL) {
776                 /* pass */
777         }
778         else if (item == Py_None) {
779                 done = true;
780         }
781         else if (BPy_StructRNA_Check(item)) {
782                 ptr = &(((BPy_StructRNA *)item)->ptr);
783
784                 //result->ptr = ((BPy_StructRNA *)item)->ptr;
785                 CTX_data_pointer_set(result, ptr->id.data, ptr->type, ptr->data);
786                 CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
787                 done = true;
788         }
789         else if (PySequence_Check(item)) {
790                 PyObject *seq_fast = PySequence_Fast(item, "bpy_context_get sequence conversion");
791                 if (seq_fast == NULL) {
792                         PyErr_Print();
793                         PyErr_Clear();
794                 }
795                 else {
796                         int len = PySequence_Fast_GET_SIZE(seq_fast);
797                         PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
798                         int i;
799
800                         for (i = 0; i < len; i++) {
801                                 PyObject *list_item = seq_fast_items[i];
802
803                                 if (BPy_StructRNA_Check(list_item)) {
804 #if 0
805                                         CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "bpy_context_get");
806                                         link->ptr = ((BPy_StructRNA *)item)->ptr;
807                                         BLI_addtail(&result->list, link);
808 #endif
809                                         ptr = &(((BPy_StructRNA *)list_item)->ptr);
810                                         CTX_data_list_add(result, ptr->id.data, ptr->type, ptr->data);
811                                 }
812                                 else {
813                                         CLOG_INFO(BPY_LOG_CONTEXT, 1,
814                                                   "'%s' list item not a valid type in sequence type '%s'",
815                                                   member, Py_TYPE(item)->tp_name);
816                                 }
817
818                         }
819                         Py_DECREF(seq_fast);
820                         CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
821                         done = true;
822                 }
823         }
824
825         if (done == false) {
826                 if (item) {
827                         CLOG_INFO(BPY_LOG_CONTEXT, 1, "'%s' not a valid type", member);
828                 }
829                 else {
830                         CLOG_INFO(BPY_LOG_CONTEXT, 1, "'%s' not found\n", member);
831                 }
832         }
833         else {
834                 CLOG_INFO(BPY_LOG_CONTEXT, 2, "'%s' found", member);
835         }
836
837         if (use_gil)
838                 PyGILState_Release(gilstate);
839
840         return done;
841 }
842
843 #ifdef WITH_PYTHON_MODULE
844 /* TODO, reloading the module isn't functional at the moment. */
845
846 static void bpy_module_free(void *mod);
847 extern int main_python_enter(int argc, const char **argv);
848 extern void main_python_exit(void);
849 static struct PyModuleDef bpy_proxy_def = {
850         PyModuleDef_HEAD_INIT,
851         "bpy",  /* m_name */
852         NULL,  /* m_doc */
853         0,  /* m_size */
854         NULL,  /* m_methods */
855         NULL,  /* m_reload */
856         NULL,  /* m_traverse */
857         NULL,  /* m_clear */
858         bpy_module_free,  /* m_free */
859 };
860
861 typedef struct {
862         PyObject_HEAD
863         /* Type-specific fields go here. */
864         PyObject *mod;
865 } dealloc_obj;
866
867 /* call once __file__ is set */
868 static void bpy_module_delay_init(PyObject *bpy_proxy)
869 {
870         const int argc = 1;
871         const char *argv[2];
872
873         /* updating the module dict below will loose the reference to __file__ */
874         PyObject *filename_obj = PyModule_GetFilenameObject(bpy_proxy);
875
876         const char *filename_rel = _PyUnicode_AsString(filename_obj); /* can be relative */
877         char filename_abs[1024];
878
879         BLI_strncpy(filename_abs, filename_rel, sizeof(filename_abs));
880         BLI_path_cwd(filename_abs, sizeof(filename_abs));
881         Py_DECREF(filename_obj);
882
883         argv[0] = filename_abs;
884         argv[1] = NULL;
885
886         // printf("module found %s\n", argv[0]);
887
888         main_python_enter(argc, argv);
889
890         /* initialized in BPy_init_modules() */
891         PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py));
892 }
893
894 static void dealloc_obj_dealloc(PyObject *self);
895
896 static PyTypeObject dealloc_obj_Type;
897
898 /* use our own dealloc so we can free a property if we use one */
899 static void dealloc_obj_dealloc(PyObject *self)
900 {
901         bpy_module_delay_init(((dealloc_obj *)self)->mod);
902
903         /* Note, for subclassed PyObjects we cant just call PyObject_DEL() directly or it will crash */
904         dealloc_obj_Type.tp_free(self);
905 }
906
907 PyMODINIT_FUNC
908 PyInit_bpy(void);
909
910 PyMODINIT_FUNC
911 PyInit_bpy(void)
912 {
913         PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def);
914
915         /* Problem:
916          * 1) this init function is expected to have a private member defined - 'md_def'
917          *    but this is only set for C defined modules (not py packages)
918          *    so we cant return 'bpy_package_py' as is.
919          *
920          * 2) there is a 'bpy' C module for python to load which is basically all of blender,
921          *    and there is scripts/bpy/__init__.py,
922          *    we may end up having to rename this module so there is no naming conflict here eg:
923          *    'from blender import bpy'
924          *
925          * 3) we don't know the filename at this point, workaround by assigning a dummy value
926          *    which calls back when its freed so the real loading can take place.
927          */
928
929         /* assign an object which is freed after __file__ is assigned */
930         dealloc_obj *dob;
931
932         /* assign dummy type */
933         dealloc_obj_Type.tp_name = "dealloc_obj";
934         dealloc_obj_Type.tp_basicsize = sizeof(dealloc_obj);
935         dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
936         dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
937
938         if (PyType_Ready(&dealloc_obj_Type) < 0)
939                 return NULL;
940
941         dob = (dealloc_obj *) dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0);
942         dob->mod = bpy_proxy; /* borrow */
943         PyModule_AddObject(bpy_proxy, "__file__", (PyObject *)dob); /* borrow */
944
945         return bpy_proxy;
946 }
947
948 static void bpy_module_free(void *UNUSED(mod))
949 {
950         main_python_exit();
951 }
952
953 #endif
954
955 /**
956  * Avoids duplicating keyword list.
957  */
958 bool BPY_string_is_keyword(const char *str)
959 {
960         /* list is from...
961          * ", ".join(['"%s"' % kw for kw in  __import__("keyword").kwlist])
962          */
963         const char *kwlist[] = {
964             "False", "None", "True",
965             "and", "as", "assert", "break",
966             "class", "continue", "def", "del", "elif", "else", "except",
967             "finally", "for", "from", "global", "if", "import", "in",
968             "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
969             "return", "try", "while", "with", "yield", NULL,
970         };
971
972         for (int i = 0; kwlist[i]; i++) {
973                 if (STREQ(str, kwlist[i])) {
974                         return true;
975                 }
976         }
977
978         return false;
979 }
980
981
982 /* EVIL, define text.c functions here... */
983 /* BKE_text.h */
984 int text_check_identifier_unicode(const unsigned int ch)
985 {
986         return (ch < 255 && text_check_identifier((char)ch)) || Py_UNICODE_ISALNUM(ch);
987 }
988
989 int text_check_identifier_nodigit_unicode(const unsigned int ch)
990 {
991         return (ch < 255 && text_check_identifier_nodigit((char)ch)) || Py_UNICODE_ISALPHA(ch);
992 }