Update app.py

app.py

@@ -0,0 +1,446 @@
+from flask import Flask, render_template, request, send_file,abort,send_from_directory
+import torch
+from werkzeug.security import generate_password_hash, check_password_hash
+from flask import Flask, render_template, request, redirect, url_for, jsonify, session
+
+from flask import Flask, request, jsonify
+from pymongo import MongoClient
+import pickle
+from pymongo import MongoClient
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from PyPDF2 import PdfReader
+from docx import Document
+import re
+import seaborn as sns
+import matplotlib.pyplot as plt
+import os
+import string
+import requests
+from bs4 import BeautifulSoup
+from flask import jsonify
+from flask import Flask, render_template, request, jsonify
+from sentence_transformers import SentenceTransformer
+import faiss
+import fitz 
+import groq
+import PyPDF2
+import numpy as np
+from flask import Flask, render_template, request, redirect, url_for, flash, session
+from flask_argon2 import Argon2
+from pymongo import MongoClient
+import os
+import pdfplumber
+from groq import Groq
+import logging
+logging.getLogger("pdfminer").setLevel(logging.ERROR)
+
+
+
+app = Flask(__name__)
+
+GROQ_API_KEY = "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"
+cli = Groq(api_key=GROQ_API_KEY)
+
+# Load embedding model globally
+embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+
+# Load preprocessed data
+with open("data//legal_data.pkl", "rb") as f:
+    legal_data = pickle.load(f)
+
+# Load FAISS indices
+faiss_indices = {}
+for law in legal_data:
+    try:
+        index_path = f"data/{law.replace(' ', '_')}_faiss.index"
+        index = faiss.read_index(index_path)
+        faiss_indices[law] = (index, legal_data[law])
+    except Exception as e:
+        print(f"Error loading FAISS index for {law}: {str(e)}")
+
+# Helper to match section
+def get_exact_section(section_number, structured_data):
+    for section in structured_data:
+        if section["section_id"].strip() == section_number.strip():
+            return section
+    return None
+
+# Helper to find relevant section via similarity
+def find_relevant_section(query, model, index, structured_data, top_k=3):
+    query_embedding = model.encode([query])
+    distances, indices = index.search(np.array(query_embedding), top_k)
+    return [structured_data[i] for i in indices[0] if i < len(structured_data)]
+
+# Generate answer using Groq
+def generate_response_with_groq(prompt, section_number, book_name, context):
+    full_prompt = f"According to Section {section_number} of {book_name}, {prompt}"
+    try:
+        response = cli.chat.completions.create(
+            model="llama3-8b-8192",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a legal assistant providing detailed and comprehensive legal explanations based on Pakistani law. Always provide at least 5-6 sentences per response."
+                },
+                {
+                    "role": "user",
+                    "content": f"{full_prompt}\n\nContext: {context}"
+                }
+            ],
+            max_tokens=1000
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"Error with Groq API: {str(e)}")
+        return "Error communicating with Groq API."
+
+
+
+# Main route
+@app.route('/ask', methods=['POST'])
+def ask():
+    try:
+        # Ensure the request is JSON
+        if not request.is_json:
+            return jsonify({'response': 'Request must be JSON'}), 400
+
+        data = request.get_json()
+        query = data.get('query', '').strip()
+
+        if not query:
+            return jsonify({'response': 'Please enter a valid question.'}), 400
+
+        # Extract section number and book name using regex
+        pattern = r"what\s+is\s+section\s+no\.?\s*(\d+[A-Z]?(?:\(\d+\))?)\s+of\s+(.*)"
+        match = re.search(pattern, query, re.IGNORECASE)
+
+        if match:
+            section_number = match.group(1).strip()
+            book_name = match.group(2).strip()
+
+            matched_book = None
+            for law in legal_data:
+                if book_name.lower() in law.lower():
+                    matched_book = law
+                    break
+
+            if not matched_book:
+                return jsonify({'response': 'Book name not recognized. Please try again with a valid book name.'}), 404
+
+            index, structured_data = faiss_indices.get(matched_book, (None, None))
+            if index is None or structured_data is None:
+                return jsonify({'response': 'Error loading FAISS index for the selected law.'}), 500
+
+            exact_section = get_exact_section(section_number, structured_data)
+            if exact_section:
+                response = generate_response_with_groq(query, section_number, matched_book, exact_section['content'])
+                return jsonify({'response': response}), 200
+            else:
+                relevant = find_relevant_section(query, embedding_model, index, structured_data)
+                if relevant:
+                    response = generate_response_with_groq(query, relevant[0]['section_id'], matched_book, relevant[0]['content'])
+                    return jsonify({'response': response}), 200
+                else:
+                    return jsonify({'response': 'No relevant section found.'}), 404
+        else:
+            return jsonify({'response': 'Please ask your question in this format: "What is Section No. 302 of Pakistan Penal Code?"'}), 400
+
+    except Exception as e:
+        print(f"Server error at /ask: {str(e)}")
+        return jsonify({'response': 'An internal error occurred. Please try again later.'}), 500
+
+
+
+# Flask route
+
+
+# Load the fine-tuned Legal LED model
+MODEL_NAME = "Izza-shahzad-13/legal-LED-final"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)
+
+# Function to generate summary
+def generate_summary(text):
+    inputs = tokenizer.encode("summarize: " + text, return_tensors="pt", max_length=1024, truncation=True)
+    outputs = model.generate(inputs, max_length=800, min_length=40, length_penalty=2.0, num_beams=4, early_stopping=True)
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+# Function to calculate sentence importance scores
+def calculate_sentence_importance(summary):
+    sentences = summary.split(". ")
+    scores = [len(sentence) for sentence in sentences]  # Score based on sentence length
+    max_score = max(scores) if scores else 1
+    normalized_scores = [score / max_score for score in scores]
+    return sentences, normalized_scores
+
+# Function to generate heatmap
+def generate_heatmap(scores):
+    plt.figure(figsize=(10, 2))
+    sns.heatmap([scores], annot=True, cmap="coolwarm", xticklabels=False, yticklabels=False, cbar=True)
+    plt.title("Sentence Importance Heatmap")
+    plt.savefig("static/heatmap.png")  # Save heatmap image
+    plt.close()
+
+# Function to highlight sentences in the summary
+def highlight_summary(sentences, scores):
+    cmap = sns.color_palette("coolwarm", as_cmap=True)
+    highlighted_summary = ""
+
+    for sentence, score in zip(sentences, scores):
+        color = cmap(score)
+        rgb_color = f"rgb({int(color[0]*255)}, {int(color[1]*255)}, {int(color[2]*255)})"
+        highlighted_summary += f'<span style="background-color:{rgb_color};padding:2px;">{sentence}.</span> '
+
+    return highlighted_summary
+
+# Function to highlight legal terms
+def highlight_keywords(text):
+    patterns = {
+        'act_with_year': r'\b([A-Za-z\s]+(?:\sAct(?:\s[\d]{4})?))\s*,\s*(\d{4})\b',
+        'article': r'\bArticle\s\d{1,3}(-[A-Z])?\b',
+        'section': r'\bSection\s\d{1,3}[-A-Za-z]?\(?[a-zA-Z]?\)?\b',
+        'date': r'\b(?:[A-Za-z]+)\s\d{4}\b|\b\d{1,2}[-/]\d{1,2}[-/]\d{2,4}\b',
+        'persons': r'\b([A-Z][a-z]+(?:\s[A-Z][a-z]+)*)\b',
+        'ordinance': r'\b([A-Z][a-z\s]+Ordinance(?:,\s\d{4})?)\b',  # Example: PEMRA Ordinance, 2002
+        'petition': r'\b(?:[A-Za-z\s]*Petition\sNo\.\s\d+/\d{4})\b',  # Example: Constitutional Petition No. 123/2024
+        'act_with_year': r'\b([A-Za-z\s]+(?:\sAct(?:\s\d{4})?)),\s*(\d{4})\b',  # Example: Control of Narcotic Substances Act, 1997
+        'article': r'\b(Article\s\d{1,3}(-[A-Z])?)\b',  # Example: Article 10-A
+        'section': r'\b(Section\s\d{1,3}(\([a-zA-Z0-9]+\))?)\b',  # Example: Section 302(b), Section 9(c), Section 144-A
+        'date': r'\b(?:\d{1,2}[-/]\d{1,2}[-/]\d{2,4}|\d{4}|\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s\d{1,2},?\s\d{4})\b',  
+        # Examples: 15/07/2015, July 2015, March 5, 2021, 2023
+        'person': r'\b([A-Z][a-z]+(?:\s[A-Z][a-z]+)+)\b'  # Example: Justice Ali Raza
+
+    }
+
+    highlighted_text = text
+    for pattern in patterns.values():
+        highlighted_text = re.sub(pattern, lambda match: f'<span class="highlight">{match.group(0)}</span>', highlighted_text)
+
+    return highlighted_text
+
+# Function to read uploaded files
+def read_file(file):
+    if file.filename.endswith(".txt"):
+        return file.read().decode("utf-8")
+    elif file.filename.endswith(".pdf"):
+        pdf_reader = PdfReader(file)
+        return " ".join(page.extract_text() for page in pdf_reader.pages)
+    elif file.filename.endswith(".docx"):
+        doc = Document(file)
+        return " ".join(paragraph.text for paragraph in doc.paragraphs)
+    return None
+
+# Function to fetch text from a URL
+def fetch_text_from_url(url):
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        # Check content type
+        content_type = response.headers.get("Content-Type", "")
+        if "text/html" in content_type:  # If it's a webpage
+            soup = BeautifulSoup(response.text, "html.parser")
+            paragraphs = soup.find_all("p")  # Extract paragraph text
+            return " ".join([p.get_text() for p in paragraphs])
+
+        elif "text/plain" in content_type:  # If it's a plain text file
+            return response.text
+
+        else:
+            return None
+    except Exception as e:
+        print("Error fetching URL:", e)
+        return None
+
+@app.route("/", methods=["GET", "POST"])
+def index():
+    document_text = None
+    summary = None
+    heatmap_url = None
+
+    if request.method == "POST":
+        file = request.files.get("file")
+        pasted_text = request.form.get("pasteText", "").strip()
+        url = request.form.get("url", "").strip()
+
+        if file and file.filename:
+            document_text = read_file(file)
+        elif pasted_text:
+            document_text = pasted_text
+        elif url:
+            document_text = fetch_text_from_url(url)
+
+        if document_text:
+            summary = generate_summary(document_text)
+            sentences, scores = calculate_sentence_importance(summary)
+
+            generate_heatmap(scores)
+
+            highlighted_summary = highlight_summary(sentences, scores)
+            highlighted_summary = highlight_keywords(highlighted_summary)
+
+            # Save the summary to a text file
+            with open("summary.txt", "w", encoding="utf-8") as f:
+                f.write(summary)
+
+            return render_template("mainscreen.html", document_text=document_text, summary=highlighted_summary, heatmap_url="static/heatmap.png")
+
+    return render_template("mainscreen.html", document_text=None, summary=None, heatmap_url=None)
+
+@app.route("/download_summary")
+def download_summary():
+    file_path = os.path.join(os.getcwd(), "summary.txt")
+
+    if not os.path.exists(file_path):
+        return abort(404, description="File not found")
+
+    return send_file(file_path, as_attachment=True, download_name="summary.txt", mimetype="text/plain")
+
+
+  # Homepage 
+@app.route("/home")
+def home():
+     return render_template("homepage.html")
+@app.route("/about")
+def about():
+    return render_template("aboutpage.html") 
+@app.route("/summarization")
+def summarization():
+    return render_template("mainscreen.html")  # Login Page
+
+
+@app.route('/lawbooks/<filename>')
+def serve_pdf(filename):
+    return send_from_directory('static/lawbooks', filename)
+
+
+
+
+# MongoDB connection
+client = MongoClient('mongodb+srv://law:[email protected]/?retryWrites=true&w=majority&appName=law')
+db = client['chatbotDB']
+users = db['users']
+
+
+
+@app.route('/signup', methods=['GET'])
+def signup():
+    return render_template('signuppage.html')  # Render the HTML form
+
+@app.route('/api/signup', methods=['POST'])
+def api_signup():
+    # Get JSON data from the request
+    data = request.get_json()
+    first_name = data.get('firstName')
+    last_name = data.get('lastName')
+    email = data.get('email')
+    password = data.get('password')
+
+    # Hash the password for security before storing it in the database
+    hashed_pw = generate_password_hash(password)
+
+    # Check if the user already exists
+    if users.find_one({'email': email}):
+        return jsonify({'message': 'Email already exists!'}), 400
+
+    # Insert the user data into MongoDB
+    users.insert_one({
+        'first_name': first_name,
+        'last_name': last_name,
+        'email': email,
+        'password': hashed_pw
+    })
+
+    # Return a success response
+    return jsonify({'message': 'Signup successful!'}), 201
+
+# Success page or login page
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    if request.method == 'POST':
+        # Handle POST request for login
+        data = request.get_json()
+        email = data.get('email')
+        password = data.get('password')
+
+        # Log login attempt
+        print(f"Login attempt - Email: {email}")
+
+        # Check if the user exists
+        user = users.find_one({'email': email})
+        if not user:
+            print(f"Login failed - Email '{email}' not found.")
+            return jsonify({'message': 'Invalid email or password!'}), 401
+
+        # Check if the password is correct (compare hashed passwords)
+        if not check_password_hash(user['password'], password):
+            print(f"Login failed - Incorrect password for email '{email}'.")
+            return jsonify({'message': 'Invalid email or password!'}), 401
+
+        # Log successful login
+        print(f"Login successful - Email: {email}")
+        return jsonify({'message': 'Login successful!'}), 200
+
+    # Handle GET request - Show login form (if needed)
+    return render_template('loginpage.html')  # This would be the login form page (replace with your template)
+
+
+@app.route('/reset-password', methods=['GET', 'POST'])
+def reset_password():
+    if request.method == 'POST':
+        email = request.form['email']
+        new_password = request.form['newPassword']
+        confirm_password = request.form['confirmPassword']
+
+        # Check if passwords match
+        if new_password != confirm_password:
+            return jsonify({'message': 'Passwords do not match!'}), 400
+
+        # Check if user exists
+        user = users.find_one({'email': email})
+        if not user:
+            return jsonify({'message': 'User not found!'}), 404
+
+        # Hash the new password
+        hashed_pw = generate_password_hash(new_password)
+
+        # Update the user's password in the database
+        users.update_one({'email': email}, {'$set': {'password': hashed_pw}})
+        return jsonify({'message': 'Password updated successfully!'}), 200
+
+    return render_template('forgetpasswordpage.html')
+
+
+contacts_collection = db["contacts"]
+@app.route('/contact', methods=['GET', 'POST'])
+def contact():
+    if request.method == 'POST':
+        name = request.form.get('name')
+        email = request.form.get('email')
+        message = request.form.get('message')
+
+        print(f"Name: {name}, Email: {email}, Message: {message}")  # Debug
+
+        if not name or not email or not message:
+            return jsonify({'message': 'All fields are required!'}), 400
+
+        contact_data = {
+            'name': name,
+            'email': email,
+            'message': message
+        }
+
+        contacts_collection.insert_one(contact_data)
+        return jsonify({'message': f'Thank you, {name}! Your message has been sent successfully.',
+            'status': 'success'}), 200
+
+    return render_template('contactpage.html')
+
+
+
+
+
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=True)