Update app.py

app.py

@@ -1,16 +1,15 @@
 # -*- coding: utf-8 -*-
-"""Complete_3_model_code.ipynb
+"""Flipkart Frontend.ipynb
 
 Automatically generated by Colab.
 
 Original file is located at
-    https://colab.research.google.com/drive/1Ivlv1jHXwoldi9Mb-quvDBlCNeIIAhc9
+    https://colab.research.google.com/github/Abhinav-gh/404NotFound/blob/main/Flipkart%20Frontend.ipynb
 
 # 1. Install Gradio and Required Libraries
 ### Start by installing Gradio if it's not already installed.
 """
 
-
 """# 2. Import Libraries
 ### Getting all the necessary Libraries
 """
@@ -24,9 +23,7 @@ import time
 from ultralytics import YOLO
 import pandas as pd
 from collections import defaultdict, deque
-import matplotlib.pyplot as plt
 import torch
-from PIL import Image
 from torchvision import transforms, models, datasets, transforms
 from torch.utils.data import DataLoader
 import torch.nn as nn
@@ -35,19 +32,28 @@ import google.generativeai as genai
 from datetime import datetime
 from paddleocr import PaddleOCR
 import os
+import re
 
-"""# 3. Import Drive
+"""# Path Variables
 
+### Path used in OCR
 """
 
-# from google.colab import drive
-# drive.mount('/content/drive')
+# OCR_M3="best.pt"
+GOOGLE_API_KEY = os.getenv("GEMINI_API")
+# GEMINI_MODEL = 'models/gemini-1.5-flash'
+
+
+# Brand_Recognition_Model ='kitkat_s.pt'
+# annotatedOpFile= 'annotated_output.mp4'
 
 """# 4. Brand Recognition Backend
 
-### Image uploading for Grocery detection
+### Model for Grocery Detection
 """
 
+"""### Image uploading for Grocery detection"""
+
 def detect_grocery_items(image):
     model = YOLO('kitkat_s.pt')
     image = np.array(image)[:, :, ::-1]
