style

Author: yiyixuxu

src/diffusers/__init__.py

@@ -38,8 +38,8 @@
     "hooks": [],
     "loaders": ["FromOriginalModelMixin"],
     "models": [],
-    "pipelines": [],
     "modular_pipelines": [],
+    "pipelines": [],
     "quantizers.quantization_config": [],
     "schedulers": [],
     "utils": [
@@ -147,8 +147,8 @@
         [
             "FasterCacheConfig",
             "HookRegistry",
-            "PyramidAttentionBroadcastConfig",
             "LayerSkipConfig",
+            "PyramidAttentionBroadcastConfig",
             "SmoothedEnergyGuidanceConfig",
             "apply_faster_cache",
             "apply_layer_skip",
@@ -235,6 +235,15 @@
             "WanVACETransformer3DModel",
         ]
     )
+    _import_structure["modular_pipelines"].extend(
+        [
+            "ComponentsManager",
+            "ComponentSpec",
+            "ModularLoader",
+            "ModularPipeline",
+            "ModularPipelineBlocks",
+        ]
+    )
     _import_structure["optimization"] = [
         "get_constant_schedule",
         "get_constant_schedule_with_warmup",
@@ -266,15 +275,6 @@
             "StableDiffusionMixin",
         ]
     )
-    _import_structure["modular_pipelines"].extend(
-        [
-            "ModularLoader",
-            "ModularPipeline",
-            "ModularPipelineBlocks",
-            "ComponentSpec",
-            "ComponentsManager",
-        ]
-    )
     _import_structure["quantizers"] = ["DiffusersQuantizer"]
     _import_structure["schedulers"].extend(
         [
@@ -356,6 +356,12 @@
     ]
 
 else:
+    _import_structure["modular_pipelines"].extend(
+        [
+            "StableDiffusionXLAutoPipeline",
+            "StableDiffusionXLModularLoader",
+        ]
+    )
     _import_structure["pipelines"].extend(
         [
             "AllegroPipeline",
@@ -565,12 +571,6 @@
             "WuerstchenPriorPipeline",
         ]
     )
-    _import_structure["modular_pipelines"].extend(
-        [
-            "StableDiffusionXLAutoPipeline",
-            "StableDiffusionXLModularLoader",
-        ]
-    )
 
 
 try:

src/diffusers/commands/custom_blocks.py

@@ -30,6 +30,7 @@
 EXPECTED_PARENT_CLASSES = ["PipelineBlock"]
 CONFIG = "config.json"
 
+
 def conversion_command_factory(args: Namespace):
     return CustomBlocksCommand(args.block_module_name, args.block_class_name)
 
@@ -45,7 +46,10 @@ def register_subcommand(parser: ArgumentParser):
             help="Module filename in which the custom block will be implemented.",
         )
         conversion_parser.add_argument(
-            "--block_class_name", type=str, default=None, help="Name of the custom block. If provided None, we will try to infer it."
+            "--block_class_name",
+            type=str,
+            default=None,
+            help="Name of the custom block. If provided None, we will try to infer it.",
         )
         conversion_parser.set_defaults(func=conversion_command_factory)
 
@@ -71,7 +75,7 @@ def run(self):
                 f"Found classes: {classes_found} will be using {classes_found[0]}. "
                 "If this needs to be changed, re-run the command specifying `block_class_name`."
             )
-            child_class, parent_class =  out[0][0], out[0][1]
+            child_class, parent_class = out[0][0], out[0][1]
 
         # dynamically get the custom block and initialize it to call `save_pretrained` in the current directory.
         # the user is responsible for running it, so I guess that is safe?
@@ -107,10 +111,7 @@ def _get_class_names(self, file_path):
                 continue
 
             # extract all base names for this class
-            base_names = [
-                bname for b in node.bases
-                if (bname := self._get_base_name(b)) is not None
-            ]
+            base_names = [bname for b in node.bases if (bname := self._get_base_name(b)) is not None]
 
             # for each allowed base that appears in the class's bases, emit a tuple
             for allowed in EXPECTED_PARENT_CLASSES:
