{saved_content}
"""
def generate_editor_html():
saved_content = read_saved_homepage()
return f"""{saved_content}
⚠️ Please enter a valid search topic.
"
all_results = []
source_logs = []
source_map = {
'PubMed': lambda: _fetch_pubmed(topic, since_date),
'Europe PMC': lambda: _fetch_europe_pmc(topic, since_date_dash),
'CrossRef': lambda: _fetch_crossref(topic, since_date_dash),
'Semantic Scholar': lambda: _fetch_semantic_scholar(topic, since_date_dash),
'bioRxiv / medRxiv': lambda: _fetch_biorxiv(topic, since_date_dash),
}
for src_name, fetch_fn in source_map.items():
if src_name not in selected_sources:
continue
try:
res, log = fetch_fn()
all_results.extend(res)
source_logs.append(log)
except Exception as e:
source_logs.append(f"{src_name}: unexpected error – {str(e)}")
if not all_results:
log_html = ' | '.join(source_logs)
return f"""
🔍 No papers found for "{topic}"
{window_label}.
{log_html}
"""
unique_results = _deduplicate(all_results)
sorted_results = _sort_results(unique_results)
# ── Count by source ──
source_counts = {}
for r in sorted_results:
src = r.get('source', 'Unknown')
source_counts[src] = source_counts.get(src, 0) + 1
badge_row = ' '.join(
f''
f'{src}: {cnt}'
for src, cnt in source_counts.items()
)
log_html = ' | '.join(source_logs)
html = f"""
{log_html}
✅ {len(sorted_results)} unique publications retrieved ({window_label} · deduplicated)
{badge_row}
{log_html}
{title_html}
"""
html += "
{src_badge}
{_reviewed_badge() if is_reviewed else ''}
Authors: {authors}
{'•' + journal + '' if journal else ''}
📅 {date}
{doi_link}
{mark_btn}
No results on this page.
")
html = ""
for r in items:
src_badge = _render_source_badge(r['source'], r['source_color'], r['source_bg'])
title = r.get('title', 'Untitled')
url = r.get('url', '')
authors = r.get('authors', 'Unknown Authors')
journal = r.get('journal', '')
date = r.get('date', 'N/A')
doi = r.get('doi', '').strip()
article_id = doi.lower() if doi else r.get('url', '').lower()
is_reviewed = bool(article_id and article_id in reviewed_dois)
mark_btn = _mark_btn_html(article_id, is_reviewed, 'ls') if is_admin else ''
doi_link = (
f'DOI: {doi}'
if doi else ''
)
title_html = (
f'{title}'
if url else
f'{title}'
)
html += f"""
{title_html}
"""
return html
def _ls_render_nav(state):
"""Render the pagination bar HTML."""
page = state['page']
pool = state['pool']
exhausted = state['exhausted']
sources = state['sources']
total_pool = len(pool)
max_known_page = max(1, (total_pool + LS_PAGE_SIZE - 1) // LS_PAGE_SIZE)
all_exhausted = all(s in exhausted for s in sources) if sources else True
has_more = not all_exhausted
# Pages to display: always show up to 10, then "..."
pages_to_show = list(range(1, min(max_known_page, 10) + 1))
show_ellipsis = (max_known_page > 10) or has_more
btns = ""
for p in pages_to_show:
if p == page:
btns += (f'{p}')
else:
btns += (f'{p}')
if show_ellipsis:
btns += ('…')
src_counts = {}
for r in pool:
s = r.get('source', '')
src_counts[s] = src_counts.get(s, 0) + 1
badges = ' '.join(
f'{s}: {c}'
for s, c in src_counts.items()
)
status_line = (
f'
{src_badge}
{_reviewed_badge() if is_reviewed else ''}
Authors: {authors}
{'•' + journal + '' if journal else ''}
📅 {date}
{doi_link}
{mark_btn}
'
f'Page {page} · {total_pool} results loaded'
+ (' · fetching more…' if has_more else ' · all sources loaded')
+ f'
'
)
return f"""
{status_line}
"""
def _ls_empty_state():
return {
'topic': '', 'sources': [], 'start_year': LS_YEAR_MIN, 'end_year': LS_YEAR_MAX,
'page': 1, 'pool': [], 'offsets': {}, 'exhausted': [],
'seen_dois': [], 'seen_titles': [], 'is_admin': False,
}
def ls_init_search(topic, sources, start_year, end_year, is_admin=False):
"""Kick off a new search; returns (results_html, nav_html, new_state)."""
start_year = int(start_year) if start_year else LS_YEAR_MIN
end_year = int(end_year) if end_year else LS_YEAR_MAX
if not topic or not topic.strip():
err = ("
{btns}
{badges}
"
"⚠️ Please enter a valid search topic.
")
return err, "", _ls_empty_state()
state = {
'topic': topic.strip(), 'sources': list(sources),
'start_year': start_year, 'end_year': end_year,
'page': 1, 'pool': [], 'offsets': {}, 'exhausted': [],
'seen_dois': [], 'seen_titles': [], 'is_admin': bool(is_admin),
}
# Fetch first two batches to ensure a full first page even with heavy deduplication
_ls_fetch_batch(state)
if len(state['pool']) < LS_PAGE_SIZE:
_ls_fetch_batch(state)
if not state['pool']:
empty_html = (
""
"🔍 No papers found for “"
+ topic +
"” in the selected year range across chosen databases.
"
)
return empty_html, "", state
reviewed_dois = load_reviewed_dois()
return _ls_render_page(state, reviewed_dois), _ls_render_nav(state), state
def ls_prev_page(state):
"""Navigate to the previous page."""
reviewed_dois = load_reviewed_dois()
if not state or state['page'] <= 1:
return _ls_render_page(state, reviewed_dois), _ls_render_nav(state), state
state = {**state, 'page': state['page'] - 1}
return _ls_render_page(state, reviewed_dois), _ls_render_nav(state), state
def ls_next_page(state):
"""Navigate to next page, fetching more results from APIs if needed."""
if not state:
return "", "", state
state = dict(state)
next_page = state['page'] + 1
needed = next_page * LS_PAGE_SIZE
# Keep fetching until we have enough or all sources are exhausted
max_batches = 6 # safety limit per click
batches_done = 0
all_exhausted = lambda: all(s in state['exhausted'] for s in state['sources'])
while len(state['pool']) < needed and not all_exhausted() and batches_done < max_batches:
_ls_fetch_batch(state)
batches_done += 1
# Advance only if results exist for next page
if len(state['pool']) >= (next_page - 1) * LS_PAGE_SIZE + 1:
state['page'] = next_page
reviewed_dois = load_reviewed_dois()
return _ls_render_page(state, reviewed_dois), _ls_render_nav(state), state
# ── Database functions ────────────────────────────────────────────────────────
def search_supabase(species, tissue, tool, accession=""):
if not supabase:
return pd.DataFrame({"Error": ["Supabase keys are missing."]})
try:
table_name = "sra_database" if tool == "SRA" else "geo_database"
response = supabase.table(table_name).select("*").execute()
raw_data = response.data
if not raw_data:
return pd.DataFrame({"Status": [f"No records found in {table_name}."]})
df = pd.DataFrame(raw_data)
if 'created_at' in df.columns:
df = df.drop(columns=['created_at'])
if accession and accession.strip():
if "Accession" in df.columns:
df = df[df["Accession"].astype(str).str.lower().str.strip() == accession.lower().strip()]
if df.empty:
return pd.DataFrame({"Status": [f"No matching record for Accession '{accession}'."]})
else:
if "Organism" in df.columns:
df = df[df["Organism"].apply(normalize_organism) == normalize_organism(species)]
if "tissue" in df.columns:
df = df[df["tissue"].astype(str).str.lower().str.strip() == tissue.lower().strip()]
if df.empty:
return pd.DataFrame({"Status": [f"No records for '{species}' in {tool}."]})
display_cols = [c for c in ALL_UNIQUE_COLUMNS if c in df.columns]
return df[display_cols].fillna("N/A")
except Exception as e:
return pd.DataFrame({"Database Error": [str(e)]})
def load_entire_table():
if not supabase:
return pd.DataFrame({"Error": ["Supabase connection is inactive."]})
try:
sra_res = supabase.table("sra_database").select("*").execute()
df_sra = pd.DataFrame(sra_res.data) if sra_res.data else pd.DataFrame()
if 'created_at' in df_sra.columns:
df_sra = df_sra.drop(columns=['created_at'])
geo_res = supabase.table("geo_database").select("*").execute()
df_geo = pd.DataFrame(geo_res.data) if geo_res.data else pd.DataFrame()
if 'created_at' in df_geo.columns:
df_geo = df_geo.drop(columns=['created_at'])
if df_sra.empty and df_geo.empty:
return pd.DataFrame(columns=ALL_UNIQUE_COLUMNS)
combined_df = pd.concat([df_sra, df_geo], ignore_index=True)
ordered_cols = [c for c in ALL_UNIQUE_COLUMNS if c in combined_df.columns]
return combined_df[ordered_cols].fillna("N/A")
except Exception as e:
return pd.DataFrame({"Error": [str(e)]})
def generate_tools_launchpad_html(dataset_type="GEO"):
tools = SRA_TOOLS_DATA if dataset_type == "SRA" else GEO_TOOLS_DATA
icon = "🧬" if dataset_type == "SRA" else "🌐"
label = "SRA Download & QC" if dataset_type == "SRA" else "GEO Analytical"
accent = "#0891b2" if dataset_type == "SRA" else "#2563eb"
html = f"""{icon} Biological Data Located. Launch a {label} Suite below:
"""
for tool in tools:
html += f"""
Go to Tool
"""
html += "
{tool['Name']}
{tool['Type']}
{tool['Feature']}
{tools_launchpad}
")
def check_upload_credentials_generator(username, password):
global _admin_active
if not AUTH_USER or not AUTH_PASS:
_admin_active = False
yield (gr.Column(visible=True), gr.Column(visible=False), "Configuration Error: Secrets missing.", BLANK_TEMPLATE_DF, gr.Column(visible=True), gr.Column(visible=False), gr.HTML(value=generate_editor_html()), False, gr.Column(visible=False), gr.Column(visible=False))
return
if username == AUTH_USER and password == AUTH_PASS:
_admin_active = True
yield (gr.Column(visible=False), gr.Column(visible=True), "Authenticated. Loading data...", BLANK_TEMPLATE_DF, gr.Column(visible=False), gr.Column(visible=True), gr.HTML(value=generate_editor_html()), True, gr.Column(visible=True), gr.Column(visible=True))
entire_table_df = load_entire_table()
yield (gr.Column(visible=False), gr.Column(visible=True), "Admin Dashboard Ready.", entire_table_df, gr.Column(visible=False), gr.Column(visible=True), gr.HTML(value=generate_editor_html()), True, gr.Column(visible=True), gr.Column(visible=True))
else:
_admin_active = False
yield (gr.Column(visible=True), gr.Column(visible=False), "Invalid credentials. Access denied.", BLANK_TEMPLATE_DF, gr.Column(visible=True), gr.Column(visible=False), gr.HTML(value=generate_view_html()), False, gr.Column(visible=False), gr.Column(visible=False))
def upload_data_to_supabase(file_obj, species, tissue, dataset_type):
if not supabase:
return "Configuration Error: Supabase connection is inactive."
if file_obj is None:
return "Please upload a valid CSV or Excel file first."
try:
if file_obj.name.endswith('.csv'):
uploaded_df = pd.read_csv(file_obj.name)
elif file_obj.name.endswith(('.xls', '.xlsx')):
uploaded_df = pd.read_excel(file_obj.name)
else:
return "Unsupported format. Please upload a .csv or .xlsx file."
uploaded_df.columns = [c.strip() for c in uploaded_df.columns]
table_name = "sra_database" if dataset_type == "SRA" else "geo_database"
for target_col in EXACT_MATCH_COLUMNS:
if target_col not in uploaded_df.columns:
uploaded_df[target_col] = None
db_ready_df = uploaded_df[EXACT_MATCH_COLUMNS].copy().dropna(subset=["Accession"])
canonical_organism = "Bos taurus" if normalize_organism(species) == "bos taurus" else species.strip()
db_ready_df["Organism"] = canonical_organism
db_ready_df["tissue"] = tissue.strip()
db_ready_df["dataset"] = dataset_type.strip()
db_ready_df = sanitize_dataframe(db_ready_df)
new_records = db_ready_df.to_dict(orient="records")
if not new_records:
return "No rows with valid Accession numbers found."
db_response = supabase.table(table_name).select("Accession,Organism,tissue").execute()
existing = db_response.data if db_response.data else []
exact_keys = set()
accession_only = {}
for r in existing:
acc = normalize_val(r.get("Accession"))
org = normalize_organism(r.get("Organism", ""))
tis = normalize_val(r.get("tissue", ""))
exact_keys.add((acc, org, tis))
if acc not in accession_only:
accession_only[acc] = []
accession_only[acc].append((r.get("Organism", ""), r.get("tissue", "")))
incoming_org_norm = normalize_organism(canonical_organism)
incoming_tis_norm = normalize_val(tissue)
true_dupes = []
cross_category_warnings = []
final_records = []
for r in new_records:
acc = normalize_val(r.get("Accession"))
key = (acc, incoming_org_norm, incoming_tis_norm)
if key in exact_keys:
true_dupes.append(acc)
else:
if acc in accession_only:
for (ex_org, ex_tis) in accession_only[acc]:
cross_category_warnings.append(
f" • {acc} already exists as Organism='{ex_org}', Tissue='{ex_tis}'"
)
final_records.append(r)
msg_parts = []
if cross_category_warnings:
warn_lines = "\n".join(cross_category_warnings)
msg_parts.append(
f"⚠️ Warning — are you sure you inputted the right parameters?\n"
f"The following accessions already exist in a different category:\n{warn_lines}"
)
if true_dupes:
msg_parts.append(f"Skipped {len(true_dupes)} exact duplicate(s) (same accession + organism + tissue).")
if not final_records:
msg_parts.append("No new records to insert after duplicate check.")
return "\n".join(msg_parts)
supabase.table(table_name).insert(final_records).execute()
msg_parts.append(f"✅ Inserted {len(final_records)} record(s) into {table_name}.")
return "\n".join(msg_parts)
except Exception as e:
return f"Upload failed: {str(e)}"
def handle_row_selection(evt: gr.SelectData, current_df):
try:
row_idx = evt.index[0]
if "Accession" in current_df.columns:
accession_id = str(current_df.iloc[row_idx].get("Accession", "")).strip()
if accession_id and accession_id != "N/A":
return accession_id, f"Selected: {accession_id}"
return "", "Selected row has no valid Accession ID."
except Exception as e:
return "", f"Selection error: {str(e)}"
def delete_record_from_supabase(accession_id, current_df):
if not supabase or not accession_id.strip() or accession_id == "N/A":
return "No valid record selected.", current_df, accession_id
try:
response = supabase.table("sra_database").delete().eq("Accession", accession_id.strip()).execute()
if not response.data:
response = supabase.table("geo_database").delete().eq("Accession", accession_id.strip()).execute()
if response.data:
return f"Deleted: {accession_id}", load_entire_table(), ""
return f"Record {accession_id} not found.", current_df, accession_id
except Exception as e:
return f"Deletion error: {str(e)}", current_df, accession_id
def _df_to_html_table(df):
if df is None or df.empty:
return "No records found.
" cols = list(df.columns) header = "".join(f'"
"⚠ Create a reviewed_articles (doi TEXT PRIMARY KEY, reviewed_at TIMESTAMPTZ DEFAULT NOW())"
" table in Supabase for persistent storage. Currently using session memory.
No articles marked yet.
" + note html = "" for r in rows: article_id = r.get('doi', '') at = (r.get('reviewed_at') or '')[:10] display = article_id[:80] + ('...' if len(article_id) > 80 else '') link = f"https://doi.org/{article_id}" if not article_id.startswith('http') else article_id html += ( f"" ) for c in cache_only: display = c[:80] + ('...' if len(c) > 80 else '') html += ( f""
f"✓*"
f"{display}"
f"session"
f"
"
)
return html
def handle_card_review(is_auth, doi, action):
"""Called by hidden card buttons to mark/unmark an article."""
if not is_auth:
return "⚠ Admin login required to mark articles.", list_reviewed_html()
result = save_reviewed_article(doi) if action == "mark" else remove_reviewed_article(doi)
return result, list_reviewed_html()
def _mark_btn_html(article_id, is_reviewed, tab_prefix):
"""Render admin-only Mark/Unmark button using data attributes (no escaping issues)."""
safe_id = article_id.replace('"', """).replace("'", "'")
if is_reviewed:
return (
f''
)
return (
f''
)
def _reviewed_badge():
return (
'✓ Reviewed'
)
# ── Theme ─────────────────────────────────────────────────────────────────────
light_theme = gr.themes.Base(
primary_hue=gr.themes.colors.blue,
neutral_hue=gr.themes.colors.slate,
font=gr.themes.GoogleFont("Inter"),
).set(
body_background_fill="#f8fafc",
body_background_fill_dark="#f8fafc",
body_text_color="#1e293b",
body_text_color_dark="#1e293b",
block_background_fill="#ffffff",
block_background_fill_dark="#ffffff",
block_border_color="#e2e8f0",
block_border_color_dark="#e2e8f0",
block_label_text_color="#475569",
block_label_text_color_dark="#475569",
block_title_text_color="#0f172a",
block_title_text_color_dark="#0f172a",
input_background_fill="#ffffff",
input_background_fill_dark="#ffffff",
input_border_color="#cbd5e1",
input_border_color_dark="#cbd5e1",
input_placeholder_color="#94a3b8",
input_placeholder_color_dark="#94a3b8",
checkbox_background_color="#ffffff",
checkbox_background_color_dark="#ffffff",
button_primary_background_fill="#2563eb",
button_primary_background_fill_dark="#2563eb",
button_primary_text_color="#ffffff",
button_primary_text_color_dark="#ffffff",
button_secondary_background_fill="#ffffff",
button_secondary_background_fill_dark="#ffffff",
button_secondary_text_color="#475569",
button_secondary_text_color_dark="#475569",
button_secondary_border_color="#cbd5e1",
button_secondary_border_color_dark="#cbd5e1",
table_even_background_fill="#ffffff",
table_even_background_fill_dark="#ffffff",
table_odd_background_fill="#f8fafc",
table_odd_background_fill_dark="#f8fafc",
table_border_color="#e2e8f0",
table_border_color_dark="#e2e8f0",
)
css = """
*, *::before, *::after { color-scheme: light !important; }
.gradio-container,
.gradio-container.dark,
body, html {
background-color: #f8fafc !important;
color: #1e293b !important;
}
.gradio-container h1,
.gradio-container h2,
.gradio-container h3,
.gradio-container h4 {
color: #0f172a !important;
font-weight: 700 !important;
}
.gradio-container label,
.gradio-container .block label span,
.gradio-container p,
.gradio-container span {
color: #334155 !important;
}
.gradio-container input,
.gradio-container textarea,
.gradio-container select {
background-color: #ffffff !important;
color: #0f172a !important;
border-color: #cbd5e1 !important;
}
.gradio-container .options,
.gradio-container ul.options,
.gradio-container [class*="options"] {
background-color: #ffffff !important;
border: 1px solid #e2e8f0 !important;
box-shadow: 0 4px 12px rgba(0,0,0,0.08) !important;
}
.gradio-container .options li,
.gradio-container [class*="options"] li {
color: #334155 !important;
background-color: #ffffff !important;
}
.gradio-container .options li:hover,
.gradio-container [class*="options"] li:hover {
background-color: #f1f5f9 !important;
color: #1e293b !important;
}
.gradio-container .wrap label {
background-color: #ffffff !important;
border: 1px solid #e2e8f0 !important;
color: #475569 !important;
}
.gradio-container .wrap label.selected,
.gradio-container .wrap input[type="radio"]:checked + span {
border-color: #2563eb !important;
color: #2563eb !important;
background-color: #eff6ff !important;
font-weight: 600 !important;
}
/* Only give the white-box treatment to actual leaf component blocks,
not to gr.Column / gr.Row layout containers (.gap) */
.gradio-container .block {
background-color: #ffffff !important;
border-color: #e2e8f0 !important;
}
/* Layout containers: transparent, no border, no shadow */
.gradio-container .gap,
.gradio-container .gap > .block > .gap,
.gradio-container fieldset,
.gradio-container .form {
background-color: transparent !important;
border: none !important;
box-shadow: none !important;
padding: 0 !important;
}
.gradio-container table {
background-color: #ffffff !important;
border-color: #e2e8f0 !important;
}
.gradio-container table th {
background-color: #f8fafc !important;
color: #475569 !important;
border-bottom: 1px solid #e2e8f0 !important;
font-weight: 600 !important;
}
.gradio-container table td {
background-color: #ffffff !important;
color: #334155 !important;
border-bottom: 1px solid #f1f5f9 !important;
}
.gradio-container table tr:hover td,
.gradio-container table tr.hover td,
.gradio-container table tr[class*="selected"] td,
.gradio-container table tr[class*="hover"] td,
.gradio-container tbody tr:hover td,
.gradio-container tbody tr:hover,
.gradio-container [class*="row"]:hover,
.gradio-container [class*="row"]:hover td,
.gradio-container [class*="table"] tr:hover,
.gradio-container [class*="table"] tr:hover td {
background-color: #dbeafe !important;
color: #1e40af !important;
}
.gradio-container table tr:nth-child(odd) td {
background-color: #f8fafc !important;
}
.gradio-container .tabs .tab-nav,
div[class*="tab-nav"],
.tab-nav {
border-bottom: 1px solid #e2e8f0 !important;
background-color: #f8fafc !important;
}
.gradio-container .tabs button,
.gradio-container [class*="tab-nav"] button,
.gradio-container [role="tab"],
button[class*="tab"],
div[class*="tab-nav"] button {
color: #64748b !important;
background-color: transparent !important;
background: transparent !important;
border: none !important;
font-weight: 500 !important;
padding: 10px 18px !important;
transition: background-color 0.15s, color 0.15s !important;
}
.gradio-container .tabs button:hover,
.gradio-container [class*="tab-nav"] button:hover,
.gradio-container [role="tab"]:hover,
button[class*="tab"]:hover,
div[class*="tab-nav"] button:hover {
background-color: #f1f5f9 !important;
background: #f1f5f9 !important;
color: #1e293b !important;
}
.gradio-container .tabs button.selected,
.gradio-container [class*="tab-nav"] button.selected,
.gradio-container [role="tab"][aria-selected="true"],
div[class*="tab-nav"] button.selected {
color: #2563eb !important;
background-color: #ffffff !important;
background: #ffffff !important;
border-bottom: 2px solid #2563eb !important;
font-weight: 700 !important;
}
.gradio-container .tabs button.selected:hover,
.gradio-container [role="tab"][aria-selected="true"]:hover {
background-color: #ffffff !important;
background: #ffffff !important;
color: #2563eb !important;
}
.gradio-container button.primary,
.gradio-container button[variant="primary"] {
background: #2563eb !important;
color: #ffffff !important;
border: none !important;
font-weight: 600 !important;
border-radius: 6px !important;
}
.gradio-container button.primary:hover {
background: #1d4ed8 !important;
}
.gradio-container button.stop {
background: #dc2626 !important;
color: #ffffff !important;
border: none !important;
font-weight: 600 !important;
border-radius: 6px !important;
}
.gradio-container button.secondary {
background: #ffffff !important;
color: #475569 !important;
border: 1px solid #cbd5e1 !important;
border-radius: 6px !important;
}
.gradio-container .upload-container,
.gradio-container [class*="upload"] {
background-color: #f8fafc !important;
border: 1px dashed #cbd5e1 !important;
color: #475569 !important;
}
.gradio-container .textbox textarea {
background-color: #f8fafc !important;
color: #1e293b !important;
border-color: #e2e8f0 !important;
}
/* Prevent layout containers from flashing a background on hover */
.gradio-container .gap:hover,
.gradio-container .gap > .block:hover {
background-color: transparent !important;
}
footer { display: none !important; }
#homepage-canvas-editor {
color: #1e293b !important;
background-color: #f8fafc !important;
}
#qt-search-panel > div {
max-width: 480px !important;
margin: 0 auto !important;
}
#qt-form-inner {
max-width: 480px !important;
}
#qt-search-panel {
animation: qtFadeIn 0.35s ease both;
}
#qt-results-panel {
animation: qtSlideIn 0.4s cubic-bezier(0.4,0,0.2,1) both;
}
@keyframes qtFadeIn {
from { opacity:0; transform:scale(0.98); }
to { opacity:1; transform:scale(1); }
}
@keyframes qtSlideIn {
from { opacity:0; transform:translateX(40px); }
to { opacity:1; transform:translateX(0); }
}
#qt-search-panel > div > div {
max-width: 440px !important;
margin: 0 auto !important;
}
.panel-card {
background: #ffffff;
border: 1px solid #e2e8f0;
border-radius: 8px;
padding: 20px;
box-shadow: 0 1px 3px rgba(0,0,0,0.05);
}
"""
# ── Layout ────────────────────────────────────────────────────────────────────
ALL_SOURCES = ['PubMed', 'Europe PMC', 'CrossRef', 'Semantic Scholar', 'bioRxiv / medRxiv']
with gr.Blocks() as demo: # Removed css and theme parameters from here (moved to launch)
# ── Institute header ──
gr.HTML("""
भाकृअनुप-राष्ठ्रीय डेरी अनुसंधान संस्थान
ICAR – National Dairy Research Institute
KARNAL, HARYANA
Bioinformatics Data Hub & Analysis Launchpad
🔬
Query Biological Records
Select filters and click Search to retrieve data.
📚
Multi-Database Literature Search (Past 6 Months)
Search across PubMed, Europe PMC, CrossRef, Semantic Scholar, and bioRxiv/medRxiv simultaneously. Results are deduplicated and sorted by date.
DATABASE LEGEND
PubMed — NCBI indexed biomedical literature
Europe PMC — EBI life-science literature + open access
CrossRef — DOI registry; broad journal coverage
Semantic Scholar — AI-enriched citation graph
bioRxiv / medRxiv — Biology & medicine preprints
Select databases and enter a topic to begin searching…
"
)
pm_search_btn.click(
fn=fetch_multi_db_papers,
inputs=[pm_topic_input, pm_sources_input, is_authenticated],
outputs=pm_output_html
)
# ── artReview JS — uses data attributes, proper session_hash ─
gr.HTML("""""")
pm_card_status = gr.HTML("")
# ── Admin panel: reviewed list only ───────────────────────────
with gr.Column(visible=False) as pm_admin_col:
gr.HTML("""🔒 ADMIN MODE — Click ✓ Mark as Read on any result card above to track it. The badge is visible to all users.
🌐
Literature Search
Full cross-database search with year-range filtering and page-by-page loading. Results are deduplicated and sorted newest-first.
DATABASE LEGEND
PubMed — NCBI biomedical literature
Europe PMC — EBI life-science + open access
CrossRef — DOI registry; broad coverage
Semantic Scholar — AI-enriched citation graph
bioRxiv / medRxiv — Preprints
Enter a topic and click Search to begin…
"
)
with gr.Row():
ls_prev_btn = gr.Button("← Prev", variant="secondary", size="sm")
ls_next_btn = gr.Button("Next →", variant="primary", size="sm")
# ── Event wiring ──────────────────────────────────────────────
ls_search_btn.click(
fn=ls_init_search,
inputs=[ls_topic_input, ls_sources_input, ls_year_from, ls_year_to, is_authenticated],
outputs=[ls_output_html, ls_nav_html, ls_state],
)
ls_prev_btn.click(
fn=ls_prev_page,
inputs=[ls_state],
outputs=[ls_output_html, ls_nav_html, ls_state],
)
ls_next_btn.click(
fn=ls_next_page,
inputs=[ls_state],
outputs=[ls_output_html, ls_nav_html, ls_state],
)
# ── artReview is defined in Tab 3; Tab 4 reuses it via same page scope ─
ls_card_status = gr.HTML("")
# ── Admin panel: reviewed list only ───────────────────────────
with gr.Column(visible=False) as ls_admin_col:
gr.HTML("""🔒 ADMIN MODE — Click ✓ Mark as Read on any result card above to track it. The badge is visible to all users.
🤖
AI / ML / DL Tools for Cattle & Buffalo Reproduction
Click any card to open the source paper or tool.
🥚 Oocyte Assessment / Grading
DeepLabV3Plus + SqueezeNet Pipeline
Combines DeepLabV3Plus segmentation with a refined SqueezeNet classifier; 96% validation accuracy for oocyte meiotic-stage classification.
CNN-Based Oocyte Competence Scoring
Semi-automatic CNN-based system for bovine oocyte competence, labelling images post hoc by resulting blastocyst outcomes.
ML + Microfluidic Integration
Multiple supervised ML models (RF, XGBoost, SVM, LightGBM, KNN, Naïve Bayes, LR) evaluated for oocyte quality prediction integrated with microfluidic chip data.
🧫 Embryo / Blastocyst Grading
Blasto3Q
Fully automated ANN-based bovine blastocyst grading per IETS standard (Grade 1/2/3); 76.4% accuracy; MATLAB + multiplatform web interface.
iDAScore (Vitrolife)
Fully automated time-lapse analysis; ranks embryos by likelihood of fetal heartbeat at day 2/3/blastocyst stage. Widely cited in bovine ET literature.
EmbryoScope / Primo Vision / Eeva
Time-lapse incubation systems with integrated kinetics and cleavage-symmetry evaluation software; Primo Vision used to record bovine blastulation timing (tSB, tB).
ML Embryo Stage / Transferability Classifier
81.7% agreement with expert embryologists on developmental stage; 95.2% agreement on transferability decision.
Multi-Task DL + Dynamic Programming
2D CNN per time-lapse frame with dynamic-programming post-processing enforcing monotonic cell-count progression for embryo cell-stage classification.
Supervised Contrastive Learning Model
Benchmarked on public Bovine Embryo CS dataset and NYU Mouse Embryo dataset for cell-stage classification using contrastive CNN.
CNN Oocyte / Embryo Scoring (Mana et al.)
CNN-based scoring of 269 oocytes and 269 corresponding embryos from 104 women; preliminary high-quality embryo classification study.
ML Live-Birth Prediction (Miyagi et al.)
Multiple ML algorithms compared (LR, Naïve Bayes, KNN, RF, Neural Network, SVM) for predicting probability of live birth from blastocyst-stage images.
AI Pregnancy-Probability Platform (Khosravi et al.)
AI platform trained on embryologist-scored blastocyst images; predicted pregnancy chance 13.8–66.3% depending on blastocyst/patient factors.
💉 Sperm / Semen Analysis (CASA + AI)
BGM — Open-Access CASA Software
Open-access CASA software validated against commercial Hamilton-Thorne (HTM) system for cattle and buffalo sperm motility/kinematics. Most directly relevant tool for cattle + buffalo work.
BSPMCsvm3casa
SVM-based bull sperm motility classifier using three CASA kinematic parameters (VCL, VSL, LIN); outperforms prior static-threshold classification methods.
Tracking-Grid + Mean-Angle Motion Tracker
Predicts position of sperm with failed detection using mean motion angle + Tracking-Grid; 5% fewer ID-switches and +15.6 MOTAL points vs Deep SORT baseline.
Hamilton-Thorne CASA (IVOS / HTM Series)
Industry-standard CASA combining camera, microscope, and pixel-recognition software for motility/velocity/morphology evaluation across cattle and buffalo.
DL Bovine Sperm Morphology Classifier (IFC)
Deep learning morphology analysis trained on ~1.8 million imaging flow cytometry images across 6 bulls, fresh and frozen-thawed semen.
AI Bull Sperm Morphology Evaluation System
AI algorithm benchmarked against manual morphology assessment in bull semen analysis; confirmed potential applicability for automated sperm morphology evaluation.
🐄 Animal Identification (Cattle / Buffalo)