diffusers-workflow 0.4.0a3__py3-none-any.whl

dw/workflow_schema.json

@@ -0,0 +1,1157 @@
+{
+    "$id": "https://github.com/dkackman/diffusers-helper/workflow",
+    "$schema": "https://json-schema.org/draft/2020-12/schema#",
+    "description": "The definition of the diffusers-workflow.",
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "variables": {
+            "$ref": "#/$defs/arguments"
+        },
+        "seed": {
+            "description": "Default seed for the entire workflow",
+            "type": "integer",
+            "format": "int64"
+        },
+        "steps": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "$ref": "#/$defs/step"
+            }
+        }
+    },
+    "required": [
+        "id",
+        "steps"
+    ],
+    "$defs": {
+        "image": {
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "format": "uri"
+                },
+                "size": {
+                    "type": "object",
+                    "properties": {
+                        "width": {
+                            "type": "integer",
+                            "format": "int16"
+                        },
+                        "height": {
+                            "type": "integer",
+                            "format": "int16"
+                        }
+                    }
+                }
+            },
+            "required": [
+                "location"
+            ]
+        },
+        "step": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "seed": {
+                    "description": "Default seed for the entire step",
+                    "type": "integer",
+                    "format": "int64"
+                },
+                "release_pipeline": {
+                    "description": "Unload this step's pipeline once the step completes, freeing its memory for later steps. A later pipeline_reference to this step is an error, and the REPL's cross-run cache will not retain it.",
+                    "type": "boolean"
+                },
+                "release_models": {
+                    "description": "Unload every cached task model once the step completes, freeing their memory for later steps. Task models otherwise stay loaded for the life of the process; set this on a task or sub-workflow step whose model is not needed again, such as a prompt expander running ahead of a generation step. A later step using the same model reloads it.",
+                    "type": "boolean"
+                },
+                "task": {
+                    "$ref": "#/$defs/task"
+                },
+                "pipeline": {
+                    "$ref": "#/$defs/pipeline"
+                },
+                "pipeline_reference": {
+                    "$ref": "#/$defs/pipeline_reference"
+                },
+                "workflow": {
+                    "$ref": "#/$defs/workflow_reference"
+                },
+                "result": {
+                    "$ref": "#/$defs/result"
+                }
+            },
+            "oneOf": [
+                {
+                    "required": [
+                        "name",
+                        "task"
+                    ]
+                },
+                {
+                    "required": [
+                        "name",
+                        "pipeline"
+                    ]
+                },
+                {
+                    "required": [
+                        "name",
+                        "pipeline_reference"
+                    ]
+                },
+                {
+                    "required": [
+                        "name",
+                        "workflow"
+                    ]
+                }
+            ]
+        },
+        "arguments": {
+            "type": "object",
+            "additionalProperties": {
+                "description": "null declares an argument that is optional - a workflow can expose a variable a caller may pass without inventing a sentinel value for its absence.",
+                "type": [
+                    "string",
+                    "integer",
+                    "number",
+                    "object",
+                    "array",
+                    "boolean",
+                    "null"
+                ]
+            }
+        },
+        "pipeline_reference": {
+            "type": "object",
+            "properties": {
+                "reference_name": {
+                    "type": "string"
+                },
+                "chain": {
+                    "$ref": "#/$defs/chain"
+                },
+                "arguments": {
+                    "$ref": "#/$defs/arguments"
+                }
+            },
+            "required": [
+                "reference_name",
+                "arguments"
+            ]
+        },
+        "chain": {
+            "description": "Run this pipeline repeatedly, carrying visual continuity from each segment into the next, and stitch the segments into one long video. Specify the length with exactly one of 'segments' or 'match_audio'.",
+            "type": "object",
+            "properties": {
+                "segments": {
+                    "description": "Number of segments to generate and stitch. Accepts a 'variable:' reference.",
+                    "type": [
+                        "integer",
+                        "string"
+                    ],
+                    "minimum": 1
+                },
+                "match_audio": {
+                    "description": "Derive the segment count from the duration of the audio reference in this step's arguments, slicing it into frame-aligned per-segment chunks; the final video is muxed with the original, unsliced audio track.",
+                    "type": "boolean"
+                },
+                "continuity": {
+                    "description": "How continuity is carried from one segment into the next. 'last_frame' carries the segment's final frame as the next one's keyframe. 'last_segment' carries the segment itself - its frames and the soundtrack generated with them - as a video reference, which keeps motion, camera and voice across the seam instead of appearance alone; it needs a 'segment_argument' holding a references list.",
+                    "type": "string",
+                    "enum": [
+                        "last_frame",
+                        "last_segment"
+                    ],
+                    "default": "last_frame"
+                },
+                "segment_argument": {
+                    "description": "The pipeline argument the carry-over lands in - e.g. 'image' for image-to-video pipelines, or 'references' for reference-conditioned modular pipelines, where the carry-over is appended as an image or video reference.",
+                    "type": "string",
+                    "default": "image"
+                },
+                "carry_frames": {
+                    "description": "'last_segment' only - carry just this many frames from the tail of each segment rather than all of them, cutting the reference's soundtrack to the same span. A shorter carry costs less sequence length and memory (MiniMax H3 conditions on reference clips of 2 seconds and up, i.e. 48 frames at its 24 fps). Accepts a 'variable:' reference.",
+                    "type": [
+                        "integer",
+                        "string"
+                    ],
+                    "minimum": 1
+                },
+                "carry_audio": {
+                    "description": "'last_segment' only - whether the carried video reference brings the soundtrack generated with it, which is what carries a voice across the seam. Turn it off when the segments are already conditioned on a supplied audio track, as in a 'match_audio' chain.",
+                    "type": "boolean",
+                    "default": true
+                },
+                "trim_frames": {
+                    "description": "Frames removed from the head of every segment after the first (an image-to-video segment reproduces its keyframe as frame 0). Also bounds the audio crossfade window to trim_frames / fps seconds. Accepts a 'variable:' reference.",
+                    "type": [
+                        "integer",
+                        "string"
+                    ],
+                    "minimum": 0,
+                    "default": 1
+                },
+                "crossfade_ms": {
+                    "description": "Equal-power crossfade applied to generated audio at segment boundaries, clamped to the trim_frames / fps window. Accepts a 'variable:' reference.",
+                    "type": [
+                        "number",
+                        "string"
+                    ],
+                    "minimum": 0,
+                    "default": 75
+                },
+                "fps": {
+                    "description": "Frame rate used for the chain's audio math - trimming, crossfading, and match_audio planning. Defaults to the pipeline's 'frame_rate' argument when present; pipelines with a fixed rate (MiniMax H3: 24) need it set here. Accepts a 'variable:' reference.",
+                    "type": [
+                        "number",
+                        "string"
+                    ],
+                    "exclusiveMinimum": 0
+                },
+                "frame_snap": {
+                    "description": "Constraint the pipeline places on num_frames - counts must equal modulus * n + remainder within the bounds (MiniMax H3: modulus 17, remainder 5, min 124, max 345). Used to snap the final match_audio segment to a valid length.",
+                    "type": "object",
+                    "properties": {
+                        "modulus": {
+                            "type": "integer",
+                            "minimum": 1
+                        },
+                        "remainder": {
+                            "type": "integer",
+                            "minimum": 0
+                        },
+                        "min_frames": {
+                            "type": "integer",
+                            "minimum": 1
+                        },
+                        "max_frames": {
+                            "type": "integer",
+                            "minimum": 1
+                        }
+                    },
+                    "required": [
+                        "modulus",
+                        "remainder"
+                    ],
+                    "additionalProperties": false
+                },
+                "prompts": {
+                    "description": "Per-segment prompt overrides; segment i uses prompts[min(i, len(prompts) - 1)].",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "minItems": 1
+                },
+                "save_segments": {
+                    "description": "Write each completed segment to the output directory as a playable mp4 and free its frames, bounding memory to one segment - a crashed chain leaves the finished segments behind. The final video is streamed from the segment files. Requires PyAV and a frame rate.",
+                    "type": "boolean",
+                    "default": false
+                },
+                "keep_segments": {
+                    "description": "Leave the segment files in place after the final video is written (default: they are removed once it saves successfully). Only meaningful with save_segments.",
+                    "type": "boolean",
+                    "default": false
+                }
+            },
+            "oneOf": [
+                {
+                    "required": [
+                        "segments"
+                    ]
+                },
+                {
+                    "required": [
+                        "match_audio"
+                    ]
+                }
+            ],
+            "additionalProperties": false
+        },
+        "pipeline": {
+            "type": "object",
+            "properties": {
+                "configuration": {
+                    "$ref": "#/$defs/pipeline_configuration"
+                },
+                "shared_components": {
+                    "$ref": "#/$defs/shared_components"
+                },
+                "reused_components": {
+                    "$ref": "#/$defs/reused_components"
+                },
+                "scheduler": {
+                    "$ref": "#/$defs/scheduler"
+                },
+                "audio_scheduler": {
+                    "$ref": "#/$defs/scheduler"
+                },
+                "model": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "transformer": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "transformer_2": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "vae": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "unet": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "text_encoder": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "text_encoder_2": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "text_encoder_3": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "tokenizer": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "tokenizer_2": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "tokenizer_3": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "image_encoder": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "feature_extractor": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "prompt_enhancer_head": {
+                    "$ref": "#/$defs/pipeline_component"
+                },
+                "controlnet": {
+                    "$ref": "#/$defs/controlnet"
+                },
+                "loras": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/lora"
+                    }
+                },
+                "ip_adapter": {
+                    "$ref": "#/$defs/ip_adapter"
+                },
+                "from_pretrained_arguments": {
+                    "$ref": "#/$defs/from_pretrained_arguments"
+                },
+                "remote_text_encoder": {
+                    "description": "Encode prompts with a remote text-encoder service instead of loading the text encoder locally. The pipeline's text_encoder is set to None, the prompt is POSTed to the service (authenticated with the HuggingFace token), and the returned embeddings are passed to the pipeline as prompt_embeds. Mutually exclusive with prompt_weighting.",
+                    "type": "object",
+                    "properties": {
+                        "url": {
+                            "description": "URL of the remote text encoder endpoint, e.g. a HuggingFace inference endpoint.",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "url"
+                    ]
+                },
+                "seed": {
+                    "description": "The seed for this pipeline",
+                    "type": "integer",
+                    "format": "int64"
+                },
+                "chain": {
+                    "$ref": "#/$defs/chain"
+                },
+                "arguments": {
+                    "$ref": "#/$defs/arguments"
+                }
+            },
+            "required": [
+                "configuration",
+                "from_pretrained_arguments",
+                "arguments"
+            ]
+        },
+        "pipeline_configuration": {
+            "type": "object",
+            "properties": {
+                "offload": {
+                    "type": "string",
+                    "enum": [
+                        "model",
+                        "sequential"
+                    ]
+                },
+                "exclude_from_cpu_offload": {
+                    "description": "Component names (e.g. 'vae', 'text_encoder') to keep resident on the accelerator instead of offloading. Only applies when offload is 'sequential'.",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "group_offload": {
+                    "$ref": "#/$defs/group_offload"
+                },
+                "device": {
+                    "description": "The device to run this pipeline on, e.g. 'cuda', 'cuda:1', 'mps' or 'cpu'. Defaults to the device dw is running on and becomes the default for this pipeline's components.",
+                    "type": "string"
+                },
+                "component_type": {
+                    "description": "The python type of pipeline to use in the format 'module.typename' module defaults to diffusers",
+                    "type": "string"
+                },
+                "no_generator": {
+                    "description": "Whether to use a generator for the pipeline. Some pipelines do not support generators.",
+                    "type": "boolean"
+                },
+                "enable_attention_slicing": {
+                    "description": "Whether to enable attention slicing for the pipeline to reduce memory usage.",
+                    "type": "boolean"
+                },
+                "disable_attention_slicing": {
+                    "description": "Whether to disable automatic attention slicing on MPS devices. Attention slicing is enabled by default on MPS to reduce memory usage.",
+                    "type": "boolean"
+                },
+                "attention_backend": {
+                    "description": "The attention backend to use for the pipeline.",
+                    "type": "string"
+                },
+                "prompt_weighting": {
+                    "description": "Enable A1111-style prompt weighting syntax: (word:1.5) for emphasis, [word] for de-emphasis, ((word)) for nested weighting. Also supports prompts longer than 77 tokens. Currently supports Flux pipelines. Mutually exclusive with remote_text_encoder.",
+                    "type": "boolean"
+                },
+                "pre_load_modules": {
+                    "description": "List of Python modules to import before loading the pipeline. Used for modules that register with diffusers on import (e.g., sdnq).",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "load_components": {
+                    "description": "Arguments passed to a modular pipeline's load_components() - modular pipelines load their component weights separately from their config. Use 'dtype' to set the component dtype and 'names' to load a subset of components.",
+                    "type": "object",
+                    "properties": {
+                        "names": {
+                            "description": "Names of the components to load. All components are loaded when omitted.",
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "dtype": {
+                            "description": "The torch dtype to load components in, e.g. 'torch.bfloat16'",
+                            "type": "string"
+                        },
+                        "quantization_config": {
+                            "description": "Quantization configuration per component, keyed by component name (e.g. 'transformer', 'text_encoder'). A component not named here loads unquantized.",
+                            "type": "object",
+                            "additionalProperties": {
+                                "$ref": "#/$defs/quantization_config"
+                            }
+                        }
+                    }
+                },
+                "configs": {
+                    "description": "Values a modular pipeline's blocks declare and read while they run - not components, and not call arguments. Keys are whatever the pipeline itself declares, so what may be set here depends on the model: MiniMax-H3 declares 'canvas_short_edge', 'canvas_max_pixels' and 'reference_image_short_edge'. A name the pipeline does not declare is an error rather than a setting that quietly did nothing.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": [
+                            "string",
+                            "integer",
+                            "number",
+                            "boolean",
+                            "array",
+                            "null"
+                        ]
+                    }
+                },
+                "components": {
+                    "description": "Configuration applied to components once the pipeline has loaded them. This is where a modular pipeline's components are placed, since it pulls their weights itself. Keys name a component, optionally as a dotted path into one, e.g. 'text_encoder.model'.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": "object",
+                        "properties": {
+                            "group_offload": {
+                                "$ref": "#/$defs/group_offload"
+                            },
+                            "device": {
+                                "description": "The device to move this component to, e.g. 'cuda'. Only for components small enough to stay resident - the offloaded ones are placed by their own hooks.",
+                                "type": "string"
+                            },
+                            "residency": {
+                                "description": "Whether the component stays on its device for the whole run ('resident', the default) or rests in system memory and is moved to the device only while one of its own calls runs ('on_demand'). Use on_demand for a component that is large but called a handful of times, like a VAE that only encodes references and decodes the result - it frees the device for the rest of the run and, unlike group_offload, moves the model whole, so a tiled decode costs one pair of transfers rather than one per tile. Not for a component called every step, and cannot be combined with group_offload.",
+                                "type": "string",
+                                "enum": [
+                                    "resident",
+                                    "on_demand"
+                                ]
+                            },
+                            "enable_tiling": {
+                                "description": "Enable tiled decoding on this component, for a decoder that is not the one named 'vae' (which the pipeline-level 'vae' block covers) - LTX-2.5's 'diffusion_decoder', say, which otherwise decodes the whole video volume in one allocation. 'true' uses the model's own default tile size; an object passes tile and stride sizes through to enable_tiling(), which is what a card smaller than those defaults needs.",
+                                "type": [
+                                    "boolean",
+                                    "object"
+                                ]
+                            },
+                            "attention_backend": {
+                                "description": "Pin this component's attention backend persistently via set_attention_backend, e.g. 'flash', 'sage', '_flash_3_hub'. Use this instead of the pipeline-level attention_backend when the component is compiled - the per-call context manager forces recompiles.",
+                                "type": "string"
+                            },
+                            "truncate_layers": {
+                                "description": "Drop the tail of a ModuleList inside this component that the run never reads, before any offload hooks are installed. Keys are dotted paths relative to the component, values the number of entries to keep. For an encoder used for its hidden states: MiniMax-H3 conditions on hidden_states[50] of its 64-layer Qwen3-VL, so { 'language_model.layers': 51 } drops the 13 layers whose output nothing consumes while leaving hidden_states[50] bit-identical (keeping only 50 would hand back the final-norm output instead, a different tensor).",
+                                "type": "object",
+                                "additionalProperties": {
+                                    "type": "integer",
+                                    "minimum": 1
+                                }
+                            },
+                            "remove_modules": {
+                                "description": "Dotted paths to modules inside this component that the run never calls, each replaced with an Identity before any offload hooks are installed - a language-model head on a model used as an encoder, say. The attribute survives for anything that looks it up; the weights are freed rather than held (and, offloaded, pinned) for a call that never comes.",
+                                "type": "array",
+                                "items": {
+                                    "type": "string"
+                                }
+                            },
+                            "compile": {
+                                "$ref": "#/$defs/compile_config"
+                            }
+                        }
+                    }
+                },
+                "preserve_device_placement": {
+                    "description": "Whether to leave the component where it loaded rather than moving it to the device. Needed when the component is loaded already placed - by a 'device_map', or by a quantization that pins its tensors to one device. A 'components' block that group offloads already keeps the pipeline off the device on its own. Renamed from 'do_not_send_to_device', which is no longer recognized.",
+                    "type": "boolean"
+                },
+                "components_manager": {
+                    "description": "Attach a ComponentsManager to a modular pipeline. The manager tracks the pipeline's components and, with auto CPU offload enabled, keeps only the running ones on the device. It replaces 'offload', which modular pipelines do not support.",
+                    "type": "object",
+                    "properties": {
+                        "enable_auto_cpu_offload": {
+                            "description": "Move components between the device and system memory as the pipeline runs. Requires a device that reports free memory (CUDA). When enabled the manager owns device placement, so the pipeline is not moved to the device directly.",
+                            "type": "boolean",
+                            "default": false
+                        },
+                        "memory_reserve_margin": {
+                            "description": "Device memory to keep free when deciding what to offload, e.g. '3GB'",
+                            "type": "string",
+                            "default": "3GB"
+                        }
+                    }
+                },
+                "sdnq_optimize": {
+                    "description": "List of pipeline component names to apply SDNQ quantized matmul optimization to (e.g., ['transformer', 'text_encoder']). Requires sdnq package and CUDA/XPU hardware.",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "cache": {
+                    "description": "Enable diffusers built-in cache acceleration on the transformer. Mutually exclusive with teacache. Hooks auto-reset between inference runs.",
+                    "type": "object",
+                    "properties": {
+                        "type": {
+                            "description": "Cache algorithm: first_block (simplest, broadest support), faster (video-oriented, experimental), mag (magnitude-based, needs num_inference_steps), taylorseer (Taylor series approximation), text_kv (text key-value cache).",
+                            "type": "string",
+                            "enum": [
+                                "first_block",
+                                "faster",
+                                "mag",
+                                "taylorseer",
+                                "text_kv"
+                            ]
+                        },
+                        "threshold": {
+                            "description": "Cache threshold for first_block and mag types. Higher = more speedup, more quality loss. first_block default: 0.05, mag default: 0.06. Accepts a 'variable:' reference.",
+                            "type": [
+                                "number",
+                                "string"
+                            ]
+                        },
+                        "num_inference_steps": {
+                            "description": "Required for mag cache type. Must match the pipeline's num_inference_steps.",
+                            "type": "integer"
+                        },
+                        "max_skip_steps": {
+                            "description": "Max consecutive skippable steps for mag cache. Default: 3.",
+                            "type": "integer"
+                        },
+                        "retention_ratio": {
+                            "description": "Fraction of initial steps where skipping is disabled for mag cache. Default: 0.2.",
+                            "type": "number"
+                        },
+                        "mag_ratios": {
+                            "description": "Per-step magnitude ratios for mag cache. Required unless calibrate is true, and checkpoint-dependent. Either a preset name shipped by diffusers ('flux') or an explicit array of per-step ratios. Interpolated automatically when its length differs from num_inference_steps.",
+                            "oneOf": [
+                                {
+                                    "type": "string"
+                                },
+                                {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "number"
+                                    }
+                                }
+                            ]
+                        },
+                        "calibrate": {
+                            "description": "Run mag cache in calibration mode: skip nothing, and log the magnitude ratios for this model at the end of the run so they can be pasted into mag_ratios. Default: false.",
+                            "type": "boolean"
+                        },
+                        "cache_interval": {
+                            "description": "Full computation every N steps for taylorseer cache. Default: 5.",
+                            "type": "integer"
+                        },
+                        "max_order": {
+                            "description": "Taylor series order for taylorseer cache. Higher = better approximation, more memory. Default: 1.",
+                            "type": "integer"
+                        }
+                    },
+                    "required": [
+                        "type"
+                    ]
+                },
+                "teacache": {
+                    "description": "Enable TeaCache inference acceleration. Auto-detects transformer type. Caches intermediate computations and skips redundant steps. Requires num_inference_steps in pipeline arguments. Currently supports FluxTransformer2DModel. Mutually exclusive with cache.",
+                    "type": "object",
+                    "properties": {
+                        "rel_l1_thresh": {
+                            "description": "Cache threshold. Higher = more speedup, more quality loss. Model-specific defaults apply if omitted.",
+                            "type": "number"
+                        },
+                        "coefficients": {
+                            "description": "Polynomial coefficients for rescaling relative L1 distance. 5 floats for np.poly1d. If omitted, uses model-specific defaults.",
+                            "type": "array",
+                            "items": {
+                                "type": "number"
+                            },
+                            "minItems": 5,
+                            "maxItems": 5
+                        },
+                        "variant": {
+                            "description": "Explicit model variant from teacache_models.json. Required for models with multiple variants (e.g., 'cogvideox_2b', 'wan2.1_t2v_1.3b'). If omitted, uses the class default.",
+                            "type": "string"
+                        }
+                    }
+                },
+                "vae": {
+                    "type": "object",
+                    "properties": {
+                        "enable_slicing": {
+                            "type": "boolean"
+                        },
+                        "enable_tiling": {
+                            "type": "boolean"
+                        },
+                        "channels_last": {
+                            "type": "boolean"
+                        },
+                        "torch_dtype": {
+                            "type": "string"
+                        }
+                    }
+                },
+                "unet": {
+                    "type": "object",
+                    "properties": {
+                        "enable_forward_chunking": {
+                            "type": "boolean"
+                        },
+                        "channels_last": {
+                            "type": "boolean"
+                        },
+                        "torch_dtype": {
+                            "type": "string"
+                        },
+                        "attn_processor_type": {
+                            "type": "string"
+                        }
+                    }
+                },
+                "transformer": {
+                    "type": "object",
+                    "properties": {
+                        "attn_processor_type": {
+                            "description": "The type name of an attention processor",
+                            "type": "string"
+                        }
+                    }
+                },
+                "text_encoder": {
+                    "type": "object",
+                    "properties": {
+                        "torch_dtype": {
+                            "type": "string"
+                        }
+                    }
+                },
+                "shared_components": {
+                    "$ref": "#/$defs/shared_components"
+                },
+                "reused_components": {
+                    "$ref": "#/$defs/reused_components"
+                },
+                "enable_layerwise_casting": {
+                    "$ref": "#/$defs/enable_layerwise_casting"
+                },
+                "inversion": {
+                    "description": "Run the pipeline's invert() rather than the pipeline itself, returning the inverted latents. Only for pipelines that have one.",
+                    "type": "boolean"
+                },
+                "generate": {
+                    "description": "Run the pipeline's generate() rather than the pipeline itself, returning the generated ids. Only for pipelines that have one, such as a conditioner used on its own.",
+                    "type": "boolean"
+                }
+            },
+            "additionalProperties": false,
+            "required": [
+                "component_type"
+            ]
+        },
+        "shared_components": {
+            "description": "The names of components this step loads and later steps may reuse. A modular pipeline is given them after it is built, so the components it shares are the ones it actually loaded.",
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "reused_components": {
+            "description": "The names of components an earlier step shared, reused here instead of being loaded again. A reused component keeps the device placement the step that shared it gave it.",
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "scheduler": {
+            "type": "object",
+            "properties": {
+                "configuration": {
+                    "type": "object",
+                    "properties": {
+                        "scheduler_type": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "scheduler_type"
+                    ]
+                },
+                "from_config_args": {
+                    "$ref": "#/$defs/arguments"
+                },
+                "shift": {
+                    "description": "Exponential sigma shift applied to this scheduler's schedule, for schedulers that take one (MiniMax H3: 12.0 for video, 3.0 for audio in the released checkpoint). Lower it when running few steps - a high shift packs the whole grid near sigma 1 and leaves one enormous final step, which a short schedule cannot absorb. Accepts a 'variable:' reference.",
+                    "type": [
+                        "number",
+                        "string"
+                    ],
+                    "exclusiveMinimum": 0
+                }
+            },
+            "anyOf": [
+                {
+                    "required": [
+                        "configuration"
+                    ]
+                },
+                {
+                    "required": [
+                        "shift"
+                    ]
+                }
+            ]
+        },
+        "pipeline_component": {
+            "type": "object",
+            "properties": {
+                "configuration": {
+                    "type": "object",
+                    "properties": {
+                        "device": {
+                            "description": "The device to load this component onto, e.g. 'cuda', 'cuda:1', 'mps' or 'cpu'. Defaults to the device its pipeline runs on.",
+                            "type": "string"
+                        },
+                        "component_type": {
+                            "description": "The python type of pipeline component to use in the format 'module.typename' module defaults to diffusers",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "component_type"
+                    ]
+                },
+                "group_offload": {
+                    "$ref": "#/$defs/group_offload"
+                },
+                "enable_layerwise_casting": {
+                    "$ref": "#/$defs/enable_layerwise_casting"
+                },
+                "quantization_config": {
+                    "$ref": "#/$defs/quantization_config"
+                },
+                "from_pretrained_arguments": {
+                    "$ref": "#/$defs/from_pretrained_arguments"
+                }
+            },
+            "required": [
+                "configuration",
+                "from_pretrained_arguments"
+            ]
+        },
+        "quantization_config": {
+            "type": "object",
+            "properties": {
+                "configuration": {
+                    "type": "object",
+                    "properties": {
+                        "config_type": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "config_type"
+                    ]
+                },
+                "arguments": {
+                    "$ref": "#/$defs/arguments"
+                }
+            },
+            "required": [
+                "configuration",
+                "arguments"
+            ]
+        },
+        "controlnet": {
+            "type": "object",
+            "properties": {
+                "configuration": {
+                    "$ref": "#/$defs/pipeline_configuration"
+                },
+                "from_pretrained_arguments": {
+                    "$ref": "#/$defs/from_pretrained_arguments"
+                }
+            },
+            "required": [
+                "configuration",
+                "from_pretrained_arguments"
+            ]
+        },
+        "ip_adapter": {
+            "type": "object",
+            "properties": {
+                "model_name": {
+                    "description": "The huggingface hub name of the ip adadapter model to use.",
+                    "type": "string"
+                },
+                "weight_name": {
+                    "description": "The file name of the ip adapter weights.",
+                    "type": "string"
+                },
+                "subfolder": {
+                    "description": "The subfolder location of a model file within a larger model repository",
+                    "type": [
+                        "string",
+                        "null"
+                    ]
+                },
+                "scale": {
+                    "description": "The scale factor of the ip adapter.",
+                    "type": "number",
+                    "format": "float"
+                }
+            },
+            "required": [
+                "model_name"
+            ]
+        },
+        "lora": {
+            "type": "object",
+            "properties": {
+                "model_name": {
+                    "description": "The huggingface hub name of the lora.",
+                    "type": "string"
+                },
+                "weight_name": {
+                    "description": "The file name of the lora weights.",
+                    "type": "string"
+                },
+                "subfolder": {
+                    "description": "The subfolder location of a model file within a larger model repository",
+                    "type": "string"
+                },
+                "scale": {
+                    "description": "The scale factor of the lora when fusing. Accepts a 'variable:' reference.",
+                    "type": [
+                        "number",
+                        "string"
+                    ],
+                    "format": "float"
+                },
+                "adapter_name": {
+                    "description": "The user defined name of the adapter to pass to set_adapters function",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "model_name"
+            ]
+        },
+        "from_pretrained_arguments": {
+            "type": "object",
+            "description": "Arguments to pass to the from_pretrained function when creating the component. Names at most one source: 'model_name', 'from_single_file' or 'task'. A pipeline assembled entirely from components an earlier step shared and components declared beside it - LTX-2's latent upsampler, say - names none of them and is constructed directly from those components.",
+            "properties": {
+                "model_name": {
+                    "description": "The huggingface hub name of the pretrained model to load",
+                    "type": "string"
+                },
+                "from_single_file": {
+                    "description": "Location of a checkpoint model from a single file",
+                    "type": "string"
+                },
+                "task": {
+                    "description": "The name of a task that transformers.Pipeline understands",
+                    "type": "string"
+                }
+            },
+            "additionalProperties": {
+                "type": [
+                    "string",
+                    "number",
+                    "object",
+                    "array",
+                    "boolean",
+                    "null"
+                ]
+            },
+            "oneOf": [
+                {
+                    "required": [
+                        "model_name"
+                    ]
+                },
+                {
+                    "required": [
+                        "from_single_file"
+                    ]
+                },
+                {
+                    "required": [
+                        "task"
+                    ]
+                },
+                {
+                    "allOf": [
+                        {
+                            "not": {
+                                "required": [
+                                    "model_name"
+                                ]
+                            }
+                        },
+                        {
+                            "not": {
+                                "required": [
+                                    "from_single_file"
+                                ]
+                            }
+                        },
+                        {
+                            "not": {
+                                "required": [
+                                    "task"
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ]
+        },
+        "task": {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string"
+                },
+                "arguments": {
+                    "$ref": "#/$defs/arguments"
+                },
+                "inputs": {
+                    "type": "array",
+                    "items": {
+                        "type": [
+                            "string",
+                            "integer",
+                            "number",
+                            "object",
+                            "boolean"
+                        ]
+                    }
+                }
+            },
+            "oneOf": [
+                {
+                    "required": [
+                        "command",
+                        "arguments"
+                    ]
+                },
+                {
+                    "required": [
+                        "command",
+                        "inputs"
+                    ]
+                }
+            ]
+        },
+        "workflow_reference": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "description": "The path to the workflow file. Use 'builtin:' for built-in workflows.",
+                    "type": "string"
+                },
+                "arguments": {
+                    "$ref": "#/$defs/arguments"
+                }
+            }
+        },
+        "result": {
+            "type": "object",
+            "properties": {
+                "content_type": {
+                    "description": "The content type of the result when serialized to disk. Audio can be written as 'audio/wav', 'audio/flac', 'audio/mpeg' (mp3), 'audio/ogg' or 'audio/opus'. Opus is written into an ogg container and only encodes sample rates of 8000, 12000, 16000, 24000 or 48000.",
+                    "type": "string"
+                },
+                "save": {
+                    "description": "Whether to save the result",
+                    "type": "boolean",
+                    "default": true
+                },
+                "file_base_name": {
+                    "description": "The base name for saving result and metadata files. The file extension is determined by context and content_type.",
+                    "type": "string"
+                },
+                "fps": {
+                    "description": "Frames per second - only used when output is video",
+                    "type": "integer",
+                    "default": 8
+                },
+                "sample_rate": {
+                    "description": "Audio sample rate - only used when output is audio",
+                    "type": "integer",
+                    "default": 44100
+                },
+                "audio_sample_rate": {
+                    "description": "Sample rate of the audio generated with a video, muxed into 'video/mp4' output. Defaults to the rate reported by the pipeline's vocoder - only set this to override it.",
+                    "type": "integer"
+                },
+                "subtype": {
+                    "description": "Audio encoding subtype, e.g. 'PCM_24' for wav and flac or 'VORBIS' for ogg. Defaults to the container's own default ('PCM_16' for wav and flac). Only used when output is audio.",
+                    "type": "string"
+                },
+                "compression_level": {
+                    "description": "Encoding compression level from 0.0 to 1.0 for compressed audio formats (flac, mp3, ogg). Higher means smaller files. Only used when output is audio.",
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
+                },
+                "bitrate_mode": {
+                    "description": "Bitrate mode for compressed audio formats: 'CONSTANT', 'AVERAGE' or 'VARIABLE'. Only used when output is audio.",
+                    "type": "string",
+                    "enum": [
+                        "CONSTANT",
+                        "AVERAGE",
+                        "VARIABLE"
+                    ]
+                },
+                "embed_metadata": {
+                    "description": "Whether to embed generation parameters as metadata in saved images (PNG info chunks or EXIF). Only applies to image content types.",
+                    "type": "boolean",
+                    "default": false
+                }
+            },
+            "additionalProperties": {
+                "type": [
+                    "string",
+                    "number",
+                    "object",
+                    "array",
+                    "boolean"
+                ]
+            },
+            "required": [
+                "content_type"
+            ]
+        },
+        "enable_layerwise_casting": {
+            "type": "object",
+            "properties": {
+                "storage_dtype": {
+                    "type": "string"
+                },
+                "compute_dtype": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "storage_dtype",
+                "compute_dtype"
+            ]
+        },
+        "group_offload": {
+            "description": "Stream a model between system memory and the accelerator a group of layers at a time. Anything beyond the keys named here is passed through to apply_group_offloading, e.g. 'use_stream', 'num_blocks_per_group', 'low_cpu_mem_usage', 'offload_to_disk_path'.",
+            "type": "object",
+            "properties": {
+                "onload_device": {
+                    "type": "string"
+                },
+                "offload_device": {
+                    "type": "string",
+                    "default": "cpu"
+                },
+                "offload_type": {
+                    "type": "string"
+                }
+            },
+            "additionalProperties": true,
+            "required": [
+                "offload_type"
+            ]
+        },
+        "compile_config": {
+            "description": "Compile the component with torch.compile once it is fully configured. Best paired with a pinned attention_backend - the per-call context manager forces recompiles.",
+            "type": "object",
+            "properties": {
+                "mode": {
+                    "description": "torch.compile mode, e.g. 'default', 'reduce-overhead', 'max-autotune'.",
+                    "type": "string"
+                },
+                "fullgraph": {
+                    "description": "Require a single graph with no breaks. Fails fast on graph breaks instead of silently losing speedup.",
+                    "type": "boolean"
+                },
+                "dynamic": {
+                    "description": "Compile with dynamic shapes. Set true when resolutions or frame counts vary between runs to avoid recompiles.",
+                    "type": "boolean"
+                },
+                "repeated_blocks": {
+                    "description": "Compile only the model's repeated block classes (diffusers regional compilation) - near the same speedup as full compilation with a fraction of the cold-start cost.",
+                    "type": "boolean"
+                }
+            }
+        }
+    }
+}