Upload 8 files

.env

@@ -0,0 +1,6 @@
+[email protected]
+EMAIL_PASSWORD=mwvm tluh heuy fowf
+GROQ_API_KEY=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
+[email protected]
+[email protected]
+EMAIL_PASS=mwvm tluh heuy fowf

Update_tracking.py

@@ -0,0 +1,169 @@
+import requests
+from bs4 import BeautifulSoup
+import time
+import streamlit as st
+import threading
+from datetime import datetime, timedelta
+import smtplib
+from email.message import EmailMessage
+import os
+from dotenv import load_dotenv
+from google.oauth2.service_account import Credentials
+from googleapiclient.discovery import build
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Google Sheets Configuration
+SHEET_ID = '1bZjlA-UJrBhWS2jHlEQ-7nbmDvxpEoKylgxHW51Hhzc'  # Google Sheets ID
+RANGE = 'Sheet1!A:D'  # The range where you want to append the data
+
+# Predefined list of URLs to track
+TRACKING_URLS = [
+    "https://gdpr-info.eu/recitals/no-1/"]
+
+# Event to signal thread termination
+stop_event = threading.Event()
+
+# Authenticate Google Sheets API
+def authenticate_google_sheets():
+    creds = Credentials.from_service_account_file(
+        'Credentials.json',
+        scopes=['https://www.googleapis.com/auth/spreadsheets']
+    )
+    service = build('sheets', 'v4', credentials=creds)
+    return service
+
+# Append data to Google Sheets
+def append_to_google_sheets(service, url, title, content, timestamp):
+    values = [
+        [url, title, content[:200], timestamp]  # Prepare row to append
+    ]
+    body = {'values': values}
+    try:
+        service.spreadsheets().values().append(
+            spreadsheetId=SHEET_ID,
+            range=RANGE,
+            valueInputOption="RAW",
+            body=body
+        ).execute()
+        st.write(f"Data appended to Google Sheets at {timestamp}.")
+    except Exception as e:
+        st.error(f"Error appending to Google Sheets: {e}")
+
+# Send email notification
+def send_email_notification(to_email, url, title, content, timestamp):
+    sender_email = os.getenv("EMAIL_ADDRESS")
+    sender_password = os.getenv("EMAIL_PASSWORD")
+    smtp_server = "smtp.gmail.com"
+    smtp_port = 587
+
+    if not sender_email or not sender_password:
+        st.error("Environment variables not loaded. Check your .env file.")
+        return
+
+    msg = EmailMessage()
+    msg["Subject"] = f"Website Update Notification for {url}"
+    msg["From"] = sender_email
+    msg["To"] = to_email
+    msg.set_content(f"""
+    Website: {url}
+    Title: {title}
+    Content (preview): {content[:200]}...
+    Tracked at: {timestamp}
+    """)
+
+    try:
+        with smtplib.SMTP(smtp_server, smtp_port) as server:
+            server.starttls()
+            server.login(sender_email, sender_password)
+            server.send_message(msg)
+            st.success(f"Notification email sent to {to_email}")
+    except smtplib.SMTPException as e:
+        st.error(f"SMTP Error: {e}")
+
+# Fetch website data
+def fetch_website_data(url):
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, 'html.parser')
+        title = soup.title.string.strip() if soup.title else 'No title available'
+        paragraphs = soup.find_all('p')
+        content = ' '.join([p.text.strip() for p in paragraphs]) if paragraphs else 'New Notification available'
+        return title, content
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching website data: {e}")
+        return "Error occurred", "New notification detected. No content available due to an error."
+
+# Track websites and store updates in Google Sheets
+def track_websites(urls, recipient_email, interval=60, max_duration=20*60):
+    st.write(f"Started tracking for {recipient_email}")
+    service = authenticate_google_sheets()
+    last_updates = {}  # To track changes in website content
+
+    start_time = datetime.now()  # Record the start time
+    end_time = start_time + timedelta(seconds=max_duration)  # Set end time (20 minutes later)
+
+    while not stop_event.is_set() and datetime.now() < end_time:
+        for url in urls:
+            title, content = fetch_website_data(url)
+            if title and content:
+                timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+                # Check for updates
+                if url not in last_updates or last_updates[url] != (title, content):
+                    last_updates[url] = (title, content)
+
+                    # Append to Google Sheets
+                    append_to_google_sheets(service, url, title, content, timestamp)
+
+                    # Send notification email
+                    try:
+                        send_email_notification(recipient_email, url, title, content, timestamp)
+                    except Exception as e:
+                        st.error(f"Error sending email notification: {e}")
+
+        # Wait for the next interval or until stop_event is set
+        stop_event.wait(interval)
+
+    st.write("Stopped tracking after 20 minutes.")
+
+# Display tracking status
+def display_tracking_status():
+    st.title("Update Tracking System with Notifications")
+
+    email_input = st.text_input("Enter your email for notifications:")
+
+    # Maintain thread state
+    if "tracking_thread" not in st.session_state:
+        st.session_state["tracking_thread"] = None
+
+    if email_input:
+        # Start tracking
+        if st.button("Tracking"):
+            if st.session_state["tracking_thread"] is None or not st.session_state["tracking_thread"].is_alive():
+                stop_event.clear()  # Clear the stop flag to allow tracking
+                thread = threading.Thread(target=track_websites, args=(TRACKING_URLS, email_input), daemon=True)
+                thread.start()
+                st.session_state["tracking_thread"] = thread
+                st.success(f"Notifications will be sent to {email_input}.")
+            else:
+                st.warning("Tracking Updates is already running.")
+
+        # Stop tracking
+        if st.button("Stop Tracking"):
+            if st.session_state["tracking_thread"] is not None and st.session_state["tracking_thread"].is_alive():
+                stop_event.set()  # Signal the thread to stop
+                st.session_state["tracking_thread"].join()  # Wait for the thread to finish
+                st.session_state["tracking_thread"] = None
+                st.success("Tracking stopped.")
+            else:
+                st.warning("No active tracking to stop.")
+
+# Main function
+def main():
+    display_tracking_status()
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,17 @@
+import streamlit as st
+import Update_tracking
+import legal_document_analysis
+from rag_pipeline import extract_text_from_pdf, create_vector_store, create_qa_pipeline
+
+# Streamlit App Navigation
+def main():
+    st.sidebar.title("Navigation")
+    page = st.sidebar.radio("Choose a page", ["Update Tracking", "Legal Document Analysis"])
+
+    if page == "Update Tracking":
+        Update_tracking.display_tracking_status()  # Ensure the correct function name
+    elif page == "Legal Document Analysis":
+        legal_document_analysis.display_legal_analysis_page()
+
+if __name__ == "__main__":
+    main()

