Update app.py

app.py

@@ -8,7 +8,10 @@ from groq import Groq
 from deep_translator import GoogleTranslator
 import os
 from dotenv import load_dotenv
+
+# Load environment variables
 load_dotenv()
+
 app = Flask(__name__)
 
 # Load the model for disease detection
@@ -18,9 +21,8 @@ model = load_model(MODEL_PATH, compile=False)
 # Load the labels for disease detection
 class_names = open("s3/labels.txt", "r").readlines()
 
-# Medication suggestions for specific diseases
-medications = {
-    "1 LUMPY SKIN": "Tips for Lumpy Skin Disease (LSD):"
+# Medication suggestions
+medications = "1 LUMPY SKIN": "Tips for Lumpy Skin Disease (LSD):"
                     "Isolation: Immediately isolate affected animals to prevent the spread of the disease to other livestock."
                     "Hygiene: Maintain a clean environment by disinfecting animal housing, feeding equipment, and water troughs regularly."
                     "Supportive Care: Ensure animals are well-fed with a nutritious diet to strengthen their immune systems. Providing fresh, clean water is essential."
@@ -58,12 +60,14 @@ medications = {
                         "Monitor: Watch for early signs and isolate any affected animals."
 }
 
-# Initialize Groq client (Replace with your actual API key)
-API_KEY = "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" # This is your provided key
+# Groq API initialization from .env
+API_KEY = os.getenv("GROQ_API_KEY")
+if not API_KEY:
+    raise ValueError("GROQ_API_KEY is missing from the .env file")
+
 client = Groq(api_key=API_KEY)
 
 def translate_text(text, target_language):
-    """Translates text to the specified target language."""
     return GoogleTranslator(source="auto", target=target_language).translate(text)
 
 @app.route("/")
@@ -76,15 +80,10 @@ def rearing_guidance():
 
 @app.route('/result', methods=['POST'])
 def result():
-    # Get user input
     animal_type = request.form['animal_type']
     number_of_animals = int(request.form['number_of_animals'])
-    
-    # Map animal type and count to required features
     area_size, feed_type, feed_quantity, cost_in_inr, water_supply, hygiene_tips, seasonal_tips = get_animal_data(animal_type, number_of_animals)
 
-    # Translate the content to the selected language (if needed here, otherwise handled in JS)
-
     return render_template('s1.html',
                             area_size=area_size,
                             feed_type=feed_type,
@@ -94,207 +93,72 @@ def result():
                             hygiene_tips=hygiene_tips,
                             seasonal_tips=seasonal_tips,
                             animal_type=animal_type,
-                            number_of_animals=number_of_animals,
-                            )
+                            number_of_animals=number_of_animals)
 
-# Helper function to map animal type and count to required values
 def get_animal_data(animal_type, count):
