Update app.py

app.py

@@ -1,5 +1,3 @@
-# --- START OF FILE app.py ---
-
 import json
 import os
 import time
@@ -13,190 +11,134 @@ import mimetypes
 from google import genai
 from google.genai import types
 
-# --- IMPORTANT SECURITY UPDATE ---
-# API Key is now loaded from an environment variable for security.
-# DO NOT hardcode your API key here.
-# Set it in your terminal before running:
-# export GEMINI_API_KEY="YOUR_API_KEY" (for Linux/macOS)
-# set GEMINI_API_KEY=YOUR_API_KEY (for Windows)
-
-GEMINI_API_KEY = os.getenv("AIzaSyCrhWiAEQmCidtE2QZw3CTiLt7F8yv5M7A")
-
-# Check if the API key is available
-if not GEMINI_API_KEY:
-    raise ValueError("AIzaSyCrhWiAEQmCidtE2QZw3CTiLt7F8yv5M7A")
-
-# Configure the genai library with the API key
-genai.configure(api_key=AIzaSyCrhWiAEQmCidtE2QZw3CTiLt7F8yv5M7A)
-
+# Aapki Gemini API Key yahan daal di gayi hai.
+GEMINI_API_KEY = "AIzaSyCrhWiAEQmCidtE2QZw3CTiLt7F8yv5M7A"
 
 def save_binary_file(file_name, data):
-    """Saves binary data to a file."""
     with open(file_name, "wb") as f:
         f.write(data)
 
-def generate(text, file_name, model="gemini-1.5-flash-latest"):
-    """
-    Generates content using the Gemini model by uploading a file.
-    """
-    # Using the globally configured API key.
-    client = genai.GenerativeModel(model_name=model)
+def generate(text, file_name, model="gemini-2.0-flash-exp"):
+    # Client ko hardcoded API key se initialize karein.
+    client = genai.Client(api_key=GEMINI_API_KEY)
     
-    print(f"Uploading file: {file_name}")
-    # The new File API for gemini-1.5-flash expects a different upload method
-    uploaded_file = genai.upload_file(path=file_name)
-
-    # Wait for the file to be processed
-    while uploaded_file.state.name == "PROCESSING":
-        print('.', end='')
-        time.sleep(2)
-        uploaded_file = genai.get_file(uploaded_file.name)
-
-    if uploaded_file.state.name == "FAILED":
-        raise ValueError(f"File upload failed: {uploaded_file.state}")
-
-    print(f"\nFile uploaded successfully: {uploaded_file.uri}")
+    files = [
+        client.files.upload(file=file_name),
+    ]
 
-    # Create the prompt content
     contents = [
-        uploaded_file,
-        text
+        types.Content(
+            role="user",
+            parts=[
+                types.Part.from_uri(
+                    file_uri=files[0].uri,
+                    mime_type=files[0].mime_type,
+                ),
+                types.Part.from_text(text=text),
+            ],
+        ),
     ]
