Update app.py

app.py

@@ -1,30 +1,16 @@
+from typing import Optional, Dict
 import streamlit as st
-import requests
-import json
-import fitz  # PyMuPDF
-from fpdf import FPDF
 import os
-import tempfile
-import base64
-import dotenv
 from dotenv import load_dotenv
 import torch
 from transformers import DistilBertForSequenceClassification, DistilBertTokenizer
 from torch.nn.functional import softmax
 from doctr.models import ocr_predictor
 from doctr.io import DocumentFile
-import tempfile
+from functionbloom import save_uploaded_file, get_pdf_path, extract_text_pymupdf, get_bloom_taxonomy_scores,generate_ai_response,normalize_bloom_weights, generate_pdf,process_pdf_and_generate_questions,get_bloom_taxonomy_details
+from functionbloom import predict_with_loaded_model, process_document, sendtogemini
 
 
-def save_uploaded_file(uploaded_file):
-    if uploaded_file is not None:
-        file_extension = uploaded_file.name.split('.')[-1].lower()
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix = f'.{file_extension}')
-        temp_file.write(uploaded_file.getvalue())
-        temp_file.close()
-        return temp_file.name
-    return None
-
 load_dotenv()
 
 model = DistilBertForSequenceClassification.from_pretrained('./fine_tuned_distilbert')
