First Commit

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+*.py[cod]

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.pythonPath": "/usr/bin/python3",
+    "python.linting.pylintEnabled": true,
+    "python.linting.enabled": true
+}

README.md

@@ -1,4 +1,4 @@
-# asset_library
+# asset_browser
 
 
 
@@ -15,14 +15,14 @@ Already a pro? Just edit this README.md and make it your own. Want to make it ea
 
 ```
 cd existing_repo
-git remote add origin https://gitlab.com/autour-de-minuit/blender/asset_library.git
+git remote add origin https://gitlab.com/autour-de-minuit/blender/asset_browser.git
 git branch -M main
 git push -uf origin main
 ```
 
 ## Integrate with your tools
 
-- [ ] [Set up project integrations](https://gitlab.com/autour-de-minuit/blender/asset_library/-/settings/integrations)
+- [ ] [Set up project integrations](https://gitlab.com/autour-de-minuit/blender/asset_browser/-/settings/integrations)
 
 ## Collaborate with your team
 

__init__.py

@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Extending features of the Asset Browser for a studio use. 
+"""
+
+bl_info = {
+    "name": "Asset Library",
+    "description": "Asset Library based on the Asset Browser.",
+    "author": "Sybren A. Stüvel, Clement Ducarteron, Christophe Seux, Samuel Bernou",
+    "version": (2, 0),
+    "blender": (3, 3, 0),
+    "warning": "In development, things may change",
+    "location": "Asset Browser -> Animations, and 3D Viewport -> Animation panel",
+    "category": "Animation",
+}
+
+#from typing import List, Tuple
+
+
+from asset_library import pose
+from asset_library import action
+from asset_library import collection
+from asset_library import file
+from asset_library import (gui, keymaps, prefs, operators)
+from asset_library import constants
+#from asset_library.common.adapter import AssetLibraryAdapter
+from asset_library.common.bl_utils import get_addon_prefs
+from asset_library.common.functions import set_env_libraries
+from asset_library.common.template import Template
+
+import re
+
+
+if 'bpy' in locals():
+    print("Reload Addon Asset Library")
+
+    import importlib
+
+    importlib.reload(gui)
+    importlib.reload(keymaps)
+
+    importlib.reload(prefs)
+    importlib.reload(operators)
+    importlib.reload(constants)
+
+import bpy
+import os
+
+
+#addon_keymaps: List[Tuple[bpy.types.KeyMap, bpy.types.KeyMapItem]] = []
+
+bl_modules = (
+    operators,
+    pose,
+    action,
+    collection,
+    file,
+    keymaps,
+    gui,
+    prefs
+)
+
+
+def load_handler():
+    print('load_handler')
+
+    set_env_libraries()
+    bpy.ops.assetlib.set_paths(all=True)
+    #bpy.ops.assetlib.#(all=True, only_recent=True)
+
+    bpy.ops.assetlib.bundle(blocking=False, mode='AUTO_BUNDLE')
+            
+
+
+def register() -> None:
+
+    for m in bl_modules:
+        m.register()
+
+    #prefs = get_addon_prefs()
+    
+
+
+
+    bpy.app.timers.register(load_handler, first_interval=1)
+
+
+def unregister() -> None:
+    for m in reversed(bl_modules):
+        m.unregister()

action/__init__.py

@@ -0,0 +1,30 @@
+
+from asset_library.action import (
+    gui,
+    keymaps,
+    clear_asset,
+    concat_preview,
+    operators,
+    properties,
+    rename_pose,
+    render_preview,)
+
+if 'bpy' in locals():
+    import importlib
+
+    importlib.reload(gui)
+    importlib.reload(keymaps)
+    importlib.reload(clear_asset)
+    importlib.reload(concat_preview)
+    importlib.reload(operators)
+    importlib.reload(properties)
+    importlib.reload(rename_pose)
+    importlib.reload(render_preview)
+
+def register():
+    operators.register()
+    keymaps.register()
+
+def unregister():
+    operators.unregister()
+    keymaps.unregister()

action/clear_asset.py

@@ -0,0 +1,48 @@
+
+import argparse
+import bpy
+import json
+import sys
+
+from pathlib import Path
+sys.path.append(Path(__file__).parents[3])
+from asset_library.common.bl_utils import (
+    get_preview,
+)
+
+def clear_asset(action_name='', use_fake_user=False):
+        
+    scn = bpy.context.scene
+
+    action = bpy.data.actions.get(action_name)
+    if not action:
+        print(f'No {action_name} not found.')
+        bpy.ops.wm.quit_blender()
+
+    action.asset_clear()    
+    if use_fake_user:
+        action.use_fake_user = True
+    else:
+        preview = get_preview(asset_path=bpy.data.filepath, asset_name=action_name)
+        if preview:
+            preview.unlink()
+        bpy.data.actions.remove(action)
+        
+    bpy.ops.wm.save_mainfile(
+        filepath=bpy.data.filepath, compress=True, exit=True
+    )
+    
+    
+if __name__ == '__main__' :
+    parser = argparse.ArgumentParser(description='Add Comment To the tracker',
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--action-name')
+    parser.add_argument('--use-fake-user', type=json.loads, default='false')
+
+    if '--' in sys.argv :
+        index = sys.argv.index('--')
+        sys.argv = [sys.argv[index-1], *sys.argv[index+1:]]
+
+    args = parser.parse_args()
+    clear_asset(**vars(args))

action/concat_preview.py

@@ -0,0 +1,146 @@
+
+import bpy
+import math
+import numpy as np
+
+from pathlib import Path
+
+
+def alpha_to_color(pixels_data, color):
+    """Convert Alpha to WhiteBG"""
+    new_pixels_data = []
+    for i in pixels_data:
+        height, width, array_d = i.shape 
+        mask = i[:,:,3:]
+        background = np.array([color[0], color[1], color[2] ,1], dtype=np.float32)
+        background = np.tile(background, (height*width))
+        background = np.reshape(background, (height,width,4))
+        new_pixels_data.append(i * mask + background * (1 - mask))
+        # print(new_pixels_data)#Dbg
+    return new_pixels_data
+
+def create_array(height, width):
+    return np.zeros((height*width*4), dtype=np.float32)
+
+def read_pixels_data(img, source_height, source_width):
+    img_w, img_h = img.size
+
+    if img_w != source_width :
+        scale = abs(img_w/source_width)
+        img.scale(int(img_w/scale), int(img_h/scale))
+        img_w, img_h = img.size
+
+    array = create_array(img_h, img_w)
+    img.pixels.foreach_get(array)
+    array = array.reshape(img_h, img_w, 4)
+    
+    if array.shape[0] != source_height:
+        #print('ARRAY SHAPE', array.shape[:], source_height)
+        missing_height = int(abs(source_height-img_h)/2)
+        empty_array = create_array(missing_height, source_width)
+        empty_array = empty_array.reshape(missing_height, source_width, 4)
+        array = np.vstack((empty_array, array, empty_array))
+
+    return array.reshape(source_height, source_width, 4)
+
+def create_final(output_name, pixels_data, final_height, final_width):
+    #print('output_name: ', output_name)
+
+    new_img = bpy.data.images.get(output_name)
+    if new_img:
+        bpy.data.images.remove(new_img)
+
+    new_img = bpy.data.images.new(output_name, final_width, final_height)
+    new_img.generated_color=(0,0,0,0)
+
+    #print('pixels_data: ', pixels_data)
+    new_img.pixels.foreach_set(pixels_data)
+
+    return new_img
+
+def guess_input_format(img_list):
+    for i in img_list:
+        if i.size[0] == i.size[1]:
+            return i.size
+
+def format_files(files, catalog_data):
+    img_dict = {}
+    for k, v in catalog_data.items():
+        if '/' not in k:
+            continue
+        img_dict[v['name']] = [f for f in files if v['name'] in f]
+
+    return img_dict
+
+def mosaic_export(
+    files, catalog_data, row=2, columns=2, auto_calculate=True,
+    bg_color=(0.18, 0.18, 0.18,), resize_output=100,
+):
+
+    img_dict = format_files(files, catalog_data)
+    
+    for cat, files_list in img_dict.items():
+
+        if not files_list:
+            continue
+
+        for i in bpy.data.images:
+            bpy.data.images.remove(i)
+            
+        img_list = []
+        
+        chars = Path(files_list[0]).parts[-4]
+        output_dir = str(Path(files_list[0]).parent.parent)
+
+        ext = 'jpg'
+        output_name = f'{chars}_{cat}.{ext}'
+
+        for img in files_list:
+            img_list.append(bpy.data.images.load(img, check_existing=True))
+
+        for i in img_list:
+            i.colorspace_settings.name = 'Raw'
+
+        if auto_calculate:
+            rows = int(math.sqrt(len(img_list)))
+            columns = math.ceil(len(img_list)/rows)
+
+        if rows*columns < len(img_list):
+            raise AttributeError('Grid too small for number of images')
+        
+        src_w, src_h = img_list[0].size
+        final_w = src_w * columns
+        final_h = src_h * rows
+
+        img_pixels = [read_pixels_data(img, src_h, src_w) for img in img_list]
+        
+        #Check if there is enough "data" to create an horizontal stack
+        ##It not, create empty array
+        h_stack = []
+        total_len = rows*columns
+        if len(img_pixels) < total_len:
+            for i in range(total_len-len(img_pixels)):
+                img_pixels.append(create_array(src_h, src_w).reshape(src_h, src_w, 4))
+        
+        img_pixels = alpha_to_color(img_pixels, bg_color)
+        for i in range(0,len(img_pixels),columns):
+            h_stack.append(np.hstack(img_pixels[i:i+columns]))
+        if rows > 1:
+            combined_stack = np.vstack(h_stack[::-1])
+        else:
+            combined_stack = np.hstack((h_stack[:]))
+
+        combined_img = create_final(output_name, combined_stack.flatten(), final_h, final_w)
+
+        if resize_output != 100:
+            w, h = combined_img.size
+            combined_img.scale(w*(resize_output*.01), h*(resize_output*.01))
+        
+
+        combined_img.filepath_raw = '/'.join([output_dir, output_name])
+        combined_img.file_format = 'JPEG'
+        combined_img.save()
+
+        print(f"""
+        Image saved: {combined_img.filepath_raw}
+        """)

action/functions.py

@@ -0,0 +1,207 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Functions related to anim and pose.
+"""
+
+from collections.abc import Collection
+
+from typing import Optional, FrozenSet, Set, Union, Iterable, cast
+import dataclasses
+import functools
+import re
+
+import bpy
+from bpy.types import (
+    Action,
+    Bone,
+    Context,
+    FCurve,
+    Keyframe,
+    Object,
+    TimelineMarker
+)
+
+from asset_library.common.bl_utils import active_catalog_id, split_path
+
+FCurveValue = Union[float, int]
+
+pose_bone_re = re.compile(r'pose.bones\["([^"]+)"\]')
+"""RegExp for matching FCurve data paths."""
+
+def is_pose(action):
+    for fc in action.fcurves:
+        if len(fc.keyframe_points) > 1:
+            return False
+
+    return True
+
+def get_bone_visibility(data_path):
+    bone, prop = split_path(data_path)
+    
+    ob = bpy.context.object
+    b_layers = [i for i, val in enumerate(ob.pose.bones[bone].bone.layers) if val]
+    
+    rig_layers = [(i, val) for i, val in enumerate(ob.data.layers)]
+
+    return ob.data.layers[b_layers[0]]
+
+def get_keyframes(action, selected=False, includes=[]):
+    if selected:
+        # keyframes = sorted([int(k.co[0]) for f in action.fcurves for k in f.keyframe_points if k.select_control_point and get_bone_visibility(f.data_path)])
+        keyframes = []
+        for f in action.fcurves:
+            bone, prop = split_path(f.data_path)
+            for k in f.keyframe_points:
+                if bone not in includes:
+                    continue
+                if not k.select_control_point:
+                    continue
+                if not get_bone_visibility(f.data_path):
+                    continue
+                
+                keyframes += [int(k.co[0])]                    
+        if len(keyframes) <= 1:
+            keyframes = [bpy.context.scene.frame_current]
+    else:
+        keyframes = sorted([int(k.co[0]) for f in action.fcurves for k in f.keyframe_points])
+
+    return keyframes
+
+def get_marker(action):
+    if action.pose_markers:
+        markers = action.pose_markers
+        return next((m.name for m in markers if m.frame == bpy.context.scene.frame_current), None)
+
+def reset_bone(bone, transform=True, custom_props=True):
+    if transform:
+        bone.location = (0, 0, 0)
+        if bone.rotation_mode == "QUATERNION":
+            bone.rotation_quaternion = (0, 0, 0, 0)
+        elif bone.rotation_mode == "AXIS_ANGLE":
+            bone.rotation_axis_angle = (0, 0, 0, 0)
+        else:
+            bone.rotation_euler = (0, 0, 0)
+            
+        bone.scale = (1, 1, 1)
+    
+    if custom_props:
+        for key, value in bone.items():
+            try:
+                id_prop = bone.id_properties_ui(key)
+            except TypeError:
+                continue
+                
+            if not isinstance(value, (int, float)) or not id_prop:
+                continue
+            bone[key] = id_prop.as_dict()['default']
+
+def is_asset_action(action):
+    return action.asset_data and action.asset_data.catalog_id != str(uuid.UUID(int=0))
+
+def conform_action(action):
+    tags = ('pose', 'anim')
+
+    if any(tag in action.asset_data.tags.keys() for tag in tags):
+        return
+
+    for fc in action.fcurves:
+        action.asset_data['is_single_frame'] = True
+        if len(fc.keyframe_points) > 1:
+            action.asset_data['is_single_frame'] = False
+            break
+
+    if action.asset_data['is_single_frame']:
+        action.asset_data.tags.new('pose')
+    else:
+        action.asset_data.tags.new('anim')
+
+def clean_action(action='', frame_start=0, frame_end=0, excludes=[], includes=[]):
+    ## Clean Keyframe Before/After Range
+    for fc in action.fcurves:
+        bone, prop = split_path(fc.data_path)
+        # !! Mush Mush dependent. Need to be fix
+        if bone in excludes or bone not in includes:
+            action.fcurves.remove(fc)
+            continue
+
+        # Add Keyframe At Start/End Range
+        for fr in (frame_start, frame_end):
+            fc_val = fc.evaluate(fr)
+            fc.keyframe_points.insert(frame=fr, value=fc_val)
+            fc.update()
+
+        # Remove Keyframe out of range
+        for k in reversed(fc.keyframe_points):                    
+            if int(k.co[0]) not in range(frame_start, frame_end+1):
+                fc.keyframe_points.remove(k)
+                fc.update()
+
+def append_action(action_path='', action_name=''):
+    print(f'Loading {action_name} from: {action_path}')
+
+    with bpy.data.libraries.load(str(action_path), link=False) as (data_from, data_to):
+        data_to.actions = [action_name]
+
+    return data_to.actions[0]
+
+def apply_anim(action_lib, ob, bones=[]):
+    from mathutils import Vector
+
+    scn = bpy.context.scene
+
+    if not ob.animation_data:
+        ob.animation_data_create()
+    
+    action = ob.animation_data.action
+    
+    if not action:
+        action = bpy.data.actions.new(ob.name)
+        ob.animation_data.action = action
+
+    keys = sorted([k.co[0] for f in action_lib.fcurves for k in f.keyframe_points])
+    if not keys:
+        print(f'The action {action_lib.name} has no keyframes')
+        return
+
+    first_key = keys[0]
+    key_offset = scn.frame_current - first_key
+
+    key_attr = ('type', 'interpolation', 'handle_left_type', 'handle_right_type',
+        'amplitude', 'back', 'easing', 'period', 'handle_right', 'handle_left'
+    )
+    for fc in action_lib.fcurves:
+        bone_name, prop_name = split_path(fc.data_path)
+
+        if bones and bone_name not in bones:
+            continue
+
+        action_fc = action.fcurves.find(fc.data_path, index=fc.array_index)
+        if not action_fc:
+            action_fc = action.fcurves.new(
+                fc.data_path,
+                index=fc.array_index,
+                action_group=fc.group.name if fc.group else fc.data_path.split('"')[1]
+            )
+        
+        for kf_lib in fc.keyframe_points:
+            kf = action_fc.keyframe_points.insert(
+                frame=kf_lib.co[0] + key_offset,
+                value=kf_lib.co[1]
+            )
+            for attr in key_attr:
+                src_val = getattr(kf_lib, attr)
+                if attr.startswith('handle') and 'type' not in attr:
+                    src_val += Vector((key_offset, 0))
+
+                setattr(kf, attr, src_val)
+
+        fc.update()
+    
+    # redraw graph areas
+    for window in bpy.context.window_manager.windows:
+        screen = window.screen
+        for area in screen.areas:
+            if area.type == 'GRAPH_EDITOR':
+                area.tag_redraw()

action/gui.py

@@ -0,0 +1,49 @@
+
+import bpy
+
+
+def draw_context_menu(layout):
+    params = bpy.context.space_data.params
+    asset = bpy.context.asset_file_handle
+
+    layout.operator("assetlib.open_blend", text="Open blend file")#.asset = asset.name
+    layout.operator("assetlib.play_preview", text="Play Preview")
+    
+    layout.separator()
+
+    layout.operator_context = 'INVOKE_DEFAULT'
+
+    #layout.operator("assetlib.rename_asset", text="Rename Action")
+    layout.operator("assetlib.clear_asset", text="Remove Asset")
+    layout.operator("assetlib.edit_data", text="Edit Asset data")
+    
+    #layout.operator("actionlib.clear_asset", text="Clear Asset (Fake User)").use_fake_user = True
+
+    layout.separator()
+
+    layout.operator("actionlib.apply_selected_action", text="Apply Pose").flipped = False
+    layout.operator("actionlib.apply_selected_action", text="Apply Pose (Flipped)").flipped = True
+    
+    layout.separator()
+
+    layout.operator("poselib.blend_pose_asset_for_keymap", text="Blend Pose").flipped = False
+    layout.operator("poselib.blend_pose_asset_for_keymap", text="Blend Pose (Flipped)").flipped = True
+
+    layout.separator()
+
+    layout.operator("poselib.pose_asset_select_bones", text="Select Bones").selected_side = 'CURRENT'
+    layout.operator("poselib.pose_asset_select_bones", text="Select Bones (Flipped)").selected_side = 'FLIPPED'
+    layout.operator("poselib.pose_asset_select_bones", text="Select Bones (Both)").selected_side = 'BOTH'
+
+    layout.separator()
+    #layout.operator("asset.library_refresh")
+    if params.display_type == 'THUMBNAIL':
+        layout.prop_menu_enum(params, "display_size")
+
+
+def draw_header(layout):
+    '''Draw the header of the Asset Browser Window'''
+
+    layout.separator()
+    layout.operator("actionlib.store_anim_pose", text='Add Action', icon='FILE_NEW')
+

action/keymaps.py

@@ -0,0 +1,49 @@
+
+
+from typing import List, Tuple
+
+import bpy
+
+addon_keymaps: List[Tuple[bpy.types.KeyMap, bpy.types.KeyMapItem]] = []
+
+def register():
+    wm = bpy.context.window_manager
+    addon = wm.keyconfigs.addon
+    if not addon:
+        return
+    
+    km = addon.keymaps.new(name="File Browser Main", space_type="FILE_BROWSER")
+
+    # DblClick to apply pose.
+    kmi = km.keymap_items.new("actionlib.apply_selected_action", "LEFTMOUSE", "DOUBLE_CLICK")
+    kmi.properties.flipped = False
+    addon_keymaps.append((km, kmi))
+        
+    kmi = km.keymap_items.new("actionlib.apply_selected_action", "LEFTMOUSE", "DOUBLE_CLICK", alt=True)
+    kmi.properties.flipped = True
+    addon_keymaps.append((km, kmi))
+        
+    kmi = km.keymap_items.new("poselib.blend_pose_asset_for_keymap", "LEFTMOUSE", "DOUBLE_CLICK", shift=True)
+    kmi.properties.flipped = False
+    addon_keymaps.append((km, kmi))
+    
+    kmi = km.keymap_items.new("poselib.blend_pose_asset_for_keymap", "LEFTMOUSE", "DOUBLE_CLICK", alt=True, shift=True)
+    kmi.properties.flipped = True
+    addon_keymaps.append((km, kmi))
+    
+    kmi = km.keymap_items.new("poselib.pose_asset_select_bones", "S", "PRESS")
+    kmi.properties.selected_side = 'CURRENT'
+    addon_keymaps.append((km, kmi))
+
+    kmi = km.keymap_items.new("poselib.pose_asset_select_bones", "S", "PRESS", alt=True)
+    kmi.properties.selected_side = 'FLIPPED'
+    addon_keymaps.append((km, kmi))
+
+    kmi = km.keymap_items.new("poselib.pose_asset_select_bones", "S", "PRESS", alt=True, ctrl=True)
+    kmi.properties.selected_side = 'BOTH'
+    addon_keymaps.append((km, kmi))
+
+def unregister():
+    for km, kmi in addon_keymaps:
+        km.keymap_items.remove(kmi)
+    addon_keymaps.clear()

action/properties.py

@@ -0,0 +1,34 @@
+import bpy
+from bpy.types import PropertyGroup
+from bpy.props import PointerProperty, StringProperty, BoolProperty
+
+class ACTIONLIB_PG_scene(PropertyGroup):
+    flipped : BoolProperty(
+        name="Flip Pose",
+        default=False,
+    )
+    previous_action : PointerProperty(type=bpy.types.Action)
+    publish_path : StringProperty(subtype='FILE_PATH')
+    camera : PointerProperty(type=bpy.types.Object, poll=lambda s, o: o.type == 'CAMERA')
+    rest_pose : PointerProperty(type=bpy.types.Action, poll=lambda s, a: a.asset_data)
+
+
+classes = (
+    ACTIONLIB_PG_scene,
+)
+
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+
+    bpy.types.Scene.actionlib = PointerProperty(type=ACTIONLIB_PG_scene)
+
+def unregister():
+    try:
+        del bpy.types.Scene.actionlib
+    except AttributeError:
+        pass
+
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)

action/rename_pose.py

@@ -0,0 +1,44 @@
+
+import argparse
+import bpy
+import json
+import re
+import sys
+
+from pathlib import Path
+sys.path.append(Path(__file__).parents[3])
+from asset_library.common.bl_utils import (
+    get_preview,
+)
+
+def rename_pose(src_name='', dst_name=''):
+        
+    scn = bpy.context.scene
+    action = bpy.data.actions.get(src_name)
+    if not action:
+        print(f'No {src_name} not found.')
+        bpy.ops.wm.quit_blender()
+
+    action.name = dst_name
+    preview = get_preview(asset_path=bpy.data.filepath, asset_name=src_name)
+    if preview:
+        preview.rename(re.sub(src_name, dst_name, str(preview)))
+
+    bpy.ops.wm.save_mainfile(
+        filepath=bpy.data.filepath, compress=True, exit=True
+    )
+    
+
+if __name__ == '__main__' :
+    parser = argparse.ArgumentParser(description='Add Comment To the tracker',
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--src-name')
+    parser.add_argument('--dst-name')
+
+    if '--' in sys.argv :
+        index = sys.argv.index('--')
+        sys.argv = [sys.argv[index-1], *sys.argv[index+1:]]
+
+    args = parser.parse_args()
+    rename_pose(**vars(args))

action/render_preview.py

@@ -0,0 +1,292 @@
+
+
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parents[3]))
+
+from asset_library.action.concat_preview import mosaic_export
+from asset_library.common.file_utils import open_file
+from asset_library.action.functions import reset_bone, get_keyframes
+from asset_library.common.functions import read_catalog
+
+import bpy
+import argparse
+import json
+import re
+import shutil
+import subprocess
+
+from tempfile import gettempdir
+
+
+
+def rm_tree(pth):
+    pth = Path(pth)
+    for child in pth.glob('*'):
+        if child.is_file():
+            child.unlink()
+        else:
+            rm_tree(child)
+    pth.rmdir()
+
+def render_preview(directory, asset_catalog, render_actions, publish_actions, remove_folder):
+
+    scn = bpy.context.scene
+    rnd = bpy.context.scene.render
+    rnd.resolution_x = rnd.resolution_y = 512
+
+    report = []
+    blendfile = Path(bpy.data.filepath)
+    asset_catalog_data = read_catalog(asset_catalog)
+
+    anim_render_dir = Path(gettempdir()) / 'actionlib_render'   #/tmp/actionlib_render. Removed at the end
+    anim_render_dir.mkdir(exist_ok=True, parents=True)
+
+    preview_render_dir = Path(directory) / 'preview'
+
+    if preview_render_dir.exists() and remove_folder:
+        rm_tree(preview_render_dir)
+
+    preview_render_dir.mkdir(exist_ok=True, parents=True)
+    for i in ('anim', 'pose'):
+        Path(preview_render_dir / i).mkdir(exist_ok=True, parents=True)
+    
+    for f in preview_render_dir.rglob('*'):
+        if f.is_dir():
+            print(f'{f} is dir. Skipped.')
+            continue
+        if all(i not in f.parts for i in ('anim', 'pose')) and f.parent.parts[-1] != 'preview':
+            print(f'{f} is out of pipe. Approved or Rtk pictures. Skipped.')
+            continue
+        if not any(f.stem.endswith(a) for a in publish_actions):
+            print(f'{str(f)} not in publish actions anymore. Removing...')
+            f.unlink()
+
+    # Set Scene
+    # ----------
+    # Scene Setting
+    scn.use_preview_range = True
+    scn.eevee.use_gtao = True
+    scn.tool_settings.use_keyframe_insert_auto = False
+    
+    # Render Setting
+    rnd.engine = 'BLENDER_EEVEE'
+    rnd.use_simplify = False
+    rnd.use_stamp_date = True
+    rnd.use_stamp_time = True
+    rnd.use_stamp_render_time = False
+    rnd.use_stamp_frame = True
+    rnd.use_stamp_frame_range = False
+    rnd.use_stamp_memory = False
+    rnd.use_stamp_hostname = False
+    rnd.use_stamp_camera = True
+    rnd.use_stamp_lens = False
+    rnd.use_stamp_scene = False
+    rnd.use_stamp_marker = False
+    rnd.use_stamp_filename = False
+    rnd.use_stamp_sequencer_strip = False
+    rnd.use_stamp_note = True
+    rnd.use_stamp = True
+    rnd.stamp_font_size = 16
+    rnd.use_stamp_labels = False
+    rnd.image_settings.file_format = 'JPEG'
+
+    # Viewport Look
+    # ----------
+    """
+    # Eevee
+    for screen in bpy.data.screens:
+        for area in screen.areas:
+            for space in area.spaces:
+                if space.type == 'VIEW_3D':
+                    space.overlay.show_overlays = False
+                    space.shading.type = 'RENDERED'
+                    space.shading.use_scene_lights_render = False
+                    space.shading.use_scene_world_render = False
+                    space.region_3d.view_perspective = 'CAMERA'
+    
+    """
+    # Cycles Mat Shading
+    for a in bpy.context.screen.areas:
+        if a.type == 'VIEW_3D':
+            a.spaces[0].overlay.show_overlays = False
+            a.spaces[0].region_3d.view_perspective = 'CAMERA'
+            a.spaces[0].shading.show_cavity = True
+            a.spaces[0].shading.cavity_type = 'WORLD'
+            a.spaces[0].shading.cavity_ridge_factor = 0.75
+            a.spaces[0].shading.cavity_valley_factor = 1.0
+    
+
+    # Add Subsurf
+    # -----------
+    deform_ob = [m.object for o in scn.objects \
+            for m in o.modifiers if m.type == 'MESH_DEFORM'
+    ]
+    deform_ob += [m.target for o in scn.objects \
+            for m in o.modifiers if m.type == 'SURFACE_DEFORM'
+    ]
+    
+    objects = [o for o in bpy.context.scene.objects if (o.type == 'MESH' 
+        and o not in deform_ob and o not in bpy.context.scene.collection.objects[:])
+    ]
+    
+    for o in objects:
+        subsurf = False
+        for m in o.modifiers:
+            if m.type == 'SUBSURF':
+                m.show_viewport = m.show_render
+                m.levels = m.render_levels
+                subsurf = True
+                break
+
+        if not subsurf:
+            subsurf = o.modifiers.new('', 'SUBSURF')
+            subsurf.show_viewport = subsurf.show_render
+            subsurf.levels = subsurf.render_levels
+
+
+    # Loop through action and render
+    # ------------------------------
+    rig = next((o for o in scn.objects if o.type == 'ARMATURE'), None)
+    # actions = [a for a in bpy.data.actions if a.asset_data]
+
+
+    rig.animation_data_create()
+    for action_name in render_actions:
+        action = bpy.data.actions.get(action_name)
+
+        if not action:
+            print(f'\'{action_name}\' not found.')
+            continue
+
+        print(f"-- Current --: {action.name}")
+    
+        rnd.stamp_note_text = '{type} : {pose_name}'
+        action_data = action.asset_data
+    
+        if 'camera' not in action_data.keys():
+            report.append(f"'{action.name}' has no CameraData.")
+            continue
+        
+        catalog_name = next((v['name'] for v in asset_catalog_data.values() if action_data.catalog_id == v['id']), None)
+        pose_name = '/'.join([*catalog_name.split('-'), action.name])
+        filename = bpy.path.clean_name(f'{catalog_name}_{action.name}')
+        ext = 'jpg'
+
+        rig.animation_data.action = None
+        bpy.context.view_layer.update()
+        for b in rig.pose.bones:
+            if re.match('^[A-Z]+\.', b.name):
+                continue
+            reset_bone(b)
+
+        rest_pose = None
+        if isinstance(action.asset_data.get('rest_pose'), str):
+            rest_pose = bpy.data.actions.get(action.asset_data['rest_pose'])
+        
+        rig.animation_data.action = rest_pose
+        bpy.context.view_layer.update()
+        
+        rig.animation_data.action = action
+
+        if 'camera' in action.asset_data.keys():
+            action_cam = bpy.data.objects.get(action.asset_data['camera'], '')
+            if action_cam:
+                scn.camera = action_cam
+
+        # Is Anim
+        if not action_data['is_single_frame'] or 'anim' in action_data.tags.keys():
+            keyframes = get_keyframes(action)
+            if not keyframes:
+                continue
+            anim_start = keyframes[0]
+            anim_end = keyframes[-1]
+
+            if anim_start < scn.frame_start:
+                report.append(f"Issue found for '{action.name}'. Has keyframes before 'Start Frame'.")
+                continue
+            
+            scn.frame_preview_start = anim_start
+            scn.frame_preview_end = anim_end
+
+            rnd.stamp_note_text = rnd.stamp_note_text.format(
+                type='ANIM', 
+                pose_name=pose_name,
+            )
+
+            rnd.filepath = f'{str(anim_render_dir)}/{filename}_####.{ext}'
+            
+            bpy.ops.render.opengl(animation=True)
+
+            ffmpeg_cmd = [
+                'ffmpeg', '-y', 
+                '-start_number', f'{anim_start:04d}',
+                '-i', rnd.filepath.replace('####', '%04d'),
+                '-c:v', 'libx264', 
+                str((preview_render_dir/'anim'/filename).with_suffix('.mov')),
+            ]
+            subprocess.call(ffmpeg_cmd)
+            
+        # Is Pose
+        elif action_data['is_single_frame'] or 'pose' in action_data.tags.keys():
+            scn.frame_preview_start = scn.frame_preview_end = scn.frame_start
+            
+            rnd.stamp_note_text = rnd.stamp_note_text.format(
+                type='POSE', 
+                pose_name=pose_name,
+            )
+
+            rnd.filepath = f'{str(preview_render_dir)}/pose/{filename}_####.{ext}'
+            
+            bpy.ops.render.opengl(animation=True)
+
+            filename = rnd.filepath.replace('####', f'{scn.frame_preview_end:04d}')
+            Path(filename).rename(re.sub('_[0-9]{4}.', '.', filename))
+
+    shutil.rmtree(anim_render_dir)
+    
+    # Report
+    # ------
+    if report:
+        report_file = blendfile.parent / Path(f'{blendfile.stem}report').with_suffix('.txt')
+        if not report_file.exists():
+            report_file.touch(exist_ok=False)
+
+        report_file.write_text('-')
+        report_file.write_text('\n'.join(report))
+        
+        result = report_file
+
+    else:
+        result = preview_render_dir
+
+    open_file(result)
+
+    files = [str(f) for f in sorted((preview_render_dir/'pose').glob('*.jpg'))]
+
+    mosaic_export(
+        files=files, catalog_data=asset_catalog_data,
+        row=2, columns=2, auto_calculate=True,
+        bg_color=(0.18, 0.18, 0.18,), resize_output=100
+    )
+
+    bpy.ops.wm.quit_blender()
+
+
+
+if __name__ == '__main__' :
+    parser = argparse.ArgumentParser(description='Add Comment To the tracker',
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--directory')
+    parser.add_argument('--asset-catalog')
+    parser.add_argument('--render-actions', nargs='+')
+    parser.add_argument('--publish-actions', nargs='+')
+    parser.add_argument('--remove-folder', type=json.loads, default='false')
+
+    if '--' in sys.argv :
+        index = sys.argv.index('--')
+        sys.argv = [sys.argv[index-1], *sys.argv[index+1:]]
+
+    args = parser.parse_args()
+    render_preview(**vars(args))

adapters/__init__.py

@@ -0,0 +1,4 @@
+
+from asset_library.adapters.adapter import AssetLibraryAdapter
+from asset_library.adapters.copy_folder import CopyFolderLibrary
+from asset_library.adapters.scan_folder import ScanFolderLibrary

adapters/adapter.py

@@ -0,0 +1,545 @@
+
+from asset_library.common.functions import (read_catalog, write_catalog, norm_asset_datas, get_catalog_path)
+from asset_library.common.bl_utils import get_addon_prefs, load_datablocks
+from asset_library.common.file_utils import read_file, write_file
+from asset_library.common.template import Template
+
+from asset_library import (action, collection, file)
+
+from bpy.types import PropertyGroup
+from bpy.props import StringProperty
+import bpy
+
+from itertools import groupby
+from pathlib import Path
+import shutil
+import os
+import json
+import uuid
+
+
+class AssetLibraryAdapter(PropertyGroup):
+
+    #def __init__(self):
+    name = "Base Adapter"
+    #library = None
+
+    bundle_directory : StringProperty()
+    
+    @property
+    def library(self):
+        prefs = self.addon_prefs
+        for lib in prefs.libraries:
+            if lib.adapter == self:
+                return lib
+            if lib.conform.adapter == self:
+                return lib
+
+    @property
+    def library_path(self):
+        return self.library.library_path
+
+    @property
+    def image_template(self):
+        return Template(self.library.image_template)
+
+    @property
+    def video_template(self):
+        return Template(self.library.video_template)
+
+    @property
+    def asset_description_template(self):
+        return Template(self.library.asset_description_template)
+
+    @property
+    def data_type(self):
+        return self.library.data_type
+
+    @property
+    def data_types(self):
+        return self.library.data_types
+
+    @property
+    def blend_depth(self):
+        return self.library.blend_depth
+
+    @property
+    def externalize_data(self):
+        return self.library.externalize_data
+
+    @property
+    def catalog_path(self):
+        return self.library.catalog_path
+
+    def get_catalog_path(self, filepath):
+        return get_catalog_path(filepath)
+
+    @property
+    def cache_file(self):
+        return Path(self.library_path) / f"blender_assets.{self.library.id}.json"
+        #return get_asset_datas_file(self.library_path)
+
+    @property
+    def addon_prefs(self):
+        return get_addon_prefs()
+    
+    @property
+    def module_type(self):
+        lib_type = self.library.data_type
+        if lib_type == 'ACTION':
+            return action
+        elif lib_type == 'FILE':
+            return file
+        elif lib_type == 'COLLECTION':
+            return collection
+
+    def to_dict(self):
+        return {p: getattr(self, p) for p in self.bl_rna.properties.keys() if p !='rna_type'}
+
+    def fetch(self):
+        raise Exception('This method need to be define in the adapter')
+
+    def norm_file_name(self, name):
+        return name.replace(' ', '_')
+
+    def copy_file(self, source, destination):
+        src = Path(source)
+        dst = Path(destination)
+
+        if not source.exists():
+            print(f'Cannot copy file {source}: file not exist')
+            return
+
+        dst.parent.mkdir(exist_ok=True, parents=True)
+        
+        if src == dst:
+            print(f'Cannot copy file {source}: source and destination are the same')
+            return
+
+        print(f'Copy file from {source} to {destination}')
+        shutil.copy2(str(source), str(destination))
+
+    def load_datablocks(self, src, names=None, type='objects', link=True, expr=None):
+        """Link or append a datablock from a blendfile"""
+        return load_datablocks(src, names=names, type=type, link=link, expr=expr)
+
+    def get_asset_relative_path(self, name, catalog):
+        '''Get a relative path for the asset'''
+        name = self.norm_file_name(name)
+        return Path(catalog, name, name).with_suffix('.blend')
+
+    #def _get_file_name(self, name, filepath):
+    #    '''Ensure having a unique name per asset if in the same folder by prefixing with the blend_file name'''
+    #    file_name = name
+    #    if filepath.stem != name:
+    #        file_name = f'{file_name}_{name}'
+    #    
+    #    return file_name
+
+    def get_active_asset_library(self):
+        asset_handle = bpy.context.asset_file_handle
+        prefs = get_addon_prefs()
+        asset_handle = bpy.context.asset_file_handle
+
+        lib = None
+        if '.library_id' in asset_handle.asset_data:
+            lib_id = asset_handle.asset_data['.library_id']
+            lib = next((l for l in prefs.libraries if l.id == lib_id), None)
+
+            if not lib:
+                print(f"No library found for id {lib_id}")
+        
+        if not lib:
+            lib = self
+        
+        return lib
+
+    def get_active_asset_path(self):
+        '''Get the full path of the active asset_handle from the asset brower'''
+        prefs = get_addon_prefs()
+        asset_handle = bpy.context.asset_file_handle
+
+        lib = self.get_active_asset_library()
+
+        if 'filepath' in asset_handle.asset_data:
+            asset_path = asset_handle.asset_data['filepath']
+            asset_path = lib.adapter.format_path(asset_path)
+        else:
+            asset_path = bpy.types.AssetHandle.get_full_library_path(
+                asset_handle, bpy.context.asset_library_ref
+            )
+
+        return asset_path
+
+    def get_path(self, type, name, asset_path, template=None) -> Path:
+        if not template:
+            template = getattr(self, f'{type}_template')
+        
+        if isinstance(template, str):
+            template = Template(template)
+
+        filepath = Path(asset_path)
+        return (filepath / template.format(name=name, path=Path(asset_path))).resolve()
+
+    #def get_image_path(self, name, asset_path):
+    #    filepath = Path(asset_path)
+    #    image_name = self._get_file_name(name, asset_path)
+    #    return (filepath / self.image_template.format(name=image_name)).resolve()
+
+    def get_cache_image_path(self, name, catalog) -> Path:
+        """"Get the the cache path of a image for asset without an externalized image"""
+        return Path(self.library_path, '.previews', f"{catalog.replace('/', '_')}_{name}").with_suffix(('.png'))
+
+    def get_cache_image(self, name, catalog):
+        cache_image_path = self.get_cache_image_path(name, catalog)
+        if cache_image_path.exists():
+            return cache_image_path
+
+    #def get_video_path(self, name, asset_path):
+    #    filepath = Path(asset_path)
+    #    video_name = self._get_file_name(name, asset_path)
+    #    return (filepath / self.video_template.format(name=video_name)).resolve()
+
+    def get_image(self, name, asset_path):
+        image_path = self.get_path('image', name, asset_path)
+        if image_path.exists():
+            return image_path
+
+    def get_video(self, name, asset_path):
+        video_path = self.get_path('video', name, asset_path)
+        if video_path.exists():
+            return video_path
+
+    def get_asset_description_path(self, asset_path) -> Path:
+        """"Get the path of the json or yaml describing all assets data in onle file"""
+        filepath = Path(asset_path)
+        return (filepath / self.asset_description_template.format(name=filepath.stem)).resolve()
+
+    def read_asset_description(self, asset_path) -> dict:
+        """Read the description file of the asset"""
+
+        asset_description_path = self.get_asset_description_path(asset_path)
+        return read_file(asset_description_path)
+
+    def write_asset_description(self, asset_data, asset_path) -> None:
+        asset_description_path = self.get_asset_description_path(asset_path)
+        return write_file(asset_description_path, asset_data)
+
+    def write_asset(self, asset, asset_path):
+        bpy.data.libraries.write(
+            str(asset_path), 
+            {asset},
+            path_remap="NONE",
+            fake_user=True,
+            compress=True
+        )
+
+    
+    def read_catalog(self, filepath=None):
+        """Read the catalog file of the library bundle path or of the specified filepath"""
+
+        catalog_path = self.catalog_path
+        if filepath:
+            catalog_path = self.get_catalog_path(filepath)
+        return read_catalog(catalog_path)
+
+    def write_catalog(self, catalog_data, filepath=None):
+        """Write the catalog file in the library bundle path or of the specified filepath"""
+        
+        catalog_path = self.catalog_path
+        if filepath:
+            catalog_path = self.get_catalog_path(filepath)
+        
+        return write_catalog(catalog_path, catalog_data)
+
+    def read_cache(self):
+        return read_file(self.cache_file)
+
+    def norm_asset_datas(self, asset_file_datas):
+        ''' Return a new flat list of asset data
+            the filepath keys are merge with the assets keys
+        '''        
+        return norm_asset_datas(asset_file_datas)
+
+    def write_cache(self, asset_datas):
+        path = self.cache_file
+        print(f'cache file writen to {path}')
+        return write_file(path, list(asset_datas))
+
+    def prop_rel_path(self, path, prop):
+        '''Get a filepath relative to a property of the adapter'''
+        field_prop = '{%s}/'%prop
+
+        prop_value = getattr(self, prop)
+        prop_value = Path(os.path.expandvars(prop_value)).resolve()
+        
+        rel_path = Path(path).resolve().relative_to(prop_value).as_posix()
+
+        return field_prop + rel_path
+
+    def write_preview(self, preview, filepath):
+        if not preview or not filepath:
+            return
+
+        filepath = Path(filepath)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        
+        img_size = preview.image_size
+
+        px = [0] * img_size[0] * img_size[1] * 4
+        preview.image_pixels_float.foreach_get(px)
+        img = bpy.data.images.new(name=filepath.name, width=img_size[0], height=img_size[1], is_data=True, alpha=True)
+        img.pixels.foreach_set(px)
+        img.filepath_raw = str(filepath.with_suffix('.png'))
+        img.file_format = 'PNG'
+        img.save()
+
+    def draw_header(self, layout):
+        """Draw the header of the Asset Browser Window"""
+        #layout.separator()
+
+        self.module_type.gui.draw_header(layout)
+
+    def draw_context_menu(self, layout):
+        """Draw the context menu of the Asset Browser Window"""
+        #layout.separator()        
+        self.module_type.gui.draw_context_menu(layout)
+
+    def group_key(self, asset_data):
+        """Key used to group assets inside one blend"""
+
+        catalog_parts = asset_data['catalog'].split('/') + [asset_data['name']]
+
+        return catalog_parts[:self.blend_depth]
+
+    def set_asset_preview(self, asset, asset_data):
+        """Load an externalize image as preview for an asset"""
+
+        image_path = Path(asset_data['image'])
+        if not image_path.is_absolute():
+            image_path = Path(asset_data['filepath'], image_path)
+
+        image_path = self.format_path(image_path.as_posix())
+        if image_path and image_path.exists():
+            with bpy.context.temp_override(id=asset):
+                bpy.ops.ed.lib_id_load_custom_preview(
+                    filepath=str(image_path)
+                )
+            return
+        
+        if asset.preview:
+            return
+        
+        #Creating the preview for collection, object or material
+        src_asset = self.load_datablocks(asset_data['filepath'], names=asset_data['name'], link=True, type=self.data_types)
+        if not src_asset:
+            print(f'No asset named {asset_data["name"]} in {asset_data["filepath"]}')
+            return
+
+        bpy.ops.ed.lib_id_generate_preview({"id": src_asset})
+
+        #Transfering pixels between previews
+        pixels = [0] * (128*128*4)
+        src_asset.preview.image_pixels_float.foreach_get(pixels)
+        asset.preview.image_pixels_float.foreach_set(pixels)
+
+        getattr(bpy.data, self.data_types).remove(src_asset)
+
+
+    def set_asset_catalog(self, asset, asset_data, catalog_data):
+        """Find the catalog if already exist or create it"""
+        catalog_name = asset_data['catalog']
+        catalog = catalog_data.get(catalog_name)
+        if not catalog:
+            catalog = {'id': str(uuid.uuid4()), 'name': catalog_name}
+            catalog_data[catalog_name] = catalog
+
+        asset.asset_data.catalog_id = catalog['id']
+
+    def set_asset_metadata(self, asset, asset_data):
+        """Create custom prop to an asset base on provided data"""
+        metadata = asset_data.get('metadata', {})
+
+        library_id = self.library.id
+        if 'library_id' in asset_data:
+            library_id = asset_data['library_id']
+
+        metadata['.library_id'] = library_id
+        metadata['filepath'] = asset_data['filepath']
+        for k, v in metadata.items():
+            asset.asset_data[k] = v
+
+    def set_asset_tags(self, asset, asset_data):
+        """Create asset tags base on provided data"""
+        tags = asset_data.get('tags', [])
+        if tags:
+            #Clear all tags first
+            for tag in asset.asset_data.tags[:]:
+                asset.asset_data.tags.remove(tag)
+
+            for tag in tags:
+                if not tag:
+                    continue
+                asset.asset_data.tags.new(tag, skip_if_exists=True)
+
+    def bundle(self, cache_diff=None):
+        """Group all new assets in one or multiple blends for the asset browser"""
+
+        if self.data_type not in ('FILE', 'ACTION', 'COLLECTION'):
+            print(f'{self.data_type} is not supported yet')
+            return
+
+        lib_path = self.library_path
+        catalog_data = self.read_catalog() #TODO remove unused catalog
+
+        write_cache = False
+        if not cache_diff:
+            # Get list of all modifications
+            cache, cache_diff = self.diff()
+
+            # Only write complete cache at the end
+            write_cache = True
+
+        elif isinstance(cache_diff, (Path, str)):
+            cache_diff = json.loads(Path(cache_diff).read_text(encoding='utf-8'))
+
+        if self.blend_depth == 0:
+            groups = [(cache_diff)]
+        else:
+            cache_diff.sort(key=self.group_key)
+            groups = groupby(cache_diff, key=self.group_key)
+
+        total_assets = len(cache_diff)
+        print(f'total_assets={total_assets}')
+
+        if total_assets == 0:
+            print('No assets found')
+            return
+
+        i = 0
+        for sub_path, asset_datas in groups:
+            blend_name = sub_path[-1].replace(' ', '_').lower()
+            blend_path = Path(lib_path, *sub_path, blend_name).with_suffix('.blend')
+
+            if blend_path.exists():
+                print(f'Opening existing bundle blend: {blend_path}')
+                bpy.ops.wm.open_mainfile(filepath=str(blend_path))
+            else:
+                print(f'Create new bundle blend to: {blend_path}')
+                bpy.ops.wm.read_homefile(use_empty=True)
+
+            for asset_data in asset_datas:
+                if total_assets <= 100 or i % int(total_assets / 10) == 0:
+                    print(f'Progress: {int(i / total_assets * 100)+1}')
+                
+                operation = asset_data.get('operation', 'ADD')
+                asset = getattr(bpy.data, self.data_types).get(asset_data['name'])
+
+                if operation == 'REMOVE':
+                    if asset:
+                        getattr(bpy.data, self.data_types).remove(asset)
+                    else:
+                        print(f'ERROR : Remove Asset: {asset_data["name"]} not found in {blend_path}')
+                    continue
+
+                if operation == 'MODIFY' and not asset:
+                    print(f'WARNING: Modifiy Asset: {asset_data["name"]} not found in {blend_path} it will be created')
+
+                elif operation == 'ADD' or not asset:
+                    if asset:
+                        #raise Exception(f"Asset {asset_data['name']} Already in Blend")
+                        getattr(bpy.data, self.data_types).remove(asset)
+
+                    #print(f"INFO: Add new asset: {asset_data['name']}")
+                    asset = getattr(bpy.data, self.data_types).new(name=asset_data['name'])
+                else:
+                    print(f'operation {operation} not supported should be in (ADD, REMOVE, MODIFIED)')
+                    continue
+
+                asset.asset_mark()
+
+                self.set_asset_preview(asset, asset_data)
+                #if self.externalize_data:
+                #    self.write_preview(preview, filepath)
+
+                self.set_asset_catalog(asset, asset_data, catalog_data)
+                self.set_asset_metadata(asset, asset_data)
+                self.set_asset_tags(asset, asset_data)
+                asset.asset_data.description = asset_data.get('description', '')
+
+                i += 1
+
+            print(f'Saving Blend to {blend_path}')
+
+            blend_path.parent.mkdir(exist_ok=True, parents=True)
+            bpy.ops.wm.save_as_mainfile(filepath=str(blend_path), compress=True)
+        
+        if write_cache:
+            self.write_cache(cache)
+
+        self.write_catalog(catalog_data)
+
+        bpy.ops.wm.quit_blender()
+    
+
+    def norm_cache(self, cache):
+        """ Return a new flat list of asset data
+        the filepath keys are merge with the assets keys"""
+    
+        new_cache = []
+        for asset_description in cache:
+            asset_description = asset_description.copy()
+            if 'assets' in asset_description:
+
+                assets = asset_description.pop('assets')
+                for asset_data in assets:
+                    new_cache.append({**asset_description, **asset_data})
+            else:
+                new_cache.append(asset_description)
+    
+        return new_cache
+
+    def diff(self):
+        """Compare the library cache with it current state and return the difference"""
+
+        cache = self.read_cache()
+
+        if cache is None:
+            print(f'Fetch The library {self.library.name} for the first time, might be long...')
+            cache = []
+        
+        new_cache = self.fetch()
+
+        cache = {f"{a['filepath']}/{a['name']}": a for a in self.norm_cache(cache)}
+        new_cache = {f"{a['filepath']}/{a['name']}" : a for a in self.norm_cache(new_cache)}
+
+        assets_added = [v for k, v  in new_cache.items() if k not in cache]
+        assets_removed = [v for k, v  in cache.items() if k not in new_cache]
+        assets_modified = [v for k, v in cache.items() if v not in assets_removed and v!= new_cache[k]]
+
+        if assets_added:
+            print(f'{len(assets_added)} Assets Added \n{tuple(a["name"] for a in assets_added[:10])}\n')
+        if assets_removed:
+            print(f'{len(assets_removed)} Assets Removed \n{tuple(a["name"] for a in assets_removed[:10])}\n')
+        if assets_modified:
+            print(f'{len(assets_modified)} Assets Modified \n{tuple(a["name"] for a in assets_modified[:10])}\n')
+        
+        assets_added = [dict(a, operation='ADD') for a  in assets_added]
+        assets_removed = [dict(a, operation='REMOVE') for a  in assets_removed]
+        assets_modified = [dict(a, operation='MODIFY') for a in assets_modified]
+
+        cache_diff = assets_added + assets_removed + assets_modified
+        if not cache_diff:
+            print('No change in the library')
+
+        return new_cache, cache_diff
+
+    def draw_prefs(self, layout):
+        """Draw the options in the addon preference for this adapter"""
+
+        annotations = self.__class__.__annotations__
+        for k, v in annotations.items():
+            layout.prop(self, k, text=bpy.path.display_name(k))
+    
+    def format_path(self, template, **kargs):
+        return Template(template).format(self.to_dict(), **kargs).resolve()

adapters/copy_folder.py

@@ -0,0 +1,34 @@
+
+"""
+Adapter for making an asset library of all  blender file found in a folder
+"""
+
+
+from asset_library.adapters.adapter import AssetLibraryAdapter
+from asset_library.common.file_utils import copy_dir
+from bpy.props import StringProperty
+from os.path import expandvars
+
+
+class CopyFolderLibrary(AssetLibraryAdapter):
+    """Copy library folder from a server to a local disk for better performance"""
+
+    name = "Copy Folder"
+    source_directory : StringProperty()
+    
+    includes : StringProperty() 
+    excludes : StringProperty() 
+
+    def bundle(self):
+        src = expandvars(self.source_directory)
+        dst = expandvars(self.library_path)
+
+        includes = [inc.strip() for inc in self.includes.split(',')]
+        excludes = [ex.strip() for ex in self.excludes.split(',')]
+
+        print(f'Copy Folder from {src} to {dst}...')
+        copy_dir(
+            src, dst, only_recent=True,
+            excludes=excludes, includes=includes
+        )
+ 

adapters/kitsu.py

@@ -0,0 +1,162 @@
+
+"""
+Plugin for making an asset library of all  blender file found in a folder
+"""
+
+
+from asset_library.adapters.adapter import AssetLibraryAdapter
+from asset_library.common.template import Template
+from asset_library.common.file_utils import install_module
+
+import bpy
+from bpy.props import (StringProperty, IntProperty, BoolProperty)
+import re
+from pathlib import Path
+from itertools import groupby
+import uuid
+import os
+import shutil
+import json
+import urllib3
+import traceback
+import time
+
+gazu = install_module('gazu')
+
+
+class KitsuLibrary(AssetLibraryAdapter):
+
+    name = "Kitsu"
+    template_name : StringProperty()
+    template_file : StringProperty()
+
+    url: StringProperty()
+    login: StringProperty()
+    password: StringProperty(subtype='PASSWORD')
+    project_name: StringProperty()
+    
+    def connect(self, url=None, login=None, password=None):
+        '''Connect to kitsu api using provided url, login and password'''
+
+        urllib3.disable_warnings()
+
+        if not self.url:
+            print(f'Kitsu Url: {self.url} is empty')
+            return
+
+        url = self.url
+        if not url.endswith('/api'):
+            url += '/api'
+
+        print(f'Info: Setting Host for kitsu {url}')
+        gazu.client.set_host(url)
+
+        if not gazu.client.host_is_up():
+            print('Error: Kitsu Host is down')
+
+        try:
+            print(f'Info: Log in to kitsu as {self.login}')
+            res = gazu.log_in(self.login, self.password)
+            print(f'Info: Sucessfully login to Kitsu as {res["user"]["full_name"]}')
+            return res['user']
+        except Exception as e:
+            print(f'Error: {traceback.format_exc()}')
+
+    def get_asset_path(self, name, catalog, directory=None):
+        directory = directory or self.source_directory
+        return Path(directory, self.get_asset_relative_path(name, catalog))
+
+    def get_asset_description(self, data, path):
+        
+        modified = time.time_ns()
+        catalog = data['entity_type_name']
+        asset_path = Path(path)
+        asset_name = self.norm_file_name(data['name'])
+
+        asset_description = dict(
+            filepath='{source_directory}/' + asset_path.as_posix(),
+            modified=modified,
+            library_id=self.library.id,
+            assets=[dict(
+                catalog=catalog,
+                metadata=data.get('data', {}),
+                description=data['description'],
+                tags=[],
+                type=self.data_type,
+                image=str(self.image_template.format(name=asset_name)),
+                video=str(self.video_template.format(name=asset_name)),
+                name=data['name'])
+            ]
+        )
+        
+        return asset_description 
+
+    def bundle(self, cache_diff=None):
+        """Group all asset in one or multiple blends for the asset browser"""
+
+        return super().bundle(cache_diff=cache_diff)
+
+    def get_preview(self, asset_data):
+
+        name = asset_data['name']
+        preview = (f / image_template.format(name=name)).resolve()
+        if not preview.exists():
+            preview_blend_file(f, preview)
+        
+        return preview
+
+    def conform(self, directory, templates):
+        """Split each assets per blend and externalize preview"""
+
+        print(f'Conforming {self.library.name} to {directory}')
+
+        
+    def fetch(self):
+        """Gather in a list all assets found in the folder"""
+
+        print(f'Fetch Assets for {self.library.name}')
+
+        self.connect()
+
+        template_file = Template(self.template_file)
+        template_name = Template(self.template_name)
+
+        project = gazu.client.fetch_first('projects', {'name': self.project_name})
+        entity_types = gazu.client.fetch_all('entity-types')
+        entity_types_ids = {e['id']: e['name'] for e in entity_types}
+
+        new_cache = []
+        for asset_data in gazu.asset.all_assets_for_project(project):
+            asset_data['entity_type_name'] = entity_types_ids[asset_data.pop('entity_type_id')]
+            asset_name = asset_data['name']
+
+            asset_field_data = dict(name=asset_name, type=asset_data['entity_type_name'])
+
+            try:
+                asset_field_data.update(template_name.parse(asset_name))
+            except Exception:
+                print(f'Warning: Could not parse {asset_name} with template {template_name}')
+
+            asset_path = template_file.find(asset_field_data)
+            if not asset_path:
+                print(f'Warning: Could not find file for {template_file.format(asset_field_data)}')
+                continue
+
+            #print(asset_path)
+
+            new_cache.append(self.get_asset_description(asset_data, asset_path))
+
+            #asset = load_datablocks(asset_path, data_type='collections', names=asset_data['name'], link=True)
+            #if not asset:
+            #    print(f"Asset {asset_name} not found in {asset_path}")
+
+
+            #asset_description = self.get_asset_description(asset)
+
+            #new_cache.append(asset_description)
+
+        #print(assets)
+        # for k, v in assets[0].items():
+        #     print(f'- {k} {v}')
+
+        return new_cache

adapters/scan_folder.py

@@ -0,0 +1,459 @@
+
+"""
+Plugin for making an asset library of all  blender file found in a folder
+"""
+
+
+from asset_library.adapters.adapter import AssetLibraryAdapter
+from asset_library.common.bl_utils import load_datablocks
+from asset_library.common.template import Template
+
+import bpy
+from bpy.props import (StringProperty, IntProperty, BoolProperty)
+import re
+from pathlib import Path
+from itertools import groupby
+import uuid
+import os
+import shutil
+import json
+
+
+class ScanFolderLibrary(AssetLibraryAdapter):
+
+    name = "Scan Folder"
+    source_directory : StringProperty(subtype='DIR_PATH')
+    template : StringProperty()
+    blend_depth : IntProperty()
+    #externalize_preview : BoolProperty(default=True)
+    
+    #def draw_header(self, layout):
+    #    '''Draw the header of the Asset Browser Window'''
+    #    layout.separator()
+    #    layout.operator("actionlib.store_anim_pose", text='Add Action', icon='FILE_NEW')
+
+    #def update(self):
+    #
+    def get_asset_path(self, name, catalog, directory=None):
+        directory = directory or self.source_directory
+        return Path(directory, self.get_asset_relative_path(name, catalog))
+
+    def get_asset_description(self, asset, catalog, modified):
+
+        asset_path = self.get_asset_relative_path(name=asset.name, catalog=catalog)
+        asset_name = self.norm_file_name(asset.name)
+
+        asset_description = dict(
+            filepath='{source_directory}/' + asset_path.as_posix(),
+            modified=modified,
+            library_id=self.library.id,
+            assets=[]
+        )
+
+        asset_description['assets'].append(dict(
+            catalog=catalog,
+            metadata=dict(asset.asset_data),
+            tags=asset.asset_data.tags.keys(),
+            type=self.data_type,
+            image=str(self.image_template.format(name=asset_name)),
+            video=str(self.video_template.format(name=asset_name)),
+            name=asset.name)
+        )
+        
+        return asset_description
+
+    def _find_blend_files(self):
+        '''Get a sorted list of all blender files found matching the template'''
+        template = Template(self.template)
+
+        print(f'Search for blend using glob template: {template.glob_pattern}')
+
+        source_directory = Path(os.path.expandvars(self.source_directory))
+        print(f'Scanning Folder {source_directory}...')
+        blend_files = list(source_directory.glob(template.glob_pattern))
+
+        blend_files.sort()
+
+        return blend_files
+    
+    def _group_key(self, asset_data):
+        """Group assets inside one blend"""
+
+        catalog_parts = asset_data['catalog'].split('/') + [asset_data['name']]
+
+        return catalog_parts[:self.blend_depth]
+
+    def bundle(self, cache_diff=None):
+        """Group all asset in one or multiple blends for the asset browser"""
+
+        if self.data_type not in ('FILE', 'ACTION'):
+            print(f'{self.data_type} is not supported yet')
+            return
+
+        lib_path = self.library_path
+        catalog_data = self.read_catalog() # TODO remove unused catalog
+
+        #asset_file_datas = self.fetch() # TODO replace to only change new assets
+
+        if not cache_diff:
+            # Get list of all modifications
+            cache, cache_diff = self.diff()
+            self.write_cache(cache)
+
+        elif isinstance(cache_diff, (Path, str)):
+            cache_diff = json.loads(Path(cache_diff).read_text(encoding='utf-8'))
+
+        if self.blend_depth == 0:
+            groups = [(cache_diff)]
+        else:
+            cache_diff.sort(key=self._group_key)
+            groups = groupby(cache_diff, key=self._group_key)
+
+        # #print(cache_diff)
+        # print('\n')
+        # for sub_path, asset_datas in groups:
+
+        #     print('\n')
+        #     print(f'{sub_path=}')
+        #     print(f'asset_datas={list(asset_datas)}')
+
+        # raise Exception()
+
+        #progress = 0
+        total_assets = len(cache_diff)
+        print(f'total_assets={total_assets}')
+
+        if total_assets == 0:
+            print('No assets found')
+            return
+
+        i = 0
+        for sub_path, asset_datas in groups:
+
+            # print('\n')
+            # print(f'{sub_path=}')
+            # print(f'asset_datas={list(asset_datas)}')
+
+            # print('\n')
+
+            blend_name = sub_path[-1].replace(' ', '_').lower()
+            blend_path = Path(lib_path, *sub_path, blend_name).with_suffix('.blend')
+
+            if blend_path.exists():
+                print(f'Opening existing bundle blend: {blend_path}')
+                bpy.ops.wm.open_mainfile(filepath=str(blend_path))
+            else:
+                print(f'Create new bundle blend to: {blend_path}')
+                bpy.ops.wm.read_homefile(use_empty=True)
+
+            for asset_data in asset_datas:
+                if total_assets <= 100 or i % int(total_assets / 10) == 0:
+                    print(f'Progress: {int(i / total_assets * 100)+1}')
+                
+                operation = asset_data.get('operation', 'ADD')
+                asset = getattr(bpy.data, self.data_types).get(asset_data['name'])
+
+                if operation == 'REMOVE':
+                    if asset:
+                        getattr(bpy.data, self.data_types).remove(asset)
+                    else:
+                        print(f'ERROR : Remove Asset: {asset_data["name"]} not found in {blend_path}')
+                    continue
+
+                elif operation == 'MODIFY':
+                    if not asset:
+                        print(f'WARNING: Modifiy Asset: {asset_data["name"]} not found in {blend_path} it will be created')
+
+                elif operation == 'ADD' or not asset:
+                    if asset:
+                        #raise Exception(f"Asset {asset_data['name']} Already in Blend")
+                        getattr(bpy.data, self.data_types).remove(asset)
+
+                    #print(f"INFO: Add new asset: {asset_data['name']}")
+                    asset = getattr(bpy.data, self.data_types).new(name=asset_data['name'])
+                else:
+                    print(f'operation {operation} not supported should be in (ADD, REMOVE, MODIFIED)')
+                    continue
+
+                asset.asset_mark()
+
+                # Load external preview if exists
+                #image_template = Template(asset_data['preview'])
+                image_path = Path(asset_data['image'])
+                if not image_path.is_absolute():
+                    image_path = Path(asset_data['filepath'], image_path)
+
+                image_path = self.format_path(image_path.as_posix())
+
+                if image_path and image_path.exists():
+                    with bpy.context.temp_override(id=asset):
+                        bpy.ops.ed.lib_id_load_custom_preview(
+                            filepath=str(image_path)
+                        )
+                #else:
+                #    print(f'Preview {image_path} not found for asset {asset}')
+
+                asset.asset_data.description = asset_data.get('description', '')
+
+                catalog_name = asset_data['catalog']
+                catalog = catalog_data.get(catalog_name)
+                if not catalog:
+                    catalog = {'id': str(uuid.uuid4()), 'name': catalog_name}
+                    catalog_data[catalog_name] = catalog
+
+                asset.asset_data.catalog_id = catalog['id']
+
+                metadata = asset_data.get('metadata', {})
+
+                library_id = self.library.id
+                if 'library_id' in asset_data:
+                    library_id = asset_data['library_id']
+
+                metadata['.library_id'] = library_id
+                
+                #print(metadata)
+
+                metadata['filepath'] = asset_data['filepath']
+                for k, v in metadata.items():
+                    asset.asset_data[k] = v
+                
+                # Set tags if specified the asset_description
+                tags = asset_data.get('tags', [])
+                if tags:
+                    for tag in asset.asset_data.tags[:]:
+                        asset.asset_data.tags.remove(tag)
+
+                    for tag in tags:
+                        if not tag:
+                            continue
+                        asset.asset_data.tags.new(tag, skip_if_exists=True)
+
+                i += 1
+
+            print(f'Saving Blend to {blend_path}')
+
+            blend_path.parent.mkdir(exist_ok=True, parents=True)
+            bpy.ops.wm.save_as_mainfile(filepath=str(blend_path), compress=True)
+            
+        self.write_catalog(catalog_data)
+
+        bpy.ops.wm.quit_blender()
+
+    def get_preview(self, asset_data):
+
+        name = asset_data['name']
+        preview = (f / image_template.format(name=name)).resolve()
+        if not preview.exists():
+            preview_blend_file(f, preview)
+        
+        return preview
+
+
+    def conform(self, directory, templates):
+        """Split each assets per blend and externalize preview"""
+
+        print(f'Conforming {self.library.name} to {directory}')
+
+        if self.data_type not in ('FILE', 'ACTION'):
+            print(f'{self.data_type} is not supported yet')
+            return
+
+        #lib_path = self.library_path
+        source_directory = Path(os.path.expandvars(self.source_directory))
+        catalog_data = self.read_catalog(filepath=source_directory)
+        catalog_ids = {v['id']: {'path': k, 'name': v['name']} for k,v in catalog_data.items()}
+        directory = Path(directory).resolve()
+
+        image_template = templates.get('image') or self.image_template
+        video_template = templates.get('video') or self.video_template
+
+        # Get list of all modifications
+        for blend_file in self._find_blend_files():
+            
+            modified = blend_file.stat().st_mtime_ns
+
+            print(f'Scanning blendfile {blend_file}...')
+            with bpy.data.libraries.load(str(blend_file), link=True, assets_only=True) as (data_from, data_to):
+                asset_names = getattr(data_from, self.data_types)
+                print(f'Found {len(asset_names)} {self.data_types} inside')
+
+                setattr(data_to, self.data_types, asset_names)
+
+            assets = getattr(data_to, self.data_types)
+            #print('assets', assets)
+
+            for asset in assets:
+                #TODO options for choose beetween asset catalog and filepath directory
+                asset_catalog_data = catalog_ids.get(asset.asset_data.catalog_id)
+
+                if not asset_catalog_data:
+                    print(f'No catalog found for asset {asset.name}')
+                    asset_catalog_data = {"path": blend_file.parent.relative_to(source_directory).as_posix()}
+                
+                catalog_path = asset_catalog_data['path']
+
+                asset_path = self.get_asset_path(name=asset.name, catalog=catalog_path, directory=directory)
+                asset_description = self.get_asset_description(asset, catalog=catalog_path, modified=modified)
+
+                self.write_asset_description(asset_description, asset_path)
+                #Write blend file containing only one asset
+                self.write_asset(asset=asset, asset_path=asset_path)
+
+                # Copy image if source image found else write the asset preview
+                src_image_path = self.get_path('image', name=asset.name, asset_path=blend_file, template=image_template)
+                dst_image_path = self.get_path('image', name=asset.name, asset_path=asset_path)
+
+                if src_image_path.exists():
+                    self.copy_file(src_image_path, dst_image_path)
+                else:
+                    self.write_preview(asset.preview, dst_image_path)
+
+                # Copy video if source video found
+                src_video_path = self.get_path('video', name=asset.name, asset_path=blend_file, template=video_template)
+
+                #print('src_video_path', src_video_path)
+                if src_video_path.exists():
+                    dst_video_path = self.get_path('video', name=asset.name, asset_path=asset_path)
+                    self.copy_file(src_video_path, dst_video_path)
+            
+        self.write_catalog(catalog_data, filepath=directory)
+
+    def fetch(self):
+        """Gather in a list all assets found in the folder"""
+
+        print(f'Fetch Assets for {self.library.name}')
+
+        source_directory = Path(os.path.expandvars(self.source_directory))
+        template = Template(self.template)
+        catalog_data = self.read_catalog(filepath=source_directory)
+        catalog_ids = {v['id']: {'path': k, 'name': v['name']} for k,v in catalog_data.items()}
+
+        cache = self.read_cache() or []
+
+        print(f'Search for blend using glob template: {template.glob_pattern}')
+
+        print(f'Scanning Folder {source_directory}...')
+        #blend_files = list(source_directory.glob(template.glob_pattern))
+
+        # Remove delete blends for the list
+        #blend_paths = [self.prop_rel_path(f, 'source_directory') for f in blend_files]
+        #print('blend_paths', blend_paths)
+        
+
+        #cache = []
+        #blend_paths = []
+        new_cache = []
+
+        for blend_file in template.glob(source_directory):#sorted(blend_files):
+            
+            source_rel_path = self.prop_rel_path(blend_file, 'source_directory')
+            modified = blend_file.stat().st_mtime_ns
+
+            asset_description = next((a for a in cache if a['filepath'] == source_rel_path), None)
+
+            if asset_description and asset_description['modified'] >= modified:
+                print(blend_file, 'is skipped because not modified')
+                new_cache.append(asset_description)
+                continue
+
+            rel_path = blend_file.relative_to(source_directory).as_posix()
+            #field_values = re.findall(re_pattern, rel_path)[0]
+            #field_data = {k:v for k,v in zip(field_names, field_values)}
+            field_data = template.parse(rel_path)
+
+            if not field_data:
+                raise Exception()
+
+            #asset_data = (blend_file / prefs.asset_description_template.format(name=name)).resolve()
+
+            catalogs = [v for k,v in sorted(field_data.items()) if k.isdigit()]
+            catalogs = [c.replace('_', ' ').title() for c in catalogs]
+        
+            if self.data_type == 'FILE':
+                name = field_data.get('name', blend_file.stem)
+                image = self.get_path('image', name=name, asset_path=blend_file)
+
+                asset_description = dict(
+                    filepath=source_rel_path,
+                    modified=modified,
+                    catalog='/'.join(catalogs),
+                    tags=[],
+                    type=self.data_type,
+                    image=self.prop_rel_path(image, 'source_directory'),
+                    name=name
+                )
+                new_cache.append(asset_description)
+
+                continue
+
+            #First Check if there is a asset_data .json
+            asset_description = self.read_asset_description(blend_file)
+
+            if not asset_description:
+                # Scan the blend file for assets inside and write a custom asset description for info found
+
+                print(f'Scanning blendfile {blend_file}...')
+                with bpy.data.libraries.load(str(blend_file), link=True, assets_only=True) as (data_from, data_to):
+                    asset_names = getattr(data_from, self.data_types)
+                    print(f'Found {len(asset_names)} {self.data_types} inside')
+
+                    setattr(data_to, self.data_types, asset_names)
+                    assets = getattr(data_to, self.data_types)
+
+                asset_description = dict(
+                    filepath=source_rel_path,
+                    modified=modified,
+                    assets=[]
+                )
+
+                for asset in assets:
+                    asset_catalog_data = catalog_ids.get(asset.asset_data.catalog_id)
+
+                    if not asset_catalog_data:
+                        print(f'No catalog found for asset {asset.name}')
+                        asset_catalog_data = {"path": blend_file.relative_to(self.source_directory).as_posix()}
+                    
+                    catalog_path = asset_catalog_data['path']
+
+                    image_path = self.get_path('image', asset.name, catalog_path)
+                    image = self.prop_rel_path(image_path, 'source_directory')
+
+                    # Write image only if no image was found
+                    if not image_path.exists():
+                        image_path = self.get_cache_image_path(asset.name, catalog_path)
+                        image = self.prop_rel_path(image_path, 'library_path')
+                        self.write_preview(asset.preview, image_path)
+
+                    video_path = self.get_path('video', asset.name, catalog_path)
+                    video = self.prop_rel_path(video_path, 'source_directory')
+
+                    asset_data = dict(
+                        filepath=self.prop_rel_path(blend_file, 'source_directory'),
+                        modified=modified,
+                        catalog=catalog_path,
+                        tags=asset.asset_data.tags.keys(),
+                        type=self.data_type,
+                        image=image,
+                        video=video,
+                        name=asset.name
+                    )
+                    asset_description['assets'].append(asset_data)
+            
+                    getattr(bpy.data, self.data_types).remove(asset)
+
+            new_cache.append(asset_description)
+
+
+        #cache = [a for a in cache if a['filepath'] in blend_paths]
+
+        #for a in asset_data:
+        #    print(a)
+
+        #print(asset_data)
+        new_cache.sort(key=lambda x:x['filepath'])
+
+        return new_cache
+
+        # Write json data file to store all asset found
+        #print(f'Writing asset data file to, {asset_data_path}')
+        #asset_data_path.write_text(json.dumps(asset_data, indent=4))

collection/__init__.py

@@ -0,0 +1,25 @@
+
+from asset_library.collection import (
+    gui,
+    operators,
+    keymaps,
+    build_collection_blends,
+    create_collection_library)
+
+if 'bpy' in locals():
+    import importlib
+
+    importlib.reload(gui)
+    importlib.reload(operators)
+    importlib.reload(keymaps)
+    importlib.reload(build_collection_blends)
+    importlib.reload(create_collection_library)
+
+
+def register():
+    operators.register()
+    keymaps.register()
+
+def unregister():
+    operators.unregister()
+    keymaps.unregister()

collection/build_collection_blends.py

@@ -0,0 +1,124 @@
+import argparse
+import bpy
+import sys
+import json
+from pathlib import Path
+from time import time, sleep
+from itertools import groupby
+from asset_library.common.bl_utils import load_datablocks, col_as_asset
+from asset_library.constants import ASSETLIB_FILENAME
+
+""" blender_assets.libs.json data Structure
+[
+    {
+    'name': 'chars/main',
+    'id': '013562-56315-4563156-123',
+    'children':
+            [
+                {
+                'filepath' : '/z/...',
+                'name' : 'collection name',
+                'tags' : ['variation', 'machin', 'chose'],
+                'metadata' : {'filepath': '$PROJECT/...', 'version' : 'mushable'}
+                },
+                {
+                'filepath' : '/z/...',
+                },
+            ],
+    },
+] 
+"""
+
+def build_collection_blends(path, categories=None, clean=True):
+
+    t0 = time()
+    scn = bpy.context.scene
+    scn.render.resolution_x = scn.render.resolution_y = 1000
+    
+    json_path = Path(path) / ASSETLIB_FILENAME
+    if not json_path.exists():
+        return
+
+    # _col_datas = json.loads(json_path.read())[category]
+    category_datas = json.loads(json_path.read_text())
+
+    for category_data in category_datas:
+        if categories and category_data['name'] not in categories:
+            continue
+
+        bpy.ops.wm.read_homefile(use_empty=True)
+
+
+        #category_data = next(c for c in category_datas if c['name'] == category)
+        #_col_datas = category_data['children']
+
+        cat_name = category_data['name']
+        build_path = Path(path) / cat_name / f'{cat_name}.blend'
+
+        ## re-iterate in grouped filepath
+        col_datas = sorted(category_data['children'], key=lambda x: x['filepath'])
+        for filepath, col_data_groups in groupby(col_datas, key=lambda x: x['filepath']):
+            #f = Path(f)
+            if not Path(filepath).exists():
+                print(f'Not exists: {filepath}')
+                continue
+
+            col_data_groups = list(col_data_groups)
+
+            col_names = [a['name'] for a in col_data_groups]
+            linked_cols = load_datablocks(filepath, col_names, link=True, type='collections')
+
+            for i, col in enumerate(linked_cols):
+                # iterate in linked collection and associated data
+                if not col:
+                    continue
+                asset_data = col_data_groups[i]
+
+                ## asset_data -> {'filepath': str, 'tags': list, 'metadata': dict}
+
+                ## Directly link as collection inside a marked collection with same name
+                marked_col = col_as_asset(col, verbose=True)
+                marked_col.asset_data.description = asset_data.get('description', '')
+                marked_col.asset_data.catalog_id = category_data['id'] # assign catalog
+
+                for k, v in asset_data.get('metadata', {}).items():
+                    marked_col.asset_data[k] = v
+
+                ## exclude collections and generate preview
+                bpy.ops.ed.lib_id_generate_preview({"id": marked_col}) # preview gen
+                vcol = bpy.context.view_layer.layer_collection.children[marked_col.name]
+                vcol.exclude = True
+
+        sleep(1.0)
+
+        ## clear all objects (can be very long with a lot of objects...):
+        if clean:
+            print('Removing links...')
+            for lib in reversed(bpy.data.libraries):
+                bpy.data.libraries.remove(lib)
+
+        
+
+        # Créer les dossiers intermediaires
+        build_path.parent.mkdir(parents=True, exist_ok=True)
+        print('Saving to', build_path)
+        bpy.ops.wm.save_as_mainfile(filepath=str(build_path), compress=False)
+    
+    print("build time:", f'{time() - t0:.1f}s')
+
+    bpy.ops.wm.quit_blender()
+
+
+if __name__ == '__main__' :
+    parser = argparse.ArgumentParser(description='build_collection_blends',
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('-path') # Trouve/créer le json assetlib.json en sous-dossier de libdir
+    parser.add_argument('--category') # Lit la category dans le json et a link tout dans le blend
+
+    if '--' in sys.argv :
+        index = sys.argv.index('--')
+        sys.argv = [sys.argv[index-1], *sys.argv[index+1:]]
+
+    args = parser.parse_args()
+    build_collection_blends(**vars(args))

collection/create_collection_library.py

@@ -0,0 +1,163 @@
+import argparse
+import sys
+import os
+import json
+import uuid
+import subprocess
+import bpy
+from pathlib import Path
+from asset_library.common.functions import create_catalog_file
+from asset_library.common.file_utils import get_last_files
+from asset_library.constants import ASSETLIB_FILENAME
+
+
+"""
+### Create asset collection
+
+## create_collection_library: generate all category blend from json
+## if source_directory is set, call create_collection_json
+
+##    # create_collection_json:
+##    # scan marked blend, create json and call create_catalog_file
+
+##         # create_catalog_file
+##         # create catalog file from json file
+
+###  Json Structure 
+[
+    {
+    'name': 'chars/main',
+    'id': '013562-56315-4563156-123',
+    'children':
+            [
+                {
+                'filepath' : '/z/...',
+                'name' : 'collection name',
+                'tags' : ['variation', 'machin', 'chose'],
+                'metadata' : {'filepath': '$PROJECT/...', 'version' : 'mushable'}
+                },
+                {
+                'filepath' : '/z/...',
+                },
+            ],
+    },
+] 
+"""
+
+def create_collection_json(path, source_directory):
+    '''Create a Json from every marked collection in blends
+    contained in folderpath (respect hierachy)
+    '''
+
+    json_path = Path(path) / ASSETLIB_FILENAME
+    
+    # scan all last version of the assets ?
+    # get last version files ?
+    # or open all blends and look only for marked collection ? (if versionned, get still get only last)
+
+    # get all blend in dir and subdirs (only last when versionned _v???)
+    blends = get_last_files(source_directory, pattern=r'(_v\d{3})?\.blend$', only_matching=True)
+
+    root_path = Path(source_directory).as_posix().rstrip('/') + '/'
+    print('root_path: ', root_path)
+    # open and check data block marked as asset
+
+    category_datas = []
+    for i, blend in enumerate(blends):
+        fp = Path(blend)
+        print(f'{i+1}/{len(blends)}')
+        
+        ## What is considered a grouping category ? top level folders ? parents[1] ?
+
+        ## Remove root path and extension
+        ## top level folder ('chars'), problem if blends at root 
+        category = fp.as_posix().replace(root_path, '').split('/')[0]
+        
+        ## full blend path (chars/perso/perso)
+        # category = fp.as_posix().replace(root_path, '').rsplit('.', 1)[0]
+        
+        print(category)
+
+        with bpy.data.libraries.load(blend, link=True, assets_only=True) as (data_from, data_to):
+            ## just listing
+            col_name_list = [c for c in data_from.collections]
+
+        if not col_name_list:
+            continue
+
+        col_list = next((c['children'] for c in category_datas if c['name'] == category), None)
+        if col_list is None:
+            col_list = []
+            category_data = {
+                'name': category,
+                'id': str(uuid.uuid4()),
+                'children': col_list,
+                }
+            category_datas.append(category_data)
+
+
+        blend_source_path = blend.as_posix()
+        if (project_root := os.environ.get('PROJECT_ROOT')):
+            blend_source_path = blend_source_path.replace(project_root, '$PROJECT_ROOT')
+
+
+        for name in col_name_list:
+            data = {
+                'filepath' : blend,
+                'name' : name,
+                # 'tags' : [],
+                'metadata' : {'filepath': blend_source_path},
+            }
+
+            col_list.append(data)
+
+    json_path.write_text(json.dumps(category_datas, indent='\t'))
+    ## create text catalog from json (keep_existing_category ?)
+    create_catalog_file(json_path, keep_existing_category=True)
+
+
+def create_collection_library(path, source_directory=None):
+    '''
+    path: store collection library (json and blends database)
+    source_directory: if a source is set, rebuild json and library
+    '''
+
+    if source_directory:
+        if not Path(source_directory).exists():
+            print(f'Source directory not exists: {source_directory}')
+            return
+
+        ## scan source and build json in assetlib dir root
+        create_collection_json(path, source_directory)
+
+    json_path = Path(path) / ASSETLIB_FILENAME
+    if not json_path.exists():
+        print(f'No json found at: {json_path}')
+        return
+
+    file_datas = json.loads(json_path.read())
+
+    ## For each category in json, execute build_assets_blend script
+    script = Path(__file__).parent / 'build_collection_blends.py'
+    #empty_blend = Path(__file__).parent / 'empty_scene.blend'
+    
+    # for category, asset_datas in file_datas.items():
+    for category_data in file_datas:
+        ## add an empty blend as second arg
+        cmd = [bpy.app.binary_path, '--python', str(script), '--', '--path', path, '--category', category_data['name']]
+        print('cmd: ', cmd)
+        subprocess.call(cmd)
+
+
+if __name__ == '__main__' :
+    parser = argparse.ArgumentParser(description='Create Collection Library',
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--path') # trouve/créer le json assetlib.json en sous-dossier de libdir 
+
+    if '--' in sys.argv :
+        index = sys.argv.index('--')
+        sys.argv = [sys.argv[index-1], *sys.argv[index+1:]]
+
+    args = parser.parse_args()
+    create_collection_library(**vars(args))

collection/gui.py

@@ -0,0 +1,14 @@
+
+import bpy
+
+
+def draw_context_menu(layout):
+    params = bpy.context.space_data.params
+
+    return
+
+
+def draw_header(layout):
+    '''Draw the header of the Asset Browser Window'''
+
+    return

collection/keymaps.py

@@ -0,0 +1,22 @@
+
+
+from typing import List, Tuple
+
+import bpy
+
+addon_keymaps: List[Tuple[bpy.types.KeyMap, bpy.types.KeyMapItem]] = []
+
+def register():
+    wm = bpy.context.window_manager
+    addon = wm.keyconfigs.addon
+    if not addon:
+        return
+
+    km = addon.keymaps.new(name="File Browser Main", space_type="FILE_BROWSER")
+    kmi = km.keymap_items.new("assetlib.load_asset", "LEFTMOUSE", "DOUBLE_CLICK") # , shift=True
+    addon_keymaps.append((km, kmi))
+
+def unregister():
+    for km, kmi in addon_keymaps:
+        km.keymap_items.remove(kmi)
+    addon_keymaps.clear()

collection/operators.py

@@ -0,0 +1,102 @@
+import bpy
+from bpy.types import Context, Operator
+from bpy_extras import asset_utils
+
+from fnmatch import fnmatch
+import os
+import fnmatch
+from os.path import expandvars
+from typing import List, Tuple, Set
+from pathlib import Path
+import subprocess
+
+from asset_library.common.bl_utils import load_col
+from asset_library.common.functions import get_active_library
+
+
+
+class ASSETLIB_OT_load_asset(Operator):
+    bl_idname = "assetlib.load_asset"
+    bl_options = {"REGISTER", "UNDO", "INTERNAL"}
+    bl_label = 'Load Asset'
+    bl_description = 'Link and override asset in current file'
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            cls.poll_message_set("Current editor is not an asset browser")
+            return False
+        
+        lib = get_active_library()
+        if not lib or lib.data_type != 'COLLECTION':
+            return False
+        
+        if not context.active_file or 'filepath' not in context.active_file.asset_data:
+            cls.poll_message_set("Has not filepath property")
+            return False
+
+        return True
+
+    def execute(self, context: Context) -> Set[str]:
+
+        print('Load Asset')
+
+        lib = get_active_library()
+        print(lib, lib.data_type)
+
+        # dir(asset) :  'asset_data', 'bl_rna', 'id_type', 'local_id', 'name', 'preview_icon_id', 'relative_path', 'rna_type']
+        # dir(asset.asset_data) : 'active_tag', 'author', 'bl_rna', 'catalog_id', 'catalog_simple_name', 'description', 'rna_type', 'tags']
+
+        ## get source path
+        # asset_file_handle = context.asset_file_handle
+        # if asset_file_handle is None:
+        #     return {'CANCELLED'}
+        # if asset_file_handle.local_id:
+        #     return {'CANCELLED'}
+        # asset_library_ref = context.asset_library_ref
+        # source_directory = bpy.types.AssetHandle.get_full_library_path(
+        #     asset_file_handle, asset_library_ref
+        # )
+
+        asset = context.active_file
+        if not asset:
+            self.report({"ERROR"}, 'No asset selected')
+            return {'CANCELLED'}
+        
+        fp = expandvars(asset.asset_data['filepath'])
+        name = asset.name
+
+        ## set mode to object
+        if context.mode != 'OBJECT':
+            bpy.ops.object.mode_set(mode='OBJECT')
+        
+        ## get the real direct path with expand_var
+        print('path expanded: ', fp)
+
+        if not Path(fp).exists():
+            self.report({'ERROR'}, f'Not exists: {fp}')
+            return {'CANCELLED'}
+
+        res = load_col(fp, name, link=True, override=True, rig_pattern='*_rig')
+        if res:
+            if res.type == 'ARMATURE':
+                self.report({'INFO'}, f'Override rig {res.name}')
+            elif res.type == 'EMPTY':
+                self.report({'INFO'}, f'Instance collection {res.name}')
+
+        return {'FINISHED'}
+
+
+### --- REGISTER ---
+
+classes = (
+    ASSETLIB_OT_load_asset,
+)
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+
+def unregister():
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)

common/__init__.py

@@ -0,0 +1,26 @@
+
+#from asset_library.bundle_blend import bundle_blend, bundle_library
+#from file_utils import (norm_str, norm_value,
+#    norm_arg, get_bl_cmd, copy_file, copy_dir)
+#from asset_library.functions import 
+
+#from asset_library.common import bundle_blend
+from asset_library.common import file_utils
+from asset_library.common import functions
+from asset_library.common import synchronize
+from asset_library.common import template
+
+if 'bpy' in locals():
+    import importlib
+
+    #importlib.reload(bundle_blend)
+    importlib.reload(file_utils)
+    importlib.reload(functions)
+    importlib.reload(synchronize)
+    importlib.reload(template)
+
+import bpy
+
+    
+
+

common/bl_utils.py

@@ -0,0 +1,465 @@
+
+"""
+Generic Blender functions
+"""
+
+from pathlib import Path
+from fnmatch import fnmatch
+from typing import Any, List, Iterable, Optional, Tuple
+Datablock = Any
+
+import bpy
+from bpy_extras import asset_utils
+from asset_library.constants import RESOURCES_DIR
+#from asset_library.common.file_utils import no
+from os.path import abspath
+
+
+class attr_set():
+    '''Receive a list of tuple [(data_path, "attribute" [, wanted value)] ]
+    entering with-statement : Store existing values, assign wanted value (if any)
+    exiting with-statement: Restore values to their old values
+    '''
+
+    def __init__(self, attrib_list):
+        self.store = []
+        # item = (prop, attr, [new_val])
+        for item in attrib_list:
+            prop, attr = item[:2]
+            self.store.append( (prop, attr, getattr(prop, attr)) )
+            if len(item) >= 3:
+                try:
+                    setattr(prop, attr, item[2])
+                except TypeError:
+                    print(f'Cannot set attribute {attr} to {prop}')
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        for prop, attr, old_val in self.store:
+            setattr(prop, attr, old_val)
+
+def get_overriden_col(ob, scene=None):
+    scn = scene or bpy.context.scene
+
+    cols = [c for c in bpy.data.collections if scn.user_of_id(c)]
+    
+    return next((c for c in cols if ob in c.all_objects[:] 
+           if all(not c.override_library for c in get_col_parents(c))), None)
+
+def get_view3d_persp():
+    windows = bpy.context.window_manager.windows
+    view_3ds = [a for w in windows for a in w.screen.areas if a.type == 'VIEW_3D']
+    view_3d = next((a for a in view_3ds if a.spaces.active.region_3d.view_perspective == 'PERSP'), view_3ds[0])
+    return view_3d
+
+def biggest_asset_browser_area(screen: bpy.types.Screen) -> Optional[bpy.types.Area]:
+    """Return the asset browser Area that's largest on screen.
+
+    :param screen: context.window.screen
+
+    :return: the Area, or None if no Asset Browser area exists.
+    """
+
+    def area_sorting_key(area: bpy.types.Area) -> Tuple[bool, int]:
+        """Return area size in pixels."""
+        return (area.width * area.height)
+
+    areas = list(suitable_areas(screen))
+    if not areas:
+        return None
+
+    return max(areas, key=area_sorting_key)
+
+def suitable_areas(screen: bpy.types.Screen) -> Iterable[bpy.types.Area]:
+    """Generator, yield Asset Browser areas."""
+
+    for area in screen.areas:
+        space_data = area.spaces[0]
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(space_data):
+            continue
+        yield area
+
+def area_from_context(context: bpy.types.Context) -> Optional[bpy.types.Area]:
+    """Return an Asset Browser suitable for the given category.
+
+    Prefers the current Asset Browser if available, otherwise the biggest.
+    """
+
+    space_data = context.space_data
+    if asset_utils.SpaceAssetInfo.is_asset_browser(space_data):
+        return context.area
+
+    # Try the current screen first.
+    browser_area = biggest_asset_browser_area(context.screen)
+    if browser_area:
+        return browser_area
+
+    for win in context.window_manager.windows:
+        if win.screen == context.screen:
+            continue
+        browser_area = biggest_asset_browser_area(win.screen)
+        if browser_area:
+            return browser_area
+
+    return None
+
+def activate_asset(
+    asset: bpy.types.Action, asset_browser: bpy.types.Area, *, deferred: bool
+) -> None:
+    """Select & focus the asset in the browser."""
+
+    space_data = asset_browser.spaces[0]
+    assert asset_utils.SpaceAssetInfo.is_asset_browser(space_data)
+    space_data.activate_asset_by_id(asset, deferred=deferred)
+
+def active_catalog_id(asset_browser: bpy.types.Area) -> str:
+    """Return the ID of the catalog shown in the asset browser."""
+    return params(asset_browser).catalog_id
+
+def get_asset_space_params(asset_browser: bpy.types.Area) -> bpy.types.FileAssetSelectParams:
+    """Return the asset browser parameters given its Area."""
+    space_data = asset_browser.spaces[0]
+    assert asset_utils.SpaceAssetInfo.is_asset_browser(space_data)
+    return space_data.params
+
+def refresh_asset_browsers():
+    for area in suitable_areas(bpy.context.screen):
+        bpy.ops.asset.library_refresh({"area": area, 'region': area.regions[3]})
+
+def tag_redraw(screen: bpy.types.Screen) -> None:
+    """Tag all asset browsers for redrawing."""
+
+    for area in suitable_areas(screen):
+        area.tag_redraw()
+
+# def get_blender_command(file=None, script=None, background=True, **args):
+#     '''Return a Blender Command as a list to be used in a subprocess'''
+
+#     cmd = [bpy.app.binary_path]
+
+#     if file:
+#         cmd += [str(file)]
+#     if background:
+#         cmd += ['--background']
+#     if script:
+#         cmd += ['--python', str(script)]
+#     if args:
+#         cmd += ['--']
+#         for k, v in args.items():
+#             cmd += [f"--{k.replace('_', '-')}", str(v)]
+            
+#     return cmd
+
+def norm_value(value):
+    if isinstance(value, (tuple, list)):
+        values = []
+        for v in value:
+            if not isinstance(v, str):
+                v = json.dumps(v)
+            values.append(v)
+
+        return values       
+
+    if isinstance(value, Path):
+        return str(value)
+
+    if not isinstance(value, str):
+        value = json.dumps(value)
+    return value
+
+def norm_arg(arg_name, format=str.lower, prefix='--', separator='-'):
+    arg_name = norm_str(arg_name, format=format, separator=separator)
+
+    return prefix + arg_name
+
+def get_bl_cmd(blender=None, background=False, focus=True, blendfile=None, script=None, **kargs):
+    cmd = [str(blender)] if blender else [bpy.app.binary_path]
+
+    if background:
+        cmd += ['--background']
+
+    if not focus and not background:
+        cmd += ['--no-window-focus']
+        cmd += ['--window-geometry', '5000', '0', '10', '10']
+
+    if blendfile:
+        cmd += [str(blendfile)]
+        
+    if script:
+        cmd += ['--python', str(script)]
+
+    if kargs:
+        cmd += ['--']     
+        for k, v in kargs.items():
+            k = norm_arg(k)
+            v = norm_value(v)
+
+            cmd += [k]
+            if isinstance(v, (tuple, list)):
+                cmd += v
+            else:
+                cmd += [v]
+
+    return cmd
+
+def get_addon_prefs():
+    addon_name = __package__.split('.')[0]
+    return bpy.context.preferences.addons[addon_name].preferences
+
+
+
+def thumbnail_blend_file(input_blend, output_img):
+    input_blend = Path(input_blend).resolve()
+    output_img = Path(output_img).resolve()
+
+    print(f'Thumbnailing {input_blend} to {output_img}')
+    blender_thumbnailer = Path(bpy.app.binary_path).parent / 'blender-thumbnailer'
+
+    output_img.parent.mkdir(exist_ok=True, parents=True)
+
+    subprocess.call([blender_thumbnailer, str(input_blend), str(output_img)])
+
+    success = output_img.exists()
+
+    if not success:
+        empty_preview = RESOURCES_DIR / 'empty_preview.png'
+        shutil.copy(str(empty_preview), str(output_img))
+
+    return success
+
+def get_col_parents(col, root=None, cols=None):
+    '''Return a list of parents collections of passed col
+    root : Pass a collection to search in (recursive)
+    else search in master collection
+    '''
+    if cols is None:
+        cols = []
+
+    if root == None:
+        root = bpy.context.scene.collection
+
+    for sub in root.children:
+        if sub == col:
+            cols.append(root)
+
+        if len(sub.children):
+            cols = get_col_parents(col, root=sub, cols=cols)
+    return cols
+
+def get_overriden_col(ob, scene=None):
+    '''Get the collection use for making the override'''
+    scn = scene or bpy.context.scene
+
+    cols = [c for c in bpy.data.collections if scn.user_of_id(c)]
+    
+    return next((c for c in cols if ob in c.all_objects[:] 
+           if all(not c.override_library for c in get_col_parents(c))), None)
+
+def load_assets_from(filepath: Path) -> List[Datablock]:
+    if not has_assets(filepath):
+        # Avoid loading any datablocks when there are none marked as asset.
+        return []
+
+    # Append everything from the file.
+    with bpy.data.libraries.load(str(filepath)) as (
+        data_from,
+        data_to,
+    ):
+        for attr in dir(data_to):
+            setattr(data_to, attr, getattr(data_from, attr))
+
+    # Iterate over the appended datablocks to find assets.
+    def loaded_datablocks() -> Iterable[Datablock]:
+        for attr in dir(data_to):
+            datablocks = getattr(data_to, attr)
+            for datablock in datablocks:
+                yield datablock
+
+    loaded_assets = []
+    for datablock in loaded_datablocks():
+        if not getattr(datablock, "asset_data", None):
+            continue
+
+        # Fake User is lost when appending from another file.
+        datablock.use_fake_user = True
+        loaded_assets.append(datablock)
+    return loaded_assets
+
+def has_assets(filepath: Path) -> bool:
+    with bpy.data.libraries.load(str(filepath), assets_only=True) as (
+        data_from,
+        _,
+    ):
+        for attr in dir(data_from):
+            data_names = getattr(data_from, attr)
+            if data_names:
+                return True
+    return False
+
+
+
+
+
+
+
+def copy_frames(start, end, offset, path):
+    for i in range (start, end):
+        src = path.replace('####', f'{i:04d}')
+        dst = src.replace(src.split('_')[-1].split('.')[0], f'{i+offset:04d}')
+        shutil.copy2(src, dst)
+
+def split_path(path) :
+    try :
+        bone_name = path.split('["')[1].split('"]')[0]
+    except :
+        bone_name = None
+    try :
+        prop_name = path.split('["')[2].split('"]')[0]
+    except :
+        prop_name = path.split('.')[-1]
+
+    return bone_name, prop_name
+
+
+
+
+
+def load_datablocks(src, names=None, type='objects', link=True, expr=None) -> list:
+    return_list = not isinstance(names, str)
+    names = names or []
+
+    if not isinstance(names, (list, tuple)):
+        names = [names]
+    
+    if isinstance(expr, str):
+        pattern = expr
+        expr = lambda x : fnmatch(x, pattern)
+    
+    with bpy.data.libraries.load(str(src), link=link) as (data_from, data_to):
+        datablocks = getattr(data_from, type)
+        if expr:
+            names += [i for i in datablocks if expr(i)]
+        elif not names:
+            names = datablocks
+        
+        setattr(data_to, type, names)
+
+        datablocks = getattr(data_to, type)
+
+    if return_list:
+        return datablocks
+
+    elif datablocks:
+        return datablocks[0]
+
+"""
+# --- Collection handling
+"""
+
+def col_as_asset(col, verbose=False):
+    if col is None:
+        return
+    if verbose:
+        print('linking:', col.name)
+    pcol = bpy.data.collections.new(col.name)
+    bpy.context.scene.collection.children.link(pcol)
+    pcol.children.link(col)
+    pcol.asset_mark()
+    return pcol
+
+def load_col(filepath, name, link=True, override=True, rig_pattern=None, context=None):
+    '''Link a collection by name from a file and override if has armature'''
+
+    # with bpy.data.libraries.load(filepath, link=link) as (data_from, data_to):
+    #     data_to.collections = [c for c in data_from.collections if c == name]
+    # if not data_to.collections:
+    #     return
+    # return data_to.collections[0]
+    context = context or bpy.context
+
+    collections = load_datablocks(filepath, name, link=link, type='collections')
+    if not collections:
+        print(f'No collection "{name}" found in: {filepath}')
+        return
+    
+    col = collections[0]
+    print('collection:', col.name)
+
+    ## create instance object
+    inst = bpy.data.objects.new(col.name, None)
+    inst.instance_collection = col
+    inst.instance_type = 'COLLECTION'
+    context.scene.collection.objects.link(inst)
+
+    # make active
+    inst.select_set(True)
+    context.view_layer.objects.active = inst
+
+    ## simple object (no armatures)
+    if not link or not override:
+        return inst
+    if not next((o for o in col.all_objects if o.type == 'ARMATURE'), None):
+        return inst
+    
+    ## Create the override
+    # Search
+    parent_cols = inst.users_collection
+    child_cols = [child for pcol in parent_cols for child in pcol.children]
+
+    params = {'active_object': inst, 'selected_objects': [inst]}
+    try:
+        bpy.ops.object.make_override_library(params)
+
+        ## check which collection is new in parents collection
+        asset_col = next((c for pcol in parent_cols for c in pcol.children if c not in child_cols), None)
+        if not asset_col:
+            print('Overriden, but no collection found !!')
+            return
+        
+        for ob in asset_col.all_objects:
+            if ob.type != 'ARMATURE':
+                continue
+            if rig_pattern and not fnmatch(ob.name, rig_pattern):
+                continue
+
+            ob.hide_select = ob.hide_viewport = False
+            ob.select_set(True)
+            context.view_layer.objects.active = ob
+            print(ob.name)
+            return ob
+
+    except Exception as e:
+        print(f'Override failed on {col.name}')
+        print(e)
+    
+    return inst
+
+
+def get_preview(asset_path='', asset_name=''):
+    asset_preview_dir = Path(asset_path).parents[1]
+    name = asset_name.lower()
+    return next((f for f in asset_preview_dir.rglob('*') if f.stem.lower().endswith(name)), None)
+
+def get_object_libraries(ob):
+    if not ob : 
+        return []
+    
+    libraries = [ob.library, ob.data.library]
+
+    if ob.type in ('MESH', 'CURVE'):
+        libraries += [m.library for m in ob.data.materials if m]
+    
+    filepaths = []
+    for l in libraries:
+        if not l or not l.filepath:
+            continue
+        
+        absolute_filepath = abspath(bpy.path.abspath(l.filepath, library=l))
+        if absolute_filepath in filepaths:
+            continue
+
+        filepaths.append(absolute_filepath)
+
+    return filepaths

common/file_utils.py

@@ -0,0 +1,307 @@
+
+"""Generic python functions to make operation on file and names"""
+
+import fnmatch
+import json
+import platform
+import re
+import subprocess
+import unicodedata
+import os
+from pathlib import Path
+import importlib
+import sys
+import shutil
+
+
+def install_module(module_name, package_name=None):
+    '''Install a python module with pip or return it if already installed'''
+    try:
+        module = importlib.import_module(module_name)
+    except ModuleNotFoundError:
+        print(f'Installing Module {module_name} ....')
+
+        subprocess.call([sys.executable, '-m', 'ensurepip'])
+        subprocess.call([sys.executable, '-m', 'pip', 'install', package_name or module_name])
+        
+        module = importlib.import_module(module_name)
+    
+    return module
+
+def import_module_from_path(path):
+    from importlib import util
+
+    try:
+        path = Path(path)
+        spec = util.spec_from_file_location(path.stem, str(path))
+        mod = util.module_from_spec(spec)
+        
+        spec.loader.exec_module(mod)
+
+        return mod
+    except Exception as e:
+        print(f'Cannot import file {path}')
+        print(e)
+
+def norm_str(string, separator='_', format=str.lower, padding=0):    
+    string = str(string)
+    string = string.replace('_', ' ')
+    string = string.replace('-', ' ')
+    string = re.sub('[ ]+', ' ', string)
+    string = re.sub('[ ]+\/[ ]+', '/', string)
+    string = string.strip()
+
+    if format:
+        string = format(string)
+    
+    # Padd rightest number
+    string = re.sub(r'(\d+)(?!.*\d)', lambda x : x.group(1).zfill(padding), string)
+    
+    string = string.replace(' ', separator)
+    string = unicodedata.normalize('NFKD', string).encode('ASCII', 'ignore').decode("utf-8")
+
+    return string
+
+def remove_version(filepath):
+    pattern = '_v[0-9]+\.'
+    search = re.search(pattern, filepath)
+
+    if search:
+        filepath = filepath.replace(search.group()[:-1], '')
+
+    return Path(filepath).name
+
+def is_exclude(name, patterns) -> bool:
+    # from fnmatch import fnmatch
+    if not isinstance(patterns, (list,tuple)) :
+        patterns = [patterns]
+    return any([fnmatch(name, p) for p in patterns])
+
+def get_last_files(root, pattern=r'_v\d{3}\.\w+', only_matching=False, ex_file=None, ex_dir=None, keep=1, verbose=False) -> list:
+    '''Recursively get last(s) file(s) (when there is multiple versions) in passed directory
+    root -> str: Filepath of the folder to scan.
+    pattern -> str: Regex pattern to group files.
+    only_matching -> bool: Discard files that aren't matched by regex pattern.
+    ex_file -> list : List of fn_match pattern to exclude files.
+    ex_dir -> list : List of fn_match pattern of directory name to skip.
+    keep -> int: Number of lasts versions to keep when there are mutliple versionned files (e.g: 1 keep only last).
+    verbose -> bool: Print infos in console.
+    '''
+
+    files = []
+    if ex_file is None:
+        all_items = [f for f in os.scandir(root)]
+    else:
+        all_items = [f for f in os.scandir(root) if not is_exclude(f.name, ex_file)]
+
+    allfiles = [f for f in all_items if f.is_file()]
+    # Need to sort to effectively group separated key in list
+    allfiles.sort(key=lambda x: x.name)
+
+    dirs = [f for f in all_items if f.is_dir()]
+
+    for i in range(len(allfiles)-1,-1,-1):# fastest way to iterate on index in reverse
+        if not re.search(pattern, allfiles[i].name):
+            if only_matching:
+                allfiles.pop(i)
+            else:
+                files.append(allfiles.pop(i).path)
+
+    # separate remaining files in prefix grouped lists
+    lilist = [list(v) for k, v in groupby(allfiles, key=lambda x: re.split(pattern, x.name)[0])]
+
+    # get only item last of each sorted grouplist
+    for l in lilist:
+        versions = sorted(l, key=lambda x: x.name)[-keep:]  # exclude older
+        for f in versions:
+            files.append(f.path)
+
+        if verbose and len(l) > 1:
+            print(f'{root}: keep {str([x.name for x in versions])} out of {len(l)} elements')
+
+    for d in dirs: # recursively treat all detected directory
+        if ex_dir and is_exclude(d.name, ex_dir):
+            # skip folder with excluded name 
+            continue
+        files += get_last_files(
+            d.path, pattern=pattern, only_matching=only_matching, ex_file=ex_file, ex_dir=ex_dir, keep=keep)
+
+    return sorted(files)
+
+def copy_file(src, dst, only_new=False, only_recent=False):
+    if dst.exists():
+        if only_new:
+            return
+        elif only_recent and dst.stat().st_mtime >= src.stat().st_mtime:
+            return
+
+    dst.parent.mkdir(exist_ok=True, parents=True)
+    print(f'Copy file from {src} to {dst}')
+    if platform.system() == 'Windows':
+        subprocess.call(['copy', str(src), str(dst)], shell=True)
+    else:
+        subprocess.call(['cp', str(src), str(dst)])
+
+def copy_dir(src, dst, only_new=False, only_recent=False, excludes=['.*'], includes=[]):
+    src, dst = Path(src), Path(dst)
+
+    if includes:
+        includes = r'|'.join([fnmatch.translate(x) for x in includes])
+    if excludes:
+        excludes = r'|'.join([fnmatch.translate(x) for x in excludes])
+
+    if dst.is_dir():
+        dst.mkdir(exist_ok=True, parents=True)
+    else:
+        dst.parent.mkdir(exist_ok=True, parents=True)
+
+    if src.is_file():
+        copy_file(src, dst, only_new=only_new, only_recent=only_recent)
+
+    elif src.is_dir():
+        src_files = list(src.rglob('*'))
+        if excludes:
+            src_files = [f for f in src_files if not re.match(excludes, f.name)]
+
+        if includes:
+            src_files = [f for f in src_files if re.match(includes, f.name)]
+
+        dst_files = [dst/f.relative_to(src) for f in src_files]
+
+        for src_file, dst_file in zip(src_files, dst_files) :
+            if src_file.is_dir():
+                dst_file.mkdir(exist_ok=True, parents=True)
+            else:
+                copy_file(src_file, dst_file, only_new=only_new, only_recent=only_recent)
+
+
+def open_file(filepath, select=False):
+    '''Open a filepath inside the os explorer'''
+    
+    if platform.system() == 'Darwin':       # macOS
+        cmd = ['open']
+    elif platform.system() == 'Windows':    # Windows
+        cmd = ['explorer']
+        if select:
+            cmd += ['/select,']
+    else:                                   # linux variants
+        cmd = ['xdg-open']
+        if select:
+            cmd = ['nemo']
+    
+    cmd += [str(filepath)]
+    subprocess.Popen(cmd)
+
+def open_blender_file(filepath=None):
+    filepath = filepath or bpy.data.filepath
+    
+    cmd = sys.argv
+    
+    # if no filepath, use command as is to reopen blender
+    if filepath != '':
+        if len(cmd) > 1 and cmd[1].endswith('.blend'):
+            cmd[1] = str(filepath)
+        else:
+            cmd.insert(1, str(filepath))
+
+    subprocess.Popen(cmd)
+
+def read_file(path):
+    '''Read a file with an extension in (json, yaml, yml, txt)'''
+
+    exts = ('.json', '.yaml', '.yml', '.txt')
+
+    if not path:
+        print('Try to read empty file')
+    
+    path = Path(path)
+    if not path.exists():
+        print('File not exist', path)
+        return
+    
+    if path.suffix not in exts:
+        print(f'Cannot read file {path}, extension must be in {exts}')
+        return
+
+    txt = path.read_text()
+    data = None
+
+    if path.suffix.lower() in ('.yaml', '.yml'):
+        yaml = install_module('yaml')
+        try:
+            data = yaml.safe_load(txt)
+        except Exception:
+            print(f'Could not load yaml file {path}')
+            return
+    elif path.suffix.lower() == '.json':
+        try:
+            data = json.loads(txt)
+        except Exception:
+            print(f'Could not load json file {path}')
+            return
+    else:
+        data = txt
+
+    return data
+
+def write_file(path, data, indent=4):
+    '''Read a file with an extension in (json, yaml, yml, text)'''
+
+    exts = ('.json', '.yaml', '.yml', '.txt')
+
+    if not path:
+        print('Try to write empty file')
+    
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if path.suffix not in exts:
+        print(f'Cannot read file {path}, extension must be in {exts}')
+        return
+
+    if path.suffix.lower() in ('.yaml', '.yml'):
+        yaml = install_module('yaml')
+        try:
+            path.write_text(yaml.dump(data), encoding='utf8')
+        except Exception as e:
+            print(e)
+            print(f'Could not write yaml file {path}')
+            return
+    elif path.suffix.lower() == '.json':
+        try:
+            path.write_text(json.dumps(data, indent=indent), encoding='utf8')
+        except Exception as e:
+            print(e)
+            print(f'Could not write json file {path}')
+            return
+    else:
+        data = path.write_text(data, encoding='utf8')
+
+
+def synchronize(src, dst, only_new=False, only_recent=False, clear=False):
+
+    #actionlib_dir = get_actionlib_dir(custom=custom)
+    #local_actionlib_dir = get_actionlib_dir(local=True, custom=custom)
+
+    try:
+        if clear and Path(dst).exists():
+            shutil.rmtree(dst)
+
+        #set_actionlib_dir(custom=custom)
+
+        script = Path(__file__).parent / 'synchronize.py'
+
+        cmd = [
+            sys.executable,
+            script,
+            '--src', str(src),
+            '--dst', str(dst),
+            '--only-new', json.dumps(only_new),
+            '--only-recent', json.dumps(only_recent),
+        ]
+
+        subprocess.Popen(cmd)
+
+    except Exception as e:
+        print(e)
+    

common/functions.py

@@ -0,0 +1,465 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Function relative to the asset browser addon
+"""
+
+from pathlib import Path
+import json
+import os
+import re
+
+import time
+#from asset_library.constants import ASSETLIB_FILENAME
+import inspect
+from asset_library.common.file_utils import read_file
+from asset_library.common.bl_utils import get_addon_prefs
+import uuid
+
+import bpy
+
+
+def command(func):
+    '''Decorator to be used from printed functions argument and run time'''
+    func_name = func.__name__.replace('_', ' ').title()
+    
+    def _command(*args, **kargs):
+
+        bound = inspect.signature(func).bind(*args, **kargs)
+        bound.apply_defaults()
+
+        args_str = ', '.join([f'{k}={v}' for k, v in bound.arguments.items()])
+        print(f'\n[>-] {func_name} ({args_str}) --- Start ---')
+
+        t0 = time.time()
+        result = func(*args, **kargs)
+
+        print(f'[>-] {func_name} --- Finished (total time : {time.time() - t0:.2f}s) ---')
+        return result
+    
+    return _command  
+
+def asset_warning_callback(self, context):
+    """Callback function to display a warning message when ading or modifying an asset"""
+    self.warning = ''
+
+    if not self.name:
+        self.warning = 'You need to specify a name'
+        return
+    if not self.catalog:
+        self.warning = 'You need to specify a catalog'
+        return
+
+    lib = get_active_library()
+    action_path = lib.adapter.get_asset_relative_path(self.name, self.catalog)
+    self.path = action_path.as_posix()
+
+    if lib.merge_libraries:
+        prefs = get_addon_prefs()
+        lib = prefs.libraries[lib.store_library]
+
+    if not lib.adapter.get_asset_path(self.name, self.catalog).parents[1].exists():
+        self.warning = 'A new folder will be created'
+
+def get_active_library():
+    '''Get the pref library properties from the active library of the asset browser'''
+    prefs = get_addon_prefs()
+    asset_lib_ref = bpy.context.space_data.params.asset_library_ref
+
+    #Check for merged library
+    for l in prefs.libraries:
+        if l.library_name == asset_lib_ref:
+            return l
+
+def get_active_catalog():
+    '''Get the active catalog path'''
+
+    lib = get_active_library()
+    cat_data = lib.adapter.read_catalog()
+    cat_data = {v['id']:k for k,v in cat_data.items()}
+
+    cat_id = bpy.context.space_data.params.catalog_id
+    if cat_id in cat_data:
+        return cat_data[cat_id]
+
+    return ''
+
+
+def norm_asset_datas(asset_file_datas):
+    ''' Return a new flat list of asset data
+        the filepath keys are merge with the assets keys'''
+    
+    asset_datas = []
+    for asset_file_data in asset_file_datas:
+        asset_file_data = asset_file_data.copy()
+        if 'assets' in asset_file_data:
+
+            assets = asset_file_data.pop('assets')
+            for asset_data in assets:
+
+                asset_datas.append({**asset_file_data, **asset_data})
+
+        else:
+            asset_datas.append(asset_file_data)
+    
+    return asset_datas
+
+def cache_diff(cache, new_cache):
+    '''Compare and return the difference between two asset datas list'''
+
+    #TODO use an id to be able to tell modified asset if renamed
+    #cache = {a.get('id', a['name']) : a for a in norm_asset_datas(cache)}
+    #new_cache = {a.get('id', a['name']) : a for a in norm_asset_datas(new_cache)}
+
+    cache = {f"{a['filepath']}/{a['name']}": a for a in norm_asset_datas(cache)}
+    new_cache = {f"{a['filepath']}/{a['name']}" : a for a in norm_asset_datas(new_cache)}
+
+    assets_added = [v for k, v  in new_cache.items() if k not in cache]
+    assets_removed = [v for k, v  in cache.items() if k not in new_cache]
+    assets_modified = [v for k, v in cache.items() if v not in assets_removed and v!= new_cache[k]]
+
+    if assets_added:
+        print(f'{len(assets_added)} Assets Added \n{tuple(a["name"] for a in assets_added[:10])}\n')
+    if assets_removed:
+        print(f'{len(assets_removed)} Assets Removed \n{tuple(a["name"] for a in assets_removed[:10])}\n')
+    if assets_modified:
+        print(f'{len(assets_modified)} Assets Modified \n{tuple(a["name"] for a in assets_modified[:10])}\n')
+    
+    assets_added = [dict(a, operation='ADD') for a  in assets_added]
+    assets_removed = [dict(a, operation='REMOVE') for a  in assets_removed]
+    assets_modified = [dict(a, operation='MODIFY') for a in assets_modified]
+
+    assets_diff = assets_added + assets_removed + assets_modified
+    if not assets_diff:
+        print('No change in the library')
+
+    return assets_diff
+
+def clean_default_lib():    
+    prefs = bpy.context.preferences
+    
+    if not prefs.filepaths.asset_libraries:
+        print('[>-] No Asset Libraries Filepaths Setted.')
+        return
+
+    lib, lib_id = get_lib_id(
+        library_name='User Library',
+        asset_libraries=prefs.filepaths.asset_libraries
+    )
+    if lib:
+        bpy.ops.preferences.asset_library_remove(index=lib_id)
+
+def get_asset_source(replace_local=False):
+    sp = bpy.context.space_data
+    prefs = bpy.context.preferences.addons[__package__].preferences
+    asset_file_handle = bpy.context.asset_file_handle
+
+    if asset_file_handle is None:
+        return None
+
+    if asset_file_handle.local_id:
+        publish_path = os.path.expandvars(scn.actionlib.get('publish_path'))
+        if not publish_path:
+            print('[>.] No \'Publish Dir\' found. Publish file first.' )
+            return None
+
+        return Path(publish_path)
+
+    asset_library_ref = bpy.context.asset_library_ref
+    source_path = bpy.types.AssetHandle.get_full_library_path(asset_file_handle, asset_library_ref)
+
+    if replace_local:
+        if 'custom' in sp.params.asset_library_ref.lower():
+            actionlib_path = prefs.action.custom_path
+            actionlib_path_local = prefs.action.custom_path_local
+        else:
+            actionlib_path = prefs.action.path
+            actionlib_path_local = prefs.action.path_local
+
+        source_path = re.sub(actionlib_dir_local, actionlib_dir, source_path)
+
+    return source_path
+
+def get_catalog_path(filepath=None):
+    filepath = filepath or bpy.data.filepath
+    filepath = Path(filepath)
+
+    if filepath.is_file():
+        filepath = filepath.parent
+
+    filepath.mkdir(parents=True, exist_ok=True)
+
+    catalog = filepath / 'blender_assets.cats.txt'
+    if not catalog.exists():
+        catalog.touch(exist_ok=False)
+
+    return catalog
+
+
+# def read_catalog(path, key='path'):
+#     cat_data = {}
+
+#     supported_keys = ('path', 'id', 'name')
+
+#     if key not in supported_keys:
+#         raise Exception(f'Not supported key: {key} for read catalog, supported keys are {supported_keys}')
+
+#     for line in Path(path).read_text(encoding="utf-8").split('\n'):
+#         if line.startswith(('VERSION', '#')) or not line:
+#             continue
+
+#         cat_id, cat_path, cat_name = line.split(':')
+
+#         if key == 'id':
+#             cat_data[cat_id] = {'path':cat_path, 'name':cat_name}
+#         elif key == 'path':
+#             cat_data[cat_path] = {'id':cat_id, 'name':cat_name}
+#         elif key =='name':
+#             cat_data[cat_name] = {'id':cat_id, 'path':cat_path}
+    
+#     return cat_data
+
+def read_catalog(path):
+    cat_data = {}
+
+    for line in Path(path).read_text(encoding="utf-8").split('\n'):
+        if line.startswith(('VERSION', '#')) or not line:
+            continue
+
+        cat_id, cat_path, cat_name = line.split(':')
+        cat_data[cat_path] = {'id':cat_id, 'name':cat_name}
+    
+    return cat_data
+
+def write_catalog(path, data):
+    lines = ['VERSION 1', '']
+
+    # Add missing parents catalog
+    norm_data = {}
+    for cat_path, cat_data in data.items():
+        norm_data[cat_path] = cat_data
+        for p in Path(cat_path).parents[:-1]:
+            if p in data or p in norm_data:
+                continue
+            
+            norm_data[p.as_posix()] = {'id': str(uuid.uuid4()), 'name': '-'.join(p.parts)}
+
+    for cat_path, cat_data in sorted(norm_data.items()):
+        cat_name = cat_data['name'].replace('/', '-')
+        lines.append(f"{cat_data['id']}:{cat_path}:{cat_name}")
+    
+    print(f'Catalog writen at: {path}')
+    Path(path).write_text('\n'.join(lines), encoding="utf-8")
+
+def create_catalog_file(json_path : str|Path, keep_existing_category : bool = True):
+    '''create asset catalog file from json
+    if catalog already exists, keep existing catalog uid'''
+
+    json_path = Path(json_path)
+    # if not json.exists(): return
+    assert json_path.exists(), 'Json not exists !'
+    
+    category_datas = json.loads(json_path.read_text(encoding="utf-8"))
+    
+    catalog_path = json_path.parent / 'blender_assets.cats.txt'
+    catalog_data = {}
+    if catalog_path.exists():
+        catalog_data = read_catalog(catalog_path)
+        ## retrun a format catalog_data[path] = {'id':id, 'name':name}
+        ## note: 'path' in catalog is 'name' in category_datas
+    
+    catalog_lines = ['VERSION 1', '']
+
+    ## keep existing
+    for c in category_datas:
+        # keep same catalog line for existing category keys
+        if keep_existing_category and catalog_data.get(c['name']):
+            print(c['name'], 'category exists')
+            cat = catalog_data[c['name']] #get 
+            catalog_lines.append(f"{cat['id']}:{c['name']}:{cat['name']}")
+        else:
+            print(c['name'], 'new category')
+            # add new category 
+            catalog_lines.append(f"{c['id']}:{c['name']}:{c['name'].replace('/', '-')}")
+    
+    ## keep category that are non-existing in json ?
+    if keep_existing_category:
+        for k in catalog_data.keys():
+            if next((c['name'] for c in category_datas if c['name'] == k), None):
+                continue
+            print(k, 'category not existing in json')
+            cat = catalog_data[k]
+            # rebuild existing line
+            catalog_lines.append(f"{cat['id']}:{k}:{cat['name']}")
+
+    ## write_text overwrite the file
+    catalog_path.write_text('\n'.join(catalog_lines), encoding="utf-8")
+
+    print(f'Catalog saved at: {catalog_path}')
+
+    return 
+
+def clear_env_libraries():
+    print('clear_env_libraries')
+
+    prefs = get_addon_prefs()
+    asset_libraries = bpy.context.preferences.filepaths.asset_libraries
+
+    for env_lib in prefs.env_libraries:
+        name = env_lib.get('asset_library')
+        if not name:
+            continue
+        
+        asset_lib = asset_libraries.get(name)
+        if not asset_lib:
+            continue
+
+        index = list(asset_libraries).index(asset_lib)
+        bpy.ops.preferences.asset_library_remove(index=index)
+    
+    prefs.env_libraries.clear()
+
+'''
+    env_libs = get_env_libraries()
+    paths = [Path(l['path']).resolve().as_posix() for n, l in env_libs.items()]
+    
+    for i, l in reversed(enumerate(libs)):
+        lib_path = Path(l.path).resolve().as_posix()
+
+        if (l.name in env_libs or lib_path in paths):
+            libs.remove(i)
+            '''
+            
+def set_env_libraries(path=None) -> list:
+    '''Read the environments variables and create the libraries'''
+
+    #from asset_library.prefs import AssetLibraryOptions
+    prefs = get_addon_prefs()
+    path = path or prefs.config_directory
+
+    #print('Read', path)
+    library_data = read_file(path)
+
+    clear_env_libraries()
+
+    if not library_data:
+        return
+
+    libs = []
+
+    for lib_info in library_data:
+        lib = prefs.env_libraries.add()
+
+        lib.set_dict(lib_info)
+
+        libs.append(lib)
+
+    return libs
+
+'''
+def get_env_libraries():
+    env_libraries = {}
+
+    for k, v in os.environ.items():
+        if not re.findall('ASSET_LIBRARY_[0-9]', k):
+            continue
+
+        lib_infos = v.split(os.pathsep)
+
+        if len(lib_infos) == 5:        
+            name, data_type, tpl, src_path, bdl_path = lib_infos
+        elif len(lib_infos) == 4:
+            name, data_type, tpl, src_path = lib_infos
+            bdl_path = ''
+        else:
+            print(f'Wrong env key {k}', lib_infos)
+            continue
+        
+        source_type = 'TEMPLATE'
+        if tpl.lower().endswith(('.json', '.yml', 'yaml')):
+            source_type = 'DATA_FILE'
+
+        env_libraries[name] = {
+            'data_type': data_type, 
+            'source_directory': src_path, 
+            'bundle_directory': bdl_path,
+            'source_type': source_type,
+            'template': tpl,
+            }
+    
+    return env_libraries
+'''
+
+
+
+
+
+def resync_lib(name, waiting_time):
+    bpy.app.timers.register(
+        lambda: bpy.ops.assetlib.synchronize(only_recent=True, name=name),
+        first_interval=waiting_time
+    )
+
+
+
+'''
+def set_assetlib_paths():
+    prefs = bpy.context.preferences
+
+    assetlib_name = 'Assets'
+    assetlib = prefs.filepaths.asset_libraries.get(assetlib_name)
+
+    if not assetlib:
+        bpy.ops.preferences.asset_library_add(directory=str(assetlib_path))
+        assetlib = prefs.filepaths.asset_libraries[-1]
+        assetlib.name = assetlib_name
+    
+    assetlib.path = str(actionlib_dir)
+
+def set_actionlib_paths():
+    prefs = bpy.context.preferences
+
+    actionlib_name = 'Action Library'
+    actionlib_custom_name = 'Action Library Custom'
+
+    actionlib = prefs.filepaths.asset_libraries.get(actionlib_name)
+
+    if not assetlib:
+        bpy.ops.preferences.asset_library_add(directory=str(assetlib_path))
+        assetlib = prefs.filepaths.asset_libraries[-1]
+        assetlib.name = assetlib_name
+
+    actionlib_dir = get_actionlib_dir(custom=custom)
+    local_actionlib_dir = get_actionlib_dir(local=True, custom=custom)
+
+    if local_actionlib_dir:
+        actionlib_dir = local_actionlib_dir
+
+    if actionlib_name not in prefs.filepaths.asset_libraries:
+        bpy.ops.preferences.asset_library_add(directory=str(actionlib_dir))
+
+    #lib, lib_id = get_lib_id(
+    #    library_path=actionlib_dir,
+    #    asset_libraries=prefs.filepaths.asset_libraries
+    #)
+
+    #if not lib:
+    #    print(f'Cannot set dir for {actionlib_name}')
+    #    return
+
+    prefs.filepaths.asset_libraries[lib_id].name = actionlib_name
+    #prefs.filepaths.asset_libraries[lib_id].path = str(actionlib_dir)
+    '''
+
+
+
+
+
+
+
+
+
+
+
+

common/synchronize.py

@@ -0,0 +1,42 @@
+
+import argparse
+import fnmatch
+import importlib.util
+import json
+import re
+import subprocess
+import sys
+
+from pathlib import Path
+
+# import module utils without excuting __init__
+spec = importlib.util.spec_from_file_location(
+    "utils", Path(__file__).parent/"file_utils.py"
+)
+utils = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(utils)
+
+
+def synchronize(src, dst, only_new=False, only_recent=False):
+
+    excludes=['*.sync-conflict-*', '.*']
+    includes=['*.blend', 'blender_assets.cats.txt']
+    
+    utils.copy_dir(
+        src, dst,
+        only_new=only_new, only_recent=only_recent,
+        excludes=excludes, includes=includes
+    )
+
+
+if __name__ == '__main__' :
+    parser = argparse.ArgumentParser(description='Add Comment To the tracker',
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--src')
+    parser.add_argument('--dst')
+    parser.add_argument('--only-new', type=json.loads, default='false')
+    parser.add_argument('--only-recent', type=json.loads, default='false')
+
+    args = parser.parse_args()
+    synchronize(**vars(args))

common/template.py

@@ -0,0 +1,89 @@
+import re
+import os
+from pathlib import Path
+from fnmatch import fnmatch
+from glob import glob
+
+
+class Template:
+    field_pattern = re.compile(r'{(\w+)\*{0,2}}')
+    field_pattern_recursive = re.compile(r'{(\w+)\*{2}}')
+
+    def __init__(self, template):
+        #asset_data_path = Path(lib_path) / ASSETLIB_FILENAME
+
+        self.template = template
+
+    @property
+    def glob_pattern(self):
+        pattern = self.field_pattern_recursive.sub('**', self.template)
+        pattern = self.field_pattern.sub('*', pattern)
+        return pattern
+
+    @property
+    def re_pattern(self):
+        pattern = self.field_pattern_recursive.sub('([\\\w -_.\/]+)', self.template)
+        pattern = self.field_pattern.sub('([\\\w -_.]+)', pattern)
+        pattern = pattern.replace('?', '.')
+        pattern = pattern.replace('*', '.*')
+
+        return re.compile(pattern)
+
+    @property
+    def fields(self):
+        return self.field_pattern.findall(self.template)
+        #return [f or '0' for f in fields]
+
+    def parse(self, path):
+
+        path = Path(path).as_posix()
+
+        res = self.re_pattern.findall(path)
+        if not res:
+            print('Could not parse {path} with {self.re_pattern}')
+            return {}
+
+        fields = self.fields
+
+        if len(fields) == 1:
+            field_values = res
+        else:
+            field_values = res[0]
+
+        return {k:v for k,v in zip(fields, field_values)}
+
+    def format(self, data=None, **kargs):
+
+        #print('format', self.template, data, kargs)
+
+        data = {**(data or {}), **kargs}
+
+        try:
+            path = self.template.format(**data)
+        except KeyError: 
+            print(f'Cannot format {self.template} with {data}')
+            return
+
+        path = os.path.expandvars(path)
+        return Path(path)
+
+    def glob(self, directory, pattern=None):
+        '''If pattern is given it need to be absolute'''
+        if pattern is None:
+            pattern = Path(directory, self.glob_pattern).as_posix()
+
+        for entry in os.scandir(directory):
+            entry_path = Path(entry.path)
+            if entry.is_file() and fnmatch(entry_path.as_posix(), pattern):
+                yield entry_path
+            elif entry.is_dir():
+                yield from self.glob(entry.path, pattern)
+
+    def find(self, data, **kargs):
+        pattern = self.format(data, **kargs)
+        paths = glob(pattern.as_posix())
+        if paths:
+            return Path(paths[0])
+
+    def __repr__(self):
+        return f'Template({self.template})'

constants.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+
+DATA_TYPE_ITEMS = [
+    ("ACTION", "Action", "", "ACTION", 1),
+    ("COLLECTION", "Collection", "", "OUTLINER_OB_GROUP_INSTANCE", 2),
+    ("FILE", "File", "", "FILE", 3)
+]
+DATA_TYPES = [i[0] for i in DATA_TYPE_ITEMS]
+ICONS = {identifier: icon for identifier, name, description, icon, number in DATA_TYPE_ITEMS}
+
+ASSETLIB_FILENAME = "blender_assets.libs.json"
+MODULE_DIR = Path(__file__).parent
+RESOURCES_DIR = MODULE_DIR / 'resources'
+ADAPTER_DIR = MODULE_DIR / 'adapters'

file/__init__.py

@@ -0,0 +1,18 @@
+
+from asset_library.file import (
+    operators, gui, keymaps)
+
+if 'bpy' in locals():
+    import importlib
+
+    importlib.reload(operators)
+    importlib.reload(gui)
+    importlib.reload(keymaps)
+
+def register():
+    operators.register()
+    keymaps.register()
+
+def unregister():
+    operators.unregister()
+    keymaps.unregister()

file/bundle.py

@@ -0,0 +1,171 @@
+
+import argparse
+import sys
+import json
+from pathlib import Path
+import bpy
+import re
+import uuid
+from itertools import groupby
+
+from asset_library.constants import ASSETLIB_FILENAME, MODULE_DIR
+from asset_library.common.bl_utils import thumbnail_blend_file
+from asset_library.common.functions import (read_catalog, get_catalog_path, 
+command, write_catalog)
+
+
+
+
+@command
+def bundle_library(source_directory, bundle_directory, asset_description_template, thumbnail_template, 
+        template=None, data_file=None):
+
+    field_pattern = r'{(\w+)}'
+    asset_data_path = Path(bundle_directory) / ASSETLIB_FILENAME
+
+    glob_pattern = re.sub(field_pattern, '*', template)
+    re_pattern = re.sub(field_pattern, r'([\\w -_.]+)', template)
+    re_pattern = re_pattern.replace('?', '.')
+
+    field_names = re.findall(field_pattern, template)
+
+    asset_file_datas = []
+    for f in sorted(Path(source_directory).glob(glob_pattern)):
+        rel_path = f.relative_to(source_directory).as_posix()
+
+        field_values = re.findall(re_pattern, rel_path)[0]
+        field_data = {k:v for k,v in zip(field_names, field_values)}
+
+        name = field_data.get('name', f.stem)
+        thumbnail = (f / thumbnail_template.format(name=name)).resolve()
+        asset_data = (f / asset_description_template.format(name=name)).resolve()
+
+        catalogs = sorted([v for k,v in sorted(field_data.items()) if k.isdigit()])
+        catalogs = [c.replace('_', ' ').title() for c in catalogs]
+
+        if not thumbnail.exists():
+            thumbnail_blend_file(f, thumbnail)
+
+        asset_data = {
+            'catalog' : '/'.join(catalogs),
+            'preview' : thumbnail.as_posix(), #'./' + bpy.path.relpath(str(thumbnail), start=str(f))[2:],
+            'filepath' : f.as_posix(), #'./' + bpy.path.relpath(str(f), start=str(asset_data_path))[2:],
+            'name': name,
+            'tags': [],
+            'metadata': {'filepath': f.as_posix()}
+        }
+
+        asset_file_datas.append(asset_data)
+
+    # Write json data file to store all asset found
+    print(f'Writing asset data file to, {asset_data_path}')
+    asset_data_path.write_text(json.dumps(asset_file_datas, indent=4))
+
+    #script = MODULE_DIR / 'common' / 'bundle_blend.py'
+    #cmd = [bpy.app.binary_path, '--python', str(script), '--', '--filepath', str(filepath)]
+    #print(cmd)
+    #subprocess.call(cmd)
+
+@command
+def bundle_blend(filepath, depth=0):
+    #print('Bundle Blend...')
+    filepath = Path(filepath)
+
+    #asset_data_path = get_asset_datas_file(filepath)
+
+    asset_data_path = filepath / ASSETLIB_FILENAME
+    blend_name = filepath.name.replace(' ', '_').lower()
+    blend_path = (filepath / blend_name).with_suffix('.blend')
+
+    if not asset_data_path.exists():
+        raise Exception(f'The file {asset_data_path} not exist')
+
+    catalog_path = get_catalog_path(filepath)
+    catalog_data = read_catalog(catalog_path)
+
+    asset_file_data = json.loads(asset_data_path.read_text())
+    #asset_file_data = {i['catalog']:i for i in asset_file_data}
+
+    if depth == 0:
+        groups = [asset_file_data]
+    else:
+        asset_file_data.sort(key=lambda x :x['catalog'].split('/')[:depth])
+        groups = groupby(asset_file_data, key=lambda x :x['catalog'].split('/')[:depth])
+
+    #progress = 0
+    total_assets = len(asset_file_data)
+
+    i = 0
+    for sub_path, asset_datas in groups:
+        bpy.ops.wm.read_homefile(use_empty=True)
+
+        for asset_data in asset_datas:
+            blend_name = sub_path[-1].replace(' ', '_').lower()
+            blend_path = Path(filepath, *sub_path, blend_name).with_suffix('.blend')
+
+            if i % int(total_assets / 100) == 0:
+                print(f'Progress: {int(i / total_assets * 100)}')
+
+            col = bpy.data.collections.new(name=asset_data['name'])
+
+            # Seems slow
+            #bpy.context.scene.collection.children.link(col)
+            col.asset_mark()
+
+            with bpy.context.temp_override(id=col):
+                bpy.ops.ed.lib_id_load_custom_preview(
+                    filepath=asset_data['preview']
+                )
+
+            col.asset_data.description = asset_data.get('description', '')
+
+            catalog_name = asset_data['catalog']
+            catalog = catalog_data.get(catalog_name)
+            if not catalog:
+                catalog = {'id': str(uuid.uuid4()), 'name': catalog_name}
+                catalog_data[catalog_name] = catalog
+
+            col.asset_data.catalog_id = catalog['id']
+
+            for k, v in asset_data.get('metadata', {}).items():
+                col.asset_data[k] = v
+            
+            i += 1
+
+        print(f'Saving Blend to {blend_path}')
+
+        blend_path.mkdir(exist_ok=True, parents=True)
+        bpy.ops.wm.save_as_mainfile(filepath=str(blend_path), compress=True)
+        
+    write_catalog(catalog_path, catalog_data)
+
+    bpy.ops.wm.quit_blender()
+
+
+if __name__ == '__main__' :
+    parser = argparse.ArgumentParser(description='bundle_blend',
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--source-path')
+    parser.add_argument('--bundle-path')
+    parser.add_argument('--asset-data-template')
+    parser.add_argument('--thumbnail-template')
+    parser.add_argument('--template', default=None)
+    parser.add_argument('--data-file', default=None)
+    parser.add_argument('--depth', default=0, type=int)
+
+    if '--' in sys.argv :
+        index = sys.argv.index('--')
+        sys.argv = [sys.argv[index-1], *sys.argv[index+1:]]
+
+    args = parser.parse_args()
+
+    bundle_library(
+        source_directory=args.source_directory,
+        bundle_directory=args.bundle_directory,
+        asset_description_template=args.asset_description_template,
+        thumbnail_template=args.thumbnail_template,
+        template=args.template,
+        data_file=args.data_file)
+
+    bundle_blend(filepath=args.bundle_directory, depth=args.depth)

file/gui.py

@@ -0,0 +1,30 @@
+
+import bpy
+from pathlib import Path
+
+from bpy.types import (
+    Context,
+    Header,
+    Menu,
+    Panel,
+    UIList,
+    WindowManager,
+    WorkSpace,
+)
+
+from bpy_extras import asset_utils
+from asset_library.common.bl_utils import get_object_libraries, get_addon_prefs
+
+
+def draw_context_menu(self, context):
+    layout = self.layout
+    #asset = context.active_file
+
+    layout.operator("assetlib.open_blend_file", text="Open Blend File")#.filepath = asset.asset_data['filepath']
+
+
+def draw_header(layout):
+    '''Draw the header of the Asset Browser Window'''
+
+    layout.separator()
+    #layout.operator("actionlib.store_anim_pose", text='Add Action', icon='FILE_NEW')

file/keymaps.py

@@ -0,0 +1,25 @@
+
+
+from typing import List, Tuple
+
+import bpy
+from bpy.app.handlers import persistent
+
+addon_keymaps: List[Tuple[bpy.types.KeyMap, bpy.types.KeyMapItem]] = []
+
+def register() -> None:
+    wm = bpy.context.window_manager
+    if not wm.keyconfigs.addon:
+        # This happens when Blender is running in the background.
+        return
+
+    km = wm.keyconfigs.addon.keymaps.new(name="File Browser Main", space_type="FILE_BROWSER")
+
+    kmi = km.keymap_items.new("assetlib.open_blend_file", "LEFTMOUSE", "DOUBLE_CLICK")
+    addon_keymaps.append((km, kmi))
+
+
+def unregister() -> None:
+    for km, kmi in addon_keymaps:
+        km.keymap_items.remove(kmi)
+    addon_keymaps.clear()

file/operators.py

@@ -0,0 +1,57 @@
+
+import bpy
+from bpy.types import Context, Operator
+from bpy_extras import asset_utils
+from bpy.props import StringProperty
+from typing import List, Tuple, Set
+
+from asset_library.common.file_utils import (open_blender_file, 
+    synchronize, open_blender_file)
+
+from asset_library.common.functions import get_active_library
+
+
+class ASSETLIB_OT_open_blend_file(Operator):
+    bl_idname = "assetlib.open_blend_file"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_label = 'Open Blender File'
+    bl_description = 'Open blender file'
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            cls.poll_message_set("Current editor is not an asset browser")
+            return False
+        
+        lib = get_active_library()
+        if not lib or lib.data_type != 'FILE':
+            return False
+        
+        if not context.active_file or 'filepath' not in context.active_file.asset_data:
+            cls.poll_message_set("Has not filepath property")
+            return False
+        
+        return True
+
+    def execute(self, context: Context) -> Set[str]:
+        
+        lib = get_active_library()
+        print(lib, lib.data_type)
+
+        filepath = context.active_file.asset_data['filepath']
+        open_blender_file(filepath)
+
+        return {'FINISHED'}
+
+    
+classes = (
+    ASSETLIB_OT_open_blend_file,
+)
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+
+def unregister():
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)

gui.py

@@ -0,0 +1,333 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Action Library - GUI definition.
+"""
+
+import bpy
+from pathlib import Path
+
+from bpy.types import (
+    AssetHandle,
+    Context,
+    Header,
+    Menu,
+    Panel,
+    UIList,
+    WindowManager,
+    WorkSpace,
+)
+
+from bpy_extras import asset_utils
+from asset_library.common.bl_utils import (
+    get_addon_prefs,
+    get_object_libraries,
+)
+
+from asset_library.common.functions import (
+    get_active_library
+)
+
+
+
+def pose_library_panel_poll():
+    return bpy.context.object and bpy.context.object.mode == 'POSE'
+
+class PoseLibraryPanel:
+    @classmethod
+    def pose_library_panel_poll(cls, context: Context) -> bool:
+        return bool(
+            context.object
+            and context.object.mode == 'POSE'
+        )
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return cls.pose_library_panel_poll(context);
+
+
+class AssetLibraryMenu:
+    @classmethod
+    def poll(cls, context):
+        from bpy_extras.asset_utils import SpaceAssetInfo
+        return SpaceAssetInfo.is_asset_browser_poll(context)
+
+
+class ASSETLIB_PT_libraries(Panel):
+    bl_label = "Libraries"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    bl_category = 'Item'
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return context.object and get_object_libraries(context.object)
+
+    def draw(self, context: Context) -> None:
+        layout = self.layout
+
+        for f in get_object_libraries(context.object):
+            row = layout.row(align=True)
+            row.label(text=f)
+            row.operator("assetlib.open_blend", icon='FILE_BLEND', text='').filepath = f
+
+'''
+class ASSETLIB_PT_pose_library_usage(Panel):
+    bl_space_type = 'FILE_BROWSER'
+    bl_region_type = "TOOLS"
+    bl_label = "Action Library"
+    # asset_categories = {'ANIMATIONS'}
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        sp = context.space_data
+
+        if not context.object or not context.object.mode == 'POSE':
+            return False
+
+        if not (sp and sp.type == 'FILE_BROWSER' and sp.browse_mode == 'ASSETS'):
+            return False
+
+        return True
+
+    def draw(self, context: Context) -> None:
+        layout = self.layout
+        wm = context.window_manager
+
+        sp = context.space_data
+        sp.params.asset_library_ref
+
+        if sp.params.asset_library_ref == 'LOCAL':
+            col = layout.column(align=True)
+            row = col.row(align=True)
+            row.operator("poselib.create_pose_asset", text="Create Pose", icon='POSE_HLT').activate_new_action = False
+            row.operator("actionlib.replace_pose", text='Replace Pose', icon='FILE_REFRESH')
+            col.operator("actionlib.create_anim_asset", text="Create Anim", icon='ANIM')
+            
+            col.separator()
+            row = col.row(align=True)
+            row.operator("actionlib.edit_action", text='Edit Action', icon='ACTION')
+            row.operator("actionlib.clear_action", text='Finish Edit', icon='CHECKBOX_HLT')
+            
+            col.separator()
+            col.operator("actionlib.generate_preview", icon='RESTRICT_RENDER_OFF', text="Generate Thumbnail")
+            col.operator("actionlib.update_action_data", icon='FILE_TEXT', text="Update Action Data")
+        else:
+            col = layout.column(align=True)
+            row = col.row(align=True)
+            row.operator("actionlib.store_anim_pose", text='Store Anim/Pose', icon='ACTION')
+'''
+
+
+class ASSETLIB_PT_pose_library_editing(PoseLibraryPanel, asset_utils.AssetBrowserPanel, Panel):
+    bl_space_type = 'FILE_BROWSER'
+    bl_region_type = "TOOL_PROPS"
+    bl_label = "Metadata"
+    #bl_options = {'HIDE_HEADER'}
+    # asset_categories = {'ANIMATIONS'}
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        sp = context.space_data
+
+        if not (sp and sp.type == 'FILE_BROWSER' and sp.browse_mode == 'ASSETS'):
+            return False
+
+        if not (context.active_file and context.active_file.asset_data):
+            return False
+
+        return True
+
+    def draw(self, context: Context) -> None:
+        layout = self.layout
+
+        layout.use_property_split = True
+        asset_data = context.active_file.asset_data
+        metadata = ['camera', 'is_single_frame', 'rest_pose']
+        
+        if 'camera' in asset_data.keys():
+            layout.prop(asset_data, f'["camera"]', text='Camera', icon='CAMERA_DATA') 
+        if 'is_single_frame' in asset_data.keys():
+            layout.prop(asset_data, f'["is_single_frame"]', text='Is Single Frame') 
+        if 'rest_pose' in asset_data.keys():
+            layout.prop(asset_data, f'["rest_pose"]', text='Rest Pose', icon='ACTION') 
+        if 'filepath' in asset_data.keys():
+            layout.prop(asset_data, f'["filepath"]', text='Filepath') 
+
+
+class ASSETLIB_MT_context_menu(AssetLibraryMenu, Menu):
+    bl_label = "Asset Library Menu"
+    
+    @classmethod
+    def poll(cls, context):
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            cls.poll_message_set("Current editor is not an asset browser")
+            return False
+        
+        prefs = get_addon_prefs()
+        asset_lib_ref = context.space_data.params.asset_library_ref
+
+        lib = get_active_library()
+        if not lib:
+            return False
+        
+        return True
+
+    def draw(self, context):
+        lib = get_active_library()
+        lib.adapter.draw_context_menu(self.layout)
+
+
+def is_option_region_visible(context, space):
+    from bpy_extras.asset_utils import SpaceAssetInfo
+
+    if SpaceAssetInfo.is_asset_browser(space):
+        pass
+    # For the File Browser, there must be an operator for there to be options
+    # (irrelevant for the Asset Browser).
+    elif not space.active_operator:
+        return False
+
+    for region in context.area.regions:
+        if region.type == 'TOOL_PROPS' and region.width <= 1:
+            return False
+
+    return True
+
+
+def draw_assetbrowser_header(self, context):
+    lib = get_active_library()
+
+    if not lib:
+        bpy.types.FILEBROWSER_HT_header._draw_asset_browser_buttons(self, context)
+        return
+
+    space_data = context.space_data
+    params = context.space_data.params
+
+    row = self.layout.row(align=True)
+    row.separator()
+
+    row.operator("assetlib.bundle", icon='UV_SYNC_SELECT', text='').name = lib.name
+    #op
+    #op.clean = False
+    #op.only_recent = True
+
+    lib.adapter.draw_header(row)
+
+    if context.selected_files and context.active_file:
+        row.separator()
+        row.label(text=context.active_file.name)
+
+    row.separator_spacer()
+
+    sub = row.row()
+    sub.ui_units_x = 10
+    sub.prop(params, "filter_search", text="", icon='VIEWZOOM')
+
+    row.separator_spacer()
+
+    row.prop_with_popover(
+        params,
+        "display_type",
+        panel="ASSETBROWSER_PT_display",
+        text="",
+        icon_only=True,
+    )
+
+    row.operator(
+        "screen.region_toggle",
+        text="",
+        icon='PREFERENCES',
+        depress=is_option_region_visible(context, space_data)
+    ).region_type = 'TOOL_PROPS'
+
+
+### Messagebus subscription to monitor asset library changes.
+_msgbus_owner = object()
+
+def _on_asset_library_changed() -> None:
+    """Update areas when a different asset library is selected."""
+    refresh_area_types = {'DOPESHEET_EDITOR', 'VIEW_3D'}
+    for win in bpy.context.window_manager.windows:
+        for area in win.screen.areas:
+            if area.type not in refresh_area_types:
+                continue
+
+            area.tag_redraw()
+
+def register_message_bus() -> None:
+
+    bpy.msgbus.subscribe_rna(
+        key=(bpy.types.FileAssetSelectParams, "asset_library_ref"),
+        owner=_msgbus_owner,
+        args=(),
+        notify=_on_asset_library_changed,
+        options={'PERSISTENT'},
+    )
+
+def unregister_message_bus() -> None:
+    bpy.msgbus.clear_by_owner(_msgbus_owner)
+
+@bpy.app.handlers.persistent
+def _on_blendfile_load_pre(none, other_none) -> None:
+    # The parameters are required, but both are None.
+    unregister_message_bus()
+
+@bpy.app.handlers.persistent
+def _on_blendfile_load_post(none, other_none) -> None:
+    # The parameters are required, but both are None.
+    register_message_bus()
+
+
+classes = (
+    ASSETLIB_PT_pose_library_editing,
+    #ASSETLIB_PT_pose_library_usage,
+    ASSETLIB_MT_context_menu,
+    ASSETLIB_PT_libraries
+)
+
+
+def register() -> None:
+    for cls in classes:
+        bpy.utils.register_class(cls)
+
+    bpy.types.FILEBROWSER_HT_header._draw_asset_browser_buttons = bpy.types.FILEBROWSER_HT_header.draw_asset_browser_buttons
+    bpy.types.FILEBROWSER_HT_header.draw_asset_browser_buttons = draw_assetbrowser_header
+
+    #WorkSpace.active_pose_asset_index = bpy.props.IntProperty(
+    #    name="Active Pose Asset",
+    #    # TODO explain which list the index belongs to, or how it can be used to get the pose.
+    #    description="Per workspace index of the active pose asset"
+    #)
+    # Register for window-manager. This is a global property that shouldn't be
+    # written to files.
+    #WindowManager.pose_assets = bpy.props.CollectionProperty(type=AssetHandle)
+
+    # bpy.types.UI_MT_list_item_context_menu.prepend(pose_library_list_item_context_menu)
+    # bpy.types.ASSETLIB_MT_context_menu.prepend(pose_library_list_item_context_menu)
+    # bpy.types.ACTIONLIB_MT_context_menu.prepend(pose_library_list_item_context_menu)
+    #bpy.types.ASSETBROWSER_MT_editor_menus.append(draw_assetbrowser_header)
+
+    register_message_bus()
+    bpy.app.handlers.load_pre.append(_on_blendfile_load_pre)
+    bpy.app.handlers.load_post.append(_on_blendfile_load_post)
+
+
+def unregister() -> None:
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)
+
+    bpy.types.FILEBROWSER_HT_header.draw_asset_browser_buttons = bpy.types.FILEBROWSER_HT_header._draw_asset_browser_buttons
+    del bpy.types.FILEBROWSER_HT_header._draw_asset_browser_buttons
+
+    unregister_message_bus()
+
+    #del WorkSpace.active_pose_asset_index
+    #del WindowManager.pose_assets
+
+    # bpy.types.UI_MT_list_item_context_menu.remove(pose_library_list_item_context_menu)
+    # bpy.types.ASSETLIB_MT_context_menu.remove(pose_library_list_item_context_menu)
+    # bpy.types.ACTIONLIB_MT_context_menu.remove(pose_library_list_item_context_menu)
+    #bpy.types.ASSETBROWSER_MT_editor_menus.remove(draw_assetbrowser_header)

keymaps.py

@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+from typing import List, Tuple
+
+import bpy
+from bpy.app.handlers import persistent
+
+addon_keymaps: List[Tuple[bpy.types.KeyMap, bpy.types.KeyMapItem]] = []
+
+
+@persistent
+def copy_play_anim(dummy):
+    wm = bpy.context.window_manager
+    km = wm.keyconfigs.addon.keymaps.new(name="File Browser Main", space_type="FILE_BROWSER")
+
+    km_frames = wm.keyconfigs.user.keymaps.get('Frames')
+    if km_frames:
+        play = km_frames.keymap_items.get('screen.animation_play')
+        if play:
+            kmi = km.keymap_items.new(
+                "assetlib.play_preview", 
+                play.type, play.value,
+                any=play.any, shift=play.shift, ctrl=play.ctrl, alt=play.alt,
+                oskey=play.oskey, key_modifier=play.key_modifier,
+                )
+            addon_keymaps.append((km, kmi))
+
+
+def register() -> None:
+    wm = bpy.context.window_manager
+    if wm.keyconfigs.addon is None:
+        # This happens when Blender is running in the background.
+        return
+
+    km = wm.keyconfigs.addon.keymaps.new(name="File Browser Main", space_type="FILE_BROWSER")
+
+    kmi = km.keymap_items.new("wm.call_menu", "RIGHTMOUSE", "PRESS")
+    kmi.properties.name = 'ASSETLIB_MT_context_menu'
+    addon_keymaps.append((km, kmi))
+
+    kmi = km.keymap_items.new("assetlib.play_preview", "SPACE", "PRESS")
+    addon_keymaps.append((km, kmi))
+
+    # km = addon.keymaps.new(name = "Grease Pencil Stroke Paint Mode", space_type = "EMPTY")
+    # kmi = km.keymap_items.new('wm.call_panel', type='F2', value='PRESS')
+
+    if 'copy_play_anim' not in [hand.__name__ for hand in bpy.app.handlers.load_post]:
+        bpy.app.handlers.load_post.append(copy_play_anim)
+
+def unregister() -> None:
+    # Clear shortcuts from the keymap.
+    if 'copy_play_anim' in [hand.__name__ for hand in bpy.app.handlers.load_post]:
+        bpy.app.handlers.load_post.remove(copy_play_anim)
+ 
+    for km, kmi in addon_keymaps:
+        km.keymap_items.remove(kmi)
+    addon_keymaps.clear()

operators.py

@@ -0,0 +1,562 @@
+
+
+from typing import Set
+#import shutil
+from pathlib import Path
+import subprocess
+import importlib
+import time
+import json
+
+import bpy
+from bpy_extras import asset_utils
+from bpy.types import Context, Operator
+from bpy.props import (
+    BoolProperty, 
+    EnumProperty, 
+    StringProperty, 
+    IntProperty)
+
+#from asset_library.constants import (DATA_TYPES, DATA_TYPE_ITEMS, MODULE_DIR)
+import asset_library
+from asset_library.common.bl_utils import (
+    get_addon_prefs, 
+    get_bl_cmd, 
+    #suitable_areas, 
+    refresh_asset_browsers,
+    load_datablocks)
+
+from asset_library.common.file_utils import open_blender_file, synchronize
+from asset_library.common.functions import get_active_library, asset_warning_callback
+
+from textwrap import dedent
+from tempfile import gettempdir
+
+
+class ASSETLIB_OT_clear_asset(Operator):
+    bl_idname = "assetlib.clear_asset"
+    bl_options = {"REGISTER", "UNDO", "INTERNAL"}
+    bl_label = 'Clear Asset'
+    bl_description = 'Clear Selected Assets'
+
+    @classmethod
+    def poll(cls, context):
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            return False
+
+        sp = context.space_data
+        if sp.params.asset_library_ref == 'LOCAL':
+            return False
+
+        return True
+
+    def execute(self, context: Context) -> Set[str]:
+        asset = context.active_file
+    
+        lib = get_active_library()
+
+        filepath = lib.adapter.format_path(asset.asset_data['filepath'])
+        asset_image = lib.adapter.get_path('image', asset.name, filepath)
+        asset_video = lib.adapter.get_path('video', asset.name, filepath)
+
+        if filepath:
+            if filepath.exists():
+                filepath.unlink()
+        if asset_image:
+            asset_image.unlink()
+        if asset_video:
+            asset_video.unlink()
+        #open_blender_file(filepath)
+
+        bpy.ops.assetlib.bundle(name=lib.name, blocking=True)
+
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_edit_data(Operator):
+    bl_idname = "assetlib.edit_data"
+    bl_label = "Edit Asset Data"
+    bl_description = "Edit Current Asset Data"
+    bl_options = {"REGISTER", "UNDO"}
+
+    warning: StringProperty(name='')
+    path: StringProperty(name='Path')
+    catalog: StringProperty(name='Catalog', update=asset_warning_callback, options={'TEXTEDIT_UPDATE'})
+    name: StringProperty(name='Name', update=asset_warning_callback, options={'TEXTEDIT_UPDATE'})
+    tags: StringProperty(name='Tags', description='Tags need to separate with a comma (,)')
+
+    @classmethod
+    def poll(cls, context):
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            return False
+        return True
+
+    def execute(self, context: Context) -> Set[str]:
+        prefs = get_addon_prefs()
+
+        lib = get_active_library()
+        if lib.merge_libraries:
+            lib = prefs.libraries[lib.store_library]
+
+        new_name = lib.adapter.norm_file_name(self.name)
+        new_asset_path = lib.adapter.get_asset_path(name=new_name, catalog=self.catalog)
+
+        self.old_asset_path.unlink()
+        lib.adapter.write_asset(asset=self.asset, asset_path=new_asset_path)
+
+        if self.old_image_path.exists():
+            new_img_path = lib.adapter.get_path('image', new_name, new_asset_path)
+            self.old_image_path.rename(new_img_path)
+
+        if self.old_video_path.exists():
+            new_video_path = lib.adapter.get_path('video', new_name, new_asset_path)
+            self.old_video_path.rename(new_video_path)
+
+        if self.old_asset_description_path.exists():
+            self.old_asset_description_path.unlink()
+
+        new_asset_description = lib.adapter.get_asset_description(
+            asset=self.asset,
+            catalog=self.catalog,
+            modified=time.time_ns()
+        )
+
+        lib.adapter.write_asset_description(new_asset_description, new_asset_path)
+
+        if not list(self.old_asset_path.parent.iterdir()):
+            self.old_asset_path.parent.rmdir()
+
+        diff_path = Path(bpy.app.tempdir, 'diff.json')
+
+        diff = [dict(self.old_asset_description, operation='REMOVE')]
+        diff += [dict(lib.adapter.norm_asset_datas([new_asset_description])[0], operation='ADD')]
+
+        diff_path.write_text(json.dumps(diff, indent=4), encoding='utf-8')
+
+        bpy.ops.assetlib.bundle(name=lib.name, diff=str(diff_path), blocking=True)
+
+        return {"FINISHED"}
+
+    def draw(self, context):
+        layout = self.layout
+        layout.separator()
+
+        layout.use_property_split = True
+
+        lib = get_active_library()
+
+        if lib.merge_libraries:
+            layout.prop(lib, 'store_library', expand=False)
+
+        layout.prop(self, "catalog", text="Catalog")
+        layout.prop(self, "name", text="Name")
+        layout.prop(self, 'tags')
+
+        #layout.prop()
+
+        layout.separator()
+        col = layout.column()
+        col.use_property_split = False
+        #row.enabled = False
+
+        if self.path:
+            col.label(text=self.path)
+
+        if self.warning:
+            col.label(icon='ERROR', text=self.warning)
+
+    def invoke(self, context, event):
+
+        lib = get_active_library()
+
+        active_lib = lib.adapter.get_active_asset_library()
+
+        lib.store_library = active_lib.name
+
+        asset_handle = context.asset_file_handle
+
+        catalog_file = lib.adapter.read_catalog()
+        catalog_ids = {v['id']: {'path': k, 'name': v['name']} for k,v in catalog_file.items()}
+
+        #asset_handle = context.asset_file_handle
+        self.old_asset_name = asset_handle.name
+        self.old_asset_path = lib.adapter.get_active_asset_path()
+        
+        self.asset = load_datablocks(self.old_asset_path, self.old_asset_name, type=lib.data_types)
+
+        self.old_image_path = lib.adapter.get_path('image', self.old_asset_name, self.old_asset_path)
+        self.old_video_path = lib.adapter.get_path('video', self.old_asset_name, self.old_asset_path)
+
+        self.old_asset_description_path = lib.adapter.get_asset_description_path(self.old_asset_path)
+        
+        self.old_asset_description = lib.adapter.read_asset_description(self.old_asset_path)
+        self.old_asset_description = lib.adapter.norm_asset_datas([self.old_asset_description])[0]
+
+
+        if not self.asset:
+            self.report({'ERROR'}, 'No asset found')
+
+        self.name = self.old_asset_name
+        self.tags = ', '.join(self.asset.asset_data.tags.keys())
+        #asset_path
+        self.catalog = catalog_ids[asset_handle.asset_data.catalog_id]['path']
+
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def cancel(self, context):
+        print('Cancel Edit Data, removing the asset')
+
+        lib = get_active_library()
+        active_lib = lib.adapter.get_active_asset_library()
+
+        getattr(bpy.data, active_lib.data_types).remove(self.asset)
+
+class ASSETLIB_OT_remove_user_library(Operator):
+    bl_idname = "assetlib.remove_user_library"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_label = 'Remove User Library'
+    bl_description = 'Remove User Library'
+
+    index : IntProperty(default=-1)
+
+    def execute(self, context: Context) -> Set[str]:
+        prefs = get_addon_prefs()
+
+        prefs.user_libraries.remove(self.index)
+
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_add_user_library(Operator):
+    bl_idname = "assetlib.add_user_library"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_label = 'Add User Library'
+    bl_description = 'Add User Library'
+
+
+    def execute(self, context: Context) -> Set[str]:
+        prefs = get_addon_prefs()
+
+        lib = prefs.user_libraries.add()
+        lib.expand = True
+
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_open_blend(Operator):
+    bl_idname = "assetlib.open_blend"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_label = 'Open Blender File'
+    bl_description = 'Open blender file'
+
+    #filepath : StringProperty(subtype='FILE_PATH') 
+
+    def execute(self, context: Context) -> Set[str]:
+        #asset = context.active_file
+        #prefs = get_addon_prefs()
+
+        lib = get_active_library()
+
+        #filepath = lib.adapter.format_path(asset.asset_data['filepath'])
+
+        filepath = lib.adapter.get_active_asset_path()
+
+        open_blender_file(filepath)
+
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_set_paths(Operator):
+    bl_idname = "assetlib.set_paths"
+    bl_options = {"REGISTER", "UNDO", "INTERNAL"}
+    bl_label = 'Set Paths'
+    bl_description = 'Set Library Paths'
+
+    name: StringProperty()
+    all: BoolProperty(default=False)
+
+    def execute(self, context: Context) -> Set[str]:
+        prefs = get_addon_prefs()
+        print('Set Paths')
+        if self.all:
+            libs = prefs.libraries
+        else:
+            libs = [prefs.libraries[self.name]]
+        
+        for lib in libs:
+            lib.clear_library_path()
+            lib.set_library_path()
+
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_bundle_library(Operator):
+    bl_idname = "assetlib.bundle"
+    bl_options = {"INTERNAL"}
+    bl_label = 'Bundle Library'
+    bl_description = 'Bundle all matching asset found inside one blend'
+
+    name : StringProperty()
+    diff : StringProperty()
+    blocking : BoolProperty(default=False)
+    mode : EnumProperty(items=[(i.replace(' ', '_').upper(), i, '') for i in ('None', 'All', 'Auto Bundle')], default='NONE')
+    directory : StringProperty(subtype='DIR_PATH')
+
+    #def refresh(self):
+    #    for area in suitable_areas(bpy.context.screen):
+    #        bpy.ops.asset.library_refresh({"area": area, 'region': area.regions[3]})
+            #space_data.activate_asset_by_id(asset, deferred=deferred)
+
+    def execute(self, context: Context) -> Set[str]:
+        prefs = get_addon_prefs()
+
+        libs = []
+        if self.name:
+            libs += [prefs.libraries[self.name]]
+
+        if self.mode == 'ALL':
+            libs += prefs.libraries.values()
+        elif self.mode == 'AUTO_BUNDLE':
+            libs += [l for l in prefs.libraries if l.auto_bundle]   
+                
+        lib_datas = [l.to_dict() for l in libs]
+
+        print(f'Bundle Libraries: {[l.name for l in libs]}')
+
+        script_path = Path(gettempdir()) / 'bundle_library.py'
+        script_code = dedent(f"""
+            import bpy
+            prefs = bpy.context.preferences.addons["asset_library"].preferences
+
+            for lib_data in {lib_datas}:
+                lib = prefs.env_libraries.add()
+                lib.set_dict(lib_data)
+                lib.adapter.bundle(cache_diff='{self.diff}')
+            """)
+
+        script_path.write_text(script_code)
+
+        #print(script_code)
+
+        #raise Exception()
+
+        cmd = get_bl_cmd(script=str(script_path), background=True)
+
+        #print(cmd) 
+        if self.blocking:
+            subprocess.call(cmd)
+            bpy.app.timers.register(refresh_asset_browsers, first_interval=0.2)
+        else:
+            subprocess.Popen(cmd)
+        
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_reload_addon(Operator):
+    bl_idname = "assetlib.reload_addon"
+    bl_options = {"UNDO"}
+    bl_label = 'Reload Asset Library Addon'
+    bl_description = 'Reload The Asset Library Addon and the addapters'
+
+    def execute(self, context: Context) -> Set[str]:
+
+        print('Execute reload')
+
+        asset_library.unregister()
+        importlib.reload(asset_library)
+        asset_library.register()
+
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_diff(Operator):
+    bl_idname = "assetlib.diff"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_label = 'Synchronize'
+    bl_description = 'Synchronize Action Lib to Local Directory'
+
+    name : StringProperty()
+    conform : BoolProperty(default=False)
+
+    def execute(self, context: Context) -> Set[str]:
+        prefs = get_addon_prefs()
+
+        lib = prefs.libraries.get(self.name)
+
+        if self.conform:
+            lib.conform.adapter.diff()
+        else:
+            lib.adapter.diff()
+
+        return {'FINISHED'}
+
+
+class ASSETLIB_OT_conform_library(Operator):
+    bl_idname = "assetlib.conform_library"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_label = "Conform Library"
+    bl_description = "Split each assets per blend and externalize preview"
+
+    name : StringProperty()
+    image_template : StringProperty()
+    video_template : StringProperty()
+    directory : StringProperty(subtype='DIR_PATH', name='Filepath')
+
+    def execute(self, context: Context) -> Set[str]:
+        prefs = get_addon_prefs()
+
+        lib = prefs.libraries.get(self.name)
+        #lib.adapter.conform(self.directory)
+
+        templates = {}
+        if self.image_template:
+            templates['image'] = self.image_template
+        if self.video_template:
+            templates['video'] = self.video_template
+
+
+        script_path = Path(gettempdir()) / 'bundle_library.py'
+        script_code = dedent(f"""
+            import bpy
+            prefs = bpy.context.preferences.addons["asset_library"].preferences
+            lib = prefs.env_libraries.add()
+            lib.set_dict({lib.to_dict()})
+            lib.adapter.conform(directory='{self.directory}', templates={templates})
+            """)
+
+        script_path.write_text(script_code)
+
+        cmd = get_bl_cmd(script=str(script_path), background=True)
+
+        subprocess.Popen(cmd)
+
+        return {'FINISHED'}
+    
+    def invoke(self, context, event):
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+
+class ASSETLIB_OT_play_preview(Operator):
+    bl_idname = "assetlib.play_preview"
+    bl_options = {"REGISTER", "UNDO", "INTERNAL"}
+    bl_label = 'Play Preview'
+    bl_description = 'Play Preview'
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        if not context.active_file:
+            return False
+
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            cls.poll_message_set("Current editor is not an asset browser")
+            return False
+
+        lib = get_active_library()
+        if not lib:
+            return False
+
+        return True
+
+    def execute(self, context: Context) -> Set[str]:
+        asset = context.active_file
+        prefs = get_addon_prefs()
+
+        lib = get_active_library()
+
+        #filepath = lib.adapter.format_path(asset.asset_data['filepath'])
+        asset_path = lib.adapter.get_active_asset_path()
+
+        asset_image = lib.adapter.get_image(asset.name, asset_path)
+        asset_video = lib.adapter.get_video(asset.name, asset_path)
+        
+        if not asset_image and not asset_video:
+            self.report({'ERROR'}, f'Preview for {asset.name} not found.')
+            return {"CANCELLED"}
+        
+        if asset_video:
+            self.report({'INFO'}, f'Video found. {asset_video}.')
+
+            if prefs.video_player:
+                subprocess.Popen([prefs.video_player, asset_video])
+            else:
+                bpy.ops.wm.path_open(filepath=str(asset_video))
+        else:
+            self.report({'INFO'}, f'Image found. {asset_image}.')
+
+            if prefs.image_player:
+                subprocess.Popen([prefs.image_player, asset_image])
+            else:
+                bpy.ops.wm.path_open(filepath=str(asset_image))
+
+
+        return {"FINISHED"}
+
+
+class ASSETLIB_OT_synchronize(Operator):
+    bl_idname = "assetlib.synchronize"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_label = 'Synchronize'
+    bl_description = 'Synchronize Action Lib to Local Directory'
+
+    clean : BoolProperty(default=False)
+    only_new : BoolProperty(default=False)
+    only_recent : BoolProperty(default=False)
+    name: StringProperty()
+    all: BoolProperty(default=False)
+
+    def execute(self, context: Context) -> Set[str]:
+
+        print('Not yet Implemented, have to be replace by Bundle instead')
+        return {'FINISHED'}
+
+        prefs = get_addon_prefs()
+        print('Synchronize')
+        if self.all:
+            libs = prefs.libraries
+        else:
+            libs = [prefs.libraries.get(self.name)]
+
+        for lib in libs:            
+            if self.clean and Path(lib.path_local).exists():
+                pass
+                print('To check first')
+                #shutil.rmtree(path_local)
+
+            if not lib.path_local:
+                continue
+
+            synchronize(
+                src=lib.path,
+                dst=lib.path_local,
+                only_new=self.only_new,
+                only_recent=self.only_recent
+            )
+
+        return {'FINISHED'}
+
+classes = (
+    ASSETLIB_OT_play_preview,
+    ASSETLIB_OT_open_blend,
+    ASSETLIB_OT_set_paths,
+    ASSETLIB_OT_synchronize,
+    ASSETLIB_OT_add_user_library,
+    ASSETLIB_OT_remove_user_library,
+    ASSETLIB_OT_diff,
+    ASSETLIB_OT_bundle_library,
+    ASSETLIB_OT_clear_asset,
+    ASSETLIB_OT_edit_data,
+    ASSETLIB_OT_conform_library,
+    ASSETLIB_OT_reload_addon
+)
+
+def register():
+    #bpy.types.UserAssetLibrary.is_env = False
+
+    for cls in classes:
+        bpy.utils.register_class(cls)
+
+def unregister():
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)