@@ -131,4 +132,3 @@ def _create_automap(self, parent_class, child_class):
         module = str(self.block_module_name).replace(".py", "").rsplit(".", 1)[-1]
         auto_map = {f"{parent_class}": f"{module}.{child_class}"}
         return {"auto_map": auto_map}
-

src/diffusers/guiders/__init__.py

@@ -26,4 +26,12 @@
     from .smoothed_energy_guidance import SmoothedEnergyGuidance
     from .tangential_classifier_free_guidance import TangentialClassifierFreeGuidance
 
-    GuiderType = Union[AdaptiveProjectedGuidance, AutoGuidance, ClassifierFreeGuidance, ClassifierFreeZeroStarGuidance, SkipLayerGuidance, SmoothedEnergyGuidance, TangentialClassifierFreeGuidance]
+    GuiderType = Union[
+        AdaptiveProjectedGuidance,
+        AutoGuidance,
+        ClassifierFreeGuidance,
+        ClassifierFreeZeroStarGuidance,
+        SkipLayerGuidance,
+        SmoothedEnergyGuidance,
+        TangentialClassifierFreeGuidance,
+    ]

src/diffusers/guiders/adaptive_projected_guidance.py

@@ -27,7 +27,7 @@
 class AdaptiveProjectedGuidance(BaseGuidance):
     """
     Adaptive Projected Guidance (APG): https://huggingface.co/papers/2410.02416
-    
+
     Args:
         guidance_scale (`float`, defaults to `7.5`):
             The scale parameter for classifier-free guidance. Higher values result in stronger conditioning on the text
@@ -74,8 +74,9 @@ def __init__(
         self.use_original_formulation = use_original_formulation
         self.momentum_buffer = None
 
-    def prepare_inputs(self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None) -> List["BlockState"]:
-
+    def prepare_inputs(
+        self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None
+    ) -> List["BlockState"]:
         if input_fields is None:
             input_fields = self._input_fields
 

src/diffusers/guiders/auto_guidance.py

@@ -29,7 +29,7 @@
 class AutoGuidance(BaseGuidance):
     """
     AutoGuidance: https://huggingface.co/papers/2406.02507
-    
+
     Args:
         guidance_scale (`float`, defaults to `7.5`):
             The scale parameter for classifier-free guidance. Higher values result in stronger conditioning on the text
@@ -86,7 +86,9 @@ def __init__(
             )
         if auto_guidance_layers is not None and auto_guidance_config is not None:
             raise ValueError("Only one of `auto_guidance_layers` or `auto_guidance_config` can be provided.")
-        if (dropout is None and auto_guidance_layers is not None) or (dropout is not None and auto_guidance_layers is None):
+        if (dropout is None and auto_guidance_layers is not None) or (
+            dropout is not None and auto_guidance_layers is None
+        ):
             raise ValueError("`dropout` must be provided if `auto_guidance_layers` is provided.")
 
         if auto_guidance_layers is not None:
