griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Re-design of submodules used in blender.git

Browse Source 
This commit implements described in the #104573.

The goal is to fix the confusion of the submodule hashes change, which are not
ideal for any of the supported git-module configuration (they are either always
visible causing confusion, or silently staged and committed, also causing
confusion).

This commit replaces submodules with a checkout of addons and addons_contrib,
covered by the .gitignore, and locale and developer tools are moved to the
main repository.

This also changes the paths:
- /release/scripts are moved to the /scripts
- /source/tools are moved to the /tools
- /release/datafiles/locale is moved to /locale

This is done to avoid conflicts when using bisect, and also allow buildbot to
automatically "recover" wgen building older or newer branches/patches.

Running `make update` will initialize the local checkout to the changed
repository configuration.

Another aspect of the change is that the make update will support Github style
of remote organization (origin remote pointing to thy fork, upstream remote
pointing to the upstream blender/blender.git).

Pull Request #104755
This commit is contained in:
Sergey Sharybin
2023-02-21 16:39:58 +01:00
committed by Sergey Sharybin
parent 3e721195b0
commit 03806d0b67
570 changed files with 2039093 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
scripts/modules/bpy/__init__.py Normal file
View File

@@ -0,0 +1,63 @@
# SPDX-License-Identifier: GPL-2.0-or-later
"""
Give access to blender data and utility functions.
"""
__all__ = (
"app",
"context",
"data",
"ops",
"path",
"props",
"types",
"utils",
)
# internal blender C module
from _bpy import (
app,
context,
data,
msgbus,
props,
types,
)
# python modules
from . import (
ops,
path,
utils,
)
def main():
import sys
# Possibly temp. addons path
from os.path import join, dirname
sys.path.extend([
join(dirname(dirname(dirname(__file__))), "addons", "modules"),
join(utils.user_resource('SCRIPTS'), "addons", "modules"),
])
# fake module to allow:
# from bpy.types import Panel
sys.modules.update({
"bpy.app": app,
"bpy.app.handlers": app.handlers,
"bpy.app.translations": app.translations,
"bpy.types": types,
})
# Initializes Python classes.
# (good place to run a profiler or trace).
utils.load_scripts()
main()
del main

185
scripts/modules/bpy/ops.py Normal file
View File

@@ -0,0 +1,185 @@
# SPDX-License-Identifier: GPL-2.0-or-later
# for slightly faster access
from _bpy import ops as _ops_module
# op_add = _ops_module.add
_op_dir = _ops_module.dir
_op_poll = _ops_module.poll
_op_call = _ops_module.call
_op_as_string = _ops_module.as_string
_op_get_rna_type = _ops_module.get_rna_type
_op_get_bl_options = _ops_module.get_bl_options
_ModuleType = type(_ops_module)
# -----------------------------------------------------------------------------
# Callable Operator Wrapper
class _BPyOpsSubModOp:
"""
Utility class to fake submodule operators.
eg. bpy.ops.object.somefunc
"""
__slots__ = ("_module", "_func")
def _get_doc(self):
idname = self.idname()
sig = _op_as_string(self.idname())
# XXX You never quite know what you get from bpy.types,
# with operators... Operator and OperatorProperties
# are shadowing each other, and not in the same way for
# native ops and py ones! See #39158.
# op_class = getattr(bpy.types, idname)
op_class = _op_get_rna_type(idname)
descr = op_class.description
return "%s\n%s" % (sig, descr)
@staticmethod
def _parse_args(args):
C_dict = None
C_exec = 'EXEC_DEFAULT'
C_undo = False
is_dict = is_exec = is_undo = False
for arg in args:
if is_dict is False and isinstance(arg, dict):
if is_exec is True or is_undo is True:
raise ValueError("dict arg must come first")
C_dict = arg
is_dict = True
elif is_exec is False and isinstance(arg, str):
if is_undo is True:
raise ValueError("string arg must come before the boolean")
C_exec = arg
is_exec = True
elif is_undo is False and isinstance(arg, int):
C_undo = arg
is_undo = True
else:
raise ValueError("1-3 args execution context is supported")
return C_dict, C_exec, C_undo
@staticmethod
def _view_layer_update(context):
view_layer = context.view_layer
if view_layer: # None in background mode
view_layer.update()
else:
import bpy
for scene in bpy.data.scenes:
for view_layer in scene.view_layers:
view_layer.update()
__doc__ = property(_get_doc)
def __init__(self, module, func):
self._module = module
self._func = func
def poll(self, *args):
C_dict, C_exec, _C_undo = _BPyOpsSubModOp._parse_args(args)
return _op_poll(self.idname_py(), C_dict, C_exec)
def idname(self):
# submod.foo -> SUBMOD_OT_foo
return self._module.upper() + "_OT_" + self._func
def idname_py(self):
return self._module + "." + self._func
def __call__(self, *args, **kw):
import bpy
context = bpy.context
# Get the operator from blender
wm = context.window_manager
# Run to account for any RNA values the user changes.
# NOTE: We only update active view-layer, since that's what
# operators are supposed to operate on. There might be some
# corner cases when operator need a full scene update though.
_BPyOpsSubModOp._view_layer_update(context)
if args:
C_dict, C_exec, C_undo = _BPyOpsSubModOp._parse_args(args)
ret = _op_call(self.idname_py(), C_dict, kw, C_exec, C_undo)
else:
ret = _op_call(self.idname_py(), None, kw)
if 'FINISHED' in ret and context.window_manager == wm:
_BPyOpsSubModOp._view_layer_update(context)
return ret
def get_rna_type(self):
"""Internal function for introspection"""
return _op_get_rna_type(self.idname())
@property
def bl_options(self):
return _op_get_bl_options(self.idname())
def __repr__(self): # useful display, repr(op)
return _op_as_string(self.idname())
def __str__(self): # used for print(...)
return ("<function bpy.ops.%s.%s at 0x%x'>" %
(self._module, self._func, id(self)))
# -----------------------------------------------------------------------------
# Sub-Module Access
def _bpy_ops_submodule__getattr__(module, func):
# Return a value from `bpy.ops.{module}.{func}`
if func.startswith("__"):
raise AttributeError(func)
return _BPyOpsSubModOp(module, func)
def _bpy_ops_submodule__dir__(module):
functions = set()
module_upper = module.upper()
for id_name in _op_dir():
id_split = id_name.split("_OT_", 1)
if len(id_split) == 2 and module_upper == id_split[0]:
functions.add(id_split[1])
return list(functions)
def _bpy_ops_submodule(module):
result = _ModuleType("bpy.ops." + module)
result.__getattr__ = lambda func: _bpy_ops_submodule__getattr__(module, func)
result.__dir__ = lambda: _bpy_ops_submodule__dir__(module)
return result
# -----------------------------------------------------------------------------
# Module Access
def __getattr__(module):
# Return a value from `bpy.ops.{module}`.
if module.startswith("__"):
raise AttributeError(module)
return _bpy_ops_submodule(module)
def __dir__():
submodules = set()
for id_name in _op_dir():
id_split = id_name.split("_OT_", 1)
if len(id_split) == 2:
submodules.add(id_split[0].lower())
else:
submodules.add(id_split[0])
return list(submodules)

