Update app.py

app.py

@@ -1,194 +1,377 @@
-import json
+import logging
+from fastapi import FastAPI, UploadFile, File, HTTPException, Form, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse
+import base64
 import os
 import time
-import uuid
-import tempfile
+import jwt
+from pathlib import Path
+from typing import List
+import io
+import razorpay
+from razorpay.errors import SignatureVerificationError
+from supabase import create_client, Client
+from pydantic import BaseModel
+from typing import Optional
 from PIL import Image
-import gradio as gr
-import base64
-import mimetypes
 from io import BytesIO
 from google import genai
 
-def generate(text, images, api_key=None, model="gemini-2.5-flash-image-preview"):
-    # Initialize client using provided api_key or fallback to environment variable
-    api_key = api_key.strip() if api_key and api_key.strip() != "" else os.environ.get("GEMINI_API_KEY", "AIzaSyDL5Rilo7ptJpUOZdY6wy8PJYUcVcnDADs")
-    client = genai.Client(api_key=api_key)
-
-    # Prepare contents with images first, then text
-    contents = images + [text]
-
-    response = client.models.generate_content(
-        model=model,
-        contents=contents,
-    )
-
-    text_response = ""
-    image_path = None
-
-    for part in response.candidates[0].content.parts:
-        if part.text is not None:
-            text_response += part.text + "\n"
-        elif part.inline_data is not None:
-            # Create a temporary file to store the generated image
-            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
-                temp_path = tmp.name
-                generated_image = Image.open(BytesIO(part.inline_data.data))
-                generated_image.save(temp_path)
-                image_path = temp_path
-                print(f"Generated image saved to: {temp_path} with prompt: {text}")
-
-    return image_path, text_response
-
-def load_uploaded_images(uploaded_files):
-    """Load and display uploaded images immediately"""
-    uploaded_images = []
-    if uploaded_files:
-        for file in uploaded_files:
-            if file.name.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
-                img = Image.open(file.name)
-                if img.mode == "RGBA":
-                    img = img.convert("RGBA")
-                uploaded_images.append(img)
-    return uploaded_images
-
-def process_image_and_prompt(uploaded_files, prompt, gemini_api_key):
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(title="Gemini Image Editing API with Razorpay")
+
+# Enable CORS for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "https://hivili.web.app",
+        "http://localhost:3000",
+        "https://*.lovable.dev",
+        "https://*.sandbox.lovable.dev",
+    ],
+    allow_origin_regex=r"https://.*\.lovable\.dev|https://.*\.sandbox\.lovable\.dev",
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ===== API CONFIGURATION =====
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "AIzaSyDL5Rilo7ptJpUOZdY6wy8PJYUcVcnDADs")
+GEMINI_MODEL = "gemini-2.5-flash-image-preview"
+
+# ===== RAZORPAY CONFIGURATION =====
+RAZORPAY_KEY_ID = os.getenv("RAZORPAY_KEY_ID")
+RAZORPAY_KEY_SECRET = os.getenv("RAZORPAY_KEY_SECRET")
+razorpay_client = razorpay.Client(auth=(RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET)) if RAZORPAY_KEY_ID and RAZORPAY_KEY_SECRET else None
+
+# ===== SUPABASE CONFIGURATION =====
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY) if SUPABASE_URL and SUPABASE_KEY else None
+
+# Pydantic models for JSON input validation
+class CreateOrderRequest(BaseModel):
+    amount: int
+
+class VerifyPaymentRequest(BaseModel):
+    razorpay_order_id: str
+    razorpay_payment_id: str
+    razorpay_signature: str
+    user_id: Optional[str] = None
+
+class GenerateImageRequest(BaseModel):
+    prompt: str
+    user_id: Optional[str] = None
+
+# ===== AUTHENTICATION =====
+def generate_jwt_token():
+    """Generate JWT token for API authentication"""
+    payload = {
+        "iss": "gemini-image-editor",
+        "exp": int(time.time()) + 1800,  # 30 minutes expiration
+        "nbf": int(time.time()) - 5      # Not before 5 seconds ago
+    }
+    return jwt.encode(payload, GEMINI_API_KEY, algorithm="HS256")
+
+# ===== IMAGE PROCESSING =====
+def prepare_image_base64(image_content: bytes):
+    """Convert image bytes to base64 without prefix"""
     try:
