Scene Manager: request publishes missing on this site

- Request (globe) on casting rows and loaded assets whose latest publish is not on this site, and Request Missing for all of them, through the new wtdcmds command wtd_request_revisions. Requested publishes show "requested, waiting for the download". - The version picker requests a version that is not on this site. - A 404 explains that the session is gone or wtdcmds is too old. - Fake server: car (vehicles) with a publish not on this site, wtd_request_revisions and /_test/download; 45 checks. - Tested live: car_paul modeling.blend v001 -> Requested. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Scene Manager: fixes from the first run against a real Libreflow
2026-10-27 11:45:17 +01:00 · 2026-10-27 11:30:46 +01:00 · 2026-10-27 11:15:02 +01:00 · 2026-10-27 11:15:02 +01:00
14 changed files with 2395 additions and 11 deletions
@@ -0,0 +1,99 @@
 # Melvile Tools: notes for Claude
 Blender add-on (Blender 5.2) for the Melvile pipeline at Walking The Dog: Sanity Check,
 Rename, Shot Viewer and Scene Manager panels in the 3D View sidebar (WTD tab). `README.md`
 is the user guide: keep it up to date with every user-visible change.
 ## Layout and conventions
 - `config.py`: every production value (prefixes, formats, patterns, modes). Values are
  read at run time (`config.X`, never copied at import) because a studio JSON file can
  override them (add-on preferences "Config Override", or `WTD_SANITY_CONFIG`).
  New tunable values go here, with a comment, and in the README's Configuration table.
 - `ui/panel.py`: all panels. Operators live with their tool (`rename.py`,
  `shot_viewer.py`, `scene_manager/`, `ui/operators.py` for the Sanity Check).
 - `checks/`: sanity checks, auto-registered (see README > For developers).
 - `__init__.py` deletes cached submodules on reload, so Reload Scripts picks up every file.
 - Versions: `blender_manifest.toml` and `bl_info` in `__init__.py` (keep both in sync).
 - Style: match the surrounding code; short docstrings, few comments, no heavy abstractions.
 ## Working with the user
 - Commits: when asked, create a branch from `master`, commit there (end with the
  Co-Authored-By line), and give the user the merge / push / branch-delete commands:
  they run them themselves. Only commit straight on `master` when told to.
 - Real Blender API facts beat memory: probe in headless Blender before relying on an API.
 ## Testing
 Blender binary: macOS `/Applications/Blender.app/Contents/MacOS/Blender`, Windows
 `blender.exe` from the install folder. Import the add-on in tests by putting the folder
 that contains this repo on `sys.path` and importing the repo folder name (see
 `dev/test_scene_manager.py`).
 - Headless: `blender -b --factory-startup --python-exit-code 1 --python <script> -- <args>`.
  Timers do not run in background mode: pump background jobs by hand
  (`scene_manager.ipc._poll()`).
 - UI: run Blender with a window (`--factory-startup <file.blend> --python <script>`, a
  .blend argument avoids the splash), drive it with `bpy.app.timers`, take screenshots with
  `bpy.ops.screen.screenshot_area`, quit with `bpy.ops.wm.quit_blender()`. A sidebar tab
  (`region.active_panel_category`) can only be set once the region has been drawn.
 - Scene Manager without Libreflow (`dev/`):
  1. `blender -b --factory-startup --python dev/make_test_assets.py -- <workdir>`
  2. `python dev/fake_libreflow.py <workdir>` (keep running; restart for a clean state)
  3. `blender -b --factory-startup --python-exit-code 1 --python dev/test_scene_manager.py -- <workdir>`
     (45 checks, "All checks passed"). `/_test/publish` and `/_test/download` simulate a new
     publish and a requested revision reaching this site.
  The fake server follows the real `wtdcmds` replies; check them against the real
  Libreflow when one is available.
 ## External pieces
 - Libreflow `wtdcmds` extension (commands used by the Scene Manager), on the share:
  `WG/_Dev/GIT/ndemaerschalk/_MELVILE/libreflow_dev_utils/dev/src/wtdcmds/`
  (`src/libreflow/extensions/wtdcmds/wtd_cmds.py`, `BLENDER_ADDON_BRIEF.md`).
  Server address/token: `~/.kabaret/ipc/server.json` (config `LIBREFLOW_SERVER_FILE`).
 - Add Camera Rigs extension: `bpy.ops.object.build_camera_rig(mode=...)` builds the
  Shot Viewer cameras. It finds its rigs by the `rig_id` custom property, not by name.
 - `tools_ops.py` "Get Oid" uses the separate kabaret Blender client (`bpy.ops.kabaret.cmds_call`).
 ## Design notes (found by testing)
 - Shot Viewer: shots are timeline markers bound to cameras, in one scene. Setting
  `scene.frame_current` does not switch the camera (only `frame_set` does): set
  `scene.camera` explicitly.
 - Scene Manager: tags live on `bpy.types.Library` only. Library overrides lose custom
  properties when they resync, so instances are traced back to their library (empty →
  `instance_collection.library`, override → `override_library.reference.library`).
 - `library.reload()` invalidates every Python reference to linked and override data:
  look IDs up again afterwards. In Blender 5.2 it also replaces the Library itself (renamed
  after its file, custom properties gone): `library.update()` finds it by path and restores
  the name and tags.
 - Removing a library leaves the libraries it linked indirectly (e.g. Blender's
  `geometry_nodes_essentials.blend`): `remove_unused_libraries()` drops the ones whose data
  is no longer used, never a managed library.
 - Background requests (`scene_manager.ipc.run`) hand results back through a timer;
  in callbacks, find scenes by name (`bpy.context.scene` is not reliable in timers).
 ## Real Libreflow (first run, 2026-10-27)
 - Kitsu asset types: `main_character`, `secondary_character`, `tertiary_character`,
  `main_props`, `secondary_props`, `set_props`, `vehicles`, `bg_location`, `bg_set`,
  `skies`, `setdress_bank`. The fake server uses the same names.
 - Paths come back as Windows paths with backslashes; `comment` can be `null`.
 - Set dressing publishes (`setdress_low`) hold a whole layout scene: the set is the
  `environments` collection, next to `lights`, `cameras`, `characters`, `_unused`.
 - Tested live: connection, context, casting, load (instance and override), version switch
  and update, remove, assetize errors, one request (`car_paul` modeling.blend v001 →
  `Requested`). Not tested: an actual assetize publish (it writes to production).
  New wtdcmds commands need every Libreflow session restarted (a running one keeps the
  old code and answers 404).
 ## Open points
 - Override vs instance per asset type (`SCENE_MANAGER_LINK_MODES`), and the file patterns
  of sets (`setdress_low` seen on one asset only): confirm with production.
 - The server picks the first file matching a pattern even when it is not on this site,
  while another matching file is (e.g. `car_paul`: `modeling/modeling.blend` v001 not
  available, `modeling/tes_modeling.blend` v002 available).
 - Values marked TODO in `config.py` wait for production specs.
