Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-PaperSearchPro - STRICT Hierarchical Keyword Search
-PREMIUM GUI with Proper Dark/Light Text Contrast - FIXED
+PaperSearchPro - FULL Professional Version
+Hierarchical Keyword Search + Export + Responsive UI
 """
 
 import requests
@@ -8,535 +8,147 @@ import pandas as pd
 import time
 from datetime import datetime
 import gradio as gr
-import tempfile
 import os
 
-# Custom CSS with proper contrast - BLACK TEXT ON WHITE BACKGROUNDS
+# ============================================
+# CLEAN RESPONSIVE CSS
+# ============================================
+
 custom_css = """
 @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
 
 :root {
     --primary: #2563eb;
-    --primary-dark: #1d4ed8;
     --secondary: #7c3aed;
-    --success: #10b981;
-    --warning: #f59e0b;
-    --danger: #ef4444;
-    
-    /* Light theme - BLACK TEXT ON WHITE BACKGROUNDS */
-    --bg-page: #ffffff;
-    --bg-card: #ffffff;
-    --bg-input: #ffffff;
-    --bg-hover: #f3f4f6;
     --border: #e5e7eb;
-    
-    --text-primary: #000000;
-    --text-secondary: #1f2937;
-    --text-muted: #4b5563;
-    --text-inverse: #ffffff;
-    
-    --shadow: 0 1px 3px rgba(0,0,0,0.1);
-    --shadow-lg: 0 10px 15px -3px rgba(0,0,0,0.1);
-    
-    --radius: 0.5rem;
-}
-
-/* Base styles - WHITE BACKGROUND, BLACK TEXT */
-.gradio-container {
-    background-color: var(--bg-page) !important;
-    font-family: 'Inter', -apple-system, sans-serif !important;
-    color: #000000 !important;
+    --bg-soft: #f9fafb;
+    --text-main: #111827;
 }
 
