Upload 11 files

.gitattributes

@@ -1 +1,7 @@
 logo.png filter=lfs diff=lfs merge=lfs -text
+mobilenet_best_model_merged_bee_nobee.keras filter=lfs diff=lfs merge=lfs -text
+mobilenet_best_model_merged_mite_nomite.keras filter=lfs diff=lfs merge=lfs -text
+mobilenet_best_model_merged_queen_noqueen.keras filter=lfs diff=lfs merge=lfs -text
+mobilenet_best_model.keras filter=lfs diff=lfs merge=lfs -text
+mobilenet_best_model1.keras filter=lfs diff=lfs merge=lfs -text
+mobilenet_best_model2.keras filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,11 @@
+---
+title: Bee Notbee
+emoji: 😻
+colorFrom: blue
+colorTo: red
+sdk: docker
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

mobilenet_best_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9c06dc6d2209efe5f39c461cd83b2edd58ab6f1e0b5be9c202e1fd4de53bcad
+size 13539546

mobilenet_best_model1.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10e757e202532397e6ca5aa0ce5a3b2ee48482f01ffb3adce0e166aaf24b5651
+size 31466423

mobilenet_best_model2.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14e389b76c39e707765e69073c83f3eb37f82af06b2ad3b5a4729a682dec75ce
+size 13561171

mobilenet_best_model_merged_bee_nobee.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e20a01cd950764c873b888a36428b7b489748daed39af72033669129e270ae49
+size 13561172

mobilenet_best_model_merged_mite_nomite.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a59eaa08ce9460c85a405752c043c159e685dd41a603645ea5cadb11463d787a
+size 13561171

mobilenet_best_model_merged_queen_noqueen.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfb49050677429f3adb44197f395e3f033b6a409b469ac44f2fbfb275e3e87f1
+size 13561172

predict.py

