Upload 7 files

.gitattributes

@@ -1,53 +1,53 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-testimages/003f0afdcd15.png filter=lfs diff=lfs merge=lfs -text
-testimages/005b95c28852.png filter=lfs diff=lfs merge=lfs -text
-testimages/dyedlifted1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/dyedlifted2.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/dyedresection1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/dyedresection2.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/esophagitis1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/esophagitis2.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/normalceacum1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/normalceacum2.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/normalpylorus1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/normalpylorus2.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/normalzline1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/normalzline2.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/polypus1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/polypus2.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/ulcerative1.jpg filter=lfs diff=lfs merge=lfs -text
-testimages/ulcerative2.jpg filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+testimages/003f0afdcd15.png filter=lfs diff=lfs merge=lfs -text
+testimages/005b95c28852.png filter=lfs diff=lfs merge=lfs -text
+testimages/dyedlifted1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/dyedlifted2.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/dyedresection1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/dyedresection2.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/esophagitis1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/esophagitis2.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/normalceacum1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/normalceacum2.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/normalpylorus1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/normalpylorus2.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/normalzline1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/normalzline2.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/polypus1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/polypus2.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/ulcerative1.jpg filter=lfs diff=lfs merge=lfs -text
+testimages/ulcerative2.jpg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,27 @@
+# Use a Python 3.10 runtime
+FROM python:3.10-slim
+
+# Install Tesseract OCR Engine and other required system dependencies
+# (Keeping this in case you switch back later)
+RUN apt-get update && apt-get install -y \
+    tesseract-ocr \
+    build-essential \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory
+WORKDIR /code
+
+# Copy and install Python packages
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Copy the rest of the application code
+COPY . /code/
+
+# Command to run your ORIGINAL app.py file
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app"]

README.md

@@ -1,13 +1,8 @@
----
-title: AI Medical
-emoji: 📈
-colorFrom: pink
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
-short_description: New Medical repository
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+metadatatitle: Medical Report Analyzer
+emoji: 🩺
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+---

app.py