-        input_text = prompt 
-        model = "gemini-2.5-flash-image-preview"
-        
-        # Load images from uploaded files
-        images = []
-        uploaded_images = []
-        if uploaded_files:
-            for file in uploaded_files:
-                if file.name.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
-                    img = Image.open(file.name)
-                    if img.mode == "RGBA":
-                        img = img.convert("RGBA")
-                    images.append(img)
-                    uploaded_images.append(img)
-
-        if not images:
-            raise gr.Error("Please upload at least one image", duration=5)
-
-        # Call generate with images and prompt
-        image_path, text_response = generate(text=input_text, images=images, api_key=gemini_api_key, model=model)
+        return base64.b64encode(image_content).decode('utf-8')
+    except Exception as e:
+        logger.error(f"Image processing failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Image processing failed: {str(e)}")
+
+def validate_image(image_content: bytes):
+    """Validate image meets API requirements"""
+    try:
+        size_mb = len(image_content) / (1024 * 1024)
+        if size_mb > 10:
+            raise HTTPException(status_code=400, detail="Image too large (max 10MB)")
+        img = Image.open(BytesIO(image_content))
+        if img.format.lower() not in ['png', 'jpg', 'jpeg', 'webp']:
+            raise HTTPException(status_code=400, detail="Unsupported image format. Use PNG, JPG, JPEG, or WEBP")
+        return True, ""
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Image validation error: {str(e)}")
+
+def generate_gemini_image(images: List[Image.Image], prompt: str, api_key: str):
+    """Generate or edit image using Gemini API"""
+    try:
+        client = genai.Client(api_key=api_key)
+        contents = images + [prompt]
         
+        response = client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=contents,
+        )
+
+        text_response = ""
+        image_path = None
+
+        for part in response.candidates[0].content.parts:
+            if part.text is not None:
+                text_response += part.text + "\n"
+            elif part.inline_data is not None:
+                with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+                    temp_path = tmp.name
+                    generated_image = Image.open(BytesIO(part.inline_data.data))
+                    generated_image.save(temp_path)
+                    image_path = temp_path
+                    logger.info(f"Generated image saved to: {temp_path} with prompt: {prompt}")
+
         if image_path:
-            # Load and convert the generated image if needed
-            result_img = Image.open(image_path)
-            if result_img.mode == "RGBA":
-                result_img = result_img.convert("RGBA")
-            return uploaded_images, [result_img], ""  # Return uploaded images, generated image, and empty text output
+            return image_path, ""
         else:
-            # Return uploaded images, no generated image, and the text response
-            return uploaded_images, None, text_response
+            return None, text_response.strip()
     except Exception as e:
