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