credentials.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "graphite-setup-448304-u1",
+  "private_key_id": "c745314b1cd8b8a135a10c4819dabdb0d3d9a552",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDKKXcJFGxBxdan\nBPI+M1js/YcBI3646efu1U88oWG7CrZDYEs6ZMTx46mdsgaiJ3LCmt6NRI691rdt\nOl2rh3KZ/rMLQXyyQvMfePwk4t1f/MFbHK75pD+nUWsUlbXawnGfZXRJxV9gC0F8\nindrqRFXqfrJaCjsexW5WdKEt5FAb4OSRSEAEzO6AC7VOAnME+ctOvzI8pg8Cuaw\nkJf8/0fTN/1Fgmygmj3om16J3gYVmxvaTYjZnrM6hQhvHFvTCkoLYk4DSXhIBxce\nzD/qLgoqwFGjlhrveb8FXErzTXlulAed/R49HJnbSKsL+Nq2guthoYV/j3Bg+TZ4\ngwPdlWQxAgMBAAECggEAC/jb6eud1CDUWxCDzItzqhhDCx4YInkGsVoMTtvDSwWB\nwPh2SAtg7u7DtBkvg6GYrh3oDV9ooSUyuGsfEjoLn0NKROHAUdm9ZmkerIwLXmR8\namoG0jWoB99+WwoZKo7+ldkXI4nG4cwU2RxloVhyNJn2RkBvAP8yjIcdXJr25QUC\nqA7v+grCR2CcxBkbRXoh/BQ+4wJQjT12eW7ybYXgxJb8HK8fWcGWXv8ir+KPNOrL\nONMhUS8rHyJ3i/9i/uwMP61pqmKf5x1gBTM1h7Wr+8tTIbCsrv1D8DSwOqvHrgTb\nDzUDKmpZFBUD0xyKETR5r7xTpje1M/xcTQlOskllyQKBgQDmhxz3kcnEHN88J1Jq\nvCXD4+0pBF+tzNc9ZmSnu2W+EBq5mAMu7sDTGRZtj/GisyYgm8YMybGnh38IPh5f\nOM+dqcXOM68ARi1srkGXPbLOMksAALhx9NVkbAZvm8Y6wIw6S5V/SsRiW8dq0VTM\nW2ncwUfn9gV3jstdAokjsZTM2QKBgQDgf/l8AZO6MHl/lujz480HP1ye/bkxhPnZ\ndsyHJG7zKRjQsqa1Kj006mGVLtcaC+zhNxGpeLrBbK/+OzyiBuM5OX0UXeS8zfIp\nPkXliSNarWIncgTCEwrcZOe1HFhIYYfd8JKebpaMtPOGYs2ZaKALMNXLDAJv5kSe\nrB0y0nabGQKBgEBKLAzrDo7v0l3vRW/Y2ttfpFNNEfXha6GG/ck9XOl9ikZ6G2Eq\nWoJEu9mATE4okhiD+N62HSJwij/dOxEpQdVhdHXGOibka2Sk0EwCe+w/YGU2zjmR\nozVnXwAfPFBERJc5Xw7p5gzcNagXiwOW9tYG3SvWk729B///ZgmbS7k5AoGBAIWX\nwgeoDJe0duiVDgTsHzrb2qsGAylTnzZoOmeFJ7ztTMYMOaX+/7M4cl9LI1dtl0Wh\n9pGptUCbA9O+vmMQxDBuZF81TIOJ7jvawc9In1A7cvhUIj63BDSIm1WsC2DvIOHS\nYf2Dg3UxzOTAcOaEWxCtu9t7Rwv9tAHUG//9O/UpAoGBALNfN69s+vhpPX4Ioq3B\nyv0bAk3QU4NZHnX7d48eFbWSS5Hhbboo/T/0KPcOf7ynOptsLeV+HqLS/WLXsJ5J\npKw7mW7pb0VoLv+JokWeAtIc4c0Ft2EZtvb+6t3GcrrDJsFBshUdwblrP9sl6i2X\nYUd3Ck2TaXpXirfFdUgByhLl\n-----END PRIVATE KEY-----\n",
+  "client_email": "[email protected]",
+  "client_id": "105183693282963617063",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/sheet-865%40graphite-setup-448304-u1.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

