initial copy

.env.example

@@ -0,0 +1,10 @@
+# Hugging Face token
+HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxx
+
+# API settings
+API_HOST=0.0.0.0
+API_PORT=8000
+
+# Gradio settings
+GRADIO_HOST=0.0.0.0
+GRADIO_PORT=7860

.gitignore

@@ -0,0 +1,3 @@
+.venv
+*.pyc
+__pycache__

Project.md

@@ -0,0 +1,46 @@
+# Diffusion Models App
+
+A Python application that uses Hugging Face inference endpoints for text-to-image and image-to-image generation with a Gradio UI and API endpoints.
+
+## Features
+
+- Text-to-image generation
+- Image-to-image transformation with optional prompt
+- Gradio UI for interactive use
+- API endpoints for integration with other applications
+- Configurable models via text input
+
+## Project Structure
+
+- `main.py` - Entry point that can run both UI and API
+- `app.py` - Gradio UI implementation
+- `api.py` - FastAPI server for API endpoints
+- `inference.py` - Core functionality for HF inference
+- `config.py` - Configuration and settings
+- `requirements.txt` - Dependencies
+
+## Setup & Usage
+
+1. Clone the repository
+2. Create a .env file with your Hugging Face token (copy from .env.example)
+3. Install dependencies: `pip install -r requirements.txt`
+4. Run the application: `python main.py`
+
+## Running Options
+
+- Run both UI and API: `python main.py`
+- Run only the API: `python main.py --mode api`
+- Run only the UI: `python main.py --mode ui`
+
+## API Endpoints
+
+- `POST /text-to-image` - Generate an image from text
+- `POST /image-to-image` - Transform an image with optional prompt
+
+## Environment Variables
+
+- `HF_TOKEN` - Your Hugging Face API token
+- `API_HOST` - Host for the API server (default: 0.0.0.0)
+- `API_PORT` - Port for the API server (default: 8000)
+- `GRADIO_HOST` - Host for the Gradio UI (default: 0.0.0.0)
+- `GRADIO_PORT` - Port for the Gradio UI (default: 7860)

api.py

@@ -0,0 +1,98 @@
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi.responses import Response
+from PIL import Image
+import io
+import uvicorn
+import config
+from inference import DiffusionInference
+
+app = FastAPI(title="Diffusion Models API")
+
+# Initialize the inference class
+inference = DiffusionInference()
+
+@app.get("/")
+async def root():
+    return {"message": "Diffusion Models API is running"}
+
+@app.post("/text-to-image")
+async def text_to_image(
+    prompt: str = Form(...),
+    model: str = Form(None),
+    negative_prompt: str = Form(None),
+    guidance_scale: float = Form(7.5),
+    num_inference_steps: int = Form(50)
+):
+    """
+    Generate an image from a text prompt
+    """
+    try:
+        # Use default model if not specified
+        if not model:
+            model = config.DEFAULT_TEXT2IMG_MODEL
+            
+        # Call the inference module
+        image = inference.text_to_image(
+            prompt=prompt,
+            model_name=model,
+            negative_prompt=negative_prompt,
+            guidance_scale=guidance_scale,
+            num_inference_steps=num_inference_steps
+        )
+        
+        # Convert PIL image to bytes
+        img_byte_arr = io.BytesIO()
+        image.save(img_byte_arr, format='PNG')
+        img_byte_arr = img_byte_arr.getvalue()
+        
+        return Response(content=img_byte_arr, media_type="image/png")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/image-to-image")
+async def image_to_image(
+    image: UploadFile = File(...),
+    prompt: str = Form(None),
+    model: str = Form(None),
+    negative_prompt: str = Form(None),
+    guidance_scale: float = Form(7.5),
+    num_inference_steps: int = Form(50)
+):
+    """
+    Generate a new image from an input image and optional prompt
+    """
+    try:
+        # Read and convert input image
+        contents = await image.read()
+        input_image = Image.open(io.BytesIO(contents))
+        
+        # Use default model if not specified
+        if not model:
+            model = config.DEFAULT_IMG2IMG_MODEL
+            
+        # Call the inference module
+        result = inference.image_to_image(
+            image=input_image,
+            prompt=prompt,
+            model_name=model,
+            negative_prompt=negative_prompt,
+            guidance_scale=guidance_scale,
+            num_inference_steps=num_inference_steps
+        )
+        
+        # Convert PIL image to bytes
+        img_byte_arr = io.BytesIO()
+        result.save(img_byte_arr, format='PNG')
+        img_byte_arr = img_byte_arr.getvalue()
+        
+        return Response(content=img_byte_arr, media_type="image/png")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "api:app",
+        host=config.API_HOST,
+        port=config.API_PORT,
+        reload=True
+    )