@@ -35,206 +21,164 @@ mapping = {"Remembering": 0, "Understanding": 1, "Applying": 2, "Analyzing": 3,
 reverse_mapping = {v: k for k, v in mapping.items()}
 modelocr = ocr_predictor(det_arch='db_resnet50', reco_arch='crnn_vgg16_bn', pretrained=True)
 
-# Previous functions from Question Generator
-def get_pdf_path(pdf_source=None, uploaded_file=None):
-    try:
-        # If a file is uploaded locally
-        if uploaded_file is not None:
-            # Create a temporary file to save the uploaded PDF
-            temp_dir = tempfile.mkdtemp()
-            pdf_path = os.path.join(temp_dir, uploaded_file.name)
-            
-            # Save the uploaded file
-            with open(pdf_path, "wb") as pdf_file:
-                pdf_file.write(uploaded_file.getvalue())
-            return pdf_path
-
-        # If a URL is provided
-        if pdf_source:
-            response = requests.get(pdf_source, timeout=30)
-            response.raise_for_status()
-            
-            # Create a temporary file
-            temp_dir = tempfile.mkdtemp()
-            pdf_path = os.path.join(temp_dir, "downloaded.pdf")
-            
-            with open(pdf_path, "wb") as pdf_file:
-                pdf_file.write(response.content)
-            return pdf_path
-
-        # If no source is provided
-        st.error("No PDF source provided.")
-        return None
-    except Exception as e:
-        st.error(f"Error getting PDF: {e}")
-        return None
-
-def extract_text_pymupdf(pdf_path):
-    try:
-        doc = fitz.open(pdf_path)
-        pages_content = []
-        for page_num in range(len(doc)):
-            page = doc[page_num]
-            pages_content.append(page.get_text())
-        doc.close()
-        return " ".join(pages_content)  # Join all pages into one large context string
-    except Exception as e:
-        st.error(f"Error extracting text from PDF: {e}")
-        return ""
-
-def generate_ai_response(api_key, assistant_context, user_query, role_description, response_instructions, bloom_taxonomy_weights, num_questions):
-    try:
-        url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key={api_key}"
-        
-        prompt = f"""
-        You are a highly knowledgeable assistant. Your task is to assist the user with the following context from an academic paper.
-
-        **Role**: {role_description}
-
-        **Context**: {assistant_context}
-
-        **Instructions**: {response_instructions}
-
-        **Bloom's Taxonomy Weights**:
-        Knowledge: {bloom_taxonomy_weights['Knowledge']}%
-        Comprehension: {bloom_taxonomy_weights['Comprehension']}%
-        Application: {bloom_taxonomy_weights['Application']}%
-        Analysis: {bloom_taxonomy_weights['Analysis']}%
-        Synthesis: {bloom_taxonomy_weights['Synthesis']}%
-        Evaluation: {bloom_taxonomy_weights['Evaluation']}%
-
-        **Query**: {user_query}
-
-        **Number of Questions**: {num_questions}
-        """
-        
-        payload = {
-            "contents": [
-                {
-                    "parts": [
-                        {"text": prompt}
-                    ]
-                }
-            ]
-        }
-        headers = {"Content-Type": "application/json"}
-
-        response = requests.post(url, headers=headers, data=json.dumps(payload), timeout=60)
-        response.raise_for_status()
-        
-        result = response.json()
-        questions = result.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
-        questions_list = [question.strip() for question in questions.split("\n") if question.strip()]
-        return questions_list
-    except requests.RequestException as e:
-        st.error(f"API request error: {e}")
-        return []
-    except Exception as e:
-        st.error(f"Error generating questions: {e}")
-        return []
-
-def normalize_bloom_weights(bloom_weights):
-    total = sum(bloom_weights.values())
-    if total != 100:
-        normalization_factor = 100 / total
-        # Normalize each weight by multiplying it by the normalization factor
-        bloom_weights = {key: round(value * normalization_factor, 2) for key, value in bloom_weights.items()}
-    return bloom_weights
-
-def generate_pdf(questions, filename="questions.pdf"):
-    try:
-        pdf = FPDF()
-        pdf.set_auto_page_break(auto=True, margin=15)
-        pdf.add_page()
-
-        # Set font
-        pdf.set_font("Arial", size=12)
-        
-        # Add a title or heading
-        pdf.cell(200, 10, txt="Generated Questions", ln=True, align="C")
-
-        # Add space between title and questions
-        pdf.ln(10)
-
-        # Loop through questions and add them to the PDF
-        for i, question in enumerate(questions, 1):
-            # Using multi_cell for wrapping the text in case it's too long
-            pdf.multi_cell(0, 10, f"Q{i}: {question}")
-
-        # Save the generated PDF to the file
-        pdf.output(filename)
-        return filename
-    except Exception as e:
-        st.error(f"Error generating PDF: {e}")
-        return None
-
-def process_pdf_and_generate_questions(pdf_source, uploaded_file, api_key, role_description, response_instructions, bloom_taxonomy_weights, num_questions):
-    try:
-        # Get PDF path (either from URL or uploaded file)
-        pdf_path = get_pdf_path(pdf_source, uploaded_file)
-        if not pdf_path:
-            return []
-
-        # Extract text
-        pdf_text = extract_text_pymupdf(pdf_path)
-        if not pdf_text:
-            return []
-
-        # Generate questions
-        assistant_context = pdf_text
-        user_query = "Generate questions based on the above context."
-        normalized_bloom_weights = normalize_bloom_weights(bloom_taxonomy_weights)
-        questions = generate_ai_response(
-            api_key, 
-            assistant_context, 
-            user_query, 
-            role_description, 
-            response_instructions, 
-            normalized_bloom_weights, 
-            num_questions
-        )
-
-        # Clean up temporary PDF file
-        try:
-            os.remove(pdf_path)
-            # Remove the temporary directory
-            os.rmdir(os.path.dirname(pdf_path))
-        except Exception as e:
-            st.warning(f"Could not delete temporary PDF file: {e}")
-
-        return questions
-    except Exception as e:
-        st.error(f"Error processing PDF and generating questions: {e}")
-        return []
-
 def main():
     st.set_page_config(page_title="Academic Paper Tool", page_icon="📝", layout="wide")
+    
     # Tabs for different functionalities
     st.markdown("""
-       <style>
-            .stTabs [data-baseweb="tab"] {
-                margin-bottom: 1rem;
-                flex: 1;
-                justify-content: center;
-            }
-            .stTabs [data-baseweb="tab-list"] button [data-testid="stMarkdownContainer"] p {
-            font-size:2rem;
+    <style>
+        .stTabs [data-baseweb="tab"] {
+            margin-bottom: 1rem;
+            flex: 1;
+            justify-content: center;
+        }
+        .stTabs [data-baseweb="tab-list"] button [data-testid="stMarkdownContainer"] p {
+            font-size: 2rem;
             padding: 0 2rem;
+            font-weight: bold;
             margin: 0;
-            }
-        </style>
+        }
+        
+        /* Information Button Styling */
+        .info-button {
+            background-color: #f0f2f6;
+            border: 1px solid #4a6cf7;
+            border-radius: 50%;
+            width: 24px;
+            height: 24px;
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            margin-left: 8px;
+            font-weight: bold;
+            color: #4a6cf7;
+        }
+        
+        /* Modal Styling */
+        .modal {
+            display: none;
+            position: fixed;
+            z-index: 1000;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            overflow: auto;
+            background-color: rgba(0,0,0,0.4);
+        }
+        
+        .modal-content {
+            background-color: #fefefe;
+            margin: 15% auto;
+            padding: 20px;
+            border: 1px solid #888;
+            width: 80%;
+            max-width: 500px;
+            border-radius: 10px;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        }
+        
+        .close-button {
+            color: #aaa;
+            float: right;
+            font-size: 28px;
+            font-weight: bold;
+            cursor: pointer;
+        }
+        
+        .close-button:hover,
+        .close-button:focus {
+            color: black;
+            text-decoration: none;
+            cursor: pointer;
+        }
+        
+        /* Question Container Styling */
+        .question-container {
+            display: flex;
+            align-items: start;
+            gap: 10px;
+            margin-bottom: 10px;
+        }
+        
+        /* Info Button Styling */
+        .info-button {
+            background-color: #f0f2f6;
+            border: 1px solid #4a6cf7;
+            border-radius: 50%;
+            width: 24px;
+            height: 24px;
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            font-weight: bold;
+            color: #4a6cf7;
+            flex-shrink: 0;
+            font-size: 14px;
+        }
+        
+        .info-button:hover {
+            background-color: #4a6cf7;
+            color: white;
+        }
+        
+        /* Modal Styling */
+        .modal {
+            display: none;
+            position: fixed;
+            z-index: 9999;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0,0,0,0.4);
+        }
+        
+        .modal-content {
+            background-color: #fefefe;
+            margin: 15% auto;
+            padding: 20px;
+            border: 1px solid #888;
+            width: 80%;
+            max-width: 500px;
+            border-radius: 10px;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            position: relative;
+        }
+        
+        .close-button {
+            position: absolute;
+            right: 10px;
+            top: 5px;
+            color: #aaa;
+            font-size: 28px;
+            font-weight: bold;
+            cursor: pointer;
+        }
+        
+        .close-button:hover,
+        .close-button:focus {
+            color: black;
+            text-decoration: none;
+            cursor: pointer;
+        }
+    </style>
     """, unsafe_allow_html=True)
+
     tab1, tab2 = st.tabs(["Question Generator", "Paper Scorer"])
 
     if 'totalscore' not in st.session_state:
         st.session_state.totalscore = None
     if 'show_details' not in st.session_state:
         st.session_state.show_details = False
+    if 'question_scores' not in st.session_state:
+        st.session_state.question_scores = {}
 
-    
     # Question Generator Tab
     with tab1:
-        st.title("🎓 Academic Paper Question Generator")
+        st.markdown("<h1 style='font-size: 28px;'>🎓 Academic Paper Question Generator</h1>", unsafe_allow_html=True)
         st.markdown("Generate insightful questions from academic papers using Bloom's Taxonomy")
 
         # Initialize session state variables with defaults
@@ -251,11 +195,10 @@ def main():
 
         # API Configuration
         api_key = os.getenv('GEMINI_API_KEY')
-        # api_key = st.sidebar.text_input("Enter Gemini API Key", type="password", value=apivalue)
         
         # Main form for PDF and question generation
         with st.form(key='pdf_generation_form'):
-            st.header("PDF Source Configuration")
+            st.subheader("PDF Source")
             
             st.session_state.pdf_url = st.text_input(
                     "Enter the URL of the PDF", 
@@ -263,7 +206,7 @@ def main():
                     key="pdf_url_input"
                 )
             
-            st.markdown("<h3 style='text-align: center;'>OR</h3>", unsafe_allow_html=True)
+            st.markdown("<h4 style='text-align: center;'>OR</h4>", unsafe_allow_html=True)
 
             st.session_state.uploaded_file = st.file_uploader(
                     "Upload a PDF file", 
@@ -271,20 +214,30 @@ def main():
                     key="pdf_file_upload"
             )
 
+            # Question Length Selection
+            question_length = st.select_slider(
+                "Select Question Length",
+                options=["Short", "Medium", "Long"],
+                value="Medium",
+                help="Short: 10-15 words, Medium: 20-25 words, Long: 30-40 words"
+            )
+
+            st.session_state.include_numericals = st.checkbox("Include Numericals", key="include_numericals_checkbox")
+
             # Bloom's Taxonomy Weights
             st.subheader("Adjust Bloom's Taxonomy Weights")
             col1, col2, col3 = st.columns(3)
 
             with col1:
-                knowledge = st.slider("Knowledge or Remembering: Remembering information", 0, 100, 20, key='knowledge_slider')
-                application = st.slider("Application: Use knowledge in new situations or solve problems.", 0, 100, 20, key='application_slider')
+                knowledge = st.slider("Knowledge: Remembering information", 0, 100, 20, key='knowledge_slider')
+                application = st.slider("Application: Using abstractions in concrete situations", 0, 100, 20, key='application_slider')
 
             with col2:
-                comprehension = st.slider("Comprehension or Understanding: Comprehend and explain ideas or concepts.", 0, 100, 20, key='comprehension_slider')
+                comprehension = st.slider("Comprehension: Explaining the meaning of information", 0, 100, 20, key='comprehension_slider')
                 analysis = st.slider("Analysis: Breaking down a whole into component parts", 0, 100, 20, key='analysis_slider')
 
             with col3:
-                synthesis = st.slider("Synthesis or Creating: Putting parts together to form a new and integrated whole", 0, 100, 10, key='synthesis_slider')
+                synthesis = st.slider("Synthesis: Putting parts together to form a new and integrated whole", 0, 100, 10, key='synthesis_slider')
                 evaluation = st.slider("Evaluation: Making and defending judgments based on internal evidence or external criteria", 0, 100, 10, key='evaluation_slider')
 
             # Collect the Bloom's Taxonomy weights
@@ -331,38 +284,48 @@ def main():
                         role_description=role_description, 
                         response_instructions=response_instructions, 
                         bloom_taxonomy_weights=normalized_bloom_weights, 
-                        num_questions=num_questions
+                        num_questions=num_questions,
+                        question_length=question_length,
+                        include_numericals=st.session_state.include_numericals
                     )