@@ -223,36 +229,55 @@ def annotate_video(input_video):
 Run these 3 cells before trying out any model
 """
 
-# Function to draw bounding boxes and show text
-def draw_bounding_boxes(image_path):
-    # Read the image
-    img = Image.open(image_path)
-    result = ocr.ocr(image_path, cls=True)  # Get the OCR result
+def new_draw_bounding_boxes(image):
+    """Draw bounding boxes around detected text in the image and display it."""
+    try:
+        # Check the input type and load the image
+        if isinstance(image, str):
+            img = Image.open(image)
+            np_img = np.array(img)  # Convert to NumPy array
+            print("[DEBUG] Loaded image from file path.")
+        elif isinstance(image, Image.Image):
+            np_img = np.array(image)  # Convert PIL Image to NumPy array
+            print("[DEBUG] Converted PIL Image to NumPy array.")
+        else:
+            raise ValueError("Input must be a file path or a PIL Image object.")
 
-    # Create a figure to display the image
-    plt.figure(figsize=(10, 10))
-    plt.imshow(img)
-    ax = plt.gca()
-    all_text_data = []
-    # Iterate through the results and draw boxes
-    for idx, line in enumerate(result[0]):
-        box = line[0]  # Get the bounding box coordinates
-        text = line[1][0]  # Extracted text
-        print(f"[DEBUG] Box {idx + 1}: {text}")  # Display text with box number
-        all_text_data.append(f"{text}")
+        # Perform OCR on the array
+        ocr_result = ocr.ocr(np_img, cls=True)  # Ensure this line is error-free
+        print("[DEBUG] OCR Result:\n", ocr_result)
 
-        # Draw the bounding box
-        polygon = plt.Polygon(box, fill=None, edgecolor='red', linewidth=2)
-        ax.add_patch(polygon)
-        # Add text label in the box
-        # ax.text(box[0][0], box[0][1] - 5, f"{idx + 1}: {text}", color='blue', fontsize=12)
+        # Create a figure to display the image
+        plt.figure(figsize=(10, 10))
+        plt.imshow(image)
+        ax = plt.gca()
+        all_text_data = []
 
-    plt.axis('off')  # Hide axes
-    plt.show()
-    return all_text_data
+        # Iterate through the OCR results and draw boxes
+        for idx, line in enumerate(ocr_result[0]):
+            box = line[0]  # Get the bounding box coordinates
+            text = line[1][0]  # Extracted text
+            print(f"[DEBUG] Box {idx + 1}: {text}")  # Debug print
+            all_text_data.append(text)
+
+            # Draw the bounding box
+            polygon = plt.Polygon(box, fill=None, edgecolor='red', linewidth=2)
+            ax.add_patch(polygon)
+
+            # Add text label with a small offset for visibility
+            x, y = box[0][0], box[0][1]
+            ax.text(x, y - 5, f"{idx + 1}: {text}", color='blue', fontsize=12, ha='left')
+
+        plt.axis('off')  # Hide axes
+        plt.title("Detected Text with Bounding Boxes", fontsize=16)  # Add a title
+        plt.show()
+
+        return all_text_data
+
+    except Exception as e:
+        print(f"[ERROR] Error in new_draw_bounding_boxes: {e}")
+        return []
 
-# Set your API key securely (store it in Colab’s userdata)
-GOOGLE_API_KEY= os.getenv("GEMINI_API")
 genai.configure(api_key=GOOGLE_API_KEY)
 
 def gemini_context_correction(text):
@@ -265,14 +290,14 @@ def gemini_context_correction(text):
         f"The text may contain noise or unclear information. If only one date is provided, assume it is the Expiration Date. "
         f"Additionally, extract the MRP (e.g., 'MRP: ₹99.00', 'Rs. 99/-'). "
         f"Format the output as:\n"
-        f"Manufacturing Date: <MFG Date>\n"
-        f"Expiration Date: <EXP Date>\n"
-        f"MRP: <MRP Value>\n\n"
+        f"Manufacturing Date: <MFG Date> Expiration Date: <EXP Date> MRP: <MRP Value>"
         f"Here is the text: {text}"
     )
 
     return response.text
 
+
+
 def validate_dates_with_gemini(mfg_date, exp_date):
     """Use Gemini API to validate and correct the manufacturing and expiration dates."""
     model = genai.GenerativeModel('models/gemini-1.5-flash')
@@ -295,55 +320,6 @@ def validate_dates_with_gemini(mfg_date, exp_date):
     return "Invalid response from Gemini API."
 
 
-def extract_and_validate_with_gemini(refined_text):
-    """
-    Use Gemini API to extract, validate, and correct manufacturing and expiration dates.
-    """
-    model = genai.GenerativeModel('models/gemini-1.5-flash')
-
-    # Correctly call the generate_content method
-    response = model.generate_content(
-         f"The extracted text is:\n'{refined_text}'\n\n"
-        f"1. Extract the 'Manufacturing Date' and 'Expiration Date' from the above text. "
-        f"Ignore unrelated data (e.g., 'MRP: Not Found').\n"
-        f"2. If a date is missing or invalid, return -1 for that date.\n"
-        f"3. If the 'Expiration Date' is earlier than the 'Manufacturing Date', swap them.\n"
-        f"4. Ensure both dates are in 'dd/mm/yyyy' format. If the original dates are not in this format, convert them.\n"
-        f"Respond ONLY in this exact format:\n"
-        f"Manufacturing Date: <MFG Date>, Expiration Date: <EXP Date>"
-    )
-    print("[DEBUG] Response from validation function", response)
-    # Ensure the response object is valid and contains the required parts
-    if hasattr(response, 'parts') and response.parts:
-        final_dates = response.parts[0].text.strip()
-        print(f"[DEBUG] Gemini Response: {final_dates}")
-
-        # Extract the dates from the response
-        mfg_date_str, exp_date_str = parse_gemini_response(final_dates)
-
-        # Process and swap if necessary
-        if mfg_date_str != "-1" and exp_date_str != "-1":
-            mfg_date = datetime.strptime(mfg_date_str, "%Y/%m/%d")
-            exp_date = datetime.strptime(exp_date_str, "%Y/%m/%d")
-
-            # Swap if Expiration Date is earlier than Manufacturing Date
-            if exp_date < mfg_date:
-                print("[DEBUG] Swapping dates.")
-                mfg_date, exp_date = exp_date, mfg_date
-
-            # Return the formatted swapped dates
-            return (
-                f"Manufacturing Date: {mfg_date.strftime('%Y/%m/%d')}, "
-                f"Expiration Date: {exp_date.strftime('%Y/%m/%d')}"
-            )
-
-        # If either date is -1, return them as-is
-        return final_dates
-
-    # Handle invalid responses gracefully
-    print("[ERROR] Invalid response from Gemini API.")
-    return "Invalid response from Gemini API."
-
 def extract_and_validate_with_gemini(refined_text):
     """
     Use Gemini API to extract, validate, correct, and swap dates in 'yyyy/mm/dd' format if necessary.
