chore: fix metadata propertoes for HF Inference Endpoint

README.md

@@ -7,6 +7,7 @@ tags:
   - text-to-image
   - diffusers
   - huggingface-inference-endpoints
+  - custom-inference
 pipeline_tag: text-to-image
 inference: true
 ---
@@ -129,10 +130,20 @@ Response format from the local server:
 3. Click "Create a new endpoint"
 4. Configure your endpoint with the following settings:
    - Name: Give your endpoint a name
+   - Region: Choose a region close to your users (e.g., us-east-1)
    - Instance Type: Choose a GPU instance (recommended: at least 16GB VRAM for SDXL)
    - Replicas: Start with 1 replica
    - Autoscaling: Configure as needed
-5. Click "Create endpoint"
+
+   **IMPORTANT: IF YOU SEE THIS WARNING**:
+   > "Warning: deploying this model will probably fail because the model's Diffusers pipeline is not set"
+   
+   5. Click "Continue anyway" - this is expected because you're using a custom handler implementation
+   6. Under Advanced configuration:
+      - Make sure "Framework" is set to "Custom"
+      - Configure "Task" as "Text-to-Image"
+   
+7. Click "Create endpoint"
 
 The Hugging Face Inference Endpoints service will automatically detect and use your `EndpointHandler` class in the `handler.py` file.
 
@@ -203,4 +214,52 @@ The local server uses the FastAPI implementation included in `handler.py` that p
 
 ## License
 
-This project is licensed under the terms of the MIT license. 
+This project is licensed under the terms of the MIT license.
+
+## Testing Your Inference Endpoint
+
+We've included a test script `test_endpoint.py` to help you test your deployed endpoint.
+
+### Prerequisites
+- Python 3.7+
+- Your Hugging Face API token
+- An active Hugging Face Inference Endpoint
+
+### Installation
+```bash
+pip install requests pillow
+```
+
+### Usage
+```bash
+python test_endpoint.py --token "YOUR_HF_API_TOKEN" --url "YOUR_ENDPOINT_URL" --prompt "your test prompt here"
+```
+
+#### Additional Options
+```
+--negative_prompt TEXT     Negative prompt to guide generation
+--seed INTEGER             Random seed for reproducibility
+--steps INTEGER            Number of inference steps (default: 30)
+--guidance FLOAT           Guidance scale (default: 7.0)
+--width INTEGER            Image width (default: 1024)
+--height INTEGER           Image height (default: 768)
+--output_dir TEXT          Directory to save generated images (default: "generated_images")
+```
+
+#### Example
+```bash
+python test_endpoint.py \
+  --token "hf_..." \
+  --url "https://api-inference.huggingface.co/models/username/your-repo-name" \
+  --prompt "beautiful sunset over mountains" \
+  --negative_prompt "blurry, low quality" \
+  --seed 42 \
+  --steps 30 \
+  --guidance 7.5
+```
+
+This will:
+1. Send a request to your endpoint
+2. Download the generated image
+3. Save it to the specified output directory
+4. Display the seed used for generation 

api-inference/config.json

@@ -0,0 +1,5 @@
+{
+  "framework": "custom",
+  "task": "text-to-image",
+  "custom_handler": "handler:EndpointHandler"
+} 

model-index.json

@@ -0,0 +1,18 @@
+{
+  "_class_name": "CustomInferenceAPI",
+  "task": "text-to-image",
+  "widget": {
+    "input_template": {
+      "inputs": "beautiful landscape with mountains",
+      "parameters": {
+        "negative_prompt": "blurry, low quality",
+        "seed": 42,
+        "inference_steps": 30,
+        "guidance_scale": 7,
+        "width": 1024,
+        "height": 768
+      }
+    },
+    "output_widget": "Base64ImageOutput"
+  }
+} 

