app.py

import os
import gradio as gr
import numpy as np
import requests
import json
import time
from tensorflow.keras.models import load_model
from PIL import Image

# ===== API Configuration =====
# Try to get API tokens from environment variables
HF_API_TOKEN = os.getenv("HUGGINGFACE_TOKEN")  # Hugging Face API token
GROQ_API_KEY = os.getenv("GROQ_API_KEY")  # Groq API key
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")  # OpenAI API key (fallback)

print(f"API tokens available: HF={'Yes' if HF_API_TOKEN else 'No'}, Groq={'Yes' if GROQ_API_KEY else 'No'}, OpenAI={'Yes' if OPENAI_API_KEY else 'No'}")

# ===== Disease Information Database =====
disease_info = {
    "Tomato Bacterial Spot": {
        "description": "A bacterial disease that causes small, dark spots on leaves, stems, and fruits.",
        "causes": "Caused by Xanthomonas bacteria, spread by water splash, contaminated tools, and seeds.",
        "treatment": [
            "Remove and destroy infected plants",
            "Rotate crops with non-solanaceous plants",
            "Use copper-based fungicides",
            "Avoid overhead irrigation"
        ]
    },
    "Tomato Early Blight": {
        "description": "A fungal disease that causes dark spots with concentric rings on lower leaves first.",
        "causes": "Caused by Alternaria solani fungus, favored by warm, humid conditions.",
        "treatment": [
            "Remove infected leaves promptly",
            "Improve air circulation around plants",
            "Apply fungicides preventatively",
            "Mulch around plants to prevent soil splash"
        ]
    },
    "Tomato Late Blight": {
        "description": "A devastating fungal disease that causes dark, water-soaked lesions on leaves and fruits.",
        "causes": "Caused by Phytophthora infestans, favored by cool, wet conditions.",
        "treatment": [
            "Remove and destroy infected plants immediately",
            "Apply fungicides preventatively in humid conditions",
            "Improve drainage and air circulation",
            "Plant resistant varieties when available"
        ]
    },
    "Tomato Mosaic Virus": {
        "description": "A viral disease that causes mottled green/yellow patterns on leaves and stunted growth.",
        "causes": "Caused by tobacco mosaic virus (TMV), spread by handling, tools, and sometimes seeds.",
        "treatment": [
            "Remove and destroy infected plants",
            "Wash hands and tools after handling infected plants",
            "Control insect vectors like aphids",
            "Plant resistant varieties"
        ]
    },
    "Tomato Yellow Leaf Curl Virus": {
        "description": "A viral disease transmitted by whiteflies that causes yellowing and curling of leaves.",
        "causes": "Caused by a begomovirus, transmitted primarily by whiteflies.",
        "treatment": [
            "Use whitefly control measures",
            "Remove and destroy infected plants",
            "Use reflective mulches to repel whiteflies",
            "Plant resistant varieties"
        ]
    },
    "Tomato___Target_Spot": {
        "description": "A fungal disease causing circular lesions with concentric rings on leaves, stems, and fruits.",
        "causes": "Caused by Corynespora cassiicola fungus, favored by warm, humid conditions.",
        "treatment": [
            "Remove infected plant parts",
            "Improve air circulation",
            "Apply fungicides at first sign of disease",
            "Avoid overhead irrigation"
        ]
    },
    "Tomato___Bacterial_spot": {
        "description": "A bacterial disease causing small, dark, water-soaked spots on leaves, stems, and fruits.",
        "causes": "Caused by Xanthomonas species, spread by water splash and contaminated tools.",
        "treatment": [
            "Remove infected plant debris",
            "Use copper-based bactericides",
            "Rotate crops",
            "Use disease-free seeds and transplants"
        ]
    },
    "Tomato___healthy": {
        "description": "The plant shows no signs of disease and appears to be in good health.",
        "causes": "Proper growing conditions, good management practices, and disease prevention.",
        "treatment": [
            "Continue regular watering and fertilization",
            "Monitor for early signs of disease",
            "Maintain good air circulation",
            "Practice crop rotation"
        ]
    }
}

