# 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

<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`)

### 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)

### 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.

## License

MIT — see `LICENSE`.