Spaces:

fizzarif7
/

assistant

Running

App Files Files Community

fizzarif7 commited on Jun 24

Commit

ce4fe6e

verified ·

1 Parent(s): 6b3a032

Upload 8 files

Browse files

Files changed (9) hide show

.gitattributes +1 -0
ibtehaj dataset.parquet +3 -0
index.html +51 -0
legal.py +266 -0
man.jpg +0 -0
pdf_data.json +3 -0
requirement.txt +11 -0
script.js +106 -0
style.css +154 -0

.gitattributes CHANGED Viewed

@@ -33,3 +33,4 @@ saved_model/**/* 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

 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+pdf_data.json filter=lfs diff=lfs merge=lfs -text

ibtehaj dataset.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:dcf30ef8425b78d6420c65065a161542a0a51daf3fcf7e26073f82daa1f958b7
+size 25068229

index.html ADDED Viewed

	@@ -0,0 +1,51 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>Legal Assistant</title>
+  <link rel="stylesheet" href="style.css" />
+  <script src="script.js"></script>
+</head>
+<body>
+  <h1 class="title">Legal Assistant</h1>
+  <div class="container">
+    <div class="left-panel">
+      <img src="man.jpg" alt="Profile" />
+    </div>
+    <div class="center-panel">
+      <div class="top-label">
+        <textarea id="topLabel" readonly>Dictate your legal question!</textarea>
+      </div>
+      <div class="qa-section">
+        <div class="input-area">
+          <label>Ask your legal question:</label>
+          <textarea id="question" rows="10"></textarea>
+        </div>
+        <div class="output-area">
+          <label>Answer:</label>
+          <textarea id="answer" rows="10" readonly></textarea>
+        </div>
+      </div>
+      <div class="button-panel">
+        <button onclick="handleDictate()">🎙 Dictate</button>
+        <button onclick="generateAnswer()">🧾 Generate Response</button>
+        <button onclick="readAloud()">🔊 Read Aloud</button>
+        <button onclick="uploadMP3()">🎵 Upload MP3</button>
+        <button onclick="saveQA()">🖨 Save/Print</button>
+        <button onclick="resetApp()">🧹 Reset</button>
+      </div>
+    </div>
+    <div class="right-panel">
+      <label>Conversation History:</label>
+      <textarea id="history" readonly></textarea>
+    </div>
+  </div>
+  <script src="script.js"></script>
+</body>
+</html>

legal.py ADDED Viewed

	@@ -0,0 +1,266 @@

