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