-/* Force ALL text to be BLACK */
-body, p, h1, h2, h3, h4, h5, h6, span, div, label, .gr-markdown, 
-.gr-text, .gr-form-text, .gr-input-label, .gr-box-title,
-.gr-panel, .gr-group, .gr-block, .gr-form {
-    color: #000000 !important;
-    background-color: transparent !important;
+body, .gradio-container {
+    font-family: 'Inter', sans-serif !important;
+    background-color: #ffffff !important;
+    color: var(--text-main) !important;
 }
 
-/* Main container */
-.gradio-container-outer {
-    background-color: #ffffff !important;
+.gradio-container {
+    max-width: 1600px !important;
+    margin: auto !important;
 }
 
-/* Cards - WHITE BACKGROUND */
 .white-card {
-    background-color: #ffffff !important;
-    border-radius: var(--radius) !important;
-    padding: 1.5rem !important;
+    background: #ffffff !important;
     border: 1px solid var(--border) !important;
-    box-shadow: var(--shadow) !important;
-}
-
-/* Headers - BLACK */
-h1 {
-    font-size: 2.5rem !important;
-    font-weight: 700 !important;
-    color: #000000 !important;
-    background-color: transparent !important;
+    border-radius: 12px !important;
+    padding: 2rem !important;
 }
 
 h1 span {
     background: linear-gradient(135deg, var(--primary), var(--secondary));
     -webkit-background-clip: text;
     -webkit-text-fill-color: transparent;
-    background-color: transparent !important;
-}
-
-h3 {
-    font-size: 1.25rem !important;
-    font-weight: 600 !important;
-    color: #000000 !important;
-    margin-bottom: 1rem !important;
-    background-color: transparent !important;
 }
 
-/* Input fields - WHITE BACKGROUND, BLACK TEXT */
-input, textarea, select, .gr-input, .gr-textarea, .gr-dropdown {
-    background-color: #ffffff !important;
-    border: 1px solid var(--border) !important;
-    border-radius: var(--radius) !important;
-    padding: 0.625rem 0.875rem !important;
-    color: #000000 !important;
-    font-size: 0.95rem !important;
-    width: 100% !important;
-}
-
-input:focus, textarea:focus, select:focus {
-    border-color: var(--primary) !important;
-    outline: none !important;
-    box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.1) !important;
-}
-
-input::placeholder, textarea::placeholder {
-    color: #6b7280 !important;
-    opacity: 1 !important;
-}
-
-/* Labels - BLACK */
-label, .gr-label {
-    color: #000000 !important;
-    font-size: 0.875rem !important;
-    font-weight: 600 !important;
-    margin-bottom: 0.375rem !important;
-    display: block !important;
-    background-color: transparent !important;
-}
-
-/* Buttons */
-.gr-button-primary {
-    background: linear-gradient(135deg, var(--primary), var(--secondary)) !important;
-    border: none !important;
-    color: #ffffff !important;
-    font-weight: 600 !important;
-    padding: 0.75rem 1.5rem !important;
-    border-radius: var(--radius) !important;
-    cursor: pointer !important;
-    transition: all 0.2s !important;
-    font-size: 1rem !important;
-    width: 100% !important;
-}
-
-.gr-button-primary:hover {
-    transform: translateY(-2px);
-    box-shadow: var(--shadow-lg) !important;
-}
-
-.gr-button-secondary {
-    background-color: #ffffff !important;
-    border: 1px solid var(--border) !important;
-    color: #000000 !important;
-    font-weight: 500 !important;
-    padding: 0.75rem 1.5rem !important;
-    border-radius: var(--radius) !important;
-    cursor: pointer !important;
-    transition: all 0.2s !important;
-    width: 100% !important;
-}
-
-.gr-button-secondary:hover {
-    background-color: var(--bg-hover) !important;
-    border-color: #000000 !important;
-}
-
-/* Table/Dataframe - WHITE BACKGROUND, BLACK TEXT */
-.gr-dataframe {
-    background-color: #ffffff !important;
-    border: 1px solid var(--border) !important;
-    border-radius: var(--radius) !important;
-    overflow: hidden !important;
-}
-
-.gr-dataframe table {
-    width: 100% !important;
-    border-collapse: collapse !important;
-    background-color: #ffffff !important;
-}
-
-.gr-dataframe th {
-    background-color: #f9fafb !important;
-    color: #000000 !important;
-    font-weight: 600 !important;
-    font-size: 0.875rem !important;
-    padding: 0.875rem !important;
-    border-bottom: 2px solid var(--border) !important;
-    text-align: left !important;
-}
-
-.gr-dataframe td {
-    padding: 0.875rem !important;
-    border-bottom: 1px solid var(--border) !important;
-    color: #000000 !important;
-    font-size: 0.875rem !important;
-    background-color: #ffffff !important;
-}
-
-.gr-dataframe tr:last-child td {
-    border-bottom: none !important;
+.metric-value {
+    font-size: 2rem !important;
+    font-weight: 700 !important;
+    color: var(--primary) !important;
 }
+"""
 
-.gr-dataframe tr:hover td {
-    background-color: #f3f4f6 !important;
-}
+# ============================================
+# SEARCH ENGINE
+# ============================================
 
-/* Slider */
-.gr-slider {
-    background: linear-gradient(90deg, var(--primary), var(--secondary)) !important;
-    height: 6px !important;
-    border-radius: 3px !important;
-}
+class PaperSearchPro:
 
-.gr-slider-value {
-    color: #000000 !important;
-    font-weight: 600 !important;
-}
+    def __init__(self):
+        self.base_url = "https://api.openalex.org/works"
+        self.per_page = 200
 
-/* Checkbox */
-.gr-checkbox {
-    accent-color: var(--primary) !important;
-    width: 1.125rem !important;
-    height: 1.125rem !important;
-}
+    def search_papers(self, query, keywords, max_papers, year_from, year_to, open_access):
 
-.gr-checkbox-label {
-    color: #000000 !important;
-    margin-left: 0.5rem !important;
-}
+        filters = []
+        if year_from:
+            filters.append(f"publication_year:>{int(year_from)-1}")
+        if year_to:
+            filters.append(f"publication_year:<{int(year_to)+1}")
+        if open_access:
+            filters.append("open_access.is_oa:true")
 
-/* Metric cards - WHITE BACKGROUND, BLACK TEXT */
-.metric-card {
-    background-color: #ffffff !important;
-    border-radius: var(--radius) !important;
-    padding: 1rem !important;
-    border: 1px solid var(--border) !important;
-    text-align: center !important;
-}
+        filter_str = ",".join(filters) if filters else None
 
-.metric-value {
-    font-size: 2rem !important;
-    font-weight: 700 !important;
-    color: var(--primary) !important;
-    line-height: 1.2 !important;
-    margin: 0 !important;
-    background-color: transparent !important;
-}
+        all_papers = []
+        page = 1
 
-.metric-label {
-    font-size: 0.875rem !important;
-    color: #000000 !important;
-    margin-top: 0.25rem !important;
-    background-color: transparent !important;
-}
+        while len(all_papers) < max_papers:
+            params = {
+                "search": query,
+                "per-page": self.per_page,
+                "page": page
+            }
 
-/* Keyword badges */
-.keyword-badge {
-    display: inline-block;
-    padding: 0.375rem 1rem;
-    border-radius: 9999px;
-    font-size: 0.875rem;
-    font-weight: 600;
-    margin: 0.25rem;
-}
+            if filter_str:
+                params["filter"] = filter_str
 
-.keyword-required {
-    background-color: #fee2e2;
-    color: #b91c1c !important;
-    border: 1px solid #fecaca;
-}
+            response = requests.get(self.base_url, params=params, timeout=20)
+            data = response.json()
+            results = data.get("results", [])
 
-.keyword-optional {
-    background-color: #dcfce7;
-    color: #166534 !important;
-    border: 1px solid #bbf7d0;
-}
+            if not results:
+                break
 
-/* Info boxes - WHITE BACKGROUND */
-.info-box {
-    background-color: #eff6ff !important;
-    border-left: 4px solid var(--primary);
-    border-radius: var(--radius);
-    padding: 1rem;
-    margin: 1rem 0;
-}
+            for work in results:
+                paper = self.extract_info(work)
+                all_papers.append(paper)
 
-.info-box strong, .info-box p {
-    color: #000000 !important;
-}
+            page += 1
+            time.sleep(0.2)
 
-/* Status messages */
-.gr-status, .gr-message {
-    color: #000000 !important;
-    font-size: 0.875rem !important;
-    padding: 0.5rem !important;
-    background-color: #ffffff !important;
-}
+        # ===============================
+        # HIERARCHICAL KEYWORD FILTERING
+        # ===============================
 
-/* File download link */
-.gr-file {
-    background-color: #ffffff !important;
-    border: 1px solid var(--border) !important;
-    border-radius: var(--radius) !important;
-    padding: 0.5rem !important;
-}
+        keyword_list = [k.strip().lower() for k in keywords.split(",") if k.strip()]
 
-.gr-file a {
-    color: var(--primary) !important;
-    text-decoration: none !important;
-    font-weight: 500 !important;
-}
+        if len(keyword_list) >= 2:
+            filtered = []
 
-.gr-file a:hover {
-    text-decoration: underline !important;
-}
+            for p in all_papers:
+                combined = f"{p['Title']} {p['Abstract']} {p['Authors']}".lower()
 
-/* Number inputs */
-.gr-number {
-    background-color: #ffffff !important;
-    border: 1px solid var(--border) !important;
-    border-radius: var(--radius) !important;
-    padding: 0.5rem !important;
-    color: #000000 !important;
-}
+                # first 2 keywords REQUIRED
+                if keyword_list[0] not in combined or keyword_list[1] not in combined:
+                    continue
 
-/* Row and column layouts */
-.gr-row, .gr-column {
-    background-color: transparent !important;
-}
+                score = 2
+                matched = [keyword_list[0], keyword_list[1]]
 
-/* Tabs */
-.gr-tabs {
-    background-color: #ffffff !important;
-}
+                for kw in keyword_list[2:]:
+                    if kw in combined:
+                        score += 1
+                        matched.append(kw)
 
-.gr-tabs .gr-tab-nav {
-    background-color: #f9fafb !important;
-    border-bottom: 1px solid var(--border) !important;
-}
+                p["Relevance"] = score
+                p["Matched Keywords"] = ", ".join(matched)
 
-.gr-tabs .gr-tab-nav button {
-    color: #000000 !important;
-    background-color: transparent !important;
-}
+                filtered.append(p)
 
-.gr-tabs .gr-tab-nav button.selected {
-    color: var(--primary) !important;
-    border-bottom: 2px solid var(--primary) !important;
-}
+            filtered.sort(key=lambda x: x["Relevance"], reverse=True)
+            all_papers = filtered[:max_papers]
 
-/* Dropdown options */
-.gr-dropdown-options {
-    background-color: #ffffff !important;
-    border: 1px solid var(--border) !important;
-}
+        total = len(all_papers)
+        avg_rel = sum(p.get("Relevance", 0) for p in all_papers) / total if total else 0
+        years = [p["Year"] for p in all_papers if p["Year"] != "N/A"]
+        year_range = f"{min(years)} - {max(years)}" if years else "N/A"
 
-.gr-dropdown-options .gr-dropdown-option {
-    color: #000000 !important;
-}
+        df = pd.DataFrame(all_papers)
 
-.gr-dropdown-options .gr-dropdown-option:hover {
-    background-color: #f3f4f6 !important;
-}
+        return df, all_papers, total, avg_rel, year_range
 
-/* Responsive */
-@media (max-width: 768px) {
-    .white-card {
-        padding: 1rem !important;
-    }
-    
-    h1 {
-        font-size: 2rem !important;
-    }
-    
-    .metric-value {
-        font-size: 1.5rem !important;
-    }
-}
-"""
+    def extract_info(self, work):
 
-class PaperSearchMobile:
-    def __init__(self):
-        self.base_url = "https://api.openalex.org/works"
-        self.per_page = 200
-        
-    def search_papers(self, query, keywords, sort_by, sort_order, max_papers, 
-                     year_from, year_to, open_access):
-        
-        # Prepare sort parameter
-        sort_order_param = 'asc' if sort_order == "ascending" else 'desc'
-        sort_field_map = {
-            "citations": "cited_by_count",
-            "year": "publication_year",
-            "date": "publication_date",
-            "title": "title",
-            "relevance": "relevance_score"
-        }
-        api_sort_field = sort_field_map.get(sort_by, "cited_by_count")
-        sort_param = f"{api_sort_field}:{sort_order_param}"
-        
-        # Prepare filters
-        filters = []
-        if year_from and year_from > 0:
-            filters.append(f"publication_year:>{year_from-1}")
-        if year_to and year_to > 0:
-            filters.append(f"publication_year:<{year_to+1}")
-        if open_access:
-            filters.append("open_access.is_oa:true")
-        
-        filter_str = ",".join(filters) if filters else None
-        
-        all_papers = []
-        page = 1
-        max_attempts = 50
-        
-        # Fetch papers
-        while len(all_papers) < max_papers and page <= max_attempts:
-            params = {
-                'search': query,
-                'per-page': self.per_page,
-                'page': page,
-                'sort': sort_param
-            }
-            
-            if filter_str:
-                params['filter'] = filter_str
-            
-            try:
-                response = requests.get(self.base_url, params=params, timeout=15)
-                data = response.json()
-                results = data.get("results", [])
-                
-                if not results:
-                    break
-                
-                for work in results:
-                    paper = self._extract_paper_info(work)
-                    all_papers.append(paper)
-                
-                page += 1
-                time.sleep(0.3)
-                
-            except Exception as e:
-                break
-        
-        # Strict hierarchical filtering
-        keyword_list = []
-        if keywords and keywords.strip():
-            keyword_list = [k.strip().lower() for k in keywords.split(',') if k.strip()]
-            
-            if len(keyword_list) >= 2:
-                scored_papers = []
-                for paper in all_papers:
-                    title_text = paper['Title'].lower()
-                    abstract_text = paper.get('Abstract', '').lower()
-                    authors_text = paper['Authors'].lower()
-                    
-                    combined_text = f"{title_text} {abstract_text} {authors_text}"
-                    
-                    # Check if BOTH keywords are present
-                    kw1_present = keyword_list[0] in combined_text
-                    kw2_present = keyword_list[1] in combined_text
-                    
-                    if not (kw1_present and kw2_present):
-                        continue
-                    
-                    # Check abstract
-                    if (keyword_list[0] in abstract_text) or (keyword_list[1] in abstract_text):
-                        paper['abstract_match'] = "Yes"
-                    else:
-                        paper['abstract_match'] = "No"
-                    
-                    # Calculate score
-                    score = 2
-                    matched = [keyword_list[0], keyword_list[1]]
-                    
-                    for idx, kw in enumerate(keyword_list[2:], start=3):
-                        if kw in combined_text:
-                            score += (len(keyword_list) - idx + 1)
-                            matched.append(kw)
-                    
-                    if paper['abstract_match'] == "Yes":
-                        score += 1
-                    
-                    paper['Abstract_Short'] = paper['Abstract'][:200] + "..." if len(paper['Abstract']) > 200 else paper['Abstract']
-                    paper['score'] = score
-                    paper['matched'] = ', '.join(matched)
-                    paper['required_matched'] = f"✓ {keyword_list[0]}, ✓ {keyword_list[1]}"
-                    
-                    scored_papers.append(paper)
-                
-                scored_papers.sort(key=lambda x: x['score'], reverse=True)
-                all_papers = scored_papers[:max_papers]
-        
-        # Prepare display
-        if all_papers:
-            for i, p in enumerate(all_papers):
-                p['Rank'] = i + 1
-            
-            df = pd.DataFrame(all_papers)
-            display_cols = ["Rank", "score", "Title", "Authors", "Year", "Citations", "Journal", "abstract_match", "Abstract_Short"]
-            display_df = df[display_cols]
-            
-            rename_dict = {
-                "score": "Relevance",
-                "abstract_match": "In Abstract",
-                "Abstract_Short": "Abstract Preview"
-            }
-            display_df = display_df.rename(columns=rename_dict)
-            
-            years_list = [p['Year'] for p in all_papers if p['Year'] != 'N/A']
-            
-            # Extract metrics for display
-            total_papers = len(all_papers)
-            if years_list:
-                year_min = min(years_list)
-                year_max = max(years_list)
-                year_range_text = f"{year_min} - {year_max}"
-            else:
-                year_range_text = "N/A"
-            
-            if total_papers > 0:
-                avg_relevance = sum(p.get('score', 0) for p in all_papers) / total_papers
-            else:
-                avg_relevance = 0
-            
-            return display_df, all_papers, total_papers, avg_relevance, year_range_text
-        
-        return pd.DataFrame(), [], 0, 0, "N/A"
-    
-    def _extract_paper_info(self, work):
-        def get_authors(authorships):
-            if not authorships:
-                return "Unknown"
-            authors = []
-            for a in authorships[:3]:
-                name = a.get("author", {}).get("display_name", "")
-                if name:
-                    authors.append(name)
-            return ", ".join(authors) + ("..." if len(authorships) > 3 else "")
-        
-        # Get FULL abstract
+        # Rebuild abstract
         abstract = ""
         if work.get("abstract_inverted_index"):
             words = []
@@ -547,289 +159,136 @@ class PaperSearchMobile:
             abstract = " ".join([w[1] for w in words])
         else:
             abstract = "No abstract available"
-        
+
+        authors = ", ".join(
+            a.get("author", {}).get("display_name", "")
+            for a in work.get("authorships", [])[:3]
+        )
+
         return {
             "Title": work.get("title", "No title"),
-            "Authors": get_authors(work.get("authorships", [])),
+            "Authors": authors,
             "Year": work.get("publication_year", "N/A"),
             "Citations": work.get("cited_by_count", 0),
             "Journal": (work.get("primary_location", {}).get("source") or {}).get("display_name", "Unknown"),
-            "DOI": work.get("doi", "N/A"),
-            "URL": work.get("id", "N/A"),
             "Abstract": abstract,
-            "matched": ""
+            "Relevance": 0,
+            "Matched Keywords": ""
         }
 
-def download_results(papers, fname, fmt):
-    if not papers:
-        return None, "No papers to export"
-    
-    df = pd.DataFrame(papers)
-    column_order = ['Rank', 'score', 'Title', 'Authors', 'Year', 'Citations', 'Journal', 
-                   'DOI', 'URL', 'Abstract', 'matched', 'required_matched', 'abstract_match']
-    
-    available_cols = [col for col in column_order if col in df.columns]
-    df = df[available_cols]
-    
-    df = df.rename(columns={
-        'score': 'Relevance_Score',
-        'matched': 'All_Keywords_Found',
-        'required_matched': 'Required_Keywords',
-        'abstract_match': 'Keywords_In_Abstract'
-    })
-    
-    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    
-    with tempfile.NamedTemporaryFile(mode='w', suffix=f'.{fmt.lower()}', delete=False) as tmp:
-        if fmt == "TXT":
-            filename = f"{fname}_with_abstracts_{timestamp}.txt"
-            with open(tmp.name, 'w', encoding='utf-8') as f:
-                # Write header
-                f.write("="*100 + "\n")
-                f.write(f"PAPER SEARCH RESULTS - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-                f.write("="*100 + "\n\n")
-                
-                # Write summary
-                f.write("SUMMARY\n")
-                f.write("-"*50 + "\n")
-                f.write(f"Total Papers: {len(papers)}\n")
-                f.write(f"Export Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-                f.write(f"Format: {fmt}\n\n")
-                
-                # Write each paper
-                for idx, paper in enumerate(papers, 1):
-                    f.write(f"\n{'='*100}\n")
-                    f.write(f"PAPER #{idx}\n")
-                    f.write(f"{'='*100}\n")
-                    
-                    for col in available_cols:
-                        display_name = col.replace('_', ' ').title()
-                        value = paper.get(col, 'N/A')
-                        f.write(f"{display_name}: {value}\n")
-                    
-                    f.write("\n")
-            
-        elif fmt == "CSV":
-            filename = f"{fname}_with_abstracts_{timestamp}.csv"
-            df.to_csv(tmp.name, index=False, encoding='utf-8')
-        else:  # Excel
-            filename = f"{fname}_with_abstracts_{timestamp}.xlsx"
-            with pd.ExcelWriter(tmp.name, engine='openpyxl') as writer:
-                df.to_excel(writer, sheet_name='Results', index=False)
-                
-                summary_data = {
-                    'Metric': ['Total Papers', 'Date Exported', 'Export Format'],
-                    'Value': [len(papers), datetime.now().strftime('%Y-%m-%d %H:%M:%S'), fmt]
-                }
-                pd.DataFrame(summary_data).to_excel(writer, sheet_name='Summary', index=False)
-    
-    return tmp.name, f"✅ Ready to download: {filename}"
 
 # ============================================
-# PREMIUM GRADIO INTERFACE
+# INTERFACE
 # ============================================
+
 def create_interface():
-    with gr.Blocks(title="PaperSearchPro", theme=gr.themes.Soft(), css=custom_css) as demo:
-        # Header
+
+    with gr.Blocks(title="PaperSearchPro", css=custom_css) as demo:
+
         gr.HTML("""
-        <div style='text-align: center; padding: 2rem 0; background-color: white;'>
+        <div style='text-align:center; padding:2rem 0'>
             <h1><span>📱 PaperSearchPro</span></h1>
-            <p style='color: #000000; font-size: 1.1rem; background-color: transparent;'>Academic Paper Search with Hierarchical Keywords</p>
+            <p>Professional Academic Paper Search</p>
         </div>
         """)
-        
-        # Main content
+
         with gr.Column(elem_classes="white-card"):
-            # Search section
-            with gr.Row():
-                with gr.Column(scale=2):
-                    query = gr.Textbox(
-                        label="🔍 Search Topic",
-                        placeholder="Enter your research topic...",
-                        value="photoacoustic imaging",
-                        elem_classes="gr-input"
-                    )
-                
-                with gr.Column(scale=1):
-                    max_papers = gr.Slider(
-                        label="📊 Max Papers",
-                        minimum=100,
-                        maximum=10000,
-                        value=2000,
-                        step=100,
-                        elem_classes="gr-slider"
-                    )
-            
-            # Keywords section
-            gr.HTML("""
-            <div style='margin: 1.5rem 0; background-color: transparent;'>
-                <h3 style='color: #000000; margin-bottom: 0.75rem; background-color: transparent;'>🔑 Keyword Hierarchy</h3>
-                <div>
-                    <span class='keyword-badge keyword-required'>Keyword 1: REQUIRED</span>
-                    <span class='keyword-badge keyword-required'>Keyword 2: REQUIRED</span>
-                    <span class='keyword-badge keyword-optional'>Keyword 3+: Optional</span>
-                </div>
-            </div>
-            """)
-            
+
+            query = gr.Textbox(label="Search Topic", value="photoacoustic imaging")
+
             keywords = gr.Textbox(
-                label="Enter keywords (comma-separated)",
-                placeholder="blood, photoacoustics, imaging, cancer",
-                value="blood, photoacoustics, imaging",
-                elem_classes="gr-input"
+                label="Keywords (first 2 REQUIRED)",
+                value="blood, photoacoustics, imaging"
             )
-            
-            # Filters
-            with gr.Row():
-                with gr.Column():
-                    sort_by = gr.Dropdown(
-                        label="Sort By",
-                        choices=["relevance", "citations", "year"],
-                        value="relevance",
-                        elem_classes="gr-dropdown"
-                    )
-                
-                with gr.Column():
-                    sort_order = gr.Dropdown(
-                        label="Order",
-                        choices=["descending", "ascending"],
-                        value="descending",
-                        elem_classes="gr-dropdown"
-                    )
-                
-                with gr.Column():
-                    open_access = gr.Checkbox(
-                        label="Open Access Only",
-                        value=False,
-                        elem_classes="gr-checkbox"
-                    )
-            
-            # Year range
+
+            max_papers = gr.Slider(100, 5000, value=1000, step=100, label="Max Papers")
+
             with gr.Row():
-                with gr.Column():
-                    year_from = gr.Number(
-                        label="Year From",
-                        value=2000,
-                        minimum=1900,
-                        maximum=2026,
-                        elem_classes="gr-number"
-                    )
-                
-                with gr.Column():
-                    year_to = gr.Number(
-                        label="Year To",
-                        value=2026,
-                        minimum=1900,
-                        maximum=2026,
-                        elem_classes="gr-number"
-                    )
-            
-            # Search button
-            search_btn = gr.Button(
-                "🔍 SEARCH PAPERS",
-                variant="primary",
-                size="lg",
-                elem_classes="gr-button-primary"
-            )
-            
-            # Metrics - now as display elements
+                year_from = gr.Number(value=2000, label="Year From")
+                year_to = gr.Number(value=2026, label="Year To")
+                open_access = gr.Checkbox(label="Open Access Only")
+
+            search_btn = gr.Button("🔍 SEARCH PAPERS", variant="primary")
+
             with gr.Row():
-                with gr.Column():
-                    total_papers_display = gr.Markdown("**0**", elem_classes="metric-value")
-                    gr.Markdown("Total Papers", elem_classes="metric-label")
-                
-                with gr.Column():
-                    avg_relevance_display = gr.Markdown("**0.0**", elem_classes="metric-value")
-                    gr.Markdown("Avg Relevance", elem_classes="metric-label")
-                
-                with gr.Column():
-                    year_range_display = gr.Markdown("**N/A**", elem_classes="metric-value")
-                    gr.Markdown("Year Range", elem_classes="metric-label")
-            
-            # Results
-            results = gr.Dataframe(
-                label="📄 Results",
-                wrap=True,
-                row_count=15,
-                elem_classes="gr-dataframe"
-            )
-            papers_state = gr.State([])
-            
-            # Export section
+                total_display = gr.Markdown("**0**", elem_classes="metric-value")
+                avg_display = gr.Markdown("**0.0**", elem_classes="metric-value")
+                year_display = gr.Markdown("**N/A**", elem_classes="metric-value")
+
+            results = gr.Dataframe(row_count=15)
+            state = gr.State([])
+
+            # ==========================
+            # EXPORT SECTION
+            # ==========================
+
+            gr.Markdown("### 📥 Export Results")
+
             with gr.Row():
-                with gr.Column(scale=2):
-                    filename = gr.Textbox(
-                        label="Filename",
-                        value="papers_results",
-                        placeholder="Enter filename",
-                        elem_classes="gr-input"
-                    )
-                
-                with gr.Column(scale=1):
-                    format_type = gr.Dropdown(
-                        label="Format",
-                        choices=["TXT", "CSV", "Excel"],
-                        value="TXT",
-                        elem_classes="gr-dropdown"
-                    )
-            
-            export_btn = gr.Button(
-                "📥 DOWNLOAD WITH ABSTRACTS",
-                variant="secondary",
-                elem_classes="gr-button-secondary"
-            )
-            export_status = gr.Textbox(label="", visible=True)
-            download_file = gr.File(label="Download Link", visible=False)
-            
-            # Info box
-            gr.HTML("""
-            <div class='info-box'>
-                <strong>📌 Note:</strong> Downloaded files include FULL abstracts. 
-                <strong>TXT</strong> format includes formatted text with summaries.
-                <strong>CSV</strong> format is comma-separated values.
-                <strong>Excel</strong> format includes a Summary sheet with metadata.
-            </div>
-            """)
-        
-        # Initialize searcher
-        searcher = PaperSearchMobile()
-        
-        # Search function
-        def search_wrapper(query, keywords, sort_by, sort_order, max_papers, year_from, year_to, open_access):
-            df, papers, total, avg, year_range = searcher.search_papers(
-                query, keywords, sort_by, sort_order, max_papers, year_from, year_to, open_access
-            )
-            
-            total_md = f"**{total}**"
-            avg_md = f"**{avg:.1f}**"
-            year_md = f"**{year_range}**"
-            
-            return df, papers, total_md, avg_md, year_md
-        
+                filename = gr.Textbox(label="Filename", value="papers_results")
+                format_type = gr.Dropdown(
+                    label="Format",
+                    choices=["TXT", "CSV", "Excel"],
+                    value="TXT"
+                )
+
+            export_btn = gr.Button("Download Results", variant="secondary")
+
+            export_status = gr.Markdown("")
+            download_file = gr.File(visible=False)
+
+        searcher = PaperSearchPro()
+
+        def search_wrapper(q, k, m, yf, yt, oa):
+            df, papers, total, avg, yr = searcher.search_papers(q, k, m, yf, yt, oa)
+            return df, papers, f"**{total}**", f"**{avg:.2f}**", f"**{yr}**"
+
         search_btn.click(
             search_wrapper,
-            inputs=[query, keywords, sort_by, sort_order, max_papers, year_from, year_to, open_access],
-            outputs=[results, papers_state, total_papers_display, avg_relevance_display, year_range_display]
+            inputs=[query, keywords, max_papers, year_from, year_to, open_access],
+            outputs=[results, state, total_display, avg_display, year_display]
         )
-        
-        # Export function
-        def export_wrapper(papers, fname, fmt):
+
+        def export_results(papers, fname, fmt):
+
             if not papers:
                 return None, "No papers to export", gr.File(visible=False)
-            file_path, message = download_results(papers, fname, fmt)
-            return file_path, message, gr.File(visible=True)
-        
+
+            df = pd.DataFrame(papers)
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+            if fmt == "CSV":
+                path = f"{fname}_{timestamp}.csv"
+                df.to_csv(path, index=False)
+
+            elif fmt == "Excel":
+                path = f"{fname}_{timestamp}.xlsx"
+                df.to_excel(path, index=False)
+
+            else:
+                path = f"{fname}_{timestamp}.txt"
+                with open(path, "w", encoding="utf-8") as f:
+                    for i, row in df.iterrows():
+                        f.write("="*80 + "\n")
+                        for col in df.columns:
+                            f.write(f"{col}: {row[col]}\n")
+                        f.write("\n")
+
+            return path, f"✅ File ready: {path}", gr.File(visible=True)
+
         export_btn.click(
-            export_wrapper,
-            inputs=[papers_state, filename, format_type],
+            export_results,
+            inputs=[state, filename, format_type],
             outputs=[download_file, export_status, download_file]
         )
-    
+
     return demo
 
+
 # ============================================
-# MAIN ENTRY POINT
+# MAIN
 # ============================================
+
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(share=False)
+    demo.launch(inbrowser=True, height=1000)