+from flask import Flask, request, jsonify, send_from_directory
+import speech_recognition as sr
+import threading
+import datetime
+import pyttsx3
+from langdetect import detect
+from huggingface_hub import login
+from sentence_transformers import SentenceTransformer
+from transformers import pipeline, AutoTokenizer, AutoModelForQuestionAnswering, AutoModelForSeq2SeqLM
+import faiss
+import numpy as np
+import pandas as pd
+import json
+import webbrowser
+from pydub import AudioSegment
+import os
+from werkzeug.utils import secure_filename
+import tempfile
+app = Flask(__name__, static_folder='.') # Serve static files from the current directory
+# Load Hugging Face API key from environment variable
+hf_token = os.environ.get("API_KEY")
+if not hf_token:
+    # Attempt to load from .env file if not set in environment
+    from dotenv import load_dotenv
+    load_dotenv()
+    hf_token = os.environ.get("API_KEY")
+    if not hf_token:
+        raise ValueError("Hugging Face API key not found. Please set 'API_KEY' as an environment variable or in a .env file.")
+login(token=hf_token)
+# QA Models
+qa_model = AutoModelForQuestionAnswering.from_pretrained("deepset/roberta-base-squad2")
+qa_tokenizer = AutoTokenizer.from_pretrained("deepset/roberta-base-squad2")
+qa_pipeline = pipeline("question-answering", model=qa_model, tokenizer=qa_tokenizer)
+# Summarization Model
+summarizer_model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")
+summarizer_tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
+summarizer_pipeline = pipeline("summarization", model=summarizer_model, tokenizer=summarizer_tokenizer)
+embed_model = SentenceTransformer("sentence-transformers/paraphrase-MiniLM-L6-v2")
+# Load both datasets
+df_parquet = pd.read_parquet("ibtehaj dataset.parquet")
+corpus_parquet = df_parquet["text"].dropna().tolist()
+# Load the JSON dataset
+with open("pdf_data.json", "r", encoding="utf-8") as f:
+    json_data = json.load(f)
+# Extract text from JSON
+corpus_json = []
+for entry in json_data:
+    if isinstance(entry, dict) and "text" in entry:
+        text = entry["text"].strip()
+        if text:
+            corpus_json.append(text)
+# Combine both corpora
+corpus = corpus_parquet + corpus_json
+# Compute embeddings
+embeddings = embed_model.encode(corpus, show_progress_bar=True, batch_size=16)
+# Build FAISS index
+index = faiss.IndexFlatL2(embeddings.shape[1])
+index.add(np.array(embeddings))
+def rag_answer(question: str, k: int = 3) -> str:
+    q_emb = embed_model.encode([question])
+    D, I = index.search(q_emb, k)
+    context = "\n\n".join(corpus[i] for i in I[0] if 0 <= i < len(corpus))
+    if not context.strip():
+        return "Context is empty. Try rephrasing the question."
+    try:
+        result = qa_pipeline(question=question, context=context)
+        raw_answer = result.get("answer", "No answer found.")
+        # Summarize if answer is too long (>40 words or 300 characters)
+        if len(raw_answer.split()) > 40 or len(raw_answer) > 300:
+            summary = summarizer_pipeline(raw_answer, max_length=50, min_length=15, do_sample=False)
+            summarized_answer = summary[0]['summary_text']
+        else:
+            summarized_answer = raw_answer
+        return f"Answer: {summarized_answer}\n\n[Context Used]:\n{context[:500]}..."
+    except Exception as e:
+        return f"Error: {e}"
+# Global for TTS engine (to allow stopping)
+tts_engine = None
+def init_tts_engine():
+    global tts_engine
+    if tts_engine is None:
+        tts_engine = pyttsx3.init()
+        tts_engine.setProperty('rate', 150)
+        tts_engine.setProperty('volume', 1.0)
+        voices = tts_engine.getProperty('voices')
+        for v in voices:
+            if "zira" in v.name.lower() or "female" in v.name.lower():
+                tts_engine.setProperty('voice', v.id)
+                break
+init_tts_engine()
+# Global variables for managing state (simplify for web context)
+conversation_history = []
+last_question_text = ""
+last_answer_text = ""
+@app.route('/')
+def serve_index():
+    return send_from_directory('.', 'index.html')
+@app.route('/<path:path>')
+def serve_static_files(path):
+    return send_from_directory('.', path)
+@app.route('/answer', methods=['POST'])
+def generate_answer_endpoint():
+    global last_question_text, last_answer_text, conversation_history
+    data = request.get_json()
+    question = data.get('question', '').strip()
+    if not question:
+        return jsonify({"answer": "Please provide a question."}), 400
+    last_question_text = question
+    timestamp = datetime.datetime.now().strftime("%H:%M:%S")
+    conversation_history.append({"role": "user", "time": timestamp, "text": question})
+    ans = rag_answer(question)
+    last_answer_text = ans
+    conversation_history.append({"role": "bot", "time": timestamp, "text": ans})
+    return jsonify({"answer": ans})
+@app.route('/read-aloud', methods=['POST'])
+def read_aloud_endpoint():
+    data = request.get_json()
+    text_to_read = data.get('text', '').strip()
+    if not text_to_read:
+        return jsonify({"status": "No text provided to read."}), 400
+    try:
+        # Create a temporary file for the speech audio
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as fp:
+            temp_audio_path = fp.name
+        tts_engine.save_to_file(text_to_read, temp_audio_path)
+        tts_engine.runAndWait()
+        # You would typically serve this file or stream it.
+        # For simplicity, let's just confirm it was generated.
+        # In a real app, you might use Flask's send_file for audio playback.
+        # For now, let's just return success.
+        # This approach is suitable if the browser requests the audio file directly after this.
+        # For direct playback, you might stream it or serve it immediately.
+        # For web, it's more common to have the frontend's SpeechSynthesis API handle this.
+        # The frontend `readAloud` function already does this.
+        # So, this endpoint might not be strictly necessary unless for server-side TTS.
+        return jsonify({"status": "TTS audio generated (server-side)."})
+    except Exception as e:
+        return jsonify({"status": f"Error during TTS: {str(e)}"}), 500
+    finally:
+        if os.path.exists(temp_audio_path):
+            os.remove(temp_audio_path)
+@app.route('/upload-mp3', methods=['POST'])
+def upload_mp3_endpoint():
+    global last_question_text, last_answer_text, conversation_history
+    if 'file' not in request.files:
+        return jsonify({"message": "No file part"}), 400
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({"message": "No selected file"}), 400
+    if file:
+        filename = secure_filename(file.filename)
+        # Create a temporary directory to save the uploaded file and its WAV conversion
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mp3_path = os.path.join(tmpdir, filename)
+            file.save(mp3_path)
+            wav_path = os.path.join(tmpdir, filename.replace(".mp3", ".wav"))
+            try:
+                sound = AudioSegment.from_mp3(mp3_path)
+                sound.export(wav_path, format="wav")
+            except Exception as e:
+                return jsonify({"message": f"Error converting MP3 to WAV: {e}"}), 500
+            try:
+                recognizer = sr.Recognizer()
+                with sr.AudioFile(wav_path) as src:
+                    audio = recognizer.record(src)
+                    text = recognizer.recognize_google(audio)
+            except sr.UnknownValueError:
+                return jsonify({"message": "Speech not understood."}), 400
+            except sr.RequestError as e:
+                return jsonify({"message": f"Speech recognition service error: {e}"}), 500
+            # Store transcription temporarily (can be handled differently)
+            transcript_path = os.path.join(tmpdir, "transcription.txt")
+            with open(transcript_path, "w", encoding="utf-8") as f:
+                f.write(text)
+            # Option to summarize or generate answer from transcription
+            # For this web integration, we'll return the transcription and let frontend decide
+            return jsonify({
+                "message": "MP3 transcribed successfully.",
+                "transcription": text
+            })
+@app.route('/summarize', methods=['POST'])
+def summarize_endpoint():
+    data = request.get_json()
+    text_to_summarize = data.get('text', '').strip()
+    if not text_to_summarize:
+        return jsonify({"summary": "No text provided for summarization."}), 400
+    def chunk_text(text, max_chunk_size=4000):
+        sentences = text.split(". ")
+        chunks = []
+        current_chunk = ""
+        for sentence in sentences:
+            # Add sentence length + 2 for ". "
+            if len(current_chunk) + len(sentence) + 2 < max_chunk_size:
+                current_chunk += sentence + ". "
+            else:
+                chunks.append(current_chunk.strip())
+                current_chunk = sentence + ". "
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+        return chunks
+    try:
+        chunks = chunk_text(text_to_summarize)
+        summaries = [
+            summarizer_pipeline(chunk, max_length=150, min_length=50, do_sample=False)[0]["summary_text"]
+            for chunk in chunks
+        ]
+        final_input = " ".join(summaries)
+        final_summary = summarizer_pipeline(final_input, max_length=150, min_length=50, do_sample=False)[0]["summary_text"]
+        return jsonify({"summary": final_summary})
+    except Exception as e:
+        return jsonify({"summary": f"Error during summarization: {e}"}), 500
+@app.route('/history', methods=['GET'])
+def get_history():
+    return jsonify({"history": conversation_history})
+if __name__ == '__main__':
+    # Make sure your datasets are in the same directory as app.py
+    # ibtehaj dataset.parquet
+    # pdf_data.json
+    # man.jpg (for the image)
+    app.run(debug=True) # debug=True allows for automatic reloading on code changes