@@ -0,0 +1,435 @@
+import os
+import json
+import librosa
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+import matplotlib.pyplot as plt
+from PIL import Image
+from googleapiclient.discovery import build
+from google.oauth2 import service_account
+from googleapiclient.http import MediaIoBaseUpload
+from flask import jsonify
+import logging
+from datetime import datetime
+import subprocess
+import tempfile
+import shutil
+from database import update_hive_health_in_db
+
+# Ensure matplotlib runs in non-GUI mode
+import matplotlib
+matplotlib.use("Agg")
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Google Drive API Setup
+SCOPES = ['https://www.googleapis.com/auth/drive.file']
+PARENT_FOLDER_ID = os.getenv("GOOGLE_DRIVE_FOLDER_ID")
+
+service_account_info = json.loads(os.getenv("G_Drive_Credentials"))
+credentials = service_account.Credentials.from_service_account_info(service_account_info)
+
+# Initialize Google Drive API
+drive_service = build("drive", "v3", credentials=credentials)
+
+# Load the bee/no bee model
+MODEL_PATH = "./mobilenet_best_model_merged_bee_nobee.keras"
+bee_model = load_model(MODEL_PATH)
+
+# Load the queen model (MobileNet)
+QUEEN_MODEL_PATH = "./mobilenet_best_model_merged_queen_noqueen.keras"
+queen_model = load_model(QUEEN_MODEL_PATH)
+
+# Load the mite attack model (MobileNet)
+MITE_MODEL_PATH = "./mobilenet_best_model_merged_mite_nomite.keras"
+mite_model = load_model(MITE_MODEL_PATH)
+
+def check_ffmpeg():
+    """Check if FFmpeg is available."""
+    return shutil.which("ffmpeg") is not None
+
+def convert_to_wav(input_path, output_path):
+    """Convert audio file to WAV format using FFmpeg."""
+    try:
+        if not os.path.exists(input_path):
+            raise FileNotFoundError("Input audio file does not exist")
+        
+        if not check_ffmpeg():
+            raise RuntimeError("FFmpeg is not installed or not found in PATH")
+        
+        cmd = [
+            "ffmpeg",
+            "-i", input_path,
+            "-acodec", "pcm_s16le",
+            "-ar", "44100",
+            "-ac", "2",
+            "-y",
+            output_path
+        ]
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"FFmpeg conversion failed: {result.stderr}")
+        
+        logger.info(f"Converted {input_path} to {output_path}")
+        return output_path
+    
+    except Exception as e:
+        logger.error(f"Error converting audio to WAV: {str(e)}")
+        raise
+
+def get_or_create_folder(folder_name, parent_id):
+    """Retrieve or create a folder in Google Drive and return its ID."""
+    query = f"name='{folder_name}' and mimeType='application/vnd.google-apps.folder' and '{parent_id}' in parents and trashed=false"
+    response = drive_service.files().list(q=query, spaces='drive', fields='files(id, name)').execute()
+    files = response.get('files', [])
+    
+    if files:
+        return files[0].get('id')
+    
+    folder_metadata = {
+        'name': folder_name,
+        'mimeType': 'application/vnd.google-apps.folder',
+        'parents': [parent_id]
+    }
+    folder = drive_service.files().create(body=folder_metadata, fields='id').execute()
+    return folder.get('id')
+
+def upload_to_drive(audio_file, result, user_predict=None):
+    """Uploads an audio file to the appropriate Google Drive folder(s) based on prediction result and user_predict."""
+    try:
+        file_ids = []
+        
+        if result == "not bee":
+            folder_name = "not bee"
+            folder_id = get_or_create_folder(folder_name, PARENT_FOLDER_ID)
+            file_metadata = {
+                'name': audio_file.filename,
+                'parents': [folder_id]
+            }
+            media = MediaIoBaseUpload(audio_file, mimetype=audio_file.content_type, resumable=True)
+            file = drive_service.files().create(
+                body=file_metadata,
+                media_body=media,
+                fields='id'
+            ).execute()
+            file_ids.append(file.get('id'))
+            logger.info(f"Uploaded {audio_file.filename} to Google Drive folder '{folder_name}' with file ID: {file.get('id')}")
+        
+        else:
+            bee_folder_id = get_or_create_folder("bee", PARENT_FOLDER_ID)
+            audio_file.seek(0)
+            file_metadata = {
+                'name': audio_file.filename,
+                'parents': [bee_folder_id]
+            }
+            media = MediaIoBaseUpload(audio_file, mimetype=audio_file.content_type, resumable=True)
+            file = drive_service.files().create(
+                body=file_metadata,
+                media_body=media,
+                fields='id'
+            ).execute()
+            file_ids.append(file.get('id'))
+            logger.info(f"Uploaded {audio_file.filename} to Google Drive folder 'bee' with file ID: {file.get('id')}")
+            
+            if user_predict:
+                user_predict = user_predict.strip().lower()
+                valid_folders = {'healthy', 'no queen', 'mite attack', 'chalkbrood'}
+                if user_predict in valid_folders:
+                    folder_id = get_or_create_folder(user_predict, PARENT_FOLDER_ID)
+                    audio_file.seek(0)
+                    file_metadata = {
+                        'name': audio_file.filename,
+                        'parents': [folder_id]
+                    }
+                    media = MediaIoBaseUpload(audio_file, mimetype=audio_file.content_type, resumable=True)
+                    file = drive_service.files().create(
+                        body=file_metadata,
+                        media_body=media,
+                        fields='id'
+                    ).execute()
+                    file_ids.append(file.get('id'))
+                    logger.info(f"Uploaded {audio_file.filename} to Google Drive folder '{user_predict}' with file ID: {file.get('id')}")
+                else:
+                    logger.warning(f"Ignoring invalid user_predict value: {user_predict}")
+        
+        return file_ids[0]
+    
+    except Exception as e:
+        logger.error(f"Error uploading to Google Drive: {str(e)}")
+        raise
+
+def create_mel_spectrogram(audio_segment, sr):
+    """Creates a mel spectrogram from an audio segment."""
+    try:
+        spectrogram = librosa.feature.melspectrogram(y=audio_segment, sr=sr, n_mels=128)
+        spectrogram_db = librosa.power_to_db(spectrogram, ref=np.max)
+
+        plt.figure(figsize=(2, 2), dpi=100)
+        plt.axis('off')
+        plt.imshow(spectrogram_db, aspect='auto', cmap='magma', origin='lower')
+        plt.tight_layout(pad=0)
+        
+        temp_image_path = "/tmp/temp_spectrogram.png"
+        plt.savefig(temp_image_path, bbox_inches='tight', pad_inches=0)
+        plt.close()
+
+        img = Image.open(temp_image_path).convert('RGB')
+        img = img.resize((224, 224))
+        img_array = np.array(img) / 255.0
+
+        os.remove(temp_image_path)
+        return img_array
+
+    except Exception as e:
+        logger.error(f"Error creating spectrogram: {e}")
+        return None
+
+def predict_queen_audio(file_path, model):
+    """Processes audio for queen detection using 10-second segments."""
+    try:
+        y, sr = librosa.load(file_path, sr=None)
+        duration = librosa.get_duration(y=y, sr=sr)
+        if duration <= 10:
+            return {"error": "Audio file must be longer than 10 seconds"}
+
+        healthy_count = 0
+        total_segments = 0
+        segment_start = 0
+
+        while segment_start < duration:
+            segment_end = min(segment_start + 10, duration)
+            if segment_end - segment_start < 10 and segment_start > 0:
+                segment_start = max(0, duration - 10)
+                segment_end = duration
+
+            audio_segment = y[int(segment_start * sr):int(segment_end * sr)]
+            spectrogram = create_mel_spectrogram(audio_segment, sr)
+
+            if spectrogram is not None:
+                spectrogram = np.expand_dims(spectrogram, axis=0)
+                prediction = model.predict(spectrogram)
+                probability = prediction[0][0]  # Assuming binary classification (0: no queen, 1: healthy)
+                if probability >= 0.8:  # Aligned with predict_audio for consistency
+                    healthy_count += 1
+                total_segments += 1
+
+            segment_start += 10
+
+        if total_segments > 0:
+            healthy_percentage = (healthy_count / total_segments) * 100
+            result = "healthy" if healthy_percentage >= 70 else "no queen"
+            return result
+        else:
+            return {"error": "No valid segments processed"}
+
+    except Exception as e:
+        logger.error(f"Error in queen prediction: {e}")
+        return {"error": str(e)}
+
+def predict_mite_audio(file_path, model):
+    """Processes audio for mite attack detection using 10-second segments."""
+    try:
+        y, sr = librosa.load(file_path, sr=None)
+        duration = librosa.get_duration(y=y, sr=sr)
+        if duration <= 10:
+            return {"error": "Audio file must be longer than 10 seconds"}
+
+        healthy_count = 0
+        total_segments = 0
+        segment_start = 0
+
+        while segment_start < duration:
+            segment_end = min(segment_start + 10, duration)
+            if segment_end - segment_start < 10 and segment_start > 0:
+                segment_start = max(0, duration - 10)
+                segment_end = duration
+
+            audio_segment = y[int(segment_start * sr):int(segment_end * sr)]
+            spectrogram = create_mel_spectrogram(audio_segment, sr)
+
+            if spectrogram is not None:
+                spectrogram = np.expand_dims(spectrogram, axis=0)
+                prediction = model.predict(spectrogram)
+                probability = prediction[0][0]  # Assuming binary classification (0: mite attack, 1: healthy)
+                if probability >= 0.8:  # Consistent threshold
+                    healthy_count += 1
+                total_segments += 1
+
+            segment_start += 10
+
+        if total_segments > 0:
+            healthy_percentage = (healthy_count / total_segments) * 100
+            result = "healthy" if healthy_percentage >= 70 else "mite attack"
+            return result
+        else:
+            return {"error": "No valid segments processed"}
+
+    except Exception as e:
+        logger.error(f"Error in mite attack prediction: {e}")
+        return {"error": str(e)}
+
+def predict_audio(audio_path, request_id):
+    """Predicts whether an audio file contains bee sounds."""
+    try:
+        y, sr = librosa.load(audio_path, sr=None)
+        if y is None or sr is None:
+            return {"error": "Failed to load audio"}
+
+        duration = librosa.get_duration(y=y, sr=sr)
+        if duration <= 10:
+            return {"error": "Audio file must be longer than 10 seconds"}
+
+        bee_count = 0
+        total_segments = 0
+        segment_start = 0
+
+        while segment_start < duration:
+            segment_end = min(segment_start + 10, duration)
+            if segment_end - segment_start < 10 and segment_start > 0:
+                segment_start = max(0, duration - 10)
+                segment_end = duration
+
+            audio_segment = y[int(segment_start * sr):int(segment_end * sr)]
+            spectrogram = create_mel_spectrogram(audio_segment, sr)
+
+            if spectrogram is not None:
+                spectrogram = np.expand_dims(spectrogram, axis=0)
+                prediction = bee_model.predict(spectrogram)
+                probability = prediction[0][0]
+
+                if probability <= 0.2:
+                    bee_count += 1
+
+                total_segments += 1
+
+            segment_start += 10
+
+        if total_segments > 0:
+            bee_percentage = (bee_count / total_segments) * 100
+            result = "bee" if bee_percentage >= 70 else "not bee"
+            logger.info(f"Request {request_id} - Prediction result: {result}")
+            return {"result": result}
+        else:
+            return {"result": "try again"}
+
+    except Exception as e:
+        logger.error(f"Request {request_id} - Error during bee prediction: {e}")
+        return {"error": str(e)}
+
+def handle_predict(request, save_prediction):
+    """Handles the prediction logic for the /predict route."""
+    request_id = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    logger.info(f"Request {request_id} - Starting prediction")
+
+    if 'audio' not in request.files or 'user_id' not in request.form:
+        logger.error(f"Request {request_id} - Missing data")
+        return jsonify({"error": "Missing data"}), 400
+
+    user_id = request.form['user_id']
+    audio_file = request.files['audio']
+    hive_id = request.form.get('hive_id')
+    user_predict = request.form.get('user_predict')
+    
+    if audio_file.filename == '':
+        logger.error(f"Request {request_id} - No file selected")
+        return jsonify({"error": "No file selected"}), 400
+
+    if not check_ffmpeg():
+        logger.error(f"Request {request_id} - FFmpeg not found")
+        return jsonify({"error": "Server error: FFmpeg is not available"}), 500
+
+    temp_dir = tempfile.gettempdir()
+    original_filename = audio_file.filename
+    original_ext = os.path.splitext(original_filename)[1].lower()
+    temp_original_path = os.path.join(temp_dir, f"temp_audio_{request_id}{original_ext}")
+    audio_file.save(temp_original_path)
+
+    temp_wav_path = os.path.join(temp_dir, f"temp_audio_{request_id}.wav")
+    if original_ext not in ['.wav', '.mp3']:
+        try:
+            convert_to_wav(temp_original_path, temp_wav_path)
+        except Exception as e:
+            os.remove(temp_original_path)
+            logger.error(f"Request {request_id} - Audio conversion failed: {str(e)}")
+            return jsonify({"error": f"Failed to process audio file: {str(e)}"}), 400
+    else:
+        temp_wav_path = temp_original_path
+        logger.info(f"Request {request_id} - Using original file (no conversion needed): {temp_wav_path}")
+
+    prediction_result = predict_audio(temp_wav_path, request_id)
+    
+    if "error" in prediction_result:
+        os.remove(temp_original_path)
+        if temp_wav_path != temp_original_path and os.path.exists(temp_wav_path):
+            os.remove(temp_wav_path)
+        logger.error(f"Request {request_id} - Prediction failed: {prediction_result['error']}")
+        return jsonify({"result": "try again"}), 400
+
+    result = prediction_result["result"].lower()
+
+    if result == "try again":
+        os.remove(temp_original_path)
+        if temp_wav_path != temp_original_path and os.path.exists(temp_wav_path):
+            os.remove(temp_wav_path)
+        logger.info(f"Request {request_id} - Result: try again")
+        return jsonify({"result": "try again"})
+
+    if result == "bee":
+        queen_result = predict_queen_audio(temp_wav_path, queen_model)
+        mite_result = predict_mite_audio(temp_wav_path, mite_model)
+        
+        if "error" in queen_result or "error" in mite_result:
+            os.remove(temp_original_path)
+            if temp_wav_path != temp_original_path and os.path.exists(temp_wav_path):
+                os.remove(temp_wav_path)
+            logger.error(f"Request {request_id} - Queen prediction failed: {queen_result.get('error', 'Unknown')}, Mite prediction failed: {mite_result.get('error', 'Unknown')}")
+            return jsonify({"result": "try again"}), 400
+
+        logger.info(f"Request {request_id} - Queen prediction result: {queen_result}, Mite prediction result: {mite_result}")
+
+        # Combine results according to specified logic
+        if queen_result == "healthy" and mite_result == "healthy":
+            result = "healthy"
+        elif queen_result == "no queen" and mite_result == "healthy":
+            result = "no queen"
+        elif queen_result == "healthy" and mite_result == "mite attack":
+            result = "mite attack"
+        elif queen_result == "no queen" and mite_result == "mite attack":
+            result = "no queen,mite attack"
+        else:
+            result = "try again"  # Fallback for unexpected cases
+            logger.warning(f"Request {request_id} - Unexpected combination: queen={queen_result}, mite={mite_result}")
+
+    if user_predict and hive_id:
+        try:
+            user_predict = user_predict.strip().lower()
+            update_hive_health_in_db(hive_id, user_predict)
+            logger.info(f"Request {request_id} - Updated hive {hive_id} health_status to {user_predict}")
+        except Exception as e:
+            logger.error(f"Request {request_id} - Failed to update hive health status: {str(e)}")
+            return jsonify({"error": f"Failed to update hive health status: {str(e)}"}), 400
+
+    file_id = None
+    try:
+        audio_file.seek(0)
+        file_id = upload_to_drive(audio_file, result, user_predict)
+    except Exception as e:
+        logger.error(f"Request {request_id} - Failed to upload to Google Drive: {str(e)}")
+        # Continue with saving prediction and returning result with file_id=None
+
+    save_prediction(user_id, audio_file.filename, result, file_id, hive_id, user_predict)
+
+    os.remove(temp_original_path)
+    if temp_wav_path != temp_original_path and os.path.exists(temp_wav_path):
+        os.remove(temp_wav_path)
+
+    logger.info(f"Request {request_id} - Final result: {result}, file_id: {file_id}")
+    return jsonify({"result": result, "file_id": file_id})