+                    
         if st.session_state.questions:
             st.header("Generated Questions")
             
             # Create a form for question management to prevent reload
             with st.form(key='questions_form'):
                 for idx, question in enumerate(st.session_state.questions, 1):
-                    cols = st.columns([4, 1])  # Create two columns for radio buttons (Accept, Discard)
+                    cols = st.columns([4, 1])  # Create two columns
                     
                     with cols[0]:
+                        # Display the question
                         st.write(f"Q{idx}: {question}")
+                        
+                        # Add info button using Streamlit's expander
+                        with st.expander("Show Bloom's Taxonomy Details"):
+                            taxonomy_details = get_bloom_taxonomy_details(st.session_state.question_scores.get(question))
+                            st.text(taxonomy_details)
                     
                     # Use radio buttons for selection
                     with cols[1]:
-                        # Default value is 'Discard', so users can change it to 'Accept'
-                        selected_option = st.radio(f"Select an option for Q{idx}", ["Accept", "Discard"], key=f"radio_{idx}", index=1)
+                        selected_option = st.radio(
+                            f"Select an option for Q{idx}", 
+                            ["Accept", "Discard"], 
+                            key=f"radio_{idx}", 
+                            index=1
+                        )
                     
                     # Handle radio button state changes
                     if selected_option == "Accept":