446
scripts/modules/bpy/path.py Normal file
View File

@@ -0,0 +1,446 @@
# SPDX-License-Identifier: GPL-2.0-or-later
"""
This module has a similar scope to os.path, containing utility
functions for dealing with paths in Blender.
"""
__all__ = (
"abspath",
"basename",
"clean_name",
"display_name",
"display_name_to_filepath",
"display_name_from_filepath",
"ensure_ext",
"extensions_image",
"extensions_movie",
"extensions_audio",
"is_subdir",
"module_names",
"native_pathsep",
"reduce_dirs",
"relpath",
"resolve_ncase",
)
import bpy as _bpy
import os as _os
from _bpy_path import (
extensions_audio,
extensions_movie,
extensions_image,
)
def _getattr_bytes(var, attr):
return var.path_resolve(attr, False).as_bytes()
def abspath(path, *, start=None, library=None):
"""
Returns the absolute path relative to the current blend file
using the "//" prefix.
:arg start: Relative to this path,
when not set the current filename is used.
:type start: string or bytes
:arg library: The library this path is from. This is only included for
convenience, when the library is not None its path replaces *start*.
:type library: :class:`bpy.types.Library`
:return: The absolute path.
:rtype: string
"""
if isinstance(path, bytes):
if path.startswith(b"//"):
if library:
start = _os.path.dirname(
abspath(_getattr_bytes(library, "filepath")))
return _os.path.join(
_os.path.dirname(_getattr_bytes(_bpy.data, "filepath"))
if start is None else start,
path[2:],
)
else:
if path.startswith("//"):
if library:
start = _os.path.dirname(
abspath(library.filepath))
return _os.path.join(
_os.path.dirname(_bpy.data.filepath)
if start is None else start,
path[2:],
)
return path
def relpath(path, *, start=None):
"""
Returns the path relative to the current blend file using the "//" prefix.
:arg path: An absolute path.
:type path: string or bytes
:arg start: Relative to this path,
when not set the current filename is used.
:type start: string or bytes
:return: The relative path.
:rtype: string
"""
if isinstance(path, bytes):
if not path.startswith(b"//"):
if start is None:
start = _os.path.dirname(_getattr_bytes(_bpy.data, "filepath"))
return b"//" + _os.path.relpath(path, start)
else:
if not path.startswith("//"):
if start is None:
start = _os.path.dirname(_bpy.data.filepath)
return "//" + _os.path.relpath(path, start)
return path
def is_subdir(path, directory):
"""
Returns true if *path* in a subdirectory of *directory*.
Both paths must be absolute.
:arg path: An absolute path.
:type path: string or bytes
:return: Whether or not the path is a subdirectory.
:rtype: boolean
"""
from os.path import normpath, normcase, sep
path = normpath(normcase(path))
directory = normpath(normcase(directory))
if len(path) > len(directory):
sep = sep.encode('ascii') if isinstance(directory, bytes) else sep
if path.startswith(directory.rstrip(sep) + sep):
return True
return False
def clean_name(name, *, replace="_"):
"""
Returns a name with characters replaced that
may cause problems under various circumstances,
such as writing to a file.
All characters besides A-Z/a-z, 0-9 are replaced with "_"
or the *replace* argument if defined.
:arg name: The path name.
:type name: string or bytes
:arg replace: The replacement for non-valid characters.
:type replace: string
:return: The cleaned name.
:rtype: string
"""
if replace != "_":
if len(replace) != 1 or ord(replace) > 255:
raise ValueError("Value must be a single ascii character")
def maketrans_init():
trans_cache = clean_name._trans_cache
trans = trans_cache.get(replace)
if trans is None:
bad_chars = (
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2e, 0x2f, 0x3a,
0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x5b, 0x5c,
0x5d, 0x5e, 0x60, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe,
)
trans = str.maketrans({char: replace for char in bad_chars})
trans_cache[replace] = trans
return trans
trans = maketrans_init()
return name.translate(trans)
clean_name._trans_cache = {}
def _clean_utf8(name):
if type(name) == bytes:
return name.decode("utf8", "replace")
else:
return name.encode("utf8", "replace").decode("utf8")
_display_name_literals = {
":": "_colon_",
"+": "_plus_",
"/": "_slash_",
}
def display_name(name, *, has_ext=True, title_case=True):
"""
Creates a display string from name to be used menus and the user interface.
Intended for use with filenames and module names.
:arg name: The name to be used for displaying the user interface.
:type name: string
:arg has_ext: Remove file extension from name.
:type has_ext: boolean
:arg title_case: Convert lowercase names to title case.
:type title_case: boolean
:return: The display string.
:rtype: string
"""
if has_ext:
name = _os.path.splitext(basename(name))[0]
# string replacements
for disp_value, file_value in _display_name_literals.items():
name = name.replace(file_value, disp_value)
# strip to allow underscore prefix
# (when paths can't start with numbers for eg).
name = name.replace("_", " ").lstrip(" ")
if title_case and name.islower():
name = name.lower().title()
name = _clean_utf8(name)
return name
def display_name_to_filepath(name):
"""
Performs the reverse of display_name using literal versions of characters
which aren't supported in a filepath.
:arg name: The display name to convert.
:type name: string
:return: The file path.
:rtype: string
"""
for disp_value, file_value in _display_name_literals.items():
name = name.replace(disp_value, file_value)
return name
def display_name_from_filepath(name):
"""
Returns the path stripped of directory and extension,
ensured to be utf8 compatible.
:arg name: The file path to convert.
:type name: string
:return: The display name.
:rtype: string
"""
name = _os.path.splitext(basename(name))[0]
name = _clean_utf8(name)
return name
def resolve_ncase(path):
"""
Resolve a case insensitive path on a case sensitive system,
returning a string with the path if found else return the original path.
:arg path: The path name to resolve.
:type path: string
:return: The resolved path.
:rtype: string
"""
def _ncase_path_found(path):
if not path or _os.path.exists(path):
return path, True
# filename may be a directory or a file
filename = _os.path.basename(path)
dirpath = _os.path.dirname(path)
suffix = path[:0] # "" but ensure byte/str match
if not filename: # dir ends with a slash?
if len(dirpath) < len(path):
suffix = path[:len(path) - len(dirpath)]
filename = _os.path.basename(dirpath)
dirpath = _os.path.dirname(dirpath)
if not _os.path.exists(dirpath):
if dirpath == path:
return path, False
dirpath, found = _ncase_path_found(dirpath)
if not found:
return path, False
# at this point, the directory exists but not the file
# we are expecting 'dirpath' to be a directory, but it could be a file
if _os.path.isdir(dirpath):
try:
files = _os.listdir(dirpath)
except PermissionError:
# We might not have the permission to list dirpath...
return path, False
else:
return path, False
filename_low = filename.lower()
f_iter_nocase = None
for f_iter in files:
if f_iter.lower() == filename_low:
f_iter_nocase = f_iter
break
if f_iter_nocase:
return _os.path.join(dirpath, f_iter_nocase) + suffix, True
else:
# can't find the right one, just return the path as is.
return path, False
ncase_path, found = _ncase_path_found(path)
return ncase_path if found else path
def ensure_ext(filepath, ext, *, case_sensitive=False):
"""
Return the path with the extension added if it is not already set.
:arg filepath: The file path.
:type filepath: string
:arg ext: The extension to check for, can be a compound extension. Should
start with a dot, such as '.blend' or '.tar.gz'.
:type ext: string
:arg case_sensitive: Check for matching case when comparing extensions.
:type case_sensitive: boolean
:return: The file path with the given extension.
:rtype: string
"""
if case_sensitive:
if filepath.endswith(ext):
return filepath
else:
if filepath[-len(ext):].lower().endswith(ext.lower()):
return filepath
return filepath + ext
def module_names(path, *, recursive=False):
"""
Return a list of modules which can be imported from *path*.
:arg path: a directory to scan.
:type path: string
:arg recursive: Also return submodule names for packages.
:type recursive: bool
:return: a list of string pairs (module_name, module_file).
:rtype: list of strings
"""
from os.path import join, isfile
modules = []
for filename in sorted(_os.listdir(path)):
if filename == "modules":
pass # XXX, hard coded exception.
elif filename.endswith(".py") and filename != "__init__.py":
fullpath = join(path, filename)
modules.append((filename[0:-3], fullpath))
elif not filename.startswith("."):
# Skip hidden files since they are used by for version control.
directory = join(path, filename)
fullpath = join(directory, "__init__.py")
if isfile(fullpath):
modules.append((filename, fullpath))
if recursive:
for mod_name, mod_path in module_names(directory, recursive=True):
modules.append(("%s.%s" % (filename, mod_name),
mod_path,
))
return modules
def basename(path):
"""
Equivalent to ``os.path.basename``, but skips a "//" prefix.
Use for Windows compatibility.
:return: The base name of the given path.
:rtype: string
"""
return _os.path.basename(path[2:] if path[:2] in {"//", b"//"} else path)
def native_pathsep(path):
"""
Replace the path separator with the systems native ``os.sep``.
:arg path: The path to replace.
:type path: string
:return: The path with system native separators.
:rtype: string
"""
if type(path) is str:
if _os.sep == "/":
return path.replace("\\", "/")
else:
if path.startswith("//"):
return "//" + path[2:].replace("/", "\\")
else:
return path.replace("/", "\\")
else: # bytes
if _os.sep == "/":
return path.replace(b"\\", b"/")
else:
if path.startswith(b"//"):
return b"//" + path[2:].replace(b"/", b"\\")
else:
return path.replace(b"/", b"\\")
def reduce_dirs(dirs):
"""
Given a sequence of directories, remove duplicates and
any directories nested in one of the other paths.
(Useful for recursive path searching).
:arg dirs: Sequence of directory paths.
:type dirs: sequence of strings
:return: A unique list of paths.
:rtype: list of strings
"""
dirs = list({_os.path.normpath(_os.path.abspath(d)) for d in dirs})
dirs.sort(key=lambda d: len(d))
for i in range(len(dirs) - 1, -1, -1):
for j in range(i):
print(i, j)
if len(dirs[i]) == len(dirs[j]):
break
elif is_subdir(dirs[i], dirs[j]):
del dirs[i]
break
return dirs