preprocessor_config.json

@@ -0,0 +1,11 @@
+{
+  "crop_size": 224,
+  "do_center_crop": true,
+  "do_normalize": true,
+  "do_resize": true,
+  "feature_extractor_type": "ViTImageProcessor",
+  "image_mean": [0.5, 0.5, 0.5],
+  "image_std": [0.5, 0.5, 0.5],
+  "resample": 3,
+  "size": 224
+}

report.py

@@ -0,0 +1,317 @@
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib import colors
+from reportlab.lib.units import inch
+from database import get_farm_details_from_db, get_hives_from_db, get_hive_detail_from_db, get_history, get_user_profile
+from datetime import datetime
+import io
+import os
+import matplotlib
+matplotlib.use('Agg')  # Non-GUI backend for server environments
+import matplotlib.pyplot as plt
+import tempfile
+import uuid
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def create_table(data, col_widths=None):
+    """Helper function to create a styled table."""
+    table = Table(data, colWidths=col_widths)
+    table.setStyle(TableStyle([
+        ('GRID', (0, 0), (-1, -1), 1, colors.black),
+        ('FONT', (0, 0), (-1, -1), 'Helvetica', 10),
+        ('BACKGROUND', (0, 0), (-1, 0), colors.lightgrey),
+        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+        ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.black),
+        ('BOX', (0, 0), (-1, -1), 0.25, colors.black),
+        ('LEFTPADDING', (0, 0), (-1, -1), 6),
+        ('RIGHTPADDING', (0, 0), (-1, -1), 6),
+        ('TOPPADDING', (0, 0), (-1, -1), 6),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+    ]))
+    return table
+
+def create_pie_chart(data_counts, output_path, title):
+    """Generate a pie chart for given data distribution."""
+    try:
+        if not data_counts:
+            logger.warning(f"No data for {title} pie chart, skipping generation")
+            return False
+        
+        labels = list(data_counts.keys())
+        sizes = list(data_counts.values())
+        colors_list = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#ffb3e6', '#c2c2f0']
+        
+        plt.figure(figsize=(4, 4))
+        plt.pie(sizes, labels=labels, colors=colors_list[:len(labels)], autopct='%1.1f%%', startangle=90)
+        plt.axis('equal')  # Ensure circular shape
+        plt.title(title)
+        plt.savefig(output_path, bbox_inches='tight', dpi=150, format='png')
+        plt.close()
+        
+        if os.path.exists(output_path):
+            return True
+        else:
+            logger.error(f"Pie chart file not found at {output_path} after saving")
+            return False
+    except Exception as e:
+        logger.error(f"Error generating {title} pie chart: {str(e)}")
+        return False
+
+def create_bar_chart(history, output_path):
+    """Generate a bar chart for prediction results."""
+    try:
+        result_counts = {'healthy': 0, 'no queen': 0, 'not bee': 0}
+        for entry in history:
+            result = entry['result'].lower()
+            if result in result_counts:
+                result_counts[result] += 1
+        
+        labels = list(result_counts.keys())
+        counts = list(result_counts.values())
+        
+        plt.figure(figsize=(6, 4))
+        plt.bar(labels, counts, color=['#66b3ff', '#ff9999', '#99ff99'])
+        plt.xlabel('Prediction Result')
+        plt.ylabel('Count')
+        plt.title('Prediction Result Distribution')
+        for i, v in enumerate(counts):
+            plt.text(i, v + 0.1, str(v), ha='center')
+        plt.savefig(output_path, bbox_inches='tight', dpi=150, format='png')
+        plt.close()
+        
+        if os.path.exists(output_path):
+            return True
+        else:
+            logger.error(f"Bar chart file not found at {output_path} after saving")
+            return False
+    except Exception as e:
+        logger.error(f"Error generating bar chart: {str(e)}")
+        return False
+
+def add_footer(canvas, doc):
+    """Add a footer with page number to each page."""
+    canvas.saveState()
+    canvas.setFont('Helvetica', 9)
+    page_number = f"Page {doc.page}"
+    canvas.drawCentredString(letter[0] / 2, 0.5 * inch, page_number)
+    canvas.restoreState()
+
+def generate_report(user_id):
+    """
+    Generates a PDF report for a user's bee hives with visualizations and returns a BytesIO buffer.
+    
+    Args:
+        user_id (str): The ID of the user for whom the report is generated.
+    
+    Returns:
+        io.BytesIO: A buffer containing the generated PDF report.
+    
+    Raises:
+        Exception: If farm details are not found or an error occurs during report generation.
+    """
+    logger.info(f"Generating report for user_id: {user_id}")
+    
+    # Create a unique temporary directory for this report
+    temp_dir = os.path.join(tempfile.gettempdir(), f"report_{uuid.uuid4()}")
+    os.makedirs(temp_dir, exist_ok=True)
+    
+    try:
+        # Get user details
+        user = get_user_profile(user_id)
+        if 'error' in user:
+            logger.error(f"User not found for user_id: {user_id}")
+            user_details = ["User details not found."]
+        else:
+            user_details = [
+                f"Name: {user.get('fullname', 'N/A')}",
+                f"Email: {user.get('email', 'N/A')}",
+                f"Location: {user.get('city', 'N/A')}, {user.get('country', 'N/A')}",
+                f"Gender: {user.get('gender', 'N/A')}",
+                f"Phone: {user.get('phone_number', 'N/A')}"
+            ]
+
+        # Get farm details
+        farm = get_farm_details_from_db(user_id)
+        if not farm:
+            logger.error(f"No farm details found for user_id: {user_id}")
+            raise Exception("Farm details not found")
+
+        # Get hives
+        hives = get_hives_from_db(farm['farm_id'])
+        hive_details = []
+        health_status_counts = {}
+        bee_type_counts = {}
+
+        for hive in hives:
+            hive_detail = get_hive_detail_from_db(hive['hive_id'])
+            if 'error' not in hive_detail:
+                hive_details.append(hive_detail)
+                health_status = hive_detail.get('health_status', 'Unknown')
+                health_status_counts[health_status] = health_status_counts.get(health_status, 0) + 1
+                bee_type = hive_detail.get('bee_type', 'Unknown')
+                bee_type_counts[bee_type] = bee_type_counts.get(bee_type, 0) + 1
+
+        # Get prediction history
+        history = get_history(user_id)
+
+        # Generate recommendations
+        recommendations = []
+        if health_status_counts.get('Unhealthy', 0) > 0:
+            recommendations.append("Inspect hives with 'Unhealthy' status immediately and consult a beekeeping expert.")
+        if health_status_counts.get('Unknown', 0) > 0:
+            recommendations.append("Update health status for hives marked as 'Unknown' to ensure accurate monitoring.")
+        no_queen_count = sum(1 for entry in history if entry['result'].lower() == 'no queen')
+        if no_queen_count > len(history) * 0.3:  # More than 30% no queen results
+            recommendations.append("Multiple hives lack a queen. Consider introducing new queens or requeening.")
+        if len(history) > 0 and len([entry for entry in history if entry['result'].lower() == 'not bee']) > len(history) * 0.5:
+            recommendations.append("High number of 'not bee' predictions. Verify audio recordings and hive activity.")
+
+        # Create PDF
+        buffer = io.BytesIO()
+        doc = SimpleDocTemplate(buffer, pagesize=letter, topMargin=0.5*inch, bottomMargin=0.5*inch)
+        styles = getSampleStyleSheet()
+        
+        # Custom styles
+        styles.add(ParagraphStyle(name='CenteredTitle', parent=styles['Title'], alignment=1))
+        styles.add(ParagraphStyle(name='BoldNormal', parent=styles['Normal'], fontName='Helvetica-Bold'))
+
+        elements = []
+
+        # Title
+        elements.append(Paragraph("Bee Hive Monitoring Report", styles['CenteredTitle']))
+        elements.append(Paragraph(f"Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
+        elements.append(Spacer(1, 12))
+
+        # User Details
+        elements.append(Paragraph("User Details", styles['Heading2']))
+        for detail in user_details:
+            elements.append(Paragraph(detail, styles['Normal']))
+        elements.append(Spacer(1, 12))
+
+        # Farm Details
+        try:
+            farm_data = [
+                ["Farm ID", farm.get('farm_id', 'N/A')],
+                ["Name", farm.get('fullname', 'N/A')],
+                ["Location", f"{farm.get('city', 'N/A')}, {farm.get('country', 'N/A')} {farm.get('zip', 'N/A')}"]
+            ]
+            farm_table = create_table(farm_data, col_widths=[2*inch, 4*inch])
+            elements.append(farm_table)
+        except Exception as e:
+            logger.error(f"Error creating farm details table: {e}")
+            elements.append(Paragraph("Error: Unable to display farm details.", styles['Normal']))
+        elements.append(Spacer(1, 12))
+
+        # Hive Summary
+        elements.append(Paragraph("Hive Summary", styles['Heading2']))
+        hive_data = [["Hive #", "Bee Type", "Frames", "Health", "Created"]]
+        for hive in hive_details:
+            hive_data.append([
+                hive.get('hive_number', 'N/A'),
+                hive.get('bee_type', 'N/A'),
+                hive.get('number_of_frames', 'N/A'),
+                hive.get('health_status', 'Unknown'),
+                hive.get('creation_date', datetime.now()).strftime('%Y-%m-%d')
+            ])
+        hive_table = create_table(hive_data, col_widths=[1.2*inch, 1.8*inch, 1.2*inch, 1.2*inch, 1.6*inch])
+        elements.append(hive_table)
+        elements.append(Spacer(1, 12))
+
+        # Bee Type Distribution with Pie Chart
+        elements.append(Paragraph("Bee Type Distribution", styles['Heading2']))
+        bee_type_table = create_table([["Bee Type", "Count"]] + [[bt, count] for bt, count in bee_type_counts.items()], col_widths=[3*inch, 1*inch])
+        elements.append(bee_type_table)
+        bee_type_chart_path = os.path.join(temp_dir, f"bee_type_pie_{user_id}.png")
+        if bee_type_counts:
+            if create_pie_chart(bee_type_counts, bee_type_chart_path, "Bee Type Distribution"):
+                if os.path.exists(bee_type_chart_path):
+                    elements.append(Spacer(1, 12))
+                    elements.append(Image(bee_type_chart_path, width=3*inch, height=3*inch, kind='proportional'))
+                else:
+                    elements.append(Paragraph("Error: Unable to display bee type pie chart.", styles['Normal']))
+            else:
+                elements.append(Paragraph("No bee type data available for pie chart.", styles['Normal']))
+        else:
+            elements.append(Paragraph("No bee type data available for pie chart.", styles['Normal']))
+        elements.append(Spacer(1, 12))
+
+        # Health Status Overview with Pie Chart
+        elements.append(Paragraph("Health Status Overview", styles['Heading2']))
+        health_data = [[status, count] for status, count in health_status_counts.items()]
+        health_table = create_table([["Status", "Count"]] + health_data, col_widths=[3*inch, 1*inch])
+        elements.append(health_table)
+        health_chart_path = os.path.join(temp_dir, f"health_pie_{user_id}.png")
+        if health_status_counts:
+            if create_pie_chart(health_status_counts, health_chart_path, "Health Status Distribution"):
+                if os.path.exists(health_chart_path):
+                    elements.append(Spacer(1, 12))
+                    elements.append(Image(health_chart_path, width=3*inch, height=3*inch, kind='proportional'))
+                else:
+                    elements.append(Paragraph("Error: Unable to display health status pie chart.", styles['Normal']))
+            else:
+                elements.append(Paragraph("No health status data available for pie chart.", styles['Normal']))
+        else:
+            elements.append(Paragraph("No health status data available for pie chart.", styles['Normal']))
+        elements.append(Spacer(1, 12))
+
+        # Prediction History with Bar Chart
+        elements.append(Paragraph("Prediction History", styles['Heading2']))
+        history_data = [["Timestamp", "Audio", "Result", "Hive #"]]
+        for entry in history[:10]:
+            history_data.append([
+                entry.get('timestamp', 'N/A'),
+                entry.get('audio_name', 'N/A'),
+                entry.get('result', 'N/A'),
+                entry.get('hive_number', 'N/A') or "N/A"
+            ])
+        history_table = create_table(history_data, col_widths=[1.5*inch, 2*inch, 1*inch, 1*inch])
+        elements.append(history_table)
+        bar_chart_path = os.path.join(temp_dir, f"prediction_bar_{user_id}.png")
+        if history:
+            if create_bar_chart(history, bar_chart_path):
+                if os.path.exists(bar_chart_path):
+                    elements.append(Spacer(1, 12))
+                    elements.append(Image(bar_chart_path, width=4*inch, height=2.5*inch))
+                else:
+                    elements.append(Paragraph("Error: Unable to display prediction history bar chart.", styles['Normal']))
+            else:
+                elements.append(Paragraph("No prediction data available for bar chart.", styles['Normal']))
+        else:
+            elements.append(Paragraph("No prediction data available for bar chart.", styles['Normal']))
+        elements.append(Spacer(1, 12))
+
+        # Recommendations
+        elements.append(Paragraph("Recommendations", styles['Heading2']))
+        for rec in recommendations:
+            elements.append(Paragraph(f"• {rec}", styles['BoldNormal']))
+        elements.append(Spacer(1, 12))
+
+        # Build PDF with footer
+        try:
+            doc.build(elements, onFirstPage=add_footer, onLaterPages=add_footer)
+        except Exception as e:
+            logger.error(f"Error building PDF: {e}")
+            raise Exception(f"Failed to generate PDF: {e}")
+
+    finally:
+        # Clean up temporary directory
+        if os.path.exists(temp_dir):
+            for file in os.listdir(temp_dir):
+                try:
+                    os.remove(os.path.join(temp_dir, file))
+                except Exception as e:
+                    logger.error(f"Error cleaning up file {file}: {e}")
+            try:
+                os.rmdir(temp_dir)
+            except Exception as e:
+                logger.error(f"Error cleaning up directory {temp_dir}: {e}")
+
+    buffer.seek(0)
+    logger.info(f"Report generated successfully for user_id: {user_id}")
+    return buffer

requirements.txt

@@ -0,0 +1,21 @@
+tensorflow
+librosa==0.9.2
+numba==0.56.4
+llvmlite==0.39.1
+reportlab
+matplotlib
+pillow
+torch
+soundfile
+Flask==2.3.3
+flask-cors==4.0.0
+psycopg2-binary==2.9.9
+google-auth==2.27.0
+google-auth-oauthlib==1.1.0
+google-auth-httplib2==0.2.0
+google-api-python-client==2.123.0
+flask-dance
+Authlib
+requests
+sendgrid
+apscheduler