api_example.py

@@ -0,0 +1,88 @@
+import requests
+import io
+from PIL import Image
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Hugging Face API token (need to set in .env or environment)
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+# API base URL
+API_BASE = "http://localhost:8000"
+
+def text_to_image(prompt, model=None, negative_prompt=None):
+    """
+    Generate image from text using the API
+    """
+    url = f"{API_BASE}/text-to-image"
+    
+    # Prepare form data
+    data = {
+        "prompt": prompt,
+    }
+    
+    if model:
+        data["model"] = model
+    
+    if negative_prompt:
+        data["negative_prompt"] = negative_prompt
+    
+    # Make API request
+    response = requests.post(url, data=data)
+    
+    if response.status_code == 200:
+        # Convert response to PIL image
+        image = Image.open(io.BytesIO(response.content))
+        return image
+    else:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+        return None
+
+def image_to_image(image_path, prompt=None, model=None):
+    """
+    Transform image using the API
+    """
+    url = f"{API_BASE}/image-to-image"
+    
+    # Prepare form data and files
+    data = {}
+    if prompt:
+        data["prompt"] = prompt
+    
+    if model:
+        data["model"] = model
+    
+    files = {
+        "image": open(image_path, "rb")
+    }
+    
+    # Make API request
+    response = requests.post(url, data=data, files=files)
+    
+    if response.status_code == 200:
+        # Convert response to PIL image
+        image = Image.open(io.BytesIO(response.content))
+        return image
+    else:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+        return None
+
+if __name__ == "__main__":
+    # Example usage
+    print("Text to Image example:")
+    image = text_to_image("A beautiful mountain landscape at sunset")
+    if image:
+        image.save("text2img_output.png")
+        print("Image saved as text2img_output.png")
+    
+    print("Image to Image example (requires an input image):")
+    # Uncomment and modify path to run:
+    # result = image_to_image("input.png", "Turn this into a fantasy scene")
+    # if result:
+    #     result.save("img2img_output.png")
+    #     print("Image saved as img2img_output.png")

app.py

