Rename app.py to app

app

@@ -0,0 +1,376 @@
+import os
+import gradio as gr
+import re
+import folium
+from fastai.vision.all import *
+from groq import Groq
+from PIL import Image
+
+# Load the trained model for grapevine disease classification
+learn = load_learner('export.pkl')  # Assumes you have a trained model for grapevine diseases
+labels = learn.dls.vocab
+
+# Initialize Groq client
+client = Groq(
+    api_key=os.environ.get("GROQ_API_KEY"),
+)
+
+def clean_disease_name(name):
+    """Clean disease name by removing numbers and special characters, and fix formatting"""
+    # Remove numbers and dots at the beginning
+    cleaned = re.sub(r'^\d+\.', '', name)
+    # Replace underscores with spaces
+    cleaned = cleaned.replace('_', ' ')
+    # Remove any remaining special characters
+    cleaned = re.sub(r'[^\w\s]', '', cleaned)
+    # Fix spacing
+    cleaned = ' '.join(cleaned.split())
+    return cleaned
+
+def get_disease_distribution_map(disease_name):
+    """Get global distribution map for the disease using Groq API"""
+    clean_name = clean_disease_name(disease_name)
+   
+    # Get the disease distribution locations
+    prompt = f"""
+    Provide a JSON array of the main regions where {clean_name} disease is prevalent in grapevines worldwide.
+    Return ONLY a JSON array with 3-5 entries, each containing:
+    1. "name": Region or country name
+    2. "lat": Latitude (numeric value)
+    3. "lon": Longitude (numeric value)
+    4. "description": Brief description of why this region is affected and the severity (2-3 sentences)
+   
+    Example format:
+    [
+      {{"name": "Example Location", "lat": 12.34, "lon": 56.78, "description": "Brief description"}},
+      ...
+    ]
+    """
+   
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            model="llama-3.3-70b-versatile",
+        )
+        response = chat_completion.choices[0].message.content
+       
+        # Extract JSON from response (in case there's additional text)
+        import json
+        import re
+       
+        # Find JSON pattern in response
+        json_match = re.search(r'\[.*\]', response, re.DOTALL)
+        if json_match:
+            locations = json.loads(json_match.group())
+        else:
+            # Fallback if JSON extraction fails
+            locations = [
+                {"name": "Major vineyard regions", "lat": 0, "lon": 0,
+                 "description": "Could not retrieve specific distribution information for this disease."}
+            ]
+       
+        return locations
+       
+    except Exception as e:
+        return [{"name": "Error retrieving data", "lat": 0, "lon": 0,
+                "description": "Please try again or check your connection."}]
+
+def create_distribution_map(locations):
+    """Create a folium map with the disease distribution locations"""
+    # Find center point based on valid coordinates
+    valid_coords = [(loc.get("lat", 0), loc.get("lon", 0))
+                    for loc in locations
+                    if loc.get("lat", 0) != 0 or loc.get("lon", 0) != 0]
+   
+    if valid_coords:
+        # Calculate the average of the coordinates
+        avg_lat = sum(lat for lat, _ in valid_coords) / len(valid_coords)
+        avg_lon = sum(lon for _, lon in valid_coords) / len(valid_coords)
+        # Create map centered on the average coordinates
+        m = folium.Map(location=[avg_lat, avg_lon], zoom_start=3)
+    else:
+        # Default world map if no valid coordinates
+        m = folium.Map(location=[20, 0], zoom_start=2)
+   
+    # Add markers for each location
+    for location in locations:
+        name = location.get("name", "Unknown")
+        lat = location.get("lat", 0)
+        lon = location.get("lon", 0)
+        description = location.get("description", "No description available")
+       
+        # Skip invalid coordinates
+        if lat == 0 and lon == 0:
+            continue
+           
+        # Add marker with custom color for disease (red)
+        folium.Marker(
+            location=[lat, lon],
+            popup=folium.Popup(f"<b>{name}</b><br>{description}", max_width=300),
+            tooltip=name,
+            icon=folium.Icon(color='red', icon='info-sign')
+        ).add_to(m)
+   
+    # Save map to HTML
+    map_html = m._repr_html_()
+    return map_html
+
+def format_disease_info(raw_info):
+    """Improve the formatting of disease information"""
+    # Add proper line breaks between sections and ensure consistent heading levels
+    formatted = raw_info
+   
+    # Replace markdown headings with HTML headings for better control
+    formatted = re.sub(r'#+\s+(.*)', r'<h3>\1</h3>', formatted)
+   
+    # Add paragraph tags for better spacing
+    formatted = re.sub(r'\n\*\s+(.*)', r'<p>• \1</p>', formatted)
+    formatted = re.sub(r'\n([^<\n].*)', r'<p>\1</p>', formatted)
+   
+    # Remove any duplicate paragraph tags
+    formatted = formatted.replace('<p><p>', '<p>')
+    formatted = formatted.replace('</p></p>', '</p>')
+   
+    return formatted
+
+def get_disease_info(disease_name):
+    """Get detailed information about a grapevine disease using Groq API"""
+    clean_name = clean_disease_name(disease_name)
+   
+    prompt = f"""
+    Provide detailed information about {clean_name} disease in grapevines, including:
+    1. Pathogen information (fungus, bacteria, virus, etc.)
+    2. Symptoms and visual identification
+    3. Disease cycle and conditions that favor development
+    4. Impact on grape production and wine quality
+    5. Management and treatment strategies
+    6. Any recent changes in disease prevalence or severity due to climate change
+   
+    Format your response in markdown for better readability.
+    """
+   
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            model="llama-3.3-70b-versatile",
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as e:
+        return f"Error fetching information: {str(e)}"
+
+def predict_and_get_info(img):
+    """Predict grapevine disease and get detailed information"""
+    # Process the image
+    img = PILImage.create(img)
+   
+    # Get prediction
+    pred, pred_idx, probs = learn.predict(img)
+   
+    # Get top 5 predictions (or all if less than 5)
+    num_classes = min(5, len(labels))
+    top_indices = probs.argsort(descending=True)[:num_classes]
+    top_probs = probs[top_indices]
+    top_labels = [labels[i] for i in top_indices]
+   
+    # Format as dictionary with cleaned names for display
+    prediction_results = {clean_disease_name(top_labels[i]): float(top_probs[i]) for i in range(num_classes)}
+   
+    # Get top prediction (original format for info retrieval)
+    top_disease = str(pred)
+    # Also keep a clean version for display
+    clean_top_disease = clean_disease_name(top_disease)
+   
+    # Get distribution locations and create map
+    distribution_locations = get_disease_distribution_map(top_disease)
+    distribution_map_html = create_distribution_map(distribution_locations)
+   
+    # Get detailed information about the top predicted disease
+    disease_info = get_disease_info(top_disease)
+    formatted_info = format_disease_info(disease_info)
+   
+    # Create combined info with map at the top and properly formatted information
+    custom_css = """
+    <style>
+    .disease-container {
+        font-family: Arial, sans-serif;
+        padding: 10px;
+    }
+    .map-container {
+        height: 400px;
+        width: 100%;
+        border: 1px solid #ddd;
+        border-radius: 8px;
+        overflow: hidden;
+        margin-bottom: 20px;
+    }
+    .info-container {
+        line-height: 1.6;
+    }
+    .info-container h3 {
+        margin-top: 20px;
+        margin-bottom: 10px;
+        color: #8B0000;
+        border-bottom: 1px solid #eee;
+        padding-bottom: 5px;
+    }
+    .info-container p {
+        margin-bottom: 10px;
+    }
+    .treatment-section {
+        background-color: #f1f8e9;
+        padding: 15px;
+        border-radius: 8px;
+        margin-top: 20px;
+    }
+    </style>
+    """
+   
+    combined_info = f"""
+    {custom_css}
+    <div class="disease-container">
+        <h2>Global Distribution of {clean_top_disease}</h2>
+        <div class="map-container">
+            {distribution_map_html}
+        </div>
+       
+        <div class="info-container">
+            <h2>Disease Information</h2>
+            {formatted_info}
+        </div>
+    </div>
+    """
+   
+    return prediction_results, combined_info, clean_top_disease
+
+def follow_up_question(question, disease_name):
+    """Allow vineyard managers to ask follow-up questions about the identified disease"""
+    if not question.strip() or not disease_name:
+        return "Please identify a grapevine disease first and ask a specific question about it."
+   
+    prompt = f"""
+    The vineyard manager is asking about {disease_name} disease: "{question}"
+   
+    Provide a detailed, scientific answer focusing on accurate plant pathology information.
+    If the question relates to treatment options, preventive measures, or climate change impacts, emphasize those aspects in your response.
+   
+    IMPORTANT: Do not repeat basic introductory information about the disease that would have already been provided in a general description.
+    Do not start your answer with phrases like "Introduction to {disease_name}" or similar repetitive headers.
+    Directly answer the specific question asked.
+   
+    Format your response in markdown for better readability.
+    """
+   
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            model="llama-3.3-70b-versatile",
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as e:
+        return f"Error fetching information: {str(e)}"
+
+# Create the Gradio interface
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("# Grapevine Disease Identification Tool")
+    gr.Markdown("Upload an image to identify grapevine diseases and get detailed information on management strategies and treatment options.")
+   
+    # Store the current disease for context
+    current_disease = gr.State("")
+   
+    # Main identification section
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(type="pil", label="Upload Grapevine Image")
+            submit_btn = gr.Button("Identify Disease", variant="primary")
+       
+        with gr.Column(scale=2):
+            prediction_output = gr.Label(label="Top 5 Predictions", num_top_classes=5)
+            disease_info_output = gr.HTML(label="Disease Information")
+   
+    # Clear divider
+    gr.Markdown("---")
+   
+    # Follow-up question section with improved UI
+    gr.Markdown("## Follow-up Questions")
+   
+    conversation_history = gr.Markdown("")
+   
+    with gr.Row():
+        follow_up_input = gr.Textbox(
+            label="Ask a question about this disease",
+            placeholder="Example: What are the best preventative measures for this disease?",
+            lines=2
+        )
+   
+    with gr.Row():
+        follow_up_btn = gr.Button("Submit Question", variant="primary")
+        clear_btn = gr.Button("Clear Conversation")
+   
+    # Set up event handlers
+    def process_image(img):
+        if img is None:
+            return None, "Please upload an image", "", ""
+       
+        try:
+            pred_results, info, clean_disease_name = predict_and_get_info(img)
+            return pred_results, info, clean_disease_name, ""
+        except Exception as e:
+            return None, f"Error processing image: {str(e)}", "", ""
+   
+    def update_conversation(question, disease_name, history):
+        if not question.strip():
+            return history
+       
+        answer = follow_up_question(question, disease_name)
+       
+        # Format the conversation with clear separation
+        new_exchange = f"""
+### Question:
+{question}
+### Answer:
+{answer}
+---
+"""
+        updated_history = new_exchange + history
+        return updated_history
+   
+    def clear_conversation_history():
+        return ""
+   
+    submit_btn.click(
+        process_image,
+        inputs=[input_image],
+        outputs=[prediction_output, disease_info_output, current_disease, conversation_history]
+    )
+   
+    follow_up_btn.click(
+        update_conversation,
+        inputs=[follow_up_input, current_disease, conversation_history],
+        outputs=[conversation_history]
+    ).then(
+        lambda: "",
+        outputs=follow_up_input
+    )
+   
+    clear_btn.click(
+        clear_conversation_history,
+        outputs=[conversation_history]
+    )
+
+# Launch the app
+app.launch(share=True)

