# ComfyUI-FilePathsFromFolder

Load file paths **from a folder by extension** (`*.png`, `*.mp4`, `*.txt`, etc.), then feed them into any ComfyUI node that accepts a path (image/video/audio/anything-from-path).

This repo is mainly for **easy batch processing**:
- Use it with your favorite loop/for/while node pack (pick items by index), or
- Use this repo’s simple loop node (`FilePathsForLoop`) to have ComfyUI run downstream nodes **once per file** (list batching).

## Installation

### Recommended: Git clone

1. Clone into `ComfyUI/custom_nodes`

```bash
cd path/to/ComfyUI/custom_nodes
git clone https://github.com/RockyHong/ComfyUI-FilePathsFromFolder.git
```

2. Restart ComfyUI
3. Search nodes by name: `Load File Paths From Folder`, `Get File Path By Index`, `File Paths For Loop Start`

### Alternative: Manual install (ZIP)

1. Download ZIP from GitHub
2. Extract
3. Copy folder `ComfyUI-FilePathsFromFolder` into `ComfyUI/custom_nodes/`
4. Restart ComfyUI

## Choose how you want to iterate

- **Option A — External loop (index-based): get a file path list + pick one path per iteration** ([jump](#option-a-external-loop))
  - Use `LoadFilePathsFromFolder` → `GetPathByIndex` (UI: `Load File Paths From Folder` → `Get File Path By Index`)
  - Best when you already have a loop/for/while node from another pack, and you just need a clean “files-by-extension” input.

- **Option B — This repo’s loop node: run downstream nodes once per file (list batching)** ([jump](#option-b-internal-loop))
  - Use `FilePathsForLoop` → your processing nodes → (optional) `FilePathsEnsureExecution` → `FilePathsLoopClose`
  - UI: `File Paths For Loop Start` → your processing nodes → (optional) `File Paths Loop Ensure Execution` → `File Paths Loop End`
  - Best when you want a simple, no-extra-deps “loop”: ComfyUI runs downstream nodes once per file via list batching.

<a id="option-a-external-loop"></a>
## Option A — External loop (index-based)

Use this when you already have an external loop/for/while node pack and you want to drive it with “files in a folder” (by extension).

### Nodes used

- `LoadFilePathsFromFolder`: scan folder → get `filepaths` / `filenames` / `count`
- `GetPathByIndex`: choose one item → get `filepath` / `filename` (UI: `Get File Path By Index`)

### Example workflow (external loop pack)

![Option A — External Loop Method](screenshots/Option%20A%20(External%20Loop%20Method).jpg)

1. `LoadFilePathsFromFolder` (set folder path + extension)
2. `count` → your loop node “iterations” / “max” (names vary by pack)
3. Loop `index` → `GetPathByIndex.index`
4. `LoadFilePathsFromFolder.filepaths` + `.filenames` → `GetPathByIndex`
5. `GetPathByIndex.filepath` → your loader node (Load Image / Load Video / etc.)
6. Do your processing + save/export inside your external loop pack

### Node reference

#### `LoadFilePathsFromFolder`
- **Parameters**
  - `folder_path`: folder to scan
  - `extension`: pattern like `"*.png"`, `"*.jpg"`, `"*.txt"`
- **Outputs**
  - `filepaths`: newline-separated full paths
  - `filenames`: newline-separated base names (no extension)
  - `count`: number of matched files

#### `GetPathByIndex`

- **Inputs**
  - `filepaths`: from `LoadFilePathsFromFolder`
  - `filenames`: from `LoadFilePathsFromFolder`
- **Parameter**
  - `index`: 0-based index
- **Outputs**
  - `filepath`: selected full path
  - `filename`: selected base name


<a id="option-b-internal-loop"></a>
## Option B — Internal loop (this repo’s loop node, list batching)

Use this when you want the simplest setup: `FilePathsForLoop` returns lists, and ComfyUI runs downstream nodes **once per file** via list batching. (UI: `File Paths For Loop Start`)

### Nodes used

- `FilePathsForLoop`: generates the per-file list outputs (`current_filepath`, `current_index`, etc.) (UI: `File Paths For Loop Start`)
- (Optional) `FilePathsEnsureExecution`: “anchors” a route so it definitely runs (useful for save/write/export routes) (UI: `File Paths Loop Ensure Execution`)
- `FilePathsLoopClose`: loop terminator / completion signal (UI: `File Paths Loop End`)

### Memory note

`FilePathsForLoop` uses **ComfyUI list batching** (it sets `OUTPUT_IS_LIST`). This is not a “while/for loop” that runs one full item end-to-end.

- **What you may observe**: ComfyUI often runs **node-by-node for the batch**. So a route like `Load X From Path` → `Process` → `Save` can look like “all loads”, then “all processing”, then “all saves” (not Load→Process→Save per file).
- **Why memory can grow**: batching can keep more intermediate results “alive” until later nodes run; heavy nodes (models / large frames / big tensors) can push VRAM/RAM peak usage.
- **Practical tip**: if you notice memory climbing, add “Clean VRAM” / “Clean RAM” (or equivalent) at safe points after heavy steps.
- **If you need strict sequential iteration** (finish item 0 completely before item 1): use an external loop/for/while node pack and Option A.

### Example workflow (internal loop: once per file)

![Option B — Internal Loop Node Method](screenshots/Option%20B%20(Interal%20Loop%20Node%20Method).jpg)

1. `FilePathsForLoop` (set folder path + extension)
2. `current_filepath` → your loader node (e.g. Load Image)
3. Your processing nodes
4. (Optional) outputs you want to **guarantee run** (e.g. save/write/export nodes) → `FilePathsEnsureExecution.passthrough_1` … `passthrough_5`
5. `current_index` → `FilePathsLoopClose.current_index`
6. (Optional) `FilePathsEnsureExecution.passthrough` → `FilePathsLoopClose.passthrough` (this “anchors” the route so it executes)

### Node reference (internal loop nodes)

#### `FilePathsForLoop`

- **Parameters**
  - `folder_path`
  - `extension`
- **Outputs** (**all are lists**)
  - `current_filepath`
  - `current_filename`
  - `current_index` (0-based)
  - `total_file_count`

**Key detail:** this node sets `OUTPUT_IS_LIST`. Downstream nodes receive **one item per execution** (not the whole list).

#### `FilePathsEnsureExecution`

- **What it does**: “collects” outputs so a route becomes **required** (and actually runs).

ComfyUI schedules execution based on **dependencies**: if nothing downstream “needs” a route’s results, ComfyUI may skip that route (or only run part of it).

`FilePathsEnsureExecution` is a simple way to **guarantee a route runs**: plug the outputs you care about into `passthrough_1`…`passthrough_5`, then plug `passthrough` into `FilePathsLoopClose.passthrough` so the graph *depends on* that route.

Practical rule of thumb: you usually only need to connect the **terminal node/output** of the route you want to guarantee (the last node in that route). If the end node must run, everything upstream of it becomes required too.

Example route: `Load Image From Path` → processing → `Save Image` → connect the **`Save Image` output** to `FilePathsEnsureExecution.passthrough_*` to “anchor” the whole chain.
- **Inputs**
  - `passthrough_1` … `passthrough_5`: any type (`*`)
- **Outputs**
  - `passthrough`: first non-None input

Tip: if you need more than 5 inputs, chain multiple `FilePathsEnsureExecution` nodes.

#### `FilePathsLoopClose`

- **Inputs**
  - `current_index`: from `FilePathsForLoop` (required)
  - `passthrough`: optional (often from `FilePathsEnsureExecution.passthrough`)
- **Outputs**
  - `processed_count`

## License

MIT — see `LICENSE`.