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