fb89d7c9e30780ec8512dc4f2661d1e6bf838977
[blender.git] / source / blender / python / generic / bpy_internal_import.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): Willian P. Germano, Campbell Barton
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/python/generic/bpy_internal_import.c
24  *  \ingroup pygen
25  *
26  * This file defines replacements for pythons '__import__' and 'imp.reload'
27  * functions which can import from blender textblocks.
28  *
29  * \note
30  * This should eventually be replaced by import hooks (pep 302).
31  */
32
33
34 #include <Python.h>
35 #include <stddef.h>
36
37 #include "MEM_guardedalloc.h"
38
39 #include "DNA_text_types.h"
40
41 #include "BLI_listbase.h"
42 #include "BLI_path_util.h"
43 #include "BLI_string.h"
44 #include "BLI_utildefines.h"
45
46 /* UNUSED */
47 #include "BKE_text.h"  /* txt_to_buf */
48 #include "BKE_main.h"
49
50 #include "py_capi_utils.h"
51
52 #include "bpy_internal_import.h"  /* own include */
53
54 static Main *bpy_import_main = NULL;
55 static ListBase bpy_import_main_list;
56
57 static PyMethodDef bpy_import_meth;
58 static PyMethodDef bpy_reload_meth;
59 static PyObject   *imp_reload_orig = NULL;
60
61 /* 'builtins' is most likely PyEval_GetBuiltins() */
62
63 /**
64  * \note to the discerning developer, yes - this is nasty
65  * monkey-patching our own import into Python's builtin 'imp' module.
66  *
67  * However Python's alternative is to use import hooks,
68  * which are implemented in a way that we can't use our own importer as a
69  * fall-back (instead we must try and fail - raise an exception every time).
70  * Since importing from blenders text-blocks is not the common case
71  * I prefer to use Pythons import by default and fall-back to
72  * Blenders - which we can only do by intercepting import calls I'm afraid.
73  * - Campbell
74  */
75 void bpy_import_init(PyObject *builtins)
76 {
77         PyObject *item;
78         PyObject *mod;
79
80         PyDict_SetItemString(builtins, "__import__", item = PyCFunction_New(&bpy_import_meth, NULL)); Py_DECREF(item);
81
82         /* move reload here
83          * XXX, use import hooks */
84         mod = PyImport_ImportModuleLevel("importlib", NULL, NULL, NULL, 0);
85         if (mod) {
86                 PyObject *mod_dict = PyModule_GetDict(mod);
87
88                 /* blender owns the function */
89                 imp_reload_orig = PyDict_GetItemString(mod_dict, "reload");
90                 Py_INCREF(imp_reload_orig);
91
92                 PyDict_SetItemString(mod_dict, "reload", item = PyCFunction_New(&bpy_reload_meth, NULL)); Py_DECREF(item);
93                 Py_DECREF(mod);
94         }
95         else {
96                 BLI_assert(!"unable to load 'importlib' module.");
97         }
98 }
99
100
101 static void free_compiled_text(Text *text)
102 {
103         if (text->compiled) {
104                 Py_DECREF((PyObject *)text->compiled);
105         }
106         text->compiled = NULL;
107 }
108
109 struct Main *bpy_import_main_get(void)
110 {
111         return bpy_import_main;
112 }
113
114 void bpy_import_main_set(struct Main *maggie)
115 {
116         bpy_import_main = maggie;
117 }
118
119 void bpy_import_main_extra_add(struct Main *maggie)
120 {
121         BLI_addhead(&bpy_import_main_list, maggie);
122 }
123
124 void bpy_import_main_extra_remove(struct Main *maggie)
125 {
126         BLI_remlink_safe(&bpy_import_main_list, maggie);
127 }
128
129 /* returns a dummy filename for a textblock so we can tell what file a text block comes from */
130 void bpy_text_filename_get(char *fn, size_t fn_len, Text *text)
131 {
132         BLI_snprintf(fn, fn_len, "%s%c%s", ID_BLEND_PATH(bpy_import_main, &text->id), SEP, text->id.name + 2);
133 }
134
135 bool bpy_text_compile(Text *text)
136 {
137         char fn_dummy[FILE_MAX];
138         PyObject *fn_dummy_py;
139         char *buf;
140
141         bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
142
143         /* if previously compiled, free the object */
144         free_compiled_text(text);
145
146         fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);
147
148         buf = txt_to_buf(text);
149         text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);
150         MEM_freeN(buf);
151
152         Py_DECREF(fn_dummy_py);
153
154         if (PyErr_Occurred()) {
155                 PyErr_Print();
156                 PyErr_Clear();
157                 PySys_SetObject("last_traceback", NULL);
158                 free_compiled_text(text);
159                 return false;
160         }
161         else {
162                 return true;
163         }
164 }
165
166 PyObject *bpy_text_import(Text *text)
167 {
168         char modulename[MAX_ID_NAME + 2];
169         int len;
170
171         if (!text->compiled) {
172                 if (bpy_text_compile(text) == false) {
173                         return NULL;
174                 }
175         }
176
177         len = strlen(text->id.name + 2);
178         BLI_strncpy(modulename, text->id.name + 2, len);
179         modulename[len - 3] = '\0'; /* remove .py */
180         return PyImport_ExecCodeModule(modulename, text->compiled);
181 }
182
183 PyObject *bpy_text_import_name(const char *name, int *found)
184 {
185         Text *text;
186         char txtname[MAX_ID_NAME - 2];
187         int namelen = strlen(name);
188 //XXX   Main *maggie = bpy_import_main ? bpy_import_main:G.main;
189         Main *maggie = bpy_import_main;
190
191         *found = 0;
192
193         if (!maggie) {
194                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
195                 return NULL;
196         }
197
198         /* we know this cant be importable, the name is too long for blender! */
199         if (namelen >= (MAX_ID_NAME - 2) - 3)
200                 return NULL;
201
202         memcpy(txtname, name, namelen);
203         memcpy(&txtname[namelen], ".py", 4);
204
205         text = BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
206
207         if (text) {
208                 *found = 1;
209                 return bpy_text_import(text);
210         }
211
212         /* If we still haven't found the module try additional modules form bpy_import_main_list */
213         maggie = bpy_import_main_list.first;
214         while (maggie && !text) {
215                 text = BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
216                 maggie = maggie->next;
217         }
218
219         if (!text)
220                 return NULL;
221         else
222                 *found = 1;
223
224         return bpy_text_import(text);
225 }
226
227
228 /*
229  * find in-memory module and recompile
230  */
231
232 PyObject *bpy_text_reimport(PyObject *module, int *found)
233 {
234         Text *text;
235         const char *name;
236         const char *filepath;
237 //XXX   Main *maggie = bpy_import_main ? bpy_import_main:G.main;
238         Main *maggie = bpy_import_main;
239
240         if (!maggie) {
241                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
242                 return NULL;
243         }
244
245         *found = 0;
246
247         /* get name, filename from the module itself */
248         if ((name = PyModule_GetName(module)) == NULL)
249                 return NULL;
250
251         {
252                 PyObject *module_file = PyModule_GetFilenameObject(module);
253                 if (module_file == NULL) {
254                         return NULL;
255                 }
256                 filepath = _PyUnicode_AsString(module_file);
257                 Py_DECREF(module_file);
258                 if (filepath == NULL) {
259                         return NULL;
260                 }
261         }
262
263         /* look up the text object */
264         text = BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2);
265
266         /* uh-oh.... didn't find it */
267         if (!text)
268                 return NULL;
269         else
270                 *found = 1;
271
272         if (bpy_text_compile(text) == false) {
273                 return NULL;
274         }
275
276         /* make into a module */
277         return PyImport_ExecCodeModule(name, text->compiled);
278 }
279
280
281 static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
282 {
283         PyObject *exception, *err, *tb;
284         const char *name;
285         int found = 0;
286         PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
287         int level = 0; /* relative imports */
288         PyObject *newmodule;
289
290         static const char *_keywords[] = {"name", "globals", "locals", "fromlist", "level", NULL};
291         static _PyArg_Parser _parser = {"s|OOOi:bpy_import_meth", _keywords, 0};
292         if (!_PyArg_ParseTupleAndKeywordsFast(
293                 args, kw, &_parser,
294                 &name, &globals, &locals, &fromlist, &level))
295         {
296                 return NULL;
297         }
298
299         /* import existing builtin modules or modules that have been imported already */
300         newmodule = PyImport_ImportModuleLevel(name, globals, locals, fromlist, level);
301
302         if (newmodule)
303                 return newmodule;
304
305         PyErr_Fetch(&exception, &err, &tb); /* get the python error in case we cant import as blender text either */
306
307         /* importing from existing modules failed, see if we have this module as blender text */
308         newmodule = bpy_text_import_name(name, &found);
309
310         if (newmodule) { /* found module as blender text, ignore above exception */
311                 PyErr_Clear();
312                 Py_XDECREF(exception);
313                 Py_XDECREF(err);
314                 Py_XDECREF(tb);
315                 /* printf("imported from text buffer...\n"); */
316         }
317         else if (found == 1) { /* blender text module failed to execute but was found, use its error message */
318                 Py_XDECREF(exception);
319                 Py_XDECREF(err);
320                 Py_XDECREF(tb);
321                 return NULL;
322         }
323         else {
324                 /* no blender text was found that could import the module
325                  * reuse the original error from PyImport_ImportModuleEx */
326                 PyErr_Restore(exception, err, tb);
327         }
328         return newmodule;
329 }
330
331
332 /*
333  * our reload() module, to handle reloading in-memory scripts
334  */
335
336 static PyObject *blender_reload(PyObject *UNUSED(self), PyObject *module)
337 {
338         PyObject *exception, *err, *tb;
339         PyObject *newmodule = NULL;
340         int found = 0;
341
342         /* try reimporting from file */
343
344         /* in Py3.3 this just calls imp.reload() which we overwrite, causing recursive calls */
345         //newmodule = PyImport_ReloadModule(module);
346
347         newmodule = PyObject_CallFunctionObjArgs(imp_reload_orig, module, NULL);
348
349         if (newmodule)
350                 return newmodule;
351
352         /* no file, try importing from memory */
353         PyErr_Fetch(&exception, &err, &tb); /*restore for probable later use */
354
355         newmodule = bpy_text_reimport(module, &found);
356         if (newmodule) { /* found module as blender text, ignore above exception */
357                 PyErr_Clear();
358                 Py_XDECREF(exception);
359                 Py_XDECREF(err);
360                 Py_XDECREF(tb);
361                 /* printf("imported from text buffer...\n"); */
362         }
363         else if (found == 1) { /* blender text module failed to execute but was found, use its error message */
364                 Py_XDECREF(exception);
365                 Py_XDECREF(err);
366                 Py_XDECREF(tb);
367                 return NULL;
368         }
369         else {
370                 /* no blender text was found that could import the module
371                  * reuse the original error from PyImport_ImportModuleEx */
372                 PyErr_Restore(exception, err, tb);
373         }
374
375         return newmodule;
376 }
377
378 static PyMethodDef bpy_import_meth = {"bpy_import_meth", (PyCFunction)blender_import, METH_VARARGS | METH_KEYWORDS, "blenders import"};
379 static PyMethodDef bpy_reload_meth = {"bpy_reload_meth", (PyCFunction)blender_reload, METH_O, "blenders reload"};