Delete app.py

app.py

@@ -1,169 +0,0 @@
-import os
-import gradio as gr
-from io import BytesIO
-from PIL import Image, ImageDraw, ImageFont, ImageColor
-import json
-from google import genai
-from google.genai.types import GenerateContentConfig, GoogleSearch, Tool
-
-# Initialize GenAI Client
-API_KEY = os.getenv("GOOGLE_API_KEY")  # Set your API key in the environment variables
-client = genai.Client(api_key=API_KEY)
-MODEL_ID = "gemini-2.0-flash-exp"
-
-bounding_box_system_instructions = """
-    Identify objects in the image related to maternity or baby products.
-    Return bounding boxes as a JSON array with labels. Limit to 25 objects.
-    Label objects with clear and descriptive names, including unique characteristics.
-"""
-
-# Helper functions
-def parse_json(json_output):
-    """
-    Parse JSON output from the Gemini model.
-    """
-    lines = json_output.splitlines()
-    for i, line in enumerate(lines):
-        if line == "```json":
-            json_output = "\n".join(lines[i + 1:])
-            json_output = json_output.split("```")[0]
-            break
-    return json_output
-
-def plot_bounding_boxes(image, bounding_boxes):
-    """
-    Draw bounding boxes with labels on the image.
-    """
-    im = image.copy()
-    width, height = im.size
-    draw = ImageDraw.Draw(im)
-    colors = ['red', 'green', 'blue', 'yellow', 'orange', 'pink', 'purple', 'cyan'] + [
-        colorname for (colorname, _) in ImageColor.colormap.items()
-    ]
-    font = ImageFont.load_default()
-
-    try:
-        bounding_boxes_json = json.loads(bounding_boxes)
-        for i, bounding_box in enumerate(bounding_boxes_json):
-            color = colors[i % len(colors)]
-            abs_y1 = int(bounding_box["box_2d"][0] / 1000 * height)
-            abs_x1 = int(bounding_box["box_2d"][1] / 1000 * width)
-            abs_y2 = int(bounding_box["box_2d"][2] / 1000 * height)
-            abs_x2 = int(bounding_box["box_2d"][3] / 1000 * width)
-
-            if abs_x1 > abs_x2:
-                abs_x1, abs_x2 = abs_x2, abs_x1
-            if abs_y1 > abs_y2:
-                abs_y1, abs_y2 = abs_y2, abs_y1
-
-            # Draw the box and label
-            draw.rectangle(((abs_x1, abs_y1), (abs_x2, abs_y2)), outline=color, width=4)
-            if "label" in bounding_box:
-                draw.text((abs_x1 + 8, abs_y1 + 6), bounding_box["label"], fill=color, font=font)
-    except Exception as e:
-        print(f"Error drawing bounding boxes: {e}")
-
-    return im
-
-def predict_bounding_boxes(image, prompt):
-    """
-    Generate bounding boxes for the input image.
-    """
-    try:
-        # Resize image and prepare for input
-        image = image.resize((1024, int(1024 * image.height / image.width)))
-        buffered = BytesIO()
-        image.save(buffered, format="JPEG")
-        image_bytes = buffered.getvalue()
-
-        # Request bounding box predictions
-        response = client.models.generate_content(
-            model=MODEL_ID,
-            contents=[prompt, image_bytes],
-            config=GenerateContentConfig(system_instruction=bounding_box_system_instructions)
-        )
-        bounding_boxes = parse_json(response.text)
-        if not bounding_boxes:
-            raise ValueError("No bounding boxes returned.")
-
-        result_image = plot_bounding_boxes(image, bounding_boxes)
-        return result_image, bounding_boxes
-    except Exception as e:
-        return image, f"Error: {e}"
-
-def google_search_query(question, grounding_image=None):
-    """
-    Generate responses with Google search grounding.
-    """
-    try:
-        # Configure Google Search grounding
-        tools = [Tool(google_search=GoogleSearch())]
-        contents = [question]
-        
-        # If an image grounding is available, include it
-        if grounding_image:
-            contents.append(grounding_image)
-
-        response = client.models.generate_content(
-            model=MODEL_ID,
-            contents=contents,
-            config=GenerateContentConfig(tools=tools)
-        )
-        grounded_response = response.candidates[0].text
-        return grounded_response
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-# Gradio Interface
-with gr.Blocks(theme=gr.themes.Glass(secondary_hue="blue")) as app:
-    gr.Markdown("# Maternity & Baby Product Assistance")
-    
-    with gr.Tab("Image + Chat"):
-        gr.Markdown("### Upload an image and chat about the products identified in it.")
-        with gr.Row():
-            input_image = gr.Image(type="pil", label="Upload Image")
-            input_prompt = gr.Textbox(label="Describe what to identify", placeholder="Example: Identify baby products.")
-            submit_bbox = gr.Button("Generate Bounding Boxes")
-        with gr.Row():
-            output_image = gr.Image(type="pil", label="Output Image with Bounding Boxes")
-            output_json = gr.Textbox(label="Bounding Boxes JSON")
-        submit_bbox.click(
-            fn=predict_bounding_boxes,
-            inputs=[input_image, input_prompt],
-            outputs=[output_image, output_json]
-        )
-        gr.Markdown("### Chat about the products.")
-        with gr.Row():
-            image_chatbox = gr.Chatbot(label="Image-based Chat")
-            image_question = gr.Textbox(lines=2, label="Ask a Question about the Image")
-            submit_image_chat = gr.Button("Chat")
-        def chat_with_image(image_question, chat_log, output_json):
-            grounded_response = google_search_query(image_question, grounding_image=output_json)
-            chat_log.append(("You", image_question))
-            chat_log.append(("AI", grounded_response))
-            return chat_log
-        submit_image_chat.click(
-            fn=chat_with_image,
-            inputs=[image_question, image_chatbox, output_json],
-            outputs=[image_chatbox]
-        )
-
-    with gr.Tab("Chat Only"):
-        gr.Markdown("### Ask any questions about maternity or baby products.")
-        with gr.Row():
-            chatbot = gr.Chatbot(label="Chat Responses")
-        with gr.Row():
-            question_input = gr.Textbox(lines=2, label="Ask a Question", placeholder="Example: What are the best baby strollers?")
-            submit_chat = gr.Button("Chat")
-        def chat_without_image(question, chat_log):
-            grounded_response = google_search_query(question)
-            chat_log.append(("You", question))
-            chat_log.append(("AI", grounded_response))
-            return chat_log
-        submit_chat.click(
-            fn=chat_without_image,
-            inputs=[question_input, chatbot],
-            outputs=[chatbot]
-        )
-
-app.launch()