# Blocos de pipeline

## ModularPipelineBlocks[[diffusers.ModularPipelineBlocks]]

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

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

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

Classe base para todos os Blocos de Pipeline: ConditionalPipelineBlocks, AutoPipelineBlocks, SequentialPipelineBlocks, LoopSequentialPipelineBlocks

[ModularPipelineBlocks](/docs/diffusers/v0.43.0/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) fornece método para carregar e salvar a definição de blocos de pipeline.

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

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

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

Obtenha todas as entradas e intermediários em um único dicionário

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

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

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

**Parâmetros:**

- ****kwargs** : Nomes e valores de entrada. Somente as entradas de gatilho afetam a seleção de blocos.

Obtém o(s) bloco(s) que seriam executados com base nas entradas. Deve ser implementado por subclasses que suportam seleção condicional de blocos.

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

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

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

**Parâmetros:**

workflow_name : Nome do workflow a ser recuperado.

Obtenha os blocos de execução para um workflow específico. Deve ser implementado por subclasses que definem `_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)
```

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

crie um ModularPipeline, aceitando opcionalmente pretrained_model_name_or_path para carregar do hub.

## SequentialPipelineBlocks[[diffusers.SequentialPipelineBlocks]]

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

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

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

**Parâmetros:**

block_classes : lista de classes de bloco a serem usadas

block_names : lista de prefixos para cada bloco

Um Pipeline Blocks que combina várias classes de bloco de pipeline em uma única. Quando chamado, ele chamará cada bloco em sequência.

