Create app.py

app.py

@@ -0,0 +1,175 @@
+# app.py
+import streamlit as st
+import arxiv
+import requests
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+from keybert import KeyBERT
+from pyvis.network import Network
+from pybtex.database import parse_string
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import LatentDirichletAllocation
+import time
+import json
+
+# Initialize models
+@st.cache_resource
+def load_models():
+    # Summarization model
+    tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
+    summarizer = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")
+    
+    # Keyword model
+    kw_model = KeyBERT()
+    
+    # Research suggestion model
+    suggestion_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-base")
+    suggestion_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-base")
+    
+    return tokenizer, summarizer, kw_model, suggestion_tokenizer, suggestion_model
+
+def fetch_arxiv_papers(query, max_results=10):
+    client = arxiv.Client()
+    search = arxiv.Search(
+        query=query,
+        max_results=max_results,
+        sort_by=arxiv.SortCriterion.Relevance
+    )
+    results = []
+    for result in client.results(search):
+        results.append({
+            "title": result.title,
+            "abstract": result.summary,
+            "authors": [a.name for a in result.authors],
+            "published": result.published.strftime("%Y-%m-%d"),
+            "pdf_url": result.pdf_url,
+            "doi": result.doi
+        })
+    return results
+
+def fetch_semantic_scholar(query, max_results=5):
+    url = "https://api.semanticscholar.org/graph/v1/paper/search"
+    params = {
+        "query": query,
+        "limit": max_results,
+        "fields": "title,abstract,authors,year,references,url"
+    }
+    headers = {"x-api-key": "YOUR_API_KEY"}
+    response = requests.get(url, params=params, headers=headers)
+    if response.status_code == 200:
+        return response.json().get("data", [])
+    return []
+
+def generate_summary(text, tokenizer, model, max_length=300):
+    inputs = tokenizer([text], max_length=1024, return_tensors="pt", truncation=True)
+    summary_ids = model.generate(
+        inputs.input_ids, 
+        max_length=max_length, 
+        min_length=50, 
+        length_penalty=2.0, 
+        num_beams=4,
+        early_stopping=True
+    )
+    return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+
+def generate_concept_map(texts, model):
+    keywords = []
+    for text in texts:
+        kws = model.extract_keywords(text, keyphrase_ngram_range=(1,2))
+        keywords.extend([kw[0] for kw in kws])
+    
+    vectorizer = TfidfVectorizer()
+    X = vectorizer.fit_transform(keywords)
+    
+    net = Network(height="400px", width="100%")
+    unique_kws = list(set(keywords))
+    
+    for kw in unique_kws:
+        net.add_node(kw, label=kw)
+    
+    similarities = (X * X.T).A
+    np.fill_diagonal(similarities, 0)
+    
+    for i in range(len(unique_kws)):
+        for j in range(i+1, len(unique_kws)):
+            if similarities[i,j] > 0.2:
+                net.add_edge(unique_kws[i], unique_kws[j], value=similarities[i,j])
+    
+    return net
+
+def generate_citations(papers):
+    citations = []
+    for paper in papers:
+        entry = {
+            "title": paper.get("title", ""),
+            "authors": paper.get("authors", []),
+            "year": paper.get("year", ""),
+            "url": paper.get("pdf_url") or paper.get("url", "")
+        }
+        citations.append(entry)
+    return citations
+
+def generate_research_suggestions(context, tokenizer, model):
+    input_text = f"Based on this research context: {context}\nGenerate three research questions:"
+    inputs = tokenizer(input_text, return_tensors="pt")
+    outputs = model.generate(**inputs, max_length=200)
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+def main():
+    st.title("PaperPilot - Intelligent Academic Navigator")
+    
+    # Load models
+    tokenizer, summarizer, kw_model, suggestion_tokenizer, suggestion_model = load_models()
+    
+    # User input
+    query = st.text_input("Enter your research topic or question:")
+    
+    if query:
+        with st.spinner("Searching academic databases..."):
+            arxiv_results = fetch_arxiv_papers(query)
+            ss_results = fetch_semantic_scholar(query)
+            all_papers = arxiv_results + ss_results
+        
+        if not all_papers:
+            st.warning("No papers found. Try a different query.")
+            return
+            
+        # Display papers
+        st.subheader("Relevant Papers")
+        for idx, paper in enumerate(all_papers[:5]):
+            with st.expander(f"{paper['title']}"):
+                st.write(f"**Abstract:** {paper['abstract']}")
+                
+                # Generate summary
+                summary = generate_summary(paper['abstract'], tokenizer, summarizer)
+                st.write(f"**Summary:** {summary}")
+                
+                # Display metadata
+                st.write(f"**Authors:** {', '.join(paper.get('authors', []))}")
+                st.write(f"**Published:** {paper.get('published') or paper.get('year'))}")
+                st.write(f"**URL:** {paper.get('pdf_url') or paper.get('url'))}")
+        
+        # Concept Map
+        st.subheader("Research Concept Map")
+        texts = [p['abstract'] for p in all_papers]
+        net = generate_concept_map(texts, kw_model)
+        net.save_graph("concept_map.html")
+        HtmlFile = open("concept_map.html", 'r', encoding='utf-8')
+        components.html(HtmlFile.read(), height=500)
+        
+        # Citations
+        st.subheader("Citation Management")
+        citations = generate_citations(all_papers)
+        citation_format = st.selectbox("Select citation style:", ["APA", "MLA", "Chicago"])
+        
+        for cite in citations:
+            st.code(f"{cite['authors'][0]} et al. ({cite['year']}). {cite['title']}. URL: {cite['url']}")
+        
+        # Research Suggestions
+        st.subheader("Research Proposal Suggestions")
+        context = " ".join([p['abstract'] for p in all_papers[:3]])
+        suggestions = generate_research_suggestions(context, suggestion_tokenizer, suggestion_model)
+        st.write(suggestions)
+
+if __name__ == "__main__":
+    main()