@@ -5,6 +5,7 @@ Blender add-on for the Melvile pipeline (Walking The Dog). It brings together:
 - **[Sanity Check](#sanity-check)**: checks a file against the production specs and fixes what can be fixed.
 - **[Rename](#rename)**: batch renames objects and materials to the naming convention, with consistent numbering.
 - **[Shot Viewer](#shot-viewer)**: switch, create and delete the shots of a sequence (camera markers) from the sidebar, with quick access to the character and prop rigs.
 - **[Scene Manager](#scene-manager)**: loads the assets cast in a shot from Libreflow, keeps them up to date, and publishes scene collections as new assets.
 - **[Get Oid](#get-oid-for-open-scene)**: asks Libreflow for the id of the open file.
 Most values the tools rely on (prefixes, shot naming, frame rate…) live in `config.py` and can be overridden per studio without touching the code. See [Configuration](#configuration).
@@ -19,6 +20,7 @@ Most values the tools rely on (prefixes, shot naming, frame rate…) live in `co
 - [Tools panel](#tools-panel)
 - [Rename](#rename)
 - [Shot Viewer](#shot-viewer)
 - [Scene Manager](#scene-manager)
 - [Configuration](#configuration)
 - [Troubleshooting](#troubleshooting)
 - [For developers](#for-developers)
@@ -31,6 +33,8 @@ Tested on **Blender 5.2**.
 The Shot Viewer builds its cameras with the **Add Camera Rigs** extension (*Edit > Preferences > Get Extensions*, search "Add Camera Rigs"). Install and enable it next to Melvile Tools.
 The Scene Manager talks to a **running Libreflow** with the `wtdcmds` extension, on the same machine.
 **As an extension (artists):** build the package, then in Blender go to *Edit > Preferences > Get Extensions > Install from Disk…* and pick the `.zip`.
 ```bash
@@ -60,6 +64,7 @@ Open the sidebar of the 3D Viewport (**N**) and click the **WTD** tab.
 | **Tools** (Get Oid) | 3D Viewport |
 | **Rename** | 3D Viewport, Shader Editor |
 | **Shot Viewer** | 3D Viewport |
 | **Scene Manager** (Casting, Loaded, Assetize) | 3D Viewport |
 ---
@@ -307,7 +312,90 @@ The bottom of the panel lists the armatures of the scene, grouped into **Charact
 - **Shift+click**: adds it to the selection, to pose several rigs at once.
 - The rig(s) currently selected are highlighted.
-A rig counts as a character or a prop when its name, one of its collections, or the library file it comes from starts with `chr_` / `prp_` (see `SHOT_VIEWER_RIG_GROUPS` in [Configuration](#configuration)). Hidden rigs cannot be selected. Camera rigs (armatures carrying a camera) are not listed.
+A rig loaded by the [Scene Manager](#scene-manager) is grouped by its Libreflow asset type (`main_character`, `secondary_character`, `tertiary_character` → Characters; `main_props`, `secondary_props`, `vehicles` → Props; see `SHOT_VIEWER_ASSET_TYPE_GROUPS`). Otherwise, a rig counts as a character or a prop when its name, one of its collections, or the library file it comes from starts with `chr_` / `prp_` (see `SHOT_VIEWER_RIG_GROUPS` in [Configuration](#configuration)). Hidden rigs cannot be selected. Camera rigs (armatures carrying a camera) are not listed.
 ---
 ## Scene Manager
 Manages the assets of a shot by talking to the running Libreflow: it reads the shot's casting (from Kitsu), links the published files of the cast assets, flags the ones that are out of date, and publishes local collections as new assets.
 Everything goes through Libreflow: Blender never touches Kitsu or the Libreflow database. Requests run in the background, so Blender stays usable while Libreflow answers. What is in progress shows at the bottom of the main panel, with the last result (or error) under it.
 ### Connecting
 Start Libreflow, then open *WTD tab > **Scene Manager***. Blender connects on its own when it starts and when a file is opened. Click the refresh icon on the first line to connect again, for example after starting Libreflow.
 The first line shows the Libreflow session, the user and the site. When several Libreflow sessions are open, they are listed: click the one to work with.
 ### The shot (context)
 The field under the connection is the **context**: the Libreflow oid of the shot this file belongs to, like `/melvile/films/f01/sequences/s010/shots/p010`. It is saved in the file and does not change when you browse in Libreflow.
 - **Libreflow Oid**: takes the oid shown in the Libreflow window.
 - **Pick Shot**: search the shots of the project.
 A valid shot is confirmed under the field (`shot: f01 / s010 / p010`). The casting and the versions are then read on their own.
 ### Casting
 Lists the assets cast in the shot, with how many instances are loaded out of how many are cast (`2/2`):
 | Icon | Meaning |
 |---|---|
 | ✔ | Loaded. |
 | Import arrow | Not loaded (or fewer instances than cast): click it to load this asset only. |
 | ⚠ red | Cannot be loaded, with the reason from Libreflow: not found in the flow, no published file, or nothing available on this site yet. |
 | Globe | The latest publish is not on this site: click it to request it (see below). |
 | Hourglass | Requested, waiting for the download. |
 - **Load Missing** links every cast asset that is not loaded yet, and adds the missing instances. Running it again only adds what is missing.
 - **Request Missing** (shown when needed) asks Libreflow to download, on this site, the latest publish of every cast or loaded asset that is not here yet: the same as **Request** in Libreflow (from the exchange site, or from the site that published it). The download is done by the Libreflow sync: click **Refresh** later, then load or update.
 - **Refresh** reads the casting and the versions again.
 - **Loaded, no longer cast** lists assets loaded earlier that the shot's casting no longer contains.
 **What gets loaded:**
 - **File:** the latest publish **available on this site** of the asset's first file matching `rigging/*.blend`, then `modeling/*.blend` (sets, `bg_location`: `setdress_low/*.blend`).
 - **Collection:** from that file, `COL_<asset>`, else `<asset>`, else `environments` (set dressing files), else the file's only top-level collection.
 - **Characters, props and vehicles** (`*_character`, `main_props`, `secondary_props`, `vehicles`) become **library overrides**, so animators can pose them. Other types, like sets and set props, become **collection instances**.
 - **Where they go:** each asset type gets its own collection, `COL_main_character`, `COL_main_props`, `COL_bg_location`…
 All of these can be changed in the [Configuration](#configuration).
 ### Loaded
 Lists everything the Scene Manager loaded, one line per asset, with its version:
 - The version is **red** when it is not the latest publish. The line under it says either "v004 available" (click the update icon), or "v004 published, not available on this site yet" (click the globe to request it, then "v004 requested, waiting for the download").
 - **Arrow**: shows the asset's instances, each with a button to select its objects and one to remove it.
 - **Menu icon**: pick another published version, for example to roll back. Versions not on this site are marked: picking one requests it; pick it again once it is downloaded.
 - **✕**: removes the asset entirely: all its instances and the link to its file.
 - **Update All** / **Update Selected**: switch all the loaded assets (or the ones of the selected objects) to their latest available publish.
 - **Remove Selected**: removes the instances of the selected objects.
 - The magnifier re-checks the versions.
 Updating swaps the linked file and reloads it. Overrides keep their posing and animation. **Ctrl+Z** undoes removing and updating.
 ### Assetize
 Publishes a collection of the scene to Libreflow as its own `.blend`: a new asset, or a new version of an existing one.
 Click **Assetize Collection...** (in the *Assetize* sub-panel):
 | Setting | Use |
 |---|---|
 | **Collection** | Local collections only. Collections holding loaded assets are not offered. The active collection of the Outliner is picked by default. |
 | **Asset Type** | The Libreflow asset type (props, sets...). |
 | **Asset Name** | Letters, digits and underscores. Taken from the collection name, without its prefix (`COL_street_lamp` → `street_lamp`). The dialog says whether this makes a **new asset** or a **new version** of an existing one. |
 | **Asset Library** | Optional: publish under that asset library. |
 | **Task** | The asset task to publish in (default `modeling`). If it does not exist, the error lists the asset's tasks. |
 | **File Name** | Optional, defaults to the asset name. |
 | **Comment** | Saved with the revision. |
 | **Upload** | Also sends the revision to the exchange site. |
 | **Replace with the Publish** | On by default: once published, the local collection is replaced by a link to the published file, so the Scene Manager manages it like any other asset. The local collection stays in the file, unlinked, renamed `<name>_local`. |
 ---
 ---
@@ -346,7 +434,8 @@ Name formats use Python's `str.format`: `"sq{:04d}"` turns `10` into `sq0010`. `
 | Sanity Check: layout | `SET_COLLECTION_PATTERN` |
 | Sanity Check: panel | `CATEGORY_ORDER`, `MAX_ISSUES_DRAWN` |
 | Rename | `RENAME_SEPARATOR`, `RENAME_PADDING`, `RENAME_SIDES`, `RENAME_TYPE_SUFFIXES` (plus `OBJECT_PREFIXES` / `DATABLOCK_PREFIXES` for *By Type* prefixes) |
-| Shot Viewer | `SHOT_VIEWER_RIG_GROUPS`, `SHOT_NAME_FORMAT`, `SHOT_NUMBER_STEP`, `SHOT_FRAME_START`, `SHOT_DEFAULT_DURATION`, `SEQUENCE_NAME_FORMAT`, `SHOT_CAMERA_NAME_FORMAT`, `SHOT_CAMERA_RIG_NAME_FORMAT`, `SHOT_CAMERA_RIG_MODES` |
+| Shot Viewer | `SHOT_VIEWER_RIG_GROUPS`, `SHOT_VIEWER_ASSET_TYPE_GROUPS`, `SHOT_NAME_FORMAT`, `SHOT_NUMBER_STEP`, `SHOT_FRAME_START`, `SHOT_DEFAULT_DURATION`, `SEQUENCE_NAME_FORMAT`, `SHOT_CAMERA_NAME_FORMAT`, `SHOT_CAMERA_RIG_NAME_FORMAT`, `SHOT_CAMERA_RIG_MODES` |
 | Scene Manager | `LIBREFLOW_SERVER_FILE`, `LIBREFLOW_TIMEOUT`, `SCENE_MANAGER_FILE_PATTERNS`, `SCENE_MANAGER_COLLECTION_NAMES`, `SCENE_MANAGER_LINK_MODES`, `SCENE_MANAGER_TYPE_COLLECTION`, `SCENE_MANAGER_ASSETIZE_TASK` |
 ---
@@ -370,6 +459,18 @@ Only armatures in the scene's view layer are listed. A collection instance that
 **Shot Viewer: a shot is missing from the list.**
 Only markers bound to a camera are shots. Select the marker, select its camera, and press **Ctrl+B** in the Timeline.
 **Scene Manager: "Libreflow is not running".**
 Start Libreflow (with the `wtdcmds` extension), then click the refresh icon of the Scene Manager. Its IPC server stops 30 seconds after the last Libreflow session closes.
 **Scene Manager: an asset cannot be loaded.**
 Its red line says why. "No file matching..." means none of its files matches `SCENE_MANAGER_FILE_PATTERNS`. "No collection named..." means the file has none of `COL_<asset>`, `<asset>` or `environments`, and several top-level collections: rename the published collection, or add its name to `SCENE_MANAGER_COLLECTION_NAMES`.
 **Scene Manager: the version stays red after Update.**
 The newer version is published but not downloaded on this site yet. Request it (globe icon) if it is not requested yet, wait for the sync, then refresh and update again.
 **Scene Manager: "...its wtdcmds extension is too old".**
 Libreflow runs an older `wtdcmds` without the command (e.g. requests). Update the extension and restart Libreflow.
 **Shot Viewer: playback only plays one shot.**
 **Loop Shot** is on. Untick it to play the whole sequence.
@@ -390,6 +491,7 @@ Only markers bound to a camera are shots. Select the marker, select its camera,
 | `rename.py` | Rename tool (logic, settings, operator) |
 | `shot_viewer.py` | Shot Viewer (logic, settings, operators) |
 | `tools_ops.py` | Libreflow tools (Get Oid) |
 | `scene_manager/` | Scene Manager: `ipc.py` (Libreflow client and background jobs), `library.py` (linking, overrides, updates), `operators.py` |
 ### Adding a check
@@ -8,7 +8,7 @@ for _name in [name for name in sys.modules if name.startswith(__name__ + ".")]:
 import bpy  # noqa: E402
 from bpy.app.handlers import persistent  # noqa: E402
-from . import checks, core, rename, shot_viewer, tools_ops, ui  # noqa: E402
+from . import checks, core, rename, scene_manager, shot_viewer, tools_ops, ui  # noqa: E402
 from .core import runner  # noqa: E402
 api = core
@@ -49,6 +49,9 @@ def register() -> None:
    # Register the shot viewer (settings and operators, before its panel)
    shot_viewer.register()
    # Register the scene manager (settings and operators, before its panels)
    scene_manager.register()
    # Load all the sanity checks into the sanity REGISTRY
    checks.load_all()
@@ -80,6 +83,9 @@ def unregister() -> None:
    # Unregister the shot viewer (after its panel)
    shot_viewer.unregister()
    # Unregister the scene manager (after its panels)
    scene_manager.unregister()
    runner.clear()
    # The check registry is plain Python and is rebuilt with the modules on
    # re-import, so it is kept as is (enable/disable without re-import).
@@ -16,12 +16,14 @@ copyright = ["2026 WTD"]
 [permissions]
 files = "Read reference, config and sound files"
 network = "Talk to the local Libreflow server (Scene Manager)"
 [build]
 paths_exclude_pattern = [
  "__pycache__/",
  "/.git/",
  "docs/",
  "dev/",
  ".*",
  "*.blend",
  "*.md",
@@ -243,6 +243,15 @@ SHOT_VIEWER_RIG_GROUPS = {
    "Characters": r"(?i)^(?:chr|char)[_-]",
    "Props": r"(?i)^(?:prp|prop)[_-]",
 }
 # Rigs loaded by the Scene Manager are grouped by their Libreflow asset type first.
 SHOT_VIEWER_ASSET_TYPE_GROUPS = {
    "main_character": "Characters",
    "secondary_character": "Characters",
    "tertiary_character": "Characters",
    "main_props": "Props",
    "secondary_props": "Props",
    "vehicles": "Props",
 }
 # Shots added by the shot viewer. TODO: confirm with production.
 SHOT_NAME_FORMAT = "sh{:04d}"
@@ -259,6 +268,41 @@ SHOT_NUMBER_STEP = 10
 SHOT_FRAME_START = 1001
 SHOT_DEFAULT_DURATION = 48
 # --------------------------------------------------------------------------- #
 # Scene Manager (Libreflow)
 # --------------------------------------------------------------------------- #
 # Address and token of the Libreflow IPC server (kabaret.ipc).
 LIBREFLOW_SERVER_FILE = "~/.kabaret/ipc/server.json"
 # Seconds to wait for an answer (the server itself gives up after 10 s).
 LIBREFLOW_TIMEOUT = 15
 # Published file loaded for each asset type ("*" = the others): ordered
 # "task/file.ext" glob patterns, the first file of the asset matching one is loaded.
 # TODO: confirm the set publishes (only setdress_low seen so far).
 SCENE_MANAGER_FILE_PATTERNS = {
    "*": ["rigging/*.blend", "modeling/*.blend"],
    "bg_location": ["setdress_low/*.blend"],
 }
 # Collection linked from an asset file: the first of these names found ({asset}
 # = asset name), else the file's single top-level collection. "environments"
 # holds the set in the setdress files.
 SCENE_MANAGER_COLLECTION_NAMES = ["COL_{asset}", "{asset}", "environments"]
 # How an asset type (Kitsu name) is brought in: "OVERRIDE" (library override, posable)
 # or "INSTANCE" (collection instance). "*" = the other types. TODO: confirm with production.
 SCENE_MANAGER_LINK_MODES = {
    "main_character": "OVERRIDE",
    "secondary_character": "OVERRIDE",
    "tertiary_character": "OVERRIDE",
    "main_props": "OVERRIDE",
    "secondary_props": "OVERRIDE",
    "vehicles": "OVERRIDE",
    "*": "INSTANCE",
 }
 # Collection gathering the loaded assets of a type, under the scene collection.
 SCENE_MANAGER_TYPE_COLLECTION = "COL_{asset_type}"
 # Default task of the assetize dialog.
 SCENE_MANAGER_ASSETIZE_TASK = "modeling"
 # --------------------------------------------------------------------------- #
 # UI
 # --------------------------------------------------------------------------- #
@@ -0,0 +1,188 @@
 """Fake Libreflow IPC server (kabaret.ipc + wtdcmds commands) to test the Scene Manager.
    python dev/fake_libreflow.py <workdir>
 Serves a project with one shot casting bob (main_character, x2), tree (bg_set), rock (main_props),
 lamp (main_props, nothing published), car (vehicles, v001 not on this site) and ghost (not in the flow). The asset files come
 from dev/make_test_assets.py (<workdir>/lib). Writes <workdir>/kabaret/server.json:
 point config LIBREFLOW_SERVER_FILE to it (see dev/test_scene_manager.py).
 Test-only endpoints: POST /_test/publish {file_oid, name, available, path},
 POST /_test/download {revision_oid} (a requested revision reaches this site),
 POST /_test/sessions {uid: session}, POST /_test/calls (commands received).
 State lives in memory: restart the server for a clean state.
 """
 import json, os, shutil, sys, time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import urlparse, parse_qs
 ROOT = sys.argv[1]
 TOKEN = "secret-token"
 PROJECT = "/melvile"
 SHOT = "/melvile/films/f01/sequences/s010/shots/p010"
 SESSIONS = {"uid-1": {"session_name": "libreflow_dev", "cluster_name": "melvile", "is_gui": True, "current_oid": SHOT}}
 def rev(name, path, available=True, comment=""):
    return {"name": name, "oid": f"x/history/revisions/{name}", "path": path, "sync_status": "Available" if available else "NotAvailable",
            "available": available, "date": time.time(), "user": "nero", "comment": comment}
 ASSETS = {  # asset oid -> (type, {file_oid: (label, [revisions oldest first])})
    f"{PROJECT}/asset_types/main_character/assets/bob": ("main_character", {f"{PROJECT}/asset_types/main_character/assets/bob/tasks/rigging/files/rig_blend": ("rigging/rig.blend", [
        rev("v001", f"{ROOT}/lib/bob/v001/rig.blend"), rev("v002", f"{ROOT}/lib/bob/v002/rig.blend", comment="two meshes")])}),
    f"{PROJECT}/asset_types/bg_set/assets/tree": ("bg_set", {f"{PROJECT}/asset_types/bg_set/assets/tree/tasks/modeling/files/model_blend": ("modeling/model.blend", [
        rev("v001", f"{ROOT}/lib/tree/v001/model.blend")])}),
    f"{PROJECT}/asset_types/main_props/assets/rock": ("main_props", {f"{PROJECT}/asset_types/main_props/assets/rock/tasks/modeling/files/rock_blend": ("modeling/rock.blend", [
        rev("v001", f"{ROOT}/lib/rock/v001/rock.blend")])}),
    f"{PROJECT}/asset_types/main_props/assets/lamp": ("main_props", {}),
    f"{PROJECT}/asset_types/vehicles/assets/car": ("vehicles", {f"{PROJECT}/asset_types/vehicles/assets/car/tasks/rigging/files/car_blend": ("rigging/car.blend", [
        rev("v001", f"{ROOT}/lib/car/v001/car.blend", available=False)])}),
 }
 CASTING = [("bob", "main_character", 2), ("tree", "bg_set", 1), ("rock", "main_props", 1), ("lamp", "main_props", 1), ("car", "vehicles", 1), ("ghost", "main_character", 1)]
 CALLS = []
 def set_oids():
    for _a, (_t, files) in ASSETS.items():
        for f, (_l, revs) in files.items():
            for r in revs: r["oid"] = f"{f}/history/revisions/{r['name']}"
 def find_rev(oid):
    return next((r for _a, (_t, files) in ASSETS.items() for _l, revs in files.values() for r in revs if r["oid"] == oid), None)
 set_oids()
 def file_data(file_oid):
    for asset_oid, (atype, files) in ASSETS.items():
        if file_oid in files:
            label, revs = files[file_oid]
            avail = [r for r in revs if r["available"]]
            return {"label": label, "file_oid": file_oid, "latest": revs[-1] if revs else None, "latest_available": avail[-1] if avail else None}
    raise ValueError(f"No file {file_oid}")
 def context(oid):
    parts = oid.strip("/").split("/")
    if oid.startswith(PROJECT + "/films"):
        return {"oid": oid, "kind": "shot", "project": "melvile", "film": parts[2], "film_oid": "/".join([""] + parts[:3]),
                "sequence": parts[4], "sequence_oid": "/".join([""] + parts[:5]), "shot": parts[6], "shot_oid": SHOT}
    if "/assets/" in oid:
        return {"oid": oid, "kind": "asset", "project": "melvile", "asset_type": parts[2], "asset": parts[4]}
    if oid == PROJECT:
        return {"oid": oid, "kind": "project", "project": "melvile"}
    raise ValueError(f"Oid {oid} does not exist")
 def cmd(name, kw):
    import fnmatch
    if name == "wtd_ping":
        return {"version": "0.1.0", **({"project": "melvile", "user": "nero", "site": "lyon", "root": ROOT} if kw.get("oid") else {})}
    if name == "wtd_get_context":
        return context(kw["oid"])
    if name == "wtd_list_shots":
        return [context(SHOT), context(SHOT.replace("p010", "p020"))]
    if name == "wtd_list_assets":
        return [context(oid) for oid in ASSETS]
    if name == "wtd_get_casting_publishes":
        if not kw["oid"].startswith(SHOT):
            raise ValueError("Not a shot")
        patterns = kw.get("file_patterns") or ["*/*.blend"]
        out = []
        for aname, atype, nb in CASTING:
            oid = next((o for o in ASSETS if o.endswith("/assets/" + aname)), None)
            a = {"name": aname, "kitsu_id": "k-" + aname, "asset_type": atype, "nb_occurences": nb, "label": "animate", "oid": oid, "candidates": [oid] if oid else [], "file": None, "error": None}
            if oid is None:
                a["error"] = "Asset not found in the flow"
            else:
                files = ASSETS[oid][1]
                match = next((f for p in patterns for f, (label, _r) in files.items() if fnmatch.fnmatchcase(label, p)), None)
                if match is None:
                    a["error"] = "No file matching " + ", ".join(patterns)
                else:
                    a["file"] = file_data(match)
                    if a["file"]["latest_available"] is None:
                        a["error"] = "No published revision available on this site"
            out.append(a)
        return {"shot_oid": SHOT, "assets": out}
    if name == "wtd_get_latest_revisions":
        res = {}
        for f in kw["file_oids"]:
            try: res[f] = file_data(f)
            except ValueError as exc: res[f] = {"file_oid": f, "error": str(exc)}
        return res
    if name == "wtd_get_revisions":
        for _a, (_t, files) in ASSETS.items():
            if kw["file_oid"] in files:
                return list(reversed(files[kw["file_oid"]][1]))
        raise ValueError("No file")
    if name == "wtd_request_revisions":
        res = {}
        for oid in kw["revision_oids"]:
            r = find_rev(oid)
            if r is None:
                res[oid] = {"oid": oid, "error": f"Could not find {oid}"}; continue
            if not r["available"]: r["sync_status"] = "Requested"
            res[oid] = r
        return res
    if name == "wtd_assetize":
        src = kw["source_path"]
        if not os.path.isfile(src): raise ValueError(f"Source file {src} does not exist")
        atype, aname, task = kw["asset_type"], kw["asset_name"], kw["task"]
        asset_oid = f"{PROJECT}/asset_types/{atype}/assets/{aname}"
        created = asset_oid not in ASSETS
        if created and not kw.get("create_asset"):
            raise ValueError(f"Asset {aname} does not exist (pass create_asset=true to create it)")
        if task not in ("modeling", "rigging"):
            raise ValueError(f"Task {task} does not exist on {asset_oid} (available: modeling, rigging)")
        fname = kw.get("file_name") or aname
        ASSETS.setdefault(asset_oid, (atype, {}))
        files = ASSETS[asset_oid][1]
        file_oid = f"{asset_oid}/tasks/{task}/files/{fname}_blend"
        label, revs = files.setdefault(file_oid, (f"{task}/{fname}.blend", []))
        name = f"v{len(revs) + 1:03d}"
        dest = f"{ROOT}/lib/{aname}/{name}/{fname}.blend"; os.makedirs(os.path.dirname(dest), exist_ok=True); shutil.copy(src, dest)
        revs.append(rev(name, dest, comment=kw.get("comment", ""))); set_oids()
        return {"asset_oid": asset_oid, "asset_created": created, **file_data(file_oid)}
    raise KeyError(name)
 class Handler(BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def reply(self, code, body):
        data = json.dumps(body).encode(); self.send_response(code); self.send_header("Content-Type", "application/json"); self.send_header("Content-Length", str(len(data))); self.end_headers(); self.wfile.write(data)
    def auth(self):
        if self.headers.get("Authorization") != f"Bearer {TOKEN}":
            self.reply(401, {"detail": "Invalid token"}); return False
        return True
    def do_GET(self):
        if not self.auth(): return
        if self.path == "/sessions": return self.reply(200, SESSIONS)
        self.reply(404, {"detail": "Not found"})
    def do_POST(self):
        if not self.auth(): return
        url = urlparse(self.path); qs = parse_qs(url.query)
        body = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))) or b"{}")
        if url.path == "/_test/publish":  # simulate a new publish
            f = body["file_oid"]
            for _a, (_t, files) in ASSETS.items():
                if f in files: files[f][1].append(rev(body["name"], body.get("path", "/nowhere/" + body["name"]), body.get("available", True)))
            set_oids()
            return self.reply(200, {"result": True})
        if url.path == "/_test/download":
            r = find_rev(body["revision_oid"]); r["available"] = True; r["sync_status"] = "Available"
            return self.reply(200, {"result": True})
        if url.path == "/_test/sessions":
            SESSIONS.clear(); SESSIONS.update(body); return self.reply(200, {"result": True})
        if url.path == "/_test/calls":
            return self.reply(200, {"result": CALLS})
        name = url.path.rsplit("/", 1)[-1]
        uid = qs.get("session_uid", [None])[0]
        if uid is None and len(SESSIONS) > 1: return self.reply(400, {"detail": "Several sessions connected: session_uid required"})
        if uid is not None and uid not in SESSIONS: return self.reply(404, {"detail": f"Session {uid} not found"})
        CALLS.append([name, body.get("kwargs", {})])
        try:
            return self.reply(200, {"result": cmd(name, body.get("kwargs", {}))})
        except KeyError as exc: return self.reply(404, {"detail": f"Unknown command {exc}"})
        except Exception as exc: return self.reply(500, {"detail": str(exc)})
 server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
 os.makedirs(f"{ROOT}/kabaret", exist_ok=True)
 with open(f"{ROOT}/kabaret/server.json", "w") as fh:
    json.dump({"host": "127.0.0.1", "port": server.server_address[1], "token": TOKEN, "pid": os.getpid()}, fh)
 print("listening", server.server_address[1], flush=True)
 server.serve_forever()
@@ -0,0 +1,61 @@
 """Write the asset files used by fake_libreflow.py into <workdir>/lib.
    blender -b --factory-startup --python dev/make_test_assets.py -- <workdir>
 bob: a rig (COL_bob: armature + meshes), v001 has 1 mesh, v002 has 2.
 tree: COL_tree, plus an unrelated top-level collection.
 car: COL_car.
 rock: a single top-level collection not named after the asset (fallback case), its mesh
 using a node group linked from Blender's essentials (an indirect library).
 """
 import os
 import sys
 import bpy
 WORKDIR = sys.argv[sys.argv.index("--") + 1]
 def mesh_object(name):
    mesh = bpy.data.meshes.new(name)
    mesh.from_pydata([(0, 0, 0), (1, 0, 0), (0, 1, 0)], [], [(0, 1, 2)])
    return bpy.data.objects.new(name, mesh)
 def write(path, collection_name, meshes=1, rig=False, extra=False, node_group=False):
    bpy.ops.wm.read_homefile(use_empty=True)
    scene = bpy.context.scene
    collection = bpy.data.collections.new(collection_name)
    scene.collection.children.link(collection)
    parent = None
    if rig:
        parent = bpy.data.objects.new("RIG_" + collection_name, bpy.data.armatures.new("RIG_" + collection_name))
        collection.objects.link(parent)
        bpy.context.view_layer.objects.active = parent
        bpy.ops.object.mode_set(mode="EDIT")
        bone = parent.data.edit_bones.new("root")
        bone.tail = (0, 0, 1)
        bpy.ops.object.mode_set(mode="OBJECT")
    for index in range(meshes):
        ob = mesh_object(f"GEO_{collection_name}_{index}")
        ob.parent = parent
        collection.objects.link(ob)
    if node_group:
        essentials = os.path.join(bpy.utils.system_resource("DATAFILES"), "assets", "nodes", "geometry_nodes_essentials.blend")
        with bpy.data.libraries.load(essentials, link=True) as (_data_from, data_to):
            data_to.node_groups = ["Smooth by Angle"]
        ob.modifiers.new("Smooth", "NODES").node_group = data_to.node_groups[0]
    if extra:
        scene.collection.children.link(bpy.data.collections.new("WIP_other"))
    os.makedirs(os.path.dirname(path), exist_ok=True)
    bpy.ops.wm.save_as_mainfile(filepath=path)
 lib = os.path.join(WORKDIR, "lib")
 write(os.path.join(lib, "bob", "v001", "rig.blend"), "COL_bob", meshes=1, rig=True, extra=True)
 write(os.path.join(lib, "bob", "v002", "rig.blend"), "COL_bob", meshes=2, rig=True, extra=True)
 write(os.path.join(lib, "tree", "v001", "model.blend"), "COL_tree", extra=True)
 write(os.path.join(lib, "rock", "v001", "rock.blend"), "rock_geo", node_group=True)
 write(os.path.join(lib, "car", "v001", "car.blend"), "COL_car")
 print("Test assets written in", lib)
@@ -0,0 +1,249 @@
 """End-to-end test of the Scene Manager against dev/fake_libreflow.py.
    blender -b --factory-startup --python dev/make_test_assets.py -- <workdir>
    python dev/fake_libreflow.py <workdir>          (keep it running, fresh state)
    blender -b --factory-startup --python-exit-code 1 --python dev/test_scene_manager.py -- <workdir>
 Prints every check and exits with an error when one fails. Timers do not run in
 background mode, so the test runs the background-job poller itself (pump).
 """
 import importlib
 import json
 import os
 import sys
 import time
 import urllib.request
 import bpy
 WORKDIR = sys.argv[sys.argv.index("--") + 1]
 REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, os.path.dirname(REPO))
 PACKAGE = os.path.basename(REPO)
 addon = importlib.import_module(PACKAGE)
 addon.register()
 config = sys.modules[PACKAGE + ".config"]
 ipc = sys.modules[PACKAGE + ".scene_manager.ipc"]
 sm = sys.modules[PACKAGE + ".scene_manager.operators"]
 lib = sys.modules[PACKAGE + ".scene_manager.library"]
 shot_viewer = sys.modules[PACKAGE + ".shot_viewer"]
 SERVER_FILE = os.path.join(WORKDIR, "kabaret", "server.json")
 config.LIBREFLOW_SERVER_FILE = SERVER_FILE
 SHOT = "/melvile/films/f01/sequences/s010/shots/p010"
 BOB_FILE = "/melvile/asset_types/main_character/assets/bob/tasks/rigging/files/rig_blend"
 CAR = "/melvile/asset_types/vehicles/assets/car"
 CAR_FILE = CAR + "/tasks/rigging/files/car_blend"
 FAILED = []
 def check(label, condition, detail=""):
    print(("  ok    " if condition else "  FAIL  ") + label + (f"  ({detail})" if detail else ""))
    if not condition:
        FAILED.append(label)
 def pump(timeout=15):
    end = time.time() + timeout
    while ipc._jobs or not ipc._results.empty():
        ipc._poll()
        if time.time() > end:
            check("background jobs finish", False, str(ipc._jobs))
            return
        time.sleep(0.05)
 def fake(path, body):
    info = json.load(open(SERVER_FILE))
    request = urllib.request.Request(
        f"http://127.0.0.1:{info['port']}{path}",
        data=json.dumps(body).encode(),
        method="POST",
        headers={"Authorization": "Bearer " + info["token"], "Content-Type": "application/json"},
    )
    return json.loads(urllib.request.urlopen(request).read())["result"]
 def loaded():
    found = lib.all_instances()
    return {
        library.name: (library.get("wtd_revision"), [i.name for i in found.get(library.name, [])])
        for library in lib.managed_libraries()
    }
 def message():
    return sm.STATE.message[0]
 bpy.ops.wm.read_homefile(use_empty=True)
 scene = bpy.context.scene
 print("Connection")
 sm.connect(scene)
 pump()
 check("connected to the session", sm.connected() and sm.current_session().get("session_name") == "libreflow_dev")
 check("user and site known", sm.STATE.ping.get("user") == "nero" and sm.STATE.ping.get("site") == "lyon")
 print("Context")
 scene.wtd_scene_manager.context_oid = "/melvile/nope"
 pump()
 check("invalid oid reported", not sm.context_label("/melvile/nope")[1])
 scene.wtd_scene_manager.context_oid = SHOT
 pump()
 check("shot context validated", sm.context_label(SHOT) == ("shot: f01 / s010 / p010", True))
 errors = {a["name"]: a["error"] for a in sm.STATE.casting.get(SHOT, {}).get("assets", [])}
 check("casting read", set(errors) == {"bob", "tree", "rock", "lamp", "car", "ghost"}, str(errors))
 print("Load")
 bpy.ops.wtd_scene.load()
 pump()
 state = loaded()
 check("bob: 2 instances of v002", state.get("bob") == ("v002", ["COL_bob", "COL_bob.001"]), str(state.get("bob")))
 check("tree: 1 collection instance", state.get("tree") == ("v001", ["tree"]), str(state.get("tree")))
 check("rock: single top-level collection fallback", state.get("rock") == ("v001", ["rock_geo"]))
 check("lamp and ghost reported", "lamp" in message() and "ghost" in message(), message())
 check("type collections", {"COL_main_character", "COL_bg_set", "COL_main_props"} <= set(scene.collection.children.keys()))
 check(
    "chars are posable overrides",
    all(ob.override_library for ob in bpy.data.collections["COL_bob"].all_objects),
 )
 check("shot viewer groups bob as character", "Characters" in shot_viewer.rig_groups(bpy.context.view_layer))
 bpy.ops.wtd_scene.load()
 pump()
 check("load again adds nothing", message().startswith("Nothing new to load"), message())
 print("Request")
 check("car can be requested", sm.missing_files(scene) == [CAR_FILE], str(sm.missing_files(scene)))
 bpy.ops.wtd_scene.request()
 pump()
 check("car v001 requested", message() == "Requested car v001", message())
 check("nothing left to request", sm.missing_files(scene) == [])
 calls = fake("/_test/calls", {})
 check("request sent to Libreflow", ["wtd_request_revisions", {"revision_oids": [CAR_FILE + "/history/revisions/v001"]}] in calls)
 fake("/_test/download", {"revision_oid": CAR_FILE + "/history/revisions/v001"})
 bpy.ops.wtd_scene.refresh()
 pump()
 bpy.ops.wtd_scene.load(asset_oid=CAR)
 pump()
 check("car loaded once downloaded", loaded().get("car", (None,))[0] == "v001", message())
 print("Versions")
 check("bob is the latest", sm.version_status(bpy.data.libraries["bob"])[0] == "LATEST")
 fake("/_test/publish", {"file_oid": BOB_FILE, "name": "v003", "available": False})
 sm.refresh_versions()
 pump()
 check("v003 not on this site: pending", sm.version_status(bpy.data.libraries["bob"])[0] == "PENDING")
 bpy.ops.wtd_scene.request(file_oid=BOB_FILE)
 pump()
 status = sm.version_status(bpy.data.libraries["bob"])
 check("v003 requested", status == ("PENDING", "v003 requested, waiting for the download"), str(status))
 fake(
    "/_test/publish",
    {"file_oid": BOB_FILE, "name": "v004", "available": True, "path": os.path.join(WORKDIR, "lib", "bob", "v001", "rig.blend")},
 )
 sm.refresh_versions()
 pump()
 check("v004 available: update", sm.version_status(bpy.data.libraries["bob"])[0] == "UPDATE")
 bpy.ops.wtd_scene.update(library="bob")
 pump()
 check("bob updated to v004", loaded()["bob"][0] == "v004", message())
 meshes = {c.name: len([o for o in c.all_objects if o.type == "MESH"]) for c in lib.instances(bpy.data.libraries["bob"])}
 check("overrides resynced to v004 (1 mesh)", set(meshes.values()) == {1}, str(meshes))
 print("Version picker")
 sm.STATE.revisions[BOB_FILE] = ipc.call("wtd_get_revisions", None, file_oid=BOB_FILE)
 sm._REVISION_ITEMS[:] = [(r["name"], r["name"], "", "NONE", i) for i, r in enumerate(sm.STATE.revisions[BOB_FILE])]
 bpy.ops.wtd_scene.pick_revision("EXEC_DEFAULT", library="bob", revision="v002")
 check("rolled back to v002", loaded()["bob"][0] == "v002")
 check("unavailable v003 refused", bpy.ops.wtd_scene.pick_revision("EXEC_DEFAULT", library="bob", revision="v003") == {"CANCELLED"})
 fake("/_test/publish", {"file_oid": BOB_FILE, "name": "v005", "available": False})
 sm.STATE.revisions[BOB_FILE] = ipc.call("wtd_get_revisions", None, file_oid=BOB_FILE)
 sm._REVISION_ITEMS[:] = [(r["name"], r["name"], "", "NONE", i) for i, r in enumerate(sm.STATE.revisions[BOB_FILE])]
 bpy.ops.wtd_scene.pick_revision("EXEC_DEFAULT", library="bob", revision="v005")
 pump()
 check("picking a version not on this site requests it", message() == "Requested bob v005", message())
 check("still on v002", loaded()["bob"][0] == "v002")
 print("Remove")
 bpy.ops.wtd_scene.remove(instance="COL_bob.001")
 check("one instance removed", loaded()["bob"][1] == ["COL_bob"])
 for ob in bpy.context.view_layer.objects:
    ob.select_set(False)
 bpy.data.objects["tree"].select_set(True)
 bpy.ops.wtd_scene.remove(selected=True)
 check("selected instance removed", loaded()["tree"][1] == [])
 bpy.ops.wtd_scene.remove("EXEC_DEFAULT", library="rock")
 check("whole asset removed", "rock" not in bpy.data.libraries)
 check("its indirect library removed too", set(bpy.data.libraries.keys()) == {"bob", "car", "tree"}, str(bpy.data.libraries.keys()))
 bpy.ops.wtd_scene.load()
 pump()
 check("load restores what is missing", {k: len(v[1]) for k, v in loaded().items()} == {"bob": 2, "car": 1, "rock": 1, "tree": 1})
 print("Ambiguous file")
 try:
    lib.link_asset(
        {"name": "zzz", "oid": "x", "asset_type": "main_props", "file": {"file_oid": "f"}},
        {"name": "v1", "path": os.path.join(WORKDIR, "lib", "bob", "v001", "rig.blend")},
        SHOT,
    )
    check("ambiguous file refused", False)
 except lib.LoadError as exc:
    check("ambiguous file refused", "top-level collections" in str(exc), str(exc))
 print("Assetize")
 local = bpy.data.collections.new("COL_lamp")
 scene.collection.children.link(local)
 local.objects.link(bpy.data.objects.new("GEO_lamp", bpy.data.meshes.new("GEO_lamp")))
 check("only free local collections offered", [c.name for c in lib.assetize_candidates()] == ["COL_lamp"])
 sm.STATE.assets = ipc.call("wtd_list_assets", None, oid=SHOT)
 bpy.ops.wtd_scene.assetize(
    "EXEC_DEFAULT", collection="COL_lamp", asset_type="main_props", asset_name="lamp", task="modeling", comment="test"
 )
 pump()
 check("published and replaced", "replaced" in message(), message())
 check("lamp linked", loaded().get("lamp") == ("v001", ["COL_lamp"]), str(loaded().get("lamp")))
 check("local collection kept, renamed", "COL_lamp_local" in bpy.data.collections)
 bad = bpy.data.collections.new("COL_bad")
 scene.collection.children.link(bad)
 bpy.ops.wtd_scene.assetize("EXEC_DEFAULT", collection="COL_bad", asset_type="main_props", asset_name="bad", task="layout")
 pump()
 check("unknown task reported", "available: modeling, rigging" in message(), message())
 print("Save / reopen")
 path = os.path.join(WORKDIR, "scene_manager_test.blend")
 bpy.ops.wm.save_as_mainfile(filepath=path)
 bpy.ops.wm.open_mainfile(filepath=path)
 sm._on_load_post()
 check("everything found after reopening", set(loaded()) == {"bob", "car", "lamp", "rock", "tree"})
 sm.connect(bpy.context.scene)
 pump()
 check("versions checked again", sm.version_status(bpy.data.libraries["bob"])[0] == "UPDATE")
 print("Several sessions")
 fake(
    "/_test/sessions",
    {
        "uid-1": {"session_name": "a", "cluster_name": "melvile", "is_gui": True, "current_oid": SHOT},
        "uid-2": {"session_name": "b", "cluster_name": "melvile", "is_gui": False, "current_oid": "/melvile"},
    },
 )
 bpy.context.window_manager.wtd_libreflow.session_uid = ""
 sm.connect(bpy.context.scene)
 pump()
 check("asks to pick a session", "pick one" in message(), message())
 bpy.ops.wtd_scene.select_session(uid="uid-2")
 pump()
 check("works once a session is picked", sm.context_label(SHOT)[1])
 print("Libreflow not running")
 config.LIBREFLOW_SERVER_FILE = os.path.join(WORKDIR, "missing.json")
 sm.connect(bpy.context.scene)
 pump()
 check("reported as not running", not sm.connected() and sm.STATE.connection_error == "Libreflow is not running")
 addon.unregister()
 print(f"\n{len(FAILED)} check(s) failed: {', '.join(FAILED)}" if FAILED else "\nAll checks passed")
 if FAILED:
    raise RuntimeError(f"{len(FAILED)} Scene Manager check(s) failed")
@@ -0,0 +1,15 @@
 """Scene Manager: load, update and publish the assets of a shot through Libreflow.
 Libreflow is reached through its IPC server (``ipc``), the linked assets are
 handled in ``library`` and the operators in ``operators``.
 """
 from . import operators
 def register():
    operators.register()
 def unregister():
    operators.unregister()
@@ -0,0 +1,150 @@
 """Client of the Libreflow IPC server (kabaret.ipc) and its wtdcmds commands.
 The server writes its address and token in ``config.LIBREFLOW_SERVER_FILE``.
 The file is read again on every request: the port changes each time the
 server restarts.
 ``run`` executes a request in a worker thread and hands the result back on
 Blender's main thread, so the UI never waits on the network.
 """
 import json
 import os
 import queue
 import threading
 import traceback
 import urllib.error
 import urllib.parse
 import urllib.request
 import bpy
 from .. import config
 # Hints added to the server's message for the statuses the user can act on.
 _STATUS_HINTS = {
    401: "the server refused the token, try again",
    404: "the Libreflow session is gone, or its wtdcmds extension is too old: update it and restart Libreflow",
    504: "no answer within 10 s, the command may still complete in Libreflow",
 }
 # Statuses whose message replaces the server's.
 _STATUS_MESSAGES = {400: "Several Libreflow sessions are connected: pick one in the Scene Manager panel"}
 class LibreflowError(Exception):
    """A request failed. ``status`` is the HTTP status, None when the server was not reached."""
    def __init__(self, message, status=None):
        super().__init__(message)
        self.status = status
 class NotRunning(LibreflowError):
    """No IPC server: Libreflow is not running."""
 def server_info():
    path = os.path.expanduser(config.LIBREFLOW_SERVER_FILE)
    try:
        with open(path, encoding="utf-8") as fh:
            return json.load(fh)
    except FileNotFoundError:
        raise NotRunning("Libreflow is not running") from None
    except (OSError, ValueError) as exc:
        raise LibreflowError(f"Cannot read {path}: {exc}") from None
 def _request(method, path, body=None, params=None):
    info = server_info()
    url = f"http://{info['host']}:{info['port']}{path}"
    if params:
        url += "?" + urllib.parse.urlencode(params)
    request = urllib.request.Request(
        url,
        data=None if body is None else json.dumps(body).encode(),
        headers={"Authorization": f"Bearer {info['token']}", "Content-Type": "application/json"},
        method=method,
    )
    try:
        with urllib.request.urlopen(request, timeout=config.LIBREFLOW_TIMEOUT) as response:
            return json.loads(response.read() or b"null")
    except urllib.error.HTTPError as exc:
        try:
            detail = json.loads(exc.read() or b"{}").get("detail", exc.reason)
        except ValueError:
            detail = exc.reason
        hint = _STATUS_HINTS.get(exc.code)
        message = _STATUS_MESSAGES.get(exc.code) or (f"{detail} ({hint})" if hint else str(detail))
        raise LibreflowError(message, exc.code) from None
    except (urllib.error.URLError, OSError) as exc:
        raise NotRunning(f"Libreflow is not reachable ({getattr(exc, 'reason', exc)})") from None
 def sessions():
    """{session_uid: {session_name, cluster_name, is_gui, current_oid}} of the connected sessions."""
    return _request("GET", "/sessions") or {}
 def call(cmd_name, session_uid=None, **kwargs):
    """Run a Flow command and return its result."""
    params = {"session_uid": session_uid} if session_uid else None
    return _request("POST", f"/cmds/Flow/{cmd_name}", {"kwargs": kwargs}, params)["result"]
 # --------------------------------------------------------------------------- #
 # Background jobs
 # --------------------------------------------------------------------------- #
 _results = queue.Queue()
 _jobs = {}  # job id -> label, for the jobs not finished yet
 _generation = 0  # bumped on file load: results of older jobs are dropped
 _next_id = 0
 def run(label, func, on_success, on_error):
    """Run ``func()`` in a thread, then ``on_success(result)`` or ``on_error(exception)`` on the main thread."""
    global _next_id
    _next_id += 1
    job_id, generation = _next_id, _generation
    _jobs[job_id] = label
    def worker():
        try:
            _results.put((job_id, generation, on_success, func()))
        except Exception as exc:  # noqa: BLE001 - handed to on_error on the main thread
            _results.put((job_id, generation, on_error, exc))
    threading.Thread(target=worker, daemon=True).start()
    if not bpy.app.timers.is_registered(_poll):
        bpy.app.timers.register(_poll, first_interval=0.05)
 def busy_label():
    """Label of a running job, or ""."""
    return next(iter(_jobs.values()), "")
 def reset():
    """Forget the running jobs (their results will be dropped), e.g. when another file is loaded."""
    global _generation
    _generation += 1
    _jobs.clear()
 def _poll():
    while True:
        try:
            job_id, generation, callback, value = _results.get_nowait()
        except queue.Empty:
            break
        if generation != _generation:
            continue
        _jobs.pop(job_id, None)
        try:
            callback(value)
        except Exception:  # noqa: BLE001 - keep the poller alive
            traceback.print_exc()
    for window in bpy.context.window_manager.windows:
        for area in window.screen.areas:
            if area.type == "VIEW_3D":
                area.tag_redraw()
    return 0.1 if _jobs else None
@@ -0,0 +1,272 @@
 """Blender side of the Scene Manager: the assets linked from Libreflow publishes.
 Every loaded publish is one ``bpy.types.Library``, tagged with custom
 properties (``wtd_asset_oid``, ``wtd_file_oid``, ``wtd_revision``...). The tags
 live on the library only: library overrides lose custom properties when they
 resync. Instances are found back from their library: a collection instance
 (empty) through its instanced collection, a library override through the
 linked collection it overrides.
 """
 import os
 import re
 import bpy
 from .. import config
 ASSET_OID = "wtd_asset_oid"
 class LoadError(Exception):
    """An asset cannot be loaded or updated. The message is shown to the user."""
 # --------------------------------------------------------------------------- #
 # Loaded assets
 # --------------------------------------------------------------------------- #
 def managed_libraries():
    """Libraries loaded by the Scene Manager, sorted by asset name."""
    libraries = [lib for lib in bpy.data.libraries if lib.get(ASSET_OID)]
    return sorted(libraries, key=lambda lib: (lib.get("wtd_asset_name", ""), lib.name))
 def find_library(file_oid):
    return next((lib for lib in managed_libraries() if lib.get("wtd_file_oid") == file_oid), None)
 def linked_collection(library):
    """The asset collection linked from the library."""
    name = library.get("wtd_collection", "")
    return next((c for c in bpy.data.collections if c.library == library and c.name == name), None)
 def all_instances():
    """{library name: [instances]}: collection instances (empties) and override hierarchy roots,
    found in one pass over the file."""
    found = {}
    for ob in bpy.data.objects:
        collection = ob.instance_collection if ob.instance_type == "COLLECTION" else None
        if ob.library is None and collection is not None and collection.library is not None:
            found.setdefault(collection.library.name, []).append(ob)
    for collection in bpy.data.collections:
        override = collection.override_library
        if (
            collection.library is None
            and override is not None
            and override.reference is not None
            and override.reference.library is not None
            and override.hierarchy_root == collection
        ):
            found.setdefault(override.reference.library.name, []).append(collection)
    return found
 def instances(library):
    return all_instances().get(library.name, [])
 def instance_objects(instance):
    return [instance] if isinstance(instance, bpy.types.Object) else list(instance.all_objects)
 def selected_instances(view_layer):
    """(library, instance) pairs with at least one selected object."""
    selected = {ob.as_pointer() for ob in view_layer.objects if ob.select_get(view_layer=view_layer)}
    found = all_instances()
    return [
        (library, instance)
        for library in managed_libraries()
        for instance in found.get(library.name, [])
        if any(ob.as_pointer() in selected for ob in instance_objects(instance))
    ]
 # --------------------------------------------------------------------------- #
 # Load
 # --------------------------------------------------------------------------- #
 def link_mode(asset_type):
    modes = config.SCENE_MANAGER_LINK_MODES
    return modes.get(asset_type, modes.get("*", "INSTANCE"))
 def _type_collection(scene, asset_type):
    """Collection gathering the instances of an asset type, under the scene collection."""
    name = config.SCENE_MANAGER_TYPE_COLLECTION.format(asset_type=asset_type)
    collection = bpy.data.collections.get(name)
    if collection is None or collection.library is not None:
        collection = bpy.data.collections.new(name)
    if collection.name not in scene.collection.children:
        scene.collection.children.link(collection)
    return collection
 def _revision_path(revision, what):
    path = (revision or {}).get("path")
    if not path:
        raise LoadError(f"{what}: Libreflow gives no path for {revision and revision.get('name')}")
    if not os.path.isfile(path):
        raise LoadError(f"{what}: {revision['name']} not found on disk ({path})")
    return path
 def link_asset(asset, revision, context_oid):
    """Link the asset collection of a published revision. Returns its library.
    The collection is the first of config SCENE_MANAGER_COLLECTION_NAMES found in
    the file, else its single top-level collection.
    """
    name = asset["name"]
    path = _revision_path(revision, name)
    candidates = [pattern.format(asset=name) for pattern in config.SCENE_MANAGER_COLLECTION_NAMES]
    with bpy.data.libraries.load(path, link=True) as (data_from, data_to):
        chosen = next((c for c in candidates if c in data_from.collections), None)
        data_to.collections = [chosen] if chosen else list(data_from.collections)
    linked = [c for c in data_to.collections if c is not None]
    if not linked:
        raise LoadError(f"{name}: no collection in {os.path.basename(path)}")
    library = linked[0].library
    if chosen is None:
        roots = [c for c in linked if not any(c in parent.children.values() for parent in linked)]
        if len(roots) != 1:
            message = (
                f"{name}: no collection named {' or '.join(candidates)}, and "
                f"{len(roots)} top-level collections in the file ({', '.join(c.name for c in roots)})"
            )
            bpy.data.libraries.remove(library)
            remove_unused_libraries()
            raise LoadError(message)
        chosen = roots[0].name
    library.name = name
    library[ASSET_OID] = asset["oid"]
    library["wtd_asset_name"] = name
    library["wtd_asset_type"] = asset.get("asset_type") or ""
    library["wtd_file_oid"] = asset["file"]["file_oid"]
    library["wtd_revision"] = revision["name"]
    library["wtd_collection"] = chosen
    library["wtd_context_oid"] = context_oid
    return library
 def add_instance(scene, view_layer, library, parent=None):
    """Bring the library's asset in the scene: a library override or a collection instance
    (config SCENE_MANAGER_LINK_MODES), in ``parent`` or in the collection of its asset type."""
    collection = linked_collection(library)
    if collection is None:
        raise LoadError(f"{library.name}: collection {library.get('wtd_collection')} missing from the file")
    parent = parent or _type_collection(scene, library.get("wtd_asset_type", ""))
    if link_mode(library.get("wtd_asset_type", "")) == "OVERRIDE":
        override = collection.override_hierarchy_create(scene, view_layer)
        if scene.collection.children.get(override.name) == override and parent != scene.collection:
            scene.collection.children.unlink(override)
        if parent.children.get(override.name) != override:
            parent.children.link(override)
        return override
    empty = bpy.data.objects.new(library.get("wtd_asset_name", collection.name), None)
    empty.instance_type = "COLLECTION"
    empty.instance_collection = collection
    parent.objects.link(empty)
    return empty
 # --------------------------------------------------------------------------- #
 # Update / remove
 # --------------------------------------------------------------------------- #
 def update(library_name, revision):
    """Point a library to another revision of its file and reload it."""
    library = bpy.data.libraries[library_name]
    path = _revision_path(revision, library.get("wtd_asset_name", library_name))
    tags = dict(library)
    library.filepath = path
    library.reload()
    # The reload replaces the library (named after its file, no custom properties):
    # find it by its path, then give it back its name and tags.
    library = next((lib for lib in bpy.data.libraries if _same_path(lib.filepath, path)), None)
    if library is None:
        raise LoadError(f"{library_name}: {os.path.basename(path)} could not be reloaded")
    library.name = library_name
    for key, value in tags.items():
        library[key] = value
    library["wtd_revision"] = revision["name"]
    return library
 def _same_path(a, b):
    return os.path.normcase(os.path.normpath(bpy.path.abspath(a))) == os.path.normcase(os.path.normpath(b))
 def remove_instance(instance):
    if isinstance(instance, bpy.types.Object):
        bpy.data.objects.remove(instance)
        return
    ids = {instance}
    ids.update(c for c in instance.children_recursive if c.override_library and c.library is None)
    for ob in instance.all_objects:
        if ob.override_library and ob.library is None:
            ids.add(ob)
            if ob.data is not None and ob.data.override_library and ob.data.library is None:
                ids.add(ob.data)
    bpy.data.batch_remove(ids)
 def remove_library(library):
    """Remove every instance of the asset, then the library and its linked data."""
    for instance in instances(library):
        remove_instance(instance)
    bpy.data.libraries.remove(library)
    remove_unused_libraries()
 def remove_unused_libraries():
    """Remove the libraries none of whose data is used any more, e.g. the ones a removed
    asset linked indirectly (node group assets...). Managed libraries are kept."""
    while True:
        used = {
            id.library.name
            for id in bpy.data.user_map()
            if id.library is not None and (id.users or id.use_fake_user)
        }
        unused = [lib for lib in bpy.data.libraries if lib.name not in used and not lib.get(ASSET_OID)]
        if not unused:
            return
        for lib in unused:
            bpy.data.libraries.remove(lib)
 # --------------------------------------------------------------------------- #
 # Assetize
 # --------------------------------------------------------------------------- #
 def _holds_linked_data(collection):
    return any(c.override_library or c.library for c in collection.children_recursive) or any(
        ob.override_library or ob.library or (ob.instance_collection and ob.instance_collection.library)
        for ob in collection.all_objects
    )
 def assetize_candidates():
    """Local collections that can be published: not linked, not an override, holding no loaded asset."""
    return [
        c
        for c in bpy.data.collections
        if c.library is None and c.override_library is None and not c.get(ASSET_OID) and not _holds_linked_data(c)
    ]
 def asset_name_from(collection_name):
    """'COL_street lamp.001' -> 'street_lamp': the prefix and duplicate suffix removed, an identifier."""
    name = re.sub(r"\.\d{3,}$", "", collection_name)
    prefix = config.DATABLOCK_PREFIXES.get("collections", "")
    if prefix and name.upper().startswith(prefix.upper()):
        name = name[len(prefix):]
    return re.sub(r"[^A-Za-z0-9_]+", "_", name).strip("_")
 def write_collection(collection, path):
    """Write the collection and what it uses to a .blend, for publishing."""
    bpy.data.libraries.write(path, {collection}, path_remap="RELATIVE_ALL", fake_user=True)
 def parents_of(collection, scene):
    return [p for p in [scene.collection, *bpy.data.collections] if p.children.get(collection.name) == collection]
@@ -0,0 +1,974 @@
 """Scene Manager operators: connection, shot context, casting, load, update, remove, assetize.
 Libreflow is only reached through ``ipc``; every request but the ones filling a
 dialog runs in the background and applies its result on the main thread.
 What comes back from Libreflow is cached in ``STATE`` (not saved with the file).
 """
 import os
 import re
 import shutil
 import tempfile
 import time
 import bpy
 from bpy.app.handlers import persistent
 from bpy.props import BoolProperty, EnumProperty, PointerProperty, StringProperty
 from .. import config
 from . import ipc
 from . import library as lib
 class _State:
    def __init__(self):
        self.clear()
    def clear(self):
        self.sessions = {}  # session uid -> {session_name, cluster_name, is_gui, current_oid}
        self.connection_error = "Not connected"
        self.ping = {}  # wtd_ping: version, project, user, site
        self.contexts = {}  # oid -> context, or {"error": message}
        self.casting = {}  # context oid -> wtd_get_casting_publishes result
        self.files = {}  # file oid -> {latest, latest_available} or {error}
        self.revisions = {}  # file oid -> wtd_get_revisions result
        self.shots = []  # wtd_list_shots, for the shot picker
        self.assets = []  # wtd_list_assets, for the assetize dialog
        self.message = ("", "INFO")  # last outcome, shown in the panel
 STATE = _State()
 # Loaded assets unfolded in the panel (library names), UI state only.
 EXPANDED: set[str] = set()
 def report(message, level="INFO"):
    STATE.message = (message, level)
    print(f"[WTD Scene Manager] {message}")
 def _undo_push(message):
    try:
        bpy.ops.ed.undo_push(message=message)
    except RuntimeError:
        pass
 def _on_error(what, quiet=False):
    def callback(exc):
        if isinstance(exc, ipc.NotRunning):
            STATE.sessions = {}
            STATE.connection_error = str(exc)
        if not quiet:
            report(f"{what}: {exc}", "ERROR")
    return callback
 def session_uid():
    """The chosen session, None when Libreflow picks it (a single session connected)."""
    uid = bpy.context.window_manager.wtd_libreflow.session_uid
    return uid if uid in STATE.sessions else None
 def current_session():
    return STATE.sessions.get(session_uid() or "") or next(iter(STATE.sessions.values()), {})
 def connected():
    return bool(STATE.sessions)
 def context_oid(scene):
    return scene.wtd_scene_manager.context_oid.strip()
 def main_scene():
    """Scene of the main window (bpy.context.scene is not reliable in timers)."""
    windows = bpy.context.window_manager.windows
    return windows[0].scene if windows else bpy.context.scene
 def context_label(oid):
    """'f01 / s010 / p010' for a validated oid, or the reason it is not valid."""
    ctx = STATE.contexts.get(oid)
    if ctx is None:
        return "", False
    if "error" in ctx:
        return ctx["error"], False
    keys = ("film", "sequence", "shot") if ctx["kind"].startswith("shot") else ("asset_type", "asset")
    parts = [ctx[key] for key in keys if ctx.get(key)]
    return f"{ctx['kind']}: {' / '.join(parts) or ctx.get('project', '')}", True
 def is_shot_context(oid):
    ctx = STATE.contexts.get(oid) or {}
    return ctx.get("kind", "").startswith("shot")
 def version_status(library):
    """(state, text) of a loaded asset's revision: state is "LATEST", "UPDATE" (a newer one
    is available), "PENDING" (newer one published, not on this site yet) or "UNKNOWN"."""
    data = STATE.files.get(library.get("wtd_file_oid"))
    if data is None:
        return "UNKNOWN", "not checked"
    if data.get("error"):
        return "UNKNOWN", data["error"]
    current = library.get("wtd_revision")
    latest, available = data.get("latest"), data.get("latest_available")
    if latest is None or latest["name"] == current:
        return "LATEST", "latest"
    if available is not None and available["name"] != current:
        return "UPDATE", f"{available['name']} available"
    if latest.get("sync_status") == "Requested":
        return "PENDING", f"{latest['name']} requested, waiting for the download"
    return "PENDING", f"{latest['name']} published, not available on this site yet"
 def file_data(file_oid, default=None):
    """Latest known revisions of a file (refreshed by requests and version checks)."""
    return STATE.files.get(file_oid) or default
 def to_request(file):
    """The latest revision of a file when it is not on this site and not requested yet, else None."""
    latest = (file or {}).get("latest")
    if latest and latest.get("oid") and not latest.get("available") and latest.get("sync_status") != "Requested":
        return latest
    return None
 def missing_files(scene):
    """File oids of the cast and loaded assets whose latest publish can be requested."""
    casting = STATE.casting.get(context_oid(scene)) or {"assets": []}
    file_oids = [a["file"]["file_oid"] for a in casting["assets"] if a.get("file")]
    file_oids += [library["wtd_file_oid"] for library in lib.managed_libraries()]
    return [oid for oid in dict.fromkeys(file_oids) if to_request(file_data(oid))]
 def _asset_of(file_oid):
    return file_oid.split("/assets/", 1)[-1].split("/", 1)[0]
 # --------------------------------------------------------------------------- #
 # Background requests
 # --------------------------------------------------------------------------- #
 def connect(scene, quiet=False):
    """Read the sessions (and who / where we are) in the background, then check the scene's context."""
    wanted = bpy.context.window_manager.wtd_libreflow.session_uid
    oid, scene_name = context_oid(scene), scene.name
    def fetch():
        sessions = ipc.sessions()
        uid = wanted if wanted in sessions else (next(iter(sessions)) if len(sessions) == 1 else "")
        ping = {}
        if uid:
            target = oid or sessions[uid].get("current_oid")
            try:
                ping = ipc.call("wtd_ping", uid, oid=target) if target else ipc.call("wtd_ping", uid)
            except ipc.LibreflowError:
                ping = ipc.call("wtd_ping", uid)
        return sessions, uid, ping
    def done(result):
        sessions, uid, ping = result
        STATE.sessions, STATE.ping = sessions, ping
        STATE.connection_error = "" if sessions else "No Libreflow session connected"
        bpy.context.window_manager.wtd_libreflow.session_uid = uid
        scene = bpy.data.scenes.get(scene_name)
        if scene is not None and context_oid(scene):
            validate_context(scene, quiet=quiet)
    ipc.run("Connecting to Libreflow", fetch, done, _on_error("Connection", quiet))
 def validate_context(scene, quiet=False):
    """Check the context oid; for a shot, then fetch its casting and the loaded versions."""
    oid, uid, scene_name = context_oid(scene), session_uid(), scene.name
    if not oid:
        return
    def done(ctx):
        STATE.contexts[oid] = ctx
        scene = bpy.data.scenes.get(scene_name)
        if scene is not None and ctx["kind"].startswith("shot"):
            fetch_casting(scene, quiet=quiet)
        refresh_versions(quiet=quiet)
    def failed(exc):
        if not isinstance(exc, ipc.NotRunning):
            STATE.contexts[oid] = {"error": str(exc)}
        _on_error("Context", quiet)(exc)
    ipc.run("Checking the context", lambda: ipc.call("wtd_get_context", uid, oid=oid), done, failed)
 def _casting_publishes(uid, oid):
    """Casting with a file per asset, the file chosen with the patterns of its asset type
    (config SCENE_MANAGER_FILE_PATTERNS)."""
    patterns = config.SCENE_MANAGER_FILE_PATTERNS
    default = patterns.get("*", ["*/*.blend"])
    casting = ipc.call("wtd_get_casting_publishes", uid, oid=oid, file_patterns=default)
    specific = {asset_type: p for asset_type, p in patterns.items() if asset_type != "*" and p != default}
    for asset_patterns in {tuple(p) for p in specific.values()}:
        types = {t for t, p in specific.items() if tuple(p) == asset_patterns}
        if not any(asset["asset_type"] in types for asset in casting["assets"]):
            continue
        other = ipc.call("wtd_get_casting_publishes", uid, oid=oid, file_patterns=list(asset_patterns))
        by_key = {(a["asset_type"], a["name"]): a for a in other["assets"]}
        casting["assets"] = [
            by_key.get((a["asset_type"], a["name"]), a) if a["asset_type"] in types else a
            for a in casting["assets"]
        ]
    return casting
 def _store_casting(oid, casting):
    STATE.casting[oid] = casting
    STATE.files.update({a["file"]["file_oid"]: a["file"] for a in casting["assets"] if a.get("file")})
 def fetch_casting(scene, then=None, quiet=False):
    oid, uid = context_oid(scene), session_uid()
    def done(casting):
        _store_casting(oid, casting)
        if then is not None:
            then(casting)
    ipc.run("Reading the casting", lambda: _casting_publishes(uid, oid), done, _on_error("Casting", quiet))
 def refresh_versions(quiet=False):
    file_oids = [library["wtd_file_oid"] for library in lib.managed_libraries()]
    if not file_oids:
        return
    uid = session_uid()
    ipc.run(
        "Checking versions",
        lambda: ipc.call("wtd_get_latest_revisions", uid, file_oids=file_oids),
        STATE.files.update,
        _on_error("Versions", quiet),
    )
 def request_revisions(revisions):
    """Ask Libreflow to download revisions on this site ({revision oid: file oid})."""
    uid = session_uid()
    def done(result):
        requested, messages = [], []
        for oid, data in result.items():
            file_oid = revisions.get(oid, "")
            what = f"{_asset_of(file_oid)} {data.get('name') or oid.rsplit('/', 1)[-1]}"
            if data.get("error"):
                messages.append(f"{what}: {data['error']}")
                continue
            file = STATE.files.get(file_oid)
            if file is not None and (file.get("latest") or {}).get("oid") == oid:
                file["latest"] = data
                if data.get("available"):
                    file["latest_available"] = data
            for revision in STATE.revisions.get(file_oid, []):
                if revision.get("oid") == oid:
                    revision.update(data)
            if data.get("available"):
                messages.append(f"{what} is already on this site: refresh")
            else:
                requested.append(what)
        text = f"Requested {', '.join(requested)}" if requested else "Nothing requested"
        report(text + ("; " + "; ".join(messages) if messages else ""), "WARNING" if messages else "INFO")
    ipc.run(
        "Requesting",
        lambda: ipc.call("wtd_request_revisions", uid, revision_oids=list(revisions)),
        done,
        _on_error("Request"),
    )
 # --------------------------------------------------------------------------- #
 # Settings
 # --------------------------------------------------------------------------- #
 def _context_oid_update(self, context):
    if connected():
        validate_context(self.id_data)
 class WTD_SceneManagerSettings(bpy.types.PropertyGroup):
    """Per-file Scene Manager settings, saved in the .blend."""
    context_oid: StringProperty(
        name="Context",
        description="Libreflow oid of the shot this scene belongs to",
        update=_context_oid_update,
    )
 class WTD_LibreflowSettings(bpy.types.PropertyGroup):
    """Libreflow connection, for this Blender session."""
    session_uid: StringProperty(name="Session", description="Libreflow session the commands are sent to")
 # --------------------------------------------------------------------------- #
 # Connection / context
 # --------------------------------------------------------------------------- #
 class WTD_OT_scene_connect(bpy.types.Operator):
    bl_idname = "wtd_scene.connect"
    bl_label = "Connect"
    bl_description = "Connect to the running Libreflow (or refresh the sessions, context, casting and versions)"
    def execute(self, context):
        connect(context.scene)
        return {"FINISHED"}
 class WTD_OT_scene_select_session(bpy.types.Operator):
    bl_idname = "wtd_scene.select_session"
    bl_label = "Select Session"
    bl_description = "Send the commands to this Libreflow session"
    uid: StringProperty()
    def execute(self, context):
        context.window_manager.wtd_libreflow.session_uid = self.uid
        connect(context.scene)
        return {"FINISHED"}
 class WTD_OT_scene_use_current_oid(bpy.types.Operator):
    bl_idname = "wtd_scene.use_current_oid"
    bl_label = "Use Libreflow Current Oid"
    bl_description = "Set the context to the oid shown in the Libreflow window"
    @classmethod
    def poll(cls, context):
        return connected()
    def execute(self, context):
        oid = current_session().get("current_oid")
        if not oid:
            self.report({"WARNING"}, "Libreflow shows no oid")
            return {"CANCELLED"}
        context.scene.wtd_scene_manager.context_oid = oid
        return {"FINISHED"}
 def _shot_items(self, context):
    return _SHOT_ITEMS
 _SHOT_ITEMS = []
 class WTD_OT_scene_pick_shot(bpy.types.Operator):
    bl_idname = "wtd_scene.pick_shot"
    bl_label = "Pick Shot"
    bl_description = "Set the context to a shot of the project"
    bl_property = "shot"
    shot: EnumProperty(items=_shot_items)
    @classmethod
    def poll(cls, context):
        return connected()
    def invoke(self, context, event):
        uid = session_uid()
        oid = context_oid(context.scene) or current_session().get("current_oid")
        if not oid:
            self.report({"WARNING"}, "Set a context oid (or open the project in Libreflow) first")
            return {"CANCELLED"}
        context.window.cursor_set("WAIT")
        try:
            STATE.shots = ipc.call("wtd_list_shots", uid, oid=oid)
        except ipc.LibreflowError as exc:
            self.report({"WARNING"}, f"Shots: {exc}")
            return {"CANCELLED"}
        finally:
            context.window.cursor_set("DEFAULT")
        _SHOT_ITEMS[:] = [
            (s["oid"], f"{s.get('film', '')} / {s.get('sequence', '')} / {s.get('shot', '')}", s["oid"])
            for s in STATE.shots
        ]
        if not _SHOT_ITEMS:
            self.report({"WARNING"}, "No shot in the project")
            return {"CANCELLED"}
        context.window_manager.invoke_search_popup(self)
        return {"RUNNING_MODAL"}
    def execute(self, context):
        context.scene.wtd_scene_manager.context_oid = self.shot
        return {"FINISHED"}
 class WTD_OT_scene_refresh(bpy.types.Operator):
    bl_idname = "wtd_scene.refresh"
    bl_label = "Refresh"
    bl_description = "Read the casting and the latest versions of the loaded assets again"
    @classmethod
    def poll(cls, context):
        return connected()
    def execute(self, context):
        if is_shot_context(context_oid(context.scene)):
            fetch_casting(context.scene)
        refresh_versions()
        return {"FINISHED"}
 # --------------------------------------------------------------------------- #
 # Load
 # --------------------------------------------------------------------------- #
 def load_casting(scene, view_layer, casting, context_oid_value, only=None):
    """Link the missing assets of the casting and create their missing instances.
    Returns (number of instances added, error messages)."""
    added, errors = 0, []
    for asset in casting["assets"]:
        if only and asset["oid"] != only:
            continue
        if asset.get("error") or not asset.get("file"):
            errors.append(f"{asset['name']}: {asset.get('error') or 'nothing to load'}")
            continue
        try:
            library = lib.find_library(asset["file"]["file_oid"]) or lib.link_asset(
                asset, asset["file"]["latest_available"], context_oid_value
            )
            wanted = asset.get("nb_occurences") or 1
            for _ in range(wanted - len(lib.instances(library))):
                lib.add_instance(scene, view_layer, library)
                added += 1
        except (lib.LoadError, RuntimeError) as exc:
            errors.append(str(exc) if isinstance(exc, lib.LoadError) else f"{asset['name']}: {exc}")
    return added, errors
 class WTD_OT_scene_load(bpy.types.Operator):
    bl_idname = "wtd_scene.load"
    bl_label = "Load"
    bl_description = "Link the latest available publish of the cast assets that are not loaded yet"
    asset_oid: StringProperty(description="Only this asset", options={"SKIP_SAVE"})
    @classmethod
    def poll(cls, context):
        return connected() and is_shot_context(context_oid(context.scene))
    def execute(self, context):
        oid = context_oid(context.scene)
        scene_name, view_layer_name, only = context.scene.name, context.view_layer.name, self.asset_oid
        def apply(casting):
            scene = bpy.data.scenes.get(scene_name)
            if scene is None:
                return
            added, errors = load_casting(scene, scene.view_layers[view_layer_name], casting, oid, only)
            _undo_push("Load casting")
            text = f"{added} instance(s) added" if added else "Nothing new to load"
            if errors:
                report(f"{text}, {len(errors)} asset(s) cannot be loaded: " + "; ".join(errors), "WARNING")
            else:
                report(text)
        cached = STATE.casting.get(oid)
        if only and cached is not None:
            apply(cached)
        else:
            fetch_casting(context.scene, then=apply)
        return {"FINISHED"}
 # --------------------------------------------------------------------------- #
 # Update / versions
 # --------------------------------------------------------------------------- #
 def _update_libraries(names, target=None):
    """Update libraries to their latest available revision (or to ``target``). Returns messages."""
    updated, messages = [], []
    for name in names:
        library = bpy.data.libraries.get(name)
        if library is None:
            continue
        revision = target
        if revision is None:
            state, text = version_status(library)
            if state != "UPDATE":
                if state == "PENDING":
                    messages.append(f"{name}: {text}")
                continue
            revision = STATE.files[library["wtd_file_oid"]]["latest_available"]
        try:
            lib.update(name, revision)
            updated.append(f"{name} {revision['name']}")
        except (lib.LoadError, RuntimeError) as exc:
            messages.append(str(exc))
    return updated, messages
 class WTD_OT_scene_update(bpy.types.Operator):
    bl_idname = "wtd_scene.update"
    bl_label = "Update"
    bl_description = "Switch the loaded assets to their latest available publish"
    bl_options = {"REGISTER", "UNDO"}
    library: StringProperty(description="Only this loaded asset", options={"SKIP_SAVE"})
    selected: BoolProperty(description="Only the assets of the selected objects", options={"SKIP_SAVE"})
    @classmethod
    def poll(cls, context):
        return connected() and bool(lib.managed_libraries())
    def execute(self, context):
        if self.library:
            names = [self.library]
        elif self.selected:
            names = sorted({library.name for library, _ in lib.selected_instances(context.view_layer)})
            if not names:
                self.report({"WARNING"}, "No loaded asset selected")
                return {"CANCELLED"}
        else:
            names = [library.name for library in lib.managed_libraries()]
        file_oids = [bpy.data.libraries[name]["wtd_file_oid"] for name in names]
        def apply(latest):
            STATE.files.update(latest)
            updated, messages = _update_libraries(names)
            _undo_push("Update assets")
            text = f"Updated {', '.join(updated)}" if updated else "Nothing to update"
            report(text + ("; " + "; ".join(messages) if messages else ""), "WARNING" if messages else "INFO")
        uid = session_uid()
        ipc.run(
            "Updating",
            lambda: ipc.call("wtd_get_latest_revisions", uid, file_oids=file_oids),
            apply,
            _on_error("Update"),
        )
        return {"FINISHED"}
 class WTD_OT_scene_request(bpy.types.Operator):
    bl_idname = "wtd_scene.request"
    bl_label = "Request"
    bl_description = (
        "Ask Libreflow to download the latest publish on this site (from the exchange site, "
        "or from the site that published it). Refresh once it is downloaded"
    )
    file_oid: StringProperty(description="Only the latest publish of this file", options={"SKIP_SAVE"})
    @classmethod
    def poll(cls, context):
        return connected()
    def execute(self, context):
        file_oids = [self.file_oid] if self.file_oid else missing_files(context.scene)
        revisions = {}
        for file_oid in file_oids:
            revision = to_request(file_data(file_oid))
            if revision is not None:
                revisions[revision["oid"]] = file_oid
        if not revisions:
            self.report({"INFO"}, "Nothing to request")
            return {"CANCELLED"}
        request_revisions(revisions)
        return {"FINISHED"}
 def _revision_items(self, context):
    return _REVISION_ITEMS
 _REVISION_ITEMS = []
 class WTD_OT_scene_pick_revision(bpy.types.Operator):
    bl_idname = "wtd_scene.pick_revision"
    bl_label = "Pick Version"
    bl_description = "Switch this asset to another published version (e.g. roll back)"
    bl_options = {"REGISTER", "UNDO"}
    library: StringProperty()
    revision: EnumProperty(name="Version", items=_revision_items)
    @classmethod
    def poll(cls, context):
        return connected()
    def invoke(self, context, event):
        library = bpy.data.libraries.get(self.library)
        if library is None:
            return {"CANCELLED"}
        file_oid = library["wtd_file_oid"]
        context.window.cursor_set("WAIT")
        try:
            STATE.revisions[file_oid] = ipc.call("wtd_get_revisions", session_uid(), file_oid=file_oid)
        except ipc.LibreflowError as exc:
            self.report({"WARNING"}, f"Versions: {exc}")
            return {"CANCELLED"}
        finally:
            context.window.cursor_set("DEFAULT")
        current = library.get("wtd_revision")
        _REVISION_ITEMS[:] = [
            (
                r["name"],
                f"{r['name']}  {time.strftime('%Y-%m-%d', time.localtime(r['date'])) if r.get('date') else ''}"
                f"  {r.get('user') or ''}"
                + (
                    ""
                    if r.get("available")
                    else "  (requested)" if r.get("sync_status") == "Requested" else "  (not on this site: request)"
                ),
                r.get("comment") or "",
                "CHECKMARK" if r["name"] == current else "NONE",
                index,
            )
            for index, r in enumerate(STATE.revisions[file_oid])
        ]
        if not _REVISION_ITEMS:
            self.report({"WARNING"}, "No published version")
            return {"CANCELLED"}
        if current in {item[0] for item in _REVISION_ITEMS}:
            self.revision = current
        return context.window_manager.invoke_props_dialog(self, title=f"{self.library}: version")
    def execute(self, context):
        library = bpy.data.libraries.get(self.library)
        if library is None:
            return {"CANCELLED"}
        file_oid = library["wtd_file_oid"]
        revision = next(r for r in STATE.revisions[file_oid] if r["name"] == self.revision)
        if not revision.get("available"):
            if revision.get("sync_status") == "Requested":
                self.report({"WARNING"}, f"{revision['name']} is requested, waiting for the download")
            else:
                request_revisions({revision["oid"]: file_oid})
                self.report({"INFO"}, f"{revision['name']} is not on this site: requested, pick it again once downloaded")
            return {"CANCELLED"}
        updated, messages = _update_libraries([self.library], target=revision)
        if messages:
            self.report({"WARNING"}, "; ".join(messages))
            return {"CANCELLED"}
        self.report({"INFO"}, f"{self.library} switched to {revision['name']}")
        return {"FINISHED"}
 # --------------------------------------------------------------------------- #
 # Remove / select
 # --------------------------------------------------------------------------- #
 class WTD_OT_scene_remove(bpy.types.Operator):
    bl_idname = "wtd_scene.remove"
    bl_label = "Remove"
    bl_description = "Remove loaded assets from the scene"
    bl_options = {"REGISTER", "UNDO"}
    library: StringProperty(description="Remove this whole asset (all its instances and the link)", options={"SKIP_SAVE"})
    instance: StringProperty(description="Remove only this instance (object or collection name)", options={"SKIP_SAVE"})
    selected: BoolProperty(description="Remove the instances of the selected objects", options={"SKIP_SAVE"})
    def invoke(self, context, event):
        if self.library:
            return context.window_manager.invoke_confirm(
                self, event, title=f"Remove {self.library}?", message="All its instances and the link to its file"
            )
        return self.execute(context)
    def execute(self, context):
        if context.mode != "OBJECT" and context.view_layer.objects.active is not None:
            bpy.ops.object.mode_set(mode="OBJECT")
        if self.library:
            library = bpy.data.libraries.get(self.library)
            if library is None:
                return {"CANCELLED"}
            lib.remove_library(library)
            self.report({"INFO"}, f"Removed {self.library}")
            return {"FINISHED"}
        if self.selected:
            targets = [instance for _library, instance in lib.selected_instances(context.view_layer)]
        else:
            targets = [
                instance
                for library in lib.managed_libraries()
                for instance in lib.instances(library)
                if instance.name == self.instance
            ]
        if not targets:
            self.report({"WARNING"}, "No loaded instance selected")
            return {"CANCELLED"}
        for instance in targets:
            lib.remove_instance(instance)
        self.report({"INFO"}, f"Removed {len(targets)} instance(s)")
        return {"FINISHED"}
 class WTD_OT_scene_select_instance(bpy.types.Operator):
    bl_idname = "wtd_scene.select_instance"
    bl_label = "Select"
    bl_description = "Select the objects of this instance"
    bl_options = {"REGISTER", "UNDO"}
    library: StringProperty()
    instance: StringProperty()
    def execute(self, context):
        library = bpy.data.libraries.get(self.library)
        instance = next((i for i in lib.instances(library) if i.name == self.instance), None) if library else None
        if instance is None:
            return {"CANCELLED"}
        if context.mode != "OBJECT" and context.view_layer.objects.active is not None:
            bpy.ops.object.mode_set(mode="OBJECT")
        view_layer = context.view_layer
        objects = [ob for ob in lib.instance_objects(instance) if ob.name in view_layer.objects and ob.visible_get()]
        if not objects:
            self.report({"WARNING"}, "Nothing selectable (hidden or excluded)")
            return {"CANCELLED"}
        for ob in context.selected_objects:
            ob.select_set(False)
        for ob in objects:
            ob.select_set(True)
        view_layer.objects.active = next((ob for ob in objects if ob.type == "ARMATURE"), objects[0])
        return {"FINISHED"}
 class WTD_OT_scene_toggle_expand(bpy.types.Operator):
    bl_idname = "wtd_scene.toggle_expand"
    bl_label = "Show Instances"
    bl_description = "Show or hide the instances of this asset"
    library: StringProperty()
    def execute(self, context):
        EXPANDED.symmetric_difference_update({self.library})
        return {"FINISHED"}
 # --------------------------------------------------------------------------- #
 # Assetize
 # --------------------------------------------------------------------------- #
 def _collection_items(self, context):
    _COLLECTION_ITEMS[:] = [(c.name, c.name, "") for c in lib.assetize_candidates()]
    return _COLLECTION_ITEMS
 def _asset_type_items(self, context):
    types = sorted({a["asset_type"] for a in STATE.assets if a.get("asset_type")})
    _ASSET_TYPE_ITEMS[:] = [(t, t, "") for t in types]
    return _ASSET_TYPE_ITEMS
 _COLLECTION_ITEMS = []
 _ASSET_TYPE_ITEMS = []
 def _existing_asset(asset_type, asset_name, asset_lib):
    return any(
        a.get("asset_type") == asset_type
        and a.get("asset") == asset_name
        and (a.get("asset_lib") or "") == (asset_lib or "")
        for a in STATE.assets
    )
 def replace_with_publish(scene, view_layer, collection_name, asset, context_oid_value):
    """Link the published revision in place of the local collection (kept in the file, unlinked)."""
    local = bpy.data.collections.get(collection_name)
    revision = asset["file"].get("latest_available")
    if local is None or revision is None:
        raise lib.LoadError(f"{asset['name']}: published, but not available on this site to replace it")
    library = lib.find_library(asset["file"]["file_oid"])
    if library is not None:
        library = lib.update(library.name, revision)
    else:
        library = lib.link_asset(asset, revision, context_oid_value)
    parents = lib.parents_of(local, scene)
    for parent in parents:
        parent.children.unlink(local)
    # Kept in the file, out of the way: the published asset takes its name.
    local.use_fake_user = True
    local.name = f"{collection_name}_local"
    lib.add_instance(scene, view_layer, library, parent=parents[0] if parents else None)
 class WTD_OT_scene_assetize(bpy.types.Operator):
    bl_idname = "wtd_scene.assetize"
    bl_label = "Assetize"
    bl_description = "Publish a collection of this scene to Libreflow as an asset (new asset or new version)"
    collection: EnumProperty(name="Collection", items=_collection_items)
    asset_type: EnumProperty(name="Asset Type", items=_asset_type_items)
    asset_name: StringProperty(name="Asset Name", description="Letters, digits and underscores")
    asset_lib: StringProperty(name="Asset Library", description="Publish under this asset library (optional)")
    task: StringProperty(name="Task", description="Asset task to publish in")
    file_name: StringProperty(name="File Name", description="Name of the .blend (defaults to the asset name)")
    comment: StringProperty(name="Comment")
    upload: BoolProperty(name="Upload", description="Also upload the revision to the exchange site")
    replace: BoolProperty(
        name="Replace with the Publish",
        description="Link the published asset in place of the local collection (which stays in the file, unlinked)",
        default=True,
    )
    @classmethod
    def poll(cls, context):
        return connected()
    def _oid(self, context):
        return context_oid(context.scene) or current_session().get("current_oid") or ""
    def invoke(self, context, event):
        candidates = lib.assetize_candidates()
        if not candidates:
            self.report({"WARNING"}, "No local collection to publish")
            return {"CANCELLED"}
        oid = self._oid(context)
        if not oid:
            self.report({"WARNING"}, "Set a context oid first")
            return {"CANCELLED"}
        context.window.cursor_set("WAIT")
        try:
            STATE.assets = ipc.call("wtd_list_assets", session_uid(), oid=oid)
        except ipc.LibreflowError as exc:
            self.report({"WARNING"}, f"Assets: {exc}")
            return {"CANCELLED"}
        finally:
            context.window.cursor_set("DEFAULT")
        if not _asset_type_items(self, context):
            self.report({"WARNING"}, "No asset type in the project")
            return {"CANCELLED"}
        active = context.collection
        self.collection = active.name if active in candidates else candidates[0].name
        self.asset_name = lib.asset_name_from(self.collection)
        self.task = config.SCENE_MANAGER_ASSETIZE_TASK
        return context.window_manager.invoke_props_dialog(self, width=420)
    def draw(self, context):
        layout = self.layout
        layout.use_property_split = True
        layout.use_property_decorate = False
        layout.prop(self, "collection")
        layout.prop(self, "asset_type")
        layout.prop(self, "asset_name")
        exists = _existing_asset(self.asset_type, self.asset_name, self.asset_lib)
        row = layout.row()
        row.label(text="")
        row.label(text="New version of this asset" if exists else "New asset", icon="FILE_REFRESH" if exists else "ADD")
        layout.prop(self, "asset_lib")
        layout.prop(self, "task")
        layout.prop(self, "file_name")
        layout.prop(self, "comment")
        layout.prop(self, "upload")
        layout.prop(self, "replace")
    def execute(self, context):
        name = self.asset_name.strip()
        if not re.fullmatch(r"[A-Za-z0-9_]+", name or ""):
            self.report({"WARNING"}, "The asset name can only use letters, digits and underscores")
            return {"CANCELLED"}
        collection = bpy.data.collections.get(self.collection)
        if collection is None or not self.asset_type or not self.task.strip():
            self.report({"WARNING"}, "Pick a collection, an asset type and a task")
            return {"CANCELLED"}
        folder = tempfile.mkdtemp(prefix="wtd_assetize_")
        path = os.path.join(folder, f"{self.file_name.strip() or name}.blend")
        lib.write_collection(collection, path)
        kwargs = dict(
            oid=self._oid(context),
            asset_type=self.asset_type,
            asset_name=name,
            task=self.task.strip(),
            source_path=path,
            file_name=self.file_name.strip() or None,
            comment=self.comment,
            asset_lib=self.asset_lib.strip() or None,
            create_asset=not _existing_asset(self.asset_type, name, self.asset_lib.strip()),
            upload=self.upload,
        )
        uid, replace, asset_type = session_uid(), self.replace, self.asset_type
        scene_name, view_layer_name, collection_name = context.scene.name, context.view_layer.name, collection.name
        def done(result):
            shutil.rmtree(folder, ignore_errors=True)
            STATE.files[result["file_oid"]] = result
            revision = (result.get("latest") or {}).get("name", "")
            created = " (new asset)" if result.get("asset_created") else ""
            message = f"Published {name} {revision}{created}"
            if replace and (scene := bpy.data.scenes.get(scene_name)) is not None:
                asset = {"name": name, "oid": result["asset_oid"], "asset_type": asset_type, "file": result}
                try:
                    replace_with_publish(
                        scene, scene.view_layers[view_layer_name], collection_name, asset, kwargs["oid"]
                    )
                    _undo_push("Replace with the publish")
                    message += ", the collection is replaced by its link"
                except (lib.LoadError, RuntimeError) as exc:
                    report(f"{message}, not replaced: {exc}", "WARNING")
                    return
            report(message)
        def failed(exc):
            shutil.rmtree(folder, ignore_errors=True)
            _on_error(f"Publishing {name}")(exc)
        ipc.run(f"Publishing {name}", lambda: ipc.call("wtd_assetize", uid, **kwargs), done, failed)
        return {"FINISHED"}
 # --------------------------------------------------------------------------- #
 # Registration
 # --------------------------------------------------------------------------- #
@persistent
 def _on_load_post(*_args):
    """New file: forget the cached answers, then reconnect in the background."""
    ipc.reset()
    sessions, error = STATE.sessions, STATE.connection_error
    STATE.clear()
    STATE.sessions, STATE.connection_error = sessions, error
    bpy.app.timers.register(_auto_connect, first_interval=0.5)
 def _auto_connect():
    if os.path.isfile(os.path.expanduser(config.LIBREFLOW_SERVER_FILE)):
        connect(main_scene(), quiet=True)
    return None
 classes = (
    WTD_SceneManagerSettings,
    WTD_LibreflowSettings,
    WTD_OT_scene_connect,
    WTD_OT_scene_select_session,
    WTD_OT_scene_use_current_oid,
    WTD_OT_scene_pick_shot,
    WTD_OT_scene_refresh,
    WTD_OT_scene_load,
    WTD_OT_scene_update,
    WTD_OT_scene_request,
    WTD_OT_scene_pick_revision,
    WTD_OT_scene_remove,
    WTD_OT_scene_select_instance,
    WTD_OT_scene_toggle_expand,
    WTD_OT_scene_assetize,
 )
 def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.Scene.wtd_scene_manager = PointerProperty(type=WTD_SceneManagerSettings)
    bpy.types.WindowManager.wtd_libreflow = PointerProperty(type=WTD_LibreflowSettings)
    bpy.app.handlers.load_post.append(_on_load_post)
    bpy.app.timers.register(_auto_connect, first_interval=1.0)
 def unregister():
    ipc.reset()
    if _on_load_post in bpy.app.handlers.load_post:
        bpy.app.handlers.load_post.remove(_on_load_post)
    if bpy.app.timers.is_registered(_auto_connect):
        bpy.app.timers.unregister(_auto_connect)
    del bpy.types.WindowManager.wtd_libreflow
    del bpy.types.Scene.wtd_scene_manager
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)
@@ -150,20 +150,35 @@ def _new_camera_rig(context, shot, is_3d):
 # --------------------------------------------------------------------------- #
 # Rigs
 # --------------------------------------------------------------------------- #
 def _rig_library(ob):
    reference = ob.override_library.reference if ob.override_library else None
    return ob.library or (reference.library if reference else None)
 def _rig_names(ob):
    """Names a rig is classified by: object, its collections and its library file."""
    names = [ob.name, *(collection.name for collection in ob.users_collection)]
-    reference = ob.override_library.reference if ob.override_library else None
+    library = _rig_library(ob)
    library = ob.library or (reference.library if reference else None)
    if library is not None:
        names.append(os.path.basename(library.filepath))
    return names
 def _rig_group(ob, patterns):
    library = _rig_library(ob)
    # Loaded by the Scene Manager: its Libreflow asset type decides.
    asset_type = library.get("wtd_asset_type") if library is not None else None
    if asset_type in config.SHOT_VIEWER_ASSET_TYPE_GROUPS:
        return config.SHOT_VIEWER_ASSET_TYPE_GROUPS[asset_type]
    names = _rig_names(ob)
    return next((label for label, pattern in patterns if any(pattern.search(name) for name in names)), OTHER_GROUP)
 def rig_groups(view_layer):
    """{group label: [armature objects]} for the armatures of the view layer, empty groups left out."""
    patterns = [(label, re.compile(pattern)) for label, pattern in config.SHOT_VIEWER_RIG_GROUPS.items()]
    groups = {label: [] for label, _pattern in patterns}
    groups.update({label: [] for label in config.SHOT_VIEWER_ASSET_TYPE_GROUPS.values() if label not in groups})
    groups[OTHER_GROUP] = []
    # Camera rigs (armatures carrying a camera) are left out: one per shot.
    rigs = sorted(
@@ -175,12 +190,7 @@ def rig_groups(view_layer):
        key=lambda ob: ob.name.lower(),
    )
    for ob in rigs:
-        names = _rig_names(ob)
+        groups[_rig_group(ob, patterns)].append(ob)
        label = next(
            (label for label, pattern in patterns if any(pattern.search(name) for name in names)),
            OTHER_GROUP,
        )
        groups[label].append(ob)
    return {label: rigs for label, rigs in groups.items() if rigs}
@@ -3,6 +3,9 @@ import textwrap
 import bpy
 from .. import config, rename, shot_viewer, tools_ops
 from ..scene_manager import ipc
 from ..scene_manager import library as sm_library
 from ..scene_manager import operators as sm
 from ..core import CheckContext, Severity, checks_for_context, contexts, runner
 from ..core.runner import Status
 from .operators import EXPANDED
@@ -316,6 +319,191 @@ class _ShotViewerPanel:
                ).name = rig.name
 MESSAGE_ICONS = {"INFO": "INFO", "WARNING": "ERROR", "ERROR": "CANCEL"}
 class _SceneManagerPanel:
    bl_region_type = "UI"
    bl_category = "WTD"
    bl_label = "Scene Manager"
    def draw(self, context) -> None:
        layout = self.layout
        state = sm.STATE
        scene = context.scene
        row = layout.row(align=True)
        if sm.connected():
            session = sm.current_session()
            text = f"{session.get('session_name', '?')} ({session.get('cluster_name', '')})"
            if state.ping.get("user"):
                text += f"  {state.ping['user']} @ {state.ping.get('site', '')}"
            row.label(text=text, icon="LINKED")
        else:
            row.label(text=state.connection_error, icon="UNLINKED")
        row.operator(sm.WTD_OT_scene_connect.bl_idname, text="", icon="FILE_REFRESH")
        if len(state.sessions) > 1:
            col = layout.column(align=True)
            chosen = context.window_manager.wtd_libreflow.session_uid
            for uid, info in state.sessions.items():
                col.operator(
                    sm.WTD_OT_scene_select_session.bl_idname,
                    text=f"{info.get('session_name', uid)}: {info.get('current_oid') or ''}",
                    depress=uid == chosen,
                ).uid = uid
        layout.prop(scene.wtd_scene_manager, "context_oid", text="", icon="SEQUENCE")
        row = layout.row(align=True)
        row.operator(sm.WTD_OT_scene_use_current_oid.bl_idname, text="Libreflow Oid", icon="IMPORT")
        row.operator(sm.WTD_OT_scene_pick_shot.bl_idname, text="Pick Shot", icon="VIEWZOOM")
        text, valid = sm.context_label(sm.context_oid(scene))
        if text:
            row = layout.row()
            row.alert = not valid
            _wrapped_label(row, context, text, icon="CHECKMARK" if valid else "ERROR")
        busy = ipc.busy_label()
        if busy:
            layout.label(text=f"{busy}...", icon="SORTTIME")
        message, level = state.message
        if message:
            row = layout.row()
            row.alert = level == "ERROR"
            _wrapped_label(row, context, message, icon=MESSAGE_ICONS[level])
 class _SceneCastingPanel:
    bl_region_type = "UI"
    bl_category = "WTD"
    bl_label = "Casting"
    bl_parent_id = "WTD_PT_scene_manager_view3d"
    def draw(self, context) -> None:
        layout = self.layout
        oid = sm.context_oid(context.scene)
        row = layout.row(align=True)
        row.scale_y = 1.3
        row.operator(sm.WTD_OT_scene_load.bl_idname, text="Load Missing", icon="IMPORT")
        if sm.missing_files(context.scene):
            row.operator(sm.WTD_OT_scene_request.bl_idname, text="Request Missing", icon="URL")
        row.operator(sm.WTD_OT_scene_refresh.bl_idname, text="", icon="FILE_REFRESH")
        casting = sm.STATE.casting.get(oid)
        if casting is None:
            text = "Not read yet: refresh" if sm.is_shot_context(oid) else "Set a shot as context"
            layout.label(text=text, icon="INFO")
            return
        if not casting["assets"]:
            layout.label(text="Nothing cast in this shot", icon="INFO")
        found = sm_library.all_instances()
        col = layout.column(align=True)
        for asset in casting["assets"]:
            library = sm_library.find_library(asset["file"]["file_oid"]) if asset.get("file") else None
            have = len(found.get(library.name, [])) if library else 0
            want = asset.get("nb_occurences") or 1
            error = asset.get("error")
            file = sm.file_data(asset["file"]["file_oid"], asset["file"]) if asset.get("file") else None
            latest = (file or {}).get("latest") or {}
            requested = bool(error) and latest.get("sync_status") == "Requested"
            if requested:
                error = f"{latest['name']} requested, waiting for the download"
            icon = "SORTTIME" if requested else "ERROR" if error else "CHECKMARK" if have >= want else "IMPORT"
            row = col.row(align=True)
            row.alert = bool(error) and not requested
            row.label(text=f"{asset['name']}  ({asset.get('asset_type', '')})", icon=icon)
            row.label(text=f"{have}/{want}")
            if not error and have < want:
                row.operator(sm.WTD_OT_scene_load.bl_idname, text="", icon="IMPORT").asset_oid = asset["oid"]
            if sm.to_request(file):
                row.operator(sm.WTD_OT_scene_request.bl_idname, text="", icon="URL").file_oid = file["file_oid"]
            if error:
                sub = col.row()
                sub.alert = not requested
                _wrapped_label(sub, context, error, icon="BLANK1")
        cast = {asset["oid"] for asset in casting["assets"]}
        extra = [library for library in sm_library.managed_libraries() if library["wtd_asset_oid"] not in cast]
        if extra:
            box = layout.box()
            box.label(text="Loaded, no longer cast:", icon="ERROR")
            for library in extra:
                box.label(text=library.get("wtd_asset_name", library.name), icon="BLANK1")
 class _SceneLoadedPanel:
    bl_region_type = "UI"
    bl_category = "WTD"
    bl_label = "Loaded"
    bl_parent_id = "WTD_PT_scene_manager_view3d"
    def draw(self, context) -> None:
        layout = self.layout
        libraries = sm_library.managed_libraries()
        if not libraries:
            layout.label(text="Nothing loaded by the Scene Manager", icon="INFO")
            return
        row = layout.row(align=True)
        row.operator(sm.WTD_OT_scene_update.bl_idname, text="Update All", icon="FILE_REFRESH")
        row.operator(sm.WTD_OT_scene_refresh.bl_idname, text="", icon="VIEWZOOM")
        found = sm_library.all_instances()
        for library in libraries:
            state, text = sm.version_status(library)
            outdated = state in {"UPDATE", "PENDING"}
            expanded = library.name in sm.EXPANDED
            row = layout.row(align=True)
            row.operator(
                sm.WTD_OT_scene_toggle_expand.bl_idname,
                text="",
                emboss=False,
                icon="DOWNARROW_HLT" if expanded else "RIGHTARROW",
            ).library = library.name
            row.label(text=library.get("wtd_asset_name", library.name), icon="LIBRARY_DATA_DIRECT")
            version = row.row(align=True)
            version.alert = outdated
            version.label(text=library.get("wtd_revision", "?"))
            if state == "UPDATE":
                row.operator(sm.WTD_OT_scene_update.bl_idname, text="", icon="FILE_REFRESH").library = library.name
            elif state == "PENDING" and sm.to_request(sm.file_data(library["wtd_file_oid"])):
                row.operator(sm.WTD_OT_scene_request.bl_idname, text="", icon="URL").file_oid = library["wtd_file_oid"]
            row.operator(sm.WTD_OT_scene_pick_revision.bl_idname, text="", icon="COLLAPSEMENU").library = library.name
            row.operator(sm.WTD_OT_scene_remove.bl_idname, text="", icon="X").library = library.name
            if outdated:
                sub = layout.row()
                sub.alert = True
                _wrapped_label(sub, context, text, icon="BLANK1")
            if not expanded:
                continue
            col = layout.column(align=True)
            for instance in found.get(library.name, []):
                is_object = isinstance(instance, bpy.types.Object)
                sub = col.row(align=True)
                sub.label(text=instance.name, icon="OUTLINER_OB_EMPTY" if is_object else "OUTLINER_COLLECTION")
                op = sub.operator(sm.WTD_OT_scene_select_instance.bl_idname, text="", icon="RESTRICT_SELECT_OFF")
                op.library, op.instance = library.name, instance.name
                sub.operator(sm.WTD_OT_scene_remove.bl_idname, text="", icon="X").instance = instance.name
        layout.separator()
        row = layout.row(align=True)
        row.operator(sm.WTD_OT_scene_update.bl_idname, text="Update Selected").selected = True
        row.operator(sm.WTD_OT_scene_remove.bl_idname, text="Remove Selected").selected = True
 class _SceneAssetizePanel:
    bl_region_type = "UI"
    bl_category = "WTD"
    bl_label = "Assetize"
    bl_parent_id = "WTD_PT_scene_manager_view3d"
    bl_options = {"DEFAULT_CLOSED"}
    def draw(self, context) -> None:
        layout = self.layout
        _wrapped_label(
            layout, context, "Publish a local collection of this scene to Libreflow as an asset.", icon="INFO"
        )
        layout.operator(sm.WTD_OT_scene_assetize.bl_idname, text="Assetize Collection...", icon="EXPORT")
 class WTD_PT_sanity_view3d(_SanityPanel, bpy.types.Panel):
    bl_idname = "WTD_PT_sanity_view3d"
    bl_space_type = "VIEW_3D"
@@ -341,6 +529,26 @@ class WTD_PT_shot_viewer_view3d(_ShotViewerPanel, bpy.types.Panel):
    bl_space_type = "VIEW_3D"
 class WTD_PT_scene_manager_view3d(_SceneManagerPanel, bpy.types.Panel):
    bl_idname = "WTD_PT_scene_manager_view3d"
    bl_space_type = "VIEW_3D"
 class WTD_PT_scene_casting_view3d(_SceneCastingPanel, bpy.types.Panel):
    bl_idname = "WTD_PT_scene_casting_view3d"
    bl_space_type = "VIEW_3D"
 class WTD_PT_scene_loaded_view3d(_SceneLoadedPanel, bpy.types.Panel):
    bl_idname = "WTD_PT_scene_loaded_view3d"
    bl_space_type = "VIEW_3D"
 class WTD_PT_scene_assetize_view3d(_SceneAssetizePanel, bpy.types.Panel):
    bl_idname = "WTD_PT_scene_assetize_view3d"
    bl_space_type = "VIEW_3D"
 class WTD_PT_sanity_sequencer(_SanityPanel, bpy.types.Panel):
    bl_idname = "WTD_PT_sanity_sequencer"
    bl_space_type = "SEQUENCE_EDITOR"
@@ -351,6 +559,10 @@ classes = (
    WTD_PT_sanity_view3d,
    WTD_PT_tools_view3d,
    WTD_PT_shot_viewer_view3d,
    WTD_PT_scene_manager_view3d,
    WTD_PT_scene_casting_view3d,
    WTD_PT_scene_loaded_view3d,
    WTD_PT_scene_assetize_view3d,
    WTD_PT_rename_view3d,
    WTD_PT_rename_node_editor,
    WTD_PT_sanity_sequencer,
Author	SHA1	Message	Date
NDemaerschalkandClaude Opus 5.5	9fe38ce58a	Scene Manager: request publishes missing on this site - Request (globe) on casting rows and loaded assets whose latest publish is not on this site, and Request Missing for all of them, through the new wtdcmds command wtd_request_revisions. Requested publishes show "requested, waiting for the download". - The version picker requests a version that is not on this site. - A 404 explains that the session is gone or wtdcmds is too old. - Fake server: car (vehicles) with a publish not on this site, wtd_request_revisions and /_test/download; 45 checks. - Tested live: car_paul modeling.blend v001 -> Requested. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-27 11:45:17 +01:00
NDemaerschalkandClaude Opus 5.5	9ee7710479	Scene Manager: fixes from the first run against a real Libreflow - Update / version switch: Blender 5.2 replaces the library on reload (renamed after its file, custom properties gone); find it by path and restore its name and tags. - Remove the libraries an asset linked indirectly when it is removed or fails to load (remove_unused_libraries), never a managed one. - Config: real Kitsu asset types for link modes and Shot Viewer groups, setdress_low files for bg_location, "environments" collection fallback. - Dev fake server and test use the real asset types; rock links a node group from the essentials to cover the indirect library cleanup. - README and CLAUDE.md updated with the live findings. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-27 11:30:46 +01:00
Nero Frame 13andClaude Opus 5.5	017bdfc2fd	Added dev test tools and CLAUDE.md dev/: test asset files, a fake Libreflow IPC server and an end-to-end Scene Manager test (excluded from the extension build). CLAUDE.md: notes for working on the add-on (conventions, testing, design findings, open points). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-27 11:15:02 +01:00
Nero Frame 13andClaude Opus 5.5	c238f4db7c	Added the Scene Manager (Libreflow casting, load, update, assetize) New Scene Manager panel (WTD tab) talking to a running Libreflow through its IPC server and the wtdcmds commands: pick the shot context, read the casting, link the latest available publishes (overrides for chars and props, collection instances otherwise), flag out-of-date versions in red, update / roll back / remove loaded assets, and publish local collections as assets. Requests run in the background. Settings in config.py (SCENE_MANAGER_, LIBREFLOW_). The Shot Viewer groups rigs loaded by the Scene Manager by asset type. The manifest declares the network permission. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-27 11:15:02 +01:00