Yusarina
ff23d23cfc
I decided to go through each function and UI section one by one, improving and overhauling things. Each function and section is going to be fully tested and not rushed out. This is the best way to catch things, but also include the code base as much as possible.
186 lines
6.6 KiB
Python
186 lines
6.6 KiB
Python
import os
|
|
import bpy
|
|
import sys
|
|
import typing
|
|
import inspect
|
|
import pkgutil
|
|
import tomllib
|
|
import importlib
|
|
from pathlib import Path
|
|
from typing import List, Dict, Set, Optional, Any, Type, Tuple, Generator, TypeVar
|
|
|
|
__all__ = (
|
|
"init",
|
|
"register",
|
|
"unregister",
|
|
)
|
|
|
|
T = TypeVar('T')
|
|
modules: Optional[List[Any]] = None
|
|
ordered_classes: Optional[List[Type]] = None
|
|
|
|
def init() -> None:
|
|
"""Initialize the auto-loader by discovering modules and classes"""
|
|
global modules
|
|
global ordered_classes
|
|
print("Auto-load init starting")
|
|
modules = get_all_submodules(Path(__file__).parent.parent)
|
|
ordered_classes = get_ordered_classes_to_register(modules)
|
|
print(f"Found modules: {modules}")
|
|
print(f"Found classes: {ordered_classes}")
|
|
|
|
def register() -> None:
|
|
"""Register all discovered classes and modules"""
|
|
print("Registering classes")
|
|
for cls in ordered_classes:
|
|
print(f"Registering: {cls}")
|
|
try:
|
|
bpy.utils.register_class(cls)
|
|
except ValueError:
|
|
continue
|
|
|
|
for module in modules:
|
|
if module.__name__ == __name__:
|
|
continue
|
|
if hasattr(module, "register"):
|
|
module.register()
|
|
|
|
def unregister() -> None:
|
|
"""Unregister all classes and modules in reverse order"""
|
|
for cls in reversed(ordered_classes):
|
|
bpy.utils.unregister_class(cls)
|
|
|
|
for module in modules:
|
|
if module.__name__ == __name__:
|
|
continue
|
|
if hasattr(module, "unregister"):
|
|
module.unregister()
|
|
|
|
def get_manifest_id() -> str:
|
|
"""Get the addon ID from the manifest file"""
|
|
manifest_path = Path(__file__).parent.parent / "blender_manifest.toml"
|
|
with open(manifest_path, "rb") as f:
|
|
manifest = tomllib.load(f)
|
|
return manifest["id"]
|
|
|
|
def get_all_submodules(directory: Path) -> List[Any]:
|
|
"""Discover and import all submodules in the given directory"""
|
|
modules = []
|
|
addon_id = get_manifest_id()
|
|
for root, dirs, files in os.walk(directory):
|
|
if "__pycache__" in root:
|
|
continue
|
|
path = Path(root)
|
|
if path == directory:
|
|
package_name = f"bl_ext.user_default.{addon_id}"
|
|
else:
|
|
relative_path = path.relative_to(directory).as_posix().replace('/', '.')
|
|
package_name = f"bl_ext.user_default.{addon_id}.{relative_path}"
|
|
for name in sorted(iter_module_names(path)):
|
|
modules.append(importlib.import_module(f".{name}", package_name))
|
|
return modules
|
|
|
|
def iter_submodules(path: Path, package_name: str) -> Generator[Any, None, None]:
|
|
"""Iterate through submodules in a package"""
|
|
for name in sorted(iter_module_names(path)):
|
|
yield importlib.import_module("." + name, package_name)
|
|
|
|
def iter_module_names(path: Path) -> Generator[str, None, None]:
|
|
"""Iterate through module names in a directory"""
|
|
print(f"Scanning path: {path}")
|
|
modules_list = list(pkgutil.iter_modules([str(path)]))
|
|
print(f"Found these modules: {modules_list}")
|
|
for _, module_name, is_pkg in modules_list:
|
|
if not is_pkg:
|
|
print(f"Found module: {module_name}")
|
|
yield module_name
|
|
|
|
def get_ordered_classes_to_register(modules: List[Any]) -> List[Type]:
|
|
"""Get a topologically sorted list of classes to register"""
|
|
return toposort(get_register_deps_dict(modules))
|
|
|
|
def get_register_deps_dict(modules: List[Any]) -> Dict[Type, Set[Type]]:
|
|
"""Get dependencies dictionary for class registration"""
|
|
deps_dict = {}
|
|
classes_to_register = set(iter_classes_to_register(modules))
|
|
for cls in classes_to_register:
|
|
deps_dict[cls] = set(iter_own_register_deps(cls, classes_to_register))
|
|
return deps_dict
|
|
|
|
def iter_own_register_deps(cls: Type, classes_to_register: Set[Type]) -> Generator[Type, None, None]:
|
|
"""Iterate through a class's own registration dependencies"""
|
|
yield from (dep for dep in iter_register_deps(cls) if dep in classes_to_register)
|
|
|
|
def iter_register_deps(cls: Type) -> Generator[Type, None, None]:
|
|
"""Iterate through all registration dependencies of a class"""
|
|
for value in typing.get_type_hints(cls, {}, {}).values():
|
|
dependency = get_dependency_from_annotation(value)
|
|
if dependency is not None:
|
|
yield dependency
|
|
|
|
def get_dependency_from_annotation(value: Any) -> Optional[Type]:
|
|
"""Get dependency type from a type annotation"""
|
|
if isinstance(value, tuple) and len(value) == 2:
|
|
if value[0] in (bpy.props.PointerProperty, bpy.props.CollectionProperty):
|
|
return value[1]["type"]
|
|
return None
|
|
|
|
def iter_classes_to_register(modules: List[Any]) -> Generator[Type, None, None]:
|
|
"""Iterate through classes that need to be registered"""
|
|
base_types = get_register_base_types()
|
|
for cls in get_classes_in_modules(modules):
|
|
if any(base in base_types for base in cls.__bases__):
|
|
if not getattr(cls, "_is_registered", False):
|
|
yield cls
|
|
|
|
def get_classes_in_modules(modules: List[Any]) -> Set[Type]:
|
|
"""Get all classes defined in the modules"""
|
|
classes = set()
|
|
for module in modules:
|
|
for cls in iter_classes_in_module(module):
|
|
classes.add(cls)
|
|
return classes
|
|
|
|
def iter_classes_in_module(module: Any) -> Generator[Type, None, None]:
|
|
"""Iterate through classes defined in a module"""
|
|
for value in module.__dict__.values():
|
|
if inspect.isclass(value):
|
|
yield value
|
|
|
|
def get_register_base_types() -> Set[Type]:
|
|
"""Get set of base types that need registration"""
|
|
return set(getattr(bpy.types, name) for name in [
|
|
"Panel", "Operator", "PropertyGroup",
|
|
"AddonPreferences", "Header", "Menu",
|
|
"Node", "NodeSocket", "NodeTree",
|
|
"UIList", "RenderEngine"
|
|
])
|
|
|
|
def toposort(deps_dict: Dict[Type, Set[Type]]) -> List[Type]:
|
|
"""Topologically sort classes based on their dependencies"""
|
|
sorted_list = []
|
|
sorted_values = set()
|
|
|
|
panels_to_sort = [(value, deps) for value, deps in deps_dict.items()
|
|
if hasattr(value, 'bl_parent_id')]
|
|
|
|
base_panels = [(value, deps) for value, deps in deps_dict.items()
|
|
if not hasattr(value, 'bl_parent_id')]
|
|
|
|
for value, deps in base_panels:
|
|
if len(deps) == 0:
|
|
sorted_list.append(value)
|
|
sorted_values.add(value)
|
|
|
|
while len(deps_dict) > len(sorted_values):
|
|
unsorted = []
|
|
for value, deps in deps_dict.items():
|
|
if value not in sorted_values:
|
|
if len(deps - sorted_values) == 0:
|
|
sorted_list.append(value)
|
|
sorted_values.add(value)
|
|
else:
|
|
unsorted.append(value)
|
|
|
|
return sorted_list
|