pose/__init__.py

@@ -0,0 +1,14 @@
+
+from asset_library.pose import (
+    operators)
+
+if 'bpy' in locals():
+    import importlib
+
+    importlib.reload(operators)
+
+def register():
+    operators.register()
+
+def unregister():
+    operators.unregister()

pose/conversion.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Pose Library - Conversion of old pose libraries.
+"""
+
+from typing import Optional
+from collections.abc import Collection
+
+if "pose_creation" not in locals():
+    from . import pose_creation
+else:
+    import importlib
+
+    pose_creation = importlib.reload(pose_creation)
+
+import bpy
+from bpy.types import (
+    Action,
+    TimelineMarker,
+)
+
+
+def convert_old_poselib(old_poselib: Action) -> Collection[Action]:
+    """Convert an old-style pose library to a set of pose Actions.
+
+    Old pose libraries were one Action with multiple pose markers. Each pose
+    marker will be converted to an Action by itself and marked as asset.
+    """
+
+    pose_assets = [
+        action
+        for marker in old_poselib.pose_markers
+        if (action := convert_old_pose(old_poselib, marker))
+    ]
+
+    # Mark all Actions as assets in one go. Ideally this would be done on an
+    # appropriate frame in the scene (to set up things like the background
+    # colour), but the old-style poselib doesn't contain such information. All
+    # we can do is just render on the current frame.
+    bpy.ops.asset.mark({'selected_ids': pose_assets})
+
+    return pose_assets
+
+
+def convert_old_pose(old_poselib: Action, marker: TimelineMarker) -> Optional[Action]:
+    """Convert an old-style pose library pose to a pose action."""
+
+    frame: int = marker.frame
+    action: Optional[Action] = None
+
+    for fcurve in old_poselib.fcurves:
+        key = pose_creation.find_keyframe(fcurve, frame)
+        if not key:
+            continue
+
+        if action is None:
+            action = bpy.data.actions.new(marker.name)
+
+        pose_creation.create_single_key_fcurve(action, fcurve, key)
+
+    return action

pose/operators.py

@@ -0,0 +1,615 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Pose Library - operators.
+"""
+
+from math import radians
+from mathutils import Vector
+from pathlib import Path
+from tempfile import gettempdir
+from typing import Optional, Set
+
+from asset_library.pose import pose_creation, pose_usage
+
+import bpy
+import json
+import os
+import re
+import shutil
+import subprocess
+import uuid
+import time
+
+from bpy.props import BoolProperty, CollectionProperty, EnumProperty, PointerProperty, StringProperty
+from bpy.types import (
+    Action,
+    Context,
+    Event,
+    FileSelectEntry,
+    Object,
+    Operator,
+    PropertyGroup,
+)
+from bpy_extras import asset_utils
+from bpy_extras.io_utils import ExportHelper, ImportHelper
+
+from asset_library.action.functions import (
+    get_marker,
+    get_keyframes,
+)
+
+from asset_library.common.bl_utils import (
+    get_view3d_persp,
+    load_assets_from,
+    split_path
+)
+
+
+class POSELIB_OT_create_pose_asset(Operator):
+    bl_idname = "poselib.create_pose_asset"
+    bl_label = "Create Pose Asset"
+    bl_description = (
+        "Create a new Action that contains the pose of the selected bones, and mark it as Asset. "
+        "The asset will be stored in the current blend file"
+    )
+    bl_options = {"REGISTER", "UNDO"}
+
+    pose_name: StringProperty(name="Pose Name")  # type: ignore
+    activate_new_action: BoolProperty(name="Activate New Action", default=True)  # type: ignore
+
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        # Make sure that if there is an asset browser open, the artist can see the newly created pose asset.
+        asset_browse_area: Optional[bpy.types.Area] = asset_browser.area_from_context(context)
+        if not asset_browse_area:
+            # No asset browser is visible, so there also aren't any expectations
+            # that this asset will be visible.
+            return True
+        
+        asset_space_params = asset_browser.params(asset_browse_area)
+        if asset_space_params.asset_library_ref != 'LOCAL':
+            cls.poll_message_set("Asset Browser must be set to the Current File library")
+            return False
+        
+        return True
+
+    def execute(self, context: Context) -> Set[str]:
+        #pose_name = self.pose_name or context.object.name
+        pose_name = False
+        if context.object.animation_data:
+            if context.object.animation_data.action:
+                pose_name = get_marker(context.object.animation_data.action)
+
+        if pose_name:
+            prefix = True
+            asset_name = Path(bpy.data.filepath).stem.split('_')[0]
+
+            action_asset_name = re.search(f'^{asset_name}.', pose_name)
+            if action_asset_name:
+                pose_name = pose_name.replace(action_asset_name.group(0), '')
+
+            side = re.search('_\w$', pose_name)
+            if side:
+                pose_name = pose_name.replace(side.group(0), '')
+
+            if 'hands' in context.object.animation_data.action.name.lower():
+                pose_name = f'hand_{pose_name}'
+            
+            if pose_name.startswith('lips_'):
+                pose_name.replace('lips_', '')
+                split = pose_name.split('_')
+                pose_name = '-'.join([s for s in split if s.isupper()])
+                pose_name = f'{pose_name}_{split[-1]}'
+                prefix = False
+            
+            if prefix and not pose_name.startswith(asset_name):
+                pose_name = f'{asset_name}_{pose_name}'
+
+        else:
+            pose_name = self.pose_name or context.object.name
+
+        asset = pose_creation.create_pose_asset_from_context(context, pose_name)
+        if not asset:
+            self.report({"WARNING"}, "No keyframes were found for this pose")
+            return {"CANCELLED"}
+
+        ### ADD ADM
+        data = asset.asset_data
+        data.catalog_id = str(uuid.UUID(int=0))
+
+        data_dict = dict(
+            is_single_frame=True,
+        )
+        if context.scene.camera:
+            data_dict.update(dict(camera=context.scene.camera.name))
+
+
+        for k, v in data_dict.items():
+            data[k] = v
+        ###
+
+        if self.activate_new_action:
+            self._set_active_action(context, asset)
+        self._activate_asset_in_browser(context, asset)
+        return {'FINISHED'}
+
+    def _set_active_action(self, context: Context, asset: Action) -> None:
+        self._prevent_action_loss(context.object)
+
+        anim_data = context.object.animation_data_create()
+        context.scene.actionlib.previous_action = anim_data.action
+        anim_data.action = asset
+
+    def _activate_asset_in_browser(self, context: Context, asset: Action) -> None:
+        """Activate the new asset in the appropriate Asset Browser.
+
+        This makes it possible to immediately check & edit the created pose asset.
+        """
+
+        asset_browse_area: Optional[bpy.types.Area] = asset_browser.area_from_context(context)
+        if not asset_browse_area:
+            return
+
+        # After creating an asset, the window manager has to process the
+        # notifiers before editors should be manipulated.
+        pose_creation.assign_from_asset_browser(asset, asset_browse_area)
+
+        # Pass deferred=True, because we just created a new asset that isn't
+        # known to the Asset Browser space yet. That requires the processing of
+        # notifiers, which will only happen after this code has finished
+        # running.
+        asset_browser.activate_asset(asset, asset_browse_area, deferred=True)
+
+    def _prevent_action_loss(self, object: Object) -> None:
+        """Mark the action with Fake User if necessary.
+
+        This is to prevent action loss when we reduce its reference counter by one.
+        """
+
+        if not object.animation_data:
+            return
+
+        action = object.animation_data.action
+        if not action:
+            return
+
+        if action.use_fake_user or action.users > 1:
+            # Removing one user won't GC it.
+            return
+
+        action.use_fake_user = True
+        self.report({'WARNING'}, "Action %s marked Fake User to prevent loss" % action.name)
+
+
+class POSELIB_OT_restore_previous_action(Operator):
+    bl_idname = "poselib.restore_previous_action"
+    bl_label = "Restore Previous Action"
+    bl_description = "Switch back to the previous Action, after creating a pose asset"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return bool(
+            context.scene.actionlib.previous_action
+            and context.object
+            and context.object.animation_data
+            and context.object.animation_data.action
+            and context.object.animation_data.action.asset_data is not None
+        )
+
+    def execute(self, context: Context) -> Set[str]:
+        # This is the Action that was just created with "Create Pose Asset".
+        # It has to be re-applied after switching to the previous action,
+        # to ensure the character keeps the same pose.
+        self.pose_action = context.object.animation_data.action
+
+        prev_action = context.scene.actionlib.previous_action
+        context.object.animation_data.action = prev_action
+        context.scene.actionlib.previous_action = None
+
+        # Wait a bit for the action assignment to be handled, before applying the pose.
+        wm = context.window_manager
+        self._timer = wm.event_timer_add(0.001, window=context.window)
+        wm.modal_handler_add(self)
+
+        return {'RUNNING_MODAL'}
+
+    def modal(self, context, event):
+        if event.type != 'TIMER':
+            return {'RUNNING_MODAL'}
+
+        wm = context.window_manager
+        wm.event_timer_remove(self._timer)
+
+        context.object.pose.apply_pose_from_action(self.pose_action)
+        return {'FINISHED'}
+
+
+class ASSET_OT_assign_action(Operator):
+    bl_idname = "asset.assign_action"
+    bl_label = "Assign Action"
+    bl_description = "Set this pose Action as active Action on the active Object"
+    bl_options = {"REGISTER", "UNDO"}
+
+    assign: BoolProperty(name="Assign", default=True)  # type: ignore
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return bool(
+            isinstance(getattr(context, "id", None), Action)
+            and context.object
+            and context.object.mode == "POSE"  # This condition may not be desired.
+        )
+
+    def execute(self, context: Context) -> Set[str]:
+        if self.assign:
+            context.object.animation_data_create().action = context.id
+        else:
+            if context.object.animation_data.action:
+                context.object.animation_data.action = None
+
+        return {"FINISHED"}
+
+
+class POSELIB_OT_copy_as_asset(Operator):
+    bl_idname = "poselib.copy_as_asset"
+    bl_label = "Copy Pose As Asset"
+    bl_description = "Create a new pose asset on the clipboard, to be pasted into an Asset Browser"
+    bl_options = {"REGISTER"}
+
+    CLIPBOARD_ASSET_MARKER = "ASSET-BLEND="
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return bool(
+            # There must be an object.
+            context.object
+            # It must be in pose mode with selected bones.
+            and context.object.mode == "POSE"
+            and context.object.pose
+            and context.selected_pose_bones_from_active_object
+        )
+
+    def execute(self, context: Context) -> Set[str]:
+        asset = pose_creation.create_pose_asset_from_context(
+            context,
+            context.object.name,
+        )
+        if asset is None:
+            self.report({"WARNING"}, "No animation data found to create asset from")
+            return {"CANCELLED"}
+
+        filepath = self.save_datablock(asset)
+
+        context.window_manager.clipboard = "%s%s" % (
+            self.CLIPBOARD_ASSET_MARKER,
+            filepath,
+        )
+        asset_browser.tag_redraw(context.screen)
+        self.report({"INFO"}, "Pose Asset copied, use Paste As New Asset in any Asset Browser to paste")
+
+        # The asset has been saved to disk, so to clean up it has to loose its asset & fake user status.
+        asset.asset_clear()
+        asset.use_fake_user = False
+
+        # The asset can be removed from the main DB, as it was purely created to
+        # be stored to disk, and not to be used in this file.
+        if asset.users > 0:
+            # This should never happen, and indicates a bug in the code. Having a warning about it is nice,
+            # but it shouldn't stand in the way of actually cleaning up the meant-to-be-temporary datablock.
+            self.report({"WARNING"}, "Unexpected non-zero user count for the asset, please report this as a bug")
+
+        bpy.data.actions.remove(asset)
+        return {"FINISHED"}
+
+    def save_datablock(self, action: Action) -> Path:
+        tempdir = Path(bpy.app.tempdir)
+        filepath = tempdir / "copied_asset.blend"
+        bpy.data.libraries.write(
+            str(filepath),
+            datablocks={action},
+            path_remap="NONE",
+            fake_user=True,
+            compress=True,  # Single-datablock blend file, likely little need to diff.
+        )
+        return filepath
+
+
+class POSELIB_OT_paste_asset(Operator):
+    bl_idname = "poselib.paste_asset"
+    bl_label = "Paste As New Asset"
+    bl_description = "Paste the Asset that was previously copied using Copy As Asset"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            cls.poll_message_set("Current editor is not an asset browser")
+            return False
+
+        asset_lib_ref = context.space_data.params.asset_library_ref
+        if asset_lib_ref != 'LOCAL':
+            cls.poll_message_set("Asset Browser must be set to the Current File library")
+            return False
+
+        # Delay checking the clipboard as much as possible, as it's CPU-heavier than the other checks.
+        clipboard: str = context.window_manager.clipboard
+        if not clipboard:
+            cls.poll_message_set("Clipboard is empty")
+            return False
+
+        marker = POSELIB_OT_copy_as_asset.CLIPBOARD_ASSET_MARKER
+        if not clipboard.startswith(marker):
+            cls.poll_message_set("Clipboard does not contain an asset")
+            return False
+
+        return True
+
+
+    def execute(self, context: Context) -> Set[str]:
+        clipboard = context.window_manager.clipboard
+        marker_len = len(POSELIB_OT_copy_as_asset.CLIPBOARD_ASSET_MARKER)
+        filepath = Path(clipboard[marker_len:])
+
+        assets = load_assets_from(filepath)
+        if not assets:
+            self.report({"ERROR"}, "Did not find any assets on clipboard")
+            return {"CANCELLED"}
+
+        self.report({"INFO"}, "Pasted %d assets" % len(assets))
+
+        bpy.ops.asset.library_refresh()
+
+        asset_browser_area = asset_browser.area_from_context(context)
+        if not asset_browser_area:
+            return {"FINISHED"}
+
+        # Assign same catalog_global as in asset browser.
+        catalog_id = asset_browser.active_catalog_id(asset_browser_area)
+        for asset in assets:
+            asset.asset_data.catalog_id = catalog_id
+        asset_browser.activate_asset(assets[0], asset_browser_area, deferred=True)
+
+        return {"FINISHED"}
+
+
+class POSELIB_OT_pose_asset_select_bones(Operator):
+    bl_idname = "poselib.pose_asset_select_bones"
+    bl_label = "Select Bones"
+    #bl_description = "Select those bones that are used in this pose"
+    bl_description = "Click: Select used Bones\nAlt+Click: Select Flipped Bones\nCtrl+Click: Select Both sides."
+    bl_options = {"REGISTER", "UNDO"}
+    #bl_property = "selected_side"
+
+    selected_side: EnumProperty(
+        name='Selected Side',
+        items=(
+            ('CURRENT', "Current", ""),
+            ('FLIPPED', "Flipped", ""),
+            ('BOTH', "Both", ""),
+        )
+    )
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        if not (
+            context.object
+            and context.object.mode == "POSE"  # This condition may not be desired.
+            and context.asset_library_ref
+            and context.asset_file_handle
+        ):
+            return False
+        return context.asset_file_handle.id_type == 'ACTION'
+
+    def execute(self, context: Context) -> Set[str]:
+        asset: FileSelectEntry = context.asset_file_handle
+        if asset.local_id:
+            return self.use_pose(context, asset.local_id)
+        return self._load_and_use_pose(context)
+
+    def use_pose(self, context: Context, asset: bpy.types.ID) -> Set[str]:
+        # Implement in subclass.
+        pass
+
+    def _load_and_use_pose(self, context: Context) -> Set[str]:
+        asset_library_ref = context.asset_library_ref
+        asset = context.asset_file_handle
+        asset_lib_path = bpy.types.AssetHandle.get_full_library_path(asset, asset_library_ref)
+
+        if not asset_lib_path:
+            self.report(  # type: ignore
+                {"ERROR"},
+                # TODO: Add some way to get the library name from the library reference (just asset_library_ref.name?).
+                f"Selected asset {asset.name} could not be located inside the asset library",
+            )
+            return {"CANCELLED"}
+        if asset.id_type != 'ACTION':
+            self.report(  # type: ignore
+                {"ERROR"},
+                f"Selected asset {asset.name} is not an Action",
+            )
+            return {"CANCELLED"}
+
+        with bpy.types.BlendData.temp_data() as temp_data:
+            with temp_data.libraries.load(asset_lib_path) as (data_from, data_to):
+                data_to.actions = [asset.name]
+
+            action: Action = data_to.actions[0]
+            return self.use_pose(context, action)
+
+    def use_pose(self, context: Context, pose_asset: Action) -> Set[str]:
+        arm_object: Object = context.object
+        #pose_usage.select_bones(arm_object, pose_asset, select=self.select, flipped=self.flipped)
+        pose_usage.select_bones(arm_object, pose_asset, selected_side=self.selected_side)
+        return {"FINISHED"}
+
+# This operator takes the Window Manager's `actionlib_flipped` property, and
+# passes it to the `POSELIB_OT_blend_pose_asset` operator. This makes it
+# possible to bind a key to the operator and still have it respect the global
+# "Flip Pose" checkbox.
+class POSELIB_OT_blend_pose_asset_for_keymap(Operator):
+    bl_idname = "poselib.blend_pose_asset_for_keymap"
+    bl_options = {"REGISTER", "UNDO", "INTERNAL"}
+
+    _rna = bpy.ops.poselib.blend_pose_asset.get_rna_type()
+    bl_label = _rna.name
+    bl_description = _rna.description
+    del _rna
+
+    flipped: BoolProperty(name="Flipped", default=False)  # type: ignore
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return bpy.ops.poselib.blend_pose_asset.poll(context.copy())
+    
+    """
+    def invoke(self, context, event):
+        if event.type == 'LEFTMOUSE':
+            self.flipped = True if event.alt else False
+
+            if event.ctrl:
+                bpy.ops.poselib.blend_pose_asset(context.copy(), 'INVOKE_DEFAULT', flipped=not self.flipped)
+            bpy.ops.poselib.blend_pose_asset(context.copy(), 'INVOKE_DEFAULT', flipped=self.flipped)
+
+        return {'FINISHED'}
+    """
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        return bpy.ops.poselib.blend_pose_asset(context.copy(), 'INVOKE_DEFAULT', flipped=self.flipped)
+
+    def execute(self, context: Context) -> Set[str]:
+        return bpy.ops.poselib.blend_pose_asset(context.copy(), 'EXEC_DEFAULT', flipped=self.flipped)
+
+
+# This operator takes the Window Manager's `actionlib_flipped` property, and
+# passes it to the `POSELIB_OT_apply_pose_asset` operator. This makes it
+# possible to bind a key to the operator and still have it respect the global
+# "Flip Pose" checkbox.
+
+class POSELIB_OT_apply_pose_asset_for_keymap(Operator):
+    bl_idname = "poselib.apply_pose_asset_for_keymap"
+    bl_options = {"REGISTER", "UNDO", "INTERNAL"}
+
+    _rna = bpy.ops.poselib.apply_pose_asset.get_rna_type()
+    bl_label = _rna.name
+    #bl_description = _rna.description
+    bl_description = 'Apply Pose to Bones'
+    del _rna
+
+    flipped: BoolProperty(name="Flipped", default=False)  # type: ignore
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        if not asset_utils.SpaceAssetInfo.is_asset_browser(context.space_data):
+            return False
+        return bpy.ops.poselib.apply_pose_asset.poll(context.copy())
+    
+    def execute(self, context: Context) -> Set[str]:
+        if self.flipped:
+            action = bpy.data.actions.get(context.active_file.name)
+
+            store_bones = {}
+            
+            bones = [
+                'blendshape-eyes', 'blendshape-eye.L', 'blendshape-eye.R',
+                'blendshape-corner-mouth', 'blendshape-corner-mouth.L',
+                'blendshape-corner-down-mouth.L', 'blendshape-corner-up-mouth.L',
+                'blendshape-corner-mouth-add.L','blendshape-corner-mouth.R',
+                'blendshape-corner-down-mouth.R', 'blendshape-corner-up-mouth.R',
+                'blendshape-corner-mouth-add.R', 'blendshape-center-up-mouth',
+                'blendshape-center-down-mouth',
+                'hat1.R', 'hat2.R', 'hat3.R', 'hat1.L', 'hat2.L', 'hat3.L',
+            ]
+
+            attributes = [
+                'location', 'rotation_quaternion', 
+                'rotation_euler', 'rotation_axis_angle', 'scale'
+            ]
+
+            if action:
+                for fc in action.fcurves:
+                    bone_name, prop_name = split_path(fc.data_path)
+                    if bone_name not in bones:
+                        continue
+                    
+                    if not bone_name in store_bones.keys():
+                        store_bones[bone_name] = {}
+
+                    for attr in attributes:
+                        if prop_name == attr:
+                            if not prop_name in store_bones[bone_name].keys():
+                                store_bones[bone_name][prop_name] = []
+
+                                val = getattr(context.object.pose.bones[bone_name], prop_name)
+
+                            store_bones[bone_name][prop_name].append(fc.evaluate(context.scene.frame_current))
+                                
+            bpy.ops.poselib.apply_pose_asset(context.copy(), 'EXEC_DEFAULT', flipped=True)
+
+            for bone, v in store_bones.items():
+                for attr, attr_val in v.items():
+                    flipped_vector = 1
+                    
+                    ### TODO FAIRE ÇA PROPREMENT AVEC UNE COMPREHENSION LIST OU AUTRE
+                    if re.search(r'\.[RL]$', bone):
+                        flipped_bone = pose_usage.flip_side_name(bone)
+                        if attr == 'location':
+                            flipped_vector = Vector((-1, 1, 1))
+                        # print('-----', store_bones.get(flipped_bone)[attr])
+                        attr_val = Vector(store_bones.get(flipped_bone)[attr]) * flipped_vector
+                            
+                    setattr(context.object.pose.bones[bone], attr, attr_val)
+            
+            return {'FINISHED'}
+
+        else:
+            return bpy.ops.poselib.apply_pose_asset(context.copy(), 'EXEC_DEFAULT', flipped=False)
+
+
+class POSELIB_OT_convert_old_poselib(Operator):
+    bl_idname = "poselib.convert_old_poselib"
+    bl_label = "Convert Old-Style Pose Library"
+    bl_description = "Create a pose asset for each pose marker in the current action"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        action = context.object and context.object.animation_data and context.object.animation_data.action
+        if not action:
+            cls.poll_message_set("Active object has no Action")
+            return False
+        if not action.pose_markers:
+            cls.poll_message_set("Action %r is not a old-style pose library" % action.name)
+            return False
+        return True
+
+    def execute(self, context: Context) -> Set[str]:
+        from . import conversion
+
+        old_poselib = context.object.animation_data.action
+        new_actions = conversion.convert_old_poselib(old_poselib)
+
+        if not new_actions:
+            self.report({'ERROR'}, "Unable to convert to pose assets")
+            return {'CANCELLED'}
+
+        self.report({'INFO'}, "Converted %d poses to pose assets" % len(new_actions))
+        return {'FINISHED'}
+
+
+
+classes = (
+    POSELIB_OT_apply_pose_asset_for_keymap,
+    POSELIB_OT_blend_pose_asset_for_keymap,
+    POSELIB_OT_convert_old_poselib,
+    POSELIB_OT_copy_as_asset,
+    POSELIB_OT_create_pose_asset,
+    POSELIB_OT_paste_asset,
+    POSELIB_OT_pose_asset_select_bones,
+    POSELIB_OT_restore_previous_action
+)
+
+register, unregister = bpy.utils.register_classes_factory(classes)