-                        # Add to accepted questions if 'Accept' is selected
                         if question not in st.session_state.accepted_questions:
                             st.session_state.accepted_questions.append(question)
                     else:
-                        # Remove from accepted questions if 'Discard' is selected
                         if question in st.session_state.accepted_questions:
                             st.session_state.accepted_questions.remove(question)
 
                 # Submit button for question selection
                 submit_questions = st.form_submit_button("Update Accepted Questions")
 
-
             # Show accepted questions
             if st.session_state.accepted_questions:
                 st.header("Accepted Questions")
@@ -394,12 +357,10 @@ def main():
         - Support for PDF via URL or local upload
         """)
     with tab2:
-        st.title("📄 Academic Paper Scorer")
-        
-        # Add a descriptive subheader
-        st.markdown("### Evaluate the Quality of Your Academic Paper")
-        
-        # Create a styled container for the upload section
+        st.markdown("<h1 style='font-size: 28px;'>📄 Academic Paper Scorer</h1>", unsafe_allow_html=True)
+        st.markdown("Evaluate the Quality of Your Academic Paper")
+            
+            # Create a styled container for the upload section
         st.markdown("""
         <style>
         .upload-container {
@@ -430,7 +391,12 @@ def main():
                 type=['pdf','jpg','png','jpeg'],
                 label_visibility="collapsed"
             )