app.py

@@ -1,70 +0,0 @@
-import gradio as gr
-from fastai.vision.all import *
-import requests
-import os
-
-# Load the trained model
-learn = load_learner('export.pkl')
-labels = learn.dls.vocab
-
-# DeepSeek API endpoint and headers (replace with your actual API details)
-DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions"  # Example URL, replace with actual API URL
-DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")  # Use environment variable for security
-
-def predict(img):
-    # Predict the disease using the FastAI model
-    img = PILImage.create(img)
-    pred, pred_idx, probs = learn.predict(img)
-    predicted_label = labels[pred_idx]
-    
-    # Prepare the prompt for DeepSeek API
-    prompt = f"Describe the grapevine disease {predicted_label} and suggest treatment methods."
-    
-    # Prepare data for DeepSeek API
-    headers = {
-        "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
-        "Content-Type": "application/json"
-    }
-    data = {
-        "model": "deepseek-chat",  # Specify the model you are using
-        "messages": [{"role": "user", "content": prompt}]
-    }
-    
-    # Call DeepSeek API
-    try:
-        response = requests.post(DEEPSEEK_API_URL, headers=headers, json=data)
-        response.raise_for_status()  # Raise an error for bad status codes
-        deepseek_response = response.json()
-        
-        # Extract description and treatment from the API response
-        description = deepseek_response.get("choices", [{}])[0].get("message", {}).get("content", "No description available.")
-        treatment = "Treatment methods are included in the description."  # Modify this if the API provides separate treatment info
-    except requests.exceptions.RequestException as e:
-        description = f"Failed to fetch description from DeepSeek API. Error: {str(e)}"
-        treatment = "Failed to fetch treatment information from DeepSeek API."
-    
-    # Return both the prediction probabilities and the DeepSeek response
-    return {
-        "prediction": {labels[i]: float(probs[i]) for i in range(len(labels))},
-        "description": description,
-        "treatment": treatment
-    }
-
-# Define the Gradio interface
-interface = gr.Interface(
-    fn=predict,
-    inputs=gr.Image(),
-    outputs=[
-        gr.Label(num_top_classes=3, label="Prediction Probabilities"),
-        gr.Textbox(label="Disease Description"),
-        gr.Textbox(label="Treatment Methods")
-    ],
-    title="Grapevine Disease Detection",
-    description="Upload an image of a grapevine leaf to detect diseases and get treatment suggestions."
-)
-
-# Enable the queue to handle POST requests
-interface.queue(api_open=True)
-
-# Launch the interface
-interface.launch()