-    if animal_type == 'Cow':
-        area_size = 19.81 * count
-        feed_type = 'Green Feed'
-        feed_quantity = 24.85 * count
-        cost_in_inr = 6652.15 * count
-        water_supply = 68.52 * count
-        hygiene_tips = 'Clean barn daily, vaccinate regularly'
-        seasonal_tips = 'Summer: Provide shade and cool water, Winter: Ensure warmth, Rainy: Avoid damp areas.'
-    elif animal_type == 'Buffalo':
-        area_size = 24.58 * count
-        feed_type = 'Dry Feed'
-        feed_quantity = 31.45 * count
-        cost_in_inr = 7483.52 * count
-        water_supply = 81.23 * count
-        hygiene_tips = 'Ensure proper ventilation'
-        seasonal_tips = 'Summer: Provide shade and cool water, Winter: Provide shelter, Rainy: Dry bedding is essential.'
-    elif animal_type == 'Pig':
-        area_size = 15.25 * count
-        feed_type = 'Concentrates'
-        feed_quantity = 5.15 * count
-        cost_in_inr = 4989.25 * count
-        water_supply = 50.60 * count
-        hygiene_tips = 'Use disinfectants weekly'
-        seasonal_tips = 'Summer: Keep cool and dry, Winter: Ensure warmth, Rainy: Keep pens dry.'
-    elif animal_type == 'Goat':
-        area_size = 10.21 * count
-        feed_type = 'Green Feed'
-        feed_quantity = 3.25 * count
-        cost_in_inr = 3325.60 * count
-        water_supply = 20.55 * count
-        hygiene_tips = 'Provide clean bedding'
-        seasonal_tips = 'Summer: Provide fresh water and shade, Winter: Ensure dry and warm shelter, Rainy: Avoid damp areas.'
-    elif animal_type == 'Sheep':
-        area_size = 12.50 * count
-        feed_type = 'Green Feed'
-        feed_quantity = 4.75 * count
-        cost_in_inr = 3741.75 * count
-        water_supply = 25.80 * count
-        hygiene_tips = 'Check for parasites regularly'
-        seasonal_tips = 'Summer: Provide plenty of water, Winter: Keep warm with shelter, Rainy: Keep dry and prevent wool rot.'
-    elif animal_type == 'Poultry':
-        area_size = 1.5 * count
-        feed_type = 'Grain-based Feed'
-        feed_quantity = 0.25 * count
-        cost_in_inr = 120 * count
-        water_supply = 0.5 * count
-        hygiene_tips = 'Keep the coop clean and free from pests'
-        seasonal_tips = 'Summer: Ensure proper ventilation, Winter: Provide heat and protection, Rainy: Keep the coop dry.'
-    elif animal_type == 'Bee Hiving':
-        area_size = 10.25   # In square feet, for a beekeeping area
-        feed_type = 'Sugar Syrup'
-        feed_quantity = 0.5 * count   # For hives
-        cost_in_inr = 1500.55 * count   # Cost per hive
-        water_supply = 0.25 * count   # Water requirement per hive
-        hygiene_tips = 'Check for pests like mites and wax moths'
-        seasonal_tips = 'Summer: Provide ample water sources, Winter: Ensure the bees have enough food stores, Rainy: Avoid disturbances.'
-    elif animal_type == 'Sericulture':
-        area_size = 4.85 * count   # In square feet, for silkworms
-        feed_type = 'Mulberry Leaves'
-        feed_quantity = 0.1 * count   # Per silkworm
-        cost_in_inr = 198.25 * count   # Cost per silkworm
-        water_supply = 0.2 * count   # Water per silkworm
-        hygiene_tips = 'Maintain clean environment, avoid humidity'
-        seasonal_tips = 'Summer: Maintain cool and dry conditions, Winter: Keep warm, Rainy: Ensure adequate airflow.'
+    data = {
+        'Cow': (19.81, 'Green Feed', 24.85, 6652.15, 68.52, 'Clean barn daily, vaccinate regularly', 'Summer: Provide shade, Winter: Warmth, Rainy: Avoid damp.'),
+        'Buffalo': (24.58, 'Dry Feed', 31.45, 7483.52, 81.23, 'Ensure proper ventilation', 'Summer: Shade, Winter: Shelter, Rainy: Dry bedding.'),
+        'Pig': (15.25, 'Concentrates', 5.15, 4989.25, 50.60, 'Use disinfectants weekly', 'Summer: Cool & dry, Winter: Warmth, Rainy: Dry pens.'),
+        'Goat': (10.21, 'Green Feed', 3.25, 3325.60, 20.55, 'Provide clean bedding', 'Summer: Shade, Winter: Warm shelter, Rainy: Avoid damp.'),
+        'Sheep': (12.50, 'Green Feed', 4.75, 3741.75, 25.80, 'Check for parasites', 'Summer: Water, Winter: Shelter, Rainy: Dry conditions.'),
+        'Poultry': (1.5, 'Grain-based Feed', 0.25, 120, 0.5, 'Keep coop clean', 'Summer: Ventilation, Winter: Heat, Rainy: Dry coop.'),
+        'Bee Hiving': (10.25, 'Sugar Syrup', 0.5, 1500.55, 0.25, 'Check for pests', 'Summer: Water, Winter: Food stores, Rainy: Avoid disturbance.'),
+        'Sericulture': (4.85, 'Mulberry Leaves', 0.1, 198.25, 0.2, 'Clean & dry environment', 'Summer: Cool & dry, Winter: Warm, Rainy: Airflow.')
+    }
+    base_values = data.get(animal_type)
+    return tuple(v * count if isinstance(v, (int, float)) else v for v in base_values)
 
-    return area_size, feed_type, feed_quantity, cost_in_inr, water_supply, hygiene_tips, seasonal_tips
 @app.route("/ai-chatbot")
 def ai_chatbot():
     return render_template("s2.html")
+
 @app.route("/chat", methods=["POST"])
 def chat():
     data = request.json
     user_message = data.get("message")
     target_language = data.get("language", "en")
-
     try:
-        # Translate user input to English
         user_message_en = translate_text(user_message, "en")
-
-        # Call Groq API
         response = client.chat.completions.create(
             messages=[{"role": "user", "content": user_message_en}],
             model="llama-3.3-70b-versatile"
         )
-
         bot_response_en = response.choices[0].message.content
-
-        # Translate back
         bot_response_translated = translate_text(bot_response_en, target_language)
-
         return jsonify({"response": bot_response_translated})
-
     except Exception as e:
-        import traceback
-        print("Chatbot error:", e)
-        traceback.print_exc()
         return jsonify({"response": f"Error: {str(e)}"}), 500
 