-            # Custom submit button with some styling
+
+            st.markdown("<div style='text-align: center; margin-top: 20px;'><strong>OR</strong></div>", unsafe_allow_html=True)
+            if 'question_typed' not in st.session_state:
+                st.session_state.question_typed = ""
+            st.text_area("Paste your question here", value=st.session_state.question_typed, key="question_typed")
+            question_typed = st.session_state.question_typed
             submit_button = st.form_submit_button(
                 "Score Paper", 
                 use_container_width=True,
@@ -440,7 +406,7 @@ def main():
         if submit_button:
             # Calculate total score
             pdf_path = save_uploaded_file(uploaded_file)
-            dummydata = sendtogemini(pdf_path)
+            dummydata = sendtogemini(inputpath=pdf_path, question=st.session_state.question_typed)
             #print(dummydata)
             total_score = {'Remembering': 0, 'Understanding': 0, 'Applying': 0, 'Analyzing': 0, 'Evaluating': 0, 'Creating': 0}
             for item in dummydata:
@@ -483,7 +449,7 @@ def main():
                         with col:
                             # Determine color based on score
                             score = round(item['score'][category],ndigits=3)
-                            color = 'green' if score > .7 else 'orange' if score > .4 else 'red'
+                            color = 'green' if score > .7 else 'orange' if score > .3 else 'red'
                             
                             st.markdown(f"""
                             <div style="text-align: center; 
@@ -502,87 +468,6 @@ def main():
                     if idx < len(dummydata):
                         st.markdown('---') 
 
-def predict_with_loaded_model(text):
-    inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)
-    input_ids = inputs['input_ids'].to(device)
-    model.eval()
-    with torch.no_grad():
-        outputs = model(input_ids)
-        logits = outputs.logits
-        probabilities = softmax(logits, dim=-1)
-    probabilities = probabilities.squeeze().cpu().numpy()
-    # Convert to float and format to 3 decimal places
-    class_probabilities = {reverse_mapping[i]: float(f"{prob:.3f}") for i, prob in enumerate(probabilities)}
-    return class_probabilities
-
-# def process_document(input_path):
-#     return {'Avg_Confidence': 0.9397169561947093, 'String': ['What are the key differences between classification and regression tasks in', 'supervised learning, and how do you determine which algorithm to use for a', 'specific problem?', 'e How does clustering differ from dimensionality reduction, and can you', 'provide real-world examples of where each is applied?', 'What are common evaluation metrics for classification models, and how do', 'precision, recall, and F1-score relate to each other?', 'How do convolutional neural networks (CNNS) and recurrent neural networks', '(RNNS) differ in their architecture and applications?', 'What steps can be taken to identify and mitigate bias in machine learning', 'models, and why is this an important consideration?']}
-
-def process_document(input_path):
-    if input_path.lower().endswith(".pdf"):
-        doc = DocumentFile.from_pdf(input_path)
-        #print(f"Number of pages: {len(doc)}")
-    elif input_path.lower().endswith((".jpg", ".jpeg", ".png", ".bmp", ".tiff")):
-        doc = DocumentFile.from_images(input_path)
-    else:
-        raise ValueError("Unsupported file type. Please provide a PDF or an image file.")
-    result = modelocr(doc)
-    def calculate_average_confidence(result):
-        total_confidence = 0
-        word_count = 0
-        for page in result.pages:
-            for block in page.blocks:
-                for line in block.lines:
-                    for word in line.words:
-                        total_confidence += word.confidence
-                        word_count += 1
-        average_confidence = total_confidence / word_count if word_count > 0 else 0
-        return average_confidence
-    average_confidence = calculate_average_confidence(result)
-    string_result = result.render()
-    return {'Avg_Confidence': average_confidence, 'String':string_result.split('\n')}
-
-def sendtogemini(inputpath):
-    qw = process_document(inputpath)
-    questionset = str(qw['String'])
-    # send this prompt to gemini : 
-    questionset += """You are given a list of text fragments containing questions fragments extracted by an ocr model. Your task is to:
-    # only Merge the question fragments into complete and coherent questions.Don't answer then.
-    # Separate each question , start a new question with @ to make them easily distinguishable for further processing."""
-    url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key={os.getenv('GEMINI_API_KEY')}"
-    
-    payload = {
-            "contents": [
-                {
-                    "parts": [
-                        {"text": questionset}
-                    ]
-                }
-            ]
-        }
-    headers = {"Content-Type": "application/json"}
-
-    response = requests.post(url, headers=headers, data=json.dumps(payload), timeout=60)
-    result = response.json()
-    res1 = result.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
-    question = []
-    for i in res1.split('\n'):
-        i = i.strip()
-        if len(i) > 0:
-            if i[0] == '@':
-                i = i[1:].strip().lower()
-                if i[0] == 'q':
-                    question.append(i[1:].strip())
-                else:
-                    question.append(i)
-    data = []
-    for i in question:
-        d = {}
-        d['question'] = i
-        d['score'] = predict_with_loaded_model(i)
-        data.append(d)
-    return data
-
 # Run Streamlit app
 if __name__ == "__main__":
-    main()
+    main()