@@ -0,0 +1,100 @@
+import gradio as gr
+import config
+from inference import DiffusionInference
+from PIL import Image
+import io
+
+# Initialize the inference class
+inference = DiffusionInference()
+
+def text_to_image_fn(prompt, model, negative_prompt=None, guidance_scale=7.5, num_inference_steps=50):
+    """
+    Handle text to image generation request
+    """
+    try:
+        if not model:
+            model = config.DEFAULT_TEXT2IMG_MODEL
+            
+        # Call the inference module
+        image = inference.text_to_image(
+            prompt=prompt,
+            model_name=model,
+            negative_prompt=negative_prompt,
+            guidance_scale=guidance_scale,
+            num_inference_steps=num_inference_steps
+        )
+        
+        return image, None
+    except Exception as e:
+        return None, str(e)
+
+def image_to_image_fn(image, prompt, model, negative_prompt=None, guidance_scale=7.5, num_inference_steps=50):
+    """
+    Handle image to image transformation request
+    """
+    try:
+        if not model:
+            model = config.DEFAULT_IMG2IMG_MODEL
+            
+        # Call the inference module
+        result = inference.image_to_image(
+            image=image,
+            prompt=prompt,
+            model_name=model,
+            negative_prompt=negative_prompt,
+            guidance_scale=guidance_scale,
+            num_inference_steps=num_inference_steps
+        )
+        
+        return result, None
+    except Exception as e:
+        return None, str(e)
+
+# Create Gradio UI
+with gr.Blocks(title="Diffusion Models") as app:
+    gr.Markdown("# Hugging Face Diffusion Models")
+    
+    with gr.Tab("Text to Image"):
+        with gr.Row():
+            with gr.Column():
+                txt2img_prompt = gr.Textbox(label="Prompt", placeholder="Enter your prompt here...")
+                txt2img_negative = gr.Textbox(label="Negative Prompt (Optional)", placeholder="What to exclude from the image")
+                txt2img_model = gr.Textbox(label="Model", placeholder=f"Enter model name (default: {config.DEFAULT_TEXT2IMG_MODEL})")
+                txt2img_guidance = gr.Slider(minimum=1.0, maximum=20.0, value=7.5, step=0.5, label="Guidance Scale")
+                txt2img_steps = gr.Slider(minimum=10, maximum=100, value=50, step=1, label="Inference Steps")
+                txt2img_button = gr.Button("Generate Image")
+            
+            with gr.Column():
+                txt2img_output = gr.Image(type="pil", label="Generated Image")
+                txt2img_error = gr.Textbox(label="Error", visible=True)
+        
+        txt2img_button.click(
+            fn=text_to_image_fn,
+            inputs=[txt2img_prompt, txt2img_model, txt2img_negative, txt2img_guidance, txt2img_steps],
+            outputs=[txt2img_output, txt2img_error]
+        )
+    
+    with gr.Tab("Image to Image"):
+        with gr.Row():
+            with gr.Column():
+                img2img_input = gr.Image(type="pil", label="Input Image")
+                img2img_prompt = gr.Textbox(label="Prompt", placeholder="Enter your prompt here...")
+                img2img_negative = gr.Textbox(label="Negative Prompt (Optional)", placeholder="What to exclude from the image")
+                img2img_model = gr.Textbox(label="Model", placeholder=f"Enter model name (default: {config.DEFAULT_IMG2IMG_MODEL})")
+                img2img_guidance = gr.Slider(minimum=1.0, maximum=20.0, value=7.5, step=0.5, label="Guidance Scale")
+                img2img_steps = gr.Slider(minimum=10, maximum=100, value=50, step=1, label="Inference Steps")
+                img2img_button = gr.Button("Transform Image")
+            
+            with gr.Column():
+                img2img_output = gr.Image(type="pil", label="Generated Image")
+                img2img_error = gr.Textbox(label="Error", visible=True)
+        
+        img2img_button.click(
+            fn=image_to_image_fn,
+            inputs=[img2img_input, img2img_prompt, img2img_model, img2img_negative, img2img_guidance, img2img_steps],
+            outputs=[img2img_output, img2img_error]
+        )
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    app.launch(server_name=config.GRADIO_HOST, server_port=config.GRADIO_PORT)

config.py

@@ -0,0 +1,22 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Hugging Face API token
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+
+# Default model for text to image
+DEFAULT_TEXT2IMG_MODEL = "stabilityai/stable-diffusion-2-1"
+
+# Default model for image to image
+DEFAULT_IMG2IMG_MODEL = "lllyasviel/sd-controlnet-depth"
+
+# API settings
+API_HOST = os.getenv("API_HOST", "0.0.0.0")
+API_PORT = int(os.getenv("API_PORT", "8000"))
+
+# Gradio settings
+GRADIO_HOST = os.getenv("GRADIO_HOST", "0.0.0.0")
+GRADIO_PORT = int(os.getenv("GRADIO_PORT", "7860"))

inference.py

