modular_pipeline_infrastructure model/pipeline review

# `modular_pipeline_infrastructure` model/pipeline review

Commit tested: `0f1abc4ae8b0eb2a3b40e82a310507281144c423`

Review performed against the repository review rules.

Files reviewed:
- `src/diffusers/modular_pipelines/__init__.py`
- `src/diffusers/modular_pipelines/components_manager.py`
- `src/diffusers/modular_pipelines/mellon_node_utils.py`
- `src/diffusers/modular_pipelines/modular_pipeline.py`
- `src/diffusers/modular_pipelines/modular_pipeline_utils.py`

Duplicate search: checked GitHub Issues and PRs for `modular_pipeline_infrastructure`, `ModularPipeline`, `MellonPipelineConfig`, `from_custom_block`, `output_param_to_mellon_param`, `MODULAR_MODEL_CARD_TEMPLATE`, and the specific failure modes. No exact duplicate found. Related merged PRs exist for nearby modular/Mellon work, especially https://github.com/huggingface/diffusers/pull/13193 and https://github.com/huggingface/diffusers/pull/13051.

## Issue 1: `ModularPipeline()` crashes with an internal `UnboundLocalError`

Affected code:
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/src/diffusers/modular_pipelines/modular_pipeline.py#L1688-L1705

Problem:
When `blocks=None` and no `default_blocks_name` is available, `blocks_class` is never initialized, but line 1702 still reads it. The public base class therefore raises an internal `UnboundLocalError` instead of a clear configuration error.

Impact:
Users experimenting with custom modular blocks get a misleading crash before they can recover. This also weakens the fallback behavior added by the related merged PR https://github.com/huggingface/diffusers/pull/13193.

Reproduction:
```python
from diffusers import ModularPipeline

try:
ModularPipeline()
except Exception as e:
print(type(e).__name__)
print(e)
```

Relevant precedent:
`DiffusionPipeline` and other loaders generally raise explicit `ValueError`/`EnvironmentError` messages when required pipeline metadata is missing, rather than leaking local variable errors.

Suggested fix:
```python
blocks_class = None
if blocks is None:
if modular_config_dict is not None:
blocks_class_name = modular_config_dict.get("_blocks_class_name")
else:
blocks_class_name = self.default_blocks_name

if blocks_class_name is not None:
diffusers_module = importlib.import_module("diffusers")
blocks_class = getattr(diffusers_module, blocks_class_name, None)
if blocks_class is None or not blocks_class.block_classes:
blocks_class_name = self.default_blocks_name
blocks_class = getattr(diffusers_module, blocks_class_name, None)

if blocks_class is not None:
blocks = blocks_class()
else:
raise ValueError("`blocks` must be provided when no default modular blocks class is available.")
```

## Issue 2: Mellon custom block configs drop required inputs and print debug output

Affected code:
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/src/diffusers/modular_pipelines/mellon_node_utils.py#L1062-L1095

Problem:
`MellonPipelineConfig.from_custom_block()` ignores `InputParam.required=True` and always emits `"required_inputs": []`. The same loop also prints `processing input: ...` to stdout.

Impact:
Generated Mellon configs do not mark required custom block inputs, so the UI schema is less accurate than the modular block contract. The stdout print also leaks debug noise from a library API.

Reproduction:
```python
from diffusers import InputParam, ModularPipelineBlocks, OutputParam
from diffusers.modular_pipelines.mellon_node_utils import MellonPipelineConfig

class RequiredPromptBlock(ModularPipelineBlocks):
@property
def inputs(self):
return [InputParam("prompt", type_hint=str, required=True, metadata={"mellon": "textbox"})]

@property
def intermediate_outputs(self):
return [OutputParam("prompt", type_hint=str, metadata={"mellon": "text"})]

cfg = MellonPipelineConfig.from_custom_block(RequiredPromptBlock())
print(cfg.node_params["custom"]["params"]["prompt"])
```

Relevant precedent:
`node_spec_to_mellon_dict()` already supports `required_inputs` and marks labels via `mark_required()`.

Suggested fix:
```python
required_inputs = []

for input_param in block.inputs:
if input_param.name is None:
continue
if input_param.name in input_types:
input_param = copy.copy(input_param)
input_param.metadata = {"mellon": input_types[input_param.name]}
if input_param.required:
required_inputs.append(input_param.name)
inputs.append(input_param_to_mellon_param(input_param))

node_spec = {
"inputs": inputs,
"model_inputs": model_inputs,
"outputs": outputs,
"required_inputs": required_inputs,
"required_model_inputs": [p.name for p in model_inputs],
"block_name": "custom",
}
```