man.jpg ADDED Viewed

pdf_data.json ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:8556bdcc80fe496120c4f527e17d032dbaa699358026007a107545b9b71e2944
+size 46924676

requirement.txt ADDED Viewed

	@@ -0,0 +1,11 @@

+gradio
+faiss-cpu
+sentence-transformers
+transformers
+huggingface_hub
+pyttsx3
+speechrecognition
+pydub
+pandas
+langdetect
+numpy

script.js ADDED Viewed

	@@ -0,0 +1,106 @@

+// Handle Generate button click
+document.getElementById("generateBtn").addEventListener("click", async () => {
+  const question = document.getElementById("questionInput").value.trim();
+  const responseBox = document.getElementById("responseOutput");
+  const historyBox = document.getElementById("history");
+  if (!question) {
+    responseBox.value = "Please enter your legal question.";
+    return;
+  }
+  responseBox.value = "Generating...";
+  try {
+    const res = await fetch("/answer", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ question })
+    });
+    const data = await res.json();
+    const answer = data.answer || "No answer received.";
+    responseBox.value = answer;
+    // Update top label
+    document.getElementById("topLabel").innerText = question;
+    // Update history
+    historyBox.value += `\n\nYou: ${question}\nBot: ${answer}`;
+  } catch (err) {
+    responseBox.value = `Error: ${err}`;
+  }
+});
+// Handle Reset button
+function resetApp() {
+  document.getElementById("questionInput").value = "";
+  document.getElementById("responseOutput").value = "";
+  document.getElementById("topLabel").innerText = "Dictate your legal question!";
+}
+// Handle Read Aloud
+function readAloud() {
+  const text = document.getElementById("responseOutput").value;
+  if (!text.trim()) return;
+  const synth = window.speechSynthesis;
+  const utterance = new SpeechSynthesisUtterance(text);
+  synth.speak(utterance);
+}
+// Handle Save
+function saveQA() {
+  const question = document.getElementById("questionInput").value.trim();
+  const answer = document.getElementById("responseOutput").value.trim();
+  if (!question || !answer) {
+    alert("Nothing to save.");
+    return;
+  }
+  const blob = new Blob([`Question:\n${question}\n\nAnswer:\n${answer}`], { type: "text/plain" });
+  const link = document.createElement("a");
+  link.href = URL.createObjectURL(blob);
+  link.download = "QnA.txt";
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+}
+// Handle Upload MP3 (Disabled in web)
+function uploadMP3() {
+  alert("📁 MP3 upload is only supported in the desktop assistant.");
+}
+// Handle Dictate (Web Speech API)
+function handleDictate() {
+  if (!('webkitSpeechRecognition' in window)) {
+    alert("Speech recognition not supported in this browser. Use Chrome.");
+    return;
+  }
+  const recognition = new webkitSpeechRecognition();
+  recognition.lang = "en-US";
+  recognition.interimResults = false;
+  recognition.maxAlternatives = 1;
+  document.getElementById("topLabel").innerText = "Listening... 🎙";
+  recognition.onresult = function (event) {
+    const transcript = event.results[0][0].transcript;
+    document.getElementById("questionInput").value = transcript;
+    document.getElementById("topLabel").innerText = transcript;
+  };
+  recognition.onerror = function (event) {
+    console.error("Speech recognition error:", event.error);
+    document.getElementById("topLabel").innerText = "Could not recognize speech.";
+  };
+  recognition.onend = function () {
+    console.log("Speech recognition ended.");
+  };
+  recognition.start();
+}