-
-    generation_config = types.GenerationConfig(
+    generate_content_config = types.GenerateContentConfig(
         temperature=1,
         top_p=0.95,
         top_k=40,
         max_output_tokens=8192,
-    )
-    
-    # Generate content
-    response = client.generate_content(
-        contents,
-        generation_config=generation_config
+        response_modalities=[
+            "image",
+            "text",
+        ],
+        response_mime_type="text/plain",
     )
 
-    # Process the response to extract the generated image
-    output_image_path = None
-    if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
-        for part in response.candidates[0].content.parts:
-            # The edited image is returned as a blob
-            if part.blob:
-                if 'image' in part.blob.mime_type:
-                    # Save the image to a temporary file
-                    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
-                        tmp.write(part.blob.data)
-                        output_image_path = tmp.name
-                    print(
-                        f"Image of mime type {part.blob.mime_type} saved to: {output_image_path}"
-                    )
-                    break # Exit after finding the first image
-            # Sometimes the response might be text (e.g., if it can't fulfill the request)
-            elif part.text:
-                print(f"Model returned text: {part.text}")
-
-
-    if output_image_path is None:
-         # In case the model did not return an image, we can return the original to avoid an error
-         print("Warning: Model did not return an image. Returning the original.")
-         return file_name # Return original image path
-
-    return output_image_path
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+        temp_path = tmp.name
+        for chunk in client.models.generate_content_stream(
+            model=model,
+            contents=contents,
+            config=generate_content_config,
+        ):
+            if not chunk.candidates or not chunk.candidates[0].content or not chunk.candidates[0].content.parts:
+                continue
+            inline_data = chunk.candidates[0].content.parts[0].inline_data
+            if inline_data:
+                save_binary_file(temp_path, inline_data.data)
+                print(
+                    "File of mime type "
+                    f"{inline_data.mime_type} saved to: {temp_path} and prompt input :{text}"
+                )
+            else:
+                print(chunk.text)
 
+    del files
+    return temp_path
+ 
 
 def process_image_and_prompt(composite_pil, prompt):
-    """
-    Saves the input PIL image to a temporary file and calls the generation function.
-    """
-    if composite_pil is None:
-        raise gr.Error("Please upload an image.")
-    if not prompt:
-        raise gr.Error("Please enter a prompt.")
-
     # Save the composite image to a temporary file.
     with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
         composite_path = tmp.name
-        # Convert to RGB to ensure compatibility
-        if composite_pil.mode == "RGBA":
-            composite_pil = composite_pil.convert("RGB")
-        composite_pil.save(composite_path, "PNG")
+        composite_pil.save(composite_path)
 
     file_name = composite_path  
     input_text = prompt 
-    # Updated model name to a stable public version
-    model = "gemini-1.5-flash-latest"
-
-    edited_image_path = generate(text=input_text, file_name=file_name, model=model)
-    
-    if not edited_image_path or not os.path.exists(edited_image_path):
-        raise gr.Error("Failed to generate the image. The model might not have returned an image for this prompt.")
-    
-    print("Generated image path:", edited_image_path)
-    result_img = Image.open(edited_image_path)
-    
-    # Clean up temporary files
-    os.remove(composite_path)
-    if edited_image_path != composite_path: # Don't delete twice
-        os.remove(edited_image_path)
+    model = "gemini-2.0-flash-exp" 
 
+    gemma_edited_image_path = generate(text=input_text, file_name=file_name, model=model)
+    print("image_path ", gemma_edited_image_path)
+    result_img = Image.open(gemma_edited_image_path)
+    if result_img.mode == "RGBA":
+        result_img = result_img.convert("RGB")
     return [result_img]
 
-
-# Build a Blocks-based interface with an improved and cleaner UI/UX.
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    # A clean title and description for the application.
-    gr.Markdown(
-    """
-    <div style='text-align: center;'>
-        <h1>Gemini AI Image Editor</h1>
-        <p>Upload an image and provide a prompt to edit it. Let's see what you can create!</p>
-    </div>
-    """
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1): # Input column
-             with gr.Box():
-                image_input = gr.Image(
-                    type="pil",
-                    label="Upload Image",
-                    height=350
-                )
-                prompt_input = gr.Textbox(
-                    lines=3,
-                    placeholder="e.g., 'make the sky purple', 'add a superhero cape', 'remove the car'...",
-                    label="Editing Instruction (Prompt)"
-                )
-                submit_btn = gr.Button("Generate Image", variant="primary")
-
-        with gr.Column(scale=2): # Output column (wider for better viewing)
-            output_gallery = gr.Gallery(label="Generated Image", height=500, object_fit="contain")
+# Build a Blocks-based interface.
+with gr.Blocks() as demo:
+    # Yahan se HTML Header हटा दिया गया है।
 
     # Define examples to be shown within the Gradio interface
     examples = [
+        # Each example is a list corresponding to the inputs:
+        # [Input Image, Prompt]
         ["data/1.webp", 'change text to "AMEER"'],
-        ["data/2.webp", "remove the spoon from her hand"],
-        ["data/3.webp", 'change the text to "Make It"'],
-        ["data/1777043.jpg", "add joker style makeup to his face"],
-        ["data/2807615.jpg", "add red lipstick on her lips only"],
-        ["data/2807615.jpg", "make her look happier"],
+        ["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],
-        outputs=output_gallery,
-        fn=process_image_and_prompt,
-        cache_examples=False, # Set to True if example images are large and you want to speed up demos
-        label="Try these examples"
-    )
+    gr.Markdown("## Gen AI Image Editing\nUpload an image and enter a prompt to generate outputs in the gallery. Do not Use NFSW Images")
 
-    # Set up the button's click event.
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(
+                type="pil",
+                label="Upload Image",
+                image_mode="RGBA"
+            )
+            # API Key Textbox ko yahan se hata diya gaya hai
+            prompt_input = gr.Textbox(
+                lines=2,
+                placeholder="Enter prompt here...",
+                label="Prompt"
+            )
+            submit_btn = gr.Button("Generate")
+        with gr.Column():
+            output_gallery = gr.Gallery(label="Generated Outputs")
+
+    # Set up the interaction.
     submit_btn.click(
         fn=process_image_and_prompt,
-        inputs=[image_input, prompt_input],
+        inputs=[image_input, prompt_input], # Inputs se API key hata di gayi hai
         outputs=output_gallery,
+ 
+    )
+    gr.Examples(
+        examples=examples,
+        inputs=[image_input, prompt_input], # Inputs se API key hata di gayi hai
+        label="Try these examples"
     )
 
-# Launch the Gradio app
-demo.launch(share=True, debug=True)
+demo.launch(share=True)