@@ -0,0 +1,86 @@
+from huggingface_hub import InferenceClient
+from PIL import Image
+import io
+import config
+
+
+class DiffusionInference:
+    def __init__(self, api_key=None):
+        """
+        Initialize the inference client with the Hugging Face API token.
+        """
+        self.api_key = api_key or config.HF_TOKEN
+        self.client = InferenceClient(
+            provider="hf-inference",
+            api_key=self.api_key,
+        )
+
+    def text_to_image(self, prompt, model_name=None, negative_prompt=None, **kwargs):
+        """
+        Generate an image from a text prompt.
+        
+        Args:
+            prompt (str): The text prompt to guide image generation
+            model_name (str, optional): The model to use for inference
+            negative_prompt (str, optional): What not to include in the image
+            **kwargs: Additional parameters to pass to the model
+            
+        Returns:
+            PIL.Image: The generated image
+        """
+        model = model_name or config.DEFAULT_TEXT2IMG_MODEL
+        
+        # Set up parameters dictionary
+        params = {"prompt": prompt}
+        
+        if negative_prompt:
+            params["negative_prompt"] = negative_prompt
+            
+        # Add any additional parameters
+        params.update(kwargs)
+        
+        try:
+            image = self.client.text_to_image(model=model, **params)
+            return image
+        except Exception as e:
+            print(f"Error generating image: {e}")
+            raise
+
+    def image_to_image(self, image, prompt=None, model_name=None, negative_prompt=None, **kwargs):
+        """
+        Generate a new image from an input image and optional prompt.
+        
+        Args:
+            image (PIL.Image or str): Input image or path to image
+            prompt (str, optional): Text prompt to guide the transformation
+            model_name (str, optional): The model to use for inference
+            negative_prompt (str, optional): What not to include in the image
+            **kwargs: Additional parameters to pass to the model
+            
+        Returns:
+            PIL.Image: The generated image
+        """
+        model = model_name or config.DEFAULT_IMG2IMG_MODEL
+        
+        # Convert image path to PIL Image if needed
+        if isinstance(image, str):
+            image = Image.open(image)
+            
+        # Set up parameters dictionary
+        params = {"image": image}
+        
+        if prompt:
+            params["prompt"] = prompt
+            
+        if negative_prompt:
+            params["negative_prompt"] = negative_prompt
+            
+        # Add any additional parameters
+        params.update(kwargs)
+        
+        try:
+            result = self.client.image_to_image(model=model, **params)
+            return result
+        except Exception as e:
+            print(f"Error transforming image: {e}")
+            raise

main.py

@@ -0,0 +1,63 @@
+import argparse
+import uvicorn
+import threading
+import os
+import config
+from app import app as gradio_app
+from api import app as api_app
+
+def run_api():
+    """Run the FastAPI server"""
+    uvicorn.run(
+        api_app, 
+        host=config.API_HOST, 
+        port=config.API_PORT
+    )
+
+def run_gradio():
+    """Run the Gradio interface"""
+    gradio_app.launch(
+        server_name=config.GRADIO_HOST, 
+        server_port=config.GRADIO_PORT,
+        share=False
+    )
+
+def main():
+    parser = argparse.ArgumentParser(description="Run Diffusion Models App")
+    parser.add_argument(
+        "--mode", 
+        type=str, 
+        default="all", 
+        choices=["all", "api", "ui"],
+        help="Which component to run: 'all' (default), 'api', or 'ui'"
+    )
+    
+    args = parser.parse_args()
+    
+    # Check if HF_TOKEN is set
+    if not config.HF_TOKEN:
+        print("Warning: HF_TOKEN environment variable is not set. Please set it for API access.")
+        print("You can create a .env file with HF_TOKEN=your_token or set it in your environment.")
+    
+    if args.mode == "all":
+        # Run both API and UI in separate threads
+        api_thread = threading.Thread(target=run_api)
+        api_thread.daemon = True
+        api_thread.start()
+        
+        print(f"API server running at http://{config.API_HOST}:{config.API_PORT}")
+        print(f"Starting Gradio UI at http://{config.GRADIO_HOST}:{config.GRADIO_PORT}")
+        
+        # Run Gradio in the main thread
+        run_gradio()
+    
+    elif args.mode == "api":
+        print(f"Starting API server at http://{config.API_HOST}:{config.API_PORT}")
+        run_api()
+    
+    elif args.mode == "ui":
+        print(f"Starting Gradio UI at http://{config.GRADIO_HOST}:{config.GRADIO_PORT}")
+        run_gradio()
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+huggingface_hub
+Pillow
+fastapi
+uvicorn
+python-dotenv

spaces_config.json

@@ -0,0 +1,23 @@
+{
+  "sdk": "gradio",
+  "sdk_version": "3.50.2",
+  "app_file": "app.py",
+  "models": [
+    {
+      "model_name": "stabilityai/stable-diffusion-2-1",
+      "model_class": "diffusers"
+    },
+    {
+      "model_name": "lllyasviel/sd-controlnet-depth",
+      "model_class": "diffusers"
+    }
+  ],
+  "resources": {
+    "accelerator": "gpu",
+    "gpu": {
+      "count": 1,
+      "vendor": "nvidia",
+      "memory": "16GB"
+    }
+  }
+}