1110
scripts/modules/bpy/utils/__init__.py Normal file
View File

@@ -0,0 +1,1110 @@
# SPDX-License-Identifier: GPL-2.0-or-later
"""
This module contains utility functions specific to blender but
not associated with blenders internal data.
"""
__all__ = (
"blend_paths",
"escape_identifier",
"flip_name",
"unescape_identifier",
"keyconfig_init",
"keyconfig_set",
"load_scripts",
"modules_from_path",
"preset_find",
"preset_paths",
"refresh_script_paths",
"app_template_paths",
"register_class",
"register_manual_map",
"unregister_manual_map",
"register_classes_factory",
"register_submodule_factory",
"register_tool",
"make_rna_paths",
"manual_map",
"manual_language_code",
"previews",
"resource_path",
"script_path_user",
"script_path_pref",
"script_paths",
"smpte_from_frame",
"smpte_from_seconds",
"units",
"unregister_class",
"unregister_tool",
"user_resource",
"execfile",
)
from _bpy import (
_utils_units as units,
blend_paths,
escape_identifier,
flip_name,
unescape_identifier,
register_class,
resource_path,
script_paths as _bpy_script_paths,
unregister_class,
user_resource as _user_resource,
system_resource,
)
import bpy as _bpy
import os as _os
import sys as _sys
import addon_utils as _addon_utils
_preferences = _bpy.context.preferences
_is_factory_startup = _bpy.app.factory_startup
# Directories added to the start of `sys.path` for all of Blender's "scripts" directories.
_script_module_dirs = "startup", "modules"
# Base scripts, this points to the directory containing: "modules" & "startup" (see `_script_module_dirs`).
# In Blender's code-base this is `./scripts`.
#
# NOTE: in virtually all cases this should match `BLENDER_SYSTEM_SCRIPTS` as this script is it's self a system script,
# it must be in the `BLENDER_SYSTEM_SCRIPTS` by definition and there is no need for a look-up from `_bpy_script_paths`.
_script_base_dir = _os.path.dirname(_os.path.dirname(_os.path.dirname(_os.path.dirname(__file__))))
def execfile(filepath, *, mod=None):
"""
Execute a file path as a Python script.
:arg filepath: Path of the script to execute.
:type filepath: string
:arg mod: Optional cached module, the result of a previous execution.
:type mod: Module or None
:return: The module which can be passed back in as ``mod``.
:rtype: ModuleType
"""
import importlib.util
mod_name = "__main__"
mod_spec = importlib.util.spec_from_file_location(mod_name, filepath)
if mod is None:
mod = importlib.util.module_from_spec(mod_spec)
# While the module name is not added to `sys.modules`, it's important to temporarily
# include this so statements such as `sys.modules[cls.__module__].__dict__` behave as expected.
# See: https://bugs.python.org/issue9499 for details.
modules = _sys.modules
mod_orig = modules.get(mod_name, None)
modules[mod_name] = mod
# No error suppression, just ensure `sys.modules[mod_name]` is properly restored in the case of an error.
try:
mod_spec.loader.exec_module(mod)
finally:
if mod_orig is None:
modules.pop(mod_name, None)
else:
modules[mod_name] = mod_orig
return mod
def _test_import(module_name, loaded_modules):
use_time = _bpy.app.debug_python
if module_name in loaded_modules:
return None
if "." in module_name:
print("Ignoring '%s', can't import files containing "
"multiple periods" % module_name)
return None
if use_time:
import time
t = time.time()
try:
mod = __import__(module_name)
except:
import traceback
traceback.print_exc()
return None
if use_time:
print("time %s %.4f" % (module_name, time.time() - t))
loaded_modules.add(mod.__name__) # should match mod.__name__ too
return mod
# Check before adding paths as reloading would add twice.
# Storing and restoring the full `sys.path` is risky as this may be intentionally modified
# by technical users/developers.
#
# Instead, track which paths have been added, clearing them before refreshing.
# This supports the case of loading a new preferences file which may reset scripts path.
_sys_path_ensure_paths = set()
def _sys_path_ensure_prepend(path):
if path not in _sys.path:
_sys.path.insert(0, path)
_sys_path_ensure_paths.add(path)
def _sys_path_ensure_append(path):
if path not in _sys.path:
_sys.path.append(path)
_sys_path_ensure_paths.add(path)
def modules_from_path(path, loaded_modules):
"""
Load all modules in a path and return them as a list.
:arg path: this path is scanned for scripts and packages.
:type path: string
:arg loaded_modules: already loaded module names, files matching these
names will be ignored.
:type loaded_modules: set
:return: all loaded modules.
:rtype: list
"""
modules = []
for mod_name, _mod_path in _bpy.path.module_names(path):
mod = _test_import(mod_name, loaded_modules)
if mod:
modules.append(mod)
return modules
_global_loaded_modules = [] # store loaded module names for reloading.
import bpy_types as _bpy_types # keep for comparisons, never ever reload this.
def load_scripts(*, reload_scripts=False, refresh_scripts=False):
"""
Load scripts and run each modules register function.
:arg reload_scripts: Causes all scripts to have their unregister method
called before loading.
:type reload_scripts: bool
:arg refresh_scripts: only load scripts which are not already loaded
as modules.
:type refresh_scripts: bool
"""
use_time = use_class_register_check = _bpy.app.debug_python
use_user = not _is_factory_startup
if use_time:
import time
t_main = time.time()
loaded_modules = set()
if refresh_scripts:
original_modules = _sys.modules.values()
if reload_scripts:
# just unload, don't change user defaults, this means we can sync
# to reload. note that they will only actually reload of the
# modification time changes. This `won't` work for packages so...
# its not perfect.
for module_name in [ext.module for ext in _preferences.addons]:
_addon_utils.disable(module_name)
def register_module_call(mod):
register = getattr(mod, "register", None)
if register:
try:
register()
except:
import traceback
traceback.print_exc()
else:
print("\nWarning! '%s' has no register function, "
"this is now a requirement for registerable scripts" %
mod.__file__)
def unregister_module_call(mod):
unregister = getattr(mod, "unregister", None)
if unregister:
try:
unregister()
except:
import traceback
traceback.print_exc()
def test_reload(mod):
import importlib
# reloading this causes internal errors
# because the classes from this module are stored internally
# possibly to refresh internal references too but for now, best not to.
if mod == _bpy_types:
return mod
try:
return importlib.reload(mod)
except:
import traceback
traceback.print_exc()
def test_register(mod):
if refresh_scripts and mod in original_modules:
return
if reload_scripts and mod:
print("Reloading:", mod)
mod = test_reload(mod)
if mod:
register_module_call(mod)
_global_loaded_modules.append(mod.__name__)
if reload_scripts:
# module names -> modules
_global_loaded_modules[:] = [_sys.modules[mod_name]
for mod_name in _global_loaded_modules]
# loop over and unload all scripts
_global_loaded_modules.reverse()
for mod in _global_loaded_modules:
unregister_module_call(mod)
for mod in _global_loaded_modules:
test_reload(mod)
del _global_loaded_modules[:]
from bpy_restrict_state import RestrictBlend
with RestrictBlend():
for base_path in script_paths(use_user=use_user):
for path_subdir in _script_module_dirs:
path = _os.path.join(base_path, path_subdir)
if _os.path.isdir(path):
_sys_path_ensure_prepend(path)
# Only add to 'sys.modules' unless this is 'startup'.
if path_subdir == "startup":
for mod in modules_from_path(path, loaded_modules):
test_register(mod)
# load template (if set)
if any(_bpy.utils.app_template_paths()):
import bl_app_template_utils
bl_app_template_utils.reset(reload_scripts=reload_scripts)
del bl_app_template_utils
# deal with addons separately
_initialize = getattr(_addon_utils, "_initialize", None)
if _initialize is not None:
# first time, use fast-path
_initialize()
del _addon_utils._initialize
else:
_addon_utils.reset_all(reload_scripts=reload_scripts)
del _initialize
if reload_scripts:
_bpy.context.window_manager.tag_script_reload()
import gc
print("gc.collect() -> %d" % gc.collect())
if use_time:
print("Python Script Load Time %.4f" % (time.time() - t_main))
if use_class_register_check:
for cls in _bpy.types.bpy_struct.__subclasses__():
if getattr(cls, "is_registered", False):
for subcls in cls.__subclasses__():
if not subcls.is_registered:
print(
"Warning, unregistered class: %s(%s)" %
(subcls.__name__, cls.__name__)
)
def script_path_user():
"""returns the env var and falls back to home dir or None"""
path = _user_resource('SCRIPTS')
return _os.path.normpath(path) if path else None
def script_path_pref():
"""returns the user preference or None"""
path = _preferences.filepaths.script_directory
return _os.path.normpath(path) if path else None
def script_paths(*, subdir=None, user_pref=True, check_all=False, use_user=True):
"""
Returns a list of valid script paths.
:arg subdir: Optional subdir.
:type subdir: string
:arg user_pref: Include the user preference script path.
:type user_pref: bool
:arg check_all: Include local, user and system paths rather just the paths Blender uses.
:type check_all: bool
:return: script paths.
:rtype: list
"""
if check_all or use_user:
path_system, path_user = _bpy_script_paths()
base_paths = []
if check_all:
# Order: 'LOCAL', 'USER', 'SYSTEM' (where user is optional).
if path_local := resource_path('LOCAL'):
base_paths.append(_os.path.join(path_local, "scripts"))
if use_user:
base_paths.append(path_user)
base_paths.append(path_system) # Same as: `system_resource('SCRIPTS')`.
# Note that `_script_base_dir` may be either:
# - `os.path.join(bpy.utils.resource_path('LOCAL'), "scripts")`
# - `bpy.utils.system_resource('SCRIPTS')`.
# When `check_all` is enabled duplicate paths will be added however
# paths are de-duplicated so it wont cause problems.
base_paths.append(_script_base_dir)
if not check_all:
if use_user:
base_paths.append(path_user)
if user_pref:
base_paths.append(script_path_pref())
scripts = []
for path in base_paths:
if not path:
continue
path = _os.path.normpath(path)
if subdir is not None:
path = _os.path.join(path, subdir)
if path in scripts:
continue
if not _os.path.isdir(path):
continue
scripts.append(path)
return scripts
def refresh_script_paths():
"""
Run this after creating new script paths to update sys.path
"""
for path in _sys_path_ensure_paths:
try:
_sys.path.remove(path)
except ValueError:
pass
_sys_path_ensure_paths.clear()
for base_path in script_paths():
for path_subdir in _script_module_dirs:
path = _os.path.join(base_path, path_subdir)
if _os.path.isdir(path):
_sys_path_ensure_prepend(path)
for path in _addon_utils.paths():
_sys_path_ensure_append(path)
path = _os.path.join(path, "modules")
if _os.path.isdir(path):
_sys_path_ensure_append(path)
def app_template_paths(*, path=None):
"""
Returns valid application template paths.
:arg path: Optional subdir.
:type path: string
:return: app template paths.
:rtype: generator
"""
subdir_args = (path,) if path is not None else ()
# Note: keep in sync with: Blender's 'BKE_appdir_app_template_any'.
# Uses 'BLENDER_USER_SCRIPTS', 'BLENDER_SYSTEM_SCRIPTS'
# ... in this case 'system' accounts for 'local' too.
for resource_fn, module_name in (
(_user_resource, "bl_app_templates_user"),
(system_resource, "bl_app_templates_system"),
):
path_test = resource_fn('SCRIPTS', path=_os.path.join("startup", module_name, *subdir_args))
if path_test and _os.path.isdir(path_test):
yield path_test
def preset_paths(subdir):
"""
Returns a list of paths for a specific preset.
:arg subdir: preset subdirectory (must not be an absolute path).
:type subdir: string
:return: script paths.
:rtype: list
"""
dirs = []
for path in script_paths(subdir="presets", check_all=True):
directory = _os.path.join(path, subdir)
if not directory.startswith(path):
raise Exception("invalid subdir given %r" % subdir)
elif _os.path.isdir(directory):
dirs.append(directory)
# Find addons preset paths
for path in _addon_utils.paths():
directory = _os.path.join(path, "presets", subdir)
if _os.path.isdir(directory):
dirs.append(directory)
return dirs
def is_path_builtin(path):
"""
Returns True if the path is one of the built-in paths used by Blender.
:arg path: Path you want to check if it is in the built-in settings directory
:type path: str
:rtype: bool
"""
# Note that this function isn't optimized for speed,
# it's intended to be used to check if it's OK to remove presets.
#
# If this is used in a draw-loop for example, we could cache some of the values.
user_path = resource_path('USER')
for res in ('SYSTEM', 'LOCAL'):
parent_path = resource_path(res)
if not parent_path or parent_path == user_path:
# Make sure that the current path is not empty string and that it is
# not the same as the user config path. IE "~/.config/blender" on Linux
# This can happen on portable installs.
continue
try:
if _os.path.samefile(
_os.path.commonpath([parent_path]),
_os.path.commonpath([parent_path, path])
):
return True
except FileNotFoundError:
# The path we tried to look up doesn't exist.
pass
except ValueError:
# Happens on Windows when paths don't have the same drive.
pass
return False
def smpte_from_seconds(time, *, fps=None, fps_base=None):
"""
Returns an SMPTE formatted string from the *time*:
``HH:MM:SS:FF``.
If *fps* and *fps_base* are not given the current scene is used.
:arg time: time in seconds.
:type time: int, float or ``datetime.timedelta``.
:return: the frame string.
:rtype: string
"""
return smpte_from_frame(
time_to_frame(time, fps=fps, fps_base=fps_base),
fps=fps,
fps_base=fps_base
)
def smpte_from_frame(frame, *, fps=None, fps_base=None):
"""
Returns an SMPTE formatted string from the *frame*:
``HH:MM:SS:FF``.
If *fps* and *fps_base* are not given the current scene is used.
:arg frame: frame number.
:type frame: int or float.
:return: the frame string.
:rtype: string
"""
if fps is None:
fps = _bpy.context.scene.render.fps
if fps_base is None:
fps_base = _bpy.context.scene.render.fps_base
fps = fps / fps_base
sign = "-" if frame < 0 else ""
frame = abs(frame)
return (
"%s%02d:%02d:%02d:%02d" % (
sign,
int(frame / (3600 * fps)), # HH
int((frame / (60 * fps)) % 60), # MM
int((frame / fps) % 60), # SS
int(frame % fps), # FF
))
def time_from_frame(frame, *, fps=None, fps_base=None):
"""
Returns the time from a frame number .
If *fps* and *fps_base* are not given the current scene is used.
:arg frame: number.
:type frame: int or float.
:return: the time in seconds.
:rtype: datetime.timedelta
"""
if fps is None:
fps = _bpy.context.scene.render.fps
if fps_base is None:
fps_base = _bpy.context.scene.render.fps_base
fps = fps / fps_base
from datetime import timedelta
return timedelta(0, frame / fps)
def time_to_frame(time, *, fps=None, fps_base=None):
"""
Returns a float frame number from a time given in seconds or
as a datetime.timedelta object.
If *fps* and *fps_base* are not given the current scene is used.
:arg time: time in seconds.
:type time: number or a ``datetime.timedelta`` object
:return: the frame.
:rtype: float
"""
if fps is None:
fps = _bpy.context.scene.render.fps
if fps_base is None:
fps_base = _bpy.context.scene.render.fps_base
fps = fps / fps_base
from datetime import timedelta
if isinstance(time, timedelta):
time = time.total_seconds()
return time * fps
def preset_find(name, preset_path, *, display_name=False, ext=".py"):
if not name:
return None
for directory in preset_paths(preset_path):
if display_name:
filename = ""
for fn in _os.listdir(directory):
if fn.endswith(ext) and name == _bpy.path.display_name(fn, title_case=False):
filename = fn
break
else:
filename = name + ext
if filename:
filepath = _os.path.join(directory, filename)
if _os.path.exists(filepath):
return filepath
def keyconfig_init():
# Key configuration initialization and refresh, called from the Blender
# window manager on startup and refresh.
active_config = _preferences.keymap.active_keyconfig
# Load the default key configuration.
default_filepath = preset_find("Blender", "keyconfig")
keyconfig_set(default_filepath)
# Set the active key configuration if different
filepath = preset_find(active_config, "keyconfig")
if filepath and filepath != default_filepath:
keyconfig_set(filepath)
def keyconfig_set(filepath, *, report=None):
from os.path import basename, splitext
if _bpy.app.debug_python:
print("loading preset:", filepath)
keyconfigs = _bpy.context.window_manager.keyconfigs
try:
error_msg = ""
execfile(filepath)
except:
import traceback
error_msg = traceback.format_exc()
name = splitext(basename(filepath))[0]
kc_new = keyconfigs.get(name)
if error_msg:
if report is not None:
report({'ERROR'}, error_msg)
print(error_msg)
if kc_new is not None:
keyconfigs.remove(kc_new)
return False
# Get name, exception for default keymap to keep backwards compatibility.
if kc_new is None:
if report is not None:
report({'ERROR'}, "Failed to load keymap %r" % filepath)
return False
else:
keyconfigs.active = kc_new
return True
def user_resource(resource_type, *, path="", create=False):
"""
Return a user resource path (normally from the users home directory).
:arg type: Resource type in ['DATAFILES', 'CONFIG', 'SCRIPTS', 'AUTOSAVE'].
:type type: string
:arg path: Optional subdirectory.
:type path: string
:arg create: Treat the path as a directory and create
it if its not existing.
:type create: boolean
:return: a path.
:rtype: string
"""
target_path = _user_resource(resource_type, path=path)
if create:
# should always be true.
if target_path:
# create path if not existing.
if not _os.path.exists(target_path):
try:
_os.makedirs(target_path)
except:
import traceback
traceback.print_exc()
target_path = ""
elif not _os.path.isdir(target_path):
print("Path %r found but isn't a directory!" % target_path)
target_path = ""
return target_path
def register_classes_factory(classes):
"""
Utility function to create register and unregister functions
which simply registers and unregisters a sequence of classes.
"""
def register():
for cls in classes:
register_class(cls)
def unregister():
for cls in reversed(classes):
unregister_class(cls)
return register, unregister
def register_submodule_factory(module_name, submodule_names):
"""
Utility function to create register and unregister functions
which simply load submodules,
calling their register & unregister functions.
.. note::
Modules are registered in the order given,
unregistered in reverse order.
:arg module_name: The module name, typically ``__name__``.
:type module_name: string
:arg submodule_names: List of submodule names to load and unload.
:type submodule_names: list of strings
:return: register and unregister functions.
:rtype: tuple pair of functions
"""
module = None
submodules = []
def register():
nonlocal module
module = __import__(name=module_name, fromlist=submodule_names)
submodules[:] = [getattr(module, name) for name in submodule_names]
for mod in submodules:
mod.register()
def unregister():
from sys import modules
for mod in reversed(submodules):
mod.unregister()
name = mod.__name__
delattr(module, name.partition(".")[2])
del modules[name]
submodules.clear()
return register, unregister
# -----------------------------------------------------------------------------
# Tool Registration
def register_tool(tool_cls, *, after=None, separator=False, group=False):
"""
Register a tool in the toolbar.
:arg tool: A tool subclass.
:type tool: :class:`bpy.types.WorkSpaceTool` subclass.
:arg space_type: Space type identifier.
:type space_type: string
:arg after: Optional identifiers this tool will be added after.
:type after: collection of strings or None.
:arg separator: When true, add a separator before this tool.
:type separator: bool
:arg group: When true, add a new nested group of tools.
:type group: bool
"""
space_type = tool_cls.bl_space_type
context_mode = tool_cls.bl_context_mode
from bl_ui.space_toolsystem_common import (
ToolSelectPanelHelper,
ToolDef,
)
cls = ToolSelectPanelHelper._tool_class_from_space_type(space_type)
if cls is None:
raise Exception("Space type %r has no toolbar" % space_type)
tools = cls._tools[context_mode]
# First sanity check
from bpy.types import WorkSpaceTool
tools_id = {
item.idname for item in ToolSelectPanelHelper._tools_flatten(tools)
if item is not None
}
if not issubclass(tool_cls, WorkSpaceTool):
raise Exception("Expected WorkSpaceTool subclass, not %r" % type(tool_cls))
if tool_cls.bl_idname in tools_id:
raise Exception("Tool %r already exists!" % tool_cls.bl_idname)
del tools_id, WorkSpaceTool
# Convert the class into a ToolDef.
def tool_from_class(tool_cls):
# Convert class to tuple, store in the class for removal.
tool_def = ToolDef.from_dict({
"idname": tool_cls.bl_idname,
"label": tool_cls.bl_label,
"description": getattr(tool_cls, "bl_description", tool_cls.__doc__),
"icon": getattr(tool_cls, "bl_icon", None),
"cursor": getattr(tool_cls, "bl_cursor", None),
"options": getattr(tool_cls, "bl_options", None),
"widget": getattr(tool_cls, "bl_widget", None),
"widget_properties": getattr(tool_cls, "bl_widget_properties", None),
"keymap": getattr(tool_cls, "bl_keymap", None),
"data_block": getattr(tool_cls, "bl_data_block", None),
"operator": getattr(tool_cls, "bl_operator", None),
"draw_settings": getattr(tool_cls, "draw_settings", None),
"draw_cursor": getattr(tool_cls, "draw_cursor", None),
})
tool_cls._bl_tool = tool_def
keymap_data = tool_def.keymap
if keymap_data is not None:
if context_mode is None:
context_descr = "All"
else:
context_descr = context_mode.replace("_", " ").title()
from bpy import context
wm = context.window_manager
keyconfigs = wm.keyconfigs
kc_default = keyconfigs.default
# Note that Blender's default tools use the default key-config for both.
# We need to use the add-ons for 3rd party tools so reloading the key-map doesn't clear them.
kc = keyconfigs.addon
if callable(keymap_data[0]):
cls._km_action_simple(kc_default, kc, context_descr, tool_def.label, keymap_data)
return tool_def
tool_converted = tool_from_class(tool_cls)
if group:
# Create a new group
tool_converted = (tool_converted,)
tool_def_insert = (
(None, tool_converted) if separator else
(tool_converted,)
)
def skip_to_end_of_group(seq, i):
i_prev = i
while i < len(seq) and seq[i] is not None:
i_prev = i
i += 1
return i_prev
changed = False
if after is not None:
for i, item in enumerate(tools):
if item is None:
pass
elif isinstance(item, ToolDef):
if item.idname in after:
i = skip_to_end_of_group(item, i)
tools[i + 1:i + 1] = tool_def_insert
changed = True
break
elif isinstance(item, tuple):
for j, sub_item in enumerate(item, 1):
if isinstance(sub_item, ToolDef):
if sub_item.idname in after:
if group:
# Can't add a group within a group,
# add a new group after this group.
i = skip_to_end_of_group(tools, i)
tools[i + 1:i + 1] = tool_def_insert
else:
j = skip_to_end_of_group(item, j)
item = item[:j + 1] + tool_def_insert + item[j + 1:]
tools[i] = item
changed = True
break
if changed:
break
if not changed:
print("bpy.utils.register_tool: could not find 'after'", after)
if not changed:
tools.extend(tool_def_insert)
def unregister_tool(tool_cls):
space_type = tool_cls.bl_space_type
context_mode = tool_cls.bl_context_mode
from bl_ui.space_toolsystem_common import ToolSelectPanelHelper
cls = ToolSelectPanelHelper._tool_class_from_space_type(space_type)
if cls is None:
raise Exception("Space type %r has no toolbar" % space_type)
tools = cls._tools[context_mode]
tool_def = tool_cls._bl_tool
try:
i = tools.index(tool_def)
except ValueError:
i = -1
def tool_list_clean(tool_list):
# Trim separators.
while tool_list and tool_list[-1] is None:
del tool_list[-1]
while tool_list and tool_list[0] is None:
del tool_list[0]
# Remove duplicate separators.
for i in range(len(tool_list) - 1, -1, -1):
is_none = tool_list[i] is None
if is_none and prev_is_none:
del tool_list[i]
prev_is_none = is_none
changed = False
if i != -1:
del tools[i]
tool_list_clean(tools)
changed = True
if not changed:
for i, item in enumerate(tools):
if isinstance(item, tuple):
try:
j = item.index(tool_def)
except ValueError:
j = -1
if j != -1:
item_clean = list(item)
del item_clean[j]
tool_list_clean(item_clean)
if item_clean:
tools[i] = tuple(item_clean)
else:
del tools[i]
tool_list_clean(tools)
del item_clean
# tuple(sub_item for sub_item in items if sub_item is not tool_def)
changed = True
break
if not changed:
raise Exception("Unable to remove %r" % tool_cls)
del tool_cls._bl_tool
keymap_data = tool_def.keymap
if keymap_data is not None:
from bpy import context
wm = context.window_manager
keyconfigs = wm.keyconfigs
for kc in (keyconfigs.default, keyconfigs.addon):
km = kc.keymaps.get(keymap_data[0])
if km is None:
print("Warning keymap %r not found in %r!" % (keymap_data[0], kc.name))
else:
kc.keymaps.remove(km)
# -----------------------------------------------------------------------------
# Manual lookups, each function has to return a basepath and a sequence
# of...
# we start with the built-in default mapping
def _blender_default_map():
# NOTE(@ideasman42): Avoid importing this as there is no need to keep the lookup table in memory.
# As this runs when the user accesses the "Online Manual", the overhead loading the file is acceptable.
# In my tests it's under 1/100th of a second loading from a `pyc`.
ref_mod = execfile(_os.path.join(_script_base_dir, "modules", "rna_manual_reference.py"))
return (ref_mod.url_manual_prefix, ref_mod.url_manual_mapping)
# hooks for doc lookups
_manual_map = [_blender_default_map]
def register_manual_map(manual_hook):
_manual_map.append(manual_hook)
def unregister_manual_map(manual_hook):
_manual_map.remove(manual_hook)
def manual_map():
# reverse so default is called last
for cb in reversed(_manual_map):
try:
prefix, url_manual_mapping = cb()
except:
print("Error calling %r" % cb)
import traceback
traceback.print_exc()
continue
yield prefix, url_manual_mapping
# Languages which are supported by the user manual (commented when there is no translation).
_manual_language_codes = {
"ar_EG": "ar", # Arabic
# "bg_BG": "bg", # Bulgarian
# "ca_AD": "ca", # Catalan
# "cs_CZ": "cz", # Czech
"de_DE": "de", # German
# "el_GR": "el", # Greek
"es": "es", # Spanish
"fi_FI": "fi", # Finnish
"fr_FR": "fr", # French
"id_ID": "id", # Indonesian
"it_IT": "it", # Italian
"ja_JP": "ja", # Japanese
"ko_KR": "ko", # Korean
# "nb": "nb", # Norwegian
# "nl_NL": "nl", # Dutch
# "pl_PL": "pl", # Polish
"pt_PT": "pt", # Portuguese
# Portuguese - Brazil, for until we have a pt_BR version.
"pt_BR": "pt",
"ru_RU": "ru", # Russian
"sk_SK": "sk", # Slovak
# "sl": "sl", # Slovenian
"sr_RS": "sr", # Serbian
# "sv_SE": "sv", # Swedish
# "tr_TR": "th", # Thai
"uk_UA": "uk", # Ukrainian
"vi_VN": "vi", # Vietnamese
"zh_CN": "zh-hans", # Simplified Chinese
"zh_TW": "zh-hant", # Traditional Chinese
}
def manual_language_code(default="en"):
"""
:return:
The language code used for user manual URL component based on the current language user-preference,
falling back to the ``default`` when unavailable.
:rtype: str
"""
language = _bpy.context.preferences.view.language
if language == 'DEFAULT':
language = _os.getenv("LANG", "").split(".")[0]
return _manual_language_codes.get(language, default)
# Build an RNA path from struct/property/enum names.
def make_rna_paths(struct_name, prop_name, enum_name):
"""
Create RNA "paths" from given names.
:arg struct_name: Name of a RNA struct (like e.g. "Scene").
:type struct_name: string
:arg prop_name: Name of a RNA struct's property.
:type prop_name: string
:arg enum_name: Name of a RNA enum identifier.
:type enum_name: string
:return: A triple of three "RNA paths"
(most_complete_path, "struct.prop", "struct.prop:'enum'").
If no enum_name is given, the third element will always be void.
:rtype: tuple of strings
"""
src = src_rna = src_enum = ""
if struct_name:
if prop_name:
src = src_rna = ".".join((struct_name, prop_name))
if enum_name:
src = src_enum = "%s:'%s'" % (src_rna, enum_name)
else:
src = src_rna = struct_name
return src, src_rna, src_enum

