Cleanup: duplicate includes
[blender-staging.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 = "with open(__file__, 'r') as f: exec(f.read())";
495
496                                 fclose(fp);
497
498                                 py_result = PyRun_String(pystring, Py_file_input, py_dict, py_dict);
499                         }
500 #else
501                         py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
502                         fclose(fp);
503 #endif
504                 }
505                 else {
506                         PyErr_Format(PyExc_IOError,
507                                      "Python file \"%s\" could not be opened: %s",
508                                      fn, strerror(errno));
509                         py_result = NULL;
510                 }
511         }
512
513         if (!py_result) {
514                 if (text) {
515                         if (do_jump) {
516                                 /* ensure text is valid before use, the script may have freed its self */
517                                 Main *bmain_new = CTX_data_main(C);
518                                 if ((bmain_old == bmain_new) && (BLI_findindex(&bmain_new->text, text) != -1)) {
519                                         python_script_error_jump_text(text);
520                                 }
521                         }
522                 }
523                 BPy_errors_to_report(reports);
524         }
525         else {
526                 Py_DECREF(py_result);
527         }
528
529         if (py_dict) {
530 #ifdef PYMODULE_CLEAR_WORKAROUND
531                 PyModuleObject *mmod = (PyModuleObject *)PyDict_GetItemString(PyThreadState_GET()->interp->modules, "__main__");
532                 PyObject *dict_back = mmod->md_dict;
533                 /* freeing the module will clear the namespace,
534                  * gives problems running classes defined in this namespace being used later. */
535                 mmod->md_dict = NULL;
536                 Py_DECREF(dict_back);
537 #endif
538
539 #undef PYMODULE_CLEAR_WORKAROUND
540         }
541
542         PyC_MainModule_Restore(main_mod);
543
544         bpy_context_clear(C, &gilstate);
545
546         return (py_result != NULL);
547 }
548
549 /* Can run a file or text block */
550 int BPY_filepath_exec(bContext *C, const char *filepath, struct ReportList *reports)
551 {
552         return python_script_exec(C, filepath, NULL, reports, false);
553 }
554
555
556 int BPY_text_exec(bContext *C, struct Text *text, struct ReportList *reports, const bool do_jump)
557 {
558         return python_script_exec(C, NULL, text, reports, do_jump);
559 }
560
561 void BPY_DECREF(void *pyob_ptr)
562 {
563         PyGILState_STATE gilstate = PyGILState_Ensure();
564         Py_DECREF((PyObject *)pyob_ptr);
565         PyGILState_Release(gilstate);
566 }
567
568 void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
569 {
570         PyGILState_STATE gilstate = PyGILState_Ensure();
571         const int do_invalidate = (Py_REFCNT((PyObject *)pyob_ptr) > 1);
572         Py_DECREF((PyObject *)pyob_ptr);
573         if (do_invalidate) {
574                 pyrna_invalidate(pyob_ptr);
575         }
576         PyGILState_Release(gilstate);
577 }
578
579 /* return -1 on error, else 0 */
580 int BPY_button_exec(bContext *C, const char *expr, double *value, const bool verbose)
581 {
582         PyGILState_STATE gilstate;
583         int error_ret = 0;
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         error_ret = PyC_RunString_AsNumber(expr, value, "<blender button>");
595
596         if (error_ret) {
597                 if (verbose) {
598                         BPy_errors_to_report_ex(CTX_wm_reports(C), false, false);
599                 }
600                 else {
601                         PyErr_Clear();
602                 }
603         }
604
605         bpy_context_clear(C, &gilstate);
606
607         return error_ret;
608 }
609
610 int BPY_string_exec_ex(bContext *C, const char *expr, bool use_eval)
611 {
612         PyGILState_STATE gilstate;
613         PyObject *main_mod = NULL;
614         PyObject *py_dict, *retval;
615         int error_ret = 0;
616         Main *bmain_back; /* XXX, quick fix for release (Copy Settings crash), needs further investigation */
617
618         if (!expr) return -1;
619
620         if (expr[0] == '\0') {
621                 return error_ret;
622         }
623
624         bpy_context_set(C, &gilstate);
625
626         PyC_MainModule_Backup(&main_mod);
627
628         py_dict = PyC_DefaultNameSpace("<blender string>");
629
630         bmain_back = bpy_import_main_get();
631         bpy_import_main_set(CTX_data_main(C));
632
633         retval = PyRun_String(expr, use_eval ? Py_eval_input : Py_file_input, py_dict, py_dict);
634
635         bpy_import_main_set(bmain_back);
636
637         if (retval == NULL) {
638                 error_ret = -1;
639
640                 BPy_errors_to_report(CTX_wm_reports(C));
641         }
642         else {
643                 Py_DECREF(retval);
644         }
645
646         PyC_MainModule_Restore(main_mod);
647
648         bpy_context_clear(C, &gilstate);
649         
650         return error_ret;
651 }
652
653 int BPY_string_exec(bContext *C, const char *expr)
654 {
655         return BPY_string_exec_ex(C, expr, true);
656 }
657
658 void BPY_modules_load_user(bContext *C)
659 {
660         PyGILState_STATE gilstate;
661         Main *bmain = CTX_data_main(C);
662         Text *text;
663
664         /* can happen on file load */
665         if (bmain == NULL)
666                 return;
667
668         /* update pointers since this can run from a nested script
669          * on file load */
670         if (py_call_level) {
671                 BPY_context_update(C);
672         }
673
674         bpy_context_set(C, &gilstate);
675
676         for (text = bmain->text.first; text; text = text->id.next) {
677                 if (text->flags & TXT_ISSCRIPT && BLI_testextensie(text->id.name + 2, ".py")) {
678                         if (!(G.f & G_SCRIPT_AUTOEXEC)) {
679                                 if (!(G.f & G_SCRIPT_AUTOEXEC_FAIL_QUIET)) {
680                                         G.f |= G_SCRIPT_AUTOEXEC_FAIL;
681                                         BLI_snprintf(G.autoexec_fail, sizeof(G.autoexec_fail), "Text '%s'", text->id.name + 2);
682
683                                         printf("scripts disabled for \"%s\", skipping '%s'\n", bmain->name, text->id.name + 2);
684                                 }
685                         }
686                         else {
687                                 PyObject *module = bpy_text_import(text);
688
689                                 if (module == NULL) {
690                                         PyErr_Print();
691                                         PyErr_Clear();
692                                 }
693                                 else {
694                                         Py_DECREF(module);
695                                 }
696
697                                 /* check if the script loaded a new file */
698                                 if (bmain != CTX_data_main(C)) {
699                                         break;
700                                 }
701                         }
702                 }
703         }
704         bpy_context_clear(C, &gilstate);
705 }
706
707 int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
708 {
709         PyGILState_STATE gilstate;
710         bool use_gil = !PyC_IsInterpreterActive();
711
712         PyObject *pyctx;
713         PyObject *item;
714         PointerRNA *ptr = NULL;
715         bool done = false;
716
717         if (use_gil)
718                 gilstate = PyGILState_Ensure();
719
720         pyctx = (PyObject *)CTX_py_dict_get(C);
721         item = PyDict_GetItemString(pyctx, member);
722
723         if (item == NULL) {
724                 /* pass */
725         }
726         else if (item == Py_None) {
727                 done = true;
728         }
729         else if (BPy_StructRNA_Check(item)) {
730                 ptr = &(((BPy_StructRNA *)item)->ptr);
731
732                 //result->ptr = ((BPy_StructRNA *)item)->ptr;
733                 CTX_data_pointer_set(result, ptr->id.data, ptr->type, ptr->data);
734                 CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
735                 done = true;
736         }
737         else if (PySequence_Check(item)) {
738                 PyObject *seq_fast = PySequence_Fast(item, "bpy_context_get sequence conversion");
739                 if (seq_fast == NULL) {
740                         PyErr_Print();
741                         PyErr_Clear();
742                 }
743                 else {
744                         int len = PySequence_Fast_GET_SIZE(seq_fast);
745                         int i;
746                         for (i = 0; i < len; i++) {
747                                 PyObject *list_item = PySequence_Fast_GET_ITEM(seq_fast, i);
748
749                                 if (BPy_StructRNA_Check(list_item)) {
750 #if 0
751                                         CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "bpy_context_get");
752                                         link->ptr = ((BPy_StructRNA *)item)->ptr;
753                                         BLI_addtail(&result->list, link);
754 #endif
755                                         ptr = &(((BPy_StructRNA *)list_item)->ptr);
756                                         CTX_data_list_add(result, ptr->id.data, ptr->type, ptr->data);
757                                 }
758                                 else {
759                                         printf("PyContext: '%s' list item not a valid type in sequece type '%s'\n",
760                                                member, Py_TYPE(item)->tp_name);
761                                 }
762
763                         }
764                         Py_DECREF(seq_fast);
765                         CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
766                         done = true;
767                 }
768         }
769
770         if (done == false) {
771                 if (item) {
772                         printf("PyContext '%s' not a valid type\n", member);
773                 }
774                 else {
775                         printf("PyContext '%s' not found\n", member);
776                 }
777         }
778         else {
779                 if (G.debug & G_DEBUG_PYTHON) {
780                         printf("PyContext '%s' found\n", member);
781                 }
782         }
783
784         if (use_gil)
785                 PyGILState_Release(gilstate);
786
787         return done;
788 }
789
790 #ifdef WITH_PYTHON_MODULE
791 /* TODO, reloading the module isn't functional at the moment. */
792
793 static void bpy_module_free(void *mod);
794 extern int main_python_enter(int argc, const char **argv);
795 extern void main_python_exit(void);
796 static struct PyModuleDef bpy_proxy_def = {
797         PyModuleDef_HEAD_INIT,
798         "bpy",  /* m_name */
799         NULL,  /* m_doc */
800         0,  /* m_size */
801         NULL,  /* m_methods */
802         NULL,  /* m_reload */
803         NULL,  /* m_traverse */
804         NULL,  /* m_clear */
805         bpy_module_free,  /* m_free */
806 };
807
808 typedef struct {
809         PyObject_HEAD
810         /* Type-specific fields go here. */
811         PyObject *mod;
812 } dealloc_obj;
813
814 /* call once __file__ is set */
815 static void bpy_module_delay_init(PyObject *bpy_proxy)
816 {
817         const int argc = 1;
818         const char *argv[2];
819
820         /* updating the module dict below will loose the reference to __file__ */
821         PyObject *filename_obj = PyModule_GetFilenameObject(bpy_proxy);
822
823         const char *filename_rel = _PyUnicode_AsString(filename_obj); /* can be relative */
824         char filename_abs[1024];
825
826         BLI_strncpy(filename_abs, filename_rel, sizeof(filename_abs));
827         BLI_path_cwd(filename_abs);
828
829         argv[0] = filename_abs;
830         argv[1] = NULL;
831         
832         // printf("module found %s\n", argv[0]);
833
834         main_python_enter(argc, argv);
835
836         /* initialized in BPy_init_modules() */
837         PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py));
838 }
839
840 static void dealloc_obj_dealloc(PyObject *self);
841
842 static PyTypeObject dealloc_obj_Type;
843
844 /* use our own dealloc so we can free a property if we use one */
845 static void dealloc_obj_dealloc(PyObject *self)
846 {
847         bpy_module_delay_init(((dealloc_obj *)self)->mod);
848
849         /* Note, for subclassed PyObjects we cant just call PyObject_DEL() directly or it will crash */
850         dealloc_obj_Type.tp_free(self);
851 }
852
853 PyMODINIT_FUNC
854 PyInit_bpy(void);
855
856 PyMODINIT_FUNC
857 PyInit_bpy(void)
858 {
859         PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def);
860         
861         /* Problem:
862          * 1) this init function is expected to have a private member defined - 'md_def'
863          *    but this is only set for C defined modules (not py packages)
864          *    so we cant return 'bpy_package_py' as is.
865          *
866          * 2) there is a 'bpy' C module for python to load which is basically all of blender,
867          *    and there is scripts/bpy/__init__.py, 
868          *    we may end up having to rename this module so there is no naming conflict here eg:
869          *    'from blender import bpy'
870          *
871          * 3) we don't know the filename at this point, workaround by assigning a dummy value
872          *    which calls back when its freed so the real loading can take place.
873          */
874
875         /* assign an object which is freed after __file__ is assigned */
876         dealloc_obj *dob;
877         
878         /* assign dummy type */
879         dealloc_obj_Type.tp_name = "dealloc_obj";
880         dealloc_obj_Type.tp_basicsize = sizeof(dealloc_obj);
881         dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
882         dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
883         
884         if (PyType_Ready(&dealloc_obj_Type) < 0)
885                 return NULL;
886
887         dob = (dealloc_obj *) dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0);
888         dob->mod = bpy_proxy; /* borrow */
889         PyModule_AddObject(bpy_proxy, "__file__", (PyObject *)dob); /* borrow */
890
891         return bpy_proxy;
892 }
893
894 static void bpy_module_free(void *UNUSED(mod))
895 {
896         main_python_exit();
897 }
898
899 #endif
900
901
902 /* EVIL, define text.c functions here... */
903 /* BKE_text.h */
904 int text_check_identifier_unicode(const unsigned int ch)
905 {
906         return (ch < 255 && text_check_identifier((char)ch)) || Py_UNICODE_ISALNUM(ch);
907 }
908
909 int text_check_identifier_nodigit_unicode(const unsigned int ch)
910 {
911         return (ch < 255 && text_check_identifier_nodigit((char)ch)) || Py_UNICODE_ISALPHA(ch);
912 }