Fix fluid openMP not baking with some threadcounts
[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
33
34 error_duplicates = False
35 error_encoding = False
36
37
38 def paths():
39     # RELEASE SCRIPTS: official scripts distributed in Blender releases
40     paths = _bpy.utils.script_paths("addons")
41
42     # CONTRIB SCRIPTS: good for testing but not official scripts yet
43     # if folder addons_contrib/ exists, scripts in there will be loaded too
44     paths += _bpy.utils.script_paths("addons_contrib")
45
46     # EXTERN SCRIPTS: external projects scripts
47     # if folder addons_extern/ exists, scripts in there will be loaded too
48     paths += _bpy.utils.script_paths("addons_extern")
49
50     return paths
51
52
53 def modules(module_cache):
54     global error_duplicates
55     global error_encoding
56     import os
57
58     error_duplicates = False
59     error_encoding = False
60
61     path_list = paths()
62
63     # fake module importing
64     def fake_module(mod_name, mod_path, speedy=True):
65         global error_encoding
66
67         if _bpy.app.debug:
68             print("fake_module", mod_path, mod_name)
69         import ast
70         ModuleType = type(ast)
71         file_mod = open(mod_path, "r", encoding='UTF-8')
72         if speedy:
73             lines = []
74             line_iter = iter(file_mod)
75             l = ""
76             while not l.startswith("bl_info"):
77                 try:
78                     l = line_iter.readline()
79                 except UnicodeDecodeError as e:
80                     if not error_encoding:
81                         error_encoding = True
82                         print("Error reading file as UTF-8:", mod_path, e)
83                     file_mod.close()
84                     return None
85
86                 if len(l) == 0:
87                     break
88             while l.rstrip():
89                 lines.append(l)
90                 try:
91                     l = line_iter.readline()
92                 except UnicodeDecodeError as e:
93                     if not error_encoding:
94                         error_encoding = True
95                         print("Error reading file as UTF-8:", mod_path, e)
96                     file_mod.close()
97                     return None
98
99             data = "".join(lines)
100
101         else:
102             data = file_mod.read()
103
104         file_mod.close()
105
106         try:
107             ast_data = ast.parse(data, filename=mod_path)
108         except:
109             print("Syntax error 'ast.parse' can't read %r" % mod_path)
110             import traceback
111             traceback.print_exc()
112             ast_data = None
113
114         body_info = None
115
116         if ast_data:
117             for body in ast_data.body:
118                 if body.__class__ == ast.Assign:
119                     if len(body.targets) == 1:
120                         if getattr(body.targets[0], "id", "") == "bl_info":
121                             body_info = body
122                             break
123
124         if body_info:
125             try:
126                 mod = ModuleType(mod_name)
127                 mod.bl_info = ast.literal_eval(body.value)
128                 mod.__file__ = mod_path
129                 mod.__time__ = os.path.getmtime(mod_path)
130             except:
131                 print("AST error in module %s" % mod_name)
132                 import traceback
133                 traceback.print_exc()
134                 raise
135
136             return mod
137         else:
138             return None
139
140     modules_stale = set(module_cache.keys())
141
142     for path in path_list:
143         for mod_name, mod_path in _bpy.path.module_names(path):
144             modules_stale -= {mod_name}
145             mod = module_cache.get(mod_name)
146             if mod:
147                 if mod.__file__ != mod_path:
148                     print("multiple addons with the same name:\n  %r\n  %r" %
149                           (mod.__file__, mod_path))
150                     error_duplicates = True
151
152                 elif mod.__time__ != os.path.getmtime(mod_path):
153                     print("reloading addon:",
154                           mod_name,
155                           mod.__time__,
156                           os.path.getmtime(mod_path),
157                           mod_path,
158                           )
159                     del module_cache[mod_name]
160                     mod = None
161
162             if mod is None:
163                 mod = fake_module(mod_name, mod_path)
164                 if mod:
165                     module_cache[mod_name] = mod
166
167     # just incase we get stale modules, not likely
168     for mod_stale in modules_stale:
169         del module_cache[mod_stale]
170     del modules_stale
171
172     mod_list = list(module_cache.values())
173     mod_list.sort(key=lambda mod: (mod.bl_info['category'],
174                                    mod.bl_info['name'],
175                                    ))
176     return mod_list
177
178
179 def check(module_name):
180     """
181     Returns the loaded state of the addon.
182
183     :arg module_name: The name of the addon and module.
184     :type module_name: string
185     :return: (loaded_default, loaded_state)
186     :rtype: tuple of booleans
187     """
188     import sys
189     loaded_default = module_name in _bpy.context.user_preferences.addons
190
191     mod = sys.modules.get(module_name)
192     loaded_state = mod and getattr(mod, "__addon_enabled__", Ellipsis)
193
194     if loaded_state is Ellipsis:
195         print("Warning: addon-module %r found module "
196                "but without __addon_enabled__ field, "
197                "possible name collision from file: %r" %
198                (module_name, getattr(mod, "__file__", "<unknown>")))
199
200         loaded_state = False
201
202     return loaded_default, loaded_state
203
204
205 def enable(module_name, default_set=True):
206     """
207     Enables an addon by name.
208
209     :arg module_name: The name of the addon and module.
210     :type module_name: string
211     :return: the loaded module or None on failier.
212     :rtype: module
213     """
214
215     import os
216     import sys
217     import imp
218
219     def handle_error():
220         import traceback
221         traceback.print_exc()
222
223     # reload if the mtime changes
224     mod = sys.modules.get(module_name)
225     if mod:
226         mod.__addon_enabled__ = False
227         mtime_orig = getattr(mod, "__time__", 0)
228         mtime_new = os.path.getmtime(mod.__file__)
229         if mtime_orig != mtime_new:
230             print("module changed on disk:", mod.__file__, "reloading...")
231
232             try:
233                 imp.reload(mod)
234             except:
235                 handle_error()
236                 del sys.modules[module_name]
237                 return None
238             mod.__addon_enabled__ = False
239
240     # Split registering up into 3 steps so we can undo
241     # if it fails par way through.
242     # 1) try import
243     try:
244         mod = __import__(module_name)
245         mod.__time__ = os.path.getmtime(mod.__file__)
246         mod.__addon_enabled__ = False
247     except:
248         handle_error()
249         return None
250
251     # 2) try register collected modules
252     # removed, addons need to handle own registration now.
253
254     # 3) try run the modules register function
255     try:
256         mod.register()
257     except:
258         handle_error()
259         del sys.modules[module_name]
260         return None
261
262     # * OK loaded successfully! *
263     if default_set:
264         # just incase its enabled alredy
265         ext = _bpy.context.user_preferences.addons.get(module_name)
266         if not ext:
267             ext = _bpy.context.user_preferences.addons.new()
268             ext.module = module_name
269
270     mod.__addon_enabled__ = True
271
272     if _bpy.app.debug:
273         print("\taddon_utils.enable", mod.__name__)
274
275     return mod
276
277
278 def disable(module_name, default_set=True):
279     """
280     Disables an addon by name.
281
282     :arg module_name: The name of the addon and module.
283     :type module_name: string
284     """
285     import sys
286     mod = sys.modules.get(module_name)
287
288     # possible this addon is from a previous session and didnt load a
289     # module this time. So even if the module is not found, still disable
290     # the addon in the user prefs.
291     if mod:
292         mod.__addon_enabled__ = False
293
294         try:
295             mod.unregister()
296         except:
297             import traceback
298             traceback.print_exc()
299     else:
300         print("addon_utils.disable", module_name, "not loaded")
301
302     # could be in more then once, unlikely but better do this just incase.
303     addons = _bpy.context.user_preferences.addons
304
305     if default_set:
306         while module_name in addons:
307             addon = addons.get(module_name)
308             if addon:
309                 addons.remove(addon)
310
311     if _bpy.app.debug:
312         print("\taddon_utils.disable", module_name)
313
314
315 def reset_all(reload_scripts=False):
316     """
317     Sets the addon state based on the user preferences.
318     """
319     import sys
320     import imp
321
322     # RELEASE SCRIPTS: official scripts distributed in Blender releases
323     paths_list = paths()
324
325     for path in paths_list:
326         _bpy.utils._sys_path_ensure(path)
327         for mod_name, mod_path in _bpy.path.module_names(path):
328             is_enabled, is_loaded = check(mod_name)
329
330             # first check if reload is needed before changing state.
331             if reload_scripts:
332                 mod = sys.modules.get(mod_name)
333                 if mod:
334                     imp.reload(mod)
335
336             if is_enabled == is_loaded:
337                 pass
338             elif is_enabled:
339                 enable(mod_name)
340             elif is_loaded:
341                 print("\taddon_utils.reset_all unloading", mod_name)
342                 disable(mod_name)
343
344
345 def module_bl_info(mod, info_basis={"name": "",
346                                     "author": "",
347                                     "version": (),
348                                     "blender": (),
349                                     "api": 0,
350                                     "location": "",
351                                     "description": "",
352                                     "wiki_url": "",
353                                     "tracker_url": "",
354                                     "support": 'COMMUNITY',
355                                     "category": "",
356                                     "warning": "",
357                                     "show_expanded": False,
358                                     }
359                    ):
360
361     addon_info = getattr(mod, "bl_info", {})
362
363     # avoid re-initializing
364     if "_init" in addon_info:
365         return addon_info
366
367     if not addon_info:
368         mod.bl_info = addon_info
369
370     for key, value in info_basis.items():
371         addon_info.setdefault(key, value)
372
373     if not addon_info["name"]:
374         addon_info["name"] = mod.__name__
375
376     addon_info["_init"] = None
377     return addon_info