-
 @app.route("/disease-detection", methods=["GET", "POST"])
 def disease_detection():
-    prediction = None
-    confidence = None
-    medication = None
-    img_data = None   # Variable to store image data for displaying on the webpage
-    error = None
-
-    if request.method == "POST":
-        # Check if file is sent as a Blob (from JavaScript FormData)
-        if 'file' in request.files:
-            file = request.files["file"]
-            if file.filename == "":
-                error = "No selected file."
-            else:
-                try:
-                    # Read image data from the FileStorage object
-                    image_bytes = file.read()
-                    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-
-                    # Resize the image to 224x224 and crop from the center
-                    size = (224, 224)
-                    image = ImageOps.fit(image, size, Image.Resampling.LANCZOS)
-
-                    # Convert image to numpy array and normalize
-                    image_array = np.asarray(image)
-                    normalized_image_array = (image_array.astype(np.float32) / 127.5) - 1
-
-                    # Create the array of the right shape to feed into the keras model
-                    data = np.ndarray(shape=(1, 224, 224, 3), dtype=np.float32)
-                    data[0] = normalized_image_array
-
-                    # Predict the model
-                    prediction_raw = model.predict(data)
-                    index = np.argmax(prediction_raw)
-                    # Ensure class_name is cleaned of potential newlines/spaces from labels.txt
-                    class_name = class_names[index].strip()
-                    confidence_score = prediction_raw[0][index] * 100 # Convert to percentage
-
-                    prediction = f"Predicted Disease: {class_name}"
-                    confidence = f"{confidence_score:.2f}%"
-
-                    # Suggest medication if disease detected
-                    medication = medications.get(class_name, None)
-
-                    # Convert processed image to base64 for rendering on the webpage
-                    img_byte_array = io.BytesIO()
-                    # It's better to save the *processed* image to display, if you want
-                    # to show what the model actually saw. Otherwise, use the original image_bytes
-                    image.save(img_byte_array, format="PNG")
-                    img_data = base64.b64encode(img_byte_array.getvalue()).decode("utf-8")
-
-                except Exception as e:
-                    error = f"Error processing uploaded image: {e}"
-        # This handles the case if a previous approach sent a data URL directly in a form field.
-        # However, the JS change in the previous response sends a Blob via request.files
-        # so this block might be less frequently hit but good for robustness.
-        elif 'file' in request.form and request.form['file'].startswith('data:image'):
-            image_data_url = request.form['file']
+    prediction, confidence, medication, img_data, error = None, None, None, None, None
+    if request.method == "POST" and 'file' in request.files:
+        file = request.files["file"]
+        if file.filename:
             try:
-                header, encoded = image_data_url.split(',', 1)
-                image_bytes = base64.b64decode(encoded)
+                image_bytes = file.read()
                 image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-                
-                # Resize and preprocess just like the file upload
-                size = (224, 224)
-                image = ImageOps.fit(image, size, Image.Resampling.LANCZOS)
+                image = ImageOps.fit(image, (224, 224), Image.Resampling.LANCZOS)
                 image_array = np.asarray(image)
                 normalized_image_array = (image_array.astype(np.float32) / 127.5) - 1
                 data = np.ndarray(shape=(1, 224, 224, 3), dtype=np.float32)
                 data[0] = normalized_image_array
-
                 prediction_raw = model.predict(data)
                 index = np.argmax(prediction_raw)
                 class_name = class_names[index].strip()
                 confidence_score = prediction_raw[0][index] * 100
-
                 prediction = f"Predicted Disease: {class_name}"
                 confidence = f"{confidence_score:.2f}%"
-                medication = medications.get(class_name, None)
-
+                medication = medications.get(class_name)
                 img_byte_array = io.BytesIO()
-                image.save(img_byte_array, format="PNG") # Save the processed image for display
+                image.save(img_byte_array, format="PNG")
                 img_data = base64.b64encode(img_byte_array.getvalue()).decode("utf-8")
-
             except Exception as e:
-                error = f"Error processing image from data URL: {e}"
+                error = f"Error processing image: {e}"
         else:
-            error = "No image data found in the request."
-
-    return render_template("s3.html", 
-                           prediction=prediction, 
-                           confidence=confidence, 
-                           medication=medication, 
-                           img_data=img_data, 
-                           error=error)
-
+            error = "No file selected."
+    return render_template("s3.html", prediction=prediction, confidence=confidence, medication=medication, img_data=img_data, error=error)
 
 @app.route("/information")
 def information():
@@ -314,4 +178,4 @@ def veterinary_map():
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-app.run(host="0.0.0.0", port=port, debug=True)
+    app.run(host="0.0.0.0", port=port, debug=True)