# Blocs de pipeline

## ModularPipelineBlocks[[diffusers.ModularPipelineBlocks]]

#### diffusers.ModularPipelineBlocks[[diffusers.ModularPipelineBlocks]]

```python
diffusers.ModularPipelineBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L392)

Classe de base pour tous les blocs de Pipeline : ConditionalPipelineBlocks, AutoPipelineBlocks, SequentialPipelineBlocks, LoopSequentialPipelineBlocks

[ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) fournit une méthode pour charger et enregistrer la définition des blocs de pipeline.

#### get_block_state[[diffusers.ModularPipelineBlocks.get_block_state]]

```python
get_block_state(state: PipelineState)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L590)

Obtenir toutes les entrées et les intermédiaires dans un seul dictionnaire

#### get_execution_blocks[[diffusers.ModularPipelineBlocks.get_execution_blocks]]

```python
get_execution_blocks(**kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L461)

**Paramètres :**

- ****kwargs** : Noms et valeurs des entrées. Seules les entrées de déclenchement affectent la sélection des blocs.

Obtenez le ou les blocs qui s'exécuteraient étant donné les entrées. Doit être implémenté par les sous-classes qui prennent en charge la sélection conditionnelle de blocs.

#### get_workflow[[diffusers.ModularPipelineBlocks.get_workflow]]

```python
get_workflow(workflow_name: str)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L479)

**Paramètres :**

workflow_name : Nom du workflow à récupérer.

Récupère les blocs d'exécution pour un workflow spécifique. Doit être implémenté par les sous-classes qui définissent `_workflow_map`.

#### init_pipeline[[diffusers.ModularPipelineBlocks.init_pipeline]]

```python
init_pipeline(pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L568)

créer un ModularPipeline, accepter éventuellement pretrained_model_name_or_path pour charger depuis le hub.

## SequentialPipelineBlocks[[diffusers.SequentialPipelineBlocks]]

#### diffusers.SequentialPipelineBlocks[[diffusers.SequentialPipelineBlocks]]

```python
diffusers.SequentialPipelineBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1044)

**Paramètres :**

block_classes : liste des classes de bloc à utiliser

block_names : liste des préfixes pour chaque bloc

Un bloc de pipeline qui combine plusieurs classes de blocs de pipeline en un seul. Lors de son appel, il appelle chaque bloc dans l'ordre.

