diffusers-workflow 0.11.0__tar.gz → 0.11.1__tar.gz

{diffusers_workflow-0.11.0/diffusers_workflow.egg-info → diffusers_workflow-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffusers-workflow
-Version: 0.11.0
+Version: 0.11.1
 Summary: Declarative workflow engine and web UI for Hugging Face Diffusers
 Author: dkackman
 License: Apache-2.0

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1/diffusers_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffusers-workflow
-Version: 0.11.0
+Version: 0.11.1
 Summary: Declarative workflow engine and web UI for Hugging Face Diffusers
 Author: dkackman
 License: Apache-2.0

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/diffusers_workflow.egg-info/SOURCES.txt

@@ -361,6 +361,7 @@ tests/test_best_of_n_template.py
 tests/test_borders.py
 tests/test_cache_blocks.py
 tests/test_catalog_shape.py
+tests/test_catalog_speed_defaults.py
 tests/test_catalog_structure.py
 tests/test_chain.py
 tests/test_ci_config.py
@@ -463,6 +464,7 @@ tests/test_mcp_twins.py
 tests/test_mcp_workspaces.py
 tests/test_measure_sync.py
 tests/test_media_audio.py
+tests/test_media_decode_threads.py
 tests/test_media_frames.py
 tests/test_media_info.py
 tests/test_media_layering.py
@@ -507,12 +509,14 @@ tests/test_reference_skip_sets.py
 tests/test_references.py
 tests/test_rerun_new_seed.py
 tests/test_resize_bucket.py
+tests/test_restore_faces_helper_cache.py
 tests/test_restore_faces_video.py
 tests/test_result.py
 tests/test_result_fps.py
 tests/test_result_output_naming.py
 tests/test_rule_parity.py
 tests/test_runs.py
+tests/test_runtime_settings.py
 tests/test_scalar_result_validation.py
 tests/test_scheduler_config.py
 tests/test_schema.py
@@ -590,6 +594,7 @@ tests/test_worker_manager.py
 tests/test_worker_messages.py
 tests/test_worker_pool.py
 tests/test_workflow.py
+tests/test_workflow_run_keys.py
 tests/test_workflow_snapshot.py
 tests/test_workflow_step_cache.py
 tests/test_workflow_trust.py

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/ACCELERATION.md

@@ -136,6 +136,18 @@ Select the attention implementation diffusers uses for the duration of each pipe
 
 Common values: `"flash"`, `"flash_hub"`, `"sage"`, `"sage_hub"`, `"native"`, `"flex"`. The full set is diffusers' `AttentionBackendName` enum - availability depends on what's installed (`flash-attn`, `sageattention`, etc.) and the platform. `_hub`-suffixed backends are fetched from the Hugging Face Hub kernel registry on first use, which needs the `kernels` package installed (`pip install kernels`) - it is not a dw dependency, and no bundled workflow sets a backend, so each runs on a plain install. diffusers also refuses a Hub kernel whose publisher it does not list as trusted - `sage_hub` among them, since SageAttention 2 comes from `SageAttention/sage-attention` - until `DIFFUSERS_TRUST_REMOTE_KERNELS=true`, which allows remote code from any such publisher. On an RTX 3090 `sage_hub` measured about 30% faster per MiniMax-H3 step (13.8 s against 19.2 s at 960x544x124, 54.7 s against 81.2 s at 345 frames); the local `sage` backend needs `sageattention>=2.1.1`, which PyPI does not carry.
 
+The MiniMax-H3 baselines expose this as a variable: `attention_backend` on
+[video-with-audio.json](../workflows/templates/minimax/video-with-audio.json),
+[video-with-audio-768p.json](../workflows/templates/minimax/video-with-audio-768p.json),
+[image-to-video.json](../workflows/templates/minimax/image-to-video.json) and
+[reference-to-video.json](../workflows/templates/minimax/reference-to-video.json), pinned
+on the transformer and `null` by default. Pass `attention_backend=sage_hub` to a box with
+the `kernels` package and `DIFFUSERS_TRUST_REMOTE_KERNELS=true` in its `.env`; on MPS
+leave it null. The other H3 templates take the same key under `components.transformer`
+(`transformer_ref` for a ref2va workflow). LTX-2.5 cannot use it: its transformer
+passes an attention mask, and sage attention refuses one ("`attn_mask` is not supported
+for sage attention", measured 2026-10-10), so the LTX templates expose no backend.
+
 A component can also pin its backend persistently instead, via `set_attention_backend`:
 
 ```json
@@ -232,7 +244,11 @@ Three older per-component knobs, set in the pipeline `configuration` beside
 
 ## Memory Offloading
 
-`offload` (`"model"` or `"sequential"`) and `group_offload` trade speed for VRAM by streaming weights between system memory and the accelerator instead of keeping everything resident. `"model"` moves whole submodules and costs the least speed; `"sequential"` moves individual layers and is the slowest but uses the least memory; block/leaf-level `group_offload` sits between the two and is what a modular pipeline's self-loaded components use, since they aren't reachable in time for `offload`. Full configuration syntax is in [WORKFLOW_GUIDE.md](WORKFLOW_GUIDE.md#memory-offloading). Omit both for the fastest run, when VRAM allows it.
+`offload` (`"model"` or `"sequential"`) and `group_offload` trade speed for VRAM by streaming weights between system memory and the accelerator instead of keeping everything resident. `"model"` moves whole submodules and costs the least speed; `"sequential"` moves individual layers and is the slowest but uses the least memory; block/leaf-level `group_offload` sits between the two and is what a modular pipeline's self-loaded components use, since they aren't reachable in time for `offload`. Full configuration syntax is in [WORKFLOW_GUIDE.md](WORKFLOW_GUIDE.md#memory-offloading). Omit both for the fastest run, when VRAM allows it. Measured on an RTX 3090 (RECIPES_24GB.md): sequential
+offload costs about 6x per step on FLUX dev and 3.4x on Z-Image against model offload;
+a block-level, streamed `group_offload` of the transformer from pinned host memory
+matches the resident per-step cost while holding one block on the card, at ~22 GB of
+pinned host RAM per FLUX pipeline - the placement the unquantized FLUX templates use.
 
 `"residency": "on_demand"` on a component is the cheap case of the same trade: the model rests in system memory and is moved to the device whole around each of its own calls. That is a bad deal for anything called once per step, and a good one for a VAE called twice a run - it frees the VAE's VRAM for the denoise loop at the cost of two transfers, where group offloading the same VAE would restream it once per decode tile. See [On-demand components](WORKFLOW_GUIDE.md#on-demand-components).
 

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/LORAS.md

@@ -48,6 +48,10 @@ LoRA (Low-Rank Adaptation) models apply lightweight style or subject modificatio
 
 Any other property (e.g. `revision`) is forwarded as-is to the underlying `load_lora_weights()` call.
 
+`scale` and `alpha` are set in place on the loaded adapter, so a server run that changes
+only them reuses the warm pipeline instead of reloading it; changing `model_name` or
+`weight_name` reloads.
+
 ## Multiple LoRAs
 
 Stack multiple LoRAs. They are blended via weighted adapter composition:

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/RECIPES_24GB.md

@@ -12,23 +12,79 @@ The general recipe, in order of impact:
 
 ## Flux dev (12B)
 
-The bf16 transformer is ~24GB - it does not fit alongside the T5 encoder, and it does
-not fit alongside the VAE either: a resident bf16 transformer runs the denoise and then
-fails at decode. `offload: "model"` is what makes bf16 work on 24GB, and on an RTX 3090
-it is also the fastest configuration measured (1024x1024, 28 steps, pipeline loaded):
-
-| Approach | Config | Measured on RTX 3090 |
-| -------- | ------ | -------------------- |
-| **bf16 + model offload** | [flux-dev.json](../workflows/models/flux-dev.json) | 55s per image (72s cold) |
-| **bf16 + model offload + compile** | [flux-dev-compile.json](../workflows/models/flux-dev-compile.json) - `compile: {repeated_blocks: true}` on the transformer | 52s per image (64s cold) |
-| **int8 TorchAO** | transformer `quant_type: "torchao.quantization.Int8WeightOnlyConfig"` + `compile`, with or without `cache: first_block` | over 60s per *denoising step* - do not use on Ampere |
-| **float8 TorchAO** (RTX 40-series+) | `Float8DynamicActivationFloat8WeightConfig` + `compile` | needs compute capability 8.9+ (Ada); unmeasured |
-| **GGUF Q8** | [flux-gguf.json](../workflows/models/flux-gguf.json) - `from_single_file` Q8_0 transformer + `offload: "model"` | unmeasured; smallest VRAM, best quality retention |
-
-Measured 2026-09-07. A number in this table came from a run on the named card; a row
-without one is a configuration that loads, not a speed claim.
-
-**Examples:** [flux-dev-compile.json](../workflows/models/flux-dev-compile.json), [flux-gguf.json](../workflows/models/flux-gguf.json), [step-caching.json](../workflows/templates/step-caching.json)
+The bf16 transformer is ~22 GB, so on 24 GB it cannot sit beside its own activations
+with any margin, and it cannot sit beside the T5 encoder or the VAE at all. Three
+placements, measured on an RTX 3090 (2026-10-10, cold load included):
+
+| Placement | 1024x1024, 25 steps, 1 image, dev + LoRA | 768x768, 25 steps, 4 images, Krea | 1232x1632, 50 steps, Fill |
+| --------- | ----------------------------------------- | --------------------------------- | ------------------------- |
+| `offload: "sequential"` | 273 s (10.8 s/step) | not measured - same per-step cost | not measured |
+| `offload: "model"` | 61 s (1.7 s/step) at **23.3 GB reserved, 491 MB free** | **OOM** at 23.45 GiB | not attempted |
+| **transformer `group_offload`, block-level, streamed, pinned host copies** | 78 s (1.5 s/step), 17.7 GB peak reserved, 6 GB free | 131 s (3.2 s/step) | 152 s denoise (3.0 s/step), 1 s decode |
+
+Model offload is the fastest placement that loads, and the one #580 (9c708a12) retired:
+at 1024x1024 it runs with a few hundred MB to spare and fails on anything larger -
+a batch, a second encoder resident for prompt weighting, a cache's state. Sequential
+offload is safe everywhere and 6x slower per step. The streamed group offload is both:
+the transformer's blocks are copied in one at a time from pinned host memory under a
+CUDA stream, so each step costs the same as the resident model's, and the card holds
+one block plus the activations. It is what every unquantized FLUX template now uses:
+
+```json
+"configuration": {
+    "component_type": "FluxPipeline",
+    "components": {
+        "transformer": {
+            "group_offload": {
+                "offload_type": "block_level",
+                "num_blocks_per_group": 1,
+                "use_stream": true,
+                "record_stream": true
+            }
+        },
+        "text_encoder": { "device": "cuda" },
+        "text_encoder_2": { "device": "cuda" },
+        "vae": { "device": "cuda" }
+    }
+}
+```
+
+Two things the shape depends on. The non-offloaded components are placed explicitly:
+with no pipeline-level `offload`, nothing else moves them, and a T5 or VAE left on the
+CPU costs a minute per prompt encode and per decode (measured: 70 s before the first
+step, 185 s decoding). And the host copies are pinned - diffusers' default,
+`low_cpu_mem_usage: false` - which holds ~22 GB of unswappable host memory per loaded
+FLUX pipeline and takes ~35 s once per load; with `low_cpu_mem_usage: true` the copies
+come from pageable memory at 8 s/step, barely ahead of sequential. A host with less
+than 32 GB free should take `offload: "sequential"` instead.
+
+Compile and caching stack on top as before: `compile: {repeated_blocks: true}` measured
+52 s vs 55 s per image on the old model-offload placement; `cache: first_block` is
+[step-caching.json](../workflows/templates/step-caching.json). TorchAO int8 is over 60 s
+per *denoising step* on Ampere - do not use it there; float8 needs compute capability
+8.9+ (Ada) and is unmeasured; GGUF Q8 ([flux-gguf.json](../workflows/models/flux-gguf.json))
+loads with the least VRAM and is unmeasured for speed.
+
+**Examples:** [lora.json](../workflows/templates/lora.json), [flux-dev-compile.json](../workflows/models/flux-dev-compile.json), [flux-gguf.json](../workflows/models/flux-gguf.json), [step-caching.json](../workflows/templates/step-caching.json)
+
+## Z-Image Turbo (6B)
+
+Fits a 24 GB card in bf16 with model offload, and that is the configuration to use.
+Measured on an RTX 3090 (960x544, 9 steps, 4 images per prompt, cold load included,
+2026-10-10):
+
+| Offload | Load | Denoise | Decode | Total | Peak VRAM reserved |
+| ------- | ---- | ------- | ------ | ----- | ------------------ |
+| `sequential` | 18 s | 84 s | 2 s | 107 s | 1.1 GB |
+| **`model`** | 4 s | 25 s | 9 s | 41 s | 13.0 GB |
+| none (resident) | 11 s | 17 s | 2 s | 33 s | 23.7 GB, 95 MB free at decode |
+
+Sequential offload streams the transformer's layers every step and costs 3.4x on the
+denoise for a model that does not need the room. Resident is faster still but decodes
+four images with nothing to spare, so [z-image.json](../workflows/models/z-image.json)
+and the Z-Image portrait steps of the MiniMax templates use `"offload": "model"`. The
+decode's 9 s under model offload is the VAE swapping in; `vae.enable_slicing` would
+trade it for per-image decodes.
 
 ## Qwen-Image (20B)
 

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/RELEASING.md

@@ -7,6 +7,47 @@ notes from commits at tag time (see below). This section is a scratch pad
 for items a branch's author wants the next release note to name; clear it
 when a release ships.
 
+### 0.11.1
+
+<!-- Drafted from v0.11.0..develop. Paste into the GitHub release body once the tag has published: gh release edit v0.11.1 --notes-file ... -->
+
+A speed release. The unquantized FLUX templates run about 3.5x faster on
+a 24 GB card, Z-Image Turbo about 2.6x, a LoRA scale or scheduler shift
+change no longer reloads the model, and switching workflows keeps the
+models the next one shares. Every number below was measured on an RTX 3090;
+the placement tables are in docs/RECIPES_24GB.md.
+
+**Workflow speed**
+
+- The 14 unquantized FLUX templates and `models/flux-krea` stream the
+  transformer block by block from pinned host memory (`group_offload`)
+  instead of `offload: "sequential"`: a 25-step 1024x1024 image takes 78 s
+  instead of 273 s (1.5 s/step against 10.8), with 6 GB of VRAM to spare -
+  enough for the 4-image batches `offload: "model"` runs out of memory on.
+  It holds ~22 GB of pinned host RAM per loaded FLUX pipeline.
+- Z-Image Turbo (`models/z-image` and the MiniMax portrait steps) takes
+  `offload: "model"`: four 960x544 images in 41 s instead of 107 s.
+- The four MiniMax-H3 family baselines expose `attention_backend` (null by
+  default; `sage_hub` measured about 30% faster per step on a 3090; it needs
+  the `kernels` package and `DIFFUSERS_TRUST_REMOTE_KERNELS=true`, see
+  docs/ACCELERATION.md). LTX-2.5 cannot use sage attention (its attention
+  mask is refused).
+- A LoRA `scale`/`alpha` change or a scheduler `shift` change re-applies on
+  the warm pipeline instead of reloading it. Removing an alpha or shift still
+  reloads, and a `pipeline_reference` runs at the referenced step's own values.
+- Switching workflows in the worker keeps the warm pipelines the next
+  workflow loads anyway, instead of releasing everything first.
+- `restore_faces` builds its face helper once per run instead of once per
+  frame, and picture frames decode with libav threading, so video inputs
+  process faster.
+- Catalog defaults corrected: compose-workflows video steps run 5 steps
+  (was 20) and the prompt-weighting schnell workflow runs 4 steps at guidance
+  0 (was 20).
+- The six 9-step minimax ref2va templates drop a dead `first_block` cache,
+  and minimax/shots-batch drops its `release_pipeline`: a no-op inside the
+  run, but it unloaded H3 at job end, so H3 now stays resident after a
+  shots-batch job, which is the win.
+
 ### 0.11.0
 
 <!-- Drafted from v0.10.0..develop. Paste into the GitHub release body once the tag has published: gh release edit v0.11.0 --notes-file ... -->

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/SERVER.md

@@ -222,7 +222,9 @@ Among the free cards a job fits, dispatch prefers the one it has an affinity
 for: a rerun goes to the card that ran the original, and any job to the card
 whose worker last ran the same workflow (the same file, or an inline
 definition's `id`) - that worker's pipelines and step cache are warm, and a
-worker frees both when the workflow changes. A busy preferred card is not
+worker's step cache and any model the next workflow does not load are freed
+when the workflow changes, while a model both workflows load (same weights
+identity) stays warm. `clear_memory` still empties the card by hand. A busy preferred card is not
 waited for. A validation's cache probe and its `plan.estimate` ask about the
 card the job would be dispatched to now, and the estimate names it in
 `priced_for`. Memory is per card: `GET /api/memory` and `POST

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/TASKS.md

@@ -2632,7 +2632,7 @@ Restore and enhance faces in images using spandrel-compatible face restoration m
 | `eye_dist_threshold` | No | Skip faces with eye distance below this (default: 5) |
 | `upsample_img` | No | Pre-upscaled background image (e.g., from a prior upscale step) |
 
-Models are loaded via spandrel, so any `.pth`/`.safetensors` face restoration weights work. CodeFormer requires `pip install spandrel-extra-arches` (non-commercial license).
+Models are loaded via spandrel, so any `.pth`/`.safetensors` face restoration weights work. CodeFormer requires `pip install spandrel-extra-arches` (non-commercial license). The detector and parser are loaded once per settings/device and reused across frames; `release_models` drops them with the restorer.
 
 **Example:** [restore-faces.json](../workflows/templates/restore-faces.json) — Generate a portrait, then restore faces with GFPGAN v1.4.
 

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/WORKER_GUIDE.md

@@ -28,6 +28,13 @@ The worker cleans up automatically between runs (garbage collection + GPU
 cache clearing). If memory grows unexpectedly, `GET /api/memory` reports the
 current reading and `POST /api/memory/clear` resets it.
 
+Switching to a different workflow releases only the models the next workflow
+does not load: the worker prepares the incoming definition, and a pipeline
+both workflows load (same weights identity) stays warm. The step cache and
+the task model cache are still emptied, and if the incoming definition cannot
+be prepared everything is released. `clear_memory` (`POST /api/memory/clear`)
+remains the way to empty the card by hand.
+
 ## Troubleshooting
 
 **Worker crashes**: `JobManager` detects it and starts a fresh worker on the

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/docs/WORKFLOW_GUIDE.md

@@ -112,6 +112,10 @@ inverted latents:
 ```
 
 `reference_name` must name a step earlier in the same workflow that has a `pipeline`.
+Two steps whose pipelines differ only in a LoRA's `scale` or `alpha` or a scheduler's
+`shift` share one warm model, and a reference always runs at the referenced step's own
+values; `release_pipeline` on either step frees the shared model, as it does for two
+identical steps.
 See [workflows/templates/community-pipeline.json](../workflows/templates/community-pipeline.json) for a full example.
 
 ### Task Steps
@@ -1173,7 +1177,7 @@ Control how models use memory:
 ```
 
 - `"model"` — Moves entire models between CPU and GPU. Good balance of speed and memory.
-- `"sequential"` — Moves individual layers. Slowest but uses least GPU memory. On MPS it is downgraded to `"model"` with a warning: with unified memory there is no separate pool to keep small, so the per-layer copies cost speed and save nothing.
+- `"sequential"` — Moves individual layers. Slowest but uses least GPU memory (measured at 6x the per-step cost of model offload on FLUX dev and 3.4x on Z-Image; a streamed block-level `group_offload` of the transformer is the usual better answer - see [RECIPES_24GB.md](RECIPES_24GB.md#flux-dev-12b)). On MPS it is downgraded to `"model"` with a warning: with unified memory there is no separate pool to keep small, so the per-layer copies cost speed and save nothing.
   `exclude_from_cpu_offload` names components the sweep should leave alone.
 - Omit for no offloading (fastest, requires enough VRAM).
 
@@ -1325,6 +1329,13 @@ The step-level `release_pipeline` flag unloads the step's pipeline after its res
 saved. A later `pipeline_reference` to a released step is an error, and the process-wide
 step cache will not retain it.
 
+What keeps a pipeline warm: the server's worker keeps a pipeline loaded across runs for as
+long as what it *loads* is unchanged. A LoRA's `scale` and `alpha` and a scheduler's (or
+`audio_scheduler`'s) `shift` are applied in place on the warm pipeline, so iterating on
+them costs no reload; removing (nulling) an alpha or a shift reloads, so the checkpoint
+default comes back. Changing a LoRA's `model_name` or `weight_name`, the quantization,
+the placement or the scheduler type reloads it.
+
 #### Releasing task models mid-workflow
 
 Task models - the checkpoints behind `text_generation`, `segment`, `depth_estimator` and

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/media.py

@@ -33,6 +33,15 @@ from .dsp import SILENCE_DBFS, dbfs, integrated_lufs, layout_name, true_peak_dbf
 
 logger = logging.getLogger("dw")
 
+
+def _threaded(stream):
+    """A video stream set to decode on every core. libav defaults a
+    software h264 decode to one thread; AUTO lets it pick frame and
+    slice threading for the codec. Header-only reads do not call this."""
+    stream.thread_type = "AUTO"
+    return stream
+
+
 # The most a soundtrack may be as base64 before the gallery route refuses to
 # extract it whole - the twin of dw_mcp/media.py's MAX_RETURNED_BYTES (the
 # MCP package's cap on any inline payload). Two constants because dw_mcp
@@ -345,7 +354,7 @@ def video_shape(path):
         fps = float(stream.average_rate) if stream.average_rate else None
         count = int(stream.frames) if stream.frames else None
         if count is None:
-            count = sum(1 for _ in container.decode(stream))
+            count = sum(1 for _ in container.decode(_threaded(stream)))
         return {
             "frame_count": count,
             "fps": fps,
@@ -383,6 +392,8 @@ def read_frames(path, indexes, fit=None):
     wanted = sorted(set(int(i) for i in indexes))
     found = {}
     with av.open(path) as container:
+        # Not _threaded: frame threads hold frames in flight, and a backward
+        # seek after a decoded frame then yields stale ones (tests/test_media_decode_threads.py)
         stream = container.streams.video[0]
         fps = float(stream.average_rate) if stream.average_rate else None
         start_pts = stream.start_time if stream.start_time is not None else 0
@@ -479,6 +490,8 @@ def read_frame_range(path, start, stop):
         )
     out = None
     with av.open(path) as container:
+        # Not _threaded: frame threads hold frames in flight, and a backward
+        # seek after a decoded frame then yields stale ones (tests/test_media_decode_threads.py)
         stream = container.streams.video[0]
         fps = float(stream.average_rate) if stream.average_rate else None
         start_pts = stream.start_time if stream.start_time is not None else 0
@@ -513,7 +526,7 @@ def count_video_frames(path):
     """The picture frame count of `path`, by decoding every frame rather
     than reading the header. Nothing is held but the frame in hand."""
     with av.open(path) as container:
-        return sum(1 for _ in container.decode(container.streams.video[0]))
+        return sum(1 for _ in container.decode(_threaded(container.streams.video[0])))
 
 
 def decode_audio_video(handle):
@@ -531,7 +544,7 @@ def decode_audio_video(handle):
     sample_rate = None
 
     with av.open(handle) as container:
-        video_stream = container.streams.video[0]
+        video_stream = _threaded(container.streams.video[0])
         frame_rate = (
             float(video_stream.average_rate) if video_stream.average_rate else None
         )
@@ -559,7 +572,10 @@ def decode_rgb_frames(path):
     """Every picture frame of `path` as an (height, width, 3) uint8 array,
     in order."""
     with av.open(path) as container:
-        return [frame.to_ndarray(format="rgb24") for frame in container.decode(video=0)]
+        return [
+            frame.to_ndarray(format="rgb24")
+            for frame in container.decode(_threaded(container.streams.video[0]))
+        ]
 
 
 def read_thumbnails_and_track(path, thumb_width, thumb_height):
@@ -575,7 +591,9 @@ def read_thumbnails_and_track(path, thumb_width, thumb_height):
     thumbs = []
     chunks = []
     with av.open(path) as container:
-        video = container.streams.video[0] if container.streams.video else None
+        video = (
+            _threaded(container.streams.video[0]) if container.streams.video else None
+        )
         audio = container.streams.audio[0] if container.streams.audio else None
         if video is None and audio is None:
             raise ValueError(f"{path} has neither a video nor an audio stream")

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/pipeline_ownership.py

@@ -62,6 +62,11 @@ class PipelineOwnership:
         # pipeline_reference still address pipelines by the step that made
         # them
         self.keys_by_step = {}
+        # Step name -> the step's pipeline definition as the workflow holds
+        # it (never a loading copy), so a pipeline_reference can put the
+        # referenced step's own scale, alpha and shift back on a model a
+        # step differing only in those shares with it
+        self.definitions_by_step = {}
         # Step name -> _Deferred for each cache hit whose pipeline was not
         # resident and so was not loaded
         self.deferred = {}
@@ -92,9 +97,16 @@ class PipelineOwnership:
             )
         return self.running[step_name]
 
-    def record(self, step_name, key):
-        """Record which cache key a step's pipeline lives under this run."""
+    def record(self, step_name, key, pipeline_definition=None):
+        """Record which cache key a step's pipeline lives under this run,
+        and the definition it was loaded or wrapped from."""
         self.keys_by_step[step_name] = key
+        if pipeline_definition is not None:
+            self.definitions_by_step[step_name] = pipeline_definition
+
+    def definition_for(self, step_name):
+        """The pipeline definition `step_name` recorded this run, or None."""
+        return self.definitions_by_step.get(step_name)
 
     def key_for(self, step_name):
         """The cache key `step_name` recorded this run, or None."""
@@ -286,6 +298,10 @@ def wrap_resident(
             new_pipeline_wrapper.pipeline_definition.get("seed", default_seed)
         )
 
+    # The key the hit matched on is the weights identity: a scale, alpha or
+    # shift may differ from the values the resident model last ran with
+    new_pipeline_wrapper.apply_runtime_settings()
+
     # A cache hit and a cold load look identical from the outside -
     # same step, same dot - and they differ by minutes
     emit_phase("cached", detail=new_pipeline_wrapper.name)

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/pipeline_processors/adapters.py

@@ -101,11 +101,103 @@ def active_loras(loras):
     ]
 
 
+def adapter_settings(loras):
+    """(adapter_names, adapter_weights, alphas) for the active entries of
+    `loras`. An adapter is named by its own adapter_name or its ORIGINAL
+    index - a nulled entry keeps its slot, so the name a hit re-applies to
+    is the name the load gave. Reads the entries, never pops them.
+
+    `or` on adapter_name, because a variable nulled by the caller arrives as
+    a present None; float() on scale, because the schema takes a 'variable:'
+    reference there, and a variable declared as a string default substitutes
+    as one."""
+    names, weights, alphas = [], [], {}
+    for i, lora in enumerate(loras or []):
+        if not isinstance(lora, dict) or lora.get("model_name") is None:
+            continue
+        name = lora.get("adapter_name") or str(i)
+        names.append(name)
+        scale = lora.get("scale")
+        weights.append(1.0 if scale is None else float(scale))
+        if lora.get("alpha") is not None:
+            alphas[name] = lora["alpha"]
+    return names, weights, alphas
+
+
+def set_adapter_scales(pipeline, names, weights):
+    """Set each named adapter's scale on every loaded layer that carries it,
+    without re-activating the adapters.
+
+    The warm-pipeline path. diffusers' set_adapters() activates as well as
+    scales, and activation goes through peft's set_adapter(), which sets
+    requires_grad on the adapter weights - after a run under model offload
+    those are inference tensors, and torch refuses ("Setting requires_grad=True
+    on inference tensor outside InferenceMode" - seen on a 3090 the first time
+    a scale changed on a warm Flux pipeline, 2026-10-10).
+    A pipeline that already ran holds the adapters active, so a hit only
+    needs each layer's set_scale(), which recomputes scale * alpha / rank and
+    touches no tensor.
+
+    Raises:
+        ValueError: if an adapter is carried by no loaded layer - a scale
+            that applied to nothing would silently run the old value
+    """
+    touched = {name: 0 for name in names}
+    for module in _lora_layers(pipeline):
+        scaling = getattr(module, "scaling", None)
+        if not isinstance(scaling, dict):
+            continue
+        for name, weight in zip(names, weights):
+            if name in scaling:
+                module.set_scale(name, weight)
+                touched[name] += 1
+    missing = [name for name, count in touched.items() if not count]
+    if missing:
+        raise ValueError(
+            f"Cannot set the scale of adapter(s) {missing} - no loaded layer "
+            "carries them. Nothing would have been scaled."
+        )
+
+
+def apply_adapter_settings(loras, pipeline, activate=False):
+    """Set each active LoRA's alpha, then every scale, on a pipeline that
+    already holds the adapters. Alpha first: the scale pass is what recomputes
+    each layer's scaling from it. No-op with no active entry.
+
+    `activate` is the cold path, right after load_lora_weights: diffusers'
+    set_adapters() activates the adapters and sets their scales in one call.
+    A warm pipeline (a cache hit) has them active already and takes the
+    scale-only path - see set_adapter_scales for why it must.
+    """
+    names, weights, alphas = adapter_settings(loras)
+    if not names:
+        return
+    for name, alpha in alphas.items():
+        set_adapter_alpha(pipeline, name, alpha)
+    logger.info(f"Setting adapter weights: {list(zip(names, weights))}")
+    if activate:
+        # Positionally - diffusers' mixin calls the second parameter
+        # 'adapter_weights' while custom pipelines that delegate to the model
+        # (ostris/Krea2OstrisEdit) call it 'weights'
+        pipeline.set_adapters(names, weights)
+    else:
+        set_adapter_scales(pipeline, names, weights)
+
+
 def load_loras(loras, pipeline):
-    """Load and configure LoRA models."""
-    adapter_names = []
-    adapter_weights = []
-    alphas = {}
+    """Load and configure LoRA models.
+
+    Names, scales and alphas come from adapter_settings, read before the
+    entries are popped, so a load and a later cache hit's
+    apply_adapter_settings set the same values on the same names."""
+    # A snapshot of each entry's runtime keys, taken before the pops below
+    settings = [
+        {k: lora.get(k) for k in ("model_name", "adapter_name", "scale", "alpha")}
+        if isinstance(lora, dict)
+        else lora
+        for lora in loras or []
+    ]
+    names = iter(adapter_settings(settings)[0])
 
     for i, lora in enumerate(loras or []):
         if isinstance(lora, dict) and lora.get("model_name") is None:
@@ -117,40 +209,15 @@ def load_loras(loras, pipeline):
         logger.info(f"Loading LoRA: {model_name}")
         emit_phase("loading", detail=f"LoRA: {model_name}")
 
-        # Use provided adapter_name or generate from index - `or`, because a
-        # variable nulled by the caller arrives as a present None
-        adapter_name = lora.pop("adapter_name", None) or str(i)
-        adapter_names.append(adapter_name)
+        # Popped before the load: everything left in the dict is a keyword
+        # argument to load_lora_weights; the scale and alpha are applied to
+        # the layers afterwards rather than passed to it
+        for key in ("adapter_name", "scale", "alpha"):
+            lora.pop(key, None)
 
-        # Extract scale for adapter weights - float() because the schema takes a
-        # 'variable:' reference here, and a variable declared as a string default
-        # substitutes as one
-        scale = lora.pop("scale", None)
-        scale = 1.0 if scale is None else float(scale)
-        adapter_weights.append(scale)
+        pipeline.load_lora_weights(model_name, adapter_name=next(names), **lora)
 
-        # Popped before the load: everything left in the dict is a keyword
-        # argument to load_lora_weights, and the alpha is applied to the layers
-        # afterwards rather than passed to it
-        alpha = lora.pop("alpha", None)
-        if alpha is not None:
-            alphas[adapter_name] = alpha
-
-        # Load the LoRA with the adapter name
-        pipeline.load_lora_weights(model_name, adapter_name=adapter_name, **lora)
-
-    for adapter_name, alpha in alphas.items():
-        set_adapter_alpha(pipeline, adapter_name, alpha)
-
-    # Set adapter weights for all loaded LoRAs
-    if adapter_names:
-        logger.info(
-            f"Setting adapter weights: {list(zip(adapter_names, adapter_weights))}"
-        )
-        # Positionally - diffusers' mixin calls the second parameter 'adapter_weights'
-        # while custom pipelines that delegate to the model (ostris/Krea2OstrisEdit)
-        # call it 'weights'
-        pipeline.set_adapters(adapter_names, adapter_weights)
+    apply_adapter_settings(settings, pipeline, activate=True)
 
 
 def load_ip_adapter(ip_adapter_definition, pipeline):

{diffusers_workflow-0.11.0 → diffusers_workflow-0.11.1}/dw/pipeline_processors/components.py

@@ -447,6 +447,23 @@ def load_and_configure_scheduler(
             ),
         )
 
+    apply_scheduler_shift(scheduler_definition, pipeline, component_name)
+
+
+def apply_scheduler_shift(scheduler_definition, pipeline, component_name="scheduler"):
+    """Set the shift a scheduler definition names on an already-loaded
+    scheduler; nothing when the definition is None or names no shift.
+
+    A load sets it after any scheduler replacement, and a pipeline cache hit
+    sets it again (Pipeline.apply_runtime_settings), because the cache key
+    leaves the shift out - a run that only moves it reuses the warm pipeline.
+
+    Raises:
+        ValueError: if the scheduler is registered but not loaded, or has no
+            set_shift()
+    """
+    if scheduler_definition is None:
+        return
     shift = scheduler_definition.get("shift", None)
     if shift is None:
         return