legal_document_analysis.py

@@ -0,0 +1,636 @@
+import os
+import PyPDF2
+import streamlit as st
+from dotenv import load_dotenv
+from langchain_groq import ChatGroq
+from docx import Document
+import matplotlib.pyplot as plt
+import io
+import base64
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.application import MIMEApplication
+import smtplib
+from fpdf import FPDF  
+import getpass
+import pandas as pd
+import seaborn as sns
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Check if the GROQ_API_KEY is in the environment variables
+if not os.environ.get("GROQ_API_KEY"):
+    os.environ["GROQ_API_KEY"] = getpass.getpass("Enter API key for Groq: ")
+
+# Initialize the model
+model = ChatGroq(model="llama-3.1-8b-instant", api_key=os.environ.get("GROQ_API_KEY"))
+
+# Custom CSS for improved aesthetics
+st.markdown(
+    """
+    <style>
+    .main {
+        background-color: #f0f2f5;
+    }
+    .sidebar .sidebar-content {
+        background-color: #ffffff;
+    }
+    h1 {
+        color: #2C3E50;
+    }
+    h2 {
+        color: #2980B9;
+    }
+    .stButton button {
+        background-color: #2980B9;
+        color: white;
+        border: None;
+        border-radius: 5px;
+        padding: 10px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+# Function to read PDF content
+def read_pdf(file):
+    reader = PyPDF2.PdfReader(file)
+    text = ""
+    for page in reader.pages:
+        text += page.extract_text()
+    return text
+
+# Function to extract text from DOCX files
+def extract_text_from_docx(file):
+    doc = Document(file)
+    text = "\n".join([paragraph.text for paragraph in doc.paragraphs])
+    return text
+
+# Function to preprocess text
+def preprocess_text(text):
+    return " ".join(text.replace("\n", " ").replace("\r", " ").split())
+
+# Function to chunk large text into smaller parts
+def chunk_text(text, max_tokens=2000):
+    chunks = []
+    current_chunk = []
+    current_length = 0
+
+    for sentence in text.split(". "):
+        sentence_length = len(sentence.split())
+        if current_length + sentence_length <= max_tokens:
+            current_chunk.append(sentence)
+            current_length += sentence_length
+        else:
+            chunks.append(". ".join(current_chunk))
+            current_chunk = [sentence]
+            current_length = sentence_length
+
+    if current_chunk:
+        chunks.append(". ".join(current_chunk))
+
+    return chunks
+
+# Function to generate summary for each chunk
+def generate_summary(text):
+    prompt = f"Please summarize the following content:\n\n{text}"
+    try:
+        response = model.invoke(prompt)
+        if hasattr(response, 'content'):
+            summary = response.content
+        else:
+            summary = str(response)
+        return summary.strip() if summary else "No summary available."
+    except Exception as e:
+        st.error(f"Error generating summary: {str(e)}")
+        return None
+
+# Function to summarize large texts
+def summarize_large_text(text, chunk_limit=5000):
+    chunks = chunk_text(text, max_tokens=chunk_limit)
+    summaries = []
+    for chunk in chunks:
+        summary = generate_summary(chunk)
+        if summary:
+            summaries.append(summary)
+    return " ".join(summaries)
+
+# Function to detect key clauses
+def detect_key_clauses(text):
+    key_clauses = [
+        {"clause": "confidentiality", "summary": "Confidentiality clauses ensure that sensitive information remains protected."},
+        {"clause": "liability", "summary": "Liability clauses outline the responsibility for damages or losses incurred."},
+        {"clause": "termination", "summary": "Termination clauses specify the conditions under which a contract may be ended."},
+        {"clause": "force majeure", "summary": "Force majeure clauses excuse parties from performance obligations due to unforeseen events."},
+        {"clause": "governing law", "summary": "Governing law clauses specify which jurisdiction's laws will govern the contract."},
+        {"clause": "dispute resolution", "summary": "Dispute resolution clauses specify how conflicts between parties will be resolved."},
+        {"clause": "amendment", "summary": "Amendment clauses outline the process for changing the terms of the contract."},
+        {"clause": "warranty", "summary": "Warranty clauses provide assurances regarding the quality or condition of goods or services."},
+    ]
+    
+    detected_clauses = []
+    for clause in key_clauses:
+        if clause["clause"].lower() in text.lower():
+            clause_start = text.lower().find(clause["clause"].lower())
+            context = text[clause_start - 50: clause_start + 200]
+            explanation = f"The document mentions '{clause['clause']}' clause. Context: {context.strip()}..."
+            detected_clauses.append({
+                "clause": clause["clause"].capitalize(),
+                "summary": clause["summary"],
+                "explanation": explanation
+            })
+    
+    return detected_clauses
+
+# Function to detect hidden obligations or dependencies
+def detect_hidden_obligations_or_dependencies(text, summary):
+    hidden_obligations = [
+        {"phrase": "dependent upon", "summary": "This suggests that some action is conditional upon another."},
+        {"phrase": "if", "summary": "This indicates that certain conditions must be met to fulfill the obligation."},
+        {"phrase": "may be required", "summary": "Implies that the party could be obligated to perform an action under specific conditions."},
+        {"phrase": "should", "summary": "Implies a recommendation or requirement, though not explicitly mandatory."},
+        {"phrase": "obligated to", "summary": "Indicates a clear, binding duty to perform an action."},
+    ]
+    
+    hidden_dependencies = []
+    
+    for item in hidden_obligations:
+        if item["phrase"].lower() in text.lower() or item["phrase"].lower() in summary.lower():
+            phrase_start = text.lower().find(item["phrase"].lower())
+            context = text[phrase_start - 50: phrase_start + 200]
+            hidden_dependencies.append({
+                "phrase": item["phrase"],
+                "summary": item["summary"],
+                "context": context.strip()
+            })
+    
+    return hidden_dependencies
+
+# Function to detect risks in the text
+def detect_risks(text, summary):
+    risk_phrases = [
+        {"phrase": "penalty", "summary": "This indicates financial or legal consequences.", "risk_level": "High"},
+        {"phrase": "liability", "summary": "This suggests potential financial responsibility.", "risk_level": "Medium"},
+        {"phrase": "default", "summary": "This can lead to serious legal consequences.", "risk_level": "High"},
+        {"phrase": "breach", "summary": "This may expose the party to significant penalties.", "risk_level": "High"},
+        {"phrase": "suspension", "summary": "This indicates risks of halting services.", "risk_level": "Medium"},
+        {"phrase": "should", "summary": "This implies a recommendation, which may not be mandatory.", "risk_level": "Low"},
+        {"phrase": "may be required", "summary": "This suggests that obligations could exist under certain conditions.", "risk_level": "Low"},
+        {"phrase": "indemnify", "summary": "This entails a duty to compensate for harm or loss, indicating potential financial risk.", "risk_level": "High"},
+        {"phrase": "termination for cause", "summary": "This indicates a risk of ending the contract due to specific failures.", "risk_level": "High"},
+        {"phrase": "compliance", "summary": "Non-compliance with regulations can lead to legal penalties.", "risk_level": "High"},
+    ]
+    
+    detected_risks = []
+    
+    for item in risk_phrases:
+        if item["phrase"].lower() in text.lower() or item["phrase"].lower() in summary.lower():
+            phrase_start = text.lower().find(item["phrase"].lower())
+            context = text[phrase_start - 50: phrase_start + 200]
+            detected_risks.append({
+                "phrase": item["phrase"],
+                "summary": item["summary"],
+                "context": context.strip(),
+                "risk_level": item["risk_level"]
+            })
+    
+    return detected_risks
+
+# Function to calculate overall risk score
+def calculate_overall_risk_score(detected_risks):
+    risk_scores = {
+        "High": 3,
+        "Medium": 2,
+        "Low": 1
+    }
+    total_score = sum(risk_scores.get(risk['risk_level'], 0) for risk in detected_risks)
+    return total_score
+
+# Function to plot risk assessment matrix
+def plot_risk_assessment_matrix(detected_risks):
+    likelihood = []
+    impact = []
+
+    for risk in detected_risks:
+        if risk['risk_level'] == 'High':
+            likelihood.append(3)
+            impact.append(3)
+        elif risk['risk_level'] == 'Medium':
+            likelihood.append(2)
+            impact.append(2)
+        elif risk['risk_level'] == 'Low':
+            likelihood.append(1)
+            impact.append(1)
+
+    fig, ax = plt.subplots(figsize=(6, 6))
+    scatter = ax.scatter(likelihood, impact, alpha=0.6)
+
+    ax.set_xticks([1, 2, 3])
+    ax.set_yticks([1, 2, 3])
+    ax.set_xticklabels(['Low', 'Medium', 'High'])
+    ax.set_yticklabels(['Low', 'Medium', 'High'])
+    ax.set_xlabel('Likelihood')
+    ax.set_ylabel('Impact')
+    ax.set_title('Risk Assessment Matrix')
+
+    for i in range(len(detected_risks)):
+        ax.annotate(detected_risks[i]['phrase'], (likelihood[i], impact[i]))
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches='tight')
+    buf.seek(0)
+    
+    img_str = base64.b64encode(buf.read()).decode('utf-8')
+    buf.close()
+    
+    return img_str
+
+# Function to plot risk level distribution pie chart
+def plot_risk_level_distribution(detected_risks):
+    risk_levels = [risk['risk_level'] for risk in detected_risks]
+    level_counts = {level: risk_levels.count(level) for level in set(risk_levels)}
+
+    fig, ax = plt.subplots(figsize=(4, 3))
+    ax.pie(level_counts.values(), labels=level_counts.keys(), autopct='%1.1f%%', startangle=90)
+    ax.axis('equal')
+
+    plt.title("Risk Level Distribution", fontsize=10)
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches='tight')
+    buf.seek(0)
+    
+    img_str = base64.b64encode(buf.read()).decode('utf-8')
+    buf.close()
+    
+    return img_str
+
+# Function to plot risks by type bar chart
+def plot_risks_by_type(detected_risks):
+    risk_phrases = [risk['phrase'] for risk in detected_risks]
+    phrase_counts = {phrase: risk_phrases.count(phrase) for phrase in set(risk_phrases)}
+
+    fig, ax = plt.subplots(figsize=(4, 3))
+    ax.bar(phrase_counts.keys(), phrase_counts.values(), color='lightcoral')
+    plt.xticks(rotation=45, ha='right')
+    ax.set_title("Risks by Type", fontsize=10)
+    ax.set_ylabel("Count")
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches='tight')
+    buf.seek(0)
+
+    img_str = base64.b64encode(buf.read()).decode('utf-8')
+    buf.close()
+
+    return img_str
+
+# Function to plot stacked bar chart of risks by level
+def plot_stacked_bar_chart(detected_risks):
+    risk_levels = ['High', 'Medium', 'Low']
+    level_counts = {level: 0 for level in risk_levels}
+
+    for risk in detected_risks:
+        level_counts[risk['risk_level']] += 1
+
+    fig, ax = plt.subplots(figsize=(4, 3))
+    ax.bar(level_counts.keys(), level_counts.values(), color=['#ff9999', '#66b3ff', '#99ff99'])
+    ax.set_title("Stacked Bar Chart of Risks by Level", fontsize=10)
+    ax.set_ylabel("Count")
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches='tight')
+    buf.seek(0)
+
+    img_str = base64.b64encode(buf.read()).decode('utf-8')
+    buf.close()
+
+    return img_str
+
+# Function to plot risk heatmap
+def plot_risk_heatmap(detected_risks):
+    risk_data = {'Risk Level': [], 'Count': []}
+    
+    for risk in detected_risks:
+        risk_data['Risk Level'].append(risk['risk_level'])
+        risk_data['Count'].append(1)
+
+    df = pd.DataFrame(risk_data)
+    heatmap_data = df.groupby('Risk Level').count().reset_index()
+
+    fig, ax = plt.subplots(figsize=(4, 3))
+    sns.heatmap(heatmap_data.pivot_table(index='Risk Level', values='Count'), annot=True, cmap='YlGnBu', ax=ax)
+    ax.set_title("Risk Heatmap")
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches='tight')
+    buf.seek(0)
+
+    img_str = base64.b64encode(buf.read()).decode('utf-8')
+    buf.close()
+
+    return img_str
+
+# Function to convert base64 to image
+def base64_to_image(data):
+    return io.BytesIO(base64.b64decode(data))
+
+# Function to generate PDF document with improved aesthetics
+def generate_pdf_analysis(document_text, summary, detected_clauses, hidden_obligations, detected_risks, risk_assessment_matrix, risk_level_distribution, risks_by_type, stacked_bar_chart, risk_heatmap):
+    pdf = FPDF()
+    pdf.add_page()
+
+    # Set page borders
+    pdf.set_draw_color(0, 0, 0)
+    pdf.rect(5, 5, 200, 287)
+
+    # Add Arial font
+    pdf.add_font("Arial", "", "arial.ttf", uni=True)
+    pdf.set_font("Arial", size=12)
+
+    # Title
+    pdf.set_font("Arial", 'B', 16)
+    pdf.cell(0, 10, 'Legal Document Analysis Report', ln=True, align='C')
+    pdf.ln(10)
+
+    # Executive Summary
+    pdf.set_font("Arial", 'B', 14)
+    pdf.cell(0, 10, 'Executive Summary', ln=True)
+    pdf.set_font("Arial", '', 12)
+    pdf.multi_cell(0, 10, summary)
+    pdf.ln(10)
+
+    # Risks Section
+    pdf.set_font("Arial", 'B', 14)
+    pdf.cell(0, 10, 'Risk Analysis', ln=True)
+    pdf.set_font("Arial", '', 12)
+    for risk in detected_risks:
+        pdf.cell(0, 10, f"{risk['phrase']}: {risk['summary']} (Risk Level: {risk['risk_level']})", ln=True)
+    pdf.ln(10)
+
+    # Add visualizations for risks
+    pdf.image(base64_to_image(risk_assessment_matrix), x=10, y=pdf.get_y(), w=90)
+    pdf.image(base64_to_image(risk_level_distribution), x=110, y=pdf.get_y()-50, w=90)  # Position next to the first image
+    pdf.ln(60)
+
+    pdf.image(base64_to_image(risks_by_type), x=10, y=pdf.get_y(), w=90)
+    pdf.image(base64_to_image(stacked_bar_chart), x=110, y=pdf.get_y()-50, w=90)  # Position next to the previous image
+    pdf.ln(60)
+
+    pdf.image(base64_to_image(risk_heatmap), x=10, y=pdf.get_y(), w=190)  # Fit image to width
+    pdf.ln(10)
+
+    # Footer
+    pdf.set_y(-15)
+    pdf.set_font("Arial", 'I', 8)
+    pdf.cell(0, 10, f'Page {pdf.page_no()}', 0, 0, 'C')
+
+    return pdf
+
+# Function to handle chatbot interaction
+def chatbot_query(user_input):
+    try:
+        response = model({"text": user_input})
+        if isinstance(response, dict) and 'text' in response:
+            return response['text']
+        else:
+            return "Error: Unexpected response format."
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Function to generate suggestions for improvement
+def generate_suggestions(text):
+    suggestions = []
+    
+    if "shall" in text.lower():
+        suggestions.append("Consider replacing 'shall' with 'must' for clarity.")
+    if "may" in text.lower():
+        suggestions.append("Clarify the conditions under which actions 'may' be taken.")
+    if "if" in text.lower() and "then" not in text.lower():
+        suggestions.append("Ensure conditional statements are clear and complete.")
+    if "not" in text.lower():
+        suggestions.append("Review negative clauses to ensure they are not overly restrictive.")
+    
+    return suggestions
+
+# Function to send feedback via email
+def send_feedback(feedback_content):
+    sender_email = os.getenv("SENDER_EMAIL")
+    receiver_email = os.getenv("FEEDBACK_EMAIL")
+    password = os.getenv("EMAIL_PASS")
+
+    msg = MIMEMultipart()
+    msg['From'] = sender_email
+    msg['To'] = receiver_email
+    msg['Subject'] = "User Feedback on Legal Document Analysis"
+
+    msg.attach(MIMEText(feedback_content, 'plain'))
+
+    try:
+        with smtplib.SMTP('smtp.gmail.com', 587) as server:
+            server.starttls()
+            server.login(sender_email, password)
+            server.send_message(msg)
+        return True
+    except Exception as e:
+        return False
+
+# Function to send PDF via email
+def send_pdf_via_email(pdf_buffer, recipient_email):
+    sender_email = os.getenv("SENDER_EMAIL")
+    password = os.getenv("EMAIL_PASS")
+
+    msg = MIMEMultipart()
+    msg['From'] = sender_email
+    msg['To'] = recipient_email
+    msg['Subject'] = "Legal Document Analysis PDF"
+
+    msg.attach(MIMEText("Please find the attached analysis of your legal document.", 'plain'))
+
+    # Attach the PDF
+    pdf_attachment = io.BytesIO(pdf_buffer.getvalue())
+    pdf_attachment.seek(0)
+    part = MIMEApplication(pdf_attachment.read(), Name='legal_document_analysis.pdf')
+    part['Content-Disposition'] = 'attachment; filename="legal_document_analysis.pdf"'
+    msg.attach(part)
+
+    try:
+        with smtplib.SMTP('smtp.gmail.com', 587) as server:
+            server.starttls()
+            server.login(sender_email, password)
+            server.send_message(msg)
+        return True
+    except Exception as e:
+        return False
+
+# Function to simulate tracking updates in the document
+def track_updates(document_text):
+    updates = [
+        {"update": "Updated confidentiality clause.", "suggestion": "Consider specifying the duration of confidentiality."},
+        {"update": "Revised liability limits.", "suggestion": "Ensure the limits are realistic and compliant with regulations."},
+        {"update": "Clarified termination conditions.", "suggestion": "Check if all potential termination scenarios are covered."},
+    ]
+    return updates
+
+# Function to get suggestion from Groq API based on the update
+def get_update_suggestion(update):
+    prompt = f"Suggest improvements or updates for this legal clause: {update}"
+    suggestion = generate_summary(prompt)
+    return suggestion if suggestion else "No suggestion available."
+
+# Function to display feedback form
+def display_feedback_form():
+    st.subheader("Feedback Form")
+    feedback = st.text_area("Please provide your feedback or suggestions:")
+    
+    question1 = st.radio("How would you rate the analysis?", ("Excellent", "Good", "Fair", "Poor"))
+    question2 = st.radio("Would you recommend this tool to others?", ("Yes", "No"))
+    
+    if st.button("Submit Feedback"):
+        feedback_content = f"Feedback: {feedback}\nRating: {question1}\nRecommendation: {question2}"
+        if send_feedback(feedback_content):
+            st.success("Thank you for your feedback! It has been sent.")
+        else:
+            st.error("Failed to send feedback. Please try again later.")
+
+# Main function to display the legal analysis page
+def display_legal_analysis_page():
+    st.title("📜 Legal Document Analysis with Groq API")
+
+    uploaded_file = st.file_uploader("Upload your legal document (PDF or DOCX)", type=["pdf", "docx"])
+    if uploaded_file:
+        if uploaded_file.name.endswith(".pdf"):
+            document_text = preprocess_text(read_pdf(uploaded_file))
+        elif uploaded_file.name.endswith(".docx"):
+            document_text = preprocess_text(extract_text_from_docx(uploaded_file))
+        else:
+            st.error("Unsupported file type!")
+            return
+
+        tabs = st.tabs(["📄 Document Text", "🔍 Summary", "🔑 Key Clauses", "🔒 Hidden Obligations", "⚠ Risk Analysis", "💡 Suggestions & Chatbot", "🔄 Update Tracker"])
+
+        with tabs[0]:
+            st.subheader("Document Text")
+            st.write(document_text)
+
+        with tabs[1]:
+            st.subheader("Summary")
+            summary = summarize_large_text(document_text)
+            st.write(summary)
+
+        with tabs[2]:
+            st.subheader("Key Clauses Identified")
+            detected_clauses = detect_key_clauses(document_text)
+            if detected_clauses:
+                for clause in detected_clauses:
+                    with st.expander(clause['clause'], expanded=False):
+                        st.write(f"*Summary:* {clause['summary']}")
+                        st.write(f"*Context:* {clause['explanation']}")
+                
+            else:
+                st.write("No key clauses detected.")
+
+        with tabs[3]:
+            st.subheader("Hidden Obligations and Dependencies")
+            hidden_obligations = detect_hidden_obligations_or_dependencies(document_text, summary)
+            if hidden_obligations:
+                for obligation in hidden_obligations:
+                    st.write(f"{obligation['phrase']}: {obligation['summary']}")
+                    st.write(obligation['context'])
+            else:
+                st.write("No hidden obligations detected.")
+
+        with tabs[4]:
+            st.subheader("Risk Analysis")
+            detected_risks = detect_risks(document_text, summary)
+            overall_risk_score = calculate_overall_risk_score(detected_risks)
+
+            st.write(f"*Overall Risk Score:* {overall_risk_score}")
+
+            if detected_risks:
+                for risk in detected_risks:
+                    with st.expander(risk['phrase'], expanded=False):
+                        st.write(f"*Summary:* {risk['summary']} (Risk Level: {risk['risk_level']})")
+                        short_context = risk['context'].strip().split('. ')[0] + '.'
+                        st.write(f"*Context:* {short_context}")
+            else:
+                st.write("No risks detected.")
+
+            # Generate all visualizations
+            risk_assessment_matrix = plot_risk_assessment_matrix(detected_risks)
+            risk_level_distribution = plot_risk_level_distribution(detected_risks)
+            risks_by_type = plot_risks_by_type(detected_risks)
+            stacked_bar_chart = plot_stacked_bar_chart(detected_risks)
+            risk_heatmap = plot_risk_heatmap(detected_risks)
+
+            # Display the charts
+            st.image(f"data:image/png;base64,{risk_assessment_matrix}", caption="Risk Assessment Matrix")
+            st.image(f"data:image/png;base64,{risk_level_distribution}", caption="Risk Level Distribution")
+            st.image(f"data:image/png;base64,{risks_by_type}", caption="Risks by Type")
+            st.image(f"data:image/png;base64,{stacked_bar_chart}", caption="Stacked Bar Chart of Risks by Level")
+            st.image(f"data:image/png;base64,{risk_heatmap}", caption="Risk Heatmap")
+
+        with tabs[5]:
+            st.subheader("Suggestions for Improvement")
+            suggestions = generate_suggestions(document_text)
+            for suggestion in suggestions:
+                st.write(f"- {suggestion}")
+
+            st.subheader("Chatbot for Analysis")
+            user_input = st.text_input("Ask the chatbot about your document:")
+            if st.button("Send"):
+                if user_input:
+                    chatbot_response = chatbot_query(user_input)
+                    st.write("*Chatbot Response:*")
+                    st.write(chatbot_response)
+                else:
+                    st.warning("Please enter a question.")
+
+            # Download PDF Analysis Button
+            st.subheader("Download Analysis as PDF")
+            pdf_buffer = io.BytesIO()
+            pdf = generate_pdf_analysis(document_text, summary, detected_clauses, hidden_obligations, detected_risks, risk_assessment_matrix, risk_level_distribution, risks_by_type, stacked_bar_chart, risk_heatmap)
+            pdf.output(pdf_buffer, 'F')
+            pdf_buffer.seek(0)
+
+            # Add download button for PDF
+            st.download_button(
+                label="Download PDF Analysis",
+                data=pdf_buffer,
+                file_name="legal_document_analysis.pdf",
+                mime="application/pdf"
+            )
+
+            # Input for recipient email
+            recipient_email = st.text_input("Enter your email address to receive the PDF:")
+
+            # Button to send PDF via email
+            if st.button("Send PDF Analysis"):
+                if recipient_email:
+                    if send_pdf_via_email(pdf_buffer, recipient_email):
+                        st.success("PDF has been sent successfully!")
+                    else:
+                        st.error("Failed to send PDF. Please try again.")
+                else:
+                    st.warning("Please enter a valid email address.")
+
+            # Feedback Form Section
+            display_feedback_form()
+
+        with tabs[6]:  # Update Tracker Tab
+            st.subheader("Document Updates")
+            updates = track_updates(document_text)
+            if st.button("Show Updates"):
+                if updates:
+                    for update in updates:
+                        with st.expander(update['update'], expanded=False):
+                            suggestion = get_update_suggestion(update['update'])
+                            st.write(f"*Suggestion:* {suggestion}")
+                else:
+                    st.write("No updates detected.")
+
+# Run the application
+if __name__ == "__main__":
+    display_legal_analysis_page()

rag_pipeline.py

@@ -0,0 +1,76 @@
+import os
+from dotenv import load_dotenv
+from transformers import pipeline
+from PyPDF2 import PdfReader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.vectorstores import FAISS
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.chains import RetrievalQA
+from langchain.llms import HuggingFaceHub
+
+# Load environment variables from .env file
+load_dotenv()
+
+def extract_text_from_pdf(pdf_file):
+    """Extracts text from a PDF file."""
+    reader = PdfReader(pdf_file)
+    text = ""
+    for page in reader.pages:
+        text += page.extract_text() or ""
+    return text
+
+def create_vector_store(text, embeddings_model="sentence-transformers/all-MiniLM-L6-v2"):
+    """Creates a FAISS vector store from the input text."""
+    text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    texts = text_splitter.split_text(text)
+    embeddings = HuggingFaceEmbeddings(model_name=embeddings_model)
+    return FAISS.from_texts(texts, embeddings)
+
+def create_qa_pipeline(vector_store, llm_model="EleutherAI/gpt-neo-2.7B"):
+    """Creates a Retrieval-based Question-Answering pipeline."""
+    
+    # Get the Hugging Face API token from the environment variable
+    huggingfacehub_api_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    
+    if huggingfacehub_api_token is None:
+        raise ValueError("HuggingFace Hub API token is missing! Please set the 'HUGGINGFACEHUB_API_TOKEN' in your .env file.")
+    
+    retriever = vector_store.as_retriever()
+
+    # Initialize Hugging Face LLM with the API token
+    llm = HuggingFaceHub(
+        repo_id=llm_model,  # specify the repo_id (e.g., gpt-neo-2.7B)
+        huggingfacehub_api_token=huggingfacehub_api_token, 
+        task="text-generation"  # specify the task (e.g., text-generation for language models)
+    )
+    
+    return RetrievalQA.from_chain_type(llm, retriever=retriever)
+
+def process_pdf_and_answer(pdf_path):
+    """Processes the PDF and returns answers to the text inside."""
+    
+    # Extract text from the PDF
+    text = extract_text_from_pdf(pdf_path)
+
+    # Create a FAISS vector store
+    vector_store = create_vector_store(text)
+
+    # Create a QA pipeline
+    qa_pipeline = create_qa_pipeline(vector_store)
+
+    # Answer the question
+    # Since you no longer need to ask a question manually, just extract some context
+    answer = qa_pipeline.run("Extract key information from the PDF.")  # Modify to get a summary or key data
+    return answer
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="RAG Pipeline for PDF analysis")
+    parser.add_argument("--pdf", type=str, required=True, help="Path to the PDF file")
+    args = parser.parse_args()
+
+    pdf_path = args.pdf
+
+    # Process the PDF and get results
+    answer = process_pdf_and_answer(pdf_path)
+    print(f"Answer: {answer}")

requirements.txt

@@ -0,0 +1,24 @@
+streamlit==1.20.0
+PyPDF2==1.26.0
+python-dotenv==0.20.0
+langchain-groq==0.1.0
+python-docx==0.8.11
+matplotlib==3.5.1
+pandas==1.4.1
+seaborn==0.11.2
+fpdf==1.7.2
+smtplib==0.0.1 
+getpass==0.0.1 
+streamlit==1.20.0
+requests==2.28.1
+beautifulsoup4==4.11.1
+python-dotenv==0.20.0
+google-auth==2.15.0
+google-auth-oauthlib==0.5.3
+google-api-python-client==2.52.0
+smtplib==0.0.1 
+python-dotenv==0.20.0
+transformers==4.26.0
+PyPDF2==1.26.0
+langchain==0.0.200
+faiss-cpu==1.7.2