node-to-json 0.1.0__tar.gz

node_to_json-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: node_to_json
+Version: 0.1.0
+Summary: Library to serialize Blender 5.2 nodes to json files, and from json files to Blender nodes.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Node To JSON
+
+## Convert Blender 5.2 Nodes to JSON files. Convert JSON objects to Blender Nodes.
+### Created to work with Blender Addons and Extensions to serialize nodes. It is only intended to work within Blender's python interpreter and requires the bpy module.

node_to_json-0.1.0/README.md

@@ -0,0 +1,4 @@
+# Node To JSON
+
+## Convert Blender 5.2 Nodes to JSON files. Convert JSON objects to Blender Nodes.
+### Created to work with Blender Addons and Extensions to serialize nodes. It is only intended to work within Blender's python interpreter and requires the bpy module.

node_to_json-0.1.0/node_to_json/__init__.py

@@ -0,0 +1,5 @@
+from .asset_funcs import asset_nodes, asset_node_group, nodes_dir
+from .json_io import dict_to_json, json_to_dict
+from .node_getters import serialize_node_group, serialize_mat_group, serialize_material, serialize_comp_group, convert_attr, get_node_build_data, get_node_group_interface, get_node_group_names
+from .node_registry import bpy_types_funcs, register_node_setter
+from .node_setters import nested_dict, convert_default_value, create_node_group_from_data, add_node_group, create_material, add_material_to_ob, add_comp_group, process_node, set_interface

node_to_json-0.1.0/node_to_json/asset_funcs.py

@@ -0,0 +1,78 @@
+import bpy
+from pathlib import Path
+from functools import cache
+from typing import Generator
+from .type_util import BGroup, PYDict
+
+datafiles_path = Path(bpy.utils.system_resource('DATAFILES'))
+lib_relpath = Path("assets").joinpath("nodes")
+nodes_dir = datafiles_path.joinpath(lib_relpath)
+hair_nodes = nodes_dir.joinpath("procedural_hair_node_assets.blend")
+comp_nodes = nodes_dir.joinpath("compositing_nodes_essentials.blend")
+dyn_nodes = nodes_dir.joinpath("geometry_nodes_dynamics_assets.blend")
+geom_nodes = nodes_dir.joinpath("geometry_nodes_essentials.blend")
+principal_nodes = nodes_dir.joinpath("principal_components.blend")
+shading_nodes = nodes_dir.joinpath("shading_nodes_essentials.blend")
+
+
+def get_asset_nodes_helper(file: str) -> Generator[str, None, None]:
+    with bpy.data.libraries.load(str(file), link=True)  as (data_src, data_dst):
+        groups = (g for g in data_src.node_groups)
+        return groups
+
+
+@cache
+def get_asset_nodes() -> Generator[str, None, None]:
+    for file in nodes_dir.rglob('*blend'):
+        yield from get_asset_nodes_helper(file)
+
+
+asset_nodes = list(get_asset_nodes())
+
+@cache
+def get_asset_file(name: str) -> str | None:
+    for file in nodes_dir.rglob('*blend'):
+        if name in get_asset_nodes_helper(file):
+            return file
+    return
+
+
+def append_asset_nodes(*node_groups: str) -> None:
+    for group in node_groups:
+        name = group.split(".")[0]
+        file = get_asset_file(name)
+        if file:
+            with bpy.data.libraries.load(str(file), link=False)  as (data_src, data_dst):
+                data_dst.node_groups = [name]
+    return
+
+
+def get_loaded_node_groups() -> Generator[BGroup, None, None]:
+    return (group for group in bpy.data.node_groups)
+
+
+def get_loaded_node_group_names() -> list[str]:
+    return [group.name for group in get_loaded_node_groups()]
+
+
+def load_asset_node(node_group: BGroup) -> Generator[BGroup, None, None] | None:
+    global asset_nodes
+    loaded = list(get_loaded_node_groups())
+    if node_group in asset_nodes:
+        append_asset_nodes(node_group)
+        new_ = list(get_loaded_node_groups())
+        return (n for n in new_ if n not in loaded)
+    return
+
+
+def asset_node_group(node_group: str) -> BGroup | None:
+    """Add an asset node group or return None.
+    
+    :param node_group: Node group name to load.
+    :type node_group: str
+    :return: Return node group if it is an asset node else return None.
+    :rtype: Node Group | None"""
+    anode = load_asset_node(node_group)
+    if anode not in [None, []]:
+        return next((g for g in anode if g.name.split(".")[0] == node_group.split(".")[0]))
+    return