@@ -353,13 +329,18 @@ def extract_and_validate_with_gemini(refined_text):
     # Generate content using Gemini with the refined prompt
     response = model.generate_content(
         f"The extracted text is:\n'{refined_text}'\n\n"
-        f"1. Extract the 'Manufacturing Date' and 'Expiration Date' from the above text. "
-        f"Ignore unrelated data (e.g., 'MRP: Not Found').\n"
-        f"2. If a date is missing or invalid, return -1 for that date.\n"
+        f"1. Extract the 'Manufacturing Date', 'Expiration Date', and 'MRP' from the above text. "
+        f"Ignore unrelated data.\n"
+        f"2. If a date or MRP is missing or invalid, return -1 for that field.\n"
         f"3. If the 'Expiration Date' is earlier than the 'Manufacturing Date', swap them.\n"
-        f"4. Ensure both dates are in 'dd/mm/yyyy' format. If the original dates are not in this format, convert them.\n"
+        f"4. Ensure both dates are in 'dd/mm/yyyy' format. If the original dates are not in this format, convert them. "
+        f"However, if the dates are in 'mm/yyyy' format (without a day), leave them as is and return in 'mm/yyyy' format. "
+        f"If the dates do not have a day, return them in 'mm/yyyy' format.\n"
+        f"5. MRP should be returned in the format 'INR <amount>'. If not found or invalid, return 'INR -1'.\n"
         f"Respond ONLY in this exact format:\n"
-        f"Manufacturing Date: <MFG Date>, Expiration Date: <EXP Date>"
+        f"Manufacturing Date: <MFG Date>\n"
+        f"Expiration Date: <EXP Date>\n"
+        f"MRP: <MRP>"
     )
 
     # Validate the response and extract dates
@@ -368,12 +349,13 @@ def extract_and_validate_with_gemini(refined_text):
         print(f"[DEBUG] Gemini Response: {final_dates}")
 
         # Extract the dates from the response
-        mfg_date_str, exp_date_str = parse_gemini_response(final_dates)
+        mfg_date_str, exp_date_str, mrp_str = parse_gemini_response(final_dates)
 
         # Process and swap if necessary
         if mfg_date_str != "-1" and exp_date_str != "-1":
-            mfg_date = datetime.strptime(mfg_date_str, "%d/%m/%Y")
-            exp_date = datetime.strptime(exp_date_str, "%d/%m/%Y")
+            # Handle dates with possible 'mm/yyyy' format
+            mfg_date = parse_date(mfg_date_str)
+            exp_date = parse_date(exp_date_str)
 
             # Swap if Expiration Date is earlier than Manufacturing Date
             swapping_statement = ""
@@ -384,8 +366,9 @@ def extract_and_validate_with_gemini(refined_text):
 
             # Return the formatted swapped dates
             return swapping_statement + (
-                f"Manufacturing Date: {mfg_date.strftime('%d/%m/%Y')}, "
-                f"Expiration Date: {exp_date.strftime('%d/%m/%Y')}"
+                f"Manufacturing Date: {format_date(mfg_date)}, "
+                f"Expiration Date: {format_date(exp_date)}\n"
+                f"MRP: {mrp_str}"
             )
 
         # If either date is -1, return them as-is