test_endpoint.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# This script demonstrates how to test your Hugging Face Inference Endpoint
+# Replace the API_TOKEN and API_URL with your actual values
+
+import requests
+import json
+import base64
+from PIL import Image
+import io
+import argparse
+import os
+
+def test_inference_endpoint(api_token, api_url, prompt, negative_prompt=None, 
+                            seed=None, inference_steps=30, guidance_scale=7,
+                            width=1024, height=768, output_dir="generated_images"):
+    """
+    Test a Hugging Face Inference Endpoint for image generation.
+    
+    Args:
+        api_token (str): Your Hugging Face API token
+        api_url (str): The URL of your inference endpoint
+        prompt (str): The text prompt for image generation
+        negative_prompt (str, optional): Negative prompt to guide generation
+        seed (int, optional): Random seed for reproducibility
+        inference_steps (int): Number of inference steps
+        guidance_scale (float): Guidance scale for generation
+        width (int): Image width
+        height (int): Image height
+        output_dir (str): Directory to save generated images
+    """
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Headers for the request
+    headers = {
+        "Authorization": f"Bearer {api_token}",
+        "Content-Type": "application/json"
+    }
+    
+    # Build parameters dictionary with provided values
+    parameters = {
+        "width": width,
+        "height": height,
+        "inference_steps": inference_steps,
+        "guidance_scale": guidance_scale
+    }
+    
+    # Add optional parameters if provided
+    if negative_prompt:
+        parameters["negative_prompt"] = negative_prompt
+    if seed:
+        parameters["seed"] = seed
+    
+    # Request payload
+    payload = {
+        "inputs": prompt,
+        "parameters": parameters
+    }
+    
+    print(f"Sending request to {api_url}...")
+    print(f"Prompt: '{prompt}'")
+    
+    try:
+        # Send the request
+        response = requests.post(api_url, headers=headers, json=payload)
+        
+        # Check for errors
+        if response.status_code != 200:
+            print(f"Error: {response.status_code} - {response.text}")
+            return
+        
+        # Parse the response
+        result = response.json()
+        
+        # Check for error in the response
+        if isinstance(result, dict) and "error" in result:
+            print(f"API Error: {result['error']}")
+            return
+        
+        # Extract the generated image and seed
+        if isinstance(result, list) and len(result) > 0:
+            item = result[0]
+            if "generated_image" in item:
+                # Convert the base64-encoded image to a PIL Image
+                image_bytes = base64.b64decode(item["generated_image"])
+                image = Image.open(io.BytesIO(image_bytes))
+                
+                # Create a filename based on the prompt and seed
+                used_seed = item.get("seed", "unknown_seed")
+                filename = f"{output_dir}/generated_{used_seed}.png"
+                
+                # Save the image
+                image.save(filename)
+                print(f"Image saved to {filename}")
+                print(f"Seed: {used_seed}")
+                
+                return image
+            else:
+                print("Response doesn't contain 'generated_image' field")
+        else:
+            print("Unexpected response format:", result)
+    
+    except Exception as e:
+        print(f"Error: {str(e)}")
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Test Hugging Face Inference Endpoints for image generation")
+    parser.add_argument("--token", required=True, help="Your Hugging Face API token")
+    parser.add_argument("--url", required=True, help="URL of your inference endpoint")
+    parser.add_argument("--prompt", required=True, help="Text prompt for image generation")
+    parser.add_argument("--negative_prompt", help="Negative prompt")
+    parser.add_argument("--seed", type=int, help="Random seed for reproducibility")
+    parser.add_argument("--steps", type=int, default=30, help="Number of inference steps")
+    parser.add_argument("--guidance", type=float, default=7, help="Guidance scale")
+    parser.add_argument("--width", type=int, default=1024, help="Image width")
+    parser.add_argument("--height", type=int, default=768, help="Image height")
+    parser.add_argument("--output_dir", default="generated_images", help="Directory to save generated images")
+    
+    args = parser.parse_args()
+    
+    # Call the test function with provided arguments
+    test_inference_endpoint(
+        api_token=args.token,
+        api_url=args.url,
+        prompt=args.prompt,
+        negative_prompt=args.negative_prompt,
+        seed=args.seed,
+        inference_steps=args.steps,
+        guidance_scale=args.guidance,
+        width=args.width,
+        height=args.height,
+        output_dir=args.output_dir
+    )