pose/pose_creation.py

@@ -0,0 +1,423 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Pose Library - creation functions.
+"""
+
+import dataclasses
+import functools
+import re
+
+from typing import Optional, FrozenSet, Set, Union, Iterable, cast
+
+
+import bpy
+from bpy.types import (
+    Action,
+    Bone,
+    Context,
+    FCurve,
+    Keyframe,
+)
+
+FCurveValue = Union[float, int]
+
+pose_bone_re = re.compile(r'pose.bones\["([^"]+)"\]')
+"""RegExp for matching FCurve data paths."""
+
+
+@dataclasses.dataclass(unsafe_hash=True, frozen=True)
+class PoseCreationParams:
+    armature_ob: bpy.types.Object
+    src_action: Optional[Action]
+    src_frame_nr: float
+    bone_names: FrozenSet[str]
+    new_asset_name: str
+
+
+class UnresolvablePathError(ValueError):
+    """Raised when a data_path cannot be resolved to a current value."""
+
+
+@dataclasses.dataclass(unsafe_hash=True)
+class PoseActionCreator:
+    """Create an Action that's suitable for marking as Asset.
+
+    Does not mark as asset yet, nor does it add asset metadata.
+    """
+
+    params: PoseCreationParams
+
+    # These were taken from Blender's Action baking code in `anim_utils.py`.
+    # Items are (name, array_length) tuples.
+    _bbone_props = [
+        ("bbone_curveinx", None),
+        ("bbone_curveoutx", None),
+        ("bbone_curveinz", None),
+        ("bbone_curveoutz", None),
+        ("bbone_rollin", None),
+        ("bbone_rollout", None),
+        ("bbone_scalein", 3),
+        ("bbone_scaleout", 3),
+        ("bbone_easein", None),
+        ("bbone_easeout", None),
+    ]
+
+    def create(self) -> Optional[Action]:
+        """Create a single-frame Action containing only the given bones, or None if no anim data was found."""
+
+        try:
+            dst_action = self._create_new_action()
+            self._store_pose(dst_action)
+        finally:
+            # Prevent next instantiations of this class from reusing pointers to
+            # bones. They may not be valid by then any more.
+            self._find_bone.cache_clear()
+
+        if len(dst_action.fcurves) == 0:
+            bpy.data.actions.remove(dst_action)
+            return None
+
+        return dst_action
+
+    def _create_new_action(self) -> Action:
+        dst_action = bpy.data.actions.new(self.params.new_asset_name)
+        if self.params.src_action:
+            dst_action.id_root = self.params.src_action.id_root
+        dst_action.user_clear()  # actions.new() sets users=1, but marking as asset also increments user count.
+        return dst_action
+
+    def _store_pose(self, dst_action: Action) -> None:
+        """Store the current pose into the given action."""
+        self._store_bone_pose_parameters(dst_action)
+        self._store_animated_parameters(dst_action)
+        self._store_parameters_from_callback(dst_action)
+
+    def _store_bone_pose_parameters(self, dst_action: Action) -> None:
+        """Store loc/rot/scale/bbone values in the Action."""
+
+        for bone_name in sorted(self.params.bone_names):
+            self._store_location(dst_action, bone_name)
+            self._store_rotation(dst_action, bone_name)
+            self._store_scale(dst_action, bone_name)
+            self._store_bbone(dst_action, bone_name)
+
+    def _store_animated_parameters(self, dst_action: Action) -> None:
+        """Store the current value of any animated bone properties."""
+        if self.params.src_action is None:
+            return
+
+        armature_ob = self.params.armature_ob
+        for fcurve in self.params.src_action.fcurves:
+            match = pose_bone_re.match(fcurve.data_path)
+            if not match:
+                # Not animating a bone property.
+                continue
+
+            bone_name = match.group(1)
+            if bone_name not in self.params.bone_names:
+                # Bone is not our export set.
+                continue
+
+            if dst_action.fcurves.find(fcurve.data_path, index=fcurve.array_index):
+                # This property is already handled by a previous _store_xxx() call.
+                continue
+
+            # Only include in the pose if there is a key on this frame.
+            if not self._has_key_on_frame(fcurve):
+                continue
+
+            try:
+                value = self._current_value(armature_ob, fcurve.data_path, fcurve.array_index)
+            except UnresolvablePathError:
+                # A once-animated property no longer exists.
+                continue
+
+            dst_fcurve = dst_action.fcurves.new(
+                fcurve.data_path, index=fcurve.array_index, action_group=bone_name
+            )
+            dst_fcurve.keyframe_points.insert(self.params.src_frame_nr, value=value)
+            dst_fcurve.update()
+
+    def _store_parameters_from_callback(self, dst_action: Action) -> None:
+        """Store extra parameters in the pose based on arbitrary callbacks.
+
+        Not implemented yet, needs a proper design & some user stories.
+        """
+        pass
+
+    def _store_location(self, dst_action: Action, bone_name: str) -> None:
+        """Store bone location."""
+        self._store_bone_array(dst_action, bone_name, "location", 3)
+
+    def _store_rotation(self, dst_action: Action, bone_name: str) -> None:
+        """Store bone rotation given current rotation mode."""
+        bone = self._find_bone(bone_name)
+        if bone.rotation_mode == "QUATERNION":
+            self._store_bone_array(dst_action, bone_name, "rotation_quaternion", 4)
+        elif bone.rotation_mode == "AXIS_ANGLE":
+            self._store_bone_array(dst_action, bone_name, "rotation_axis_angle", 4)
+        else:
+            self._store_bone_array(dst_action, bone_name, "rotation_euler", 3)
+
+    def _store_scale(self, dst_action: Action, bone_name: str) -> None:
+        """Store bone scale."""
+        self._store_bone_array(dst_action, bone_name, "scale", 3)
+
+    def _store_bbone(self, dst_action: Action, bone_name: str) -> None:
+        """Store bendy-bone parameters."""
+        for prop_name, array_length in self._bbone_props:
+            if array_length:
+                self._store_bone_array(dst_action, bone_name, prop_name, array_length)
+            else:
+                self._store_bone_property(dst_action, bone_name, prop_name)
+
+    def _store_bone_array(
+        self, dst_action: Action, bone_name: str, property_name: str, array_length: int
+    ) -> None:
+        """Store all elements of an array property."""
+        for array_index in range(array_length):
+            self._store_bone_property(dst_action, bone_name, property_name, array_index)
+
+    def _store_bone_property(
+        self,
+        dst_action: Action,
+        bone_name: str,
+        property_path: str,
+        array_index: int = -1,
+    ) -> None:
+        """Store the current value of a single bone property."""
+
+        bone = self._find_bone(bone_name)
+        value = self._current_value(bone, property_path, array_index)
+
+        # Get the full 'pose.bones["bone_name"].blablabla' path suitable for FCurves.
+        rna_path = bone.path_from_id(property_path)
+
+        fcurve: Optional[FCurve] = dst_action.fcurves.find(rna_path, index=array_index)
+        if fcurve is None:
+            fcurve = dst_action.fcurves.new(rna_path, index=array_index, action_group=bone_name)
+
+        fcurve.keyframe_points.insert(self.params.src_frame_nr, value=value)
+        fcurve.update()
+
+    @classmethod
+    def _current_value(
+        cls, datablock: bpy.types.ID, data_path: str, array_index: int
+    ) -> FCurveValue:
+        """Resolve an RNA path + array index to an actual value."""
+        value_or_array = cls._path_resolve(datablock, data_path)
+
+        # Both indices -1 and 0 are used for non-array properties.
+        # -1 cannot be used in arrays, whereas 0 can be used in both arrays and non-arrays.
+
+        if array_index == -1:
+            return cast(FCurveValue, value_or_array)
+
+        if array_index == 0:
+            value_or_array = cls._path_resolve(datablock, data_path)
+            try:
+                # MyPy doesn't understand this try/except is to determine the type.
+                value = value_or_array[array_index]  # type: ignore
+            except TypeError:
+                # Not an array after all.
+                return cast(FCurveValue, value_or_array)
+            return cast(FCurveValue, value)
+
+        # MyPy doesn't understand that array_index>0 implies this is indexable.
+        return cast(FCurveValue, value_or_array[array_index])  # type: ignore
+
+    @staticmethod
+    def _path_resolve(
+        datablock: bpy.types.ID, data_path: str
+    ) -> Union[FCurveValue, Iterable[FCurveValue]]:
+        """Wrapper for datablock.path_resolve(data_path).
+
+        Raise UnresolvablePathError when the path cannot be resolved.
+        This is easier to deal with upstream than the generic ValueError raised
+        by Blender.
+        """
+        try:
+            return datablock.path_resolve(data_path)  # type: ignore
+        except ValueError as ex:
+            raise UnresolvablePathError(str(ex)) from ex
+
+    @functools.lru_cache(maxsize=1024)
+    def _find_bone(self, bone_name: str) -> Bone:
+        """Find a bone by name.
+
+        Assumes the named bone exists, as the bones this class handles comes
+        from the user's selection, and you can't select a non-existent bone.
+        """
+
+        bone: Bone = self.params.armature_ob.pose.bones[bone_name]
+        return bone
+
+    def _has_key_on_frame(self, fcurve: FCurve) -> bool:
+        """Return True iff the FCurve has a key on the source frame."""
+
+        points = fcurve.keyframe_points
+        if not points:
+            return False
+
+        frame_to_find = self.params.src_frame_nr
+        margin = 0.001
+        high = len(points) - 1
+        low = 0
+        while low <= high:
+            mid = (high + low) // 2
+            diff = points[mid].co.x - frame_to_find
+            if abs(diff) < margin:
+                return True
+            if diff < 0:
+                # Frame to find is bigger than the current middle.
+                low = mid + 1
+            else:
+                # Frame to find is smaller than the current middle
+                high = mid - 1
+        return False
+
+
+def create_pose_asset(
+    params: PoseCreationParams,
+) -> Optional[Action]:
+    """Create a single-frame Action containing only the pose of the given bones.
+
+    DOES mark as asset, DOES NOT configure asset metadata.
+    """
+
+    creator = PoseActionCreator(params)
+    pose_action = creator.create()
+    if pose_action is None:
+        return None
+
+    pose_action.asset_mark()
+    pose_action.asset_generate_preview()
+    return pose_action
+
+#def create_pose_asset_from_context(context: Context, new_asset_name: str, selection=True) -> Optional[Action]:
+def create_pose_asset_from_context(context: Context, new_asset_name: str) -> Optional[Action]:
+    """Create Action asset from active object & selected bones."""
+    
+    bones = context.selected_pose_bones_from_active_object
+    bone_names = {bone.name for bone in bones}
+
+    params = PoseCreationParams(
+        context.object,
+        getattr(context.object.animation_data, "action", None),
+        context.scene.frame_current,
+        frozenset(bone_names),
+        new_asset_name,
+    )
+
+    return create_pose_asset(params)
+
+
+def copy_fcurves(
+    dst_action: Action,
+    src_action: Action,
+    src_frame_nr: float,
+    bone_names: Set[str],
+) -> int:
+    """Copy FCurves, returning number of curves copied."""
+    num_fcurves_copied = 0
+    for fcurve in src_action.fcurves:
+        match = pose_bone_re.match(fcurve.data_path)
+        if not match:
+            continue
+
+        bone_name = match.group(1)
+        if bone_name not in bone_names:
+            continue
+
+        # Check if there is a keyframe on this frame.
+        keyframe = find_keyframe(fcurve, src_frame_nr)
+        if keyframe is None:
+            continue
+        create_single_key_fcurve(dst_action, fcurve, keyframe)
+        num_fcurves_copied += 1
+    return num_fcurves_copied
+
+
+def create_single_key_fcurve(
+    dst_action: Action, src_fcurve: FCurve, src_keyframe: Keyframe
+) -> FCurve:
+    """Create a copy of the source FCurve, but only for the given keyframe.
+
+    Returns a new FCurve with just one keyframe.
+    """
+
+    dst_fcurve = copy_fcurve_without_keys(dst_action, src_fcurve)
+    copy_keyframe(dst_fcurve, src_keyframe)
+    return dst_fcurve
+
+
+def copy_fcurve_without_keys(dst_action: Action, src_fcurve: FCurve) -> FCurve:
+    """Create a new FCurve and copy some properties."""
+
+    src_group_name = src_fcurve.group.name if src_fcurve.group else ""
+    dst_fcurve = dst_action.fcurves.new(
+        src_fcurve.data_path, index=src_fcurve.array_index, action_group=src_group_name
+    )
+    for propname in {"auto_smoothing", "color", "color_mode", "extrapolation"}:
+        setattr(dst_fcurve, propname, getattr(src_fcurve, propname))
+    return dst_fcurve
+
+
+def copy_keyframe(dst_fcurve: FCurve, src_keyframe: Keyframe) -> Keyframe:
+    """Copy a keyframe from one FCurve to the other."""
+
+    dst_keyframe = dst_fcurve.keyframe_points.insert(
+        src_keyframe.co.x, src_keyframe.co.y, options={'FAST'}, keyframe_type=src_keyframe.type
+    )
+
+    for propname in {
+        "amplitude",
+        "back",
+        "easing",
+        "handle_left",
+        "handle_left_type",
+        "handle_right",
+        "handle_right_type",
+        "interpolation",
+        "period",
+    }:
+        setattr(dst_keyframe, propname, getattr(src_keyframe, propname))
+    dst_fcurve.update()
+    return dst_keyframe
+
+
+def find_keyframe(fcurve: FCurve, frame: float) -> Optional[Keyframe]:
+    # Binary search adapted from https://pythonguides.com/python-binary-search/
+    keyframes = fcurve.keyframe_points
+    low = 0
+    high = len(keyframes) - 1
+    mid = 0
+
+    # Accept any keyframe that's within 'epsilon' of the requested frame.
+    # This should account for rounding errors and the likes.
+    epsilon = 1e-4
+    frame_lowerbound = frame - epsilon
+    frame_upperbound = frame + epsilon
+    while low <= high:
+        mid = (high + low) // 2
+        keyframe = keyframes[mid]
+        if keyframe.co.x < frame_lowerbound:
+            low = mid + 1
+        elif keyframe.co.x > frame_upperbound:
+            high = mid - 1
+        else:
+            return keyframe
+    return None
+
+
+def assign_from_asset_browser(asset: Action, asset_browser_area: bpy.types.Area) -> None:
+    """Assign some things from the asset browser to the asset.
+
+    This sets the current catalog ID, and in the future could include tags
+    from the active dynamic catalog, etc.
+    """
+
+    cat_id = asset_browser.active_catalog_id(asset_browser_area)
+    asset.asset_data.catalog_id = cat_id

pose/pose_usage.py

@@ -0,0 +1,180 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+
+"""
+Pose Library - usage functions.
+"""
+
+from typing import Set
+import re
+
+from bpy.types import (
+    Action,
+    Object,
+)
+
+
+#def select_bones(arm_object: Object, action: Action, *, select: bool, flipped: bool, both=False) -> None:
+def select_bones(arm_object: Object, action: Action, *, selected_side, toggle=True):
+    pose_bone_re = re.compile(r'pose.bones\["([^"]+)"\]')
+    pose = arm_object.pose
+
+    seen_bone_names: Set[str] = set()
+    bones_to_select = set()
+
+    for fcurve in action.fcurves:
+        data_path: str = fcurve.data_path
+        match = pose_bone_re.match(data_path)
+        if not match:
+            continue
+
+        bone_name = match.group(1)
+        bone_name_flip = flip_side_name(bone_name)
+
+        if bone_name in seen_bone_names:
+            continue
+        seen_bone_names.add(bone_name)
+        
+        if selected_side == 'FLIPPED':
+            bones_to_select.add(bone_name_flip)
+        elif selected_side == 'BOTH':
+            bones_to_select.add(bone_name_flip)
+            bones_to_select.add(bone_name)
+        elif selected_side == 'CURRENT':
+            bones_to_select.add(bone_name)
+        
+
+    for bone in bones_to_select:
+        pose_bone = pose.bones.get(bone)
+        if pose_bone:
+            if toggle:
+                pose_bone.bone.select = not pose_bone.bone.select
+            else:
+                pose_bone.bone.select = True
+
+
+_FLIP_SEPARATORS = set(". -_")
+
+# These are single-character replacements, others are handled differently.
+_FLIP_REPLACEMENTS = {
+    "l": "r",
+    "L": "R",
+    "r": "l",
+    "R": "L",
+}
+
+
+def flip_side_name(to_flip: str) -> str:
+    """Flip left and right indicators in the name.
+
+    Basically a Python implementation of BLI_string_flip_side_name.
+
+    >>> flip_side_name('bone_L.004')
+    'bone_R.004'
+    >>> flip_side_name('left_bone')
+    'right_bone'
+    >>> flip_side_name('Left_bone')
+    'Right_bone'
+    >>> flip_side_name('LEFT_bone')
+    'RIGHT_bone'
+    >>> flip_side_name('some.bone-RIGHT.004')
+    'some.bone-LEFT.004'
+    >>> flip_side_name('some.bone-right.004')
+    'some.bone-left.004'
+    >>> flip_side_name('some.bone-Right.004')
+    'some.bone-Left.004'
+    >>> flip_side_name('some.bone-LEFT.004')
+    'some.bone-RIGHT.004'
+    >>> flip_side_name('some.bone-left.004')
+    'some.bone-right.004'
+    >>> flip_side_name('some.bone-Left.004')
+    'some.bone-Right.004'
+    >>> flip_side_name('.004')
+    '.004'
+    >>> flip_side_name('L.004')
+    'R.004'
+    """
+    import string
+
+    if len(to_flip) < 3:
+        # we don't flip names like .R or .L
+        return to_flip
+
+    # We first check the case with a .### extension, let's find the last period.
+    number = ""
+    replace = to_flip
+    if to_flip[-1] in string.digits:
+        try:
+            index = to_flip.rindex(".")
+        except ValueError:
+            pass
+        else:
+            if to_flip[index + 1] in string.digits:
+                # TODO(Sybren): this doesn't handle "bone.1abc2" correctly.
+                number = to_flip[index:]
+                replace = to_flip[:index]
+
+    if not replace:
+        # Nothing left after the number, so no flips necessary.
+        return replace + number
+
+    if len(replace) == 1:
+        replace = _FLIP_REPLACEMENTS.get(replace, replace)
+        return replace + number
+
+    # First case; separator . - _ with extensions r R l L.
+    if replace[-2] in _FLIP_SEPARATORS and replace[-1] in _FLIP_REPLACEMENTS:
+        replace = replace[:-1] + _FLIP_REPLACEMENTS[replace[-1]]
+        return replace + number
+
+    # Second case; beginning with r R l L, with separator after it.
+    if replace[1] in _FLIP_SEPARATORS and replace[0] in _FLIP_REPLACEMENTS:
+        replace = _FLIP_REPLACEMENTS[replace[0]] + replace[1:]
+        return replace + number
+
+    lower = replace.lower()
+    prefix = suffix = ""
+    if lower.startswith("right"):
+        bit = replace[0:2]
+        if bit == "Ri":
+            prefix = "Left"
+        elif bit == "RI":
+            prefix = "LEFT"
+        else:
+            prefix = "left"
+        replace = replace[5:]
+    elif lower.startswith("left"):
+        bit = replace[0:2]
+        if bit == "Le":
+            prefix = "Right"
+        elif bit == "LE":
+            prefix = "RIGHT"
+        else:
+            prefix = "right"
+        replace = replace[4:]
+    elif lower.endswith("right"):
+        bit = replace[-5:-3]
+        if bit == "Ri":
+            suffix = "Left"
+        elif bit == "RI":
+            suffix = "LEFT"
+        else:
+            suffix = "left"
+        replace = replace[:-5]
+    elif lower.endswith("left"):
+        bit = replace[-4:-2]
+        if bit == "Le":
+            suffix = "Right"
+        elif bit == "LE":
+            suffix = "RIGHT"
+        else:
+            suffix = "right"
+        replace = replace[:-4]
+
+    return prefix + replace + suffix + number
+
+
+if __name__ == '__main__':
+    import doctest
+
+    print(f"Test result: {doctest.testmod()}")

prefs.py

@@ -0,0 +1,777 @@
+
+import bpy
+import os
+from os.path import abspath, join
+
+from bpy.types import (AddonPreferences, PointerProperty, PropertyGroup)
+from bpy.props import (BoolProperty, StringProperty, CollectionProperty, 
+    EnumProperty, IntProperty)
+    
+from asset_library.constants import (DATA_TYPES, DATA_TYPE_ITEMS, 
+    ICONS, RESOURCES_DIR, ADAPTER_DIR)
+
+from asset_library.common.file_utils import import_module_from_path, norm_str
+from asset_library.common.bl_utils import get_addon_prefs
+from asset_library.common.functions import get_catalog_path
+
+from pathlib import Path
+import importlib
+import inspect
+
+
+ADAPTERS = []
+
+def update_library_config(self, context):
+    print('update_library_config not yet implemented')
+
+def update_library_path(self, context):
+    prefs = get_addon_prefs()
+
+    self['bundle_directory'] = str(self.library_path)
+
+    if not self.custom_bundle_name:
+        self['custom_bundle_name'] = self.name
+
+    if not self.custom_bundle_directory:
+        custom_bundle_dir = Path(prefs.bundle_directory, self.library_name).resolve()
+        self['custom_bundle_directory'] = str(custom_bundle_dir)
+
+    #if self.custom_bundle_directory:
+    #    self['custom_bundle_directory'] = abspath(bpy.path.abspath(self.custom_bundle_directory))
+    #else:
+    #    bundle_directory = join(prefs.bundle_directory, norm_str(self.name))
+    #    self['custom_bundle_directory'] = abspath(bundle_directory)
+
+    self.set_library_path()
+
+def update_all_library_path(self, context):
+    #print('update_all_assetlib_paths')
+
+    prefs = get_addon_prefs()
+
+    #if self.custom_bundle_directory:
+    #    self['custom_bundle_directory'] = abspath(bpy.path.abspath(self.custom_bundle_directory))
+
+    for lib in prefs.libraries:
+        update_library_path(lib, context)
+        #lib.set_library_path()
+
+def get_adapter_items(self, context):
+    #prefs = get_addon_prefs()
+
+    items = [('NONE', 'None', '', 0)]
+    items += [(norm_str(a.name, format=str.upper), a.name, "", i+1) for i, a in enumerate(ADAPTERS)]
+    return items
+
+def get_library_items(self, context):
+    prefs = get_addon_prefs()
+
+    items = [('NONE', 'None', '', 0)]
+    items += [(l.name, l.name, "", i+1) for i, l in enumerate(prefs.libraries) if l != self]
+
+    return items
+
+def get_store_library_items(self, context):
+    prefs = get_addon_prefs()
+
+    libraries = [l for l in prefs.libraries if l.merge_library == self.name]
+
+    return  [(l.name, l.name, "", i) for i, l in enumerate([self] + libraries)]
+
+
+class AssetLibraryAdapters(PropertyGroup):
+    parent = None
+
+    def __iter__(self):
+        return (getattr(self, p) for p in self.bl_rna.properties.keys() if p not in ('rna_type', 'name'))
+
+
+class ConformAssetLibrary(PropertyGroup):
+    adapters : bpy.props.PointerProperty(type=AssetLibraryAdapters)
+    adapter_name : EnumProperty(items=get_adapter_items)
+    directory : StringProperty(
+        name="Destination Directory",
+        subtype='DIR_PATH',
+        default=''
+    )
+    image_template : StringProperty()
+    video_template : StringProperty()
+
+    externalize_data: BoolProperty(default=False, name='Externalize Data')
+    blend_depth: IntProperty(default=1, name='Blend Depth')
+
+    @property
+    def adapter(self):
+        name = norm_str(self.adapter_name)
+        if not hasattr(self.adapters, name):
+            return
+
+        return getattr(self.adapters, name)
+
+
+class AssetLibrary(PropertyGroup):
+    name : StringProperty(name='Name', default='Action Library', update=update_library_path)
+    id : StringProperty()
+    auto_bundle : BoolProperty(name='Auto Bundle', default=True)
+    expand : BoolProperty(name='Expand', default=False)
+    use : BoolProperty(name='Use', default=True, update=update_library_path)
+    data_type : EnumProperty(name='Type', items=DATA_TYPE_ITEMS, default='ACTION')
+
+    bundle_directory : StringProperty(
+        name="Bundle Directory",
+        subtype='DIR_PATH',
+        default=''
+    )
+
+    use_custom_bundle_directory : BoolProperty(default=False, update=update_library_path)
+    custom_bundle_directory : StringProperty(
+        name="Bundle Directory",
+        subtype='DIR_PATH',
+        default='',
+        update=update_library_path
+    )
+    #use_merge : BoolProperty(default=False, update=update_library_path)
+
+    use_custom_bundle_name : BoolProperty(default=False, update=update_library_path)
+    custom_bundle_name : StringProperty(name='Merge Name', update=update_library_path)
+    #merge_library : EnumProperty(name='Merge Library', items=get_library_items, update=update_library_path)
+    #merge_name : StringProperty(name='Merge Name', update=update_library_path)
+
+    #Library when adding an asset to the library if merge with another
+    store_library: EnumProperty(items=get_store_library_items, name="Library")
+
+    template: StringProperty()
+    expand_extra : BoolProperty(name='Expand', default=False)
+    blend_depth : IntProperty(name='Blend Depth', default=0)
+
+    # source_directory : StringProperty(
+    #     name="Path",
+    #     subtype='DIR_PATH',
+    #     default='',
+    #     update=update_library_path
+    # )
+
+
+    #adapter : EnumProperty(items=adapter_ITEMS)
+    adapters : bpy.props.PointerProperty(type=AssetLibraryAdapters)
+    adapter_name : EnumProperty(items=get_adapter_items)
+
+    conform: bpy.props.PointerProperty(type=ConformAssetLibrary)
+
+    # data_file_path : StringProperty(
+    #     name="Path",
+    #     subtype='FILE_PATH',
+    #     default='',
+    # )
+
+    #expand_conform : BoolProperty(name='Expand Conform', default=False)
+
+    #def __init__(self):
+    #    self.adapters.parent = self
+
+    @property
+    def merge_libraries(self):
+       prefs = get_addon_prefs()
+       return [l for l in prefs.libraries if l != self and (l.library_path == self.library_path)]
+
+    @property
+    def data_types(self):
+        return f'{self.data_type.lower()}s'
+
+    @property
+    def adapter(self):
+        name = norm_str(self.adapter_name)
+        if not hasattr(self.adapters, name):
+            return
+
+        return getattr(self.adapters, name)
+
+    @property
+    def library(self):
+        prefs = get_addon_prefs()
+        asset_lib_ref = bpy.context.space_data.params.asset_library_ref
+
+        #TODO work also outside asset_library_area
+        if asset_lib_ref not in prefs.libraries:
+            return None
+        
+        return prefs.libraries[asset_lib_ref]
+
+    @property
+    def library_path(self):
+        prefs = get_addon_prefs()
+
+        library_name = self.library_name
+        #if not self.use_custom_bundle_name:
+        #    library_name = norm_str(library_name)
+
+        if self.use_custom_bundle_directory:
+            return Path(self.custom_bundle_directory, library_name).resolve()
+        else:
+            library_name = norm_str(library_name)
+            return Path(prefs.bundle_directory, library_name).resolve()
+
+    @property
+    def library_name(self):
+        if self.use_custom_bundle_name:
+            return self.custom_bundle_name
+        
+        return self.name
+
+    @property
+    def image_template(self):
+        prefs = get_addon_prefs()
+        return prefs.image_template
+
+    @property
+    def video_template(self):
+        prefs = get_addon_prefs()
+        return prefs.video_template
+
+    @property
+    def asset_description_template(self):
+        prefs = get_addon_prefs()
+        return prefs.asset_description_template
+
+    @property
+    def catalog_path(self):
+        return get_catalog_path(self.library_path)
+
+    @property
+    def options(self):
+        return {k: getattr(self.adapter, k) for k, v in self.options.bl_rna.properties.keys() if p !='rna_type'}
+
+    def clear_library_path(self):
+        #print('Clear Library Path', self.name)
+
+        prefs = bpy.context.preferences
+        libs = prefs.filepaths.asset_libraries
+
+        #path = self.library_path.as_posix()
+        
+        for l in reversed(libs):
+            #lib_path = Path(l.path).resolve().as_posix()
+
+            prev_name = self.get('asset_library') or self.library_name
+
+            #print(l.name, prev_name)
+
+            if (l.name == prev_name):
+                index = list(libs).index(l)
+                try:
+                    bpy.ops.preferences.asset_library_remove(index=index)
+                    return
+                except AttributeError:
+                    pass
+        
+        #print('No library removed')
+    
+    def set_dict(self, data, obj=None):
+        """"Recursive method to set all attribute from a dict to this instance"""
+        obj = obj or self
+
+        # Make shure the input dict is not modidied
+        data = data.copy()
+
+        #print(obj)
+
+        for key, value in data.items():
+            if isinstance(value, dict):
+                #print('Nested value', key)
+
+                if 'name' in value:
+                    setattr(obj, f'{key}_name', value.pop('name'))
+
+                self.set_dict(value, obj=getattr(obj, key))
+            
+            elif key in obj.bl_rna.properties.keys():
+                if key == 'id':
+                    value = str(value)
+                
+                elif key == 'custom_bundle_name':
+                    if not 'use_custom_bundle_name' in data.values():
+                        obj["use_custom_bundle_name"] = True
+                
+                elif isinstance(value, str):
+                    value = os.path.expandvars(value)
+                    value = os.path.expanduser(value)
+
+                obj[key] = value
+            
+            else:
+                print(f'Prop {key} of {obj} not exist')
+
+        self['bundle_directory'] = str(self.library_path)
+
+        if not self.custom_bundle_name:
+            self['custom_bundle_name'] = self.name
+
+        # self.adapter_name = data['adapter']
+        # if not self.adapter:
+        #     print(f"No adapter named {data['adapter']}")
+        #     return
+        
+
+        # for key, value in data.items():
+        #     if key == 'options':
+        #         for k, v in data['options'].items():
+        #             setattr(self.adapter, k, v)
+        #     elif key in self.bl_rna.properties.keys():
+        #         if key == 'id':
+        #             value = str(value)
+                
+        #         if key == 'custom_bundle_name':
+        #             if not 'use_custom_bundle_name' in data.values():
+        #                 self["use_custom_bundle_name"] = True
+
+        #         self[key] = value
+
+    def to_dict(self):
+        data = {p: getattr(self, p) for p in self.bl_rna.properties.keys() if p !='rna_type'}
+        data['options'] = self.adapter.to_dict()
+        data['adapter'] = data.pop('adapter_name')
+        del data['adapters']
+        return data
+
+    def set_library_path(self):
+        '''Update the Blender Preference Filepaths tab with the addon libraries'''
+
+        prefs = bpy.context.preferences
+
+        name = self.library_name
+        prev_name = self.get('asset_library') or name
+
+        lib = prefs.filepaths.asset_libraries.get(prev_name)
+        lib_path = self.library_path
+
+        #print('name', name)
+        #print('lib', lib)
+        #print('lib_path', lib_path)
+        #print('self.merge_library ', self.merge_library)
+        #print('prev_name', prev_name)
+        #print('\nset_library_path')
+        #print(f'{self.name=}, {prev_name=}, {lib_path=}, {self.use}')
+
+        if not lib_path:
+            self.clear_library_path()
+            return
+        
+        if not self.use:
+            if all(not l.use for l in self.merge_libraries):
+                self.clear_library_path()
+                return
+
+        # Create the Asset Library Path
+        if not lib:
+            try:
+                bpy.ops.preferences.asset_library_add(directory=str(lib_path))
+            except AttributeError:
+                return
+                
+            lib = prefs.filepaths.asset_libraries[-1]
+            
+        lib.name = name
+
+        self['asset_library'] = name
+        lib.path = str(lib_path)
+    
+    @property
+    def is_user(self):
+        prefs = get_addon_prefs()
+        return self in prefs.user_libraries.values()
+
+    @property
+    def is_env(self):
+        prefs = get_addon_prefs()
+        return self in prefs.env_libraries.values()
+
+    
+    def add_row(self, layout, data=None, prop=None, label='',
+            boolean=None, factor=0.39):
+        '''Act like the use_property_split but with much more control'''
+
+        enabled = True
+        split = layout.split(factor=factor, align=True)
+
+        row = split.row(align=False)
+        row.use_property_split = False
+        row.alignment= 'RIGHT'
+        row.label(text=str(label))
+        if boolean:
+            boolean_data = self
+            if isinstance(boolean, (list, tuple)):
+                boolean_data, boolean = boolean
+
+            row.prop(boolean_data, boolean, text='')
+            enabled = getattr(boolean_data, boolean)
+
+        row = split.row(align=True)
+        row.enabled = enabled
+
+        if isinstance(data, str):
+            row.label(text=data)
+        else:
+            row.prop(data or self, prop, text='')
+        
+        return split
+        
+
+    def draw_operators(self, layout):
+        row = layout.row(align=True)
+        row.alignment = 'RIGHT'
+        row.prop(self, 'adapter_name', text='')
+        row.prop(self, 'auto_bundle', text='', icon='UV_SYNC_SELECT')
+
+        row.operator("assetlib.diff", text='', icon='FILE_REFRESH').name = self.name
+
+        op = row.operator("assetlib.bundle", icon='MOD_BUILD', text='')
+        op.name = self.name
+
+        layout.separator(factor=3)
+
+    def draw_extra(self, layout):
+        #box = layout.box()
+
+        col = layout.column(align=False)
+
+        row = col.row(align=True)
+        row.use_property_split = False
+        #row.alignment = 'LEFT'
+        icon = "DISCLOSURE_TRI_DOWN" if self.expand_extra else "DISCLOSURE_TRI_RIGHT"
+        row.label(icon='BLANK1')
+        subrow = row.row(align=True)
+        subrow.alignment = 'LEFT'
+        subrow.prop(self, 'expand_extra', icon=icon, emboss=False, text="Conform Options")
+        #row.prop(self, 'expand_extra', text='', icon="OPTIONS", emboss=False)
+        #row.prop(self, 'expand_extra', emboss=False, text='Options')
+        #row.label(text='Conform Options')
+        subrow = row.row(align=True)
+        subrow.alignment = 'RIGHT'
+        subrow.prop(self.conform, "adapter_name", text='')
+
+        op = subrow.operator('assetlib.diff', text='', icon='FILE_REFRESH')#, icon='MOD_BUILD'
+        op.name = self.name
+        op.conform = True
+
+        op = subrow.operator('assetlib.bundle', text='', icon='MOD_BUILD')#, icon='MOD_BUILD'
+        op.name = self.name
+        op.directory = self.conform.directory
+        subrow.label(icon='BLANK1')
+        #subrow.separator(factor=3)
+
+        if self.expand_extra and self.conform.adapter:
+            col.separator()
+            #row = layout.row(align=True)
+            #row.label(text='Conform Library')
+            col.prop(self.conform, "directory")
+            col.prop(self.conform, "blend_depth")
+            col.prop(self.conform, "externalize_data")
+            col.prop(self.conform, "image_template", text='Image Template')
+            col.prop(self.conform, "video_template", text='Video Template')
+
+            col.separator()
+            self.conform.adapter.draw_prefs(col)              
+
+        col.separator()
+
+
+
+    def draw(self, layout):
+        prefs = get_addon_prefs()
+
+        box = layout.box()
+
+        row = box.row(align=True)
+        icon = "DISCLOSURE_TRI_DOWN" if self.expand else "DISCLOSURE_TRI_RIGHT"
+        row.prop(self, 'expand', icon=icon, emboss=False, text='')
+
+        if self.is_user:
+            row.prop(self, 'use', text='')
+            row.prop(self, 'data_type', icon_only=True, emboss=False)
+            row.prop(self, 'name', text='')
+
+            self.draw_operators(row)
+
+            index = prefs.user_libraries.index(self)
+            row.operator("assetlib.remove_user_library", icon="X", text='', emboss=False).index = index
+
+        else:
+            row.prop(self, 'use', text='')
+            row.label(icon=ICONS[self.data_type])
+            row.label(text=self.name)
+
+            self.draw_operators(row)
+
+            sub_row = row.row()
+            sub_row.enabled = False
+            sub_row.label(icon='FAKE_USER_ON')
+
+        if self.expand:
+            col = box.column(align=False)
+            col.use_property_split = True
+            #row = col.row(align=True)
+
+            row = self.add_row(col, 
+                prop="custom_bundle_name", 
+                boolean="use_custom_bundle_name", 
+                label='Custom Bundle Name')
+
+            row.enabled = not self.use_custom_bundle_directory
+
+            prop = "bundle_directory"
+            if self.use_custom_bundle_directory:
+                prop = "custom_bundle_directory"
+
+            self.add_row(col, prop=prop,
+                boolean="use_custom_bundle_directory", 
+                label='Custom Bundle Directory',
+            )
+
+            if self.adapter:
+                col.separator()
+                self.adapter.draw_prefs(col)
+            
+            col.separator()
+            self.draw_extra(col)
+            
+
+
+class Collections:
+    '''Util Class to merge multiple collections'''
+
+    collections = []
+
+    def __init__(self, *collection):
+        self.collections = collection
+
+        for col in collection:
+            #print('Merge methods')
+            for attr in dir(col):
+                if attr.startswith('_'):
+                    continue
+
+                value = getattr(col, attr)
+                #if not callable(value):
+                #    continue
+
+                setattr(self, attr, value)
+    
+    def __contains__(self, item):
+        if isinstance(item, str):
+            return item in self.to_dict()
+        else:
+            return item in self
+
+    def __iter__(self):
+        return self.to_list().__iter__()
+
+    def __getitem__(self, item):
+        if isinstance(item, int):
+            return self.to_list()[item]
+        else:
+            return self.to_dict()[item]
+    
+    def get(self, item, fallback=None):
+        return self.to_dict().get(item) or fallback
+
+    def to_dict(self):
+        return {k:v for c in self.collections for k, v in c.items()}
+
+    def to_list(self):
+        return [v for c in self.collections for v in c.values()]
+
+    def get_parent(self, item):
+        for c in self.collections:
+            if item in c.values():
+                return c
+
+    def index(self, item):
+        c = self.get_parent(item)
+
+        if not c:
+            return item in self
+        
+        return list(c.values()).index(item)
+
+
+#class AssetLibraryOptions(PropertyGroup):
+#    pass
+
+
+class AssetLibraryPrefs(AddonPreferences):
+    bl_idname = __package__
+
+    #action : bpy.props.PointerProperty(type=AssetLibraryPath)
+    #asset : bpy.props.PointerProperty(type=AssetLibraryPath)
+    #adapters = {}
+
+    image_player: StringProperty(default='')
+    video_player: StringProperty(default='')
+
+    adapter_directory : StringProperty(
+        name="Adapter Directory",
+        subtype='DIR_PATH'
+    )
+
+    env_libraries : CollectionProperty(type=AssetLibrary)
+    user_libraries : CollectionProperty(type=AssetLibrary)
+    expand_settings: BoolProperty(default=False)
+    bundle_directory : StringProperty(
+        name="Path",
+        subtype='DIR_PATH',
+        default='',
+        update=update_all_library_path
+    )
+
+    use_single_path : BoolProperty(default=True)
+    asset_description_template : StringProperty(default='../{name}_asset_description.json')
+    image_template : StringProperty(default='../{name}_image.png')
+    video_template : StringProperty(default='../{name}_video.mov')
+
+    config_directory : StringProperty(
+        name="Config Path",
+        subtype='FILE_PATH',
+        default=str(RESOURCES_DIR/"asset_library_config.json"),
+        update=update_library_config
+    )
+
+    def load_adapters(self):
+        from asset_library.adapters.adapter import AssetLibraryAdapter
+
+        #global ADAPTERS
+
+        print('\n------Load Adapters')
+        
+        ADAPTERS.clear()
+
+        adapter_files = list(ADAPTER_DIR.glob('*.py'))
+        if self.adapter_directory:
+            user_adapter_dir = Path(self.adapter_directory)
+            if user_adapter_dir.exists():
+                adapter_files += list(user_adapter_dir.glob('*.py'))
+
+        for adapter_file in adapter_files:
+            mod = import_module_from_path(adapter_file)
+
+            if adapter_file.stem.startswith('_'):
+                continue
+            
+            print(adapter_file)
+            for name, obj in inspect.getmembers(mod):
+
+                if not inspect.isclass(obj): 
+                    continue
+
+                print(obj.__bases__)
+                if not AssetLibraryAdapter in obj.__mro__:
+                    continue
+                
+                # Non registering base adapter
+                if obj is AssetLibraryAdapter or obj.name in (a.name for a in ADAPTERS): 
+                    continue
+
+                try:
+                    print(f'Register Plugin {name}')
+                    bpy.utils.register_class(obj)
+                    setattr(AssetLibraryAdapters, norm_str(obj.name), bpy.props.PointerProperty(type=obj))
+                    ADAPTERS.append(obj)
+
+                except Exception as e:
+                    print(f'Could not register adapter {name}')
+                    print(e)
+
+    @property
+    def libraries(self):
+        return Collections(self.env_libraries, self.user_libraries)
+
+    def draw(self, context):
+        prefs = get_addon_prefs()
+
+        layout = self.layout
+        #layout.use_property_split = True
+
+        main_col = layout.column(align=False)
+
+        box = main_col.box()
+        row = box.row(align=True)
+        icon = "DISCLOSURE_TRI_DOWN" if self.expand_settings else "DISCLOSURE_TRI_RIGHT"
+        row.prop(self, 'expand_settings', icon=icon, emboss=False, text='')
+        row.label(icon='PREFERENCES')
+        row.label(text='Settings')
+        #row.separator_spacer()
+        subrow = row.row()
+        subrow.alignment = 'RIGHT'
+        subrow.operator("assetlib.reload_addon", text='Reload Addon')
+
+        if prefs.expand_settings:
+            col = box.column(align=True)
+            col.use_property_split = True
+
+            #col.prop(self, 'use_single_path', text='Single Path')
+            col.prop(self, 'bundle_directory', text='Bundle Directory')
+
+            col.separator()
+
+            col.prop(self, 'adapter_directory')
+            col.prop(self, 'config_directory')
+
+            col.separator()
+
+            col.prop(self, 'asset_description_template', text='Asset Description Template', icon='COPY_ID')
+
+            col.separator()
+
+            col.prop(self, 'image_template', text='Image Template', icon='COPY_ID')
+            col.prop(self, 'image_player', text='Image Player') #icon='OUTLINER_OB_IMAGE'
+
+            col.separator()
+
+            col.prop(self, 'video_template', text='Video Template', icon='COPY_ID')
+            col.prop(self, 'video_player', text='Video Player') #icon='FILE_MOVIE'
+
+            col.separator()
+
+            col.operator("assetlib.add_user_library", text='Bundle All Libraries', icon='MOD_BUILD')
+
+        for lib in self.libraries:# list(self.env_libraries) + list(self.user_libraries):
+
+            lib.draw(main_col)
+
+        row = main_col.row()
+        row.alignment = 'RIGHT'
+        row.operator("assetlib.add_user_library", icon="ADD", text='', emboss=False)
+
+
+classes = (
+    AssetLibraryAdapters,
+    ConformAssetLibrary,
+    AssetLibrary,
+    AssetLibraryPrefs,
+)
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    
+    prefs = get_addon_prefs()
+
+    # Read Env and override preferences
+    bundle_dir = os.getenv('ASSETLIB_BUNDLE_DIR')
+    if bundle_dir:
+        prefs.bundle_directory = os.path.expandvars(bundle_dir)
+
+    config_dir = os.getenv('ASSETLIB_CONFIG_DIR')
+    if config_dir:
+        prefs.config_directory = os.path.expandvars(config_dir)
+
+    adapter_dir = os.getenv('ASSETLIB_ADAPTER_DIR')
+    if adapter_dir:
+        prefs.adapter_directory = os.path.expandvars(adapter_dir)
+    
+    prefs.load_adapters()
+
+def unregister():
+    for cls in reversed(list(classes) + ADAPTERS):
+        bpy.utils.unregister_class(cls)
+
+    ADAPTERS.clear()