feat: migrate to uv and add daggr workflow

.gitignore

@@ -2,22 +2,28 @@
 .venv/
 venv/
 env/
+__pypackages__/
 
 # Variables de entorno
 .env
 .env.local
+.env*.local
 
 # Python
 __pycache__/
 *.py[cod]
 *$py.class
 *.so
+*.egg-info/
+dist/
+build/
 
 # IDE
 .idea/
 .vscode/
 *.swp
 *.swo
+*.sublime-*
 
 # OS
 .DS_Store
@@ -26,5 +32,13 @@ Thumbs.db
 # Modal
 .modal/
 
+# UV
+.uv-cache/
+
+# Daggr
+daggr_cache/
+
 # Artifacts
 *.log
+.gradio_cached_examples/
+.gradio_servables/

MIGRATION_UV_DAGGR.md

@@ -0,0 +1,223 @@
+# Migración a UV y Daggr - Acuarela Portrait
+
+Este documento explica cómo migrar tu proyecto a **UV** y integrar **Daggr**.
+
+## ¿Qué es UV?
+
+**UV** es un gestor de paquetes ultra-rápido para Python, escrito en Rust. Reemplaza `pip` y `venv` con una herramienta mucho más eficiente.
+
+**Ventajas:**
+- ⚡ 100x más rápido que pip
+- 🔒 Resolución de dependencias deterministica
+- 📦 Integración con `pyproject.toml`
+- 🔄 Manejo automático de virtual environments
+
+---
+
+## ¿Qué es Daggr?
+
+**Daggr** es una librería de Hugging Face para crear workflows de IA de forma visual en Python.
+
+**Características:**
+- 🔗 Encadena aplicaciones Gradio, modelos y funciones Python
+- 👀 Inspecciona outputs intermedios visualmente
+- ⏪ Vuelve a ejecutar pasos individuales sin rerun de todo el pipeline
+- 💾 Persiste estado automáticamente
+- 🎨 Genera un canvas visual automáticamente
+
+**Es ideal para tu proyecto porque:**
+- Ya tienes un pipeline secuencial (Captioning → Generation)
+- Permite ver qué salida genera cada paso
+- Facilita debugging de pipelines complejos
+
+---
+
+## Instalación de UV
+
+### Windows:
+```powershell
+# Opción 1: Con pip (si ya tienes Python)
+pip install uv
+
+# Opción 2: Con winget (si tienes Windows Package Manager)
+winget install astral-sh.uv
+
+# Opción 3: Script instalador oficial
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+
+### Verificar instalación:
+```powershell
+uv --version
+```
+
+---
+
+## Migración del Proyecto
+
+### 1. **Ya creé `pyproject.toml`**
+
+Tu proyecto ahora tiene un `pyproject.toml` que reemplaza `requirements.txt` y contiene:
+- Metadata del proyecto
+- Dependencias principales (incluyendo `daggr`)
+- Configuración de UV
+
+### 2. **Crear y activar virtual environment con UV**
+
+```powershell
+# Crear venv
+uv venv
+
+# Activar (Windows)
+.venv\Scripts\Activate.ps1
+
+# O en cmd:
+.venv\Scripts\activate.bat
+```
+
+### 3. **Instalar dependencias**
+
+```powershell
+# Opción A: Instalar todas (recomendado)
+uv pip install -e ".[dev]"
+
+# Opción B: Solo lo esencial
+uv sync
+```
+
+### 4. **Modal setup (igual que antes)**
+
+```powershell
+# Instalar Modal si no está incluido
+uv pip install modal
+
+# Login en Modal
+modal token new
+
+# Deploy backend
+modal deploy modal_backend.py
+```
+
+---
+
+## Uso: 3 Opciones
+
+### **Opción 1: Mantener app.py actual (sin Daggr)**
+
+Simplemente usa uv en lugar de pip:
+
+```powershell
+uv pip install -r requirements.txt  # También funciona con UV
+# O mejor:
+uv sync
+```
+
+Luego:
+```powershell
+gradio app.py
+```
+
+---
+
+### **Opción 2: Usar Daggr (app_daggr.py)**
+
+He creado `app_daggr.py` que refactoriza tu app para usar Daggr.
+
+**Ventajas:**
+- ✅ Visualización automática del workflow
+- ✅ Inspecciona output de cada paso
+- ✅ Vuelve a ejecutar pasos individuales
+- ✅ Debug más fácil
+
+**Uso:**
+
+```powershell
+# Primero, asegúrate que Modal está deployado
+modal deploy modal_backend.py
+
+# Luego ejecuta:
+python app_daggr.py
+```
+
+Se abrirá en `http://localhost:7860` con:
+- **Node 1**: Image Converter
+- **Node 2**: Image Analysis (Caption generation)
+- **Node 3**: Artistic Prompt Engineering
+- **Node 4**: Watercolor Generation
+
+Cada nodo muestra su output y puedes reejecutar pasos individuales.
+
+---
+
+### **Opción 3: Migración Gradual**
+
+Mantén `app.py` y agrega Daggr como una capa adicional:
+
+```python
+from daggr import GradioNode, Graph
+
+# Tu app.py desplegado en Hugging Face Spaces
+acuarela_space = GradioNode(
+    "your-username/acuarela-portrait",
+    api_name="/predict",
+    inputs={"image": gr.Image()},
+    outputs={"image": gr.Image(), "text": gr.Textbox()},
+)
+
+# Puedes encadenarlo con otros nodos...
+```
+
+---
+
+## Comparativa: pip vs UV
+
+| Operación | pip | uv |
+|-----------|-----|-----|
+| Instalar paquete | `pip install package` | `uv pip install package` |
+| Requirements | `pip install -r req.txt` | `uv sync` o `uv pip install -r req.txt` |
+| Crear venv | `python -m venv .venv` | `uv venv` |
+| Velocidad | 📊 Baseline | 📊📊📊📊📊 ~100x más rápido |
+
+---
+
+## Próximos Pasos
+
+1. **Instala UV** (si no lo has hecho)
+2. **Activa el venv con UV**:
+   ```powershell
+   uv venv
+   .venv\Scripts\Activate.ps1
+   ```
+3. **Instala dependencias**:
+   ```powershell
+   uv sync
+   ```
+4. **Elige tu enfoque**:
+   - ✅ **Opción 1**: Mantén `app.py` (cambio mínimo)
+   - ✅ **Opción 2**: Usa `app_daggr.py` (máxima visibilidad)
+   - ✅ **Opción 3**: Refactoriza gradualmente
+
+5. **Deploy Modal**:
+   ```powershell
+   modal deploy modal_backend.py
+   ```
+
+6. **Ejecuta**:
+   ```powershell
+   python app.py          # Opción 1
+   # o
+   python app_daggr.py    # Opción 2
+   ```
+
+---
+
+## Recursos
+
+- 📍 [Documentación UV](https://docs.astral.sh/uv/)
+- 📍 [Documentación Daggr](https://github.com/gradio-app/daggr)
+- 📍 [Blog Daggr en HF](https://huggingface.co/blog/daggr)
+- 📍 [Modal Docs](https://modal.com/docs)
+
+---
+
+**¿Preguntas?** Revisa los ejemplos en `app_daggr.py` o la documentación oficial.

README.md

@@ -120,6 +120,44 @@ Hugging Face Space  -->  Modal Backend
 
 ## Instalación Local
 
+### Opción A: Con UV (⚡ Recomendado - 100x más rápido)
+
+```bash
+# 1. Instalar UV (Windows/Mac/Linux)
+pip install uv
+
+# 2. Clonar repositorio
+git clone <repo-url>
+cd AcuarelaPortraits
+
+# 3. Crear entorno virtual con UV
+uv venv
+
+# 4. Activar (Windows)
+.venv\Scripts\Activate.ps1
+# O en cmd: .venv\Scripts\activate.bat
+# Linux/Mac: source .venv/bin/activate
+
+# 5. Instalar dependencias
+uv sync
+# O: uv pip install -e ".[dev]"
+
+# 6. Autenticarse en Modal
+modal token new
+
+# 7. Desplegar backend en Modal
+modal deploy modal_backend.py
+
+# 8. Ejecutar aplicación (elige una opción)
+# - App original:
+python app.py
+
+# - App con Daggr (visualización del workflow):
+python app_daggr.py
+```
+
+### Opción B: Con pip (Tradicional)
+
 ```bash
 # 1. Clonar repositorio
 git clone <repo-url>
@@ -143,6 +181,23 @@ modal deploy modal_backend.py
 python app.py
 ```
 
+### 🆕 Integración con Daggr
+
+Este proyecto ahora incluye **Daggr**, una herramienta de Hugging Face para visualizar y debuggear pipelines de IA.
+
+**Características:**
+- 👀 Inspecciona el output de cada paso del pipeline
+- ⏪ Vuelve a ejecutar pasos individuales sin re-ejecutar todo
+- 📊 Canvas visual automático del workflow
+- 💾 Persiste estado automáticamente
+
+Para usar Daggr:
+```bash
+python app_daggr.py
+```
+
+Ve a `MIGRATION_UV_DAGGR.md` para más detalles.
+
 ---
 
 ## Costos Estimados

app_daggr.py

@@ -0,0 +1,205 @@
+"""
+Acuarela Portrait Generator - Refactored with Daggr
+
+This version uses Daggr to create a visual workflow that:
+- Chains the Image Captioning and Image Generation steps
+- Provides visual inspection of intermediate steps
+- Allows rerunning individual steps without re-executing the entire pipeline
+- Automatically generates a visual canvas
+
+To use this, ensure Modal backend is running:
+$ modal deploy modal_backend.py
+
+Then run:
+$ python app_daggr.py
+"""
+
+import os
+import io
+import modal
+import gradio as gr
+from PIL import Image
+import uuid
+from dotenv import load_dotenv
+
+# Import Daggr components
+from daggr import FnNode, GradioNode, InferenceNode, Graph
+
+load_dotenv()
+
+# --- Modal Setup ---
+try:
+    ImageCaptioner = modal.Cls.from_name("acuarela-portrait", "ImageCaptioner")
+    ImageGenerator = modal.Cls.from_name("acuarela-portrait", "ImageGenerator")
+    MODAL_AVAILABLE = True
+    print("✅ Modal backend conectado correctamente")
+except modal.exception.NotFoundError:
+    print("⚠️ Modal backend no desplegado. Ejecuta: modal deploy modal_backend.py")
+    MODAL_AVAILABLE = False
+except Exception as e:
+    print(f"❌ Error conectando con Modal: {e}")
+    MODAL_AVAILABLE = False
+
+
+# --- Function Nodes ---
+
+def convert_image_to_bytes(image) -> bytes:
+    """Convert PIL Image to bytes for Modal processing"""
+    if image is None:
+        return None
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='PNG')
+    return img_byte_arr.getvalue()
+
+
+def generate_caption(img_bytes: bytes) -> str:
+    """
+    Step 1: Generate image caption using Modal
+    """
+    if not MODAL_AVAILABLE or img_bytes is None:
+        raise ValueError("Modal not available or image is None")
+    
+    try:
+        captioner = ImageCaptioner()
+        caption = captioner.caption.remote(img_bytes)
+        if not caption:
+            raise ValueError("Could not generate image caption")
+        return caption
+    except Exception as e:
+        raise ValueError(f"Caption generation failed: {str(e)}")
+
+
+def create_artistic_prompt(caption: str) -> str:
+    """
+    Step 2: Engineer prompt with artistic style
+    """
+    prompt = (
+        f"digital watercolor illustration of {caption}. "
+        "semi-realistic style, clean defined outlines, solid light blue pastel background, "
+        "soft shading, vibrant clothing colors, elegant look, "
+        "smooth gradients, high quality digital art, masterpiece, character design"
+    )
+    return prompt
+
+
+def generate_watercolor_image(img_bytes: bytes, prompt: str) -> Image.Image:
+    """
+    Step 3: Generate watercolor image using Modal SDXL
+    """
+    if not MODAL_AVAILABLE or img_bytes is None:
+        raise ValueError("Modal not available or image is None")
+    
+    try:
+        negative_prompt = (
+            "photorealistic, 3d render, photograph, complex background, "
+            "white background, dark background, messy sketch, blurry, "
+            "distorted face, ugly, bad anatomy, text, watermark, signature, "
+            "over-saturated, high contrast, gloomy"
+        )
+        
+        generator = ImageGenerator()
+        result_bytes = generator.generate.remote(img_bytes, prompt, negative_prompt, strength=0.65)
+        result_image = Image.open(io.BytesIO(result_bytes))
+        return result_image
+    except Exception as e:
+        raise ValueError(f"Image generation failed: {str(e)}")
+
+
+# --- Daggr Workflow Definition ---
+
+def create_workflow():
+    """
+    Create the Daggr workflow graph
+    """
+    
+    # Node 1: Image Input (implicit - handled by Gradio interface)
+    # Node 2: Convert image to bytes
+    converter = FnNode(
+        fn=convert_image_to_bytes,
+        name="Image Converter",
+        inputs={
+            "image": gr.Image(label="Upload your photo", type="pil"),
+        },
+        outputs={
+            "return": gr.Textbox(visible=False),  # Hidden - intermediate step
+        },
+    )
+    
+    # Node 3: Generate caption
+    captioner = FnNode(
+        fn=generate_caption,
+        name="Image Analysis (BLIP Caption)",
+        inputs={
+            "img_bytes": converter.return_,
+        },
+        outputs={
+            "return": gr.Textbox(label="Generated Caption"),
+        },
+    )
+    
+    # Node 4: Create artistic prompt
+    prompt_engineer = FnNode(
+        fn=create_artistic_prompt,
+        name="Artistic Prompt Engineering",
+        inputs={
+            "caption": captioner.return_,
+        },
+        outputs={
+            "return": gr.Textbox(label="Artistic Prompt", lines=3),
+        },
+    )
+    
+    # Node 5: Generate watercolor image
+    image_generator = FnNode(
+        fn=generate_watercolor_image,
+        name="Watercolor Generation (SDXL)",
+        inputs={
+            "img_bytes": converter.return_,
+            "prompt": prompt_engineer.return_,
+        },
+        outputs={
+            "return": gr.Image(label="Watercolor Portrait"),
+        },
+    )
+    
+    # Create the graph
+    graph = Graph(
+        name="🎨 Acuarela Portrait Generator - Daggr Workflow",
+        nodes=[converter, captioner, prompt_engineer, image_generator],
+        description="Transform your photos into watercolor artworks using AI. "
+                   "Each step is visualized and can be rerun independently!",
+    )
+    
+    return graph
+
+
+# --- Alternative: Hybrid approach (Original app with Daggr integration) ---
+
+def create_hybrid_workflow():
+    """
+    Alternative: Keep the original Gradio app but add visual inspection with Daggr
+    This version uses GradioNode to reference the existing app
+    """
+    
+    # If you have deployed your existing app.py as a Gradio Space, reference it:
+    # my_space = GradioNode(
+    #     "your-username/acuarela-portrait",
+    #     api_name="/predict",
+    #     inputs={"image": gr.Image()},
+    #     outputs={"image": gr.Image(), "text": gr.Textbox()},
+    # )
+    
+    pass
+
+
+# --- Launch ---
+
+if __name__ == "__main__":
+    if MODAL_AVAILABLE:
+        print("\n🚀 Launching Daggr workflow...")
+        workflow = create_workflow()
+        workflow.launch(share=False)
+    else:
+        print("\n❌ Modal backend not available.")
+        print("First, deploy the backend with: modal deploy modal_backend.py")
+        print("Then run this script again.")

git_error.txt

@@ -0,0 +1,66 @@
+git : remote: --
+---------------------
+---------------------
+---------------------
+--------        
+En línea: 1 
+Carácter: 1
++ git push origin 
+main 2>&1 | Out-File 
+-FilePath 
+git_error.txt 
+-Encodin ...
++ ~~~~~~~~~~~~~~~~~~~
+~~~~~~
+    + CategoryInfo   
+           : NotSpe  
+  cified: (remote:   
+  --...---[    
+0m        :Strin    
+g) [], RemoteExc    
+eption
+    + FullyQualified 
+   ErrorId : Native  
+  CommandError
+ 
+remote: Your 
+push was rejected 
+because it contains 
+binary files.    
+    
+remote: Please 
+use https://huggingfa
+ce.co/docs/hub/xet 
+to store binary 
+files.        
+remote: See 
+also: https://hugging
+face.co/docs/hub/xet/
+using-xet-storage#git
+        
+remote:     
+    
+remote: 
+Offending 
+files:        
+remote:   - 
+example.png (ref: 
+refs/heads/main) 
+       
+remote: --------
+---------------------
+---------------------
+---------------------
+--        
+To https://huggingfac
+e.co/spaces/Alexramsa
+l/AcuarelaPortraits
+ ! [remote rejected] 
+main -> main 
+(pre-receive hook 
+declined)
+error: failed to 
+push some refs to 'ht
+tps://huggingface.co/
+spaces/Alexramsal/Acu
+arelaPortraits'

install.ps1

@@ -0,0 +1,83 @@
+# Acuarela Portrait - Quick Setup Script
+# Este script automatiza la instalación con UV para Windows
+
+param(
+    [switch]$SkipPython = $false,
+    [switch]$SkipModal = $false
+)
+
+Write-Host "🎨 Acuarela Portrait - Instalación con UV" -ForegroundColor Cyan
+Write-Host "============================================`n" -ForegroundColor Cyan
+
+# Check Python
+Write-Host "1️⃣  Verificando Python..." -ForegroundColor Yellow
+$pythonVersion = python --version 2>&1
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "✅ Python encontrado: $pythonVersion" -ForegroundColor Green
+} else {
+    Write-Host "❌ Python no encontrado. Instálalo desde https://python.org" -ForegroundColor Red
+    exit 1
+}
+
+# Check/Install UV
+Write-Host "`n2️⃣  Verificando UV..." -ForegroundColor Yellow
+$uvVersion = uv --version 2>&1
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "✅ UV encontrado: $uvVersion" -ForegroundColor Green
+} else {
+    Write-Host "⚠️  UV no encontrado. Instalando..." -ForegroundColor Yellow
+    pip install uv
+    $uvVersion = uv --version 2>&1
+    Write-Host "✅ UV instalado: $uvVersion" -ForegroundColor Green
+}
+
+# Create venv
+Write-Host "`n3️⃣  Creando entorno virtual..." -ForegroundColor Yellow
+if (Test-Path ".venv") {
+    Write-Host "✅ Entorno virtual ya existe" -ForegroundColor Green
+} else {
+    uv venv
+    Write-Host "✅ Entorno virtual creado" -ForegroundColor Green
+}
+
+# Activate venv
+Write-Host "`n4️⃣  Activando entorno virtual..." -ForegroundColor Yellow
+& ".\.venv\Scripts\Activate.ps1"
+Write-Host "✅ Entorno virtual activado" -ForegroundColor Green
+
+# Install dependencies
+Write-Host "`n5️⃣  Instalando dependencias..." -ForegroundColor Yellow
+uv sync
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "✅ Dependencias instaladas" -ForegroundColor Green
+} else {
+    Write-Host "❌ Error instalando dependencias" -ForegroundColor Red
+    exit 1
+}
+
+# Modal setup
+if (-not $SkipModal) {
+    Write-Host "`n6️⃣  Configurando Modal..." -ForegroundColor Yellow
+    Write-Host "Necesitas obtener tu token de Modal en: https://modal.com/settings/tokens" -ForegroundColor Cyan
+    $continue = Read-Host "¿Continuar con configuración de Modal? (y/n)"
+    
+    if ($continue -eq "y") {
+        modal token new
+        Write-Host "✅ Modal configurado" -ForegroundColor Green
+        
+        Write-Host "`n7️⃣  Deployando backend Modal..." -ForegroundColor Yellow
+        modal deploy modal_backend.py
+        Write-Host "✅ Backend deployado" -ForegroundColor Green
+    } else {
+        Write-Host "⚠️  Modal no configurado. Hazlo manualmente con: modal token new" -ForegroundColor Yellow
+    }
+} else {
+    Write-Host "`n6️⃣  Skipping Modal setup (use -SkipModal flag)" -ForegroundColor Yellow
+}
+
+Write-Host "`n✨ ¡Instalación completada!" -ForegroundColor Green
+Write-Host "`n🚀 Para ejecutar la aplicación:" -ForegroundColor Cyan
+Write-Host "   Opción 1: python app.py" -ForegroundColor White
+Write-Host "   Opción 2: python app_daggr.py (con visualización del workflow)" -ForegroundColor White
+
+Write-Host "`n📚 Para más información: lee MIGRATION_UV_DAGGR.md" -ForegroundColor Cyan

install.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# Acuarela Portrait - Quick Setup Script
+# Este script automatiza la instalación con UV para Linux/Mac
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+echo -e "${CYAN}🎨 Acuarela Portrait - Instalación con UV${NC}"
+echo -e "${CYAN}============================================\n${NC}"
+
+# Check Python
+echo -e "${YELLOW}1️⃣  Verificando Python...${NC}"
+if command -v python3 &> /dev/null; then
+    PYTHON_VERSION=$(python3 --version)
+    echo -e "${GREEN}✅ Python encontrado: $PYTHON_VERSION${NC}"
+else
+    echo -e "${RED}❌ Python no encontrado. Instálalo desde https://python.org${NC}"
+    exit 1
+fi
+
+# Check/Install UV
+echo -e "\n${YELLOW}2️⃣  Verificando UV...${NC}"
+if command -v uv &> /dev/null; then
+    UV_VERSION=$(uv --version)
+    echo -e "${GREEN}✅ UV encontrado: $UV_VERSION${NC}"
+else
+    echo -e "${YELLOW}⚠️  UV no encontrado. Instalando...${NC}"
+    pip install uv
+    UV_VERSION=$(uv --version)
+    echo -e "${GREEN}✅ UV instalado: $UV_VERSION${NC}"
+fi
+
+# Create venv
+echo -e "\n${YELLOW}3️⃣  Creando entorno virtual...${NC}"
+if [ -d ".venv" ]; then
+    echo -e "${GREEN}✅ Entorno virtual ya existe${NC}"
+else
+    uv venv
+    echo -e "${GREEN}✅ Entorno virtual creado${NC}"
+fi
+
+# Activate venv
+echo -e "\n${YELLOW}4️⃣  Activando entorno virtual...${NC}"
+source .venv/bin/activate
+echo -e "${GREEN}✅ Entorno virtual activado${NC}"
+
+# Install dependencies
+echo -e "\n${YELLOW}5️⃣  Instalando dependencias...${NC}"
+uv sync
+echo -e "${GREEN}✅ Dependencias instaladas${NC}"
+
+# Modal setup
+echo -e "\n${YELLOW}6️⃣  Configurando Modal...${NC}"
+echo -e "${CYAN}Necesitas obtener tu token de Modal en: https://modal.com/settings/tokens${NC}"
+read -p "¿Continuar con configuración de Modal? (y/n) " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    modal token new
+    echo -e "${GREEN}✅ Modal configurado${NC}"
+    
+    echo -e "\n${YELLOW}7️⃣  Deployando backend Modal...${NC}"
+    modal deploy modal_backend.py
+    echo -e "${GREEN}✅ Backend deployado${NC}"
+else
+    echo -e "${YELLOW}⚠️  Modal no configurado. Hazlo manualmente con: modal token new${NC}"
+fi
+
+echo -e "\n${GREEN}✨ ¡Instalación completada!${NC}"
+echo -e "\n${CYAN}🚀 Para ejecutar la aplicación:${NC}"
+echo -e "   Opción 1: python app.py"
+echo -e "   Opción 2: python app_daggr.py (con visualización del workflow)"
+
+echo -e "\n${CYAN}📚 Para más información: lee MIGRATION_UV_DAGGR.md${NC}"

pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "acuarela-portrait"
+version = "3.0.0"
+description = "Watercolor Portrait Generator with AI - Combines GIT Image Captioning and SDXL Image Generation"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.11"
+dependencies = [
+    "gradio==4.19.2",
+    "huggingface_hub==0.20.3",
+    "modal",
+    "typer",
+    "pillow",
+    "python-dotenv",
+    "daggr",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "black>=23.0",
+    "ruff>=0.1.0",
+]

requirements.txt

@@ -2,4 +2,5 @@ gradio==4.19.2
 huggingface_hub==0.20.3
 modal
 pillow
-python-dotenv
+python-dotenv
+daggr