-        raise gr.Error(f"Error: {e}", duration=5)
-
-# Build a Blocks-based interface with a custom HTML header and CSS
-with gr.Blocks(css="style.css") as demo:
-    # Custom HTML header with proper class for styling
-    gr.HTML(
-        """
-        <div class="header-container">
-          <div>
-              <img src="https://www.gstatic.com/lamda/images/gemini_favicon_f069958c85030456e93de685481c559f160ea06b.png" alt="Gemini logo">
-          </div>
-          <div>
-              <h1>Gemini for Image Editing</h1>
-              <p>Powered by <a href="https://gradio.app/">Gradio</a> | 
-              <a href="https://huggingface.co/spaces/ameerazam08/Gemini-Image-Edit?duplicate=true">Duplicate</a> this Repo |
-              <a href="https://aistudio.google.com/apikey">Get an API Key</a> | 
-              Follow me on Twitter: <a href="https://x.com/Ameerazam18">Ameerazam18</a></p>
-          </div>
-        </div>
-        """
-    )
-
-    with gr.Accordion("API Configuration", open=False, elem_classes="config-accordion"):
-        gr.Markdown("""
-        - **Issue:** Sometimes the model returns text instead of an image.  
-        ### Steps to Address:
-        1. **Duplicate the Repository**  
-           - Create a separate copy for modifications.  
-        2. **Use Your Own Gemini API Key**  
-           - You **must** configure your own Gemini key for generation!  
-        """)
-
-    with gr.Accordion("Usage Instructions", open=False, elem_classes="instructions-accordion"):
-        gr.Markdown("""
-        ### Usage  
-        - Upload an image and enter a prompt to generate outputs.
-        - If text is returned instead of an image, it will appear in the text output.
-        - Upload only PNG, JPG, JPEG, or WEBP images.
-        - **Do not use NSFW images!**
-        """)
-
-    with gr.Row(elem_classes="main-content"):
-        with gr.Column(elem_classes="input-column"):
-            image_input = gr.File(
-                file_types=["image"],
-                file_count="multiple",
-                label="Upload Images",
-                elem_id="image-input",
-                elem_classes="upload-box"
-            )
-            gemini_api_key = gr.Textbox(
-                lines=1,
-                placeholder="Enter Gemini API Key (optional)",
-                label="Gemini API Key (optional)",
-                elem_classes="api-key-input"
-            )
-            prompt_input = gr.Textbox(
-                lines=2,
-                placeholder="Enter prompt here...",
-                label="Prompt",
-                elem_classes="prompt-input"
-            )
-            submit_btn = gr.Button("Generate", elem_classes="generate-btn")
+        logger.error(f"Gemini API error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Gemini API error: {str(e)}")
+
+# ===== RAZORPAY FUNCTIONS =====
+def create_razorpay_order(amount: int):
+    """Create a Razorpay order"""
+    try:
+        if not razorpay_client:
+            raise HTTPException(status_code=500, detail="Razorpay configuration missing")
+        if amount <= 0:
+            raise ValueError("Amount must be a positive integer")
+        order_data = {
+            "amount": amount * 100,  # Convert INR to paise
+            "currency": "INR",
+            "payment_capture": 1  # Auto-capture payment
+        }
+        order = razorpay_client.order.create(data=order_data)
+        logger.info(f"Razorpay order created successfully: {order['id']}")
+        return order
+    except Exception as e:
+        logger.error(f"Failed to create Razorpay order: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to create order: {str(e)}")
+
+def verify_payment_signature(order_id: str, payment_id: str, signature: str):
+    """Verify Razorpay payment signature"""
+    try:
+        if not razorpay_client:
+            raise HTTPException(status_code=500, detail="Razorpay configuration missing")
+        params_dict = {
+            "razorpay_order_id": order_id,
+            "razorpay_payment_id": payment_id,
+            "razorpay_signature": signature
+        }
+        razorpay_client.utility.verify_payment_signature(params_dict)
+        logger.info(f"Payment signature verified successfully for order: {order_id}")
+        return True
+    except SignatureVerificationError as e:
+        logger.error(f"Payment signature verification failed: {str(e)}")
+        return False
+    except Exception as e:
+        logger.error(f"Error verifying payment signature: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Verification error: {str(e)}")
+
+# ===== MAIN PROCESSING =====
+async def generate_image(images: List[bytes], prompt: str, user_id: Optional[str] = None):
+    """Handle complete image generation workflow"""
+    # Validate images
+    for img_content in images:
+        if img_content:
+            validate_image(img_content)
+    
+    # Convert bytes to PIL Images
+    pil_images = []
+    for img_content in images:
+        try:
+            img = Image.open(BytesIO(img_content))
+            if img.mode == "RGBA":
+                img = img.convert("RGBA")
+            pil_images.append(img)
+        except Exception as e:
+            logger.error(f"Image conversion failed: {str(e)}")
+            raise HTTPException(status_code=400, detail=f"Image conversion failed: {str(e)}")
+
+    if len(pil_images) < 1:
+        raise HTTPException(status_code=400, detail="At least one image required")
+
+    # Check user premium status if Supabase is configured
+    if user_id and supabase:
+        try:
+            user_data = supabase.table("users").select("is_premium").eq("user_id", user_id).execute()
+            if not user_data.data or not user_data.data[0].get("is_premium"):
+                raise HTTPException(status_code=403, detail="Premium subscription required")
+        except Exception as e:
+            logger.error(f"Supabase user check failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"User verification failed: {str(e)}")
+
+    # Generate image using Gemini API
+    image_path, text_response = generate_gemini_image(pil_images, prompt, GEMINI_API_KEY)
+
+    if image_path:
+        return image_path
+    else:
+        raise HTTPException(status_code=500, detail=f"Image generation failed: {text_response or 'Unknown error'}")
+
+# ===== API ENDPOINTS =====
+@app.post("/generate")
+async def generate_image_endpoint(
+    prompt: str = Form(...),
+    images: List[UploadFile] = File(...),
+    user_id: Optional[str] = Form(None)
+):
+    """Endpoint to generate or edit an image using Gemini API"""
+    try:
+        if len(images) < 1:
+            raise HTTPException(status_code=400, detail="At least one image required")
+        if len(images) > 4:
+            raise HTTPException(status_code=400, detail="Maximum 4 images allowed")
+
+        image_contents = [await image.read() for image in images]
+        output_path = await generate_image(image_contents, prompt, user_id)
+
+        return FileResponse(
+            path=output_path,
+            media_type="image/png",
+            filename=f"gemini_output_{Path(output_path).stem}.png"
+        )
+    except HTTPException as e:
+        raise
+    except Exception as e:
+        logger.error(f"Error in /generate: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/create-razorpay-order")
+async def create_order_endpoint(
+    request: Request,
+    amount: Optional[int] = Form(None),
+    body: Optional[CreateOrderRequest] = None
+):
+    """Create a Razorpay order (supports form-data and JSON)"""
+    logger.info("Received create order request")
+    
+    try:
+        if not razorpay_client:
+            raise HTTPException(status_code=500, detail="Razorpay configuration missing")
         
-        with gr.Column(elem_classes="output-column"):
-            uploaded_gallery = gr.Gallery(label="Uploaded Images", elem_classes="uploaded-gallery")
-            output_gallery = gr.Gallery(label="Generated Outputs", elem_classes="output-gallery")
-            output_text = gr.Textbox(
-                label="Gemini Output", 
-                placeholder="Text response will appear here if no image is generated.",
-                elem_classes="output-text"
+        # Handle JSON body if provided
+        if body and body.amount:
+            amount = body.amount
+        elif not amount:
+            try:
+                json_body = await request.json()
+                amount = json_body.get('amount')
+            except:
+                pass
+                
+        if not amount or amount <= 0:
+            raise HTTPException(status_code=422, detail="Missing or invalid 'amount' parameter")
+
+        logger.info(f"Creating order with amount: {amount}")
+        order = create_razorpay_order(amount)
+        
+        response_data = {
+            "id": order["id"],
+            "amount": order["amount"],
+            "currency": order["currency"],
+            "key_id": RAZORPAY_KEY_ID
+        }
+        
+        logger.info(f"Order created successfully: {order['id']}")
+        return JSONResponse(content=response_data)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating order: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to create order: {str(e)}")
+
+@app.post("/verify-razorpay-payment")
+async def verify_payment_endpoint(
+    request: Request,
+    razorpay_order_id: Optional[str] = Form(None),
+    razorpay_payment_id: Optional[str] = Form(None),
+    razorpay_signature: Optional[str] = Form(None),
+    user_id: Optional[str] = Form(None),
+    body: Optional[VerifyPaymentRequest] = None
+):
+    """Verify Razorpay payment signature (supports form-data and JSON)"""
+    logger.info("Received payment verification request")
+    
+    try:
+        # Handle JSON body if provided
+        if body:
+            razorpay_order_id = razorpay_order_id or body.razorpay_order_id
+            razorpay_payment_id = razorpay_payment_id or body.razorpay_payment_id
+            razorpay_signature = razorpay_signature or body.razorpay_signature
+            user_id = user_id or body.user_id
+        else:
+            try:
+                json_body = await request.json()
+                razorpay_order_id = razorpay_order_id or json_body.get('razorpay_order_id')
+                razorpay_payment_id = razorpay_payment_id or json_body.get('razorpay_payment_id')
+                razorpay_signature = razorpay_signature or json_body.get('razorpay_signature')
+                user_id = user_id or json_body.get('user_id')
+            except:
+                pass
+
+        # Validate required fields
+        if not all([razorpay_order_id, razorpay_payment_id, razorpay_signature]):
+            missing_fields = []
+            if not razorpay_order_id: missing_fields.append("razorpay_order_id")
+            if not razorpay_payment_id: missing_fields.append("razorpay_payment_id")
+            if not razorpay_signature: missing_fields.append("razorpay_signature")
+            
+            logger.error(f"Missing required fields: {missing_fields}")
+            raise HTTPException(
+                status_code=422, 
+                detail=f"Missing required fields: {', '.join(missing_fields)}"
             )
 
-    # Set up the interaction with three outputs
-    submit_btn.click(
-        fn=process_image_and_prompt,
-        inputs=[image_input, prompt_input, gemini_api_key],
-        outputs=[uploaded_gallery, output_gallery, output_text],
-    )
-
-    # Update uploaded gallery immediately when files are uploaded
-    image_input.upload(
-        fn=load_uploaded_images,
-        inputs=[image_input],
-        outputs=[uploaded_gallery],
-    )
-
-    gr.Markdown("## Try these examples", elem_classes="gr-examples-header")
-
-    examples = [
-        ["data/1.webp", 'change text to "AMEER"'],
-        ["data/2.webp", "remove the spoon from hand only"],
-        ["data/3.webp", 'change text to "Make it "'],
-        ["data/1.jpg", "add joker style only on face"],
-        ["data/1777043.jpg", "add joker style only on face"],
-        ["data/2807615.jpg", "add lipstick on lip only"],
-        ["data/76860.jpg", "add lipstick on lip only"],
-        ["data/2807615.jpg", "make it happy looking face only"],
-    ]
-
-    gr.Examples(
-        examples=examples,
-        inputs=[image_input, prompt_input],
-        elem_id="examples-grid"
-    )
-
-demo.queue(max_size=50).launch(mcp_server=True, share=True)
+        logger.info(f"Verifying payment for order_id: {razorpay_order_id}")
+        is_valid = verify_payment_signature(razorpay_order_id, razorpay_payment_id, razorpay_signature)
+        
+        if is_valid:
+            if user_id and supabase:
+                logger.info(f"Updating Supabase for user_id: {user_id}")
+                try:
+                    supabase.table("users").update({"is_premium": True}).eq("user_id", user_id).execute()
+                    logger.info(f"Successfully updated premium status for user: {user_id}")
+                except Exception as e:
+                    logger.error(f"Failed to update Supabase: {str(e)}")
+            
+            return JSONResponse(content={"success": True, "message": "Payment verified successfully"})
+        else:
+            logger.warning(f"Payment verification failed for order: {razorpay_order_id}")
+            return JSONResponse(content={"success": False, "message": "Payment verification failed"}, status_code=400)
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error verifying payment: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Verification error: {str(e)}")
+
+@app.get("/")
+async def index():
+    return {
+        "status": "Gemini Image Editing API with Razorpay is running",
+        "endpoints": {
+            "generate": "POST /generate",
+            "create_order": "POST /create-razorpay-order",
+            "verify_payment": "POST /verify-razorpay-payment"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "razorpay_configured": bool(RAZORPAY_KEY_ID and RAZORPAY_KEY_SECRET),
+        "supabase_configured": bool(SUPABASE_URL and SUPABASE_KEY),
+        "gemini_configured": bool(GEMINI_API_KEY)
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)