Cette classe hérite de [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les blocs de pipeline (tel que le chargement ou l'enregistrement, etc.)

#### from_blocks_dict[[diffusers.SequentialPipelineBlocks.from_blocks_dict]]

```python
from_blocks_dict(blocks_dict: dict[str, typing.Any], description: str | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1116)

**Paramètres :**

blocks_dict : Dictionnaire associant les noms de blocs aux classes ou instances de blocs

**Retourne :**

Une nouvelle instance de SequentialPipelineBlocks

Crée une instance de SequentialPipelineBlocks à partir d'un dictionnaire de blocs.

#### get_execution_blocks[[diffusers.SequentialPipelineBlocks.get_execution_blocks]]

```python
get_execution_blocks(**kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1259)

**Paramètres :**

- ****kwargs** : Noms et valeurs des entrées. Seules les entrées de déclenchement affectent la sélection des blocs.

**Retourne :**

SequentialPipelineBlocks ne contenant que les blocs qui s'exécuteraient

Obtenez les blocs qui s’exécuteraient avec les entrées spécifiées.

Lorsque la traversée parcourt les blocs séquentiels, les sorties intermédiaires des blocs résolus sont ajoutées aux entrées actives. Cela signifie que les blocs conditionnels qui dépendent d’intermédiaires (par exemple, « exécuter img2img si image_latents est présent ») seront résolus correctement, à condition que la condition soit basée sur la présence ou l’absence (None ou non None), et non sur la valeur réelle.

## LoopSequentialPipelineBlocks[[diffusers.LoopSequentialPipelineBlocks]]

#### diffusers.LoopSequentialPipelineBlocks[[diffusers.LoopSequentialPipelineBlocks]]

```python
diffusers.LoopSequentialPipelineBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1404)

**Paramètres :**

block_classes : liste des classes de bloc à utiliser

block_names : liste des préfixes pour chaque bloc

Un bloc Pipeline qui combine plusieurs classes de blocs de pipeline dans une boucle For. Lorsqu'il est appelé, il appelle chaque bloc dans l'ordre.

Cette classe hérite de [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les blocs de pipeline (tel que le chargement ou l'enregistrement, etc.)

#### from_blocks_dict[[diffusers.LoopSequentialPipelineBlocks.from_blocks_dict]]

```python
from_blocks_dict(blocks_dict: dict[str, typing.Any])
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1565)

**Paramètres :**

blocks_dict : Dictionnaire associant les noms de blocs aux instances de blocs

**Retourne :**

Une nouvelle instance de LoopSequentialPipelineBlocks

Crée une instance de LoopSequentialPipelineBlocks à partir d'un dictionnaire de blocs.

## AutoPipelineBlocks[[diffusers.AutoPipelineBlocks]]

#### diffusers.AutoPipelineBlocks[[diffusers.AutoPipelineBlocks]]

```python
diffusers.AutoPipelineBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L983)

**Paramètres :**

block_classes : Liste des classes de blocs à utiliser. Doit avoir la même longueur que `block_names` et `block_trigger_inputs`.

block_names : Liste des noms de chaque bloc. Doit avoir la même longueur que `block_classes` et `block_trigger_inputs`.

block_trigger_inputs : Liste des noms d'entrées où chaque élément spécifie l'entrée déclencheuse pour le bloc correspondant. Utilisez `None` pour marquer le bloc par défaut.

Un bloc Pipeline qui sélectionne automatiquement un bloc à exécuter en fonction de la présence d'entrées déclencheuses.

Il s’agit d’une version spécialisée de `ConditionalPipelineBlocks` dans laquelle :
- Chaque bloc possède une entrée de déclencheur correspondante (correspondance 1:1)
- La sélection du bloc est automatique : le premier bloc dont l'entrée de déclenchement est présente est sélectionné
- `block_trigger_inputs` doit avoir la même longueur que `block_names` et `block_classes`
- Utilisez `None` dans `block_trigger_inputs` pour spécifier le bloc par défaut, c'est-à-dire le bloc qui s'exécutera si aucun élément déclencheur n'est présent

Exemple :
```python
    class MyAutoBlock(AutoPipelineBlocks):
        block_classes = [InpaintEncoderBlock, ImageEncoderBlock, TextEncoderBlock]
        block_names = ["inpaint", "img2img", "text2img"]
        block_trigger_inputs = ["mask_image", "image", None]  # text2img is the default
```

Avec cette définition :
- Tant que `mask_image` est fourni, le bloc "inpaint" s'exécute (que `image` soit fourni ou non).
- Si `mask_image` n'est pas fourni mais que `image` l'est, le bloc "img2img" s'exécute
- Sinon, le bloc « text2img » s’exécute (par défaut, le déclencheur est `None`)

#### select_block[[diffusers.AutoPipelineBlocks.select_block]]

```python
select_block(**kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1036)

Sélectionner le bloc en fonction de l'entrée de déclencheur présente (non None).

## ConditionalPipelineBlocks[[diffusers.ConditionalPipelineBlocks]]

#### diffusers.ConditionalPipelineBlocks[[diffusers.ConditionalPipelineBlocks]]

```python
diffusers.ConditionalPipelineBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L684)

**Paramètres :**

block_classes : Liste des classes de blocs à utiliser. Doit avoir la même longueur que `block_names`.

block_names : Liste des noms de chaque bloc. Doit avoir la même longueur que `block_classes`.

block_trigger_inputs : Liste des noms d'entrées que `select_block()` utilise pour déterminer quel bloc exécuter. Pour `ConditionalPipelineBlocks`, cela n'a pas besoin de correspondre à `block_names` et `block_classes`. Pour `AutoPipelineBlocks`, cela doit avoir la même longueur que `block_names` et `block_classes`, où chaque élément spécifie l'entrée déclencheuse du bloc correspondant.

default_block_name : Nom du bloc par défaut à exécuter lorsque aucune entrée de déclenchement ne correspond. Si None, ce bloc peut être entièrement ignoré si aucune entrée de déclenchement n'est fournie.

Un bloc Pipeline qui sélectionne conditionnellement un bloc à exécuter en fonction des entrées. Les sous-classes doivent implémenter la méthode `select_block` pour définir la logique de sélection du bloc. Actuellement, nous ne prenons en charge que la logique de sélection basée sur la présence ou l'absence d'entrées (c'est-à-dire si elles sont `None` ou non).

Cette classe hérite de [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les blocs de pipeline (tel que le chargement ou l'enregistrement, etc.)

#### get_execution_blocks[[diffusers.ConditionalPipelineBlocks.get_execution_blocks]]

```python
get_execution_blocks(**kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L874)

**Paramètres :**

- ****kwargs** : Noms et valeurs des entrées. Seules les entrées de déclenchement affectent la sélection des blocs.

**Retourne :** - `ModularPipelineBlocks`

Un bloc feuille ou des `SequentialPipelineBlocks` résolus
- `None` : si ce bloc est ignoré (aucun déclencheur ne correspond et aucun défaut n’est défini)

Obtenir le ou les blocs qui s’exécuteraient étant donné les entrées.

Résout récursivement les ConditionalPipelineBlocks imbriqués jusqu'à atteindre l'un des éléments suivants :
- Un bloc feuille (sans sub_blocks ni LoopSequentialPipelineBlocks) → renvoie un seul `ModularPipelineBlocks`
- Un `SequentialPipelineBlocks` → délègue à son `get_execution_blocks()` qui renvoie
un `SequentialPipelineBlocks` contenant les blocs d'exécution résolus

#### select_block[[diffusers.ConditionalPipelineBlocks.select_block]]

```python
select_block(**kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L830)

**Paramètres :**

- ****kwargs** : Noms des entrées de déclenchement et leurs valeurs issues de l'état.

**Retourne :** `str | None`

Le nom du bloc à exécuter, ou None pour utiliser le bloc par défaut ou passer à l'étape suivante.

Sélectionnez le bloc à exécuter en fonction des entrées de déclenchement. Les sous-classes doivent implémenter cette méthode pour définir la logique de sélection du bloc.

Note : lorsque les entrées de déclenchement incluent des sorties intermédiaires de blocs antérieurs, la logique de sélection ne doit dépendre que de la présence ou de l’absence de l’entrée (c’est-à-dire qu’elle soit None ou non), et non de sa valeur réelle. En effet, `get_execution_blocks()` résout les conditions de manière statique en propageant les noms des sorties intermédiaires sans leurs valeurs d’exécution.