@@ -96,7 +98,9 @@ def __init__(
                 raise ValueError(
                     f"Expected `auto_guidance_layers` to be an int or a list of ints, but got {type(auto_guidance_layers)}."
                 )
-            auto_guidance_config = [LayerSkipConfig(layer, fqn="auto", dropout=dropout) for layer in auto_guidance_layers]
+            auto_guidance_config = [
+                LayerSkipConfig(layer, fqn="auto", dropout=dropout) for layer in auto_guidance_layers
+            ]
 
         if isinstance(auto_guidance_config, LayerSkipConfig):
             auto_guidance_config = [auto_guidance_config]
@@ -121,8 +125,9 @@ def cleanup_models(self, denoiser: torch.nn.Module) -> None:
                 registry = HookRegistry.check_if_exists_or_initialize(denoiser)
                 registry.remove_hook(name, recurse=True)
 
-    def prepare_inputs(self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None) -> List["BlockState"]:
-
+    def prepare_inputs(
+        self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None
+    ) -> List["BlockState"]:
         if input_fields is None:
             input_fields = self._input_fields
 

src/diffusers/guiders/classifier_free_guidance.py

@@ -27,25 +27,25 @@
 class ClassifierFreeGuidance(BaseGuidance):
     """
     Classifier-free guidance (CFG): https://huggingface.co/papers/2207.12598
-    
+
     CFG is a technique used to improve generation quality and condition-following in diffusion models. It works by
     jointly training a model on both conditional and unconditional data, and using a weighted sum of the two during
-    inference. This allows the model to tradeoff between generation quality and sample diversity.
-    The original paper proposes scaling and shifting the conditional distribution based on the difference between
-    conditional and unconditional predictions. [x_pred = x_cond + scale * (x_cond - x_uncond)]
-    
+    inference. This allows the model to tradeoff between generation quality and sample diversity. The original paper
+    proposes scaling and shifting the conditional distribution based on the difference between conditional and
+    unconditional predictions. [x_pred = x_cond + scale * (x_cond - x_uncond)]
+
     Diffusers implemented the scaling and shifting on the unconditional prediction instead based on the [Imagen
     paper](https://huggingface.co/papers/2205.11487), which is equivalent to what the original paper proposed in
     theory. [x_pred = x_uncond + scale * (x_cond - x_uncond)]
-    
+
     The intution behind the original formulation can be thought of as moving the conditional distribution estimates
     further away from the unconditional distribution estimates, while the diffusers-native implementation can be
     thought of as moving the unconditional distribution towards the conditional distribution estimates to get rid of
     the unconditional predictions (usually negative features like "bad quality, bad anotomy, watermarks", etc.)
-    
+
     The `use_original_formulation` argument can be set to `True` to use the original CFG formulation mentioned in the
     paper. By default, we use the diffusers-native implementation that has been in the codebase for a long time.
-    
+
     Args:
         guidance_scale (`float`, defaults to `7.5`):
             The scale parameter for classifier-free guidance. Higher values result in stronger conditioning on the text
@@ -68,16 +68,22 @@ class ClassifierFreeGuidance(BaseGuidance):
     _input_predictions = ["pred_cond", "pred_uncond"]
 
     def __init__(
-        self, guidance_scale: float = 7.5, guidance_rescale: float = 0.0, use_original_formulation: bool = False, start: float = 0.0, stop: float = 1.0
+        self,
+        guidance_scale: float = 7.5,
+        guidance_rescale: float = 0.0,
+        use_original_formulation: bool = False,
+        start: float = 0.0,
+        stop: float = 1.0,
     ):
         super().__init__(start, stop)
 
         self.guidance_scale = guidance_scale
         self.guidance_rescale = guidance_rescale
         self.use_original_formulation = use_original_formulation
 
-    def prepare_inputs(self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None) -> List["BlockState"]:
-
+    def prepare_inputs(
+        self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None
+    ) -> List["BlockState"]:
         if input_fields is None:
             input_fields = self._input_fields
 

src/diffusers/guiders/classifier_free_zero_star_guidance.py

@@ -27,14 +27,14 @@
 class ClassifierFreeZeroStarGuidance(BaseGuidance):
     """
     Classifier-free Zero* (CFG-Zero*): https://huggingface.co/papers/2503.18886
-    
+
     This is an implementation of the Classifier-Free Zero* guidance technique, which is a variant of classifier-free
     guidance. It proposes zero initialization of the noise predictions for the first few steps of the diffusion
     process, and also introduces an optimal rescaling factor for the noise predictions, which can help in improving the
     quality of generated images.
-    
+
     The authors of the paper suggest setting zero initialization in the first 4% of the inference steps.
-    
+
     Args:
         guidance_scale (`float`, defaults to `7.5`):
             The scale parameter for classifier-free guidance. Higher values result in stronger conditioning on the text
@@ -74,8 +74,9 @@ def __init__(
         self.guidance_rescale = guidance_rescale
         self.use_original_formulation = use_original_formulation
 
-    def prepare_inputs(self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None) -> List["BlockState"]:
-
+    def prepare_inputs(
+        self, data: "BlockState", input_fields: Optional[Dict[str, Union[str, Tuple[str, str]]]] = None
+    ) -> List["BlockState"]:
         if input_fields is None:
             input_fields = self._input_fields