Esta classe herda de [ModularPipelineBlocks](/docs/diffusers/v0.43.0/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os blocos de pipeline (como carregamento ou salvamento, etc.)

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

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

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

**Parâmetros:**

blocks_dict : Dicionário que mapeia nomes de blocos para classes ou instâncias de blocos

**Retorna:**

Uma nova instância de SequentialPipelineBlocks

Cria uma instância de SequentialPipelineBlocks a partir de um dicionário de blocos.

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

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

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

**Parâmetros:**

- ****kwargs** : Nomes e valores de entrada. Somente as entradas de gatilho afetam a seleção de blocos.

**Retorna:**

SequentialPipelineBlocks contendo apenas os blocos que seriam executados

Obtenha os blocos que seriam executados com as entradas especificadas.

À medida que a varredura percorre os blocos sequenciais, as saídas intermediárias dos blocos resolvidos são adicionadas às entradas ativas. Isso significa que blocos condicionais que dependem de intermediários (por exemplo, "executar img2img se image_latents estiver presente") serão resolvidos corretamente, desde que a condição seja baseada na presença/ausência (None ou não None), e não no valor real.

## LoopSequentialPipelineBlocks[[diffusers.LoopSequentialPipelineBlocks]]

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

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

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

**Parâmetros:**

block_classes : lista de classes de bloco a serem usadas

block_names : lista de prefixos para cada bloco

Um bloco Pipeline que combina várias classes de bloco de pipeline em um For Loop. Quando chamado, ele chamará cada bloco em sequência.

Esta classe herda de [ModularPipelineBlocks](/docs/diffusers/v0.43.0/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os blocos de pipeline (como carregamento ou salvamento, etc.)

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

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

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

**Parâmetros:**

blocks_dict : Dicionário que mapeia nomes de blocos para instâncias de blocos

**Retorna:**

Uma nova instância de LoopSequentialPipelineBlocks

Cria uma instância de LoopSequentialPipelineBlocks a partir de um dicionário de blocos.

## AutoPipelineBlocks[[diffusers.AutoPipelineBlocks]]

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

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

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

**Parâmetros:**

block_classes : Lista de classes de bloco a serem usadas. Deve ter o mesmo comprimento que `block_names` e `block_trigger_inputs`.

block_names : Lista de nomes para cada bloco. Deve ter o mesmo comprimento que `block_classes` e `block_trigger_inputs`.

block_trigger_inputs : Lista de nomes de entrada em que cada elemento especifica a entrada de gatilho para o bloco correspondente. Use `None` para marcar o bloco padrão.

Blocos de Pipeline que selecionam automaticamente um bloco para executar com base na presença de entradas de gatilho.

Esta é uma versão especializada de `ConditionalPipelineBlocks` em que:
- Cada bloco possui uma entrada de gatilho correspondente (mapeamento 1:1)
- A seleção de bloco é automática: o primeiro bloco cuja entrada de gatilho está presente é selecionado
- `block_trigger_inputs` deve ter o mesmo comprimento que `block_names` e `block_classes`
- Use `None` em `block_trigger_inputs` para especificar o bloco padrão, ou seja, o bloco que será executado se não houver entradas de gatilho

Exemplo:
```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
```

Com essa definição:
- Desde que `mask_image` seja fornecido, o bloco "inpaint" é executado (independentemente de `image` ser fornecido ou não)
- Se `mask_image` não for fornecido, mas `image` for fornecido, o bloco "img2img" será executado
- Caso contrário, o bloco "text2img" é executado (padrão, o gatilho é `None`)

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

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

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

Selecione o bloco com base em qual entrada de gatilho está presente (não é None).

## ConditionalPipelineBlocks[[diffusers.ConditionalPipelineBlocks]]

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

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

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

**Parâmetros:**

block_classes : Lista de classes de bloco a serem usadas. Deve ter o mesmo comprimento que `block_names`.

block_names : Lista de nomes para cada bloco. Deve ter o mesmo comprimento que `block_classes`.

block_trigger_inputs : Lista de nomes de entrada que `select_block()` usa para determinar qual bloco executar. Para `ConditionalPipelineBlocks`, isso não precisa corresponder a `block_names` e `block_classes`. Para `AutoPipelineBlocks`, isso deve ter o mesmo comprimento que `block_names` e `block_classes`, onde cada elemento especifica a entrada de gatilho para o bloco correspondente.

default_block_name : Nome do bloco padrão a ser executado quando nenhuma entrada de gatilho corresponde. Se for None, este bloco pode ser totalmente ignorado quando nenhuma entrada de gatilho for fornecida.

Um Pipeline Blocks que seleciona condicionalmente um bloco para execução com base nas entradas. As subclasses devem implementar o método `select_block` para definir a lógica de seleção do bloco. Atualmente, suportamos apenas lógica de seleção baseada na presença ou ausência de entradas (ou seja, se são `None` ou não).

Esta classe herda de [ModularPipelineBlocks](/docs/diffusers/v0.43.0/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os blocos de pipeline (como carregamento ou salvamento, etc.)

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

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

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

**Parâmetros:**

- ****kwargs** : Nomes e valores de entrada. Somente as entradas de gatilho afetam a seleção de blocos.

**Retorna:** - `ModularPipelineBlocks`

Um bloco folha ou `SequentialPipelineBlocks` resolvido
- `None`: Se esse bloco fosse ignorado (nenhum gatilho correspondente e nenhum padrão)

Obtenha o(s) bloco(s) que seriam executados com as entradas fornecidas.

Resolve recursivamente blocos aninhados de ConditionalPipelineBlocks até atingir:
- Um bloco folha (sem sub_blocks ou LoopSequentialPipelineBlocks) → retorna um único `ModularPipelineBlocks`
- A `SequentialPipelineBlocks` → delega para o seu `get_execution_blocks()`, que retorna
a `SequentialPipelineBlocks` contendo os blocos de execução resolvidos

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

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

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

**Parâmetros:**

- ****kwargs** : Nomes e valores de entrada do gatilho a partir do estado.

**Retorna:** `str | None`

O nome do bloco a ser executado, ou None para usar o padrão/pular.

Selecione o bloco a ser executado com base nas entradas do gatilho. As subclasses devem implementar este método para definir a lógica de seleção do bloco.

Nota: Quando as entradas de gatilho incluem saídas intermediárias de blocos anteriores, a lógica de seleção deve depender apenas da presença ou ausência da entrada (ou seja, se ela é None ou não), e não do seu valor real. Isso ocorre porque `get_execution_blocks()` resolve as condições estaticamente, propagando os nomes das saídas intermediárias sem seus valores em tempo de execução.