@@ -0,0 +1,413 @@
+import os
+# --- FIX: Disable GPU to prevent CUDA initialization errors ---
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+
+from flask import Flask, render_template, request, jsonify, session, redirect, url_for, send_from_directory
+from flask_pymongo import PyMongo
+from flask_bcrypt import Bcrypt
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+import numpy as np
+import cv2
+import google.generativeai as genai
+from dotenv import load_dotenv
+import certifi
+import uuid
+import secrets
+import logging
+
+# -------------------- Setup & Config --------------------
+
+# Load environment variables
+load_dotenv()
+
+app = Flask(__name__)
+
+# Configurations
+app.config["MONGO_URI"] = os.getenv("MONGODB_URI") or os.getenv("MONGO_URI")
+# Keep your format, just ensure it's set once per process
+app.config['SECRET_KEY'] = os.getenv("SECRET_KEY") or secrets.token_hex(16)
+
+# Slightly safer cookie defaults without changing your session usage
+app.config.setdefault("SESSION_COOKIE_HTTPONLY", True)
+app.config.setdefault("SESSION_COOKIE_SAMESITE", "Lax")
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+
+# Basic logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("app")
+
+# Initialize extensions
+# If MONGO_URI missing, still construct PyMongo but avoid immediate use crashes
+try:
+    if app.config["MONGO_URI"]:
+        mongo = PyMongo(app, tlsCAFile=certifi.where())
+    else:
+        logger.warning("MONGO_URI not set. MongoDB operations will fail.")
+        mongo = PyMongo(app, tlsCAFile=certifi.where())
+except Exception as e:
+    logger.error(f"Mongo initialization error: {e}")
+    # Keep an object to avoid NameError later
+    mongo = None
+
+bcrypt = Bcrypt(app)
+
+# Configure Gemini
+gemini_model = "gemini-2.0-flash"
+if GEMINI_API_KEY:
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)
+        # Keep your model name
+        gemini_model = genai.GenerativeModel('gemini-2.0-flash')
+    except Exception as e:
+        logger.error(f"Gemini initialization error: {e}")
+else:
+    logger.warning("GEMINI_API_KEY/GOOGLE_API_KEY not set. /chat will return a friendly error.")
+
+# --- Model Configuration ---
+MODEL_CONFIG = {
+    "Pneumonia": {
+        "path": "model/best_pneumonia_model.h5",
+        "labels": ["Normal", "Pneumonia"],
+        "last_conv_layer": "relu",
+        "input_size": (224, 224)
+    },
+    "Tuberculosis": {
+        "path": "model/best_tuberculosis_model.h5",
+        "labels": ["Normal", "Tuberculosis"],
+        "last_conv_layer": "relu",
+        "input_size": (224, 224)
+    },
+    "Brain Tumor": {
+        "path": "model/best_braintumor_model.h5",
+        "labels": ["glioma", "meningioma", "notumor", "pituitary"],
+        "last_conv_layer": "relu",
+        "input_size": (224, 224)
+    },
+    "Skin Cancer": {
+        "path": "model/best_skincancer_model.h5",
+        "labels": ["Actinic keratoses", "Basal cell carcinoma", "Benign keratosis-like lesions",
+                   "Dermatofibroma", "Melanoma", "Melanocytic nevi", "Vascular lesions"],
+        "last_conv_layer": "relu",
+        "input_size": (224, 224)
+    },
+    "Kvasir": {
+        "path": "model/best_kvasir_model.h5",
+        "labels": ["dyed-lifted-polyps", "dyed-resection-margins", "esophagitis",
+                   "normal-cecum", "normal-pylorus", "normal-z-line", "polyps", "ulcerative-colitis"],
+        "last_conv_layer": "relu",
+        "input_size": (224, 224)
+    }
+}
+
+# --- Model Loading ---
+models = {}
+
+def load_all_models():
+    """Loads all models from the 'model' directory based on MODEL_CONFIG."""
+    for name, config in MODEL_CONFIG.items():
+        try:
+            model_path = config["path"]
+            if os.path.exists(model_path):
+                models[name] = load_model(model_path, compile=False)
+                logger.info(f"Successfully loaded {name} model from {model_path}.")
+            else:
+                logger.warning(f"Model file not found at {model_path}")
+        except Exception as e:
+            logger.error(f"Error loading model {name}: {e}")
+
+# Load models on application startup
+load_all_models()
+
+# --- Image Preprocessing ---
+def preprocess_image(img_path, target_size=(224, 224)):
+    """Preprocesses the image for model prediction."""
+    img = image.load_img(img_path, target_size=target_size)
+    img_array = image.img_to_array(img)
+    # Handle grayscale or alpha automatically by broadcasting if needed
+    if img_array.ndim == 2:
+        img_array = np.stack([img_array]*3, axis=-1)
+    elif img_array.shape[-1] == 4:
+        img_array = img_array[..., :3]
+    img_array = np.expand_dims(img_array, axis=0)
+    img_array = img_array.astype("float32") / 255.0
+    return img_array
+
+# --- Grad-CAM Utilities ---
+def _safe_get_layer(model, layer_name):
+    """Return layer if exists; else None."""
+    try:
+        return model.get_layer(layer_name)
+    except Exception:
+        return None
+
+def find_last_conv_layer(model):
+    """Finds the name of the last convolutional layer in a model."""
+    logger.info("--- DEBUG: Searching for last convolutional layer ---")
+    for layer in reversed(model.layers):
+        if isinstance(layer, (tf.keras.layers.Conv2D, tf.keras.layers.DepthwiseConv2D)):
+            # 4D output: (batch, h, w, channels)
+            try:
+                out_shape = layer.output_shape
+            except Exception:
+                out_shape = None
+            if out_shape and len(out_shape) == 4:
+                logger.info(f"Found candidate last conv layer: {layer.name}")
+                return layer.name
+    raise ValueError("Could not automatically find a convolutional layer in the model.")
+
+def get_gradcam_heatmap(model, img_array, last_conv_layer_name, pred_index=None):
+    """Generates a Grad-CAM heatmap."""
+    # If configured layer isn't present, auto-detect
+    if not _safe_get_layer(model, last_conv_layer_name):
+        last_conv_layer_name = find_last_conv_layer(model)
+
+    conv_layer = model.get_layer(last_conv_layer_name)
+    grad_model = tf.keras.models.Model(
+        [model.inputs], [conv_layer.output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        conv_outputs, preds = grad_model(img_array, training=False)
+
+        if isinstance(preds, (list, tuple)):
+            preds = preds[0]
+
+        # Ensure preds is a tensor
+        preds = tf.convert_to_tensor(preds)
+
+        # If model is binary with single logit/sigmoid output
+        if preds.shape.rank is not None and preds.shape[-1] == 1:
+            class_channel = preds[:, 0]
+        else:
+            if pred_index is None:
+                pred_index = tf.argmax(preds[0])
+            class_channel = preds[:, pred_index]
+
+    grads = tape.gradient(class_channel, conv_outputs)
+    if grads is None:
+        # Fallback: no gradient (e.g., custom layers). Return uniform zeros heatmap.
+        heatmap = tf.zeros(conv_outputs.shape[1:3], dtype=tf.float32)
+        return heatmap.numpy()
+
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    conv_outputs = conv_outputs[0]
+    heatmap = tf.tensordot(conv_outputs, pooled_grads, axes=(2, 0))
+
+    heatmap = tf.maximum(heatmap, 0)
+    denom = tf.math.reduce_max(heatmap)
+    heatmap = heatmap / (denom + 1e-8)
+    return heatmap.numpy()
+
+def save_gradcam_image(img_path, heatmap, output_path, threshold=0.6, alpha=0.4):
+    """
+    Saves the Grad-CAM image by highlighting only the most important areas
+    with light red spots.
+    """
+    img = cv2.imread(img_path)
+    if img is None:
+        raise ValueError("Failed to read image with OpenCV.")
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Work with RGB
+
+    heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
+
+    # Create a mask where the heatmap is above the threshold
+    mask = heatmap > threshold
+
+    # Create a red overlay
+    overlay = np.zeros_like(img, dtype=np.uint8)
+    overlay[mask] = [255, 0, 0]  # Red color for highlighted spots
+
+    # Blend the original image with the red overlay using the mask
+    superimposed_img = cv2.addWeighted(overlay, alpha, img, 1 - alpha, 0)
+
+    # Areas outside the mask should be the original image
+    superimposed_img[~mask] = img[~mask]
+
+    superimposed_img = cv2.cvtColor(superimposed_img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(output_path, superimposed_img)
+    return output_path
+
+# -------------------- Routes --------------------
+
+@app.route("/")
+def home():
+    return redirect(url_for('index'))
+
+@app.route('/tmp/<path:filename>')
+def serve_tmp_file(filename):
+    return send_from_directory('/tmp', filename)
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    # Authentication removed; redirect to main app
+    return redirect(url_for('index'))
+
+@app.route('/signup', methods=['GET', 'POST'])
+def signup():
+    # Authentication removed; redirect to main app
+    return redirect(url_for('index'))
+
+@app.route('/index')
+def index():
+    # Publicly accessible index
+    return render_template('index.html')
+
+@app.route('/logout')
+def logout():
+    # Authentication removed; redirect to main app
+    return redirect(url_for('index'))
+
+def _postprocess_binary_prediction(raw):
+    """
+    Normalize binary outputs across shapes:
+    - (1,) or (N,)      : sigmoid probabilities
+    - (1,1) or (N,1)    : sigmoid probabilities
+    - logits also supported (auto-sigmoid)
+    Returns probability in [0,1].
+    """
+    arr = np.array(raw, dtype=np.float32)
+    arr = np.squeeze(arr)
+    # If scalar, keep it
+    if arr.ndim == 0:
+        prob = float(arr)
+        # Heuristic: if obviously a logit (|x|>1 and not in [0,1]), apply sigmoid
+        if prob < 0.0 or prob > 1.0:
+            prob = float(1.0 / (1.0 + np.exp(-prob)))
+        return min(max(prob, 0.0), 1.0)
+    # If 1D vector, take first
+    prob = float(arr[0])
+    if prob < 0.0 or prob > 1.0:
+        prob = float(1.0 / (1.0 + np.exp(-prob)))
+    return min(max(prob, 0.0), 1.0)
+
+@app.route("/predict", methods=["POST"])
+def predict():
+    if "file" not in request.files:
+        return jsonify({"error": "No file part"}), 400
+
+    file = request.files["file"]
+    model_name = request.form.get("model")
+
+    if not file or file.filename == "":
+        return jsonify({"error": "No selected file"}), 400
+
+    if model_name not in models:
+        return jsonify({"error": "Invalid model selected"}), 400
+
+    try:
+        filename = f"{uuid.uuid4()}_{file.filename}"
+        filepath = os.path.join("/tmp", filename)
+        file.save(filepath)
+
+        model_config = MODEL_CONFIG[model_name]
+        model = models[model_name]
+        labels = model_config["labels"]
+        input_size = model_config.get("input_size", (224, 224))
+
+        img_array = preprocess_image(filepath, target_size=input_size)
+        prediction = model.predict(img_array, verbose=0)
+
+        # Ensure numpy array
+        prediction = np.array(prediction)
+
+        # Binary case (2 labels) with single neuron output (logit or sigmoid)
+        if len(labels) == 2 and prediction.ndim >= 1 and prediction.shape[-1] in (1,) and prediction.size >= 1:
+            prob_pos = _postprocess_binary_prediction(prediction)
+            if prob_pos >= 0.5:
+                predicted_index = 1
+                predicted_label = labels[1]
+                confidence = prob_pos
+            else:
+                predicted_index = 0
+                predicted_label = labels[0]
+                confidence = 1.0 - prob_pos
+        else:
+            # Multi-class: softmax or logits
+            if prediction.ndim == 2:
+                vec = prediction[0]
+            else:
+                vec = prediction.reshape(-1)
+            # If appears to be logits, apply softmax for confidence; otherwise trust as probs
+            if np.any(vec < 0) or np.any(vec > 1) or not np.isclose(np.sum(vec), 1.0, atol=1e-3):
+                exps = np.exp(vec - np.max(vec))
+                probs = exps / (np.sum(exps) + 1e-8)
+            else:
+                probs = vec
+            predicted_index = int(np.argmax(probs))
+            predicted_label = labels[predicted_index]
+            confidence = float(np.max(probs))
+
+        gradcam_url = None
+        try:
+            logger.info(f"--- Generating Grad-CAM for model: {model_name} ---")
+            last_conv_layer_name = MODEL_CONFIG[model_name].get('last_conv_layer') or ""
+            heatmap = get_gradcam_heatmap(model, img_array, last_conv_layer_name, pred_index=predicted_index)
+
+            gradcam_filename = f"gradcam_{filename}"
+            gradcam_filepath = os.path.join("/tmp", gradcam_filename)
+            save_gradcam_image(filepath, heatmap, gradcam_filepath)
+            gradcam_url = url_for('serve_tmp_file', filename=gradcam_filename)
+            logger.info("--- Successfully generated Grad-CAM image ---")
+        except Exception as e:
+            logger.error(f"--- Grad-CAM Generation FAILED for model: {model_name} --- Error: {e}")
+            try:
+                model.summary(print_fn=lambda x: logger.info(x))
+            except Exception:
+                pass
+
+        return jsonify({
+            "original_image": url_for('serve_tmp_file', filename=filename),
+            "gradcam_image": gradcam_url,
+            "prediction": str(predicted_label),
+            "confidence": float(confidence),
+            "model_used": str(model_name)
+        })
+    except Exception as e:
+        logger.exception("Prediction error")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/chat", methods=["POST"])
+def chat():
+    data = request.get_json(silent=True) or {}
+    user_message = data.get("message", "")
+    prediction_context = data.get("context") or {}
+
+    # Guard against missing keys
+    model_used = prediction_context.get('model_used', 'Unknown Model')
+    pred_label = prediction_context.get('prediction', 'Unknown')
+    conf = prediction_context.get('confidence', 0.0)
+    try:
+        conf_pct = float(conf) * 100.0
+    except Exception:
+        conf_pct = 0.0
+
+    prompt = f"""
+You are a helpful medical assistant chatbot.
+A medical image was analyzed with the following results:
+- Model Used: {model_used}
+- Prediction: {pred_label}
+- Confidence Score: {conf_pct:.2f}%
+The user's question is: "{user_message}"
+Based on this context, provide a helpful and informative response.
+Do not provide a diagnosis. Advise the user to consult a medical professional.
+"""
+
+    try:
+        if gemini_model is None:
+            return jsonify({"error": "Gemini API not configured. Set GEMINI_API_KEY in environment."}), 500
+        response = gemini_model.generate_content(prompt)
+        # Some SDKs return .text; guard if attribute missing
+        text = getattr(response, "text", None)
+        if not text:
+            # Try to stringify safely
+            text = str(response)
+        return jsonify({"response": text})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == "__main__":
+    # Keep your debug flag as-is
+    app.run(debug=True)

report_analyzer_app.py

@@ -0,0 +1,120 @@
+import os
+from flask import Flask, request, jsonify, render_template
+from flask_pymongo import PyMongo
+from flask_bcrypt import Bcrypt
+import secrets
+import google.generativeai as genai
+import markdown
+from PIL import Image
+import pytesseract  # For OCR
+import fitz  # PyMuPDF for reading PDFs
+import io
+
+# --- Basic Flask App Setup ---
+app = Flask(__name__)
+
+# --- Configurations ---
+app.config['SECRET_KEY'] = os.getenv('SECRET_KEY') or secrets.token_hex(16)
+app.config['MONGO_URI'] = os.getenv('MONGODB_URI') or os.getenv('MONGO_URI')
+
+# --- Gemini API Configuration ---
+GOOGLE_API_KEY = os.getenv('GEMINI_API_KEY') or os.getenv('GOOGLE_API_KEY')
+try:
+    if GOOGLE_API_KEY:
+        genai.configure(api_key=GOOGLE_API_KEY)
+    else:
+        print("Warning: GEMINI_API_KEY/GOOGLE_API_KEY not set; analysis will fail until configured.")
+except Exception as e:
+    print(f"Error configuring Gemini API: {e}\nPlease make sure the GEMINI_API_KEY or GOOGLE_API_KEY environment variable is set.")
+
+# --- Initialize Extensions ---
+mongo = PyMongo(app)
+bcrypt = Bcrypt(app)
+
+# --- User Model for Flask-Login ---
+# Authentication removed: no user model or login manager
+
+# --- Helper function for Gemini Analysis ---
+def get_simplified_report(report_text):
+    """Sends text to Gemini and returns a simplified, markdown-formatted report."""
+    if not report_text or not report_text.strip():
+        raise ValueError("Extracted text is empty.")
+        
+    model = genai.GenerativeModel('gemini-2.0-flash')
+    prompt = f"""
+    You are an expert medical assistant. Your task is to translate the following medical report into simple, clear, and easy-to-understand language for a patient with no medical background.
+
+    Instructions:
+    1.  Start with a one-sentence summary of the main finding.
+    2.  Create a "Key Findings" section using bullet points.
+    3.  For each technical term or measurement, first state the term from the report, then explain what it means in simple words and whether the result is normal, high, or low.
+    4.  Maintain a reassuring and professional tone.
+    5.  Conclude with a clear disclaimer: "This is a simplified summary and not a substitute for professional medical advice. Please discuss the full report with your doctor."
+    6.  Format the entire output in Markdown.
+
+    Medical Report to Analyze:
+    ---
+    {report_text}
+    ---
+    """
+    response = model.generate_content(prompt)
+    return markdown.markdown(response.text)
+
+# --- Authentication routes removed; app is public ---
+
+# --- Main Application Routes ---
+@app.route('/')
+def index():
+    # Publicly accessible page
+    return render_template('report_analyzer.html')
+
+@app.route('/analyze_report_text', methods=['POST'])
+def analyze_report_text():
+    """Analyzes a report submitted as plain text."""
+    try:
+        data = request.get_json()
+        report_text = data.get('report_text')
+        if not report_text or not report_text.strip():
+            return jsonify({'error': 'Report text cannot be empty.'}), 400
+        
+        html_response = get_simplified_report(report_text)
+        return jsonify({'simplified_report': html_response})
+
+    except Exception as e:
+        print(f"Error during text report analysis: {e}")
+        return jsonify({'error': 'An internal error occurred during report analysis.'}), 500
+
+@app.route('/analyze_report_file', methods=['POST'])
+def analyze_report_file():
+    """Analyzes a report submitted as a PDF or Image file."""
+    try:
+        if 'report_file' not in request.files:
+            return jsonify({'error': 'No file part in the request.'}), 400
+        
+        file = request.files['report_file']
+        if file.filename == '':
+            return jsonify({'error': 'No file selected.'}), 400
+
+        report_text = ""
+        # Check file extension
+        if file.filename.lower().endswith('.pdf'):
+            pdf_document = fitz.open(stream=file.read(), filetype="pdf")
+            for page in pdf_document:
+                report_text += page.get_text()
+            pdf_document.close()
+        elif file.filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+            image = Image.open(file.stream)
+            report_text = pytesseract.image_to_string(image)
+        else:
+            return jsonify({'error': 'Unsupported file type. Please upload a PDF or an image.'}), 400
+
+        html_response = get_simplified_report(report_text)
+        return jsonify({'simplified_report': html_response})
+
+    except Exception as e:
+        print(f"Error during file report analysis: {e}")
+        return jsonify({'error': 'An internal error occurred during file analysis.'}), 500
+
+# --- Run the Application ---
+if __name__ == '__main__':
+    app.run(port=5001, debug=True)

requirements.txt

@@ -0,0 +1,13 @@
+flask
+flask_pymongo
+flask_bcrypt
+tensorflow
+numpy
+opencv-python
+google-generativeai
+python-dotenv
+Pillow
+gunicorn
+markdown
+pytesseract
+pymupdf

train.py

@@ -0,0 +1,65 @@
+import os
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.applications import MobileNetV2
+from tensorflow.keras import layers, models
+from tensorflow.keras.optimizers import Adam
+
+# Updated path
+base_dir = 'data/chest_xray'
+train_dir = os.path.join(base_dir, 'train')
+val_dir = os.path.join(base_dir, 'val')
+
+# Parameters
+IMG_SIZE = (224, 224)
+BATCH_SIZE = 32
+EPOCHS = 5  # You can increase later
+
+# Data generators
+train_gen = ImageDataGenerator(
+    rescale=1./255,
+    rotation_range=10,
+    zoom_range=0.1,
+    horizontal_flip=True
+)
+
+val_gen = ImageDataGenerator(rescale=1./255)
+
+train_data = train_gen.flow_from_directory(
+    train_dir,
+    target_size=IMG_SIZE,
+    batch_size=BATCH_SIZE,
+    class_mode='binary'
+)
+
+val_data = val_gen.flow_from_directory(
+    val_dir,
+    target_size=IMG_SIZE,
+    batch_size=BATCH_SIZE,
+    class_mode='binary'
+)
+
+# MobileNetV2 base
+base_model = MobileNetV2(input_shape=(224, 224, 3), include_top=False, weights='imagenet')
+base_model.trainable = False
+
+# Custom head
+model = models.Sequential([
+    base_model,
+    layers.GlobalAveragePooling2D(),
+    layers.Dense(128, activation='relu'),
+    layers.Dropout(0.3),
+    layers.Dense(1, activation='sigmoid')  # Binary classifier
+])
+
+model.compile(optimizer=Adam(learning_rate=0.0001),
+              loss='binary_crossentropy',
+              metrics=['accuracy'])
+
+# Train
+model.fit(train_data, validation_data=val_data, epochs=EPOCHS)
+
+# Save model
+os.makedirs("model", exist_ok=True)
+model.save("model/pneumonia_model.h5")
+print("✅ Model saved as model/pneumonia_model.h5")