dure

agents.py

@@ -1,7 +1,6 @@
 # agents.py
 from langgraph.prebuilt import create_react_agent
 import os
-import json
 import logging
 
 # Set up logging
@@ -23,23 +22,6 @@ def set_api_key(api_key: str) -> bool:
         logger.error("Invalid API key provided")
         return False
 
-def load_document_data() -> str:
-    """Load document data from JSON file if it exists"""
-    try:
-        if os.path.exists("document_data.json"):
-            with open("document_data.json", "r", encoding="utf-8") as f:
-                doc_data = json.load(f)
-                if doc_data.get("documents"):
-                    # Format the documents for agent consumption
-                    formatted_docs = []
-                    for doc_id, doc_info in doc_data["documents"].items():
-                        formatted_docs.append(f"Document: {doc_info['title']}\nContent: {doc_info['content']}\n---")
-                    return "\n".join(formatted_docs)
-        return ""
-    except Exception as e:
-        logger.error(f"Error loading document data: {e}")
-        return ""
-
 def create_agent_response(prompt: str, user_input: str, model: str = "anthropic:claude-3-haiku-20240307") -> str:
     """Generic function to create and invoke any agent"""
     global _api_key
@@ -91,13 +73,9 @@ def create_agent_response(prompt: str, user_input: str, model: str = "anthropic:
 
 # ==================== CORE AGENT FUNCTIONS ====================
 
-def judge_agent(student_arg: str, opponent_arg: str = "") -> str:
+def judge_agent(student_arg: str, opponent_arg: str = "", documents: str = "") -> str:
     """Judge agent for evaluating legal arguments"""
     logger.info("Judge agent called")
-    
-    # Load document data
-    doc_data = load_document_data()
-    
     prompt = """You are an experienced federal judge presiding over a courtroom.
     
 Your role is to:
@@ -106,22 +84,17 @@ Your role is to:
 - Point out strengths and weaknesses in arguments
 - Ensure proper legal procedure is followed
 - Give guidance on how to strengthen legal positions
-- Reference case documents when relevant to support your analysis
 
 Be fair, professional, and educational in your feedback.
 ALWAYS respond in this exact format: Judge: [your response]
 Keep responses 2-4 sentences, focusing on legal analysis."""
 
-    user_input = f"Student Argument: {student_arg}\nOpponent Argument: {opponent_arg}\nCase Documents: {doc_data}"
+    user_input = f"Student Argument: {student_arg}\nOpponent Argument: {opponent_arg}\nCase Documents: {documents}"
     return create_agent_response(prompt, user_input)
 
 def opponent_agent(student_arg: str, case_context: str = "") -> str:
     """Opponent agent for counter-arguments"""
     logger.info("Opponent agent called")
-    
-    # Load document data
-    doc_data = load_document_data()
-    
     prompt = """You are a skilled attorney arguing the opposing side in this case.
     
 Your role is to:
@@ -130,22 +103,17 @@ Your role is to:
 - Question the student's reasoning and evidence
 - Provide compelling opposition that helps the student improve
 - Stay focused on the legal issues at hand
-- Reference case documents when they support your opposing arguments
 
 Be persuasive, professional, and challenging but fair.
 ALWAYS respond in this exact format: Opponent: [your response]
 Keep responses 2-4 sentences, focused on strong legal counter-arguments."""
 
-    user_input = f"Student's Argument: {student_arg}\nCase Context: {case_context}\n\nCase Documents:\n{doc_data}"
+    user_input = f"Student's Argument: {student_arg}\nCase Context: {case_context}"
     return create_agent_response(prompt, user_input)
 
 def narrator_agent(context: str, student_arg: str = "", opponent_arg: str = "") -> str:
     """Enhanced narrator agent that handles courtroom atmosphere AND side character arguments"""
     logger.info("Narrator agent called")
-    
-    # Load document data
-    doc_data = load_document_data()
-    
     prompt = """You are a courtroom narrator who describes the scene and occasionally voices side characters.
     
 Your roles include:
@@ -154,7 +122,6 @@ Your roles include:
 - Occasionally speaking as side characters (bailiff, court clerk, witnesses, gallery reactions)
 - Setting the dramatic tone and maintaining engagement
 - Providing procedural context when needed
-- Referencing case documents when they add to the narrative
 
 You can voice side characters like:
 - Bailiff: "Order in the court!" or procedural announcements
@@ -167,7 +134,7 @@ When voicing side characters, format as: "Narrator: [description] - Character: '
 Otherwise format as: "Narrator: [your narration]"
 Keep responses 2-4 sentences, atmospheric and engaging."""
 
-    user_input = f"Context: {context}\nStudent Argument: {student_arg}\nOpponent Argument: {opponent_arg}\n\nCase Documents:\n{doc_data}"
+    user_input = f"Context: {context}\nStudent Argument: {student_arg}\nOpponent Argument: {opponent_arg}"
     return create_agent_response(prompt, user_input)
 
 # ==================== AGENT REGISTRY ====================

app.py

@@ -1,4 +1,3 @@
-import json
 import gradio as gr
 import time
 import logging
@@ -6,8 +5,7 @@ from typing import Dict, List, Tuple, Optional
 from agents import judge_agent, opponent_agent, narrator_agent, set_api_key
 from dotenv import load_dotenv
 import os
-from files_extraction import (
-    extract_text_from_pdf_bytes,extract_text_from_docx_bytes, extract_text_from_txt_bytes)
+
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -72,11 +70,11 @@ class LawTrainingSystem:
 system = LawTrainingSystem()
 
 # ==================== AGENT RESPONSE HANDLERS ====================
-def generate_judge_response(student_message: str, opponent_message: str = "") -> str:
+def generate_judge_response(student_message: str, opponent_message: str = "", documents: str = "") -> str:
     """Generate Judge AI response"""
     try:
         logger.info("Generating judge response")
-        return judge_agent(student_message, opponent_message)
+        return judge_agent(student_message, opponent_message, documents)
     except Exception as e:
         logger.error(f"Error in judge response: {e}", exc_info=True)
         return f"Judge: I'm having trouble processing your argument. Error: {str(e)}"
@@ -205,52 +203,15 @@ def upload_case_documents(files) -> str:
     try:
         if not files:
             return "No documents uploaded"
-
-        all_extracted_text = []
-        document_data_for_agent = {"documents": {}}
-
-        for idx, file_path in enumerate(files):
-            # Read bytes from the file path
-            with open(file_path, "rb") as f:
-                file_bytes = f.read()
-
-            # Determine extension
-            file_extension = os.path.splitext(file_path)[1].lstrip(".").lower()
-
-            # Extract text based on file type
-            if file_extension == "pdf":
-                text = extract_text_from_pdf_bytes(file_bytes)
-            elif file_extension == "docx":
-                text = extract_text_from_docx_bytes(file_bytes)
-            elif file_extension == "pptx":
-                text = extract_text_from_pptx_bytes(file_bytes)
-            elif file_extension == "txt":
-                text = extract_text_from_txt_bytes(file_bytes)
-            else:
-                text = ""
-
-            # Collect results
-            if text:
-                all_extracted_text.append(text)
-                document_data_for_agent["documents"][f"doc_{idx+1}"] = {
-                    "title": os.path.basename(file_path),
-                    "content": text
-                }
-
-        # Save JSON only once, after processing
-        if document_data_for_agent["documents"]:
-            json_filename = "document_data.json"
-            with open(json_filename, "w", encoding="utf-8") as json_file:
-                json.dump(document_data_for_agent, json_file, indent=4, ensure_ascii=False)
-
-        # Log and return summary
-        uploaded_names = [os.path.basename(p) for p in files]
-        logger.info(f"Uploaded {len(files)} documents: {', '.join(uploaded_names)}")
-        return f"Uploaded {len(files)} documents: {', '.join(uploaded_names)}"
-
+        
+        # TODO: Process uploaded documents with document parsing
+        file_names = [f.name for f in files]
+        logger.info(f"Uploaded {len(files)} documents: {file_names}")
+        return f"Uploaded {len(files)} documents: {', '.join(file_names)}"
+        
     except Exception as e:
-        logger.error("Error uploading documents", exc_info=True)
-        return f"Error uploading documents: {e}"
+        logger.error(f"Error uploading documents: {e}", exc_info=True)
+        return f"Error uploading documents: {str(e)}"
 
 # ==================== GRADIO INTERFACE ====================
 def create_law_training_interface():
@@ -314,7 +275,6 @@ def create_law_training_interface():
                     label="Upload Case Documents",
                     file_count="multiple",
                     file_types=[".pdf", ".txt", ".docx"],
-                    type="filepath",   
                     elem_classes="upload-section"
                 )
                 upload_status = gr.Textbox(

files_extraction.py

@@ -1,60 +0,0 @@
-
-from PyPDF2 import PdfReader
-from docx import Document
-import zipfile
-import xml.etree.ElementTree as ET
-import io
-
-def clean_extracted_text(text: str) -> str:
-    """
-    Normalize and collapse whitespace in extracted text.
-    """
-    lines = [line.strip() for line in text.split("\n") if line.strip()]
-    return ' '.join(lines)
-
-def extract_text_from_pdf_bytes(pdf_bytes: bytes) -> str:
-    """
-    Extract text from PDF bytes using PyPDF2.
-    """
-    try:
-        pdf_file = io.BytesIO(pdf_bytes)
-        reader = PdfReader(pdf_file)
-        text = ""
-        for page in reader.pages:
-            page_text = page.extract_text() or ""
-            text += clean_extracted_text(page_text) + "\n\n"
-        return text.strip()
-    except Exception as e:
-        print(f"Error extracting text from PDF: {e}")
-        return ""
-
-def extract_text_from_docx_bytes(docx_bytes: bytes) -> str:
-    """
-    Extract text (paragraphs and tables) from DOCX bytes.
-    """
-    try:
-        docx_file = io.BytesIO(docx_bytes)
-        doc = Document(docx_file)
-        text = ""
-        # paragraphs
-        for para in doc.paragraphs:
-            text += para.text + "\n"
-        # tables
-        for table in doc.tables:
-            for row in table.rows:
-                text += " | ".join(cell.text for cell in row.cells) + "\n"
-        return clean_extracted_text(text).strip()
-    except Exception as e:
-        print(f"Error extracting text from DOCX: {e}")
-        return ""
-
-
-def extract_text_from_txt_bytes(txt_bytes: bytes, encoding: str = 'utf-8') -> str:
-    """
-    Extract and clean text from raw TXT bytes using the given encoding.
-    """
-    try:
-        raw_text = txt_bytes.decode(encoding, errors='ignore')
-    except Exception:
-        raw_text = txt_bytes.decode('latin-1', errors='ignore')
-    return clean_extracted_text(raw_text).strip()

requirements.txt

@@ -1,6 +1,4 @@
 langgraph
 langchain
 dotenv
-langchain-anthropic
-python-docx
-PyPDF2
+langchain-anthropic