## Issue 3: Mellon output metadata ignores explicit `MellonParam` instances

Affected code:
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/src/diffusers/modular_pipelines/mellon_node_utils.py#L466-L491

Problem:
`input_param_to_mellon_param()` accepts `metadata={"mellon": MellonParam(...)}`, but `output_param_to_mellon_param()` only handles string metadata. Passing a fully custom `MellonParam.Output.*` silently falls through to `"custom"`.

Impact:
The docs promise full-control Mellon metadata for parameters, but custom output UI metadata is lost.

Reproduction:
```python
from diffusers import OutputParam
from diffusers.modular_pipelines.mellon_node_utils import MellonParam, output_param_to_mellon_param

param = OutputParam(
"answer",
type_hint=str,
metadata={"mellon": MellonParam.Output.text("answer")},
)

print(output_param_to_mellon_param(param).to_dict())
```

Relevant precedent:
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/src/diffusers/modular_pipelines/mellon_node_utils.py#L439-L441

Suggested fix:
```python
mellon_value = metadata.get("mellon") if metadata else None
if isinstance(mellon_value, MellonParam):
return mellon_value

mellon_type = mellon_value
```

## Issue 4: Pushed modular model cards contain a `[TODO]` placeholder

Affected code:
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L38-L56
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/src/diffusers/modular_pipelines/modular_pipeline.py#L2007-L2018

Problem:
`MODULAR_MODEL_CARD_TEMPLATE` hardcodes `[TODO]` under “Example Usage”. `ModularPipeline.save_pretrained(push_to_hub=True)` formats this template directly into `README.md`.

Impact:
Every pushed modular pipeline model card can publish placeholder text, violating the review rule to avoid TODO placeholders in generated user-facing artifacts.

Reproduction:
```python
from diffusers import ModularPipelineBlocks
from diffusers.modular_pipelines.modular_pipeline_utils import (
MODULAR_MODEL_CARD_TEMPLATE,
generate_modular_model_card_content,
)

class EmptyBlocks(ModularPipelineBlocks):
pass

readme = MODULAR_MODEL_CARD_TEMPLATE.format(**generate_modular_model_card_content(EmptyBlocks()))
print("[TODO]" in readme)
```

Relevant precedent:
The modular auto-doc rule requires generated docs to avoid unresolved TODO placeholders.

Suggested fix:
```python
MODULAR_MODEL_CARD_TEMPLATE = """{model_description}

## Pipeline Architecture

This modular pipeline is composed of the following blocks:

{blocks_description} {trigger_inputs_section}

## Model Components

{components_description} {configs_section}

{io_specification_section}
"""
```

## Issue 5: Mellon guide uses the wrong `save()` argument name

Affected code:
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/docs/source/en/modular_diffusers/mellon.md#L154-L160

Problem:
The guide calls `mellon_config.save(local_dir=...)`, but `MellonPipelineConfig.save()` requires the first argument as `save_directory` and does not accept `local_dir`.

Impact:
The documented copy-paste path for generating and pushing a Mellon config fails immediately.

Reproduction:
```python
from diffusers.modular_pipelines.mellon_node_utils import MellonPipelineConfig

cfg = MellonPipelineConfig(node_specs={})
try:
cfg.save(local_dir="somewhere", repo_id="user/repo", push_to_hub=False)
except Exception as e:
print(type(e).__name__)
print(e)
```

Relevant precedent:
The merged Mellon utility PR used `save_directory=local_dir` in its helper script: https://github.com/huggingface/diffusers/pull/13051

Suggested fix:
```python
mellon_config.save(
save_directory="/path/local/folder",
repo_id=repo_id,
push_to_hub=True,
)
```

## Coverage Status

Fast modular pipeline tests exist under `tests/modular_pipelines/`, and one slow/nightly custom-block integration exists at:
https://github.com/huggingface/diffusers/blob/0f1abc4ae8b0eb2a3b40e82a310507281144c423/tests/modular_pipelines/test_modular_pipelines_custom_blocks.py#L581-L625

I did not find dedicated fast tests for `mellon_node_utils.py`; that gap covers Issues 2, 3, and 5. No missing slow-test report item is raised because slow modular infrastructure coverage is present.

Start by reading the affected entry points in src/diffusers/modular_pipelines/modular_pipeline.py, mellon_node_utils.py, modular_pipeline_utils.py, and docs/source/en/modular_diffusers/mellon.md; run the modular pipeline tests under tests/modular_pipelines/. Done means the five reported behaviors are corrected, generated model cards contain no [TODO], the Mellon guide runs with the accepted argument name, and regression coverage is added for the Mellon utilities.

Written by the indexing model from the issue text.