@@ -400,14 +383,32 @@ def parse_gemini_response(response_text):
     Helper function to extract Manufacturing Date and Expiration Date from the response text.
     """
     try:
-        # Split and extract the dates
+        # Split and extract the dates and MRP
         parts = response_text.split(", ")
         mfg_date_str = parts[0].split(": ")[1].strip()
         exp_date_str = parts[1].split(": ")[1].strip()
-        return mfg_date_str, exp_date_str
+        mrp_str = parts[2].split(": ")[1].strip() if len(parts) > 2 else "INR -1"  # Extract MRP
+        return mfg_date_str, exp_date_str, mrp_str
     except IndexError:
         print("[ERROR] Failed to parse Gemini response.")
-        return "-1", "-1"
+        return "-1", "-1", "INR -1"
+
+def parse_date(date_str):
+    """Parse date string to datetime object considering possible formats."""
+    if '/' in date_str:  # If the date has slashes, we can parse it
+        parts = date_str.split('/')
+        if len(parts) == 3:  # dd/mm/yyyy
+            return datetime.strptime(date_str, "%d/%m/%Y")
+        elif len(parts) == 2:  # mm/yyyy
+            return datetime.strptime(date_str, "%m/%Y")
+    return datetime.strptime(date_str, "%d/%m/%Y")  # Default fallback
+
+def format_date(date):
+    """Format date back to string."""
+    if date.day == 1:  # If day is defaulted to 1, return in mm/yyyy format
+        return date.strftime('%m/%Y')
+    return date.strftime('%d/%m/%Y')
+
 
 def extract_date(refined_text, date_type):
     """Extract the specified date type from the refined text."""
@@ -422,6 +423,37 @@ def extract_date(refined_text, date_type):
             return '-1'  # Return -1 if the date is not found
     return '-1'  # Return -1 if the date type is not in the text
 
+def extract_details_from_validated_output(validated_output):
+    """Extract manufacturing date, expiration date, and MRP from the validated output."""
+    # Pattern to match the specified format exactly
+    pattern = (
+        r"Manufacturing Date:\s*([\d\/]+)\s*"
+        r"Expiration Date:\s*([\d\/]+)\s*"
+        r"MRP:\s*INR\s*([\d\.]+)"
+    )
+
+    print("[DEBUG] Validated Output:", validated_output)  # Debug print for input
+
+    match = re.search(pattern, validated_output)
+
+    if match:
+        mfg_date = match.group(1)  # Extract Manufacturing Date
+        exp_date = match.group(2)   # Extract Expiration Date
+        mrp = f"INR {match.group(3)}"  # Extract MRP with INR prefix
+
+        print("[DEBUG] Extracted Manufacturing Date:", mfg_date)  # Debug print for extracted values
+        print("[DEBUG] Extracted Expiration Date:", exp_date)
+        print("[DEBUG] Extracted MRP:", mrp)
+    else:
+        print("[ERROR] No match found for the specified pattern.")  # Debug print for errors
+        mfg_date, exp_date, mrp = "Not Found", "Not Found", "INR -1"
+
+    return [
+        ["Manufacturing Date", mfg_date],
+        ["Expiration Date", exp_date],
+        ["MRP", mrp]
+    ]
+
 """### **Model 3**
 Using Yolov8 x-large model trained till about 75 epochs
 and
