Update app.py

app.py

@@ -11,6 +11,36 @@ import base64
 # Set up Replicate API key from environment variable
 os.environ['REPLICATE_API_TOKEN'] = os.getenv('REPLICATE_API_TOKEN')
 
+def upload_to_imgur(image):
+    """
+    Upload image to Imgur and return URL
+    Alternative: You can use other services like Cloudinary, imgbb, etc.
+    """
+    import base64
+    import json
+    
+    # Convert PIL image to base64
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")
+    img_base64 = base64.b64encode(buffered.getvalue()).decode()
+    
+    # Imgur API (anonymous upload)
+    headers = {
+        'Authorization': 'Client-ID 0d90e8a3e7d8b4e'  # Public client ID for anonymous uploads
+    }
+    
+    response = requests.post(
+        'https://api.imgur.com/3/image',
+        headers=headers,
+        data={'image': img_base64}
+    )
+    
+    if response.status_code == 200:
+        data = response.json()
+        return data['data']['link']
+    else:
+        raise Exception(f"Failed to upload to Imgur: {response.status_code}")
+
 def process_images(prompt, image1, image2=None):
     """
     Process uploaded images with Replicate API
@@ -23,39 +53,39 @@ def process_images(prompt, image1, image2=None):
         return None, "⚠️ Please set REPLICATE_API_TOKEN environment variable"
     
     try:
-        import tempfile
-        from replicate.client import Client
-        
-        # Initialize Replicate client
-        client = Client(api_token=os.getenv('REPLICATE_API_TOKEN'))
+        status_message = "📤 Uploading images..."
         
-        # Upload images to get URLs
-        # Replicate needs actual URLs, so we need to upload the images first
+        # Upload images to get public URLs
         image_urls = []
         
-        # Save and create file handles for upload
-        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp1:
-            image1.save(tmp1.name, 'PNG')
-            # Upload to Replicate (this creates a temporary URL)
-            with open(tmp1.name, 'rb') as f:
-                file_url = client.upload(f)
-                image_urls.append(file_url)
-            os.unlink(tmp1.name)
-        
-        if image2:
-            with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp2:
-                image2.save(tmp2.name, 'PNG')
-                with open(tmp2.name, 'rb') as f:
-                    file_url = client.upload(f)
-                    image_urls.append(file_url)
-                os.unlink(tmp2.name)
+        try:
+            # Try to upload to Imgur (or your preferred service)
+            url1 = upload_to_imgur(image1)
+            image_urls.append(url1)
+            
+            if image2:
+                url2 = upload_to_imgur(image2)
+                image_urls.append(url2)
+                
+        except Exception as upload_error:
+            # Fallback: Convert to base64 data URIs
+            buffered1 = BytesIO()
+            image1.save(buffered1, format="PNG")
+            img_base64_1 = base64.b64encode(buffered1.getvalue()).decode()
+            image_urls.append(f"data:image/png;base64,{img_base64_1}")
+            
+            if image2:
+                buffered2 = BytesIO()
+                image2.save(buffered2, format="PNG")
+                img_base64_2 = base64.b64encode(buffered2.getvalue()).decode()
+                image_urls.append(f"data:image/png;base64,{img_base64_2}")
         
-        status_message = "🎨 Processing your images with nano-banana model..."
+        status_message = "🎨 Processing with nano-banana model..."
         
-        # Prepare input matching the exact format
+        # Prepare input matching the exact format from your example
         input_data = {
             "prompt": prompt,
-            "image_input": image_urls  # List of URLs
+            "image_input": image_urls
         }
         
         # Run the model
@@ -64,40 +94,49 @@ def process_images(prompt, image1, image2=None):
             input=input_data
         )
         
-        # Handle the output based on the reference code
+        # Handle various output formats
         output_url = None
         
-        # The output object should have a url() method based on your example
+        # Check different possible output formats
         if hasattr(output, 'url'):
             output_url = output.url()
         elif isinstance(output, str):
             output_url = output
         elif isinstance(output, list) and len(output) > 0:
             output_url = output[0]
+        elif hasattr(output, '__iter__'):
+            try:
+                for item in output:
+                    if isinstance(item, str) and item.startswith('http'):
+                        output_url = item
+                        break
+            except:
+                pass
         
         if not output_url:
-            return None, "❌ Error: No image URL found in response"
+            return None, f"❌ Error: No valid output URL found. Response type: {type(output)}"
         
         # Download the generated image
-        # Based on your example, we can also use output.read() if available
         if hasattr(output, 'read'):
+            # If output has a read method, use it
             img_data = output.read()
             img = Image.open(BytesIO(img_data))
         else:
-            # Fallback to downloading from URL
+            # Otherwise, download from URL
             response = requests.get(output_url)
             if response.status_code == 200:
                 img = Image.open(BytesIO(response.content))
             else:
                 return None, f"❌ Error: Failed to download image (Status: {response.status_code})"
         
-        return img, "✅ Image generated successfully with nano-banana!"
+        return img, f"✅ Image generated successfully! Output URL: {output_url[:50]}..."
         
+    except replicate.exceptions.ModelError as e:
+        return None, f"❌ Model Error: {str(e)}\n\nMake sure 'google/nano-banana' exists and is accessible."
     except Exception as e:
-        # If the model doesn't exist or other errors, provide helpful message
         error_msg = str(e)
         if "not found" in error_msg.lower():
-            return None, "❌ Model 'google/nano-banana' not found. Please check if the model exists on Replicate."
+            return None, "❌ Model 'google/nano-banana' not found. Please check:\n1. Model name is correct\n2. Model is public or you have access\n3. Try format: 'owner/model-name'"
         elif "authentication" in error_msg.lower():
             return None, "❌ Authentication failed. Please check your REPLICATE_API_TOKEN."
         else:
@@ -242,15 +281,17 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
        pip install gradio replicate pillow requests
        ```
     
-    3. **Model Information:**
-       - Using: `google/nano-banana` model
-       - Input: `prompt` (text) and `image_input` (list of image URLs)
-       - Output: Generated image based on the style transfer
+    3. **Image Hosting Options:**
+       - **Option A**: Uses Imgur for free image hosting (default)
+       - **Option B**: Falls back to base64 data URIs if upload fails
+       - **Option C**: Use your own image hosting service (Cloudinary, S3, etc.)
     
-    4. **Note:** 
-       - The model requires actual URLs for images
-       - Images are temporarily uploaded to Replicate's servers
-       - Check if 'google/nano-banana' is available on your Replicate account
+    4. **Model Notes:**
+       - Using: `google/nano-banana` model
+       - If this model doesn't exist, try:
+         - `stability-ai/stable-diffusion`
+         - `pharmapsychotic/clip-interrogator`
+         - Check available models at: https://replicate.com/explore
     
     ### 🔒 Security:
     - API keys are managed through environment variables