From bdac962a02144d61b819378e973ad8d62d747034 Mon Sep 17 00:00:00 2001
From: Chris Judd <85649796+juddisjudd@users.noreply.github.com>
Date: Sat, 2 Aug 2025 00:01:44 -0700
Subject: [PATCH] refactor/feat: modular rewrite w/ more nodes
---
README.md | 432 +++++++++++++++-------
__init__.py | 32 +-
nodes.py | 347 +----------------
nodes/__init__.py | 18 +
nodes/bawk_sampler.py | 337 +++++++++++++++++
nodes/diffusion_model_loader.py | 156 ++++++++
nodes/flux_image_saver.py | 203 ++++++++++
nodes/flux_prompt_saver.py | 91 +++++
nodes/flux_wildcard_encode.py | 240 ++++++++++++
previews/efficient-workflow-preview.png | Bin 0 -> 635748 bytes
pyproject.toml | 6 +-
utils/flexible_inputs.py | 60 +++
web/extensions/__init__.py | 0
web/extensions/flux_wildcard_encoder.js | 377 +++++++++++++++++++
workflows/example_bawknodes_workflow.json | 343 +++++++++++++++++
workflows/example_flux_workflow.json.json | 320 ----------------
16 files changed, 2163 insertions(+), 799 deletions(-)
create mode 100644 nodes/__init__.py
create mode 100644 nodes/bawk_sampler.py
create mode 100644 nodes/diffusion_model_loader.py
create mode 100644 nodes/flux_image_saver.py
create mode 100644 nodes/flux_prompt_saver.py
create mode 100644 nodes/flux_wildcard_encode.py
create mode 100644 previews/efficient-workflow-preview.png
create mode 100644 utils/flexible_inputs.py
create mode 100644 web/extensions/__init__.py
create mode 100644 web/extensions/flux_wildcard_encoder.js
create mode 100644 workflows/example_bawknodes_workflow.json
delete mode 100644 workflows/example_flux_workflow.json.json
diff --git a/README.md b/README.md
index be10a46..fe69371 100644
--- a/README.md
+++ b/README.md
@@ -1,165 +1,331 @@
-# 🐓 ComfyUI Bawk Nodes
+
+
🐓 ComfyUI Bawk Nodes v2.0.0
-A collection of ComfyUI nodes **focused primarily on FLUX model workflows**. While some nodes may work with other diffusion models, all development and testing is done specifically with FLUX architectures to ensure optimal performance and compatibility.
+**A collection of FLUX-optimized ComfyUI nodes for efficient AI image generation.**
-## ⚡ FLUX-First Design Philosophy
+
-Our nodes are built with FLUX models as the primary target:
-- **Optimized for FLUX**: All nodes designed around FLUX model architecture
-- **FLUX-Tested**: Extensive testing with FLUX Dev, FLUX Schnell, and FLUX variants
-- **Other Models**: May work with SDXL/SD1.5 but **not officially supported or tested**
+
-> **Note**: While these nodes might function with other diffusion models, we only guarantee compatibility and provide support for FLUX models. Use with other models at your own discretion.
+---
-## Current Nodes
+## 🎯 **What's New in v2.0.0**
-### 🚀 Diffusion Model Loader (Advanced)
-A powerful diffusion model loader specifically optimized for FLUX models with separate component loading.
+**Major Rewrite**: Complete FLUX-first redesign with modular architecture and workflow consolidation.
-**FLUX-Optimized Features:**
-- **FLUX Model Support**: Loads models from `diffusion_models` directory (FLUX format)
-- **Separate Component Loading**: Independent VAE and dual CLIP text encoder support
-- **FLUX Weight Types**: Support for FP8, FP16, BF16, and FP32 optimized for FLUX
-- **FLUX CLIP Types**: Proper `CLIPType.FLUX` handling for T5 + CLIP-L encoders
-- **Model String Output**: Returns clean model name for workflow identification
-- **FLUX Validation**: Input validation designed around FLUX model requirements
+- 🎲 **Enhanced Wildcard Encoder** with 6 LoRA slots
+- 🐓 **All-in-One BawkSampler** with integrated VAE decoding
+- 📁 **Modular Architecture** for better maintainability
+- ⚡ **Streamlined Workflows** - fewer nodes, more power
+- 💾 **Enhanced Image Saver** with prompt saving
-## 📦 Installation
+---
+
+## 🚀 **Node Collection Overview**
+
+| Node | Description | Category |
+|------|-------------|----------|
+| 🚀 **Diffusion Model Loader** | Advanced FLUX-optimized model loading | Loaders |
+| 🎲 **FLUX Wildcard Encoder** | Text encoding + 6 LoRA slots + wildcards | Conditioning |
+| 🐓 **Bawk Sampler** | All-in-one latent generation, sampling & VAE decode | Sampling |
+| 💾 **FLUX Image Saver** | Organized saving with metadata & prompt files | Image |
+| 📝 **FLUX Prompt Saver** | Standalone prompt archiving | Text |
+
+---
+
+## 🔥 **Complete FLUX Workflow**
+
+**Before BawkNodes (5+ nodes):**
+```
+CheckpointLoader → LoraLoader → CLIPTextEncode → EmptyLatent → KSampler → VAEDecode → SaveImage
+```
+
+**After BawkNodes (3 nodes):**
+```
+🚀 DiffusionModelLoader → 🎲 FluxWildcardEncode → 🐓 BawkSampler → 💾 FluxImageSaver
+```
+
+**60% fewer nodes, 100% of the power!**
+
+---
+
+## 📦 **Installation**
### Method 1: ComfyUI Manager (Recommended)
1. Open ComfyUI Manager
-2. Search for "Bawk Nodes" or "ComfyUI-BawkNodes"
+2. Search for "Bawk Nodes"
3. Click Install
+4. Restart ComfyUI
### Method 2: Manual Installation
-1. Navigate to your ComfyUI custom nodes directory:
- ```bash
- cd ComfyUI/custom_nodes/
- ```
-
-2. Clone this repository:
- ```bash
- git clone https://github.com/juddisjudd/ComfyUI-BawkNodes.git
- ```
-
-3. Restart ComfyUI
-
-## 🎯 Usage
-
-### Diffusion Model Loader (Advanced)
-1. Add the "🚀 Diffusion Model Loader (Advanced)" node to your workflow
-2. Select your diffusion model from the dropdown
-3. Choose your VAE (or use "baked VAE" for none)
-4. Select your text encoders (CLIP models)
-5. Choose your preferred weight data type
-6. Connect the outputs to your workflow
-
-### Advanced Configuration
-
-#### Weight Data Types
-- **default**: Automatic selection based on hardware
-- **fp8_e4m3fn**: 8-bit floating point (requires modern GPUs)
-- **fp8_e4m3fn_fast**: Optimized 8-bit variant
-- **fp8_e5m2**: Alternative 8-bit format
-- **fp16**: 16-bit floating point (most common)
-- **bf16**: Brain floating point 16-bit
-- **fp32**: Full precision 32-bit
-
-#### Separate VAE Loading
-- Select "baked VAE" to use the VAE included in your model
-- Choose a specific VAE file to override the model's VAE
-
-#### Dual Text Encoders (FLUX Models)
-- **clip_name1**: First text encoder (typically T5 for FLUX)
-- **clip_name2**: Second text encoder (typically CLIP-L for FLUX)
-
-## 🔧 Node Inputs
-
-| Input | Type | Default | Description |
-|-------|------|---------|-------------|
-| `model_name` | STRING | - | Checkpoint file name (required) |
-| `weight_dtype` | COMBO | "default" | Weight data type |
-| `vae_name` | COMBO | "baked VAE" | VAE model (optional) |
-| `clip_name1` | COMBO | "none" | First text encoder (optional) |
-| `clip_name2` | COMBO | "none" | Second text encoder (optional) |
-
-## 📤 Node Outputs
-
-| Output | Type | Description |
-|--------|------|-------------|
-| `MODEL` | MODEL | Loaded diffusion model |
-| `VAE` | VAE | Variational autoencoder |
-| `CLIP` | CLIP | Text encoder(s) |
-| `MODEL_STRING` | STRING | Model information summary |
-
-
-## 🔮 Planned Nodes (FLUX-Focused)
-
-***TBD***
-*All future nodes will maintain our FLUX-first design philosophy*
-
-## Example Workflows
-
-### Basic FLUX Workflow
-```
-Diffusion Model Loader (Advanced)
-├── model_name: "flux1-dev.safetensors"
-├── weight_dtype: "fp8_e4m3fn"
-├── vae_name: "ae.safetensors"
-├── clip_name1: "t5xxl_fp16.safetensors"
-└── clip_name2: "clip_l.safetensors"
+```bash
+cd ComfyUI/custom_nodes
+git clone https://github.com/juddisjudd/ComfyUI-BawkNodes.git
+# Restart ComfyUI
```
-## ⚡ FLUX Performance Tips
+---
-1. **Hardware Optimization**:
- - Use FP8 data types on RTX 4000+ series GPUs for maximum VRAM efficiency
- - FLUX models benefit significantly from modern GPU architectures
- - Ensure adequate VRAM (12GB+ recommended for FLUX Dev)
+## 🎲 **Node Details**
-2. **FLUX-Specific Settings**:
- - Use `fp8_e4m3fn` for best quality/memory balance
- - Use `fp8_e4m3fn_fast` for maximum speed
- - T5 + CLIP-L combination provides optimal text understanding
+### 🚀 **Diffusion Model Loader (Advanced)**
-3. **Model Organization**:
- - Keep FLUX models in `ComfyUI/models/diffusion_models/`
- - Use `ae.safetensors` VAE for all FLUX variants
- - Separate text encoders allow better memory management
+**FLUX-optimized model loading with advanced features.**
-## Troubleshooting
+**Features:**
+- Multiple model formats (FLUX, SDXL, SD1.5)
+- Flexible weight data types (fp8, fp16, bf16, fp32)
+- Separate VAE and CLIP loading
+- Multiple directory support
-### FLUX-Specific Issues
+**Inputs:**
+- `model_name` - Model from diffusion_models folder
+- `vae_name` - VAE or "baked VAE"
+- `clip_name1/2` - CLIP models for FLUX
+- `weight_dtype` - Precision optimization
-**"Model not found"**
-- Ensure FLUX models are in `ComfyUI/models/diffusion_models/` (NOT checkpoints!)
-- VAE files go in `ComfyUI/models/vae/`
-- Text encoders go in `ComfyUI/models/text_encoders/` or `ComfyUI/models/clip/`
+**Outputs:** `MODEL`, `VAE`, `CLIP`, `MODEL_STRING`
-**Matrix multiplication errors with FLUX samplers**
-- This usually means a checkpoint was loaded instead of a diffusion model
-- Ensure your FLUX model is in `diffusion_models` directory
-- Our loader is specifically designed to prevent this issue
+---
-**"Insufficient VRAM" with FLUX**
-- Try `fp8_e4m3fn` or `fp8_e4m3fn_fast` weight types
-- FLUX models are large - consider using smaller variants for lower VRAM
-- Ensure no other models are loaded in memory
+### 🎲 **FLUX Wildcard Encoder**
-**Empty dropdowns**
-- The node only shows files that actually exist in the correct directories
-- Check that your FLUX files are in the proper locations
-- This loader ONLY shows diffusion models (FLUX format)
+**Enhanced text encoder with 6 LoRA slots and wildcard support.**
-**Not compatible with other models**
-- Remember: These nodes are designed specifically for FLUX
-- Other diffusion models may not work correctly
-- Use standard ComfyUI loaders for non-FLUX models
+**Features:**
+- **Wildcard Processing**: `{option1|option2|option3}` syntax
+- **6 LoRA Slots**: Individual enable/disable toggles
+- **Fuzzy LoRA Matching**: Flexible file resolution
+- **FLUX Optimization**: 16-channel conditioning
+**Inputs:**
+- `model`, `clip` - From model loader
+- `prompt` - Text with wildcard support
+- `wildcard_seed` - Seed for consistent wildcard selection
+- `lora_X_on` - Enable/disable each LoRA (X = 1-6)
+- `lora_X_name` - LoRA selection dropdown
+- `lora_X_strength` - Strength adjustment (-10.0 to +10.0)
-## Support
+**Outputs:** `MODEL`, `CLIP`, `CONDITIONING`, `PROMPT_OUT`
-- **Issues**: [GitHub Issues](https://github.com/juddisjudd/ComfyUI-BawkNodes/issues)
+**Example Prompt with Wildcards:**
+```
+A {beautiful|stunning|gorgeous} {cat|dog|bird} in a {forest|garden|meadow},
+{photorealistic|artistic|stylized} style
+```
+
+---
+
+### 🐓 **Bawk Sampler (All-in-One)**
+
+**Complete latent generation, sampling, and VAE decoding in one node.**
+
+**Features:**
+- **Smart Resolution Presets**: Pre-configured FLUX-optimized resolutions
+- **Custom Resolution Support**: Manual width/height with 64px alignment
+- **Advanced FLUX Sampling**: All FLUX-specific parameters
+- **Integrated VAE Decoding**: Direct image output
+- **Batch Generation**: Up to 64 images at once
+
+**Key Inputs:**
+- `model`, `conditioning`, `vae` - From previous nodes
+- `resolution` - Smart presets or custom
+- `batch_size` - Number of images (default: 4)
+- `sampler` - Sampling method (default: euler)
+- `scheduler` - Noise schedule (default: beta)
+- `steps` - Sampling steps (default: 30)
+- `guidance` - FLUX guidance scale (default: 3.5)
+- `max_shift` - FLUX max shift (default: 0.5)
+- `base_shift` - FLUX base shift (default: 0.3)
+
+**Resolution Presets:**
+- `FHD 16:9 - 1920x1080` (default)
+- `Medium Square - 1024x1024`
+- `Portrait 9:16 - 1080x1920`
+- `Ultra-wide - 1792x768`
+- And many more...
+
+**Outputs:** `IMAGE`, `LATENT`
+
+---
+
+### 💾 **FLUX Image Saver**
+
+**Organized image saving with metadata and prompt archiving.**
+
+**Features:**
+- **Smart Folder Organization**: `[MODEL]-DD-MM-YYYY` structure
+- **Multiple Formats**: PNG, JPG, WebP support
+- **Metadata Embedding**: PNG metadata support
+- **Prompt File Saving**: Separate `.txt` files with processed prompts
+- **JSON Metadata**: Complete generation parameters
+
+**Inputs:**
+- `images` - From BawkSampler
+- `model_string` - From model loader
+- `processed_prompt` - From wildcard encoder
+- `save_prompt` - Enable prompt file saving (default: True)
+- `format` - Image format (PNG/JPG/WebP)
+- `quality` - Compression quality (1-100)
+
+**File Output Example:**
+```
+ComfyUI/output/[FLUX_Model]-01-08-2025/
+├── flux_image_01-08-2025_14-30-15_001.png
+├── flux_image_01-08-2025_14-30-15_002.png
+├── flux_image_01-08-2025_14-30-15_prompt.txt
+├── flux_image_01-08-2025_14-30-15_001_metadata.json
+└── flux_image_01-08-2025_14-30-15_002_metadata.json
+```
+
+---
+
+### 📝 **FLUX Prompt Saver**
+
+**Standalone prompt and parameter archiving.**
+
+**Features:**
+- **JSON Format**: Structured data storage
+- **Complete Parameters**: All generation settings
+- **Organized Storage**: Matches image saver folder structure
+- **Workflow Integration**: Links with other BawkNodes
+
+---
+
+## 🛠️ **Advanced Usage**
+
+### **Wildcard Examples**
+
+**Basic Wildcards:**
+```
+A {red|blue|green} car in the {city|countryside}
+```
+
+**Nested Concepts:**
+```
+{A majestic|An elegant|A powerful} {dragon|phoenix|griffin}
+{soaring through|perched upon|emerging from} {clouds|mountains|flames}
+```
+
+**Style Variations:**
+```
+Portrait of a woman, {photorealistic|oil painting|digital art|watercolor} style,
+{studio lighting|natural lighting|dramatic lighting}
+```
+
+### **LoRA Management**
+
+**Best Practices:**
+1. **Enable LoRAs individually** for precise control
+2. **Use strength between 0.5-1.5** for most LoRAs
+3. **Combine complementary LoRAs** (style + subject)
+4. **Test different combinations** for unique results
+
+**Example LoRA Setup:**
+- LoRA 1: `realistic_skin_v2.safetensors` (0.8)
+- LoRA 2: `dramatic_lighting.safetensors` (0.6)
+- LoRA 3: `detail_enhancer.safetensors` (0.4)
+
+### **Resolution Guidelines**
+
+**Recommended Presets:**
+- **Square**: `Medium Square - 1024x1024`
+- **Landscape**: `FHD 16:9 - 1920x1080`
+- **Portrait**: `Portrait 9:16 - 1080x1920`
+- **Widescreen**: `Ultra-wide - 1792x768`
+
+**Custom Resolution Rules:**
+- Must be multiples of 64 pixels
+- Keep total pixel count reasonable (<4MP for speed)
+- Consider VRAM limitations for large batches
+
+---
+
+## 🔧 **Configuration**
+
+### **Model Setup**
+
+1. **FLUX Models**: Place in `models/diffusion_models/`
+2. **VAE Files**: Place in `models/vae/`
+3. **CLIP Models**: Place in `models/text_encoders/`
+4. **LoRA Files**: Place in `models/loras/`
+
+### **Recommended Settings**
+
+**For Speed:**
+- Resolution: `Medium Square - 1024x1024`
+- Batch Size: `4`
+- Steps: `20-25`
+- Sampler: `euler`
+
+**For Quality:**
+- Resolution: `FHD 16:9 - 1920x1080`
+- Batch Size: `1-2`
+- Steps: `30-40`
+- Sampler: `dpmpp_2m`
+
+**For Experimentation:**
+- Use wildcards with high variation
+- Enable multiple LoRAs
+- Try different guidance scales (2.0-5.0)
+
+---
+
+## **Troubleshooting**
+
+### **Common Issues**
+
+**Node Not Appearing:**
+```bash
+# Check ComfyUI console for errors
+# Ensure all files are in correct directories
+# Restart ComfyUI completely
+```
+
+**LoRA Not Loading:**
+- Check file is in `models/loras/`
+- Verify file isn't corrupted
+- Check console for specific error messages
+
+**Memory Issues:**
+- Reduce batch size
+- Use lower resolution
+- Enable `fp8` weight dtype in loader
+
+**Generation Errors:**
+- Verify all connections are correct
+- Check that VAE is connected to BawkSampler
+- Ensure CLIP and MODEL are from same loader
+
+### **Performance Optimization**
+
+**VRAM Usage:**
+- Use `fp8_e4m3fn_fast` for weight dtype
+- Reduce batch size for large images
+- Close other GPU applications
+
+**Speed Improvements:**
+- Use `euler` sampler with `beta` scheduler
+- Reduce step count (20-30 is often sufficient)
+- Use medium resolution presets
+
+---
+
+## 📄 **License**
+
+GPL-3.0 license - see [LICENSE](LICENSE) file for details.
+
+---
+
+## 🙏 **Acknowledgments**
+- **[rgthree](https://github.com/rgthree/rgthree-comfy)** - Inspiration for dynamic UI patterns
+
+---
+
+## 🔗 **Links**
+
+- **Comfy Registry**: [Comfy-Registry](https://registry.comfy.org/publishers/judd/nodes/comfyui-bawknodes)
+- **Issues**: [Report Bugs](https://github.com/juddisjudd/ComfyUI-BawkNodes/issues)
---
diff --git a/__init__.py b/__init__.py
index b32e2d6..40021bb 100644
--- a/__init__.py
+++ b/__init__.py
@@ -3,29 +3,43 @@ ComfyUI Bawk Nodes - Node Registration
File: __init__.py
"""
-from .nodes import DiffusionModelLoader
+from .nodes import (
+ DiffusionModelLoader,
+ FluxImageSaver,
+ FluxPromptSaver,
+ FluxWildcardEncode,
+ BawkSampler
+)
-# Node class mappings for ComfyUI discovery
NODE_CLASS_MAPPINGS = {
"DiffusionModelLoader": DiffusionModelLoader,
+ "FluxImageSaver": FluxImageSaver,
+ "FluxPromptSaver": FluxPromptSaver,
+ "FluxWildcardEncode": FluxWildcardEncode,
+ "BawkSampler": BawkSampler,
}
-# Display names in the ComfyUI interface
NODE_DISPLAY_NAME_MAPPINGS = {
"DiffusionModelLoader": "🚀 Diffusion Model Loader (Advanced)",
+ "FluxImageSaver": "💾 FLUX Image Saver",
+ "FluxPromptSaver": "📝 FLUX Prompt Saver",
+ "FluxWildcardEncode": "🎲 FLUX Wildcard Encoder",
+ "BawkSampler": "🐓 Bawk Sampler (All-in-One)",
}
-# Export for ComfyUI
__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']
-# Package metadata
-__version__ = "1.0.0"
+__version__ = "2.0.0"
__author__ = "Bawk Nodes"
-__description__ = "A collection of useful ComfyUI nodes for enhanced workflows"
+__description__ = "A complete collection of FLUX-optimized ComfyUI nodes for enhanced workflows"
-# Optional: Print loading message
print(f"🐓 ComfyUI Bawk Nodes v{__version__} loaded successfully!")
+print(" 🎉 Major Update - Complete FLUX Workflow Suite!")
print(" Current nodes:")
print(" • 🚀 Diffusion Model Loader (Advanced) - FLUX-optimized model loading")
-print(" • More nodes coming soon...")
+print(" • 🎲 FLUX Wildcard Encoder - Text encoding with wildcard support and 6 LoRA slots")
+print(" • 💾 FLUX Image Saver - Organized image saving with metadata")
+print(" • 📝 FLUX Prompt Saver - Save prompts and generation parameters")
+print(" • 🐓 Bawk Sampler (All-in-One) - Combined latent optimizer and sampler")
+print(" 📦 Modular architecture for easy maintenance and debugging")
print(" Visit: https://github.com/juddisjudd/ComfyUI-BawkNodes")
\ No newline at end of file
diff --git a/nodes.py b/nodes.py
index 8e792f5..123351e 100644
--- a/nodes.py
+++ b/nodes.py
@@ -1,339 +1,18 @@
"""
-ComfyUI Bawk Nodes - Diffusion Model Loader
+ComfyUI Bawk Nodes - Main nodes file (clean imports only)
File: nodes.py
"""
-import os
-import torch
-import comfy.sd
-import comfy.model_management as mm
-import comfy.utils
-import folder_paths
-from typing import Optional, Tuple, Dict, Any, Union
-from .modules.validation import ValidationMixin
+from .nodes.diffusion_model_loader import DiffusionModelLoader
+from .nodes.flux_wildcard_encode import FluxWildcardEncode
+from .nodes.flux_image_saver import FluxImageSaver
+from .nodes.flux_prompt_saver import FluxPromptSaver
+from .nodes.bawk_sampler import BawkSampler
-
-class DiffusionModelLoader(ValidationMixin):
- """
- Advanced Diffusion Model Loader with support for:
- - Multiple model formats (FLUX, SDXL, SD1.5)
- - Flexible weight data types (fp8, fp16, bf16, fp32)
- - Separate VAE and CLIP loading
- - Multiple directory support
- """
-
- @classmethod
- def INPUT_TYPES(cls):
- # Match the exact format of the working DoomFluxLoader
- return {
- "required": {
- "model_name": (folder_paths.get_filename_list("diffusion_models"),),
- "vae_name": (folder_paths.get_filename_list("vae") + ["baked VAE"],),
- "clip_name1": (folder_paths.get_filename_list("text_encoders") + ["none"],),
- "clip_name2": (folder_paths.get_filename_list("text_encoders") + ["none"],),
- "weight_dtype": (["default", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e5m2"],),
- }
- }
-
- RETURN_TYPES = ("MODEL", "VAE", "CLIP", "STRING")
- RETURN_NAMES = ("MODEL", "VAE", "CLIP", "MODEL_STRING")
- FUNCTION = "load_diffusion_model"
- CATEGORY = "BawkNodes/loaders"
- DESCRIPTION = "Advanced diffusion model loader for FLUX and other modern architectures"
-
- @classmethod
- def VALIDATE_INPUTS(cls, **kwargs):
- """Simple validation matching the working loader pattern"""
- errors = []
-
- # Validate model exists in diffusion_models directory
- model_name = kwargs.get("model_name")
- if model_name:
- try:
- folder_paths.get_full_path_or_raise("diffusion_models", model_name)
- except:
- errors.append(f"Model '{model_name}' not found in diffusion_models directory")
-
- # Validate VAE if specified
- vae_name = kwargs.get("vae_name", "baked VAE")
- if vae_name and vae_name != "baked VAE":
- try:
- folder_paths.get_full_path_or_raise("vae", vae_name)
- except:
- errors.append(f"VAE '{vae_name}' not found in vae directory")
-
- # Validate CLIP models if specified
- clip1 = kwargs.get("clip_name1", "none")
- if clip1 and clip1 != "none":
- try:
- folder_paths.get_full_path_or_raise("text_encoders", clip1)
- except:
- errors.append(f"CLIP model '{clip1}' not found in text_encoders directory")
-
- clip2 = kwargs.get("clip_name2", "none")
- if clip2 and clip2 != "none":
- try:
- folder_paths.get_full_path_or_raise("text_encoders", clip2)
- except:
- errors.append(f"CLIP model '{clip2}' not found in text_encoders directory")
-
- return "; ".join(errors) if errors else True
-
- def load_diffusion_model(
- self,
- model_name: str,
- weight_dtype: str = "default",
- vae_name: str = "baked VAE",
- clip_name1: str = "none",
- clip_name2: str = "none"
- ) -> Tuple[Any, Any, Any, str]:
- """
- Main loading function for diffusion models (based on working DoomFluxLoader)
- """
- try:
- # Handle "none" and "baked VAE" values like the working loader
- vae_name = vae_name if vae_name and vae_name != "baked VAE" else None
- clip_name1 = clip_name1 if clip_name1 and clip_name1 != "none" else None
- clip_name2 = clip_name2 if clip_name2 and clip_name2 != "none" else None
- weight_dtype = weight_dtype if weight_dtype else "default"
-
- # Set up model options based on weight_dtype (like DoomFluxLoader)
- model_options = {}
- if weight_dtype == "fp8_e4m3fn":
- model_options["dtype"] = torch.float8_e4m3fn
- elif weight_dtype == "fp8_e4m3fn_fast":
- model_options["dtype"] = torch.float8_e4m3fn
- model_options["fp8_optimizations"] = True
- elif weight_dtype == "fp8_e5m2":
- model_options["dtype"] = torch.float8_e5m2
-
- # Load diffusion model using the exact same method as DoomFluxLoader
- print(f"[DiffusionModelLoader] Loading diffusion model: {model_name}")
- model_path = folder_paths.get_full_path_or_raise("diffusion_models", model_name)
- model = comfy.sd.load_diffusion_model(model_path, model_options=model_options)
-
- if model is None:
- raise RuntimeError("Failed to load diffusion model - output was None")
-
- # Load VAE (exactly like DoomFluxLoader)
- vae = None
- if vae_name:
- print(f"[DiffusionModelLoader] Loading VAE: {vae_name}")
- vae_path = folder_paths.get_full_path_or_raise("vae", vae_name)
- vae_sd = comfy.utils.load_torch_file(vae_path)
- vae = comfy.sd.VAE(sd=vae_sd)
-
- # Load CLIP models (exactly like DoomFluxLoader)
- clip_paths = []
- if clip_name1:
- clip_paths.append(folder_paths.get_full_path_or_raise("text_encoders", clip_name1))
- if clip_name2:
- clip_paths.append(folder_paths.get_full_path_or_raise("text_encoders", clip_name2))
-
- clip = None
- if clip_paths:
- print(f"[DiffusionModelLoader] Loading CLIP models")
- clip = comfy.sd.load_clip(
- ckpt_paths=clip_paths,
- embedding_directory=folder_paths.get_folder_paths("embeddings"),
- clip_type=comfy.sd.CLIPType.FLUX
- )
-
- # Generate simple model name string
- model_string = os.path.splitext(model_name)[0]
-
- print(f"[DiffusionModelLoader] Successfully loaded diffusion model: {model_string}")
- return (model, vae, clip, model_string)
-
- except Exception as e:
- error_msg = f"Failed to load diffusion model '{model_name}': {str(e)}"
- print(f"[DiffusionModelLoader] Error: {error_msg}")
- raise RuntimeError(error_msg)
-
- def _create_cache_key(self, model_name: str, weight_dtype: str, vae_name: str,
- clip_name1: str, clip_name2: str) -> str:
- """Create unique cache key for this configuration"""
- return f"{model_name}|{weight_dtype}|{vae_name}|{clip_name1}|{clip_name2}"
-
- def _validate_model_path(self, model_name: str) -> str:
- """Validate model exists and is accessible, checking multiple directories"""
- model_path = None
-
- # Try checkpoints directory first
- model_path = folder_paths.get_full_path("checkpoints", model_name)
-
- # If not found, try diffusion_models directory
- if model_path is None:
- model_path = folder_paths.get_full_path("diffusion_models", model_name)
-
- if model_path is None:
- raise FileNotFoundError(f"Model not found in checkpoints or diffusion_models directories: {model_name}")
-
- if not os.path.exists(model_path):
- raise FileNotFoundError(f"Model file does not exist: {model_path}")
-
- # Basic file size validation
- file_size = os.path.getsize(model_path)
- if file_size < 1024 * 1024: # Less than 1MB
- raise ValueError(f"Model file appears corrupted (too small): {model_path}")
-
- return model_path
-
- def _select_dtype(self, weight_dtype: str, device: torch.device) -> torch.dtype:
- """Select appropriate data type based on user preference and hardware"""
- if weight_dtype == "default":
- return self._auto_select_dtype(device)
-
- dtype_map = {
- "fp32": torch.float32,
- "fp16": torch.float16,
- "bf16": torch.bfloat16,
- }
-
- # Handle FP8 types if supported
- if weight_dtype.startswith("fp8_"):
- if self._supports_fp8(device):
- if weight_dtype == "fp8_e4m3fn":
- return torch.float8_e4m3fn
- elif weight_dtype == "fp8_e5m2":
- return torch.float8_e5m2
- else:
- print(f"FP8 not supported on device {device}, falling back to fp16")
- return torch.float16
-
- selected_dtype = dtype_map.get(weight_dtype, torch.float32)
-
- # Validate dtype compatibility
- if not self.validate_dtype_compatibility(weight_dtype, device):
- print(f"Dtype {weight_dtype} not compatible with {device}, using auto selection")
- return self._auto_select_dtype(device)
-
- return selected_dtype
-
- def _auto_select_dtype(self, device: torch.device) -> torch.dtype:
- """Automatically select best dtype for device"""
- if self._supports_fp8(device):
- free_memory = mm.get_free_memory(device)
- if free_memory < 6 * 1024**3: # Less than 6GB VRAM
- return torch.float8_e4m3fn
-
- if mm.should_use_fp16(device):
- return torch.float16
-
- if device.type == "cuda" and torch.cuda.is_bf16_supported():
- return torch.bfloat16
-
- return torch.float32
-
- def _supports_fp8(self, device: torch.device) -> bool:
- """Check if device supports FP8 computation"""
- if device.type != "cuda":
- return False
-
- try:
- compute_capability = torch.cuda.get_device_capability(device)
- return compute_capability >= (8, 9) # Ada Lovelace or newer
- except:
- return False
-
- def _load_checkpoint_components(
- self, model_path: str, dtype: torch.dtype, device: torch.device
- ) -> Tuple[Any, Any, Any]:
- """Load main checkpoint components using ComfyUI's standard API"""
- try:
- # Use ComfyUI's memory management
- mm.soft_empty_cache() # Clear cache before loading
-
- # Use the same API as CheckpointLoaderSimple
- out = comfy.sd.load_checkpoint_guess_config(
- model_path,
- output_vae=True,
- output_clip=True,
- embedding_directory=folder_paths.get_folder_paths("embeddings")
- )
-
- if out is None or len(out) < 3:
- raise RuntimeError("Failed to load checkpoint components")
-
- return out[:3] # model, clip, vae
-
- except Exception as e:
- if "Could not detect model type" in str(e):
- raise RuntimeError(
- f"Unsupported model format. This may be a FLUX model that requires "
- f"separate component loading. Try using individual loaders for "
- f"UNet/CLIP/VAE components."
- )
- raise RuntimeError(f"Error loading checkpoint: {str(e)}")
-
- def _load_separate_vae(self, vae_name: str):
- """Load separate VAE component"""
- vae_path = folder_paths.get_full_path("vae", vae_name)
- if vae_path is None:
- raise FileNotFoundError(f"VAE not found: {vae_name}")
-
- try:
- # Use ComfyUI's standard VAE loading
- vae_sd = comfy.utils.load_torch_file(vae_path, safe_load=True)
- vae = comfy.sd.VAE(sd=vae_sd)
- return vae
- except Exception as e:
- raise RuntimeError(f"Failed to load VAE '{vae_name}': {str(e)}")
-
- def _load_custom_clip(self, clip_name1: str, clip_name2: str):
- """Load custom CLIP models (for FLUX dual text encoders)"""
- clip_paths = []
-
- if clip_name1 != "none":
- # Try clip directory first, then text_encoders
- clip_path1 = folder_paths.get_full_path("clip", clip_name1)
- if clip_path1 is None:
- clip_path1 = folder_paths.get_full_path("text_encoders", clip_name1)
-
- if clip_path1 is None:
- raise FileNotFoundError(f"CLIP model not found in clip or text_encoders directories: {clip_name1}")
- clip_paths.append(clip_path1)
-
- if clip_name2 != "none":
- # Try clip directory first, then text_encoders
- clip_path2 = folder_paths.get_full_path("clip", clip_name2)
- if clip_path2 is None:
- clip_path2 = folder_paths.get_full_path("text_encoders", clip_name2)
-
- if clip_path2 is None:
- raise FileNotFoundError(f"CLIP model not found in clip or text_encoders directories: {clip_name2}")
- clip_paths.append(clip_path2)
-
- if not clip_paths:
- return None
-
- try:
- # Use ComfyUI's standard CLIP loading
- clip = comfy.sd.load_clip(
- ckpt_paths=clip_paths,
- embedding_directory=folder_paths.get_folder_paths("embeddings")
- )
- return clip
- except Exception as e:
- raise RuntimeError(f"Failed to load CLIP models: {str(e)}")
-
- def _generate_model_info(
- self, model_name: str, dtype: torch.dtype, device: torch.device,
- vae_name: str, clip_name1: str, clip_name2: str
- ) -> str:
- """Generate model name string (just the base model name without extension)"""
- # Extract base name without extension
- base_name = os.path.splitext(model_name)[0]
- return base_name
-
- def get_model_string_preview(self, model_name: str, weight_dtype: str = "default",
- vae_name: str = "baked VAE", clip_name1: str = "none",
- clip_name2: str = "none") -> str:
- """
- Preview what the model string output will look like.
- Returns just the base model name without extension.
- """
- try:
- return os.path.splitext(model_name)[0]
- except Exception as e:
- return f"Error: {str(e)}"
\ No newline at end of file
+__all__ = [
+ "DiffusionModelLoader",
+ "FluxWildcardEncode",
+ "FluxImageSaver",
+ "FluxPromptSaver",
+ "BawkSampler"
+]
\ No newline at end of file
diff --git a/nodes/__init__.py b/nodes/__init__.py
new file mode 100644
index 0000000..a89a298
--- /dev/null
+++ b/nodes/__init__.py
@@ -0,0 +1,18 @@
+"""
+Nodes package initialization
+File: nodes/__init__.py
+"""
+
+from .diffusion_model_loader import DiffusionModelLoader
+from .flux_wildcard_encode import FluxWildcardEncode
+from .flux_image_saver import FluxImageSaver
+from .flux_prompt_saver import FluxPromptSaver
+from .bawk_sampler import BawkSampler
+
+__all__ = [
+ "DiffusionModelLoader",
+ "FluxWildcardEncode",
+ "FluxImageSaver",
+ "FluxPromptSaver",
+ "BawkSampler"
+]
\ No newline at end of file
diff --git a/nodes/bawk_sampler.py b/nodes/bawk_sampler.py
new file mode 100644
index 0000000..8bf2071
--- /dev/null
+++ b/nodes/bawk_sampler.py
@@ -0,0 +1,337 @@
+"""
+BawkSampler - Combined Latent Generator and Advanced Sampler for FLUX
+File: nodes/bawk_sampler.py
+"""
+
+import torch
+import math
+import time
+import logging
+import comfy.samplers
+import comfy.model_management as mm
+from comfy.utils import ProgressBar
+from comfy_extras.nodes_custom_sampler import Noise_RandomNoise, BasicScheduler, BasicGuider, SamplerCustomAdvanced
+from comfy_extras.nodes_latent import LatentBatch
+from comfy_extras.nodes_model_advanced import ModelSamplingFlux, ModelSamplingAuraFlow
+from typing import Tuple, Dict, Any, List
+
+
+def round_to_nearest_multiple(value, multiple):
+ """Rounds a value to the nearest multiple of 'multiple'."""
+ if multiple <= 0:
+ return value
+ return int(round(value / multiple) * multiple)
+
+
+def parse_string_to_list(input_string):
+ """Parse comma/newline separated string to list of numbers"""
+ try:
+ if not input_string:
+ return []
+ items = input_string.replace('\n', ',').split(',')
+ result = []
+ for item in items:
+ item = item.strip()
+ if not item:
+ continue
+ try:
+ num = float(item)
+ if num.is_integer():
+ num = int(num)
+ result.append(num)
+ except ValueError:
+ continue
+ return result
+ except:
+ return []
+
+
+def conditioning_set_values(conditioning, values):
+ """Set conditioning values like guidance scale"""
+ c = []
+ for t in conditioning:
+ n = [t[0], t[1].copy()]
+ for k, v in values.items():
+ if k == "guidance":
+ n[1]['guidance_scale'] = v
+ c.append(tuple(n))
+ return c
+
+
+class BawkSampler:
+ """
+ Combined latent generator and advanced sampler for FLUX models.
+ Generates optimized latent dimensions, then performs advanced sampling.
+ Designed to work with FluxWildcardEncode for prompt handling.
+ """
+
+ @classmethod
+ def INPUT_TYPES(cls):
+ # Combined resolution presets with aspect ratios built-in
+ # Format: "Name - WxH (aspect ratio)"
+ resolution_presets = [
+ # 16:9 aspect ratio options
+ "HD 16:9 - 1024x576",
+ "FHD 16:9 - 1920x1080",
+ "2K 16:9 - 2048x1152",
+
+ # 1:1 square options
+ "Small Square - 768x768",
+ "Medium Square - 1024x1024",
+ "Large Square - 1536x1536",
+ "XL Square - 2048x2048",
+
+ # 3:2 photo aspect ratio
+ "Photo 3:2 - 1152x768",
+ "Photo 3:2 HD - 1728x1152",
+
+ # 4:3 classic aspect ratio
+ "Classic 4:3 - 1024x768",
+ "Classic 4:3 HD - 1536x1152",
+
+ # 9:16 portrait/mobile
+ "Portrait 9:16 - 576x1024",
+ "Mobile 9:16 - 1080x1920",
+
+ # 2:3 portrait photo
+ "Portrait Photo - 768x1152",
+
+ # 21:9 ultra-wide
+ "Ultra-wide - 1792x768",
+
+ # Custom option
+ "Custom Resolution",
+ ]
+
+ return {
+ "required": {
+ # Core inputs
+ "model": ("MODEL",),
+ "conditioning": ("CONDITIONING",),
+ "vae": ("VAE",), # Added VAE input for decoding
+
+ # Latent generation
+ "resolution": (resolution_presets, {
+ "default": "FHD 16:9 - 1920x1080",
+ "tooltip": "Select resolution preset or custom option"
+ }),
+ "batch_size": ("INT", {
+ "default": 4, "min": 1, "max": 64, "step": 1,
+ "tooltip": "Number of images to generate"
+ }),
+
+ # Sampling parameters
+ "seed": ("INT", {
+ "default": 0, "min": 0, "max": 0xffffffffffffffff,
+ "tooltip": "Random seed for generation"
+ }),
+ "sampler": (comfy.samplers.KSampler.SAMPLERS, {
+ "default": "euler",
+ "tooltip": "Sampling method for generation"
+ }),
+ "scheduler": (comfy.samplers.KSampler.SCHEDULERS, {
+ "default": "beta",
+ "tooltip": "Noise scheduling method"
+ }),
+ "steps": ("INT", {
+ "default": 30, "min": 1, "max": 100, "step": 1,
+ "tooltip": "Number of sampling steps"
+ }),
+ "guidance": ("FLOAT", {
+ "default": 3.5, "min": 0.0, "max": 20.0, "step": 0.1,
+ "tooltip": "Guidance scale for FLUX"
+ }),
+ "max_shift": ("FLOAT", {
+ "default": 0.5, "min": 0.0, "max": 2.0, "step": 0.01,
+ "tooltip": "Max shift parameter for FLUX"
+ }),
+ "base_shift": ("FLOAT", {
+ "default": 0.3, "min": 0.0, "max": 2.0, "step": 0.01,
+ "tooltip": "Base shift parameter for FLUX"
+ }),
+ "denoise": ("FLOAT", {
+ "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01,
+ "tooltip": "Denoise strength"
+ }),
+
+ # Custom resolution toggle
+ "use_custom_resolution": ("BOOLEAN", {
+ "default": False,
+ "tooltip": "Enable custom width/height instead of presets"
+ }),
+ },
+ "optional": {
+ # Custom resolution (only used when use_custom_resolution=True)
+ "custom_width": ("INT", {
+ "default": 1920, "min": 64, "max": 4096, "step": 64,
+ "tooltip": "Custom width (must be multiple of 64). Only used when custom resolution is enabled."
+ }),
+ "custom_height": ("INT", {
+ "default": 1080, "min": 64, "max": 4096, "step": 64,
+ "tooltip": "Custom height (must be multiple of 64). Only used when custom resolution is enabled."
+ }),
+ }
+ }
+
+ RETURN_TYPES = ("IMAGE", "LATENT")
+ RETURN_NAMES = ("images", "latent")
+ FUNCTION = "generate_sample_and_decode"
+ CATEGORY = "BawkNodes/sampling"
+ DESCRIPTION = "Combined latent generator, sampler, and VAE decoder optimized for FLUX models"
+
+ def generate_sample_and_decode(
+ self,
+ model, conditioning, vae,
+ resolution="FHD 16:9 - 1920x1080", batch_size=4,
+ seed=0, sampler="euler", scheduler="beta", steps=30,
+ guidance=3.5, max_shift=0.5, base_shift=0.3, denoise=1.0,
+ use_custom_resolution=False, custom_width=1920, custom_height=1080
+ ):
+ """
+ Generate optimized latent, perform FLUX sampling, and decode to images
+ """
+ try:
+ # Step 1: Generate optimized latent
+ latent = self._generate_optimized_latent(
+ resolution, batch_size, use_custom_resolution, custom_width, custom_height
+ )
+
+ # Step 2: Perform sampling
+ sampled_latent = self._perform_flux_sampling(
+ model, conditioning, latent, seed, sampler, scheduler,
+ steps, guidance, max_shift, base_shift, denoise
+ )
+
+ # Step 3: Decode latent to images using VAE
+ decoded_images = self._decode_latent_to_images(vae, sampled_latent)
+
+ print(f"[BawkSampler] Successfully generated, sampled, and decoded {batch_size} images")
+
+ return (decoded_images, sampled_latent)
+
+ except Exception as e:
+ error_msg = f"BawkSampler failed: {str(e)}"
+ print(f"[BawkSampler] Error: {error_msg}")
+ raise RuntimeError(error_msg)
+
+ def _generate_optimized_latent(
+ self, resolution, batch_size, use_custom_resolution, custom_width, custom_height
+ ) -> Dict:
+ """Generate optimized empty latent for FLUX"""
+
+ # Determine target dimensions
+ if use_custom_resolution:
+ # Use custom dimensions (ensure they're multiples of 64)
+ target_width = round_to_nearest_multiple(custom_width, 64)
+ target_height = round_to_nearest_multiple(custom_height, 64)
+ print(f"[BawkSampler] Using custom resolution: {target_width}x{target_height}")
+ else:
+ # Parse dimensions from preset string
+ target_width, target_height = self._parse_resolution_preset(resolution)
+ print(f"[BawkSampler] Using preset resolution: {resolution}")
+
+ # FLUX-specific parameters
+ vae_scale_factor = 8
+ latent_channels = 16 # FLUX uses 16 channels
+
+ # Calculate latent dimensions
+ latent_width = target_width // vae_scale_factor
+ latent_height = target_height // vae_scale_factor
+
+ # Generate latent tensor
+ try:
+ latent_tensor = torch.zeros([batch_size, latent_channels, latent_height, latent_width])
+ latent = {"samples": latent_tensor}
+ except Exception as e:
+ raise RuntimeError(f"Error creating FLUX latent tensor [{batch_size}, {latent_channels}, {latent_height}, {latent_width}]: {e}")
+
+ print(f"[BawkSampler] Generated FLUX latent: {latent_width}x{latent_height} "
+ f"(pixel: {target_width}x{target_height}, batch: {batch_size})")
+
+ return latent
+
+ def _parse_resolution_preset(self, resolution_preset):
+ """Parse width and height from resolution preset string"""
+ try:
+ # Extract dimensions from string like "FHD 16:9 - 1920x1080"
+ # Split by " - " and take the part after it
+ parts = resolution_preset.split(" - ")
+ if len(parts) < 2:
+ raise ValueError(f"Invalid resolution format: {resolution_preset}")
+
+ dimensions = parts[1] # e.g., "1920x1080"
+ width_str, height_str = dimensions.split("x")
+
+ target_width = int(width_str)
+ target_height = int(height_str)
+
+ # Ensure dimensions are multiples of 64 for FLUX compatibility
+ target_width = round_to_nearest_multiple(target_width, 64)
+ target_height = round_to_nearest_multiple(target_height, 64)
+
+ return target_width, target_height
+
+ except Exception as e:
+ print(f"[BawkSampler] Warning: Could not parse resolution '{resolution_preset}': {e}")
+ # Fallback to default FHD resolution
+ return 1920, 1080
+
+ def _perform_flux_sampling(
+ self, model, conditioning, latent_image, seed, sampler, scheduler,
+ steps, guidance, max_shift, base_shift, denoise
+ ):
+ """Perform FLUX-optimized sampling"""
+
+ # Single parameter sampling (no multi-parameter sweeps for cleaner UX)
+ noise_seed = seed
+
+ # Initialize FLUX sampling components
+ basicscheduler = BasicScheduler()
+ basicguider = BasicGuider()
+ samplercustomadvanced = SamplerCustomAdvanced()
+ modelsamplingflux = ModelSamplingFlux()
+ randnoise = Noise_RandomNoise(noise_seed)
+
+ # Get dimensions for model sampling
+ width = latent_image["samples"].shape[3] * 8
+ height = latent_image["samples"].shape[2] * 8
+
+ # Apply FLUX model sampling
+ work_model = modelsamplingflux.patch(model, max_shift, base_shift, width, height)[0]
+
+ # Set guidance in conditioning
+ cond = conditioning_set_values(conditioning, {"guidance": guidance})
+ guider = basicguider.get_guider(work_model, cond)[0]
+
+ # Create sampler object
+ samplerobj = comfy.samplers.sampler_object(sampler)
+
+ # Generate sigmas
+ sigmas = basicscheduler.get_sigmas(work_model, scheduler, steps, denoise)[0]
+
+ logging.info(f"FLUX Sampling: seed={noise_seed}, {sampler}_{scheduler}, "
+ f"steps={steps}, guidance={guidance}, max_shift={max_shift}, base_shift={base_shift}")
+
+ # Perform FLUX sampling
+ latent = samplercustomadvanced.sample(
+ randnoise, guider, samplerobj, sigmas, latent_image
+ )[1]
+
+ print(f"[BawkSampler] Completed FLUX sampling with {sampler}_{scheduler}")
+ return latent
+
+ def _decode_latent_to_images(self, vae, latent):
+ """Decode latent to images using the provided VAE"""
+ try:
+ print(f"[BawkSampler] Decoding latent to images...")
+
+ # Decode latent using VAE
+ decoded_images = vae.decode(latent["samples"])
+
+ print(f"[BawkSampler] Successfully decoded latent to images, shape: {decoded_images.shape}")
+ return decoded_images
+
+ except Exception as e:
+ error_msg = f"Failed to decode latent: {str(e)}"
+ print(f"[BawkSampler] Error: {error_msg}")
+ raise RuntimeError(error_msg)
\ No newline at end of file
diff --git a/nodes/diffusion_model_loader.py b/nodes/diffusion_model_loader.py
new file mode 100644
index 0000000..7474e3a
--- /dev/null
+++ b/nodes/diffusion_model_loader.py
@@ -0,0 +1,156 @@
+"""
+DiffusionModelLoader Node
+File: nodes/diffusion_model_loader.py
+"""
+
+import os
+import torch
+import comfy.sd
+import comfy.utils
+import folder_paths
+from typing import Tuple, Any
+
+# Try importing validation from parent modules
+try:
+ from ..modules.validation import ValidationMixin
+except ImportError:
+ # Fallback if modules structure is different
+ class ValidationMixin:
+ pass
+
+
+class DiffusionModelLoader(ValidationMixin):
+ """
+ Advanced Diffusion Model Loader with support for:
+ - Multiple model formats (FLUX, SDXL, SD1.5)
+ - Flexible weight data types (fp8, fp16, bf16, fp32)
+ - Separate VAE and CLIP loading
+ - Multiple directory support
+ """
+
+ @classmethod
+ def INPUT_TYPES(cls):
+ return {
+ "required": {
+ "model_name": (folder_paths.get_filename_list("diffusion_models"),),
+ "vae_name": (folder_paths.get_filename_list("vae") + ["baked VAE"],),
+ "clip_name1": (folder_paths.get_filename_list("text_encoders") + ["none"],),
+ "clip_name2": (folder_paths.get_filename_list("text_encoders") + ["none"],),
+ "weight_dtype": (["default", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e5m2"],),
+ }
+ }
+
+ RETURN_TYPES = ("MODEL", "VAE", "CLIP", "STRING")
+ RETURN_NAMES = ("MODEL", "VAE", "CLIP", "MODEL_STRING")
+ FUNCTION = "load_diffusion_model"
+ CATEGORY = "BawkNodes/loaders"
+ DESCRIPTION = "Advanced diffusion model loader for FLUX and other modern architectures"
+
+ @classmethod
+ def VALIDATE_INPUTS(cls, **kwargs):
+ """Simple validation matching the working loader pattern"""
+ errors = []
+
+ # Validate model exists in diffusion_models directory
+ model_name = kwargs.get("model_name")
+ if model_name:
+ try:
+ folder_paths.get_full_path_or_raise("diffusion_models", model_name)
+ except:
+ errors.append(f"Model '{model_name}' not found in diffusion_models directory")
+
+ # Validate VAE if specified
+ vae_name = kwargs.get("vae_name", "baked VAE")
+ if vae_name and vae_name != "baked VAE":
+ try:
+ folder_paths.get_full_path_or_raise("vae", vae_name)
+ except:
+ errors.append(f"VAE '{vae_name}' not found in vae directory")
+
+ # Validate CLIP models if specified
+ clip1 = kwargs.get("clip_name1", "none")
+ if clip1 and clip1 != "none":
+ try:
+ folder_paths.get_full_path_or_raise("text_encoders", clip1)
+ except:
+ errors.append(f"CLIP model '{clip1}' not found in text_encoders directory")
+
+ clip2 = kwargs.get("clip_name2", "none")
+ if clip2 and clip2 != "none":
+ try:
+ folder_paths.get_full_path_or_raise("text_encoders", clip2)
+ except:
+ errors.append(f"CLIP model '{clip2}' not found in text_encoders directory")
+
+ return "; ".join(errors) if errors else True
+
+ def load_diffusion_model(
+ self,
+ model_name: str,
+ weight_dtype: str = "default",
+ vae_name: str = "baked VAE",
+ clip_name1: str = "none",
+ clip_name2: str = "none"
+ ) -> Tuple[Any, Any, Any, str]:
+ """
+ Main loading function for diffusion models
+ """
+ try:
+ # Handle "none" and "baked VAE" values
+ vae_name = vae_name if vae_name and vae_name != "baked VAE" else None
+ clip_name1 = clip_name1 if clip_name1 and clip_name1 != "none" else None
+ clip_name2 = clip_name2 if clip_name2 and clip_name2 != "none" else None
+ weight_dtype = weight_dtype if weight_dtype else "default"
+
+ # Set up model options based on weight_dtype
+ model_options = {}
+ if weight_dtype == "fp8_e4m3fn":
+ model_options["dtype"] = torch.float8_e4m3fn
+ elif weight_dtype == "fp8_e4m3fn_fast":
+ model_options["dtype"] = torch.float8_e4m3fn
+ model_options["fp8_optimizations"] = True
+ elif weight_dtype == "fp8_e5m2":
+ model_options["dtype"] = torch.float8_e5m2
+
+ # Load diffusion model
+ print(f"[DiffusionModelLoader] Loading diffusion model: {model_name}")
+ model_path = folder_paths.get_full_path_or_raise("diffusion_models", model_name)
+ model = comfy.sd.load_diffusion_model(model_path, model_options=model_options)
+
+ if model is None:
+ raise RuntimeError("Failed to load diffusion model - output was None")
+
+ # Load VAE
+ vae = None
+ if vae_name:
+ print(f"[DiffusionModelLoader] Loading VAE: {vae_name}")
+ vae_path = folder_paths.get_full_path_or_raise("vae", vae_name)
+ vae_sd = comfy.utils.load_torch_file(vae_path)
+ vae = comfy.sd.VAE(sd=vae_sd)
+
+ # Load CLIP models
+ clip_paths = []
+ if clip_name1:
+ clip_paths.append(folder_paths.get_full_path_or_raise("text_encoders", clip_name1))
+ if clip_name2:
+ clip_paths.append(folder_paths.get_full_path_or_raise("text_encoders", clip_name2))
+
+ clip = None
+ if clip_paths:
+ print(f"[DiffusionModelLoader] Loading CLIP models")
+ clip = comfy.sd.load_clip(
+ ckpt_paths=clip_paths,
+ embedding_directory=folder_paths.get_folder_paths("embeddings"),
+ clip_type=comfy.sd.CLIPType.FLUX
+ )
+
+ # Generate simple model name string
+ model_string = os.path.splitext(model_name)[0]
+
+ print(f"[DiffusionModelLoader] Successfully loaded diffusion model: {model_string}")
+ return (model, vae, clip, model_string)
+
+ except Exception as e:
+ error_msg = f"Failed to load diffusion model '{model_name}': {str(e)}"
+ print(f"[DiffusionModelLoader] Error: {error_msg}")
+ raise RuntimeError(error_msg)
\ No newline at end of file
diff --git a/nodes/flux_image_saver.py b/nodes/flux_image_saver.py
new file mode 100644
index 0000000..9f0c09c
--- /dev/null
+++ b/nodes/flux_image_saver.py
@@ -0,0 +1,203 @@
+"""
+FluxImageSaver Node
+File: nodes/flux_image_saver.py
+"""
+
+import os
+import json
+import re
+import numpy as np
+import folder_paths
+from datetime import datetime
+from typing import Dict, Any
+
+
+class FluxImageSaver:
+ """
+ FLUX-optimized image saver with organized folder structure and metadata support
+ """
+
+ @classmethod
+ def INPUT_TYPES(cls):
+ return {
+ "required": {
+ "images": ("IMAGE",),
+ "model_string": ("STRING", {"forceInput": True}),
+ "processed_prompt": ("STRING", {"forceInput": True}), # Connect from wildcard encoder
+ "prefix": ("STRING", {"default": "flux_image"}),
+ "format": (["png", "jpg", "webp"], {"default": "png"}),
+ "quality": ("INT", {"default": 95, "min": 1, "max": 100}),
+ "save_metadata": ("BOOLEAN", {"default": True}),
+ "save_prompt": ("BOOLEAN", {"default": True, "tooltip": "Save the processed prompt as a separate text file"}),
+ },
+ "hidden": {
+ "prompt_hidden": "PROMPT",
+ "extra_pnginfo": "EXTRA_PNGINFO"
+ }
+ }
+
+ RETURN_TYPES = ()
+ RETURN_NAMES = ()
+ FUNCTION = "save_images"
+ CATEGORY = "BawkNodes/image"
+ OUTPUT_NODE = True
+ DESCRIPTION = "Save FLUX-generated images with organized folder structure"
+
+ def __init__(self):
+ self.output_dir = folder_paths.get_output_directory()
+ self.type = "output"
+
+ def save_images(self, images, model_string, processed_prompt, prefix="flux_image",
+ format="png", quality=95, save_metadata=True, save_prompt=True,
+ prompt_hidden=None, extra_pnginfo=None):
+ """
+ Save images with FLUX-optimized organization and metadata
+ """
+ try:
+ from PIL import Image
+
+ print(f"[FluxImageSaver] Processing {len(images)} images")
+
+ # Get current date for folder and filename
+ now = datetime.now()
+ date_str = now.strftime("%d-%m-%Y")
+ datetime_str = now.strftime("%d-%m-%Y_%H-%M-%S")
+
+ # Clean model string for folder name
+ clean_model = self._clean_filename(model_string)
+
+ # Create folder structure: [MODEL]-DD-MM-YYYY
+ folder_name = f"[{clean_model}]-{date_str}"
+ output_dir = os.path.join(folder_paths.get_output_directory(), folder_name)
+ os.makedirs(output_dir, exist_ok=True)
+
+ saved_paths = []
+ results = [] # For UI image preview
+
+ # Save the processed prompt as a text file if enabled
+ if save_prompt and processed_prompt:
+ self._save_prompt_file(output_dir, processed_prompt, datetime_str, prefix)
+
+ for i, image_tensor in enumerate(images):
+ print(f"[FluxImageSaver] Processing image {i+1}/{len(images)}, shape: {image_tensor.shape}")
+
+ # Convert tensor to PIL Image
+ image_np = (255.0 * image_tensor.cpu().numpy()).astype(np.uint8)
+ pil_image = Image.fromarray(image_np)
+
+ # Generate filename: prefix_DD-MM-YYYY_HH-MM-SS_001.ext
+ batch_suffix = f"_{i+1:03d}" if len(images) > 1 else ""
+ filename = f"{prefix}_{datetime_str}{batch_suffix}.{format}"
+ filepath = os.path.join(output_dir, filename)
+
+ # Check if file exists and add counter if necessary
+ counter = 1
+ original_filepath = filepath
+ while os.path.exists(filepath):
+ name_part = f"{prefix}_{datetime_str}{batch_suffix}_{counter:03d}"
+ filename = f"{name_part}.{format}"
+ filepath = os.path.join(output_dir, filename)
+ counter += 1
+
+ # Save image with format-specific options
+ save_kwargs = {}
+ if format.lower() == "jpg" or format.lower() == "jpeg":
+ save_kwargs = {"quality": quality, "optimize": True}
+ elif format.lower() == "webp":
+ save_kwargs = {"quality": quality, "method": 6}
+ elif format.lower() == "png":
+ save_kwargs = {"optimize": True}
+ # Add metadata to PNG
+ if save_metadata and extra_pnginfo:
+ from PIL.PngImagePlugin import PngInfo
+ metadata = PngInfo()
+ for key, value in extra_pnginfo.items():
+ metadata.add_text(key, str(value))
+ save_kwargs["pnginfo"] = metadata
+
+ pil_image.save(filepath, format.upper(), **save_kwargs)
+ saved_paths.append(filepath)
+
+ # Add to results for UI preview (relative to output directory)
+ results.append({
+ "filename": filename,
+ "subfolder": folder_name,
+ "type": self.type
+ })
+
+ print(f"[FluxImageSaver] Saved: {filepath}")
+
+ # Save metadata/prompt file if requested
+ if save_metadata and prompt_hidden:
+ self._save_metadata(filepath, prompt_hidden, extra_pnginfo,
+ model_string, format, quality, processed_prompt)
+
+ print(f"[FluxImageSaver] Returning {len(results)} images for preview")
+
+ return {"ui": {"images": results}}
+
+ except Exception as e:
+ error_msg = f"Failed to save images: {str(e)}"
+ print(f"[FluxImageSaver] Error: {error_msg}")
+ import traceback
+ traceback.print_exc()
+ return {"ui": {"images": []}}
+
+ def _clean_filename(self, filename):
+ """Clean filename for use in folder/file names"""
+ # Remove file extensions and clean up
+ clean = re.sub(r'\.[^.]*$', '', filename) # Remove extension
+ clean = re.sub(r'[<>:"/\\|?*]', '_', clean) # Replace invalid chars
+ clean = re.sub(r'_{2,}', '_', clean) # Collapse multiple underscores
+ return clean.strip('_')
+
+ def _save_prompt_file(self, output_dir, processed_prompt, datetime_str, prefix):
+ """Save the processed prompt as a text file"""
+ try:
+ # Create prompt filename
+ prompt_filename = f"{prefix}_{datetime_str}_prompt.txt"
+ prompt_filepath = os.path.join(output_dir, prompt_filename)
+
+ # Check if file exists and add counter if necessary
+ counter = 1
+ while os.path.exists(prompt_filepath):
+ prompt_filename = f"{prefix}_{datetime_str}_prompt_{counter:03d}.txt"
+ prompt_filepath = os.path.join(output_dir, prompt_filename)
+ counter += 1
+
+ # Save the prompt
+ with open(prompt_filepath, 'w', encoding='utf-8') as f:
+ f.write(processed_prompt)
+
+ print(f"[FluxImageSaver] Saved prompt: {prompt_filepath}")
+
+ except Exception as e:
+ print(f"[FluxImageSaver] Failed to save prompt file: {str(e)}")
+
+ def _save_metadata(self, image_path, prompt_hidden, extra_pnginfo,
+ model_string, format, quality, processed_prompt=None):
+ """Save metadata as JSON file"""
+ try:
+ # Create metadata filename
+ base_path = os.path.splitext(image_path)[0]
+ metadata_path = f"{base_path}_metadata.json"
+
+ # Collect metadata
+ metadata = {
+ "timestamp": datetime.now().isoformat(),
+ "model": model_string,
+ "processed_prompt": processed_prompt, # Add the processed prompt
+ "format": format,
+ "quality": quality if format != "png" else None,
+ "workflow_prompt": prompt_hidden,
+ "extra_info": extra_pnginfo
+ }
+
+ # Save as JSON
+ with open(metadata_path, 'w', encoding='utf-8') as f:
+ json.dump(metadata, f, indent=2, ensure_ascii=False)
+
+ print(f"[FluxImageSaver] Metadata saved: {metadata_path}")
+
+ except Exception as e:
+ print(f"[FluxImageSaver] Failed to save metadata: {str(e)}")
\ No newline at end of file
diff --git a/nodes/flux_prompt_saver.py b/nodes/flux_prompt_saver.py
new file mode 100644
index 0000000..dbe8fd3
--- /dev/null
+++ b/nodes/flux_prompt_saver.py
@@ -0,0 +1,91 @@
+"""
+FluxPromptSaver Node
+File: nodes/flux_prompt_saver.py
+"""
+
+import os
+import json
+import re
+import folder_paths
+from datetime import datetime
+from typing import Tuple
+
+
+class FluxPromptSaver:
+ """
+ Standalone prompt saver for FLUX workflows
+ """
+
+ @classmethod
+ def INPUT_TYPES(cls):
+ return {
+ "required": {
+ "model_string": ("STRING", {"forceInput": True}),
+ "prompt": ("STRING", {"multiline": True}),
+ "filename_prefix": ("STRING", {"default": "flux_prompt"}),
+ },
+ "optional": {
+ "negative_prompt": ("STRING", {"multiline": True, "default": ""}),
+ "generation_params": ("STRING", {"multiline": True, "default": ""}),
+ },
+ "hidden": {
+ "extra_pnginfo": "EXTRA_PNGINFO"
+ }
+ }
+
+ RETURN_TYPES = ("STRING",)
+ RETURN_NAMES = ("saved_path",)
+ FUNCTION = "save_prompt"
+ CATEGORY = "BawkNodes/text"
+ OUTPUT_NODE = True
+ DESCRIPTION = "Save FLUX prompts and generation parameters"
+
+ def save_prompt(self, model_string, prompt, filename_prefix="flux_prompt",
+ negative_prompt="", generation_params="", extra_pnginfo=None):
+ """Save prompt and parameters to organized text files"""
+ try:
+ # Get current date for folder structure
+ now = datetime.now()
+ date_str = now.strftime("%d-%m-%Y")
+ datetime_str = now.strftime("%d-%m-%Y_%H-%M-%S")
+
+ # Clean model string for folder name
+ clean_model = self._clean_filename(model_string)
+
+ # Create folder structure matching image saver
+ folder_name = f"[{clean_model}]-{date_str}"
+ output_dir = os.path.join(folder_paths.get_output_directory(), folder_name)
+ os.makedirs(output_dir, exist_ok=True)
+
+ # Create filename
+ filename = f"{filename_prefix}_{datetime_str}.json"
+ filepath = os.path.join(output_dir, filename)
+
+ # Prepare data
+ prompt_data = {
+ "timestamp": now.isoformat(),
+ "model": model_string,
+ "positive_prompt": prompt,
+ "negative_prompt": negative_prompt,
+ "generation_parameters": generation_params,
+ "workflow_info": extra_pnginfo
+ }
+
+ # Save as JSON
+ with open(filepath, 'w', encoding='utf-8') as f:
+ json.dump(prompt_data, f, indent=2, ensure_ascii=False)
+
+ print(f"[FluxPromptSaver] Saved: {filepath}")
+ return (f"Prompt saved to {filename}",)
+
+ except Exception as e:
+ error_msg = f"Failed to save prompt: {str(e)}"
+ print(f"[FluxPromptSaver] Error: {error_msg}")
+ return (f"Error: {error_msg}",)
+
+ def _clean_filename(self, filename):
+ """Clean filename for use in folder/file names"""
+ clean = re.sub(r'\.[^.]*$', '', filename)
+ clean = re.sub(r'[<>:"/\\|?*]', '_', clean)
+ clean = re.sub(r'_{2,}', '_', clean)
+ return clean.strip('_')
\ No newline at end of file
diff --git a/nodes/flux_wildcard_encode.py b/nodes/flux_wildcard_encode.py
new file mode 100644
index 0000000..efbf0e2
--- /dev/null
+++ b/nodes/flux_wildcard_encode.py
@@ -0,0 +1,240 @@
+"""
+FluxWildcardEncode Node with LoRA Support (using rgthree-style dynamic UI)
+File: nodes/flux_wildcard_encode.py
+"""
+
+import re
+import random
+import torch
+import folder_paths
+from typing import Tuple, Any
+
+
+# Fallback implementation for flexible inputs
+class FlexibleOptionalInputType(dict):
+ def __init__(self, type_func, data=None):
+ super().__init__()
+ self.data = data or {}
+ self.type = type_func
+ for key, value in self.data.items():
+ self[key] = value
+
+ def __contains__(self, key):
+ return True
+
+ def __getitem__(self, key):
+ if key in self.data:
+ return self.data[key]
+ return self.type
+
+
+def any_type(s=None):
+ return ("*",)
+
+
+class FluxWildcardEncode:
+ """
+ Enhanced FLUX wildcard text encoder with integrated LoRA loading.
+ Uses rgthree-style dynamic UI for clean LoRA management.
+ """
+
+ @classmethod
+ def INPUT_TYPES(cls):
+ # Get available LoRA files
+ lora_list = folder_paths.get_filename_list("loras")
+ lora_options = ["None"] + lora_list
+
+ return {
+ "required": {
+ "model": ("MODEL",),
+ "clip": ("CLIP",),
+ "prompt": ("STRING", {"multiline": True, "default": ""}),
+ "wildcard_seed": ("INT", {
+ "default": -1, "min": -1, "max": 0xffffffffffffffff,
+ "tooltip": "Seed for wildcard selection. Use -1 to disable wildcards"
+ }),
+ },
+ "optional": {
+ # LoRA 1
+ "lora_1_on": ("BOOLEAN", {"default": False}),
+ "lora_1_name": (lora_options, {"default": "None"}),
+ "lora_1_strength": ("FLOAT", {"default": 1.00, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ # LoRA 2
+ "lora_2_on": ("BOOLEAN", {"default": False}),
+ "lora_2_name": (lora_options, {"default": "None"}),
+ "lora_2_strength": ("FLOAT", {"default": 1.00, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ # LoRA 3
+ "lora_3_on": ("BOOLEAN", {"default": False}),
+ "lora_3_name": (lora_options, {"default": "None"}),
+ "lora_3_strength": ("FLOAT", {"default": 1.00, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ # LoRA 4
+ "lora_4_on": ("BOOLEAN", {"default": False}),
+ "lora_4_name": (lora_options, {"default": "None"}),
+ "lora_4_strength": ("FLOAT", {"default": 1.00, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ # LoRA 5
+ "lora_5_on": ("BOOLEAN", {"default": False}),
+ "lora_5_name": (lora_options, {"default": "None"}),
+ "lora_5_strength": ("FLOAT", {"default": 1.00, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ # LoRA 6
+ "lora_6_on": ("BOOLEAN", {"default": False}),
+ "lora_6_name": (lora_options, {"default": "None"}),
+ "lora_6_strength": ("FLOAT", {"default": 1.00, "min": -10.0, "max": 10.0, "step": 0.01}),
+ }
+ }
+
+ RETURN_TYPES = ("MODEL", "CLIP", "CONDITIONING", "STRING")
+ RETURN_NAMES = ("MODEL", "CLIP", "CONDITIONING", "PROMPT_OUT")
+ FUNCTION = "encode_with_loras"
+ CATEGORY = "BawkNodes/conditioning"
+ DESCRIPTION = "🎲 FLUX Wildcard Encoder with Dynamic LoRA Support"
+
+ def encode_with_loras(self, model, clip, prompt, wildcard_seed=-1, **kwargs):
+ """
+ Encode text prompt with wildcard processing and dynamic LoRA loading
+ """
+ try:
+ print(f"[FluxWildcardEncode] Starting encode with dynamic LoRAs")
+ print(f"[FluxWildcardEncode] Received kwargs: {list(kwargs.keys())}")
+
+ # Step 1: Process wildcards if seed is provided
+ processed_prompt = prompt
+ if wildcard_seed != -1:
+ processed_prompt = self._process_wildcards(prompt, wildcard_seed)
+ if processed_prompt != prompt:
+ print(f"[FluxWildcardEncode] Processed wildcards in prompt")
+
+ # Step 2: Apply LoRAs from fixed slots
+ working_model = model
+ working_clip = clip
+ ui_lora_count = 0
+
+ # Process 6 fixed LoRA slots
+ for i in range(1, 7): # LoRA 1-6
+ on_key = f"lora_{i}_on"
+ name_key = f"lora_{i}_name"
+ strength_key = f"lora_{i}_strength"
+
+ # Check if this LoRA slot is enabled and has a valid selection
+ lora_enabled = kwargs.get(on_key, False)
+ lora_name = kwargs.get(name_key, "None")
+
+ if lora_enabled and lora_name and lora_name != "None":
+ strength = kwargs.get(strength_key, 1.00)
+
+ # Skip if strength is zero
+ if strength == 0:
+ continue
+
+ try:
+ from nodes import LoraLoader
+ working_model, working_clip = LoraLoader().load_lora(
+ working_model, working_clip, lora_name, strength, strength
+ )
+ ui_lora_count += 1
+ print(f"[FluxWildcardEncode] Applied LoRA {i}: {lora_name} (strength: {strength})")
+ except Exception as e:
+ print(f"[FluxWildcardEncode] Failed to load LoRA {i} ({lora_name}): {e}")
+
+ if ui_lora_count > 0:
+ print(f"[FluxWildcardEncode] Applied {ui_lora_count} LoRAs")
+ else:
+ print(f"[FluxWildcardEncode] No LoRAs applied")
+
+ # Step 3: Encode the processed prompt
+ if not processed_prompt.strip():
+ print("[FluxWildcardEncode] Warning: Empty prompt")
+ empty_conditioning = [[torch.zeros((1, 77, 768)), {"pooled_output": torch.zeros((1, 768))}]]
+ return (working_model, working_clip, empty_conditioning, processed_prompt)
+
+ # Encode using the LoRA-modified CLIP
+ tokens = working_clip.tokenize(processed_prompt)
+ conditioning, pooled = working_clip.encode_from_tokens(tokens, return_pooled=True)
+ conditioning = [[conditioning, {"pooled_output": pooled}]]
+
+ print(f"[FluxWildcardEncode] Success: {ui_lora_count} LoRAs, conditioning shape: {conditioning[0][0].shape}")
+ return (working_model, working_clip, conditioning, processed_prompt)
+
+ except Exception as e:
+ error_msg = f"Failed to encode with LoRAs: {str(e)}"
+ print(f"[FluxWildcardEncode] Error: {error_msg}")
+ import traceback
+ traceback.print_exc()
+ empty_conditioning = [[torch.zeros((1, 77, 768)), {"pooled_output": torch.zeros((1, 768))}]]
+ return (model, clip, empty_conditioning, prompt)
+
+ def _process_wildcards(self, prompt, seed):
+ """
+ Process wildcard syntax in prompts
+ Wildcard format: {option1|option2|option3}
+ """
+ # Set seed for consistent wildcard selection
+ random.seed(seed)
+
+ processed = prompt
+
+ # Find and process wildcards in {option1|option2|option3} format
+ wildcard_pattern = r'\{([^}]+)\}'
+
+ def replace_wildcard(match):
+ wildcard_content = match.group(1)
+ if '|' in wildcard_content:
+ options = [option.strip() for option in wildcard_content.split('|')]
+ if options: # Make sure we have options
+ return random.choice(options)
+ return match.group(0) # Return original if no valid options
+
+ # Replace all wildcards
+ processed = re.sub(wildcard_pattern, replace_wildcard, processed)
+
+ return processed
+
+ def _get_lora_by_filename(self, file_path):
+ """Find LoRA file with fuzzy matching (rgthree style)"""
+ if not file_path:
+ return None
+
+ lora_paths = folder_paths.get_filename_list('loras')
+
+ # Direct match
+ if file_path in lora_paths:
+ return file_path
+
+ # Match without extension
+ lora_paths_no_ext = [os.path.splitext(x)[0] for x in lora_paths]
+ if file_path in lora_paths_no_ext:
+ return lora_paths[lora_paths_no_ext.index(file_path)]
+
+ # Force input without extension
+ file_path_no_ext = os.path.splitext(file_path)[0]
+ if file_path_no_ext in lora_paths_no_ext:
+ return lora_paths[lora_paths_no_ext.index(file_path_no_ext)]
+
+ # Basename matching
+ lora_basenames = [os.path.basename(x) for x in lora_paths]
+ if file_path in lora_basenames:
+ return lora_paths[lora_basenames.index(file_path)]
+
+ # Basename without extension
+ file_basename = os.path.basename(file_path)
+ if file_basename in lora_basenames:
+ return lora_paths[lora_basenames.index(file_basename)]
+
+ # Basename no extension matching
+ lora_basenames_no_ext = [os.path.splitext(os.path.basename(x))[0] for x in lora_paths]
+ file_basename_no_ext = os.path.splitext(os.path.basename(file_path))[0]
+ if file_basename_no_ext in lora_basenames_no_ext:
+ return lora_paths[lora_basenames_no_ext.index(file_basename_no_ext)]
+
+ # Fuzzy partial match
+ for lora_path in lora_paths:
+ if file_path in lora_path:
+ print(f"[FluxWildcardEncode] Fuzzy-matched '{file_path}' to '{lora_path}'")
+ return lora_path
+
+ print(f"[FluxWildcardEncode] LoRA '{file_path}' not found")
+ return None
\ No newline at end of file
diff --git a/previews/efficient-workflow-preview.png b/previews/efficient-workflow-preview.png
new file mode 100644
index 0000000000000000000000000000000000000000..addf56b1391ed9140d02a82e1848c8c2b09a0bde
GIT binary patch
literal 635748
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