Delete app.py

app.py

@@ -1,423 +0,0 @@
-import gradio as gr
-import spaces
-import os
-import logging
-import datetime
-from langchain_community.document_loaders import PyPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_community.vectorstores import Chroma
-from huggingface_hub import InferenceClient, get_token
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Set HF_HOME for caching Hugging Face assets in persistent storage
-os.environ["HF_HOME"] = "/data/.huggingface"
-os.makedirs(os.environ["HF_HOME"], exist_ok=True)
-
-# Define persistent storage directories
-DATA_DIR = "/data"  # Root persistent storage directory
-DOCS_DIR = os.path.join(DATA_DIR, "documents")  # Subdirectory for uploaded PDFs
-CHROMA_DIR = os.path.join(DATA_DIR, "chroma_db")  # Subdirectory for Chroma vector store
-
-# Create directories if they don't exist
-os.makedirs(DOCS_DIR, exist_ok=True)
-os.makedirs(CHROMA_DIR, exist_ok=True)
-
-# Initialize Cerebras InferenceClient
-try:
-    token = get_token()
-    if not token:
-        logger.error("HF_TOKEN is not set in Space secrets")
-        client = None
-    else:
-        client = InferenceClient(
-            model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
-            provider="cerebras",
-            token=token
-        )
-        logger.info("InferenceClient initialized successfully")
-except Exception as e:
-    logger.error(f"Failed to initialize InferenceClient: {str(e)}")
-    client = None
-
-# Global variables for vector store
-vectorstore = None
-retriever = None
-
-def list_uploaded_documents():
-    """List all uploaded documents in the persistent storage"""
-    try:
-        if not os.path.exists(DOCS_DIR):
-            return []
-        
-        files = os.listdir(DOCS_DIR)
-        pdf_files = [f for f in files if f.lower().endswith('.pdf')]
-        file_info = []
-        
-        for file in pdf_files:
-            file_path = os.path.join(DOCS_DIR, file)
-            file_size = os.path.getsize(file_path)
-            file_time = os.path.getmtime(file_path)
-            file_info.append({
-                "name": file,
-                "size": f"{file_size // 1024} KB",
-                "date": datetime.datetime.fromtimestamp(file_time).strftime('%Y-%m-%d %H:%M:%S')
-            })
-        
-        return file_info
-    except Exception as e:
-        logger.error(f"Error listing documents: {str(e)}")
-        return []
-
-def get_document_filenames():
-    """Get list of document filenames for dropdown"""
-    try:
-        if not os.path.exists(DOCS_DIR):
-            return []
-        
-        files = os.listdir(DOCS_DIR)
-        pdf_files = [f for f in files if f.lower().endswith('.pdf')]
-        return pdf_files
-    except Exception as e:
-        logger.error(f"Error getting document filenames: {str(e)}")
-        return []
-
-def delete_document(filename):
-    """Delete a document from persistent storage and update the vector store"""
-    try:
-        if not filename:
-            return "No file selected for deletion"
-        
-        file_path = os.path.join(DOCS_DIR, filename)
-        if not os.path.exists(file_path):
-            return f"File {filename} does not exist"
-        
-        # Delete the file
-        os.remove(file_path)
-        logger.info(f"Deleted file {filename}")
-        
-        # Refresh the vector store
-        refresh_status = refresh_vector_store()
-        
-        return f"File {filename} deleted successfully! {refresh_status}"
-    except Exception as e:
-        logger.error(f"Error deleting document: {str(e)}")
-        return f"Error deleting document: {str(e)}"
-
-def preview_document(filename, max_pages=3):
-    """Generate a preview of the document's content"""
-    try:
-        if not filename:
-            return "No file selected for preview"
-        
-        file_path = os.path.join(DOCS_DIR, filename)
-        if not os.path.exists(file_path):
-            return f"File {filename} does not exist"
-        
-        loader = PyPDFLoader(file_path)
-        documents = loader.load()
-        
-        # Limit preview to first few pages
-        preview_docs = documents[:max_pages]
-        preview_text = f"Preview of {filename} (first {len(preview_docs)} pages):\n\n"
-        
-        for i, doc in enumerate(preview_docs):
-            preview_text += f"--- Page {i+1} ---\n{doc.page_content[:500]}...\n\n"
-        
-        return preview_text
-    except Exception as e:
-        logger.error(f"Error previewing document: {str(e)}")
-        return f"Error previewing document: {str(e)}"
-
-@spaces.GPU(duration=180)  # Use GPU for vector store recreation
-def refresh_vector_store():
-    """Rebuild the vector store from all available documents"""
-    global vectorstore, retriever
-    try:
-        if not os.path.exists(DOCS_DIR):
-            logger.warning("Documents directory does not exist")
-            return "No documents directory found"
-        
-        files = [f for f in os.listdir(DOCS_DIR) if f.lower().endswith('.pdf')]
-        if not files:
-            logger.warning("No PDF documents found")
-            
-            # Clear the vector store
-            if os.path.exists(CHROMA_DIR):
-                import shutil
-                shutil.rmtree(CHROMA_DIR)
-                os.makedirs(CHROMA_DIR, exist_ok=True)
-            
-            vectorstore = None
-            retriever = None
-            return "No PDF documents found. Vector store cleared."
-        
-        # Load and process all documents
-        all_texts = []
-        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-        
-        for file in files:
-            file_path = os.path.join(DOCS_DIR, file)
-            try:
-                loader = PyPDFLoader(file_path)
-                documents = loader.load()
-                texts = text_splitter.split_documents(documents)
-                
-                # Add source file metadata to each chunk
-                for i, text in enumerate(texts):
-                    text.metadata["source"] = file
-                    
-                all_texts.extend(texts)
-                logger.info(f"Processed {file}, added {len(texts)} chunks")
-            except Exception as e:
-                logger.error(f"Error processing {file}: {str(e)}")
-        
-        # Create new vector store
-        if all_texts:
-            # Remove existing vector store
-            if os.path.exists(CHROMA_DIR):
-                import shutil
-                shutil.rmtree(CHROMA_DIR)
-                os.makedirs(CHROMA_DIR, exist_ok=True)
-            
-            vectorstore = Chroma.from_documents(
-                all_texts, embeddings, persist_directory=CHROMA_DIR
-            )
-            vectorstore.persist()
-            retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
-            logger.info(f"Vector store recreated with {len(all_texts)} chunks from {len(files)} files")
-            return f"Vector store updated with {len(files)} documents!"
-        else:
-            logger.warning("No text chunks extracted from documents")
-            return "No content could be extracted from the PDF files"
-    except Exception as e:
-        logger.error(f"Error refreshing vector store: {str(e)}")
-        return f"Error refreshing vector store: {str(e)}"
-
-@spaces.GPU(duration=180)  # Use ZeroGPU (H200) for embedding generation, 180s timeout
-def initialize_rag(file):
-    global vectorstore, retriever
-    try:
-        # Debug file object properties
-        logger.info(f"File object: {type(file)}, Attributes: {dir(file)}")
-        logger.info(f"File name: {file.name}")
-
-        # Validate file
-        if not file or not file.name:
-            logger.error("No file provided or invalid file name")
-            return "Error: No file provided or invalid file name"
-        
-        # Verify temporary file exists and is accessible
-        if not os.path.exists(file.name):
-            logger.error(f"Temporary file {file.name} does not exist")
-            return f"Error: Temporary file {file.name} does not exist"
-        
-        # Check temporary file size
-        file_size = os.path.getsize(file.name)
-        logger.info(f"Temporary file size: {file_size} bytes")
-        if file_size == 0:
-            logger.error("Uploaded file is empty")
-            return "Error: Uploaded file is empty"
-
-        # Save uploaded file to persistent storage
-        file_name = os.path.basename(file.name)
-        file_path = os.path.join(DOCS_DIR, file_name)
-        
-        # Check if file exists and its size
-        should_save = True
-        if os.path.exists(file_path):
-            existing_size = os.path.getsize(file_path)
-            logger.info(f"Existing file {file_name} size: {existing_size} bytes")
-            if existing_size == 0:
-                logger.warning(f"Existing file {file_name} is empty, will overwrite")
-            else:
-                logger.info(f"File {file_name} already exists and is not empty, skipping save")
-                should_save = False
-
-        if should_save:
-            try:
-                with open(file.name, "rb") as src_file:
-                    file_content = src_file.read()
-                logger.info(f"Read {len(file_content)} bytes from temporary file")
-                if not file_content:
-                    logger.error("File content is empty after reading")
-                    return "Error: File content is empty after reading"
-                with open(file_path, "wb") as dst_file:
-                    dst_file.write(file_content)
-                    dst_file.flush()  # Ensure write completes
-                # Verify written file
-                written_size = os.path.getsize(file_path)
-                logger.info(f"Saved {file_name} to {file_path}, size: {written_size} bytes")
-                if written_size == 0:
-                    logger.error(f"Failed to write {file_name}, file is empty")
-                    return f"Error: Failed to write {file_name}, file is empty"
-            except PermissionError as e:
-                logger.error(f"Permission error writing to {file_path}: {str(e)}")
-                return f"Error: Permission denied writing to {file_path}"
-            except Exception as e:
-                logger.error(f"Error writing file to {file_path}: {str(e)}")
-                return f"Error writing file: {str(e)}"
-
-        # After saving the file, refresh the vector store
-        refresh_status = refresh_vector_store()
-        logger.info(f"Vector store refresh status: {refresh_status}")
-        
-        return f"Document '{file_name}' processed and saved! {refresh_status}"
-    except Exception as e:
-        logger.error(f"Error processing document: {str(e)}")
-        return f"Error processing document: {str(e)}"
-
-def query_documents(query, history, system_prompt, max_tokens, temperature):
-    global retriever, client
-    try:
-        if client is None:
-            logger.error("InferenceClient not initialized")
-            return history, "Error: InferenceClient not initialized. Check HF_TOKEN."
-        if retriever is None:
-            logger.error("No documents loaded")
-            return history, "Error: No documents loaded. Please upload a document first."
-
-        # Ensure history is a list of [user, assistant] lists
-        logger.info(f"History before processing: {history}")
-        if not isinstance(history, list):
-            logger.warning("History is not a list, resetting")
-            history = []
-        history = [[str(item[0]), str(item[1])] for item in history if isinstance(item, (list, tuple)) and len(item) == 2]
-
-        # Retrieve relevant documents
-        docs = retriever.get_relevant_documents(query)
-        
-        # Format context with source information
-        context_parts = []
-        for doc in docs:
-            source = doc.metadata.get('source', 'unknown')
-            page = doc.metadata.get('page', 'unknown')
-            context_parts.append(f"[Source: {source}, Page: {page}]\n{doc.page_content}")
-        
-        context = "\n\n".join(context_parts)
-
-        # Call Cerebras inference
-        logger.info("Calling Cerebras inference")
-        response = client.chat_completion(
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": f"Context: {context}\n\nQuery: {query}"}
-            ],
-            max_tokens=int(max_tokens),
-            temperature=float(temperature),
-            stream=False
-        )
-        answer = response.choices[0].message.content
-        logger.info("Inference successful")
-
-        # Update chat history with list format
-        history.append([query, answer])
-        logger.info(f"History after append: {history}")
-        return history, ""  # Clear the query input
-    except Exception as e:
-        logger.error(f"Error querying documents: {str(e)}")
-        return history, f"Error querying documents: {str(e)}"
-
-# Load existing vector store on startup
-try:
-    if os.path.exists(CHROMA_DIR):
-        logger.info("Loading existing vector store")
-        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-        vectorstore = Chroma(persist_directory=CHROMA_DIR, embedding_function=embeddings)
-        retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
-        logger.info(f"Loaded vector store from {CHROMA_DIR}")
-except Exception as e:
-    logger.error(f"Error loading vector store: {str(e)}")
-
-# Create the Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# RAG Chatbot with Document Management")
-    
-    # File management tab
-    with gr.Tab("Document Management"):
-        # File upload
-        with gr.Row():
-            file_input = gr.File(label="Upload Document (PDF)", file_types=[".pdf"])
-            file_output = gr.Textbox(label="Upload Status")
-        
-        # Document listing and management
-        with gr.Row():
-            refresh_btn = gr.Button("Refresh Document List")
-            rebuild_vs_btn = gr.Button("Rebuild Vector Store")
-        
-        doc_list = gr.Dataframe(
-            headers=["name", "size", "date"],
-            label="Uploaded Documents"
-        )
-        
-        # Initialize dropdown with existing files
-        initial_files = get_document_filenames()
-        
-        with gr.Row():
-            selected_doc = gr.Dropdown(
-                label="Select Document", 
-                choices=initial_files,
-                allow_custom_value=True  # This helps avoid errors when dropdown is updated
-            )
-            preview_btn = gr.Button("Preview Document")
-            delete_btn = gr.Button("Delete Selected Document", variant="stop")
-        
-        doc_preview = gr.Textbox(label="Document Preview", lines=10)
-        delete_output = gr.Textbox(label="Operation Status")
-    
-    # Chat interface tab
-    with gr.Tab("Chat"):
-        chatbot = gr.Chatbot(label="Conversation")
-        
-        # Query and parameters
-        with gr.Row():
-            query_input = gr.Textbox(label="Query", placeholder="Ask about the document...")
-            system_prompt = gr.Textbox(
-                label="System Prompt",
-                value="You are a helpful assistant answering questions based on the provided document context. Only use the context provided to answer the question. If you don't know the answer, say so."
-            )
-        
-        with gr.Row():
-            max_tokens = gr.Slider(label="Max Tokens", minimum=50, maximum=2000, value=500, step=50)
-            temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=1.0, value=0.7, step=0.1)
-        
-        # Buttons
-        with gr.Row():
-            submit_btn = gr.Button("Send")
-            clear_btn = gr.Button("Clear Chat")
-    
-    # Event handlers for file management
-    def update_doc_list():
-        docs = list_uploaded_documents()
-        filenames = get_document_filenames()
-        return docs, gr.Dropdown(choices=filenames)
-    
-    file_input.upload(initialize_rag, file_input, file_output).then(
-        update_doc_list, None, [doc_list, selected_doc]
-    )
-    
-    refresh_btn.click(update_doc_list, None, [doc_list, selected_doc])
-    rebuild_vs_btn.click(refresh_vector_store, None, delete_output)
-    preview_btn.click(preview_document, selected_doc, doc_preview)
-    delete_btn.click(delete_document, selected_doc, delete_output).then(
-        update_doc_list, None, [doc_list, selected_doc]
-    )
-    
-    # Event handlers for chat
-    submit_btn.click(
-        query_documents,
-        inputs=[query_input, chatbot, system_prompt, max_tokens, temperature],
-        outputs=[chatbot, query_input]
-    )
-    
-    clear_btn.click(lambda: [], None, chatbot)
-    
-    # Initialize document list on startup
-    demo.load(update_doc_list, None, [doc_list, selected_doc])
-
-if __name__ == "__main__":
-    demo.launch()