@@ -430,11 +462,6 @@ Gradio as user interface
 
 """
 
-model = YOLO('best.pt')
-"""## Driver code to be run after selecting from Model 2 or 3.
-(Note: not needed for model 1)
-"""
-
 def new_draw_bounding_boxes(image):
     """Draw bounding boxes around detected text in the image and display it."""
     # If the input is a string (file path), open the image
@@ -475,10 +502,13 @@ def new_draw_bounding_boxes(image):
 
     return all_text_data
 
+
 # Initialize PaddleOCR
 ocr = PaddleOCR(use_angle_cls=True, lang='en')
 
 def detect_and_ocr(image):
+    model = YOLO('best.pt')
+
     """Detect objects using YOLO, draw bounding boxes, and perform OCR."""
     # Convert input image from PIL to OpenCV format
     image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
@@ -542,31 +572,61 @@ def further_processing(image, previous_result_text):
 
 def handle_processing(validated_output):
     """Decide whether to proceed with further processing."""
-    # Extract the manufacturing and expiration dates from the string
+    # Extract the manufacturing date, expiration date, and MRP from the string
     try:
-        mfg_date_str = validated_output.split("Manufacturing Date: ")[1].split(",")[0].strip()
-        exp_date_str = validated_output.split("Expiration Date: ")[1].strip()
+        mfg_date_str = validated_output.split("Manufacturing Date: ")[1].split("\n")[0].strip()
+        exp_date_str = validated_output.split("Expiration Date: ")[1].split("\n")[0].strip()
+        mrp_str = validated_output.split("MRP: ")[1].strip()
+
+        # Check for invalid manufacturing date formats
+        if mfg_date_str == "-1":
+            mfg_date = -1
+        else:
+            # Attempt to parse the manufacturing date
+            if '/' in mfg_date_str:  # If it's in dd/mm/yyyy or mm/yyyy format
+                mfg_date = mfg_date_str
+            else:
+                mfg_date = -1
+
+        # Check for invalid expiration date formats
+        if exp_date_str == "-1":
+            exp_date = -1
+        else:
+            # Attempt to parse the expiration date
+            if '/' in exp_date_str:  # If it's in dd/mm/yyyy or mm/yyyy format
+                exp_date = exp_date_str
+            else:
+                exp_date = -1
 
-        # Convert the extracted values to integers
-        mfg_date = int(mfg_date_str)
-        exp_date = int(exp_date_str)
-        print("Further processing: ", mfg_date, exp_date)
+        # Check MRP validity
+        if mrp_str == "INR -1":
+            mrp = -1
+        else:
+            # Ensure MRP is in the correct format
+            if mrp_str.startswith("INR "):
+                mrp = mrp_str.split("INR ")[1].strip()
+            else:
+                mrp = -1
 
-    except (IndexError, ValueError) as e:
-        print(f"[ERROR] Failed to parse dates: {e}")
+        print("Further processing: ", mfg_date, exp_date, mrp)
+
+    except IndexError as e:
+        print(f"[ERROR] Failed to parse validated output: {e}")
         return gr.update(visible=False)  # Hide button on error
 
-    # Check if both dates are -1
-    if mfg_date == -1 and exp_date == -1:
+    # Check if all three values are invalid (-1)
+    if mfg_date == -1 and exp_date == -1 and mrp == -1:
         print("[DEBUG] Showing the 'Further Processing' button.")  # Debug print
         return gr.update(visible=True)  # Show 'Further Processing' button
+
     print("[DEBUG] Hiding the 'Further Processing' button.")  # Debug print
-    return gr.update(visible=False)  # Hide button if dates are valid
+    return gr.update(visible=False)  # Hide button if all values are valid
 
-"""# Freshness Backend"""
 
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+"""# 5. Freshness backend
 
+"""
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
 class EfficientNet_FeatureExtractor(nn.Module):
 
@@ -580,10 +640,8 @@ class EfficientNet_FeatureExtractor(nn.Module):
         x = x.view(x.size(0), -1)
 
         return x
-
 # Calculating the mean and variance of the images whose features will be extracted
 