style.css ADDED Viewed

	@@ -0,0 +1,154 @@

+/* === GENERAL === */
+body {
+  margin: 0;
+  font-family: Arial, sans-serif;
+  background-color: #b6edf0;
+}
+h1.title {
+  text-align: center;
+  font-size: 48px;
+  font-weight: bold;
+  color: #333;
+  margin-top: 20px;
+}
+/* === CONTAINER LAYOUT === */
+.container {
+  display: flex;
+  flex-direction: row;
+  padding: 10px;
+  margin: 10px;
+  gap: 10px;
+}
+/* === LEFT PANEL (Image) === */
+.left-panel {
+  background-color: #ffffff;
+  width: 240px;
+  padding: 10px;
+  border-radius: 20px;
+  text-align: center;
+  padding-top: 90px;
+}
+.left-panel img {
+  width: 220px;
+  height: 260px;
+  border-radius: 10px;
+  margin-top: 60px;
+}
+/* === CENTER PANEL === */
+.center-panel {
+  flex-grow: 1;
+  background-color: #b0dde9;
+  border-radius: 20px;
+  padding: 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+/* Top Center Label */
+.top-label textarea {
+  width: 97%;
+  height: 100px;
+  font-size: 14px;
+  font-family: Arial, sans-serif;
+  background-color: #f0f0f0;
+  border-radius: 10px;
+  border: 1px solid #ccc;
+  padding: 12px;
+  resize: none;
+}
+/* Q&A Section */
+.qa-section {
+  display: flex;
+  gap: 10px;
+}
+.input-area, .output-area {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  background-color: #ffffff;
+  padding: 10px;
+  border-radius: 20px;
+}
+textarea {
+  resize: none;
+  font-family: Arial, sans-serif;
+  font-size: 14px;
+  padding: 10px;
+  border-radius: 10px;
+  border: 1px solid #ccc;
+  min-height: 180px;
+  background-color: #f9fbe7;
+}
+/* === BUTTON PANEL === */
+.button-panel {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: space-between;
+  gap: 10px;
+  padding: 10px;
+  background-color: #ffffff;
+  border-radius: 20px;
+}
+.button-panel button {
+  flex: 1;
+  min-width: 140px;
+  height: 45px;
+  border: none;
+  font-size: 14px;
+  font-weight: bold;
+  border-radius: 25px;
+  cursor: pointer;
+  transition: 0.2s ease-in-out;
+}
+.button-panel button:hover {
+  transform: scale(1.05);
+}
+/* Individual button colors to match Tkinter version */
+.button-panel button:nth-child(1) { background-color: #80deea; color: black; }
+.button-panel button:nth-child(2) { background-color: #c5e1a5; color: black; }
+.button-panel button:nth-child(3) { background-color: #ffccbc; color: black; }
+.button-panel button:nth-child(4) { background-color: #8ad5d5; color: black; }
+.button-panel button:nth-child(5) { background-color: #ffe082; color: black; }
+.button-panel button:nth-child(6) { background-color: #d7ccc8; color: black; }
+/* === RIGHT PANEL (History) === */
+.right-panel {
+  width: 300px;
+  background-color: #9ed4dc;
+  border-radius: 20px;
+  padding: 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+.right-panel label {
+  font-weight: bold;
+}
+#history {
+  flex: 1;
+  height: 500px;
+  resize: none;
+  border-radius: 10px;
+  padding: 10px;
+  font-family: Consolas, monospace;
+  font-size: 13px;
+  border: 1px solid #ccc;
+  background-color: #ffffff;
+  overflow-y: auto;
+}