# ===== Load Trained Models =====
model_a = load_model("Tomato_Leaf_Disease_Model.h5")
model_b = load_model("tomato_leaf_model_final(77%).h5")
classifier_model = load_model("tomato_leaf_classifier_optimized.h5")

# ===== Preprocessing Function =====
def preprocess_image(image, target_size=(224, 224)):
    # Ensure the image is resized and normalized.
    if isinstance(image, Image.Image):
        img = image.resize(target_size)
    else:
        img = Image.fromarray(image).resize(target_size)
    img_array = np.array(img) / 255.0
    img_array = np.expand_dims(img_array, axis=0)
    return img_array

# ===== Disease Label Mappings =====
# Model A labels
disease_labels_a = {
    0: "Tomato Bacterial Spot",
    1: "Tomato Early Blight",
    2: "Tomato Late Blight",
    3: "Tomato Mosaic Virus",
    4: "Tomato Yellow Leaf Curl Virus"
}

# Model B labels
disease_labels_b = {
    0: "Tomato___Target_Spot",
    1: "Tomato___Bacterial_spot",
    2: "Tomato___Early_blight",
    3: "Tomato___healthy",
    4: "Tomato___Late_blight"
}

# ===== Prediction Functions =====
def predict_model_a(image):
    img = preprocess_image(image)
    pred = model_a.predict(img)
    predicted_class = np.argmax(pred)
    confidence = float(np.max(pred) * 100)
    return disease_labels_a.get(predicted_class, "Unknown result"), confidence

def predict_model_b(image):
    img = preprocess_image(image)
    pred = model_b.predict(img)
    predicted_class = np.argmax(pred)
    confidence = float(np.max(pred) * 100)
    return disease_labels_b.get(predicted_class, "Unknown result"), confidence

def predict_classifier(image):
    img = preprocess_image(image)
    pred = classifier_model.predict(img)
    # Here we assume the classifier returns class 1 for "Tomato Leaf"
    return "Tomato Leaf" if np.argmax(pred) == 1 else "Not Tomato Leaf"

