Fix error enabling an already enabled addon
[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 # called only once at startup, avoids calling 'reset_all', correct but slower.
40 def _initialize():
41     path_list = paths()
42     for path in path_list:
43         _bpy.utils._sys_path_ensure(path)
44     for addon in _user_preferences.addons:
45         enable(addon.module)
46
47
48 def paths():
49     # RELEASE SCRIPTS: official scripts distributed in Blender releases
50     addon_paths = _bpy.utils.script_paths("addons")
51
52     # CONTRIB SCRIPTS: good for testing but not official scripts yet
53     # if folder addons_contrib/ exists, scripts in there will be loaded too
54     addon_paths += _bpy.utils.script_paths("addons_contrib")
55
56     return addon_paths
57
58
59 def modules_refresh(module_cache=addons_fake_modules):
60     global error_duplicates
61     global error_encoding
62     import os
63
64     error_duplicates = False
65     error_encoding = False
66
67     path_list = paths()
68
69     # fake module importing
70     def fake_module(mod_name, mod_path, speedy=True, force_support=None):
71         global error_encoding
72
73         if _bpy.app.debug_python:
74             print("fake_module", mod_path, mod_name)
75         import ast
76         ModuleType = type(ast)
77         try:
78             file_mod = open(mod_path, "r", encoding='UTF-8')
79         except OSError as e:
80             print("Error opening file %r: %s" % (mod_path, e))
81             return None
82
83         with file_mod:
84             if speedy:
85                 lines = []
86                 line_iter = iter(file_mod)
87                 l = ""
88                 while not l.startswith("bl_info"):
89                     try:
90                         l = line_iter.readline()
91                     except UnicodeDecodeError as e:
92                         if not error_encoding:
93                             error_encoding = True
94                             print("Error reading file as UTF-8:", mod_path, e)
95                         return None
96
97                     if len(l) == 0:
98                         break
99                 while l.rstrip():
100                     lines.append(l)
101                     try:
102                         l = line_iter.readline()
103                     except UnicodeDecodeError as e:
104                         if not error_encoding:
105                             error_encoding = True
106                             print("Error reading file as UTF-8:", mod_path, e)
107                         return None
108
109                 data = "".join(lines)
110
111             else:
112                 data = file_mod.read()
113         del file_mod
114
115         try:
116             ast_data = ast.parse(data, filename=mod_path)
117         except:
118             print("Syntax error 'ast.parse' can't read %r" % mod_path)
119             import traceback
120             traceback.print_exc()
121             ast_data = None
122
123         body_info = None
124
125         if ast_data:
126             for body in ast_data.body:
127                 if body.__class__ == ast.Assign:
128                     if len(body.targets) == 1:
129                         if getattr(body.targets[0], "id", "") == "bl_info":
130                             body_info = body
131                             break
132
133         if body_info:
134             try:
135                 mod = ModuleType(mod_name)
136                 mod.bl_info = ast.literal_eval(body.value)
137                 mod.__file__ = mod_path
138                 mod.__time__ = os.path.getmtime(mod_path)
139             except:
140                 print("AST error parsing bl_info for %s" % mod_name)
141                 import traceback
142                 traceback.print_exc()
143                 raise
144
145             if force_support is not None:
146                 mod.bl_info["support"] = force_support
147
148             return mod
149         else:
150             print("fake_module: addon missing 'bl_info' "
151                   "gives bad performance!: %r" % mod_path)
152             return None
153
154     modules_stale = set(module_cache.keys())
155
156     for path in path_list:
157
158         # force all contrib addons to be 'TESTING'
159         if path.endswith(("addons_contrib", )):
160             force_support = 'TESTING'
161         else:
162             force_support = None
163
164         for mod_name, mod_path in _bpy.path.module_names(path):
165             modules_stale.discard(mod_name)
166             mod = module_cache.get(mod_name)
167             if mod:
168                 if mod.__file__ != mod_path:
169                     print("multiple addons with the same name:\n  %r\n  %r" %
170                           (mod.__file__, mod_path))
171                     error_duplicates = True
172
173                 elif mod.__time__ != os.path.getmtime(mod_path):
174                     print("reloading addon:",
175                           mod_name,
176                           mod.__time__,
177                           os.path.getmtime(mod_path),
178                           mod_path,
179                           )
180                     del module_cache[mod_name]
181                     mod = None
182
183             if mod is None:
184                 mod = fake_module(mod_name,
185                                   mod_path,
186                                   force_support=force_support)
187                 if mod:
188                     module_cache[mod_name] = mod
189
190     # just in case we get stale modules, not likely
191     for mod_stale in modules_stale:
192         del module_cache[mod_stale]
193     del modules_stale
194
195
196 def modules(module_cache=addons_fake_modules, refresh=True):
197     if refresh or ((module_cache is addons_fake_modules) and modules._is_first):
198         modules_refresh(module_cache)
199         modules._is_first = False
200
201     mod_list = list(module_cache.values())
202     mod_list.sort(key=lambda mod: (mod.bl_info["category"],
203                                    mod.bl_info["name"],
204                                    ))
205     return mod_list
206 modules._is_first = True
207
208
209 def check(module_name):
210     """
211     Returns the loaded state of the addon.
212
213     :arg module_name: The name of the addon and module.
214     :type module_name: string
215     :return: (loaded_default, loaded_state)
216     :rtype: tuple of booleans
217     """
218     import sys
219     loaded_default = module_name in _user_preferences.addons
220
221     mod = sys.modules.get(module_name)
222     loaded_state = ((mod is not None) and
223                     getattr(mod, "__addon_enabled__", Ellipsis))
224
225     if loaded_state is Ellipsis:
226         print("Warning: addon-module %r found module "
227               "but without __addon_enabled__ field, "
228               "possible name collision from file: %r" %
229               (module_name, getattr(mod, "__file__", "<unknown>")))
230
231         loaded_state = False
232
233     if mod and getattr(mod, "__addon_persistent__", False):
234         loaded_default = True
235
236     return loaded_default, loaded_state
237
238 # utility functions
239
240
241 def _addon_ensure(module_name):
242     addons = _user_preferences.addons
243     addon = addons.get(module_name)
244     if not addon:
245         addon = addons.new()
246         addon.module = module_name
247
248
249 def _addon_remove(module_name):
250     addons = _user_preferences.addons
251
252     while module_name in addons:
253         addon = addons.get(module_name)
254         if addon:
255             addons.remove(addon)
256
257
258 def enable(module_name, default_set=False, persistent=False, handle_error=None):
259     """
260     Enables an addon by name.
261
262     :arg module_name: The name of the addon and module.
263     :type module_name: string
264     :return: the loaded module or None on failure.
265     :rtype: module
266     """
267
268     import os
269     import sys
270     from bpy_restrict_state import RestrictBlend
271
272     if handle_error is None:
273         def handle_error():
274             import traceback
275             traceback.print_exc()
276
277     # reload if the mtime changes
278     mod = sys.modules.get(module_name)
279     # chances of the file _not_ existing are low, but it could be removed
280     if mod and os.path.exists(mod.__file__):
281
282         if getattr(mod, "__addon_enabled__", False):
283             # This is an unlikely situation,
284             # re-register if the module is enabled.
285             # Note: the UI doesn't allow this to happen,
286             # in most cases the caller should 'check()' first.
287             try:
288                 mod.unregister()
289             except:
290                 print("Exception in module unregister(): %r" %
291                       getattr(mod, "__file__", module_name))
292                 handle_error()
293                 return None
294
295         mod.__addon_enabled__ = False
296         mtime_orig = getattr(mod, "__time__", 0)
297         mtime_new = os.path.getmtime(mod.__file__)
298         if mtime_orig != mtime_new:
299             import importlib
300             print("module changed on disk:", mod.__file__, "reloading...")
301
302             try:
303                 importlib.reload(mod)
304             except:
305                 handle_error()
306                 del sys.modules[module_name]
307                 return None
308             mod.__addon_enabled__ = False
309
310     # add the addon first it may want to initialize its own preferences.
311     # must remove on fail through.
312     if default_set:
313         _addon_ensure(module_name)
314
315     # Split registering up into 3 steps so we can undo
316     # if it fails par way through.
317
318     # disable the context, using the context at all is
319     # really bad while loading an addon, don't do it!
320     with RestrictBlend():
321
322         # 1) try import
323         try:
324             mod = __import__(module_name)
325             mod.__time__ = os.path.getmtime(mod.__file__)
326             mod.__addon_enabled__ = False
327         except Exception as ex:
328             # if the addon doesn't exist, dont print full traceback
329             if type(ex) is ImportError and ex.name == module_name:
330                 print("addon not found: %r" % module_name)
331             else:
332                 handle_error()
333
334             if default_set:
335                 _addon_remove(module_name)
336             return None
337
338         # 2) try register collected modules
339         # removed, addons need to handle own registration now.
340
341         # 3) try run the modules register function
342         try:
343             mod.register()
344         except:
345             print("Exception in module register(): %r" %
346                   getattr(mod, "__file__", module_name))
347             handle_error()
348             del sys.modules[module_name]
349             if default_set:
350                 _addon_remove(module_name)
351             return None
352
353     # * OK loaded successfully! *
354     mod.__addon_enabled__ = True
355     mod.__addon_persistent__ = persistent
356
357     if _bpy.app.debug_python:
358         print("\taddon_utils.enable", mod.__name__)
359
360     return mod
361
362
363 def disable(module_name, default_set=True, handle_error=None):
364     """
365     Disables an addon by name.
366
367     :arg module_name: The name of the addon and module.
368     :type module_name: string
369     """
370     import sys
371
372     if handle_error is None:
373         def handle_error():
374             import traceback
375             traceback.print_exc()
376
377     mod = sys.modules.get(module_name)
378
379     # possible this addon is from a previous session and didn't load a
380     # module this time. So even if the module is not found, still disable
381     # the addon in the user prefs.
382     if mod and getattr(mod, "__addon_enabled__", False) is not False:
383         mod.__addon_enabled__ = False
384         mod.__addon_persistent = False
385
386         try:
387             mod.unregister()
388         except:
389             print("Exception in module unregister(): %r" %
390                   getattr(mod, "__file__", module_name))
391             handle_error()
392     else:
393         print("addon_utils.disable: %s not %s." %
394               (module_name, "disabled" if mod is None else "loaded"))
395
396     # could be in more than once, unlikely but better do this just in case.
397     if default_set:
398         _addon_remove(module_name)
399
400     if _bpy.app.debug_python:
401         print("\taddon_utils.disable", module_name)
402
403
404 def reset_all(reload_scripts=False):
405     """
406     Sets the addon state based on the user preferences.
407     """
408     import sys
409
410     # initializes addons_fake_modules
411     modules_refresh()
412
413     # RELEASE SCRIPTS: official scripts distributed in Blender releases
414     paths_list = paths()
415
416     for path in paths_list:
417         _bpy.utils._sys_path_ensure(path)
418         for mod_name, mod_path in _bpy.path.module_names(path):
419             is_enabled, is_loaded = check(mod_name)
420
421             # first check if reload is needed before changing state.
422             if reload_scripts:
423                 import importlib
424                 mod = sys.modules.get(mod_name)
425                 if mod:
426                     importlib.reload(mod)
427
428             if is_enabled == is_loaded:
429                 pass
430             elif is_enabled:
431                 enable(mod_name)
432             elif is_loaded:
433                 print("\taddon_utils.reset_all unloading", mod_name)
434                 disable(mod_name)
435
436
437 def module_bl_info(mod, info_basis=None):
438     if info_basis is None:
439         info_basis = {
440             "name": "",
441             "author": "",
442             "version": (),
443             "blender": (),
444             "location": "",
445             "description": "",
446             "wiki_url": "",
447             "support": 'COMMUNITY',
448             "category": "",
449             "warning": "",
450             "show_expanded": False,
451             }
452
453     addon_info = getattr(mod, "bl_info", {})
454
455     # avoid re-initializing
456     if "_init" in addon_info:
457         return addon_info
458
459     if not addon_info:
460         mod.bl_info = addon_info
461
462     for key, value in info_basis.items():
463         addon_info.setdefault(key, value)
464
465     if not addon_info["name"]:
466         addon_info["name"] = mod.__name__
467
468     addon_info["_init"] = None
469     return addon_info