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