node_to_json-0.1.0/node_to_json/json_io.py

@@ -0,0 +1,31 @@
+from json import dump, load
+from .type_util import PYDict
+
+
+def dict_to_json(file: str, data: PYDict, indent: int | None = None) -> None:
+    """Convert python dict to json object.
+    
+    :param file: File path of file to save to.
+    :type file: str
+    :param data: Dict of data to convert.
+    :type data: dict[str, Any]
+    :param indent: How many spaces to indent json object. (None = no indent.)
+    :type indent: int | None"""
+    with open(file, 'w') as f:
+        if indent:
+            dump(data, f, indent=indent)
+        else:
+            dump(data, f)
+
+
+def json_to_dict(file: str) -> PYDict:
+    """Convert json object to python dict.
+    
+    :param file: File path to load from.
+    :type file: str
+    :return: Dict of converted json object
+    :rtype: dict[str, Any]"""
+    with open(file, 'r') as f:
+        data = load(f)
+    return data
+

node_to_json-0.1.0/node_to_json/node_getters.py

@@ -0,0 +1,490 @@
+import bpy
+from mathutils import Color, Euler, Vector, Matrix, Quaternion
+from idprop.types import IDPropertyArray
+from collections import defaultdict
+from typing import Any, Generator
+from .type_util import BNode, BGroup, PYDict, PYObject
+from .asset_funcs import asset_nodes
+
+
+node_attr_exclude = ['rna_type', 'bl_rna', 'inputs', 'internal_links', 'outputs', 'enum_definition', 'interface_items', 'panel_states', 
+                     'item', 'bl_static_type', 'dimensions', 'color_tag']
+
+node_type_exclude = [
+        'bpy_prop_collection', 
+        'Object', 
+        'Material', 
+        'Image', 
+        'ImageTexture', 
+        'Texture', 
+        'Collection', 
+        'Scene', 
+        'Sound', 
+        'Node', 
+        'GeometryNodeTree', 
+        'ShaderNodeTree', 
+        'CompositorNodeTree', 
+        ]
+
+preset_attr_exclude = [
+        'bl_description', 
+        'bl_height_default', 
+        'bl_height_max', 
+        'bl_height_min', 
+        'bl_icon', 
+        'bl_idname', 
+        'bl_label', 
+        'bl_static_type', 
+        'bl_width_default', 
+        'bl_width_max', 
+        'bl_width_min', 
+        'color', 
+        'color_tag', 
+        'dimensions', 
+        'height', 
+        'hide', 
+        'label', 
+        'location', 
+        'location_absolute', 
+        'mute', 
+        'name', 
+        'node_tree', 
+        'panel_states', 
+        'parent', 
+        'select', 
+        'show_options', 
+        'show_preview', 
+        'show_texture', 
+        'type', 
+        'use_custom_color', 
+        'warning_propagation', 
+        'width', 
+        ]
+
+socket_attr = [
+                'description', 
+                'enabled', 
+                'hide', 
+                'hide_value', 
+                'name', 
+                'pin_gizmo', 
+                'show_expanded', 
+                'type', 
+                'is_linked', 
+                'default_value', 
+                ]
+
+loop_outputs = [
+                'GeometryNodeRepeatOutput', 
+                'GeometryNodeForeachGeometryElementOutput', 
+                'GeometryNodeSimulationOutput', 
+                'NodeClosureOutput', 
+                ]
+
+
+### TREE NODES ###
+
+node_tree_attr = [
+            'bl_description', 
+            'bl_icon', 
+            'bl_idname', 
+            'bl_label', 
+            'bl_use_group_interface', 
+            'color_tag', 
+            'default_group_node_width', 
+            'description', 
+            'node_tree', 
+            ]
+
+geo_tree_attr = [
+            'is_mode_edit', 
+            'is_mode_object', 
+            'is_mode_paint', 
+            'is_mode_sculpt', 
+            'is_modifier', 
+            'is_tool', 
+            'is_type_curve', 
+            'is_type_grease_pencil', 
+            'is_type_mesh', 
+            'is_type_pointcloud', 
+            'node_tool_idname', 
+            'show_modifier_manage_panel', 
+            'use_wait_for_click', 
+            ]
+
+tree_inter_base = [
+            'item_type', 
+            'parent', 
+            'position', 
+            'description',
+            'name', 
+            'index', 
+            ]
+
+tree_inter_sock = [
+            'attribute_domain', 
+            'bl_socket_idname', 
+            'default_attribute_name', 
+            'default_input', 
+            'hide_in_modifier', 
+            'hide_value', 
+            'in_out', 
+            'is_inspect_output', 
+            'is_panel_toggle', 
+            'layer_selection_field', 
+            'menu_expanded', 
+            'optional_label', 
+            'socket_type', 
+            'structure_type', 
+            ]
+
+tree_inter_panel = [
+            'default_closed', 
+            'persistent_uid', 
+            ]
+
+items_tree_attr = [
+            'default_value', 
+            'dimensions', 
+            'min_value', 
+            'max_value', 
+            'subtype', 
+            ]
+
+
+### MATERIAL NODES ###
+
+mat_attr = [
+            'alpha_threshold', 
+            'blend_method', 
+            'diffuse_color', 
+            'displacement_method', 
+            'line_color', 
+            'line_priority', 
+            'max_vertex_displacement', 
+            'metallic', 
+            'paint_active_slot', 
+            'paint_clone_slot', 
+            'pass_index', 
+            'preview_render_type', 
+            'refraction_depth', 
+            'roughness', 
+#            'show_transparent_back', #(may introduce transparency sorting problems) (Deprecated: use ‘use_tranparency_overlap’)
+            'specular_color', 
+            'specular_intensity', 
+            'surface_render_method', 
+            'thickness_mode', 
+            'use_backface_culling', 
+            'use_backface_culling_lightprobe_volume', 
+            'use_backface_culling_shadow', 
+#            'use_nodes', #Depricated
+            'use_preview_world', 
+            'use_raytrace_refraction', 
+            'use_screen_refraction', 
+            'use_sss_translucency', 
+            'use_thickness_from_shadow', 
+            'use_transparency_overlap', 
+            'use_transparent_shadow', 
+            'volume_intersection_method', 
+            ]
+
+
+###################### HELPER FUNCS #######################
+
+def nested_dict() -> defaultdict:
+    """Create a nested dict of dicts.
+    
+    :return: dict[str, dict]
+    :rtype: defaultdict"""
+
+    return defaultdict(nested_dict)
+
+def convert_attr(val: Any) -> PYObject | list[PYObject]:
+    """Convert a value based on its bpy type.
+    
+    :param val: Value to modify if it is not serializable.
+    :type val: Any
+    :return: Modified value if it is not serializable, else the original value.
+    :rtype: Any"""
+    
+    if isinstance(val, (Color, Vector, Euler, Quaternion, bpy.types.bpy_prop_array, IDPropertyArray, set, tuple)):
+        return list(val)
+    if isinstance(val, (Matrix,)):
+        return [list(v) for v in val]
+    if isinstance(val, (bpy.types.Object, bpy.types.Material, bpy.types.Image, bpy.types.ImageTexture, bpy.types.Texture, bpy.types.Collection, bpy.types.Scene, bpy.types.Sound, bpy.types.MovieClip, bpy.types.AnimData, bpy.types.Action, bpy.types.Annotation, bpy.types.Mask)):
+        return None
+    if isinstance(val, (bpy.types.Node, bpy.types.GeometryNodeTree, bpy.types.ShaderNodeTree, bpy.types.CompositorNodeTree)):
+        return val.name
+    if isinstance(val, (bpy.types.NodeTreeInterfaceItem, bpy.types.NodeTreeInterfacePanel)):
+        if hasattr(val, 'persistent_uid'):
+            return [val.name, val.persistent_uid]
+        return val.name
+    return val
+
+
+########################## NODE ###########################
+
+
+def get_node_attr(ob: BNode, attr: list[str]) -> PYDict:
+    func = lambda a: [a, convert_attr(getattr(ob, a, None))]
+    mfunc = lambda a: hasattr(ob, a) and not isinstance(getattr(ob, a, None), type(None))
+    data = map(func, filter(mfunc, attr))
+    return dict(data)
+
+
+def get_node_data(node: BNode) -> PYDict:
+    global node_attr_exclude
+    a_filter = lambda a: (not a.startswith("__") and not a in node_attr_exclude) and (not getattr(node, a, None) is None and not type(getattr(node, a, None)).__name__ in ['bpy_func', 'method-wrapper', 'builtin_function_or_method', 'EnumProperty'])
+    attributes = filter(a_filter, dir(node))
+    def _get_attr(attr):
+        val = getattr(node, attr, None)
+        val_ = convert_attr(val)
+        if type(val).__name__ not in node_type_exclude and attr not in ['parent']:
+            if type(val).__name__ in dir(bpy.types):
+                return [attr, get_node_data(val)]
+            else:
+                return [attr, val_]
+        else: 
+            if type(val).__name__ in ['Node', 'GeometryNodeTree', 'ShaderNodeTree', 'CompositorNodeTree'] or attr in ['parent']:
+                return [attr, val_]
+            elif type(val).__name__ in ['bpy_prop_collection']:
+                return [attr, [get_node_data(v) for v in val[:]]]
+            else:
+                pass
+    return {k: v for k, v in map(_get_attr, attributes)}
+
+
+def get_socket_attr(node: BNode) -> dict[str, list[PYDict]]:
+    global socket_attr
+    i = []
+    o = []
+    if node.bl_idname not in loop_outputs:
+        if hasattr(node, 'inputs'):
+            inputs = getattr(node, 'inputs', None)
+            if inputs:
+                i = [get_node_attr(i_, socket_attr) for i_ in inputs]
+        if hasattr(node, 'outputs'):
+            outputs = getattr(node, 'outputs', None)
+            if outputs:
+                o = [get_node_attr(o_, socket_attr) for o_ in outputs]
+    return {'inputs': i, 'outputs': o}
+
+
+def get_node_build_data(node: BNode) -> dict[str, PYDict]:
+    """Serialize data to rebuild a node.
+    
+    :param node: Node to get data from.
+    :type node: Node
+    :return: Dict containing data to rebuild a node and input / output sockets.
+    :rtype: dict[str, Any]"""
+
+    return {**get_node_data(node), **get_socket_attr(node)}
+
+
+####################### NODE GROUP ########################
+
+
+def _get_node_group_names(nodes: BNode) -> Generator[str, None, None]:
+    global asset_nodes
+    for node in nodes:
+        if node.type == 'GROUP':
+            yield node.node_tree.name
+            if node.node_tree.name.split(".")[0] not in asset_nodes:
+                yield from _get_node_group_names(node.node_tree.nodes)
+
+
+def get_node_group_names(node_group: BGroup) -> PYDict:
+    """Retrieve all of the node groups inside a node group.
+    
+    :param node_group: Node group to search internal node groups inside of.
+    :type node_group: Node Group
+    :return: Dict containing the node group and all internally nested node groups.
+    :rtype: dict[str, dict[None]]"""
+
+    return {**{node_group.name: {}}, **{group: {} for group in _get_node_group_names(node_group.nodes)}}
+
+
+def get_node_group_attr_list(node_tree: BGroup) -> PYDict:
+    global node_tree_attr, geo_tree_attr
+    attributes = node_tree_attr + geo_tree_attr if node_tree.bl_idname == 'GeometryNodeTree' else node_tree_attr
+    return {a: convert_attr(getattr(node_tree, a, None)) for a in attributes}
+
+
+def get_items_tree(item: bpy.types.NodeTreeInterfaceItem) -> PYDict:
+    global tree_inter_base, tree_inter_sock, tree_inter_panel
+    itype = item.item_type
+    data = tree_inter_base
+    data = data + (tree_inter_panel if itype == 'PANEL' else tree_inter_sock)
+    if itype != 'PANEL':
+        data = data + items_tree_attr
+        return {a: convert_attr(getattr(item, a, None)) for a in data if hasattr(item, a)}
+    else:
+        return {a: convert_attr(getattr(item, a, None)) for a in data if hasattr(item, a)}
+
+
+def get_node_group_interface(node_tree: BGroup) -> Generator[PYDict, None, None]:
+    """Retrieve data for node group sockets and panels.
+    
+    :param node_tree: Node group to get data from.
+    :type node_tree: Node Group
+    :return: Generator containing dicts of socket and panel data.
+    :rtype: Generator[dict[str, Any], None, None]"""
+
+    return map(get_items_tree, node_tree.interface.items_tree)
+
+
+def get_socket_data(node: BNode) -> PYDict:
+    global node_attr_exclude
+    data = nested_dict()
+    attributes = (a for a in dir(node) if not a.startswith("__") and not a in node_attr_exclude)
+    for attr in attributes:
+        val = getattr(node, attr, None)
+        if val is None:
+            data[attr] = None
+        else: 
+            if not type(val).__name__ in ['bpy_func', 'method-wrapper', 'builtin_function_or_method', 'EnumProperty']:
+                val_ = convert_attr(val)
+                data[attr] = val_
+    return data
+
+
+def get_node_tree_nodes_data(node_tree: BGroup) -> PYDict | None:
+    nodes = getattr(node_tree, 'nodes', None)
+    if nodes:
+        return {node.name: get_node_build_data(node) for node in nodes}
+    return
+
+
+def get_node_tree_socket_data(node_tree: BGroup) -> Generator[PYDict, None, None] | None:
+    interface = getattr(node_tree, 'interface', None)
+    if interface:
+        items_tree = getattr(interface, 'items_tree', None)
+        if items_tree:
+            return (get_socket_data(socket) for socket in items_tree)
+    return
+
+
+def get_links(node_tree: BGroup) -> Generator[PYDict, None, None]:
+    link_attr = [
+            'name',
+            'type',
+            ]
+    links = getattr(node_tree, 'links', None)
+    if links:
+        for s in ([i.from_socket, i.to_socket] for i in links):
+            o_node = s[0].node.name
+            o_sock = next(idx for idx, o in enumerate(s[0].node.outputs) if o.identifier == s[0].identifier)
+            i_node = s[1].node.name
+            i_sock = next(idx for idx, i in enumerate(s[1].node.inputs) if i.identifier == s[1].identifier)
+            yield [{**{'node': o_node, 'socket': o_sock}, **{l: getattr(s[0], l, None) for l in link_attr}}, {**{'node': i_node, 'socket': i_sock}, **{l: getattr(s[1], l, None) for l in link_attr}}]
+
+
+def serialize_node_group(node_group: BGroup) -> PYDict:
+    """Serialize data to rebuild a node group.
+    
+    :param node_group: Node group to get data from.
+    :type node_group: Node Group
+    :return: Dict of data to rebuild a node group.
+    :rtype: dict[str, Any]"""
+
+    global asset_nodes
+    data = get_node_group_names(node_group)
+    gnames = [g.name for g in bpy.data.node_groups]
+    for group in data:
+        if group in gnames:
+            is_asset = group.split(".")[0] in asset_nodes
+            node_tree = bpy.data.node_groups[group]
+            data[group] = {**get_node_group_attr_list(node_tree), **{'interface': (None if is_asset else list(get_node_group_interface(node_tree)))}, **{'links': (None if is_asset else list(get_links(node_tree)))}, **{'nodes': (None if is_asset else get_node_tree_nodes_data(node_tree))}}
+    return {d: data[d] for d in data if len(data[d]) > 0}
+
+
+######################## MATERIAL #########################
+
+
+def get_mat_attr(material: bpy.types.Material) -> PYDict:
+    global mat_attr
+    return {a: convert_attr(getattr(material, a, None)) for a in mat_attr if hasattr(material, a)}
+
+
+def serialize_mat_group(node_group: BGroup) -> PYDict:
+    """Serialize data to rebuild a material node group.
+    
+    :param node_group: Node group to get data from.
+    :type node_group: Node Group
+    :return: Dict of data to rebuild a material node group.
+    :rtype: dict[str, Any]"""
+
+    global asset_nodes
+    data = get_node_group_names(node_group)
+    data_ = {**{'links': list(get_links(node_group))}, **{'nodes': get_node_tree_nodes_data(node_group)}, **{'node_groups': {}}}
+    for group in data:
+        if group in [g.name for g in bpy.data.node_groups]:
+            is_asset = group.split(".")[0] in asset_nodes
+            node_tree = bpy.data.node_groups[group]
+            data_['node_groups'] = {group: {**get_node_group_attr_list(node_tree), **{'interface': (None if is_asset else list(get_node_group_interface(node_tree)))}, **{'links': (None if is_asset else list(get_links(node_tree)))}, **{'nodes': (None if is_asset else get_node_tree_nodes_data(node_tree))}}}
+    return data_
+
+
+def serialize_material(material: bpy.types.Material) -> PYDict:
+    """Serialize data to rebuild a material.
+    
+    :param material: Material to get data from.
+    :type material: Material
+    :return: Dict of data to rebuild a material and material node group.
+    :rtype: dict[str, Any]"""
+
+    return {material.name.split(".")[0]: {**get_mat_attr(material), **{'node_tree': serialize_mat_group(material.node_tree)}}}
+
+
+####################### COMPOSITOR ########################
+
+
+def get_comp_node_data(node: BNode) -> PYDict:
+    global node_attr_exclude
+    a_filter = lambda a: (not a.startswith("__") and not a in node_attr_exclude) and (not getattr(node, a, None) is None and not type(getattr(node, a, None)).__name__ in ['bpy_func', 'method-wrapper', 'builtin_function_or_method', 'EnumProperty'])
+    attributes = filter(a_filter, dir(node))
+    def _get_attr(attr):
+        val = getattr(node, attr, None)
+        val_ = convert_attr(val)
+        if type(val).__name__ not in node_type_exclude and attr not in ['parent']:
+            if type(val).__name__ in dir(bpy.types):
+                return [attr, get_node_data(val)]
+            else:
+                return [attr, val_]
+        else: 
+            if type(val).__name__ in ['Node', 'GeometryNodeTree', 'ShaderNodeTree', 'CompositorNodeTree'] or attr in ['parent']:
+                return [attr, val_]
+            elif type(val).__name__ in ['bpy_prop_collection']:
+                return [attr, [get_node_data(v) for v in val[:]]]
+            else:
+                return [attr, val_]
+    return dict(map(_get_attr, attributes))
+
+
+def serialize_comp_group(compositor: bpy.types.CompositorNodeTree) -> PYDict:
+    """Serialize data to rebuild a compositor node group.
+    
+    :param compositor: Node group to get data from.
+    :type compositor: Node Group
+    :return: Dict of data to rebuild a compositor node group.
+    :rtype: dict[str, Any]"""
+    
+    compositor_exclude = ['bl_rna', 'id_type', 'interface', 'rna_type', 'nodes', 'links']
+    a_filter = lambda a: (not a.startswith("__") and not a in compositor_exclude) and (not getattr(compositor, a, None) is None and not type(getattr(compositor, a, None)).__name__ in ['bpy_func', 'method-wrapper', 'builtin_function_or_method', 'EnumProperty'])
+    attributes = filter(a_filter, dir(compositor))
+    def _get_attr(attr):
+        val = getattr(compositor, attr, None)
+        val_ = convert_attr(val)
+        return attr, val_
+    data = map(_get_attr, attributes)
+    group_names = get_node_group_names(compositor)
+    _nodes = lambda node_tree: {node.name: {**get_comp_node_data(node), **get_socket_attr(node)} for node in node_tree.nodes}
+    data = dict(data) | {'node_groups': {}}
+    for group in group_names:
+        if group in [g.name for g in bpy.data.node_groups]:
+            is_asset = group.split(".")[0] in asset_nodes
+            node_tree = bpy.data.node_groups[group]
+            data['node_groups'][group] = {**get_node_group_attr_list(node_tree), **{'interface': (None if is_asset else list(get_node_group_interface(node_tree)))}, **{'links': (None if is_asset else list(get_links(node_tree)))}, **{'nodes': (None if is_asset else _nodes(node_tree))}}
+    return data
+
+

node_to_json-0.1.0/node_to_json/node_registry.py

@@ -0,0 +1,26 @@
+import bpy
+from typing import Callable
+from .type_util import PYDict
+from functools import wraps
+
+
+type AttrData = PYDict
+type BtypeFn = Callable[[str, list[str]], AttrData]
+
+
+bpy_types_funcs: dict[str, BtypeFn] = {}
+
+
+def register_node_setter(*bpy_type: str) -> Callable[[bpy.types.Node, list[str]], AttrData]:
+    def decorator(fn: BtypeFn) -> dict[str, BtypeFn]:
+        @wraps(fn)
+        def wrapper(node: bpy.types.Node, attr: list[str]) -> BtypeFn:
+            return fn(node, attr)
+        # Assign types to function
+        for b in bpy_type:
+            bpy_types_funcs[b] = wrapper
+       # Return function
+        return wrapper
+    # Return the decorator
+    return decorator
+