137
scripts/modules/bpy/utils/previews.py Normal file
View File

@@ -0,0 +1,137 @@
# SPDX-License-Identifier: GPL-2.0-or-later
"""
This module contains utility functions to handle custom previews.
It behaves as a high-level 'cached' previews manager.
This allows scripts to generate their own previews, and use them as icons in UI widgets
('icon_value' for UILayout functions).
Custom Icon Example
-------------------
.. literalinclude:: __/__/__/scripts/templates_py/ui_previews_custom_icon.py
"""
__all__ = (
"new",
"remove",
"ImagePreviewCollection",
)
import _bpy
_utils_previews = _bpy._utils_previews
del _bpy
_uuid_open = set()
# High-level previews manager.
# not accessed directly
class ImagePreviewCollection(dict):
"""
Dictionary-like class of previews.
This is a subclass of Python's built-in dict type,
used to store multiple image previews.
.. note::
- instance with :mod:`bpy.utils.previews.new`
- keys must be ``str`` type.
- values will be :class:`bpy.types.ImagePreview`
"""
# Internal notes:
# - Blender's internal 'PreviewImage' struct uses 'self._uuid' prefix.
# - Blender's preview.new/load return the data if it exists,
# don't do this for the Python API as it allows accidental re-use of names,
# anyone who wants to reuse names can use dict.get() to check if it exists.
# We could use this for the C API too (would need some investigation).
def __init__(self):
super().__init__()
self._uuid = hex(id(self))
_uuid_open.add(self._uuid)
def __del__(self):
if self._uuid not in _uuid_open:
return
raise ResourceWarning(
"%r: left open, remove with 'bpy.utils.previews.remove()'" % self
)
self.close()
def _gen_key(self, name):
return ":".join((self._uuid, name))
def new(self, name):
if name in self:
raise KeyError("key %r already exists" % name)
p = self[name] = _utils_previews.new(
self._gen_key(name))
return p
new.__doc__ = _utils_previews.new.__doc__
def load(self, name, path, path_type, force_reload=False):
if name in self:
raise KeyError("key %r already exists" % name)
p = self[name] = _utils_previews.load(
self._gen_key(name), path, path_type, force_reload)
return p
load.__doc__ = _utils_previews.load.__doc__
def clear(self):
"""Clear all previews."""
for name in self.keys():
_utils_previews.release(self._gen_key(name))
super().clear()
def close(self):
"""Close the collection and clear all previews."""
self.clear()
_uuid_open.remove(self._uuid)
def __delitem__(self, key):
_utils_previews.release(self._gen_key(key))
super().__delitem__(key)
def __repr__(self):
return "<%s id=%s[%d], %r>" % (
self.__class__.__name__, self._uuid, len(self), super()
)
def new():
"""
:return: a new preview collection.
:rtype: :class:`ImagePreviewCollection`
"""
return ImagePreviewCollection()
def remove(pcoll):
"""
Remove the specified previews collection.
:arg pcoll: Preview collection to close.
:type pcoll: :class:`ImagePreviewCollection`
"""
pcoll.close()
# don't complain about resources on exit (only unregister)
import atexit
def exit_clear_warning():
del ImagePreviewCollection.__del__
atexit.register(exit_clear_warning)
del atexit, exit_clear_warning

5
scripts/modules/bpy/utils/toolsystem.py Normal file
View File

@@ -0,0 +1,5 @@
# SPDX-License-Identifier: GPL-2.0-or-later
# Until we untangle ToolDef from bl_ui internals,
# use this module to document ToolDef.
from bl_ui.space_toolsystem_common import ToolDef