# ===== AI Model API Calls =====
def get_ai_advice(prompt, retries=2):
    """Try multiple AI models with fallback mechanisms"""

    # Try Groq API first (if key available)
    if GROQ_API_KEY:
        try:
            headers = {
                "Authorization": f"Bearer {GROQ_API_KEY}",
                "Content-Type": "application/json"
            }

            payload = {
                "model": "llama3-8b-8192",  # Using Llama 3 8B model
                "messages": [
                    {"role": "system", "content": "You are an expert agricultural advisor specializing in tomato farming."},
                    {"role": "user", "content": prompt}
                ],
                "max_tokens": 800,
                "temperature": 0.7
            }

            response = requests.post(
                "https://api.groq.com/openai/v1/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )

            if response.status_code == 200:
                result = response.json()
                if "choices" in result and len(result["choices"]) > 0:
                    return result["choices"][0]["message"]["content"]

            print(f"Groq API error: {response.status_code} - {response.text}")

        except Exception as e:
            print(f"Error with Groq API: {str(e)}")

    # Try Hugging Face Inference API as first fallback (if token available)
    if HF_API_TOKEN:
        try:
            headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}

            # Format prompt for instruction-tuned models
            formatted_prompt = f"""<s>[INST] {prompt} [/INST]"""

            payload = {
                "inputs": formatted_prompt,
                "parameters": {
                    "max_new_tokens": 800,
                    "temperature": 0.7,
                    "top_p": 0.95,
                    "do_sample": True
                }
            }

            # Try Mistral model first
            url = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2"

            response = requests.post(url, headers=headers, json=payload, timeout=30)

            if response.status_code == 200:
                result = response.json()
                if isinstance(result, list) and len(result) > 0:
                    if "generated_text" in result[0]:
                        # Extract just the response part (after the prompt)
                        generated_text = result[0]["generated_text"]
                        # Remove the prompt from the response
                        response_text = generated_text.split("[/INST]")[-1].strip()
                        return response_text

            # If Mistral fails, try Llama 3
            url = "https://api-inference.huggingface.co/models/meta-llama/Meta-Llama-3-8B-Instruct"
            response = requests.post(url, headers=headers, json=payload, timeout=30)

            if response.status_code == 200:
                result = response.json()
                if isinstance(result, list) and len(result) > 0:
                    if "generated_text" in result[0]:
                        generated_text = result[0]["generated_text"]
                        response_text = generated_text.split("[/INST]")[-1].strip()
                        return response_text

        except Exception as e:
            print(f"Error with Hugging Face API: {str(e)}")

    # Try OpenAI API as final fallback (if key available)
    if OPENAI_API_KEY:
        try:
            headers = {
                "Authorization": f"Bearer {OPENAI_API_KEY}",
                "Content-Type": "application/json"
            }

            payload = {
                "model": "gpt-3.5-turbo",
                "messages": [
                    {"role": "system", "content": "You are an expert agricultural advisor specializing in tomato farming."},
                    {"role": "user", "content": prompt}
                ],
                "max_tokens": 800,
                "temperature": 0.7
            }

            response = requests.post(
                "https://api.openai.com/v1/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )

            if response.status_code == 200:
                result = response.json()
                if "choices" in result and len(result["choices"]) > 0:
                    return result["choices"][0]["message"]["content"]

        except Exception as e:
            print(f"Error with OpenAI API: {str(e)}")

    # If all API calls fail, use the fallback information from our database
    disease_name = prompt.split("disease has been detected: ")[-1].split(" with")[0] if "disease has been detected:" in prompt else ""

    if disease_name and disease_name in disease_info:
        info = disease_info[disease_name]
        return f"""
# {disease_name}

## Description
{info['description']}

## Causes
{info['causes']}

## Recommended Treatment
{chr(10).join(f"- {rec}" for rec in info['treatment'])}

*Note: This is fallback information as our AI service is currently unavailable.*
"""
    else:
        # Generic fallback response
        return """
# Agricultural Advice

I apologize, but I'm currently unable to connect to our AI service. Here are some general tips for tomato plant care:

## General Tomato Care Tips
- Water consistently, aiming for 1-2 inches per week
- Provide support with stakes or cages
- Fertilize regularly with balanced fertilizer
- Remove suckers for indeterminate varieties
- Monitor for pests and diseases regularly
- Ensure good air circulation between plants
- Mulch to retain moisture and prevent soil-borne diseases

Please try again later for more specific advice.
"""

# ===== AI Assistant Functions =====
def generate_disease_advice(disease_name, confidence):
    """Generate advice for a specific disease with confidence level."""
    if "healthy" in disease_name.lower():
        prompt = (
            "You are an agricultural advisor speaking to a farmer. "
            "The tomato crop appears healthy. "
            "Provide detailed preventive tips and best practices for maintaining tomato crop health. "
            "Include information about watering, fertilization, pest prevention, and optimal growing conditions. "
            "Format your response in clear sections with bullet points where appropriate."
        )
    else:
        prompt = (
            f"You are an agricultural advisor speaking to a farmer. "
            f"A disease has been detected in their tomato crop: {disease_name} with {confidence:.1f}% confidence. "
            f"Provide detailed advice on how to identify, manage and treat this disease. "
            f"Include information about: "
            f"1) What causes this disease "
            f"2) How it spreads "
            f"3) Specific treatments (both organic and chemical options) "
            f"4) Preventive measures for the future "
            f"Format your response in clear sections with bullet points where appropriate."
        )

    return get_ai_advice(prompt)

def chat_with_farmer(message, chat_history):
    """Handle chat interactions with farmers about agricultural topics."""
    if not message.strip():
        return "", chat_history

    # Prepare context from chat history
    context = "\n".join([f"Farmer: {q}\nAdvisor: {a}" for q, a in chat_history[-3:]])  # Use last 3 exchanges for context

    prompt = (
        f"You are FarmAssist, an expert agricultural advisor specializing in tomato farming and plant diseases. "
        f"You provide helpful, accurate, and practical advice to farmers. "
        f"Always be respectful and considerate of farmers' knowledge while providing expert guidance. "
        f"If you're unsure about something, acknowledge it and provide the best information you can. "
        f"Previous conversation:\n{context}\n\n"
        f"Farmer's new question: {message}\n\n"
        f"Provide a helpful, informative response about farming, focusing on tomatoes if relevant."
    )

    response = get_ai_advice(prompt)
    chat_history.append((message, response))
    return "", chat_history

# ===== Process Function Based on Version =====
def process_version(image, version):
    if image is None:
        return "No image provided."

    # --- Version 1.x (Model A) ---
    if version == "1.1":
        result, confidence = predict_model_a(image)
        return f"Model A Prediction: {result} (Confidence: {confidence:.1f}%)\n\nView Model A Training Notebook: https://colab.research.google.com/drive/1FMjs7JmdO6WVoXbzLA-ymwnIKq-GaV6w?usp=sharing"

    elif version == "1.2":
        result, confidence = predict_model_a(image)
        advice = generate_disease_advice(result, confidence)
        return f"Model A Prediction: {result} (Confidence: {confidence:.1f}%)\n\nExpert Advice:\n{advice}"

    elif version == "1.3":
        cls_result = predict_classifier(image)
        if cls_result != "Tomato Leaf":
            return "Classifier: The image is not a tomato leaf. Please try again with a tomato leaf image."

        result, confidence = predict_model_a(image)
        advice = generate_disease_advice(result, confidence)
        return (
            f"Classifier: {cls_result}\n"
            f"Model A Prediction: {result} (Confidence: {confidence:.1f}%)\n\n"
            f"Expert Advice:\n{advice}\n\n"
            f"[View Model A & Classifier Training Notebook](https://colab.research.google.com/drive/1FMjs7JmdO6WVoXbzLA-ymwnIKq-GaV6w?usp=sharing)"
        )

    # --- Version 2.x (Model B) ---
    elif version == "2.1":
        result, confidence = predict_model_b(image)
        return f"Model B Prediction: {result} (Confidence: {confidence:.1f}%)\n\n[View Model B Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)"

    elif version == "2.2":
        result, confidence = predict_model_b(image)
        advice = generate_disease_advice(result, confidence)
        return f"Model B Prediction: {result} (Confidence: {confidence:.1f}%)\n\nExpert Advice:\n{advice}"

    elif version == "2.3":
        cls_result = predict_classifier(image)
        if cls_result != "Tomato Leaf":
            return "Classifier: The image is not a tomato leaf. Please try again with a tomato leaf image."

        result, confidence = predict_model_b(image)
        advice = generate_disease_advice(result, confidence)
        return (
            f"Classifier: {cls_result}\n"
            f"Model B Prediction: {result} (Confidence: {confidence:.1f}%)\n\n"
            f"Expert Advice:\n{advice}\n\n"
            f"[View Model B & Classifier Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)"
        )

    else:
        return "Invalid version selected."

# ===== Helper Function to Choose Between Uploaded & Camera Image =====
def combine_images(uploaded, camera):
    return camera if camera is not None else uploaded

# ===== CSS for Theme Switching =====
light_css = """
<style>
body { background-color: white; color: black; }
.gr-button { background-color: #4CAF50; color: white; }
.gr-input, .gr-textbox, .gr-dropdown, .gr-radio, .gr-markdown, .gr-container { background-color: white; color: black; }
</style>
"""

dark_css = """
<style>
body { background-color: #121212 !important; color: #e0e0e0 !important; }
.gr-button { background-color: #555 !important; color: white !important; }
.gr-input, .gr-textbox, .gr-dropdown, .gr-radio, .gr-markdown, .gr-container { background-color: #333 !important; color: #e0e0e0 !important; }
</style>
"""

def update_css(theme):
    if theme == "Dark":
        return dark_css
    else:
        return light_css

# ===== Gradio Interface =====
with gr.Blocks() as demo:
    # Hidden element for CSS injection (initially Light theme)
    css_injector = gr.HTML(update_css("Light"))

    gr.Markdown("# 🌿 FarMVi8ioN – AI-powered Crop Monitoring")
    gr.Markdown("Detect tomato leaf diseases and get actionable advice on how to curb them.")

    with gr.Tabs():
        # === Disease Detection Tab ===
        with gr.TabItem("Disease Detection"):
            with gr.Row():
                # ----- Left Column (≈30%) -----
                with gr.Column(scale=1):
                    version = gr.Dropdown(
                        choices=["1.1", "1.2", "1.3", "2.1", "2.2", "2.3"],
                        label="Select Version",
                        value="1.3",
                        info="Versions 1.x use Model A; Versions 2.x use Model B."
                    )

                    theme_choice = gr.Radio(
                        choices=["Light", "Dark"],
                        label="Select Theme",
                        value="Light"
                    )

                    gr.Markdown("### Notebook Links")
                    gr.Markdown(
                        """
                        **For Model A:**
                        - Model A Only: [Training Notebook](https://colab.research.google.com/drive/1FMjs7JmdO6WVoXbzLA-ymwnIKq-GaV6w?usp=sharing)
                        - Model A & Classifier: [Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)

                        **For Model B:**
                        - Model B Only: [Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)
                        - Model B & Classifier: [Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)
                        """
                    )

                # ----- Right Column (≈70%) -----
                with gr.Column(scale=2):
                    image_input = gr.Image(label="📂 Upload Tomato Leaf Image", type="pil")
                    camera_input = gr.Image(label="📸 Use Camera (Live Preview)", type="pil", sources=["webcam"])
                    submit = gr.Button("🔍 Analyze", variant="primary")
                    output = gr.Markdown(label="📝 Diagnosis & Advice")

        # === Farmer Chat Tab ===
        with gr.TabItem("Chat with Farm Assistant"):
            gr.Markdown("# 💬 Chat with Farm Assistant")
            gr.Markdown("Ask any questions about farming, crop diseases, or agricultural practices.")

            chatbot = gr.Chatbot(
                label="Chat History",
                height=400,
                bubble_full_width=False,
                show_copy_button=True
            )

            with gr.Row():
                chat_input = gr.Textbox(
                    label="Your Question",
                    placeholder="Ask about tomato farming, diseases, or agricultural practices...",
                    lines=2
                )
                chat_button = gr.Button("Send", variant="primary")

            gr.Markdown("""
            ### Example Questions:
            - How often should I water my tomato plants?
            - What's the best fertilizer for tomatoes?
            - How do I prevent early blight?
            - What are the signs of nutrient deficiency in tomatoes?
            """)

    # Update CSS dynamically based on theme selection
    theme_choice.change(fn=update_css, inputs=theme_choice, outputs=css_injector)

    # When submit is clicked, combine image inputs and process the selected version
    submit.click(
        fn=lambda uploaded, camera, ver: process_version(combine_images(uploaded, camera), ver),
        inputs=[image_input, camera_input, version],
        outputs=output
    )

    # Chat functionality
    chat_button.click(
        fn=chat_with_farmer,
        inputs=[chat_input, chatbot],
        outputs=[chat_input, chatbot]
    )

    # Also allow pressing Enter to send chat
    chat_input.submit(
        fn=chat_with_farmer,
        inputs=[chat_input, chatbot],
        outputs=[chat_input, chatbot]
    )

# Launch the app
demo.launch()