-
 transform = transforms.Compose([
     transforms.Resize(256),
     transforms.CenterCrop(224),
@@ -617,6 +675,7 @@ std /= total_images
 print(f"Mean: {mean}")
 print(f"Std: {std}")
 
+
 # Transforming the images into the format so that they can be passes through the EfficientNet model
 # Define the transform for your dataset, including normalization with custom mean and std
 transform = transforms.Compose([
@@ -765,7 +824,6 @@ def classify_banana_by_distance(distance):
         }
 
     return result
-
 def classify_banana(image):
 
     model = EfficientNet_FeatureExtractor().to(device)
@@ -784,9 +842,6 @@ def classify_banana(image):
     distance = (distance) / 1e8
 
     return classify_banana_by_distance(distance)
-
-"""## Freshness Detect Using image"""
-
 def detect_objects(image):
 
 
@@ -817,14 +872,14 @@ def detect_objects(image):
 
     return img_rgb
 
-"""## Freshness Detect using Video"""
-
 def detect_objects_video(video_file):
-
-    # Load the YOLO model
     model = YOLO('Yash_Best.pt')
     # Open the video file
-    cap = cv2.VideoCapture(video_file.name)
+    cap = cv2.VideoCapture(video_file)
+
+    # Check if the video was opened successfully
+    if not cap.isOpened():
+        raise Exception("Could not open video file.")
 
     # Get video properties
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
@@ -866,6 +921,7 @@ def detect_objects_video(video_file):
 
     return output_video_path
 
+
 """# 5. Frontend Of Brand Recognition
 
 ## Layout for Image interface
@@ -924,15 +980,15 @@ def create_ocr_interface():
         gr.Markdown("# Flipkart Grid Robotics Track - OCR Interface")
 
         with gr.Tabs():
+            # Upload and Detection Tab
             with gr.TabItem("Upload & Detection"):
                 with gr.Row():
-                    # Input: Upload image
                     input_image = gr.Image(type="pil", label="Upload Image", height=400, width=400)
                     output_image = gr.Image(label="Image with Bounding Boxes", height=400, width=400)
 
-                # Button for Analyze Image & Extract Text
                 btn = gr.Button("Analyze Image & Extract Text")
 
+            # OCR Results Tab
             with gr.TabItem("OCR Results"):
                 with gr.Row():
                     extracted_textbox = gr.Textbox(label="Extracted OCR Text", lines=5)
@@ -941,7 +997,16 @@ def create_ocr_interface():
                 with gr.Row():
                     validated_textbox = gr.Textbox(label="Validated Output", lines=5)
 
-                # Comprehensive OCR button (Initially hidden)
+                # Data table for Manufacturing Date, Expiration Date, and MRP
+                with gr.Row():
+                    detail_table = gr.Dataframe(
+                        headers=["Label", "Value"],
+                        value=[["", ""], ["", ""], ["", ""]],  # Initialize with empty values
+                        label="Manufacturing, Expiration Dates & MRP",
+                        datatype=["str", "str"],
+                        interactive=False,
+                    )
+
                 further_button = gr.Button("Comprehensive OCR", visible=False)
 
         # Detect and OCR button click event
@@ -951,6 +1016,13 @@ def create_ocr_interface():
             outputs=[output_image, extracted_textbox, refined_textbox, validated_textbox]
         )
 
+        # Update the table when validated_textbox changes
+        validated_textbox.change(
+            lambda validated_output: extract_details_from_validated_output(validated_output),
+            inputs=[validated_textbox],
+            outputs=[detail_table]
+        )
+
         # Further processing button click event
         further_button.click(
             further_processing,
@@ -965,7 +1037,6 @@ def create_ocr_interface():
             outputs=[further_button]
         )
 
-        # Hide the validated_textbox when "Comprehensive OCR" is clicked
         further_button.click(
             lambda: gr.update(visible=False),
             outputs=[validated_textbox]
@@ -973,16 +1044,11 @@ def create_ocr_interface():
 
     return ocr_interface
 
-# Create and launch the OCR interface
+# Initialize the OCR interface
 ocr_interface = create_ocr_interface()
-# ocr_interface.launch(share=True, debug=True)
 
-
-"""# Frontend for Fruit Freshness
-
-## Layout for Freshness Index
+""" 6. Front End of Fruit Index
 """
-
 def create_banana_classifier_interface():
     return gr.Interface(
         fn=classify_banana,  # Your classification function
@@ -996,8 +1062,8 @@ def create_banana_classifier_interface():
 def image_freshness_interface():
     return gr.Interface(
         fn=detect_objects,  # Your detection function
-        inputs=gr.Image(type="numpy", label="Upload an Image"),  # Removed tool argument
-        outputs=gr.Image(type="numpy", label="Detected Image"),
+        inputs=gr.Image(type="pil", label="Upload an Image"),  # Removed tool argument
+        outputs=gr.Image(type="pil", label="Detected Image"),
         live=True,
         title="Image Freshness Detection",
         description="Upload an image of fruit to detect freshness.",
@@ -1006,13 +1072,15 @@ def image_freshness_interface():
 
 def video_freshness_interface():
     return gr.Interface(
-        fn=process_video,  # Your video processing function
+        fn=detect_objects_video,  # Your video processing function
         inputs=gr.Video(label="Upload a Video"),
-        outputs=gr.Video(label="Processed Video"),
+        outputs=[
+            gr.Video(label="Processed Video"),  # Output video
+        ],
         title="Video Freshness Detection",
         description="Upload a video of fruit to detect freshness.",
         css="#component-0 { width: 300px; height: 300px; }"  # Keep your CSS for fixed size
-    )
+)
 
 def create_fruit_interface():
     with gr.Blocks() as demo:
@@ -1029,9 +1097,8 @@ def create_fruit_interface():
 
 Fruit = create_fruit_interface()
 
-"""# 6. Create a Tabbed Interface for Both Image and Video
+# 6. Create a Tabbed Interface for Both Image and Video
 ### Here, we combine the image and video interfaces into a tabbed structure so users can switch between them easily.
-"""
 
 def create_tabbed_interface():
     return gr.TabbedInterface(
@@ -1045,4 +1112,4 @@ tabbed_interface = create_tabbed_interface()
 ### Finally, launch the Gradio interface to make it interactable.
 """
 
-tabbed_interface.launch()
+tabbed_interface.launch(debug=False)