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