py api: add restrict state context manager (thats python's context not blenders context),
[blender.git] / release / scripts / modules / addon_utils.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2 #
3 #  This program is free software; you can redistribute it and/or
4 #  modify it under the terms of the GNU General Public License
5 #  as published by the Free Software Foundation; either version 2
6 #  of the License, or (at your option) any later version.
7 #
8 #  This program is distributed in the hope that it will be useful,
9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 #  GNU General Public License for more details.
12 #
13 #  You should have received a copy of the GNU General Public License
14 #  along with this program; if not, write to the Free Software Foundation,
15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 # <pep8-80 compliant>
20
21 __all__ = (
22     "paths",
23     "modules",
24     "check",
25     "enable",
26     "disable",
27     "reset_all",
28     "module_bl_info",
29     )
30
31 import bpy as _bpy
32 _user_preferences = _bpy.context.user_preferences
33
34 error_duplicates = False
35 error_encoding = False
36 addons_fake_modules = {}
37
38
39 def paths():
40     # RELEASE SCRIPTS: official scripts distributed in Blender releases
41     addon_paths = _bpy.utils.script_paths("addons")
42
43     # CONTRIB SCRIPTS: good for testing but not official scripts yet
44     # if folder addons_contrib/ exists, scripts in there will be loaded too
45     addon_paths += _bpy.utils.script_paths("addons_contrib")
46
47     # EXTERN SCRIPTS: external projects scripts
48     # if folder addons_extern/ exists, scripts in there will be loaded too
49     addon_paths += _bpy.utils.script_paths("addons_extern")
50
51     return addon_paths
52
53
54 def modules(module_cache):
55     global error_duplicates
56     global error_encoding
57     import os
58
59     error_duplicates = False
60     error_encoding = False
61
62     path_list = paths()
63
64     # fake module importing
65     def fake_module(mod_name, mod_path, speedy=True, force_support=None):
66         global error_encoding
67
68         if _bpy.app.debug_python:
69             print("fake_module", mod_path, mod_name)
70         import ast
71         ModuleType = type(ast)
72         file_mod = open(mod_path, "r", encoding='UTF-8')
73         if speedy:
74             lines = []
75             line_iter = iter(file_mod)
76             l = ""
77             while not l.startswith("bl_info"):
78                 try:
79                     l = line_iter.readline()
80                 except UnicodeDecodeError as e:
81                     if not error_encoding:
82                         error_encoding = True
83                         print("Error reading file as UTF-8:", mod_path, e)
84                     file_mod.close()
85                     return None
86
87                 if len(l) == 0:
88                     break
89             while l.rstrip():
90                 lines.append(l)
91                 try:
92                     l = line_iter.readline()
93                 except UnicodeDecodeError as e:
94                     if not error_encoding:
95                         error_encoding = True
96                         print("Error reading file as UTF-8:", mod_path, e)
97                     file_mod.close()
98                     return None
99
100             data = "".join(lines)
101
102         else:
103             data = file_mod.read()
104
105         file_mod.close()
106
107         try:
108             ast_data = ast.parse(data, filename=mod_path)
109         except:
110             print("Syntax error 'ast.parse' can't read %r" % mod_path)
111             import traceback
112             traceback.print_exc()
113             ast_data = None
114
115         body_info = None
116
117         if ast_data:
118             for body in ast_data.body:
119                 if body.__class__ == ast.Assign:
120                     if len(body.targets) == 1:
121                         if getattr(body.targets[0], "id", "") == "bl_info":
122                             body_info = body
123                             break
124
125         if body_info:
126             try:
127                 mod = ModuleType(mod_name)
128                 mod.bl_info = ast.literal_eval(body.value)
129                 mod.__file__ = mod_path
130                 mod.__time__ = os.path.getmtime(mod_path)
131             except:
132                 print("AST error in module %s" % mod_name)
133                 import traceback
134                 traceback.print_exc()
135                 raise
136
137             if force_support is not None:
138                 mod.bl_info["support"] = force_support
139
140             return mod
141         else:
142             print("fake_module: addon missing 'bl_info' "
143                   "gives bad performance!: %r" % mod_path)
144             return None
145
146     modules_stale = set(module_cache.keys())
147
148     for path in path_list:
149
150         # force all contrib addons to be 'TESTING'
151         if path.endswith(("addons_contrib", "addons_extern")):
152             force_support = 'TESTING'
153         else:
154             force_support = None
155
156         for mod_name, mod_path in _bpy.path.module_names(path):
157             modules_stale -= {mod_name}
158             mod = module_cache.get(mod_name)
159             if mod:
160                 if mod.__file__ != mod_path:
161                     print("multiple addons with the same name:\n  %r\n  %r" %
162                           (mod.__file__, mod_path))
163                     error_duplicates = True
164
165                 elif mod.__time__ != os.path.getmtime(mod_path):
166                     print("reloading addon:",
167                           mod_name,
168                           mod.__time__,
169                           os.path.getmtime(mod_path),
170                           mod_path,
171                           )
172                     del module_cache[mod_name]
173                     mod = None
174
175             if mod is None:
176                 mod = fake_module(mod_name,
177                                   mod_path,
178                                   force_support=force_support)
179                 if mod:
180                     module_cache[mod_name] = mod
181
182     # just in case we get stale modules, not likely
183     for mod_stale in modules_stale:
184         del module_cache[mod_stale]
185     del modules_stale
186
187     mod_list = list(module_cache.values())
188     mod_list.sort(key=lambda mod: (mod.bl_info["category"],
189                                    mod.bl_info["name"],
190                                    ))
191     return mod_list
192
193
194 def check(module_name):
195     """
196     Returns the loaded state of the addon.
197
198     :arg module_name: The name of the addon and module.
199     :type module_name: string
200     :return: (loaded_default, loaded_state)
201     :rtype: tuple of booleans
202     """
203     import sys
204     loaded_default = module_name in _user_preferences.addons
205
206     mod = sys.modules.get(module_name)
207     loaded_state = mod and getattr(mod, "__addon_enabled__", Ellipsis)
208
209     if loaded_state is Ellipsis:
210         print("Warning: addon-module %r found module "
211                "but without __addon_enabled__ field, "
212                "possible name collision from file: %r" %
213                (module_name, getattr(mod, "__file__", "<unknown>")))
214
215         loaded_state = False
216
217     if mod and getattr(mod, "__addon_persistent__", False):
218         loaded_default = True
219
220     return loaded_default, loaded_state
221
222
223 def enable(module_name, default_set=True, persistent=False):
224     """
225     Enables an addon by name.
226
227     :arg module_name: The name of the addon and module.
228     :type module_name: string
229     :return: the loaded module or None on failure.
230     :rtype: module
231     """
232
233     import os
234     import sys
235     from bpy_restrict_state import RestrictBlend
236
237     def handle_error():
238         import traceback
239         traceback.print_exc()
240
241     # reload if the mtime changes
242     mod = sys.modules.get(module_name)
243     # chances of the file _not_ existing are low, but it could be removed
244     if mod and os.path.exists(mod.__file__):
245         mod.__addon_enabled__ = False
246         mtime_orig = getattr(mod, "__time__", 0)
247         mtime_new = os.path.getmtime(mod.__file__)
248         if mtime_orig != mtime_new:
249             import imp
250             print("module changed on disk:", mod.__file__, "reloading...")
251
252             try:
253                 imp.reload(mod)
254             except:
255                 handle_error()
256                 del sys.modules[module_name]
257                 return None
258             mod.__addon_enabled__ = False
259
260     # Split registering up into 3 steps so we can undo
261     # if it fails par way through.
262
263     # disable the context, using the context at all is
264     # really bad while loading an addon, don't do it!
265     with RestrictBlend():
266
267         # 1) try import
268         try:
269             mod = __import__(module_name)
270             mod.__time__ = os.path.getmtime(mod.__file__)
271             mod.__addon_enabled__ = False
272         except:
273             handle_error()
274             return None
275
276         # 2) try register collected modules
277         # removed, addons need to handle own registration now.
278
279         # 3) try run the modules register function
280         try:
281             mod.register()
282         except:
283             print("Exception in module register(): %r" %
284                   getattr(mod, "__file__", module_name))
285             handle_error()
286             del sys.modules[module_name]
287             return None
288
289     # * OK loaded successfully! *
290     if default_set:
291         # just in case its enabled already
292         ext = _user_preferences.addons.get(module_name)
293         if not ext:
294             ext = _user_preferences.addons.new()
295             ext.module = module_name
296
297     mod.__addon_enabled__ = True
298     mod.__addon_persistent__ = persistent
299
300     if _bpy.app.debug_python:
301         print("\taddon_utils.enable", mod.__name__)
302
303     return mod
304
305
306 def disable(module_name, default_set=True):
307     """
308     Disables an addon by name.
309
310     :arg module_name: The name of the addon and module.
311     :type module_name: string
312     """
313     import sys
314     mod = sys.modules.get(module_name)
315
316     # possible this addon is from a previous session and didn't load a
317     # module this time. So even if the module is not found, still disable
318     # the addon in the user prefs.
319     if mod and getattr(mod, "__addon_enabled__", False) is not False:
320         mod.__addon_enabled__ = False
321         mod.__addon_persistent = False
322
323         try:
324             mod.unregister()
325         except:
326             print("Exception in module unregister(): %r" %
327                   getattr(mod, "__file__", module_name))
328             import traceback
329             traceback.print_exc()
330     else:
331         print("addon_utils.disable: %s not %s." %
332               (module_name, "disabled" if mod is None else "loaded"))
333
334     # could be in more then once, unlikely but better do this just in case.
335     addons = _user_preferences.addons
336
337     if default_set:
338         while module_name in addons:
339             addon = addons.get(module_name)
340             if addon:
341                 addons.remove(addon)
342
343     if _bpy.app.debug_python:
344         print("\taddon_utils.disable", module_name)
345
346
347 def reset_all(reload_scripts=False):
348     """
349     Sets the addon state based on the user preferences.
350     """
351     import sys
352     import imp
353
354     # RELEASE SCRIPTS: official scripts distributed in Blender releases
355     paths_list = paths()
356
357     for path in paths_list:
358         _bpy.utils._sys_path_ensure(path)
359         for mod_name, mod_path in _bpy.path.module_names(path):
360             is_enabled, is_loaded = check(mod_name)
361
362             # first check if reload is needed before changing state.
363             if reload_scripts:
364                 mod = sys.modules.get(mod_name)
365                 if mod:
366                     imp.reload(mod)
367
368             if is_enabled == is_loaded:
369                 pass
370             elif is_enabled:
371                 enable(mod_name)
372             elif is_loaded:
373                 print("\taddon_utils.reset_all unloading", mod_name)
374                 disable(mod_name)
375
376
377 def module_bl_info(mod, info_basis={"name": "",
378                                     "author": "",
379                                     "version": (),
380                                     "blender": (),
381                                     "location": "",
382                                     "description": "",
383                                     "wiki_url": "",
384                                     "tracker_url": "",
385                                     "support": 'COMMUNITY',
386                                     "category": "",
387                                     "warning": "",
388                                     "show_expanded": False,
389                                     }
390                    ):
391
392     addon_info = getattr(mod, "bl_info", {})
393
394     # avoid re-initializing
395     if "_init" in addon_info:
396         return addon_info
397
398     if not addon_info:
399         mod.bl_info = addon_info
400
401     for key, value in info_basis.items():
402         addon_info.setdefault(key, value)
403
404     if not addon_info["name"]:
405         addon_info["name"] = mod.__name__
406
407     addon_info["_init"] = None
408     return addon_info