Streamlit Dashboard Pushed 20-05-2026

streamlit/.gitignore

@@ -0,0 +1 @@
+*.txt

streamlit/.streamlit/config.toml

@@ -0,0 +1,11 @@
+[theme]
+primaryColor = "#00BCD4"
+backgroundColor = "#0a0e27"
+secondaryBackgroundColor = "#111a38"
+textColor = "#c8d6e5"
+font = "sans serif"
+
+[server]
+headless = true
+port = 8501
+maxUploadSize = 500

streamlit/2902174_meta_test.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:237a8905395766789208be861c7b115998fd691ded7f00d0c12bda2dd5535934
+size 68748

streamlit/analyze_data.py

@@ -0,0 +1,85 @@
+"""Quick analysis: how many floats survive each filtering stage?"""
+import pandas as pd
+from global_land_mask import globe
+import numpy as np
+
+print("=== Loading raw data ===")
+df = pd.read_csv("ar_index_global_prof.txt", comment="#")
+df.columns = df.columns.str.strip()
+df["wmo_id"] = df["file"].str.extract(r"/(\d+)/")
+
+print(f"1. Raw rows: {len(df):,}")
+print(f"   Raw unique floats: {df['wmo_id'].nunique():,}")
+
+# After dropping NaN lat/lon
+df2 = df.dropna(subset=["latitude", "longitude"])
+print(f"\n2. After dropping NaN coords: {len(df2):,} rows, {df2['wmo_id'].nunique():,} floats")
+
+# After valid range filter
+df3 = df2[
+    (df2["latitude"] >= -90) & (df2["latitude"] <= 90)
+    & (df2["longitude"] >= -180) & (df2["longitude"] <= 180)
+]
+print(f"3. After valid range: {len(df3):,} rows, {df3['wmo_id'].nunique():,} floats")
+
+# After land masking
+is_land = globe.is_land(df3["latitude"].values, df3["longitude"].values)
+land_count = int(is_land.sum())
+df4 = df3[~is_land]
+print(f"4. Land-masked removed: {land_count:,} rows")
+print(f"   After land mask: {len(df4):,} rows, {df4['wmo_id'].nunique():,} floats")
+
+# After Indian Ocean bounding box (default filters)
+df5 = df4[
+    (df4["longitude"] >= 20.0) & (df4["longitude"] <= 145.0)
+    & (df4["latitude"] >= -70.1) & (df4["latitude"] <= 30.0)
+]
+print(f"\n5. Indian Ocean box (20-145E, 70.1S-30N):")
+print(f"   Rows: {len(df5):,}, Unique floats: {df5['wmo_id'].nunique():,}")
+
+# Latest position per float (what map shows)
+df5_sorted = df5.copy()
+df5_sorted["date"] = pd.to_datetime(df5_sorted["date"], format="%Y%m%d%H%M%S", errors="coerce")
+map_df = (
+    df5_sorted.dropna(subset=["latitude", "longitude"])
+    .sort_values("date")
+    .groupby("wmo_id")
+    .tail(1)
+)
+print(f"   Map markers (latest pos per float): {len(map_df):,}")
+
+# Check institutions in Indian Ocean
+print(f"\n6. Institutions in Indian Ocean box:")
+inst_counts = df5.groupby("institution")["wmo_id"].nunique().sort_values(ascending=False)
+for inst, count in inst_counts.items():
+    print(f"   {inst}: {count:,} floats")
+print(f"   TOTAL: {inst_counts.sum():,}")
+
+# Also check: how many floats does the GLOBAL dataset have whose LATEST position is in Indian Ocean?
+print("\n7. Floats whose LATEST position falls in Indian Ocean:")
+df4["date"] = pd.to_datetime(df4["date"], format="%Y%m%d%H%M%S", errors="coerce")
+latest_pos = df4.dropna(subset=["date"]).sort_values("date").groupby("wmo_id").tail(1)
+io_latest = latest_pos[
+    (latest_pos["longitude"] >= 20.0) & (latest_pos["longitude"] <= 145.0)
+    & (latest_pos["latitude"] >= -70.1) & (latest_pos["latitude"] <= 30.0)
+]
+print(f"   Floats with latest pos in IO: {len(io_latest):,}")
+
+# Check: floats that EVER reported from Indian Ocean
+print("\n8. Floats that EVER reported from Indian Ocean box:")
+io_ever = df4[
+    (df4["longitude"] >= 20.0) & (df4["longitude"] <= 145.0)
+    & (df4["latitude"] >= -70.1) & (df4["latitude"] <= 30.0)
+]
+print(f"   Unique floats ever in IO: {io_ever['wmo_id'].nunique():,}")
+print(f"   Total profiles in IO: {len(io_ever):,}")
+
+# Argo reference numbers
+print("\n=== For reference ===")
+print(f"Global active floats (latest profile in last 30 days):")
+latest_date = df4["date"].max()
+thirty_days = pd.Timestamp(latest_date - pd.Timedelta(days=30))
+active_global = latest_pos[latest_pos["date"] >= thirty_days]
+print(f"   Global active: {len(active_global):,}")
+active_io = io_latest[io_latest["date"] >= thirty_days]
+print(f"   Indian Ocean active: {len(active_io):,}")

streamlit/cache/bgc_profiles.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db2cdd7770e0a93233a603d7b08a8a30be3e8d94c082dce046a30c6d02e24494
+size 10149287

streamlit/cache/meta.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99cee387efe37a0f64538c5da2a9d41bbeb9fc424b65760b5c60981198ca9d78
+size 518271

streamlit/cache/profiles.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec9b42bd80e8c5c0d231fb0fdf3192670f75b2d948dd29b9114528e1f3f90a49
+size 82055253

streamlit/dashboard.py

@@ -0,0 +1,1772 @@
+"""
+Indian ARGO CTD / BGC Float Dashboard
+======================================
+Streamlit re-implementation per INCOIS PRD.
+Data Source: Argo GDAC (IFREMER)
+
+Components
+----------
+1. Geospatial float-position map (colour-coded by institution/region)
+2. Annual float-count bar chart (1999–present)
+3. BGC profile KPI tiles (DOXY, Chla, Nitrate, pH)
+4. Active floats/profiles last-7-days treemap
+5. Float-age donut chart
+6. DAC/Institution summary table
+"""
+
+# ==================== IMPORTS ====================
+import streamlit as st
+import os
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from pathlib import Path
+import warnings
+import xarray as xr
+
+warnings.filterwarnings("ignore")
+
+# ==================== PATHS & CONSTANTS ====================
+BASE_DIR = Path(__file__).parent
+CACHE_DIR = BASE_DIR / "cache"
+PROF_FILE = BASE_DIR / "ar_index_global_prof.txt"
+BIO_FILE = BASE_DIR / "argo_bio-profile_index.txt"
+META_FILE = BASE_DIR / "ar_index_global_meta.txt"
+
+# Institution → colour (PRD §7.1.2 / Table 6)
+REGION_COLORS = {
+    "IN": "#8BC34A",   # Indian Ocean – olive green
+    "AO": "#00BCD4",   # Arabian / Atlantic Ocean – cyan
+    "BO": "#FF5722",   # Bay of Bengal – deep orange
+    "CS": "#FFC107",   # Coral Sea – amber
+    "HZ": "#9E9E9E",   # Marginal seas – grey
+    "IF": "#4CAF50",   # Intermediate / Far seas – green
+    "JA": "#2196F3",   # JMA – blue
+    "KO": "#E91E63",   # KIOST – pink
+    "KM": "#9C27B0",   # KMA – purple
+    "ME": "#795548",   # MEDS – brown
+    "NM": "#607D8B",   # NMDIS – blue-grey
+}
+
+
+
+# KPI tile colours (PRD §7.3.2 / Table 7)
+KPI_COLORS = {
+    "DOXY": "#00BCD4",
+    "Chla": "#8BC34A",
+    "Nitrate": "#FF8F00",
+    "pH": "#4CAF50",
+}
+
+# Age-group colours (PRD §7.5.2)
+AGE_COLORS = {
+    "00-02": "#673AB7",
+    "03-05": "#2196F3",
+    "06-08": "#FF9800",
+    "09-11": "#F44336",
+    "12+": "#795548",
+}
+
+# Profiler Type (WMO R08 Table) → Human-readable instrument name
+PROFILER_TYPE_NAMES = {
+    831: "P-ALACE", 834: "Provor-II", 835: "Provor-III", 836: "Provor-MT",
+    837: "Arvor-C", 838: "Arvor-D", 839: "Provor-IV", 840: "Provor (no CT)",
+    841: "Provor-SBE", 842: "Arvor-CM", 843: "Provor-V", 844: "Arvor",
+    845: "Webb-PALACE", 846: "APEX", 847: "APEX-EM", 848: "APEX-EM-SBE",
+    849: "APEX-Deep", 850: "SOLO (no CT)", 851: "SOLO-SBE", 852: "SOLO-FSI",
+    853: "SOLO2", 854: "S2A", 855: "Ninja (no CT)", 856: "Ninja-D",
+    857: "Ninja-BGC", 858: "Ninja-Deep", 859: "Ninja-SBE", 860: "Ninja",
+    861: "ALTO", 862: "Navis-EBR", 863: "Navis-A", 864: "Navis-Deep",
+    865: "Nova", 869: "Deep ARVOR", 870: "APEX-APF11", 871: "APEX-Deep-APF11",
+    872: "APEX-BGC", 873: "Arvor-Deep", 874: "APEX-Deep-SBE",
+    875: "Provor-BGC", 876: "Deep SOLO", 877: "Deep SOLO-MRV",
+    878: "Deep NINJA", 879: "HM2000", 880: "HM4000", 881: "Deep Arvor-O",
+    882: "Deep S2A", 883: "Provor-BGC-II", 884: "Arvor-I", 885: "TWR",
+    886: "SOLO-BGC", 887: "Arvor-RBR", 888: "ALTO-RBR", 889: "Arvor-Deep-RBR",
+    890: "APEX-RBR", 891: "Navis-RBR",
+}
+
+# Colors for top profiler type families
+PROFILER_COLORS = {
+    "APEX": "#4FC3F7", "Arvor": "#FF7043", "SOLO-SBE": "#26A69A",
+    "SOLO2": "#BA68C8", "Deep ARVOR": "#FFB74D", "Provor-SBE": "#00BCD4",
+    "S2A": "#F06292", "Navis-A": "#9CCC65", "Provor-MT": "#9575CD",
+    "SOLO-FSI": "#FFD54F", "Nova": "#90A4AE", "Ninja": "#EF5350",
+    "Arvor-D": "#42A5F5", "Provor-II": "#66BB6A", "Navis-EBR": "#AB47BC",
+    "Arvor-CM": "#FFA726", "APEX-Deep-SBE": "#78909C", "APEX-APF11": "#29B6F6",
+    "Deep NINJA": "#EC407A", "Deep SOLO-MRV": "#5C6BC0",
+    "Other": "#607D8B",
+}
+
+# ==================== PAGE CONFIG ====================
+st.set_page_config(
+    page_title="Indian ARGO CTD_BGC Dashboard",
+    page_icon="🌊",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        "About": "Indian ARGO CTD/BGC Float Dashboard · INCOIS · Data: IFREMER GDAC"
+    },
+)
+
+
+# ==================== CUSTOM CSS ====================
+st.markdown(
+    """
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700;800&family=Inter:wght@300;400;500;600;700&display=swap');
+
+    html, body, [class*="css"] {
+        font-family: 'Outfit', 'Inter', sans-serif;
+    }
+
+    /* ── Seamless App Background ── */
+    .stApp {
+        background: radial-gradient(circle at 10% 20%, rgba(5, 12, 33, 1) 0%, rgba(1, 4, 15, 1) 90%);
+        background-attachment: fixed;
+    }
+
+    /* ── Glass Containers ── */
+    [data-testid="stMetric"], .kpi-tile, [data-testid="stExpander"], .dac-table, .treemap-info {
+        background: rgba(255, 255, 255, 0.04) !important;
+        backdrop-filter: blur(12px);
+        -webkit-backdrop-filter: blur(12px);
+        border: 1px solid rgba(255, 255, 255, 0.08) !important;
+        border-radius: 18px !important;
+        box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.37);
+        padding: 20px;
+    }
+
+    /* ── Sidebar Glass UI ── */
+    section[data-testid="stSidebar"] {
+        background: rgba(6, 11, 25, 0.82) !important;
+        backdrop-filter: blur(15px);
+        border-right: 1px solid rgba(0, 188, 212, 0.15);
+    }
+    section[data-testid="stSidebar"] * { color: #d1d9e6 !important; }
+    section[data-testid="stSidebar"] h2 { color: #00BCD4 !important; font-weight: 700; letter-spacing: 0.5px; }
+
+    /* ── KPI Tiles - Revamped ── */
+    .kpi-tile {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        min-height: 140px;
+        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        text-align: center;
+        border: 1px solid rgba(255, 255, 255, 0.12) !important;
+    }
+    .kpi-tile:hover {
+        transform: translateY(-5px);
+        background: rgba(255, 255, 255, 0.07) !important;
+        border: 1px solid rgba(0, 188, 212, 0.4) !important;
+        box-shadow: 0 12px 40px rgba(0, 188, 212, 0.15);
+    }
+    .kpi-label {
+        font-size: 0.75rem;
+        font-weight: 700;
+        letter-spacing: 1.2px;
+        text-transform: uppercase;
+        color: rgba(255, 255, 255, 0.7);
+        margin-bottom: 8px;
+    }
+    .kpi-value {
+        font-size: 1.8rem;
+        font-weight: 800;
+        color: #ffffff;
+        white-space: nowrap; /* Prevent wrapping */
+        line-height: 1.1;
+    }
+
+    /* ── Header ── */
+    .header-bar {
+        background: rgba(255, 255, 255, 0.02);
+        backdrop-filter: blur(8px);
+        border: 1px solid rgba(0, 188, 212, 0.2);
+        border-radius: 20px;
+        padding: 30px;
+        margin-bottom: 25px;
+        position: relative;
+    }
+    .header-bar h1 {
+        font-family: 'Outfit', sans-serif;
+        font-weight: 800;
+        letter-spacing: -0.5px;
+        background: linear-gradient(90deg, #ffffff, #00BCD4, #4CAF50);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+    }
+
+    /* ── Modern Scrollbar ── */
+    ::-webkit-scrollbar { width: 6px; }
+    ::-webkit-scrollbar-thumb { background: rgba(0, 188, 212, 0.4); border-radius: 10px; }
+
+    /* ── Fix Streamlit gaps ── */
+    .stPlotlyChart {
+         background: rgba(255, 255, 255, 0.02) !important;
+         border-radius: 18px;
+         padding: 10px;
+         border: 1px solid rgba(255, 255, 255, 0.05);
+    }
+
+    /* ── Legend Chips ── */
+    .legend-chip {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        padding: 4px 10px;
+        margin: 3px 4px;
+        background: rgba(255,255,255,0.06);
+        border-radius: 12px;
+        font-size: 0.75rem;
+        color: #c8d6e5;
+        border: 1px solid rgba(255,255,255,0.08);
+    }
+    .legend-dot {
+        width: 10px;
+        height: 10px;
+        border-radius: 50%;
+        display: inline-block;
+        flex-shrink: 0;
+    }
+
+    /* ── Footer ── */
+    .footer-bar {
+        text-align: center;
+        padding: 20px 30px;
+        margin-top: 30px;
+        font-size: 0.8rem;
+        color: rgba(255,255,255,0.45);
+        background: rgba(255,255,255,0.02);
+        border-top: 1px solid rgba(0,188,212,0.12);
+        border-radius: 16px;
+        letter-spacing: 0.3px;
+    }
+
+    /* ── Treemap Summary Stats ── */
+    .stat {
+        font-size: 1.6rem;
+        font-weight: 800;
+        color: #ffffff;
+        text-align: center;
+    }
+    .stat-label {
+        font-size: 0.7rem;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+        color: rgba(255,255,255,0.5);
+        text-align: center;
+        margin-top: 2px;
+    }
+
+    /* ── DAC Table ── */
+    .dac-table table {
+        width: 100%;
+        border-collapse: separate;
+        border-spacing: 0;
+        font-size: 0.85rem;
+        color: #c8d6e5;
+    }
+    .dac-table th {
+        padding: 12px 14px;
+        text-align: center;
+        font-weight: 700;
+        color: #00BCD4;
+        border-bottom: 2px solid rgba(0,188,212,0.2);
+        font-size: 0.8rem;
+        letter-spacing: 0.5px;
+        text-transform: uppercase;
+    }
+    .dac-table td {
+        padding: 10px 14px;
+        text-align: center;
+        border-bottom: 1px solid rgba(255,255,255,0.04);
+    }
+    .dac-table tbody tr:nth-child(odd) {
+        background: rgba(255,255,255,0.02);
+    }
+    .dac-table tbody tr:hover {
+        background: rgba(0,188,212,0.06);
+    }
+
+    /* ── Refresh timestamp ── */
+    .refresh-ts {
+        font-size: 0.75rem;
+        color: rgba(255,255,255,0.4);
+        margin-top: 6px;
+    }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+
+# ==================== HELPER: dark plotly layout ====================
+def _dark_layout(**overrides):
+    """Return a dark-themed plotly layout dict."""
+    base = dict(
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        font=dict(family="Inter, sans-serif", color="#c8d6e5", size=12),
+        margin=dict(l=40, r=20, t=40, b=40),
+    )
+    base.update(overrides)
+    return base
+
+
+# ==================== DATA LOADING ====================
+# Global constants for classification
+DEEP_PROFILER_TYPES = {862, 864, 876, 882, 869, 863, 873, 874, 886, 877, 875, 884, 872, 879, 865, 860, 878, 861, 871, 870, 881, 853}
+
+@st.cache_data(show_spinner="Loading core-profile index …")
+def load_profile_data():
+    """Load ar_index_global_prof.txt with Parquet cache (24-h TTL)."""
+    CACHE_DIR.mkdir(exist_ok=True)
+    cache_path = CACHE_DIR / "profiles.parquet"
+
+    if cache_path.exists():
+        age_h = (datetime.now().timestamp() - cache_path.stat().st_mtime) / 3600
+        if age_h < 24:
+            df = pd.read_parquet(cache_path)
+            # Ensure is_deep exists (handles stale caches from before this column was added)
+            if "is_deep" not in df.columns:
+                df["is_deep"] = df["profiler_type"].isin(DEEP_PROFILER_TYPES) if "profiler_type" in df.columns else False
+            if "dac" not in df.columns:
+                df["dac"] = df["file"].str.extract(r"^([^/]+)/")
+            return df
+
+    df = pd.read_csv(PROF_FILE, comment="#")
+    # Strip whitespace from column names (GDAC files sometimes have spaces)
+    df.columns = df.columns.str.strip()
+
+    # --- Land-mask filtering removed: caused discrepancies ---
+    df = df.dropna(subset=["latitude", "longitude"])
+    
+    # Ensure coordinates are within valid ranges [-90, 90] and [-180, 180]
+    df = df[
+        (df["latitude"] >= -90) & (df["latitude"] <= 90) &
+        (df["longitude"] >= -180) & (df["longitude"] <= 180)
+    ]
+
+    df["date"] = pd.to_datetime(df["date"], format="%Y%m%d%H%M%S", errors="coerce")
+    if "date_update" in df.columns:
+        df["date_update"] = pd.to_datetime(
+            df["date_update"], format="%Y%m%d%H%M%S", errors="coerce"
+        )
+    df["wmo_id"] = df["file"].str.extract(r"/(\d+)/")
+    df["dac"] = df["file"].str.extract(r"^([^/]+)/")
+    df["year"] = df["date"].dt.year
+    df["is_deep"] = df["profiler_type"].isin(DEEP_PROFILER_TYPES)
+
+    df.to_parquet(cache_path, index=False)
+    return df
+
+
+@st.cache_data(show_spinner="Loading BGC-profile index …")
+def load_bio_data():
+    """Load argo_bio-profile_index.txt with Parquet cache (24-h TTL)."""
+    CACHE_DIR.mkdir(exist_ok=True)
+    cache_path = CACHE_DIR / "bgc_profiles.parquet"
+
+    if cache_path.exists():
+        age_h = (datetime.now().timestamp() - cache_path.stat().st_mtime) / 3600
+        if age_h < 24:
+            return pd.read_parquet(cache_path)
+
+    df = pd.read_csv(BIO_FILE, comment="#")
+    df.columns = df.columns.str.strip()
+
+    df["date"] = pd.to_datetime(df["date"], format="%Y%m%d%H%M%S", errors="coerce")
+    df["wmo_id"] = df["file"].str.extract(r"/(\d+)/")
+    df["year"] = df["date"].dt.year
+
+    params_upper = df["parameters"].fillna("").str.upper()
+    df["has_doxy"] = params_upper.str.contains("DOXY")
+    df["has_chla"] = params_upper.str.contains("CHLA")
+    df["has_nitrate"] = params_upper.str.contains("NITRATE")
+    df["has_ph"] = params_upper.str.contains("PH_IN_SITU")
+
+    df.to_parquet(cache_path, index=False)
+    return df
+
+
+@st.cache_data(show_spinner="Loading float metadata index …")
+def load_meta_data():
+    """Load ar_index_global_meta.txt with Parquet cache (24-h TTL).
+
+    Provides one row per float (WMO) with profiler_type, institution,
+    dac, and a human-readable profiler_name from WMO R08.
+    """
+    CACHE_DIR.mkdir(exist_ok=True)
+    cache_path = CACHE_DIR / "meta.parquet"
+
+    if cache_path.exists():
+        age_h = (datetime.now().timestamp() - cache_path.stat().st_mtime) / 3600
+        if age_h < 24:
+            return pd.read_parquet(cache_path)
+
+    df = pd.read_csv(META_FILE, comment="#")
+    df.columns = df.columns.str.strip()
+    df["wmo_id"] = df["file"].str.extract(r"/(\d+)/")
+    df["dac"] = df["file"].str.extract(r"^([^/]+)/")
+    df["date_update"] = pd.to_datetime(
+        df["date_update"], format="%Y%m%d%H%M%S", errors="coerce"
+    )
+    # Map numeric profiler_type code to human-readable name
+    df["profiler_name"] = (
+        df["profiler_type"]
+        .map(PROFILER_TYPE_NAMES)
+        .fillna("Unknown")
+    )
+    df.to_parquet(cache_path, index=False)
+    return df
+
+
+@st.cache_data
+def _bgc_wmo_set(_df_bio):
+    """Set of WMO IDs that have at least one BGC profile."""
+    return set(_df_bio["wmo_id"].dropna().unique())
+
+
+# ==================== LOAD DATA ====================
+with st.spinner("🌊 Initialising ARGO Dashboard …"):
+    df_prof = load_profile_data()
+    df_bio = load_bio_data()
+    df_meta = load_meta_data()
+    bgc_wmos = _bgc_wmo_set(df_bio)
+
+# Derived column: is this float a BGC float?
+df_prof["is_bgc"] = df_prof["wmo_id"].isin(bgc_wmos)
+
+# Enrich profiles with profiler_name from meta (authoritative per-float source)
+_meta_pname = df_meta.set_index("wmo_id")["profiler_name"]
+df_prof["profiler_name"] = df_prof["wmo_id"].map(_meta_pname).fillna("Unknown")
+
+@st.dialog("Float Information", width="large")
+def show_float_details(wmo):
+    meta_path = BASE_DIR / f"more_components/{wmo}_meta.nc"
+    prof_path = BASE_DIR / f"more_components/{wmo}_prof.nc"
+    
+    # Auto-download from IFREMER GDAC if files do not exist
+    if not meta_path.exists() or not prof_path.exists():
+        import urllib.request
+        
+        dac_row = df_meta[df_meta["wmo_id"] == wmo]
+        if len(dac_row) > 0:
+            dac = dac_row.iloc[0]["dac"]
+        else:
+            dac = "incois"  # fallback
+            
+        meta_url = f"ftp://ftp.ifremer.fr/ifremer/argo/dac/{dac}/{wmo}/{wmo}_meta.nc"
+        prof_url = f"ftp://ftp.ifremer.fr/ifremer/argo/dac/{dac}/{wmo}/{wmo}_prof.nc"
+        
+        target_dir = BASE_DIR / "more_components"
+        target_dir.mkdir(exist_ok=True)
+        
+        with st.spinner(f"Downloading GDAC NetCDF files for {wmo} ({dac})..."):
+            try:
+                if not meta_path.exists():
+                    urllib.request.urlretrieve(meta_url, meta_path)
+                if not prof_path.exists():
+                    urllib.request.urlretrieve(prof_url, prof_path)
+            except Exception as e:
+                st.error(f"Failed to download files from {meta_url}. Error: {e}")
+                return
+        
+    try:
+        ds_meta = xr.open_dataset(meta_path)
+        ds_prof = xr.open_dataset(prof_path)
+        
+        def d(val):
+            if hasattr(val, "item") and callable(val.item):
+                try:
+                    val = val.item()
+                except:
+                    pass
+            if isinstance(val, bytes):
+                return val.decode('utf-8', errors='ignore').strip()
+            elif isinstance(val, np.ndarray) and val.dtype.kind == 'S':
+                return ", ".join([v.decode('utf-8', errors='ignore').strip() for v in val.flat if v.decode('utf-8', errors='ignore').strip()])
+            elif isinstance(val, (list, np.ndarray)):
+                return ", ".join([d(v) for v in val])
+            return str(val).strip()
+
+        maker = d(ds_meta.PLATFORM_MAKER.values) if 'PLATFORM_MAKER' in ds_meta else 'N/A'
+        serial = d(ds_meta.FLOAT_SERIAL_NO.values) if 'FLOAT_SERIAL_NO' in ds_meta else 'N/A'
+        ptype = d(ds_meta.PLATFORM_TYPE.values) if 'PLATFORM_TYPE' in ds_meta else 'N/A'
+        trans = d(ds_meta.TRANS_SYSTEM.values) if 'TRANS_SYSTEM' in ds_meta else 'N/A'
+        owner = d(ds_meta.FLOAT_OWNER.values) if 'FLOAT_OWNER' in ds_meta else 'N/A'
+        
+        dc_map = {
+            "AO": "AOML", "BO": "BODC", "CO": "Coriolis", "CS": "CSIRO", 
+            "IN": "INCOIS", "JA": "JMA", "KM": "KMA", "ME": "MEDS", 
+            "RU": "RU", "HZ": "CSIO", "NM": "NMDIS"
+        }
+        if 'DATA_CENTRE' in ds_meta:
+            dc_code = d(ds_meta.DATA_CENTRE.values).upper()
+            dc = dc_map.get(dc_code, dc_code)
+        elif 'OPERATING_INSTITUTION' in ds_meta:
+            dc = d(ds_meta.OPERATING_INSTITUTION.values)
+        else:
+            dc = 'N/A'
+        sensors = d(ds_meta.SENSOR.values) if 'SENSOR' in ds_meta else 'N/A'
+        ptt = d(ds_meta.PTT.values) if 'PTT' in ds_meta else 'N/A'
+        
+        launch_date = d(ds_meta.LAUNCH_DATE.values) if 'LAUNCH_DATE' in ds_meta else 'N/A'
+        if launch_date != 'N/A' and len(launch_date) == 14:
+            try:
+                dt = datetime.strptime(launch_date, '%Y%m%d%H%M%S')
+                launch_date_fmt = dt.strftime('%d/%m/%Y %H:%M:%S')
+                age = f"{(datetime.now() - dt).days / 365.25:.2f} years ago"
+            except:
+                launch_date_fmt = launch_date
+                age = "N/A"
+        else:
+            launch_date_fmt = launch_date
+            age = "N/A"
+            
+        launch_lat = float(ds_meta.LAUNCH_LATITUDE.values) if 'LAUNCH_LATITUDE' in ds_meta else 'N/A'
+        launch_lon = float(ds_meta.LAUNCH_LONGITUDE.values) if 'LAUNCH_LONGITUDE' in ds_meta else 'N/A'
+        
+        project = d(ds_meta.PROJECT_NAME.values) if 'PROJECT_NAME' in ds_meta else 'N/A'
+        pi = d(ds_meta.PI_NAME.values) if 'PI_NAME' in ds_meta else 'N/A'
+        
+        if 'CYCLE_NUMBER' in ds_prof and len(ds_prof.CYCLE_NUMBER) > 0:
+            cycle = int(np.nanmax(ds_prof.CYCLE_NUMBER.values))
+            juld = ds_prof.JULD.values
+            last_date_np = juld[~np.isnat(juld)]
+            if len(last_date_np) > 0:
+                dt_last = pd.to_datetime(last_date_np[-1])
+                last_date = dt_last.strftime('%d/%m/%Y %H:%M:%S')
+                if launch_date != 'N/A' and len(launch_date) == 14:
+                    try:
+                        dt_launch = datetime.strptime(launch_date, '%Y%m%d%H%M%S')
+                        cycle_age_years = (dt_last - dt_launch).days / 365.25
+                        cycle_age = f"{cycle_age_years:.2f} years old"
+                    except:
+                        cycle_age = "N/A"
+                else:
+                    cycle_age = "N/A"
+            else:
+                last_date = "N/A"
+                cycle_age = "N/A"
+                
+            try:
+                pres_data = ds_prof.PRES.values
+                valid_cycles = np.where(~np.isnan(pres_data).all(axis=1))[0]
+                if len(valid_cycles) > 0:
+                    last_valid_idx = valid_cycles[-1]
+                    last_pres = pres_data[last_valid_idx]
+                    last_temp = ds_prof.TEMP.values[last_valid_idx] if 'TEMP' in ds_prof else np.full_like(last_pres, np.nan)
+                    last_psal = ds_prof.PSAL.values[last_valid_idx] if 'PSAL' in ds_prof else np.full_like(last_pres, np.nan)
+                    
+                    valid_idx = ~np.isnan(last_pres)
+                    pres_v = last_pres[valid_idx]
+                    temp_v = last_temp[valid_idx]
+                    psal_v = last_psal[valid_idx]
+                    
+                    if len(pres_v) > 0:
+                        surface_idx = np.argmin(pres_v)
+                        bottom_idx = np.argmax(pres_v)
+                        surf_data = f"{pres_v[surface_idx]:.2f} dbar {temp_v[surface_idx]:.3f}°C {psal_v[surface_idx]:.3f} PSU"
+                        bott_data = f"{pres_v[bottom_idx]:.2f} dbar {temp_v[bottom_idx]:.3f}°C {psal_v[bottom_idx]:.3f} PSU"
+                    else:
+                        surf_data = "N/A"
+                        bott_data = "N/A"
+                else:
+                    surf_data = "N/A"
+                    bott_data = "N/A"
+            except:
+                surf_data = "N/A"
+                bott_data = "N/A"
+        else:
+            cycle = "N/A"
+            last_date = "N/A"
+            cycle_age = "N/A"
+            surf_data = "N/A"
+            bott_data = "N/A"
+            
+        status = "Inactive" 
+        if last_date != "N/A":
+             try:
+                 dt_last = datetime.strptime(last_date, '%d/%m/%Y %H:%M:%S')
+                 if (datetime.now() - dt_last).days <= 90:
+                     status = "Active"
+             except:
+                 pass
+                 
+        status_color = "#EF5350" if status == "Inactive" else "#66BB6A"
+
+        st.markdown("### Main Information")
+        st.markdown(f"""
+        <div style='display: flex; gap: 20px; flex-wrap: wrap; margin-top: 10px;'>
+            <!-- About Float -->
+            <div style='flex: 1; min-width: 250px; background: rgba(255,255,255,0.02); padding: 20px; border-radius: 12px; border: 1px solid rgba(255,255,255,0.05);'>
+                <h4 style='color: #4FC3F7; margin-top: 0; font-family: Outfit, sans-serif; border-bottom: 1px solid rgba(255,255,255,0.1); padding-bottom: 10px;'>About Float</h4>
+                <table style='width: 100%; border: none; font-size: 0.85em; line-height: 1.5;'>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>WMO<br><span style='color: #4FC3F7; font-size: 1.1em;'>{wmo}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Platform maker<br><span style='color: white; font-size: 1.1em;'>{maker}</span></td>
+                    </tr>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Float serial number<br><span style='color: white; font-size: 1.1em;'>{serial}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Platform type<br><span style='color: white; font-size: 1.1em;'>{ptype}</span></td>
+                    </tr>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Transmission system<br><span style='color: white; font-size: 1.1em;'>{trans}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>PTT<br><span style='color: white; font-size: 1.1em;'>{ptt}</span></td>
+                    </tr>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Owner<br><span style='color: white; font-size: 1.1em;'>{owner}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Data Centre<br><span style='color: #4FC3F7; font-size: 1.1em;'>{dc}</span></td>
+                    </tr>
+                    <tr>
+                        <td colspan='2' style='color: rgba(255,255,255,0.5);'>Sensors<br><span style='color: white; font-size: 0.95em;'>{sensors}</span></td>
+                    </tr>
+                </table>
+            </div>
+            <!-- Deployment -->
+            <div style='flex: 1; min-width: 250px; background: rgba(255,255,255,0.02); padding: 20px; border-radius: 12px; border: 1px solid rgba(255,255,255,0.05);'>
+                <h4 style='color: #4FC3F7; margin-top: 0; font-family: Outfit, sans-serif; border-bottom: 1px solid rgba(255,255,255,0.1); padding-bottom: 10px;'>Deployment</h4>
+                <table style='width: 100%; border: none; font-size: 0.85em; line-height: 1.5;'>
+                    <tr>
+                        <td colspan='2' style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Launched &nbsp; <span style='color: rgba(255,255,255,0.4);'>{age}</span><br><span style='color: white; font-size: 1.1em;'>{launch_date_fmt}</span></td>
+                    </tr>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Deployment Latitude<br><span style='color: white; font-size: 1.1em;'>{launch_lat}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Deployment Longitude<br><span style='color: white; font-size: 1.1em;'>{launch_lon}</span></td>
+                    </tr>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Ship<br><span style='color: white; font-size: 1.1em;'>frv sagar sampada</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Cruise<br><span style='color: white; font-size: 1.1em;'></span></td>
+                    </tr>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Project<br><span style='color: white; font-size: 1.1em;'>{project}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Principal Investigator<br><span style='color: white; font-size: 1.1em;'>{pi}</span></td>
+                    </tr>
+                </table>
+            </div>
+            <!-- Cycle activity -->
+            <div style='flex: 1; min-width: 250px; background: rgba(255,255,255,0.02); padding: 20px; border-radius: 12px; border: 1px solid rgba(255,255,255,0.05);'>
+                <h4 style='color: #4FC3F7; margin-top: 0; font-family: Outfit, sans-serif; border-bottom: 1px solid rgba(255,255,255,0.1); padding-bottom: 10px;'>Cycle activity</h4>
+                <table style='width: 100%; border: none; font-size: 0.85em; line-height: 1.5;'>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Status<br><span style='color: {status_color}; font-size: 1.1em; font-weight: bold;'>{status}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Age<br><span style='color: white; font-size: 1.1em;'>{cycle_age}</span></td>
+                    </tr>
+                    <tr>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Last profile date<br><span style='color: white; font-size: 1.1em;'>{last_date}</span></td>
+                        <td style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Cycle<br><span style='color: white; font-size: 1.1em;'>{cycle}</span></td>
+                    </tr>
+                    <tr>
+                        <td colspan='2' style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Last Surface Data<br><span style='color: white; font-size: 1.05em;'>{surf_data}</span></td>
+                    </tr>
+                    <tr>
+                        <td colspan='2' style='color: rgba(255,255,255,0.5); padding-bottom: 10px;'>Last Bottom Data<br><span style='color: white; font-size: 1.05em;'>{bott_data}</span></td>
+                    </tr>
+                </table>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("---")
+        st.markdown("#### Argo parameters section charts and overlaid profiles")
+        try:
+            import plot_utils
+            cycles, dates, pres, temp, psal, rho = plot_utils.get_valid_data(ds_prof)
+            
+            if len(pres) > 0:
+                c1, c2, c3 = st.columns(3)
+                with c1:
+                    fig = plot_utils.create_ts_diagram(cycles, temp, psal, wmo)
+                    st.pyplot(fig, clear_figure=True)
+                with c2:
+                    fig = plot_utils.create_section_chart(dates, pres, temp, "Temperature (°C)", "Section chart TEMP", wmo)
+                    st.pyplot(fig, clear_figure=True)
+                with c3:
+                    fig = plot_utils.create_section_chart(dates, pres, psal, "Salinity (PSU)", "Section chart PSAL", wmo)
+                    st.pyplot(fig, clear_figure=True)
+                    
+                c4, c5, c6 = st.columns(3)
+                with c4:
+                    fig = plot_utils.create_section_chart(dates, pres, rho, "Potential Density (kg/m³)", "Section chart RHO", wmo)
+                    st.pyplot(fig, clear_figure=True)
+                with c5:
+                    fig = plot_utils.create_overlaid_profiles(temp, pres, cycles, "Temperature (°C)", "Overlaid profiles TEMP", wmo)
+                    st.pyplot(fig, clear_figure=True)
+                with c6:
+                    fig = plot_utils.create_overlaid_profiles(psal, pres, cycles, "Salinity (PSU)", "Overlaid profiles PSAL", wmo)
+                    st.pyplot(fig, clear_figure=True)
+                    
+                c7, c8, c9 = st.columns(3)
+                with c7:
+                    fig = plot_utils.create_overlaid_profiles(rho, pres, cycles, "Potential Density (kg/m³)", "Overlaid profiles RHO", wmo)
+                    st.pyplot(fig, clear_figure=True)
+            else:
+                st.info("No valid profile data available for technical plots.")
+        except Exception as e:
+            st.error(f"Error rendering technical plots: {e}")
+                
+
+    except Exception as e:
+        st.error(f"Error loading float details: {e}")
+
+
+# ==================== HEADER ====================
+_cache_path = CACHE_DIR / "profiles.parquet"
+_last_refresh = (
+    datetime.fromtimestamp(_cache_path.stat().st_mtime).strftime("%Y-%m-%d %H:%M")
+    if _cache_path.exists() else "N/A"
+)
+st.markdown(
+    f"""
+<div class="header-bar">
+    <h1>🌊 Indian ARGO CTD / BGC Dashboard</h1>
+    <p>Real-time visibility into the Indian Ocean ARGO float network · Data Source: IFREMER GDAC</p>
+    <div class="refresh-ts">Last data refresh: {_last_refresh} UTC</div>
+</div>
+""",
+    unsafe_allow_html=True,
+)
+
+# ==================== SIDEBAR FILTERS (PRD §6) ====================
+# Read URL query params for shareable filter state
+qp = st.query_params
+
+with st.sidebar:
+    st.markdown("## 🔍 Filters")
+
+    # ── Refresh ──
+    if st.button("🔄 Refresh Data", use_container_width=True, type="primary"):
+        for f in CACHE_DIR.glob("*.parquet"):
+            f.unlink()
+        st.cache_data.clear()
+        st.rerun()
+
+    st.markdown("---")
+
+    # ── WMO search ──
+    search_wmo = st.text_input(
+        "🔎 Search WMO Float ID",
+        value=qp.get("wmo", ""),
+        placeholder="e.g. 2902115, 2902116",
+        help="Comma-separated WMO numbers",
+    )
+
+    # ── QC Mode ──
+    _qc_options = ["All", "Delayed", "Real time"]
+    _qc_default = _qc_options.index(qp.get("qc", "All")) if qp.get("qc", "All") in _qc_options else 0
+    qc_mode = st.selectbox(
+        "QC Mode",
+        _qc_options,
+        index=_qc_default,
+        help="All = all data; Delayed = quality-checked; Real time = latest",
+    )
+
+    # ── Community ──
+    st.markdown("### Community")
+    comm_all = st.checkbox("ALL", value=qp.get("comm_all", "1") == "1", key="comm_all")
+    comm_null = st.checkbox("NULL", value=qp.get("comm_null", "0") == "1", key="comm_null")
+    comm_argos = st.checkbox("ARGOS", value=qp.get("comm_argos", "0") == "1", key="comm_argos")
+    comm_beidou = st.checkbox("BEIDOU", value=qp.get("comm_beidou", "0") == "1", key="comm_beidou")
+    comm_iridium = st.checkbox("IRIDIUM", value=qp.get("comm_iridium", "0") == "1", key="comm_iridium")
+
+    # ── Network ──
+    st.markdown("### Network")
+    net_all = st.checkbox("All (Inclusive)", value=qp.get("net_all", "1") == "1", key="net_all")
+    net_bgc = st.checkbox("BGC (Bio-Argo)", value=qp.get("net_bgc", "0") == "1", key="net_bgc")
+    net_ctd = st.checkbox("CTD (Core Argo)", value=qp.get("net_ctd", "0") == "1", key="net_ctd")
+    net_dep = st.checkbox("DEP (Deep Argo)", value=qp.get("net_dep", "0") == "1", key="net_dep")
+
+    # ── Float Model / Profiler Type ──
+    st.markdown("### Float Model")
+    _available_models = sorted(df_meta["profiler_name"].dropna().unique().tolist())
+    selected_profiler_types = st.multiselect(
+        "Select Float Model(s)",
+        options=_available_models,
+        default=[],
+        placeholder="All models (no filter)",
+        help="Filter by instrument model from metadata registry (WMO R08)",
+    )
+
+    # ── Map Options ──
+    st.markdown("### Map Options")
+    show_live_only = st.toggle("Live Floats Only (90d)", value=qp.get("live_only", "0") == "1", help="Hide historical dead floats to reduce map clutter")
+
+    # ── Date range ──
+    st.markdown("### Date Range")
+    d_col1, d_col2 = st.columns(2)
+    with d_col1:
+        _min_d = datetime(1960, 1, 1)
+        _max_d = datetime.now()
+        
+        # Determine default start date (earliest profile or 1960)
+        _default_start = _min_d
+        if "df_prof" in locals() and len(df_prof) > 0 and pd.notna(df_prof["date"].min()):
+            _default_start = df_prof["date"].min().to_pydatetime()
+
+        _sd = datetime.strptime(qp.get("sd", ""), "%Y-%m-%d") if "sd" in qp and qp.get("sd", "") else _default_start
+        start_date = st.date_input("Start", value=_sd, min_value=_min_d, max_value=_max_d)
+    with d_col2:
+        _ed = datetime.strptime(qp.get("ed", ""), "%Y-%m-%d") if "ed" in qp and qp.get("ed", "") else _max_d
+        end_date = st.date_input("End", value=_ed, min_value=_min_d, max_value=_max_d)
+
+    # ── Longitude ──
+    st.markdown("### Longitude")
+    _lon_lo = float(qp.get("lon_lo", "20.0"))
+    _lon_hi = float(qp.get("lon_hi", "145.0"))
+    lon_range = st.slider(
+        "Longitude range",
+        min_value=-180.0,
+        max_value=180.0,
+        value=(_lon_lo, _lon_hi),
+        step=0.5,
+        label_visibility="collapsed",
+    )
+
+    # ── Latitude ──
+    st.markdown("### Latitude")
+    _lat_lo = float(qp.get("lat_lo", "-70.1"))
+    _lat_hi = float(qp.get("lat_hi", "30.0"))
+    lat_range = st.slider(
+        "Latitude range",
+        min_value=-90.0,
+        max_value=90.0,
+        value=(_lat_lo, _lat_hi),
+        step=0.5,
+        label_visibility="collapsed",
+    )
+
+
+# ── Sync current filter state to URL query params ──
+st.query_params.update({
+    "wmo": search_wmo,
+    "qc": qc_mode,
+    "comm_all": "1" if comm_all else "0",
+    "comm_null": "1" if comm_null else "0",
+    "comm_argos": "1" if comm_argos else "0",
+    "comm_beidou": "1" if comm_beidou else "0",
+    "comm_iridium": "1" if comm_iridium else "0",
+    "net_all": "1" if net_all else "0",
+    "net_bgc": "1" if net_bgc else "0",
+    "net_ctd": "1" if net_ctd else "0",
+    "net_dep": "1" if net_dep else "0",
+    "sd": str(start_date),
+    "ed": str(end_date),
+    "lon_lo": str(lon_range[0]),
+    "lon_hi": str(lon_range[1]),
+    "lat_lo": str(lat_range[0]),
+    "lat_hi": str(lat_range[1]),
+    "live_only": "1" if show_live_only else "0",
+})
+
+# ==================== FILTER LOGIC (PRD §6.1) ====================
+def apply_filters(df, *, is_bio=False):
+    """Apply every sidebar filter to *df* and return the filtered copy."""
+    out = df.copy()
+
+    # Date
+    if "date" in out.columns:
+        out = out[
+            (out["date"] >= pd.Timestamp(start_date))
+            & (out["date"] <= pd.Timestamp(end_date))
+        ]
+
+    # Lon / Lat
+    if "longitude" in out.columns:
+        out = out[
+            (out["longitude"] >= lon_range[0]) & (out["longitude"] <= lon_range[1])
+        ]
+    if "latitude" in out.columns:
+        out = out[
+            (out["latitude"] >= lat_range[0]) & (out["latitude"] <= lat_range[1])
+        ]
+
+    # Network Logic — only apply to core profiles (bio df lacks is_bgc/is_deep)
+    if not net_all and not is_bio and "is_bgc" in out.columns and "is_deep" in out.columns:
+        masks = []
+        if net_bgc:
+            masks.append(out["is_bgc"])
+        if net_ctd:
+            # Core = NOT BGC and NOT Deep
+            masks.append(~out["is_bgc"] & ~out["is_deep"])
+        if net_dep:
+            masks.append(out["is_deep"])
+        
+        if masks:
+            combined_mask = masks[0]
+            for m in masks[1:]:
+                combined_mask |= m
+            out = out[combined_mask]
+        elif not (net_bgc or net_ctd or net_dep):
+             # If nothing selected and All is off, show nothing
+             out = out.iloc[0:0]
+
+    # WMO search
+    if search_wmo.strip():
+        wmo_list = [w.strip() for w in search_wmo.split(",") if w.strip()]
+        out = out[out["wmo_id"].isin(wmo_list)]
+
+    # Community Logic
+    if not comm_all and "positioning_system" in out.columns:
+        masks = []
+        if comm_null:
+            masks.append(out["positioning_system"].isna() | (out["positioning_system"] == ""))
+        if comm_argos:
+            masks.append(out["positioning_system"].fillna("").str.upper().str.contains("ARGOS"))
+        if comm_beidou:
+            masks.append(out["positioning_system"].fillna("").str.upper().str.contains("BEIDOU"))
+        if comm_iridium:
+            masks.append(out["positioning_system"].fillna("").str.upper().str.contains("IRIDIUM"))
+        
+        if masks:
+            combined_mask = masks[0]
+            for m in masks[1:]:
+                combined_mask |= m
+            out = out[combined_mask]
+        elif not (comm_null or comm_argos or comm_beidou or comm_iridium):
+            out = out.iloc[0:0]
+
+    # QC mode (bio only)
+    if is_bio and "parameter_data_mode" in out.columns:
+        if qc_mode == "Delayed":
+            out = out[out["parameter_data_mode"].fillna("").str.contains("D")]
+        elif qc_mode == "Real time":
+            out = out[~out["parameter_data_mode"].fillna("").str.contains("D")]
+
+    # Profiler Type / Float Model filter (from meta enrichment)
+    if selected_profiler_types and "profiler_name" in out.columns:
+        out = out[out["profiler_name"].isin(selected_profiler_types)]
+
+    return out
+
+
+filt_prof = apply_filters(df_prof)
+filt_bio = apply_filters(df_bio, is_bio=True)
+
+# ================================================================
+#  FLEET OVERVIEW KPI ROW (from meta registry)
+# ================================================================
+_total_registered = len(df_meta)
+_total_profiled = df_meta["wmo_id"].isin(df_prof["wmo_id"].unique()).sum()
+_never_profiled = _total_registered - _total_profiled
+_unique_models = df_meta["profiler_name"].nunique()
+
+st.markdown("### 🛰️ Fleet Overview (from Metadata Registry)")
+fo1, fo2, fo3, fo4 = st.columns(4)
+for col, label, value, color, icon in [
+    (fo1, "Registered Floats", _total_registered, "#00BCD4", "📋"),
+    (fo2, "Profiled Floats", _total_profiled, "#8BC34A", "✅"),
+    (fo3, "Never Profiled", _never_profiled, "#FF5722", "⚠️"),
+    (fo4, "Float Models", _unique_models, "#9C27B0", "🔧"),
+]:
+    with col:
+        st.markdown(
+            f"""
+            <div class="kpi-tile" style="border-bottom: 4px solid {color} !important;">
+                <div class="kpi-label">{icon} {label}</div>
+                <div class="kpi-value">{value:,}</div>
+                <div style="font-size: 10px; color: rgba(255,255,255,0.4); margin-top: 4px;">META REGISTRY</div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+# ================================================================
+#  ROW 1 — MAP (left ~55 %) + BAR CHART & KPIs (right ~45 %)
+# ================================================================
+col_left, col_right = st.columns([55, 45], gap="medium")
+
+with col_left:
+    # ── Component 1: Geospatial Float Position Map (PRD §7.1) ──
+    st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+    st.markdown("### 📍 Geographic Float Positions")
+
+    if len(filt_prof) > 0:
+        # --- Check map selection from session state ---
+        selected_wmo_from_map = None
+        if "main_map" in st.session_state:
+            sel = st.session_state.main_map
+            if sel and "selection" in sel and "points" in sel["selection"] and len(sel["selection"]["points"]) > 0:
+                pt = sel["selection"]["points"][0]
+                if "customdata" in pt and len(pt["customdata"]) > 0:
+                    selected_wmo_from_map = str(pt["customdata"][0])
+        
+        is_sidebar_search = bool(search_wmo.strip())
+        is_wmo_searched = is_sidebar_search or bool(selected_wmo_from_map)
+
+        # Apply Live-Only filter if toggled and not searching specific WMOs
+        map_source = filt_prof.copy()
+        
+        # If user clicked a float on the map, filter source to just that float
+        if selected_wmo_from_map:
+            map_source = map_source[map_source["wmo_id"] == selected_wmo_from_map]
+
+        if show_live_only and not is_wmo_searched:
+            latest_d = map_source["date"].max()
+            ninety_days_ago = latest_d - timedelta(days=90)
+            # Find WMOs that have a profile in the last 90 days
+            live_wmos = map_source[map_source["date"] >= ninety_days_ago]["wmo_id"].unique()
+            map_source = map_source[map_source["wmo_id"].isin(live_wmos)]
+
+        if is_wmo_searched:
+            # Check if this float is newly selected from map to show dialog
+            if selected_wmo_from_map:
+                if st.session_state.get("last_viewed_wmo") != selected_wmo_from_map:
+                    st.session_state["last_viewed_wmo"] = selected_wmo_from_map
+                    show_float_details(selected_wmo_from_map)
+                
+            # Show full trajectory for specific floats
+            map_df = (
+                map_source.dropna(subset=["latitude", "longitude"])
+                .sort_values(["wmo_id", "date"])
+                .copy()
+            )
+            # Add a profile sequence number for each float
+            map_df["profile_seq"] = map_df.groupby("wmo_id").cumcount() + 1
+            
+            fig_map = go.Figure()
+            for wmo, group in map_df.groupby("wmo_id"):
+                inst = group["institution"].iloc[0]
+                color = REGION_COLORS.get(inst, "#ff0000")
+                fig_map.add_trace(go.Scattermapbox(
+                    lat=group["latitude"].tolist(),
+                    lon=group["longitude"].tolist(),
+                    mode="lines+markers+text",
+                    text=group["profile_seq"].astype(str).tolist(),
+                    customdata=[[wmo]] * len(group),
+                    textposition="top right",
+                    textfont=dict(size=11, color="white"),
+                    marker=dict(size=7, color=color, opacity=0.9),
+                    line=dict(width=2, color=color),
+                    name=str(wmo),
+                    hoverinfo="text",
+                    hovertext=group.apply(lambda r: f"WMO: {wmo}<br>Date: {r['date']}<br>Lat: {r['latitude']:.2f}, Lon: {r['longitude']:.2f}<br>Profile: {r['profile_seq']}", axis=1).tolist()
+                ))
+            
+            center_lat = float(map_df["latitude"].mean()) if len(map_df) > 0 else 0.0
+            center_lon = float(map_df["longitude"].mean()) if len(map_df) > 0 else 0.0
+            
+            fig_map.update_layout(
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                margin=dict(l=0, r=0, t=0, b=0),
+                mapbox=dict(
+                    style="carto-darkmatter",
+                    center=dict(lat=center_lat, lon=center_lon), 
+                    zoom=4
+                ),
+                legend=dict(
+                    title="WMO ID",
+                    bgcolor="rgba(10,14,39,0.85)",
+                    bordercolor="rgba(0,188,212,0.18)",
+                    borderwidth=1,
+                    font=dict(size=11, color="#c8d6e5"),
+                    yanchor="bottom",
+                    y=0.01,
+                    xanchor="left",
+                    x=0.01,
+                )
+            )
+        else:
+            # Latest position per float (one marker per WMO)
+            map_df = (
+                map_source.dropna(subset=["latitude", "longitude"])
+                .sort_values("date")
+                .groupby("wmo_id")
+                .tail(1)
+                .copy()
+            )
+
+            # Cap at 12 000 for browser performance
+            if len(map_df) > 12_000:
+                map_df = map_df.sample(12_000, random_state=42)
+
+            fig_map = px.scatter_mapbox(
+                map_df,
+                lat="latitude",
+                lon="longitude",
+                color="institution",
+                color_discrete_map=REGION_COLORS,
+                hover_name="wmo_id",
+                custom_data=["wmo_id"],
+                hover_data={
+                    "institution": True,
+                    "date": True,
+                    "latitude": ":.2f",
+                    "longitude": ":.2f",
+                },
+                zoom=2,
+                center={"lat": -10, "lon": 80},
+                category_orders={"institution": list(REGION_COLORS.keys())},
+            )
+            fig_map.update_traces(marker=dict(size=8, opacity=0.9))
+            fig_map.update_layout(
+                mapbox_style="carto-darkmatter",
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                margin=dict(l=0, r=0, t=0, b=0),
+                legend=dict(
+                    title="Region",
+                    bgcolor="rgba(10,14,39,0.85)",
+                    bordercolor="rgba(0,188,212,0.18)",
+                    borderwidth=1,
+                    font=dict(size=11, color="#c8d6e5"),
+                    yanchor="bottom",
+                    y=0.01,
+                    xanchor="left",
+                    x=0.01,
+                    orientation="h",
+                ),
+            )
+            
+        fig_map.update_layout(height=620)
+        st.plotly_chart(fig_map, use_container_width=True, key="main_map", on_select="rerun", config={"toImageButtonOptions": {"format": "png", "scale": 2, "filename": "argo_float_map"}})
+        
+        if selected_wmo_from_map:
+            if st.button(f"📄 View Info for Float {selected_wmo_from_map}"):
+                show_float_details(selected_wmo_from_map)
+        elif is_sidebar_search and len([w for w in search_wmo.split(",") if w.strip()]) == 1:
+            searched_id = search_wmo.strip()
+            if st.button(f"📄 View Info for Float {searched_id}"):
+                show_float_details(searched_id)
+
+        if is_wmo_searched:
+            st.caption(f"📌 {len(map_df['wmo_id'].unique()):,} floats displayed with full trajectory ({len(map_df):,} total profiles)")
+        else:
+            st.caption(f"📌 {len(map_df):,} unique floats displayed")
+    else:
+        st.info("No float data for current filters.")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ── Component 2 + 3: Bar chart + KPI tiles ──
+with col_right:
+    st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+    # ── Bar chart (PRD §7.2) ──
+    st.markdown("### 📈 Number of Floats per DAC")
+
+    if len(filt_prof) > 0 and "dac" in filt_prof.columns:
+        # Active floats in the last 90 days of each year
+        latest_ds_date = filt_prof["date"].max()
+        res = []
+        years = sorted(filt_prof["year"].dropna().unique())
+        for y in years:
+            if y == latest_ds_date.year:
+                end_of_year = latest_ds_date
+            else:
+                end_of_year = pd.Timestamp(f"{int(y)}-12-31")
+            
+            start_period = end_of_year - pd.Timedelta(days=90)
+            active_df = filt_prof[(filt_prof["date"] >= start_period) & (filt_prof["date"] <= end_of_year)]
+            active_floats = active_df.drop_duplicates(subset=["wmo_id"])
+            
+            for dac, count in active_floats["dac"].value_counts().items():
+                res.append({"Year": int(y), "DAC": dac, "Count": count})
+        yearly = pd.DataFrame(res)
+        if len(yearly) > 0:
+            yearly["Year"] = yearly["Year"].astype(int)
+            yearly = yearly.sort_values(["Year", "Count"], ascending=[True, False])
+            totals = yearly.groupby("Year")["Count"].sum().reset_index()
+
+            # Professional DAC Color Mapping
+            DAC_COLORS = {
+                "aoml": "#4FC3F7", "coriolis": "#FF7043", "kiost": "#26A69A",
+                "meds": "#BA68C8", "csiro": "#FFB74D", "jma": "#00BCD4",
+                "incois": "#F06292", "csio": "#9CCC65", "bodc": "#9575CD",
+                "kma": "#FFD54F", "nmdis": "#90A4AE",
+            }
+
+            fig_bar = px.bar(
+                yearly,
+                x="Year",
+                y="Count",
+                color="DAC",
+                color_discrete_map=DAC_COLORS,
+                category_orders={"Year": sorted(yearly["Year"].unique())}
+            )
+            
+            fig_bar.update_traces(
+                marker_line_width=0,
+                hovertemplate="<b>%{x}</b><br>DAC: %{fullData.name}<br>Floats: %{y:,}<extra></extra>"
+            )
+
+            fig_bar.add_trace(go.Scatter(
+                x=totals["Year"],
+                y=totals["Count"],
+                mode="text",
+                text=totals["Count"],
+                textposition="top center",
+                textfont=dict(size=10, color="#ffffff", family="Outfit"),
+                showlegend=False,
+                hoverinfo="skip"
+            ))
+
+            fig_bar.update_layout(
+                **_dark_layout(
+                    height=420,
+                    barmode="stack",
+                    xaxis=dict(title="", type="category", tickangle=-45, gridcolor="rgba(255,255,255,0.03)"),
+                    yaxis=dict(title="Active Floats", gridcolor="rgba(255,255,255,0.05)", zeroline=False),
+                    legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1, title=None, font=dict(size=10)),
+                    bargap=0.3,
+                    margin=dict(l=50, r=20, t=80, b=40),
+                )
+            )
+            st.plotly_chart(fig_bar, use_container_width=True, key="bar_chart", config={"toImageButtonOptions": {"format": "png", "scale": 2, "filename": "argo_annual_floats"}})
+        else:
+            st.info("No active float data for bar chart.")
+    else:
+        st.info("No data for bar chart.")
+
+    # ── KPI tiles (PRD §7.3) ──
+    st.markdown("### 🧪 BGC Profile Counts")
+
+    doxy_n = int(filt_bio["has_doxy"].sum()) if len(filt_bio) > 0 else 0
+    chla_n = int(filt_bio["has_chla"].sum()) if len(filt_bio) > 0 else 0
+    nit_n = int(filt_bio["has_nitrate"].sum()) if len(filt_bio) > 0 else 0
+    ph_n = int(filt_bio["has_ph"].sum()) if len(filt_bio) > 0 else 0
+
+    k1, k2, k3, k4 = st.columns(4)
+    for col, label, value, color in [
+        (k1, "DOXY", doxy_n, KPI_COLORS["DOXY"]),
+        (k2, "Chla", chla_n, KPI_COLORS["Chla"]),
+        (k3, "Nitrate", nit_n, KPI_COLORS["Nitrate"]),
+        (k4, "pH", ph_n, KPI_COLORS["pH"]),
+    ]:
+        with col:
+            st.markdown(
+                f"""
+                <div class="kpi-tile" style="border-bottom: 4px solid {color} !important;" role="status" aria-label="{label}: {value:,} profiles">
+                    <div class="kpi-label">{label}</div>
+                    <div class="kpi-value">{value:,}</div>
+                    <div style="font-size: 10px; color: rgba(255,255,255,0.4); margin-top: 4px;">PROFILES</div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ================================================================
+#  ROW 2 — TREEMAP (left) + DONUT (right)
+# ================================================================
+st.markdown("---")
+col_tree, col_donut = st.columns(2, gap="medium")
+# ── Component 4: Active Floats & Profiles last 1 day ──
+with col_tree:
+    st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+    st.markdown("### 📊 Active Floats & Profiles — Last 1 Day")
+
+    if len(filt_prof) > 0:
+        latest_date = filt_prof["date"].max()
+        one_day_ago = pd.Timestamp(latest_date - timedelta(days=1))
+        last1 = filt_prof[filt_prof["date"] >= one_day_ago].copy()
+
+        if len(last1) > 0:
+            tree_data = (
+                last1.groupby("institution")
+                .agg(floats=("wmo_id", "nunique"), profiles=("file", "count"))
+                .reset_index()
+            )
+
+            total_f1 = int(tree_data["floats"].sum())
+            total_p1 = int(tree_data["profiles"].sum())
+
+            # Summary card
+            st.markdown(
+                f"""
+                <div class="treemap-info">
+                    <h3>All Communities</h3>
+                    <div style="display:flex;justify-content:space-around;">
+                        <div><div class="stat">{total_f1:,}</div>
+                             <div class="stat-label">Active Floats</div></div>
+                        <div><div class="stat">{total_p1:,}</div>
+                             <div class="stat-label">Profiles</div></div>
+                    </div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+            # Treemap
+            fig_tree = px.treemap(
+                tree_data,
+                path=["institution"],
+                values="profiles",
+                color="profiles",
+                color_continuous_scale=[
+                    [0, "#1a2744"],
+                    [0.5, "#1e3a5f"],
+                    [1.0, "#2C5F8A"],
+                ],
+                hover_data=["floats", "profiles"],
+                height=340,
+            )
+            fig_tree.update_traces(
+                textinfo="label+value",
+                textfont=dict(size=14, color="white"),
+                marker=dict(line=dict(width=2, color="#0a0e27"), cornerradius=5),
+                hovertemplate=(
+                    "<b>%{label}</b><br>"
+                    "Profiles: %{value:,}<br>"
+                    "Floats: %{customdata[0]:,}<extra></extra>"
+                ),
+            )
+            fig_tree.update_layout(
+                **_dark_layout(margin=dict(l=0, r=0, t=10, b=0)),
+                coloraxis_showscale=False,
+            )
+            st.plotly_chart(fig_tree, use_container_width=True, key="treemap", config={"toImageButtonOptions": {"format": "png", "scale": 2, "filename": "argo_last1day_treemap"}})
+        else:
+            st.info("No active floats in the last 1 day for current filters.")
+    else:
+        st.info("No data available.")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ── Component 5: Float Age Donut (PRD §7.5) ──
+with col_donut:
+    st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+    st.markdown("### 🕐 Float Age Distribution")
+
+    if len(filt_prof) > 0:
+        # Only calculate age for active floats (reported in the last 90 days)
+        latest_ds_date = filt_prof["date"].max()
+        ninety_days_ago = pd.Timestamp(latest_ds_date - timedelta(days=90))
+        
+        float_last = filt_prof.dropna(subset=["date"]).groupby("wmo_id")["date"].max().reset_index()
+        active_wmos = float_last[float_last["date"] >= ninety_days_ago]["wmo_id"]
+        
+        active_prof = filt_prof[filt_prof["wmo_id"].isin(active_wmos)]
+        
+        # Use earliest profile date per active float as proxy for launch date
+        float_first = (
+            active_prof.dropna(subset=["date"])
+            .groupby("wmo_id")["date"]
+            .min()
+            .reset_index()
+        )
+        float_first["age_years"] = (
+            (pd.Timestamp.now() - float_first["date"]).dt.days / 365.25
+        )
+
+        bins = [0, 3, 6, 9, 12, 999]
+        labels = ["00-02", "03-05", "06-08", "09-11", "12+"]
+        float_first["age_group"] = pd.cut(
+            float_first["age_years"], bins=bins, labels=labels, right=False
+        )
+
+        age_counts = float_first["age_group"].value_counts().reset_index()
+        age_counts.columns = ["Age Group", "Count"]
+        age_counts["Age Group"] = pd.Categorical(
+            age_counts["Age Group"], categories=labels, ordered=True
+        )
+        age_counts = age_counts.sort_values("Age Group")
+        age_counts = age_counts[age_counts["Count"] > 0]
+
+        if len(age_counts) > 0:
+            fig_donut = px.pie(
+                age_counts,
+                values="Count",
+                names="Age Group",
+                hole=0.45,
+                color="Age Group",
+                color_discrete_map=AGE_COLORS,
+                height=420,
+            )
+            fig_donut.update_traces(
+                textinfo="label+percent",
+                textposition="outside",
+                textfont=dict(size=12, color="#c8d6e5"),
+                pull=[0.02] * len(age_counts),
+                hovertemplate=(
+                    "<b>%{label}</b><br>"
+                    "Count: %{value:,}<br>"
+                    "Percent: %{percent}<extra></extra>"
+                ),
+                marker=dict(line=dict(color="#0a0e27", width=2)),
+            )
+            fig_donut.update_layout(
+                **_dark_layout(margin=dict(l=20, r=80, t=10, b=20)),
+                legend=dict(
+                    title="Age Group",
+                    orientation="v",
+                    yanchor="middle",
+                    y=0.5,
+                    xanchor="left",
+                    x=1.05,
+                    font=dict(size=12, color="#c8d6e5"),
+                    bgcolor="rgba(0,0,0,0)",
+                ),
+            )
+            st.plotly_chart(fig_donut, use_container_width=True, key="donut", config={"toImageButtonOptions": {"format": "png", "scale": 2, "filename": "argo_age_distribution"}})
+        else:
+            st.info("No age data available.")
+    else:
+        st.info("No data available.")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ================================================================
+#  ROW 2.5 — PROFILER TYPE DONUT (left) + FLEET COMPOSITION (right)
+#  Data source: ar_index_global_meta.txt
+# ================================================================
+st.markdown("---")
+col_profiler, col_fleet = st.columns(2, gap="medium")
+
+# ── Profiler Type / Instrument Breakdown Donut ──
+with col_profiler:
+    st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+    st.markdown("### 🔧 Float Instrument Types (Meta Registry)")
+
+    if len(df_meta) > 0:
+        ptype_counts = df_meta["profiler_name"].value_counts().reset_index()
+        ptype_counts.columns = ["Model", "Count"]
+
+        # Group small categories into "Other" for readability
+        top_n = 10
+        if len(ptype_counts) > top_n:
+            top = ptype_counts.head(top_n)
+            other_count = ptype_counts.iloc[top_n:]["Count"].sum()
+            other_row = pd.DataFrame([{"Model": "Other", "Count": other_count}])
+            ptype_counts = pd.concat([top, other_row], ignore_index=True)
+
+        fig_ptype = px.pie(
+            ptype_counts,
+            values="Count",
+            names="Model",
+            hole=0.45,
+            color="Model",
+            color_discrete_map=PROFILER_COLORS,
+            height=420,
+        )
+        fig_ptype.update_traces(
+            textinfo="label+percent",
+            textposition="outside",
+            textfont=dict(size=11, color="#c8d6e5"),
+            pull=[0.02] * len(ptype_counts),
+            hovertemplate=(
+                "<b>%{label}</b><br>"
+                "Floats: %{value:,}<br>"
+                "Share: %{percent}<extra></extra>"
+            ),
+            marker=dict(line=dict(color="#0a0e27", width=2)),
+        )
+        fig_ptype.update_layout(
+            **_dark_layout(margin=dict(l=20, r=80, t=10, b=20)),
+            legend=dict(
+                title="Instrument",
+                orientation="v",
+                yanchor="middle",
+                y=0.5,
+                xanchor="left",
+                x=1.05,
+                font=dict(size=11, color="#c8d6e5"),
+                bgcolor="rgba(0,0,0,0)",
+            ),
+        )
+        st.plotly_chart(fig_ptype, use_container_width=True, key="profiler_donut", config={"toImageButtonOptions": {"format": "png", "scale": 2, "filename": "argo_profiler_types"}})
+        st.caption(f"📋 {len(df_meta):,} floats across {df_meta['profiler_name'].nunique()} instrument models (source: ar_index_global_meta.txt)")
+    else:
+        st.info("No metadata available.")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ── Fleet Composition Stacked Area Chart ──
+with col_fleet:
+    st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+    st.markdown("### 📊 Fleet Composition Over Time")
+
+    if len(filt_prof) > 0 and "profiler_name" in filt_prof.columns:
+        # Get the deployment year per float (earliest profile date)
+        float_deploy = (
+            filt_prof.dropna(subset=["date"])
+            .groupby("wmo_id")
+            .agg(deploy_year=("year", "min"), profiler_name=("profiler_name", "first"))
+            .reset_index()
+        )
+
+        if len(float_deploy) > 0:
+            # Count deployments by year and profiler type
+            comp = float_deploy.groupby(["deploy_year", "profiler_name"]).size().reset_index(name="Count")
+
+            # Keep only top N models, group rest as "Other"
+            top_models = float_deploy["profiler_name"].value_counts().head(8).index.tolist()
+            comp["Model"] = comp["profiler_name"].where(comp["profiler_name"].isin(top_models), "Other")
+            comp = comp.groupby(["deploy_year", "Model"])["Count"].sum().reset_index()
+            comp = comp.sort_values("deploy_year")
+
+            fig_fleet = px.area(
+                comp,
+                x="deploy_year",
+                y="Count",
+                color="Model",
+                color_discrete_map=PROFILER_COLORS,
+                height=420,
+            )
+            fig_fleet.update_traces(
+                line=dict(width=0.5),
+                hovertemplate="<b>%{fullData.name}</b><br>Year: %{x}<br>Floats: %{y:,}<extra></extra>",
+            )
+            fig_fleet.update_layout(
+                **_dark_layout(
+                    xaxis=dict(title="Deployment Year", gridcolor="rgba(255,255,255,0.03)"),
+                    yaxis=dict(title="Floats Deployed", gridcolor="rgba(255,255,255,0.05)", zeroline=False),
+                    legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1, title=None, font=dict(size=10)),
+                    margin=dict(l=50, r=20, t=60, b=40),
+                ),
+            )
+            st.plotly_chart(fig_fleet, use_container_width=True, key="fleet_composition", config={"toImageButtonOptions": {"format": "png", "scale": 2, "filename": "argo_fleet_composition"}})
+            st.caption("Shows how the fleet instrument mix has evolved per deployment year")
+        else:
+            st.info("No deployment data available.")
+    else:
+        st.info("No data available.")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ================================================================
+#  ROW 3 — DAC / Institution Summary Tables (PRD §7.6)
+# ================================================================
+st.markdown("---")
+col_dac1, col_dac2 = st.columns(2, gap="medium")
+
+if len(filt_prof) > 0:
+    dac_profs = (
+        filt_prof.groupby("institution")
+        .agg(Profiles=("file", "count"))
+        .reset_index()
+    )
+    dac_floats = df_meta.groupby("institution").agg(Floats=("wmo_id", "nunique")).reset_index()
+    dac = pd.merge(dac_floats, dac_profs, on="institution", how="left").fillna(0)
+    dac = dac.sort_values("Profiles", ascending=False)
+    
+    dacs = dac["institution"].tolist()
+    header = "".join(f"<th>{d}</th>" for d in dacs)
+    floats_cells = "".join(f"<td>{int(r):,}</td>" for r in dac["Floats"])
+    profs_cells = "".join(f"<td>{int(r):,}</td>" for r in dac["Profiles"])
+
+    with col_dac1:
+        st.markdown("### 🏢 DAC / Institution Summary")
+        st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+        st.markdown(
+            f"""
+            <div style="overflow-x:auto;">
+            <table class="dac-table">
+                <thead><tr><th>Metric</th>{header}</tr></thead>
+                <tbody>
+                    <tr><td>Floats</td>{floats_cells}</tr>
+                    <tr><td>Profiles</td>{profs_cells}</tr>
+                </tbody>
+            </table>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    with col_dac2:
+        st.markdown("### 📡 Float Status Summary")
+        latest_date = filt_prof["date"].max()
+        ninety_days_ago = pd.Timestamp(latest_date - timedelta(days=90))
+        float_latest = filt_prof.dropna(subset=["date"]).groupby(["institution", "wmo_id"])["date"].max().reset_index()
+        float_latest["is_live"] = float_latest["date"] >= ninety_days_ago
+        
+        live_df = float_latest.groupby("institution").agg(
+            live_floats=("is_live", "sum")
+        ).reset_index()
+        
+        status_df = pd.merge(dac_floats.rename(columns={"Floats": "total_count"}), live_df, on="institution", how="left").fillna(0)
+        status_df["dead_floats"] = status_df["total_count"] - status_df["live_floats"]
+        status_df = status_df.set_index("institution").reindex(dacs).reset_index().fillna(0)
+        
+        # Dominant instrument per institution from meta registry
+        _inst_top_model = (
+            df_meta.groupby("institution")["profiler_name"]
+            .agg(lambda x: x.value_counts().index[0] if len(x) > 0 else "—")
+        )
+        
+        header2 = "".join(f"<th>{d}</th>" for d in status_df["institution"])
+        total_cells = "".join(f"<td>{int(r):,}</td>" for r in status_df["total_count"])
+        live_cells = "".join(f"<td>{int(r):,}</td>" for r in status_df["live_floats"])
+        dead_cells = "".join(f"<td>{int(r):,}</td>" for r in status_df["dead_floats"])
+        model_cells = "".join(
+            f"<td style='font-size:0.75rem;color:#BA68C8;'>{_inst_top_model.get(d, '—')}</td>"
+            for d in status_df["institution"]
+        )
+        
+        st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+        st.markdown(
+            f"""
+            <div style="overflow-x:auto;">
+            <table class="dac-table">
+                <thead><tr><th>Status</th>{header2}</tr></thead>
+                <tbody>
+                    <tr><td>Total Count</td>{total_cells}</tr>
+                    <tr><td>Live Floats</td>{live_cells}</tr>
+                    <tr><td>Dead Floats</td>{dead_cells}</tr>
+                    <tr><td>Top Model</td>{model_cells}</tr>
+                </tbody>
+            </table>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+        st.markdown('</div>', unsafe_allow_html=True)
+else:
+    st.info("No data available for summary tables.")
+
+# ================================================================
+#  ROW 4 — INCOIS Deployment Matrix (Month vs Year)
+# ================================================================
+st.markdown("---")
+st.markdown("### 🗓️ INCOIS Float Deployments (Month vs Year)")
+
+if len(df_prof) > 0:
+    incois_df = df_prof[df_prof["institution"] == "IN"]
+    if len(incois_df) > 0:
+        # Find the deployment date (earliest profile date per float)
+        deployments = incois_df.groupby("wmo_id")["date"].min().reset_index()
+        
+        # Merge with all registered INCOIS floats to capture ones that haven't profiled
+        meta_in = df_meta[df_meta["institution"] == "IN"].copy()
+        merged = pd.merge(meta_in, deployments, on="wmo_id", how="left")
+        
+        # If float hasn't profiled, fallback to metadata registration date (date_update)
+        merged["date_update"] = pd.to_datetime(merged["date_update"], format="%Y%m%d%H%M%S", errors='coerce')
+        merged["date_final"] = merged["date"].fillna(merged["date_update"])
+        
+        merged["Year"] = merged["date_final"].dt.year
+        merged["Month"] = merged["date_final"].dt.month
+        
+        # Create a pivot table: Months as rows, Years as columns
+        pivot = merged.pivot_table(
+            index="Month", 
+            columns="Year", 
+            values="wmo_id", 
+            aggfunc="count", 
+            fill_value=0
+        )
+        
+        # Ensure all 12 months are displayed
+        all_months = range(1, 13)
+        pivot = pivot.reindex(all_months, fill_value=0)
+        
+        month_names = {
+            1: "Jan", 2: "Feb", 3: "Mar", 4: "Apr", 5: "May", 6: "Jun",
+            7: "Jul", 8: "Aug", 9: "Sep", 10: "Oct", 11: "Nov", 12: "Dec"
+        }
+        pivot.index = pivot.index.map(month_names)
+        
+        # Calculate Row and Column Totals
+        pivot["Total"] = pivot.sum(axis=1)
+        pivot.loc["Total"] = pivot.sum(axis=0)
+        
+        total_in_floats = int(pivot.loc["Total", "Total"])
+        
+        st.markdown(f"<p style='color: #c8d6e5; font-size: 1rem;'>Total INCOIS Floats Registered: <strong style='color: #00BCD4; font-size: 1.2rem;'>{total_in_floats:,}</strong></p>", unsafe_allow_html=True)
+        
+        st.markdown('<div class="stPlotlyChart">', unsafe_allow_html=True)
+        
+        # Build HTML for the table
+        header_html = "<th>Month</th>" + "".join([f"<th>{y if isinstance(y, str) else int(y)}</th>" for y in pivot.columns])
+        
+        body_html = ""
+        for month in pivot.index:
+            is_total_row = (month == "Total")
+            row_bg = "background: rgba(0,188,212,0.06);" if is_total_row else ""
+            row_html = f"<td style='font-weight:bold; color:#00BCD4;'>{month}</td>"
+            for col in pivot.columns:
+                val = pivot.loc[month, col]
+                val_str = f"{int(val):,}" if val > 0 else "<span style='color:rgba(255,255,255,0.2)'>-</span>"
+                
+                is_total_col = (col == "Total")
+                style = ""
+                if is_total_row or is_total_col:
+                    style = "font-weight:bold; color:#FFB74D;"
+                # Highlight Pending column slightly
+                if col == "Pending" and val > 0:
+                    style += " color:#EF5350;"
+                    
+                row_html += f"<td style='{style}'>{val_str}</td>"
+            body_html += f"<tr style='{row_bg}'>{row_html}</tr>"
+            
+        st.markdown(
+            f'''
+            <div style="overflow-x:auto;">
+            <table class="dac-table" style="width:100%; text-align:center;">
+                <thead><tr>{header_html}</tr></thead>
+                <tbody>
+                    {body_html}
+                </tbody>
+            </table>
+            </div>
+            ''',
+            unsafe_allow_html=True
+        )
+        st.markdown('</div>', unsafe_allow_html=True)
+    else:
+        st.info("No INCOIS deployment data found.")
+else:
+    st.info("No data available for deployment matrix.")
+
+
+# ================================================================
+#  RAW DATA VIEWER (bonus — not in PRD but useful for ops)
+# ================================================================
+st.markdown("---")
+with st.expander("📋 View Raw Data", expanded=False):
+    tab1, tab2, tab3 = st.tabs(["Core Profiles", "BGC Profiles", "Float Metadata"])
+    with tab1:
+        st.dataframe(
+            filt_prof.head(200), use_container_width=True, hide_index=True
+        )
+        st.caption(
+            f"Showing {min(200, len(filt_prof)):,} of {len(filt_prof):,} records"
+        )
+        st.download_button(
+            "⬇️ Download Filtered Core Profiles (CSV)",
+            data=filt_prof.to_csv(index=False),
+            file_name="argo_core_profiles_filtered.csv",
+            mime="text/csv",
+            key="dl_core",
+        )
+    with tab2:
+        st.dataframe(
+            filt_bio.head(200), use_container_width=True, hide_index=True
+        )
+        st.caption(
+            f"Showing {min(200, len(filt_bio)):,} of {len(filt_bio):,} records"
+        )
+        st.download_button(
+            "⬇️ Download Filtered BGC Profiles (CSV)",
+            data=filt_bio.to_csv(index=False),
+            file_name="argo_bgc_profiles_filtered.csv",
+            mime="text/csv",
+            key="dl_bgc",
+        )
+    with tab3:
+        st.dataframe(
+            df_meta.head(500), use_container_width=True, hide_index=True
+        )
+        st.caption(
+            f"Showing {min(500, len(df_meta)):,} of {len(df_meta):,} float metadata records (source: ar_index_global_meta.txt)"
+        )
+        st.download_button(
+            "⬇️ Download Float Metadata (CSV)",
+            data=df_meta.to_csv(index=False),
+            file_name="argo_float_metadata.csv",
+            mime="text/csv",
+            key="dl_meta",
+        )
+
+# ==================== FOOTER ====================
+st.markdown(
+    f"""
+<div class="footer-bar">
+    Indian ARGO CTD/BGC Dashboard · INCOIS · Data: IFREMER GDAC<br>
+    {datetime.now().strftime("%Y-%m-%d %H:%M")} ·
+    {len(df_prof):,} profiles · {df_prof['wmo_id'].nunique():,} floats ·
+    {len(df_bio):,} BGC profiles · {len(df_meta):,} registered floats (meta)
+</div>
+""",
+    unsafe_allow_html=True,
+)

streamlit/dashboard_example.py

@@ -0,0 +1,360 @@
+# argo_dashboard.py
+# Full dashboard (Static map + Bar + Donut + Interactive map + DAC table)
+# - Static & Interactive map use: C:\Users\medagam INDU\Desktop\total dataset.csv
+# - Bar, Donut, Table use:    C:\Users\medagam INDU\Desktop\bio_dataset.csv
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import matplotlib.pyplot as plt
+import cartopy.crs as ccrs
+import cartopy.feature as cfeature
+from datetime import datetime
+
+# ------------------------------
+# UPDATE THESE PATHS if needed
+# ------------------------------
+TOTAL_CSV = r"./total dataset.csv"
+BIO_CSV   = r"./bio_dataset.csv"
+
+# ------------------------------
+# Page setup
+# ------------------------------
+st.set_page_config(page_title="Argo Float Dashboard", layout="wide")
+# Simple headings only (no extra notes)
+st.title("Argo Float Dashboard")
+
+# ------------------------------
+# Helper: detect lat/lon column names
+# ------------------------------
+def detect_latlon(df):
+    lat = None
+    lon = None
+    for c in df.columns:
+        cl = c.strip().lower()
+        if cl in ("lat", "latitude") or cl.startswith("lat"):
+            lat = c
+        if cl in ("lon", "long", "longitude") or cl.startswith("lon") or cl.startswith("long"):
+            lon = c
+    return lat, lon
+
+# ------------------------------
+# Load datasets (with caching)
+# ------------------------------
+@st.cache_data
+def load_total():
+    df = pd.read_csv(TOTAL_CSV, low_memory=False, encoding='latin1')
+    return df
+
+@st.cache_data
+def load_bio():
+    df = pd.read_csv(BIO_CSV, low_memory=False, encoding='latin1')
+    return df
+
+total_df = load_total()
+bio_df = load_bio()
+
+# ------------------------------
+# Prepare total dataset for static map: try find core/bio type or split
+# ------------------------------
+def prepare_total_map(df, N_split=10):
+    d = df.copy()
+    # detect lat/lon
+    lat_col, lon_col = detect_latlon(d)
+    # find a type column if exists
+    type_col = None
+    for cand in ("Type", "FLOAT_TYPE", "Float_Type", "float_type", "TYPE"):
+        if cand in d.columns:
+            type_col = cand
+            break
+    if type_col is not None:
+        core = d[d[type_col].astype(str).str.lower().str.contains("core", na=False)].copy()
+        bio  = d[d[type_col].astype(str).str.lower().str.contains("bio|bgc", na=False)].copy()
+        if core.empty and bio.empty:
+            core = d.copy()
+            bio = d.iloc[0:0].copy()
+    else:
+        # fallback to Excel-like split (first N columns core, rest bio)
+        try:
+            core = d.iloc[:, :N_split].copy()
+            bio  = d.iloc[:, N_split:].copy()
+        except Exception:
+            core = d.copy()
+            bio = d.iloc[0:0].copy()
+    return core, bio, lat_col, lon_col
+
+core_map_df, bio_map_df, total_lat_col, total_lon_col = prepare_total_map(total_df, N_split=10)
+
+# Ensure we have lat/lon for total dataset (fallback common names)
+if total_lat_col is None or total_lon_col is None:
+    for a,b in [("LATITUDE","LONGITUDE"), ("LAT","LONG"), ("Latitude","Longitude")]:
+        if a in total_df.columns and b in total_df.columns:
+            total_lat_col, total_lon_col = a,b
+            break
+
+# ------------------------------
+# Prepare bio dataset (dates, per-float aggregated)
+# ------------------------------
+def prepare_bio(df):
+    b = df.copy()
+    # find birth and death columns
+    birth_col = None
+    death_col = None
+    for c in ("DATE_UPDATE","DATE"):
+        if c in b.columns:
+            birth_col = c
+            break
+    for c in ("DATE_UPDATE.1","DATE.1","DATE_UPDATE1","DATE_UPDATE_1"):
+        if c in b.columns:
+            death_col = c
+            break
+    # fallback search any 'date' columns
+    if birth_col is None:
+        for c in b.columns:
+            if 'date' in c.lower():
+                birth_col = c
+                break
+    # parse dates
+    if birth_col is not None:
+        b[birth_col] = pd.to_datetime(b[birth_col], errors='coerce', dayfirst=False)
+    if death_col is not None:
+        b[death_col] = pd.to_datetime(b[death_col], errors='coerce', dayfirst=False)
+    else:
+        b['DATE_UPDATE.1'] = pd.NaT
+        death_col = 'DATE_UPDATE.1'
+    # Year for bar chart
+    if birth_col is not None:
+        b['Year'] = b[birth_col].dt.year
+    else:
+        b['Year'] = pd.NA
+    # id column
+    id_col = 'WMOID' if 'WMOID' in b.columns else b.columns[0]
+    # per-float aggregation: birth=min(birth_col), death=max(death_col)
+    grouped = b.groupby(id_col).agg({
+        birth_col: 'min' if birth_col in b.columns else (lambda x: pd.NaT),
+        death_col: 'max' if death_col in b.columns else (lambda x: pd.NaT),
+        'DAC': 'first' if 'DAC' in b.columns else (lambda x: None)
+    }).reset_index().rename(columns={birth_col: 'birth', death_col: 'death'})
+    today = pd.Timestamp.today()
+    grouped['end_date'] = grouped['death'].fillna(today)
+    grouped['age_days'] = (grouped['end_date'] - grouped['birth']).dt.days
+    # classify by 90 days
+    grouped['status_90'] = grouped['age_days'].apply(lambda x: 'Live' if pd.notnull(x) and x >= 90 else 'Dead')
+    return b, id_col, birth_col, death_col, grouped
+
+bio_prepared, bio_id_col, bio_birth_col, bio_death_col, bio_floats_grouped = prepare_bio(bio_df)
+
+# ------------------------------
+# Sidebar: filters and search
+# ------------------------------
+st.sidebar.header("Controls")
+# Year filter (bio)
+years_available = sorted([int(y) for y in bio_prepared['Year'].dropna().unique() if pd.notnull(y)])
+selected_years = st.sidebar.multiselect("Year(s) for bar chart", years_available, default=years_available)
+# DAC filter
+dac_options = sorted(bio_prepared['DAC'].dropna().unique().astype(str)) if 'DAC' in bio_prepared.columns else []
+selected_dacs = st.sidebar.multiselect("DAC(s)", dac_options, default=dac_options)
+# Search box
+search_text = st.sidebar.text_input("Search WMOID or DAC")
+
+# Apply filters to bio_prepared for bar/donut
+bio_filtered = bio_prepared.copy()
+if selected_years:
+    bio_filtered = bio_filtered[bio_filtered['Year'].isin(selected_years)]
+if selected_dacs:
+    bio_filtered = bio_filtered[bio_filtered['DAC'].astype(str).isin(selected_dacs)]
+if search_text and search_text.strip():
+    bio_filtered = bio_filtered[
+        bio_filtered['WMOID'].astype(str).str.contains(search_text, case=False, na=False) |
+        bio_filtered['DAC'].astype(str).str.contains(search_text, case=False, na=False)
+    ]
+
+# Also filter grouped_for_table (per-float) by DAC/search
+grouped_for_table = bio_floats_grouped.copy()
+if selected_dacs:
+    grouped_for_table = grouped_for_table[grouped_for_table['DAC'].astype(str).isin(selected_dacs)]
+if search_text and search_text.strip():
+    grouped_for_table = grouped_for_table[
+        grouped_for_table[bio_id_col].astype(str).str.contains(search_text, case=False, na=False) |
+        grouped_for_table['DAC'].astype(str).str.contains(search_text, case=False, na=False)
+    ]
+
+# ------------------------------
+# Static Map (top) — core pink, bio blue (use total dataset)
+# ------------------------------
+st.subheader("Static Map")
+
+plt.figure(figsize=(14,7))
+ax = plt.axes(projection=ccrs.PlateCarree())
+ax.add_feature(cfeature.LAND, facecolor='lightgray')
+ax.add_feature(cfeature.COASTLINE)
+ax.add_feature(cfeature.BORDERS, linestyle=':')
+
+# detect lat/lon in core_map_df and bio_map_df returned earlier from total split
+core_lat, core_lon = detect_latlon(core_map_df)
+bio_lat, bio_lon = detect_latlon(bio_map_df)
+
+# fallback common names
+if core_lat is None or core_lon is None:
+    for a,b in (("LATITUDE","LONGITUDE"), ("LAT","LONG"), ("Latitude","Longitude")):
+        if a in core_map_df.columns and b in core_map_df.columns:
+            core_lat, core_lon = a,b
+            break
+if bio_lat is None or bio_lon is None:
+    for a,b in (("LATITUDE","LONGITUDE"), ("LAT","LONG"), ("Latitude","Longitude")):
+        if a in bio_map_df.columns and b in bio_map_df.columns:
+            bio_lat, bio_lon = a,b
+            break
+
+# plot if available
+if core_lat and core_lon and (core_lat in core_map_df.columns) and (core_lon in core_map_df.columns):
+    ax.scatter(core_map_df[core_lon], core_map_df[core_lat], color='pink', s=15, alpha=0.7, label='Core')
+if bio_lat and bio_lon and (bio_lat in bio_map_df.columns) and (bio_lon in bio_map_df.columns):
+    ax.scatter(bio_map_df[bio_lon], bio_map_df[bio_lat], color='blue', s=15, alpha=0.7, label='Bio')
+
+plt.title("Core (pink) vs Bio (blue) — Map")
+plt.legend(loc='upper right')
+st.pyplot(plt.gcf())
+
+# ------------------------------
+# Middle row: Bar chart (left) and Donut chart (right) — both from bio dataset
+# ------------------------------
+col1, col2 = st.columns(2)
+
+# Bar chart: number of unique floats per Year and DAC
+with col1:
+    st.subheader("Bar Chart")
+    id_col = bio_id_col
+    df_grouped = bio_filtered.groupby(['Year','DAC'])[id_col].nunique().reset_index(name='Float_Count')
+    totals = df_grouped.groupby('Year')['Float_Count'].sum().reset_index(name='Total_Floats')
+
+    fig_bar = px.bar(
+        df_grouped,
+        x='Year',
+        y='Float_Count',
+        color='DAC',
+        text='Float_Count',
+        title='Number of Floats per DAC'
+    )
+    for _, r in totals.iterrows():
+        fig_bar.add_annotation(x=r['Year'], y=r['Total_Floats'], text=str(int(r['Total_Floats'])), showarrow=False, yshift=10)
+    fig_bar.update_layout(barmode='stack', xaxis=dict(dtick=1), height=520)
+    st.plotly_chart(fig_bar, use_container_width=True)
+
+# Donut chart: age distribution of alive floats (bio dataset)
+with col2:
+    st.subheader("Donut Chart")
+    g = bio_floats_grouped.copy()
+    # alive = death is NaT
+    alive = g[g['death'].isna()].copy()
+    if not alive.empty:
+        alive['age_years'] = ((pd.Timestamp.today() - alive['birth']).dt.days // 365).astype('Int64')
+        alive = alive[alive['age_years'].notna() & (alive['age_years'] >= 0)]
+        age_counts = alive['age_years'].value_counts().sort_index().reset_index()
+        age_counts.columns = ['Age_Years','Count']
+        if not age_counts.empty:
+            fig_donut = px.pie(age_counts, names='Age_Years', values='Count', hole=0.55, title='Age (years) distribution of alive floats')
+            fig_donut.update_traces(textinfo='percent+label')
+            st.plotly_chart(fig_donut, use_container_width=True)
+        else:
+            st.write("No alive float age groups available for selected filters.")
+    else:
+        st.write("No alive floats found for selected filters.")
+
+# ------------------------------
+# Interactive Plotly Map (uses total dataset)
+# ------------------------------
+# ------------------------------
+# Interactive Plotly Map (ALL DACs always visible)
+# ------------------------------
+st.subheader("Interactive Plotly Map (All DACs)")
+
+# copy full total dataset (no DAC filtering)
+map_df = total_df.copy()
+
+# detect lat/lon
+lat_t, lon_t = detect_latlon(map_df)
+if lat_t is None and "LATITUDE" in map_df.columns:
+    lat_t = "LATITUDE"
+if lon_t is None and "LONGITUDE" in map_df.columns:
+    lon_t = "LONGITUDE"
+if lat_t is None and "LAT" in map_df.columns:
+    lat_t = "LAT"
+if lon_t is None and "LONG" in map_df.columns:
+    lon_t = "LONG"
+
+if lat_t is None or lon_t is None:
+    st.warning("Latitude/Longitude not found in total dataset for interactive map.")
+else:
+    # Convert dates
+    if 'DATE_UPDATE' in map_df.columns:
+        map_df['DATE_UPDATE'] = pd.to_datetime(map_df['DATE_UPDATE'], errors='coerce')
+    if 'DATE_UPDATE.1' in map_df.columns:
+        map_df['DATE_UPDATE.1'] = pd.to_datetime(map_df['DATE_UPDATE.1'], errors='coerce')
+
+    # Compute status (90-day rule)
+    if 'DATE_UPDATE' in map_df.columns:
+        map_df['end_date'] = map_df['DATE_UPDATE.1'].fillna(pd.Timestamp.today()) \
+                             if 'DATE_UPDATE.1' in map_df.columns else pd.Timestamp.today()
+        map_df['age_days'] = (map_df['end_date'] - map_df['DATE_UPDATE']).dt.days
+        map_df['Status'] = map_df['age_days'].apply(
+            lambda x: 'Live' if pd.notnull(x) and x >= 90 else 'Dead'
+        )
+    else:
+        map_df['Status'] = 'Unknown'
+
+    # Hover information
+    hover_data = {
+        lat_t: True,
+        lon_t: True,
+        "Status": True
+    }
+    if "WMOID" in map_df.columns:
+        hover_data["WMOID"] = True
+    if "DAC" in map_df.columns:
+        hover_data["DAC"] = True
+    if "DATE_UPDATE" in map_df.columns:
+        hover_data["DATE_UPDATE"] = True
+    if "DATE_UPDATE.1" in map_df.columns:
+        hover_data["DATE_UPDATE.1"] = True
+
+    # Plot ALL DACs (no filters)
+    fig_map = px.scatter_geo(
+        map_df,
+        lat=lat_t,
+        lon=lon_t,
+        color="DAC" if "DAC" in map_df.columns else None,
+        hover_name="WMOID" if "WMOID" in map_df.columns else None,
+        hover_data=hover_data,
+        title="Interactive Map — All DACs",
+        projection="natural earth"
+    )
+
+    fig_map.update_layout(height=650)
+    st.plotly_chart(fig_map, use_container_width=True)
+# ------------------------------
+# DAC summary table (bio dataset) - bottom
+# Live = age_days >= 90, Dead = age_days < 90, Total = unique floats
+# ------------------------------
+st.subheader("DAC Table")
+
+g = grouped_for_table.copy()
+# ensure age_days already present (end_date computed earlier)
+g['age_days'] = (g['end_date'] - g['birth']).dt.days
+g['Live90'] = g['age_days'].apply(lambda x: 1 if pd.notnull(x) and x >= 90 else 0)
+g['Dead90'] = g['age_days'].apply(lambda x: 1 if pd.notnull(x) and x < 90 else 0)
+
+summary_table = g.groupby('DAC').agg(
+    Live=('Live90','sum'),
+    Dead=('Dead90','sum'),
+    Total=(bio_id_col, 'nunique')
+).reset_index()
+
+# present in requested order: DAC | Live | Dead | Total
+summary_table = summary_table[['DAC','Live','Dead','Total']]
+st.dataframe(summary_table, use_container_width=True)
+
+# Compact text lines
+st.markdown("**Compact summary (DAC — Live / Dead / Total)**")
+for _, row in summary_table.iterrows():
+    st.write(f"{row['DAC']} — {int(row['Live'])} / {int(row['Dead'])} / {int(row['Total'])}")

streamlit/find_core_logic.py

@@ -0,0 +1,43 @@
+import pandas as pd
+import numpy as np
+
+target_values = {
+    2014: 973,
+    2016: 1094,
+    2020: 1056,
+}
+
+df = pd.read_parquet("cache/profiles.parquet")
+df_io = df[
+    (df["longitude"] >= 20.0) & (df["longitude"] <= 145.0) & 
+    (df["latitude"] >= -70.1) & (df["latitude"] <= 30.0)
+].copy()
+df_io["date"] = pd.to_datetime(df_io["date"])
+df_io["year"] = df_io["date"].dt.year
+
+df_bio = pd.read_parquet("cache/bgc_profiles.parquet")
+bgc_wmos = set(df_bio["wmo_id"].unique())
+DEEP_PROFILER_TYPES = {862, 864, 876, 882, 869, 863, 873, 874, 886, 877, 875, 884, 872, 879, 865, 860, 878, 861, 871, 870, 881, 853}
+
+df_io["is_bgc"] = df_io["wmo_id"].isin(bgc_wmos)
+if "profiler_type" in df_io.columns:
+    df_io["is_deep"] = df_io["profiler_type"].isin(DEEP_PROFILER_TYPES)
+else:
+    df_io["is_deep"] = False
+
+print("Total unique active floats in IO:")
+active_yearly = df_io.dropna(subset=["year"]).groupby("year")["wmo_id"].nunique().to_dict()
+for y in target_values: print(f"  {y}: Target={target_values[y]}, Calc={active_yearly.get(y, 0)}")
+
+print("Core floats only (Not BGC, Not Deep):")
+core_df = df_io[~df_io["is_bgc"] & ~df_io["is_deep"]]
+active_core = core_df.dropna(subset=["year"]).groupby("year")["wmo_id"].nunique().to_dict()
+for y in target_values: print(f"  {y}: Target={target_values[y]}, Calc={active_core.get(y, 0)}")
+
+print("BGC floats only:")
+bgc_df = df_io[df_io["is_bgc"]]
+active_bgc = bgc_df.dropna(subset=["year"]).groupby("year")["wmo_id"].nunique().to_dict()
+for y in target_values: print(f"  {y}: Target={target_values[y]}, Calc={active_bgc.get(y, 0)}")
+
+# Let's try matching exactly by seeing if there's a specific month filter or something.
+# Or maybe the data from the image is NOT Indian Ocean, but a specific subset of Global?

streamlit/find_correct_logic.py

@@ -0,0 +1,82 @@
+import pandas as pd
+import numpy as np
+
+# Target values from the image
+target_values = {
+    2000: 10,
+    2001: 33,
+    2003: 222,
+    2004: 361,
+    2006: 598,
+    2007: 669,
+    2009: 762,
+    2010: 848,
+    2011: 946,
+    2013: 905,
+    2014: 973,
+    2016: 1094,
+    2017: 1029,
+    2018: 1011,
+    2020: 1056,
+    2022: 866,
+    2023: 848,
+    2025: 966
+}
+
+print("Loading data...")
+df = pd.read_parquet("cache/profiles.parquet")
+df_io = df[
+    (df["longitude"] >= 20.0) & (df["longitude"] <= 145.0) & 
+    (df["latitude"] >= -70.1) & (df["latitude"] <= 30.0)
+].copy()
+df_io["date"] = pd.to_datetime(df_io["date"])
+df_io["year"] = df_io["date"].dt.year
+
+print("\n--- Testing different metrics to match the target values ---")
+
+def compare_to_target(calculated_dict, name):
+    print(f"\n{name}")
+    diffs = []
+    for y, target in target_values.items():
+        calc = calculated_dict.get(y, 0)
+        diff = calc - target
+        diffs.append(abs(diff))
+        print(f"  {y}: Target={target}, Calc={calc}, Diff={diff}")
+    print(f"  Avg absolute difference: {np.mean(diffs):.1f}")
+
+# 1. Total unique floats per year (active in that year)
+active_yearly = df_io.dropna(subset=["year"]).groupby("year")["wmo_id"].nunique().to_dict()
+compare_to_target(active_yearly, "Metric 1: Active floats per year in Indian Ocean")
+
+# 2. Total unique BGC floats per year? No, the title says "No. of Floats", let's try it anyway.
+df_bio = pd.read_parquet("cache/bgc_profiles.parquet")
+# The BGC profiles file doesn't have lat/lon in it in our cache, so we use wmo_id
+bgc_wmos = set(df_bio["wmo_id"].unique())
+active_bgc_yearly = df_io[df_io["wmo_id"].isin(bgc_wmos)].groupby("year")["wmo_id"].nunique().to_dict()
+compare_to_target(active_bgc_yearly, "Metric 2: Active BGC floats per year in Indian Ocean")
+
+# 3. Active floats per year globally (no lat/lon filter)
+global_active = df.dropna(subset=["year"]).groupby("year")["wmo_id"].nunique().to_dict()
+compare_to_target(global_active, "Metric 3: Active floats per year GLOBALLY")
+
+# 4. Floats that were "Live" at the end of each year?
+# A float is live if it reported a profile in the 90 days before Dec 31 of that year.
+def active_at_end_of_year(df, days=90):
+    res = {}
+    years = sorted(df["year"].dropna().unique())
+    for y in years:
+        end_of_year = pd.Timestamp(f"{int(y)}-12-31")
+        start_period = end_of_year - pd.Timedelta(days=days)
+        # Floats that reported in the last 90 days of the year
+        active = df[(df["date"] >= start_period) & (df["date"] <= end_of_year)]["wmo_id"].nunique()
+        res[y] = active
+    return res
+
+compare_to_target(active_at_end_of_year(df_io, 90), "Metric 4: Active in last 90 days of year (IO)")
+compare_to_target(active_at_end_of_year(df_io, 365), "Metric 5: Active in last 365 days of year (IO)")
+
+# 6. Core floats only? (Not deep, not BGC)
+core_wmos = set(df_io[~df_io["is_bgc"] & ~df_io["is_deep"]]["wmo_id"])
+active_core = df_io[df_io["wmo_id"].isin(core_wmos)].groupby("year")["wmo_id"].nunique().to_dict()
+compare_to_target(active_core, "Metric 6: Active CORE floats per year (IO)")
+

streamlit/hello.py

@@ -0,0 +1,151 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import geopandas as gpd
+from shapely.geometry import Point
+
+st.set_page_config(layout="wide")
+
+# ---------------- DATA FILES ----------------
+bio_data = "argo_bio-profile_index.txt"
+core_data = "ar_index_global_prof.txt"
+
+# ---------------- LOAD DATA ----------------
+@st.cache_data
+def load_data():
+    df_bio = pd.read_csv(bio_data, comment="#")
+    df_core = pd.read_csv(core_data, comment="#")
+    return df_bio, df_core
+
+df_bio, df_core = load_data()
+
+st.title("Indian ARGO CTD_BGC")
+st.caption("Global profiling float data visualization | Data Source: IFREMER")
+
+# ---------------- DATE CONVERSION ----------------
+df_bio['date'] = pd.to_datetime(df_bio['date'], format='%Y%m%d%H%M%S', errors='coerce')
+df_core['date'] = pd.to_datetime(df_core['date'], format='%Y%m%d%H%M%S', errors='coerce')
+
+# ---------------- YEAR COLUMN ----------------
+df_bio['year'] = df_bio['date'].dt.year
+df_core['year'] = df_core['date'].dt.year
+
+# ---------------- LATEST LOCATION PER FLOAT ----------------
+df_bio_latest = df_bio.sort_values('date').groupby('file').tail(1).copy()
+df_bio_latest['type'] = "BGC"
+
+df_core_latest = df_core.sort_values('date').groupby('file').tail(1).copy()
+df_core_latest['type'] = "CTD"
+
+# ---------------- COMBINE BOTH ----------------
+df_all = pd.concat([
+    df_bio_latest[['latitude','longitude','institution','type','file']],
+    df_core_latest[['latitude','longitude','institution','type','file']]
+], ignore_index=True)
+
+# ---------------- CLEAN DATA ----------------
+df_all = df_all.dropna(subset=['latitude','longitude'])
+
+# ---------------- GEO FILTER (OCEAN ONLY) ----------------
+@st.cache_data
+def filter_ocean(df):
+    geometry = [Point(xy) for xy in zip(df['longitude'], df['latitude'])]
+    gdf = gpd.GeoDataFrame(df, geometry=geometry)
+
+    world = gpd.read_file(
+        "https://naturalearth.s3.amazonaws.com/110m_cultural/ne_110m_admin_0_countries.zip"
+    )
+
+    land = world[world['CONTINENT'] != 'Antarctica']
+
+    gdf_ocean = gdf[~gdf.within(land.geometry.union_all())]
+
+    gdf_ocean = gdf_ocean[
+        (gdf_ocean['latitude'] >= -60) & (gdf_ocean['latitude'] <= 30)
+    ]
+
+    return pd.DataFrame(gdf_ocean.drop(columns='geometry'))
+
+df_map_full = filter_ocean(df_all)
+
+# ---------------- SIDEBAR FILTER ----------------
+option = st.sidebar.radio(
+    "Select Network",
+    ["ALL", "BGC", "CTD"]
+)
+
+if option == "ALL":
+    df_map = df_map_full
+elif option == "BGC":
+    df_map = df_map_full[df_map_full['type'] == "BGC"]
+else:
+    df_map = df_map_full[df_map_full['type'] == "CTD"]
+
+# ---------------- REDUCE DATA SIZE ----------------
+if len(df_map) > 8000:
+    df_map = df_map.sample(8000, random_state=42)
+
+# ---------------- KPI COUNTS ----------------
+doxy = df_bio[df_bio['parameters'].str.contains("DOXY", na=False)].shape[0]
+chla = df_bio[df_bio['parameters'].str.contains("CHLA", na=False)].shape[0]
+nitrate = df_bio[df_bio['parameters'].str.contains("NITRATE", na=False)].shape[0]
+ph = df_bio[df_bio['parameters'].str.contains("PH", na=False)].shape[0]
+
+# ---------------- LAYOUT ----------------
+col1, col2 = st.columns([3, 1])
+
+# ---------------- MAP ----------------
+with col1:
+    st.subheader("Geographic Distribution (Indian Ocean → Antarctica)")
+
+    fig_map = px.scatter_mapbox(
+        df_map,
+        lat="latitude",
+        lon="longitude",
+        color="type",
+        hover_data=["file", "institution", "type"],
+        zoom=3,
+        height=650
+    )
+
+    fig_map.update_traces(marker=dict(size=5))
+
+    fig_map.update_layout(
+        mapbox_style="open-street-map",
+        mapbox=dict(center=dict(lat=-10, lon=80), zoom=3)
+    )
+
+    st.plotly_chart(fig_map, use_container_width=True)
+
+# ---------------- KPI ----------------
+with col2:
+    st.metric("DOXY Profiles", f"{doxy:,}")
+    st.metric("Chla Profiles", f"{chla:,}")
+    st.metric("Nitrate Profiles", f"{nitrate:,}")
+    st.metric("pH Profiles", f"{ph:,}")
+
+# ---------------- BAR CHART ----------------
+st.markdown("---")
+
+st.subheader("Number of Floats Deployed Over Years")
+
+# combine years
+df_years = pd.concat([
+    df_bio[['file','year']],
+    df_core[['file','year']]
+])
+
+# remove duplicate floats
+df_years = df_years.drop_duplicates('file')
+
+# count per year
+year_counts = df_years.groupby('year').size().reset_index(name='count')
+
+# plot
+fig_bar = px.bar(
+    year_counts,
+    x="year",
+    y="count"
+)
+
+st.plotly_chart(fig_bar, use_container_width=True)

streamlit/more_components/2900552_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aeaf737d7dec2cc62394c367788f0a986ac6ea37942ecfcea2ad056e263d6775
+size 31332

streamlit/more_components/2900552_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74697fa8421a6f6daefca50680ebf2269c1f916fbb6051077c261b576dce0250
+size 1793024

streamlit/more_components/2902174_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:237a8905395766789208be861c7b115998fd691ded7f00d0c12bda2dd5535934
+size 68748

streamlit/more_components/2902174_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26ae7ab323dd3cb632986711ae58768f53c29677c4c1c0f7162664dd4c8057f4
+size 18187956

streamlit/more_components/2902771_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cf8f6dcc5123a617fd1c2f7e171ecb02fdea204cb7f98d28caeca59e7d8b42a
+size 59744

streamlit/more_components/2902771_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31f4f75b8366dd07dc1a3038c5a0e48879deb97b49e406d31f1b41b494ca6316
+size 3011048

streamlit/more_components/2902821_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40a6b4c8e0c9f6e6251b662c7e61331b21b84a0f1c5354efb4334c3c1938724d
+size 59744

streamlit/more_components/2902821_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c4910fcaffd8ebaed31f0a75c142df72f99915d130c31e6480952b6630befa2
+size 3364352

streamlit/more_components/2903145_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad50c0a0b30cb128902418b0da296ac108958b5f958e5ccc28d81b1e0e38155b
+size 52048

streamlit/more_components/2903145_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2aff0374464a3c07499b18a9004df08c80fce517ca2b0aa314fbfe073f9a7a5
+size 4172636

streamlit/more_components/2903424_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52126b39e7b1de765ff87bb9923ee16c6e6aae6999a1db6fd512c54d512187c5
+size 38772

streamlit/more_components/2903424_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:738bbb02fff1ea3a4288638a11591d9e1017579c34f98287183b3b2099260af4
+size 13458068

streamlit/more_components/5907180_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85762274fe81c739d89b03814150253704eb55bbbcd3ce601c23c3c19044969d
+size 31332

streamlit/more_components/5907180_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:051dcf032ff13b60f20aa94359d18067a1f2335be6ee99fbfcf2edde1ac74536
+size 339396

streamlit/more_components/7902408_meta.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1edac7d437d4a6e4478aea5af294b3ff1d5c687f4b7989a8e9aad39544b0ea1d
+size 31332

streamlit/more_components/7902408_prof.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3a4ecf2ebda8497161850733b4ee80222adba9243630312f84b63c1fc7f7547
+size 51016

streamlit/plot_utils.py

@@ -0,0 +1,86 @@
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+import numpy as np
+import xarray as xr
+import gsw
+
+def get_valid_data(ds_prof):
+    # Flatten the data for scatter plots
+    cycles_2d = np.repeat(ds_prof.CYCLE_NUMBER.values[:, np.newaxis], ds_prof.PRES.shape[1], axis=1)
+    dates_2d = np.repeat(ds_prof.JULD.values[:, np.newaxis], ds_prof.PRES.shape[1], axis=1)
+    
+    # We might have missing values in some profiles
+    lon = ds_prof.LONGITUDE.values
+    lat = ds_prof.LATITUDE.values
+    lon_2d = np.repeat(lon[:, np.newaxis], ds_prof.PRES.shape[1], axis=1)
+    lat_2d = np.repeat(lat[:, np.newaxis], ds_prof.PRES.shape[1], axis=1)
+
+    pres = ds_prof.PRES.values.flatten()
+    temp = ds_prof.TEMP.values.flatten() if 'TEMP' in ds_prof else np.full_like(pres, np.nan)
+    psal = ds_prof.PSAL.values.flatten() if 'PSAL' in ds_prof else np.full_like(pres, np.nan)
+    cycles = cycles_2d.flatten()
+    dates = dates_2d.flatten()
+    lon_flat = lon_2d.flatten()
+    lat_flat = lat_2d.flatten()
+    
+    valid = ~np.isnan(pres) & ~np.isnan(temp) & ~np.isnan(psal) & ~np.isnat(dates)
+    
+    pres = pres[valid]
+    temp = temp[valid]
+    psal = psal[valid]
+    cycles = cycles[valid]
+    dates = dates[valid]
+    lon_flat = lon_flat[valid]
+    lat_flat = lat_flat[valid]
+    
+    # Compute Density (sigma0)
+    SA = gsw.SA_from_SP(psal, pres, lon_flat, lat_flat)
+    CT = gsw.CT_from_t(SA, temp, pres)
+    rho = gsw.sigma0(SA, CT)
+    
+    return cycles, dates, pres, temp, psal, rho
+
+def create_ts_diagram(cycles, temp, psal, wmo):
+    fig, ax = plt.subplots(figsize=(6, 5))
+    sc = ax.scatter(psal, temp, c=cycles, cmap='jet', s=5, alpha=0.8)
+    ax.set_xlabel("Practical Salinity (PSU)")
+    ax.set_ylabel("Temperature (°C)")
+    ax.set_title("T/S Diagram")
+    cbar = plt.colorbar(sc, ax=ax)
+    cbar.set_label("Profile number")
+    fig.tight_layout()
+    return fig
+
+def create_section_chart(dates, pres, z_var, z_label, title, wmo, cmap='jet'):
+    fig, ax = plt.subplots(figsize=(6, 5))
+    sc = ax.scatter(dates, pres, c=z_var, cmap=cmap, s=15, marker='s', edgecolors='none')
+    ax.invert_yaxis()
+    ax.set_ylabel("Pressure (dbar)")
+    ax.set_title(title)
+    
+    # Format x-axis dates
+    ax.xaxis.set_major_formatter(mdates.DateFormatter('%m-%Y'))
+    plt.setp(ax.xaxis.get_majorticklabels(), rotation=45, ha='right')
+    
+    cbar = plt.colorbar(sc, ax=ax)
+    cbar.set_label(z_label)
+    fig.tight_layout()
+    return fig
+
+def create_overlaid_profiles(x_var, pres, cycles, x_label, title, wmo, cmap='jet'):
+    fig, ax = plt.subplots(figsize=(6, 5))
+    
+    # Instead of lines which might look messy if flattened, scatter is fine, 
+    # but to draw lines we group by cycle. For performance and exact match to 
+    # the screenshot (which uses lines/scatter with color mapped to cycle), 
+    # a scatter plot with small points looks identical to dense overlaid lines.
+    sc = ax.scatter(x_var, pres, c=cycles, cmap=cmap, s=2, alpha=0.8)
+    ax.invert_yaxis()
+    ax.set_xlabel(x_label)
+    ax.set_ylabel("Pressure (dbar)")
+    ax.set_title(title)
+    
+    cbar = plt.colorbar(sc, ax=ax)
+    cbar.set_label("Profile number")
+    fig.tight_layout()
+    return fig

streamlit/scratch/analyze_meta.py

@@ -0,0 +1,46 @@
+"""Quick analysis of ar_index_global_meta.txt to understand the data."""
+import pandas as pd
+
+META_FILE = r"c:\Users\harsh\incois\dashboard\ar_index_global_meta.txt"
+df = pd.read_csv(META_FILE, comment="#")
+df.columns = df.columns.str.strip()
+
+print(f"Total rows: {len(df):,}")
+print(f"Columns: {list(df.columns)}")
+print(f"\nUnique profiler_type codes: {df['profiler_type'].nunique()}")
+print(f"\nProfiler type distribution (top 20):")
+print(df['profiler_type'].value_counts().head(20).to_string())
+
+print(f"\n\nUnique institutions: {df['institution'].nunique()}")
+print(f"\nInstitution distribution:")
+print(df['institution'].value_counts().to_string())
+
+# Extract DAC and WMO from file path
+df['dac'] = df['file'].str.extract(r'^([^/]+)/')
+df['wmo_id'] = df['file'].str.extract(r'/(\d+)/')
+
+print(f"\n\nUnique DACs: {df['dac'].nunique()}")
+print(f"\nDAC distribution:")
+print(df['dac'].value_counts().to_string())
+
+print(f"\n\nTotal unique floats (WMOs): {df['wmo_id'].nunique():,}")
+
+# Check overlap with prof file
+PROF_FILE = r"c:\Users\harsh\incois\dashboard\ar_index_global_prof.txt"
+df_prof = pd.read_csv(PROF_FILE, comment="#", usecols=['file'])
+df_prof.columns = df_prof.columns.str.strip()
+df_prof['wmo_id'] = df_prof['file'].str.extract(r'/(\d+)/')
+prof_wmos = set(df_prof['wmo_id'].dropna().unique())
+meta_wmos = set(df['wmo_id'].dropna().unique())
+
+print(f"\nWMOs in meta but NOT in prof: {len(meta_wmos - prof_wmos):,}")
+print(f"WMOs in prof but NOT in meta: {len(prof_wmos - meta_wmos):,}")
+print(f"WMOs in BOTH: {len(meta_wmos & prof_wmos):,}")
+
+# Check which profiler_type codes are NOT in the prof file
+df_prof_full = pd.read_csv(PROF_FILE, comment="#", usecols=['file', 'profiler_type'])
+df_prof_full.columns = df_prof_full.columns.str.strip()
+prof_ptypes = set(df_prof_full['profiler_type'].dropna().unique())
+meta_ptypes = set(df['profiler_type'].dropna().unique())
+print(f"\nProfiler types in meta only: {meta_ptypes - prof_ptypes}")
+print(f"Profiler types in prof only: {prof_ptypes - meta_ptypes}")

streamlit/scratch/check_coordinates.py

@@ -0,0 +1,34 @@
+import pandas as pd
+from pathlib import Path
+
+BASE_DIR = Path(r"c:\Users\harsh\incois\dashboard")
+PROF_FILE = BASE_DIR / "ar_index_global_prof.txt"
+
+def check_land_points():
+    print(f"Reading {PROF_FILE}...")
+    df = pd.read_csv(PROF_FILE, comment="#")
+    df.columns = df.columns.str.strip()
+    
+    # India land area approx: 8-36N, 68-95E
+    india_land = df[
+        (df["latitude"] > 8) & (df["latitude"] < 36) & 
+        (df["longitude"] > 68) & (df["longitude"] < 95)
+    ].copy()
+    
+    india_land["wmo_id"] = india_land["file"].str.extract(r"/(\d+)/")
+    latest = india_land.sort_values("date").groupby("wmo_id").tail(1)
+    
+    # Specific search for JA floats in this box
+    ja_in_india = latest[latest["institution"] == "JA"]
+    print(f"JA floats in India box: {len(ja_in_india)}")
+    if len(ja_in_india) > 0:
+        print(ja_in_india[["wmo_id", "latitude", "longitude", "institution", "date"]].to_string())
+
+    # All floats in India land box
+    print(f"\nAll unique floats in India box: {len(latest)}")
+    # Print top 20 suspicious ones (high latitude, inland)
+    suspicious = latest[latest["latitude"] > 10]
+    print(suspicious[["wmo_id", "latitude", "longitude", "institution", "date"]].head(20))
+
+if __name__ == "__main__":
+    check_land_points()

streamlit/scratch/investigate_incois_floats.py

@@ -0,0 +1,40 @@
+import pandas as pd
+
+PROF_FILE = r"c:\Users\harsh\incois\dashboard\ar_index_global_prof.txt"
+META_FILE = r"c:\Users\harsh\incois\dashboard\ar_index_global_meta.txt"
+
+df_meta = pd.read_csv(META_FILE, comment="#")
+df_meta.columns = df_meta.columns.str.strip()
+df_meta['wmo_id'] = df_meta['file'].str.extract(r'/(\d+)/')
+
+# Filter INCOIS
+meta_in = df_meta[df_meta['institution'] == 'IN']
+meta_wmos = set(meta_in['wmo_id'].unique())
+print(f"Total INCOIS WMOs in meta: {len(meta_wmos)}")
+
+# Now check prof file before any filtering
+df_prof_raw = pd.read_csv(PROF_FILE, comment="#", usecols=['file', 'date', 'latitude', 'longitude'])
+df_prof_raw.columns = df_prof_raw.columns.str.strip()
+df_prof_raw['wmo_id'] = df_prof_raw['file'].str.extract(r'/(\d+)/')
+
+prof_in_raw = df_prof_raw[df_prof_raw['wmo_id'].isin(meta_wmos)]
+prof_raw_wmos = set(prof_in_raw['wmo_id'].unique())
+
+print(f"INCOIS WMOs in raw prof file: {len(prof_raw_wmos)}")
+print(f"Missing from raw prof file: {len(meta_wmos - prof_raw_wmos)}")
+print(meta_wmos - prof_raw_wmos)
+
+# Now check after coordinate filtering
+df_prof_coords = prof_in_raw.dropna(subset=['latitude', 'longitude'])
+df_prof_coords = df_prof_coords[
+    (df_prof_coords["latitude"] >= -90) & (df_prof_coords["latitude"] <= 90) &
+    (df_prof_coords["longitude"] >= -180) & (df_prof_coords["longitude"] <= 180)
+]
+prof_coord_wmos = set(df_prof_coords['wmo_id'].unique())
+print(f"INCOIS WMOs after coordinate filter: {len(prof_coord_wmos)}")
+
+# Now check after date formatting and filtering
+df_prof_coords['date'] = pd.to_datetime(df_prof_coords['date'], format='%Y%m%d%H%M%S', errors='coerce')
+df_prof_dates = df_prof_coords.dropna(subset=['date'])
+prof_date_wmos = set(df_prof_dates['wmo_id'].unique())
+print(f"INCOIS WMOs after valid date filter: {len(prof_date_wmos)}")

streamlit/scratch/test_land_mask.py

@@ -0,0 +1,28 @@
+import pandas as pd
+from global_land_mask import globe
+import warnings
+
+warnings.filterwarnings("ignore")
+
+PROF_FILE = "ar_index_global_prof.txt"
+
+df = pd.read_csv(PROF_FILE, comment="#")
+df.columns = df.columns.str.strip()
+df = df.dropna(subset=["latitude", "longitude"])
+df = df[
+    (df["latitude"] >= -90) & (df["latitude"] <= 90) &
+    (df["longitude"] >= -180) & (df["longitude"] <= 180)
+]
+
+total_points = len(df)
+is_land = globe.is_land(df["latitude"].values, df["longitude"].values)
+total_land_points = is_land.sum()
+
+print(f"Total points: {total_points}")
+print(f"Total points on land globally: {total_land_points}")
+
+# India bounding box
+in_india_bbox = (df["latitude"] >= 6.0) & (df["latitude"] <= 36.0) & (df["longitude"] >= 68.0) & (df["longitude"] <= 98.0)
+india_land_points = (in_india_bbox & is_land).sum()
+
+print(f"Total points on land in India BBox: {india_land_points}")

streamlit/scratch/test_pivot_dates.py

@@ -0,0 +1,40 @@
+import pandas as pd
+
+META_FILE = r"c:\Users\harsh\incois\dashboard\ar_index_global_meta.txt"
+PROF_FILE = r"c:\Users\harsh\incois\dashboard\ar_index_global_prof.txt"
+
+df_meta = pd.read_csv(META_FILE, comment="#")
+df_meta.columns = df_meta.columns.str.strip()
+df_meta['wmo_id'] = df_meta['file'].str.extract(r'/(\d+)/')
+
+df_prof = pd.read_csv(PROF_FILE, comment="#", usecols=['file', 'date', 'institution'])
+df_prof.columns = df_prof.columns.str.strip()
+df_prof['wmo_id'] = df_prof['file'].str.extract(r'/(\d+)/')
+df_prof['date'] = pd.to_datetime(df_prof['date'], format='%Y%m%d%H%M%S', errors='coerce')
+
+# Get earliest profile date
+incois_prof = df_prof[df_prof["institution"] == "IN"]
+deployments = incois_prof.groupby("wmo_id")["date"].min().reset_index()
+
+# Get all 615 INCOIS meta floats
+meta_in = df_meta[df_meta["institution"] == "IN"].copy()
+print(f"Meta IN WMOs: {len(meta_in)}")
+
+# Merge
+merged = pd.merge(meta_in, deployments, on="wmo_id", how="left")
+
+# Fill missing dates with date_update
+merged["date_update"] = pd.to_datetime(merged["date_update"], format="%Y%m%d%H%M%S", errors='coerce')
+merged["date_final"] = merged["date"].fillna(merged["date_update"])
+
+print(f"Missing dates before fallback: {merged['date'].isna().sum()}")
+print(f"Missing dates after fallback: {merged['date_final'].isna().sum()}")
+
+merged["Year"] = merged["date_final"].dt.year
+merged["Month"] = merged["date_final"].dt.month
+
+print(f"Missing Year: {merged['Year'].isna().sum()}")
+print(f"Missing Month: {merged['Month'].isna().sum()}")
+
+pivot = merged.pivot_table(index="Month", columns="Year", values="wmo_id", aggfunc="count", fill_value=0)
+print(pivot.sum().sum())

streamlit/scratch/verify_filter.py

@@ -0,0 +1,41 @@
+import pandas as pd
+from global_land_mask import globe
+from pathlib import Path
+
+PROF_FILE = Path(r"c:\Users\harsh\incois\dashboard\ar_index_global_prof.txt")
+
+def verify():
+    print("Verifying land mask filtering...")
+    df = pd.read_csv(PROF_FILE, comment="#")
+    df.columns = df.columns.str.strip()
+    
+    initial_count = len(df)
+    print(f"Initial row count: {initial_count:,}")
+    
+    # Filter logic from dashboard.py
+    df = df.dropna(subset=["latitude", "longitude"])
+    
+    # Ensure coordinates are within valid ranges for global-land-mask
+    df = df[(df["latitude"] >= -90) & (df["latitude"] <= 90) & 
+            (df["longitude"] >= -180) & (df["longitude"] <= 180)]
+            
+    is_on_land = globe.is_land(df["latitude"].values, df["longitude"].values)
+    df_filtered = df[~is_on_land]
+    
+    final_count = len(df_filtered)
+    removed_count = initial_count - final_count
+    print(f"Final row count: {final_count:,}")
+    print(f"Rows removed (on land): {removed_count:,}")
+    
+    # Check if any profiles in the filtered set are still on land
+    still_on_land = globe.is_land(df_filtered["latitude"].values, df_filtered["longitude"].values)
+    land_count = still_on_land.sum()
+    print(f"Profiles remaining in sea-only set that are still on land: {land_count}")
+    
+    if land_count == 0:
+        print("\nSUCCESS: No profiles remain on land.")
+    else:
+        print(f"\nFAILURE: {land_count} profiles are still on land.")
+
+if __name__ == "__main__":
+    verify()

streamlit/scratch_ftp_test.py

@@ -0,0 +1,14 @@
+import urllib.request
+import os
+
+wmo = "2902174"
+dac = "incois"
+meta_url = f"ftp://ftp.ifremer.fr/ifremer/argo/dac/{dac}/{wmo}/{wmo}_meta.nc"
+meta_path = f"{wmo}_meta_test.nc"
+
+try:
+    print(f"Downloading {meta_url}...")
+    urllib.request.urlretrieve(meta_url, meta_path)
+    print(f"Success! Size: {os.path.getsize(meta_path)} bytes")
+except Exception as e:
+    print("Error:", e)

streamlit/scratch_nc_inspect.py

@@ -0,0 +1,20 @@
+import xarray as xr
+
+try:
+    ds_meta = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902174_meta.nc")
+    print("Meta vars:", list(ds_meta.variables))
+    for v in ['PLATFORM_NUMBER', 'PLATFORM_MAKER', 'FLOAT_SERIAL_NO', 'PLATFORM_TYPE', 'TRANS_SYSTEM', 'PROJECT_NAME', 'PI_NAME', 'LAUNCH_DATE', 'LAUNCH_LATITUDE', 'LAUNCH_LONGITUDE', 'DATA_CENTRE', 'FIRMWARE_VERSION', 'SENSOR']:
+        if v in ds_meta:
+            val = ds_meta[v].values
+            print(f"{v}: {val}")
+except Exception as e:
+    print("Meta error:", e)
+
+try:
+    ds_prof = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902174_prof.nc")
+    print("\nProf vars:", list(ds_prof.variables))
+    for v in ['CYCLE_NUMBER', 'JULD', 'PRES', 'TEMP', 'PSAL']:
+        if v in ds_prof:
+            print(f"{v} shape: {ds_prof[v].shape}")
+except Exception as e:
+    print("Prof error:", e)

streamlit/scratch_nc_parse.py

@@ -0,0 +1,53 @@
+import xarray as xr
+import numpy as np
+import pandas as pd
+from datetime import datetime
+
+ds_meta = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902174_meta.nc")
+ds_prof = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902174_prof.nc")
+
+def d(val):
+    if hasattr(val, "item") and callable(val.item):
+        try:
+            val = val.item()
+        except:
+            pass
+    if isinstance(val, bytes):
+        return val.decode('utf-8', errors='ignore').strip()
+    elif isinstance(val, np.ndarray) and val.dtype.kind == 'S':
+        return ", ".join([v.decode('utf-8', errors='ignore').strip() for v in val.flat if v.decode('utf-8', errors='ignore').strip()])
+    elif isinstance(val, (list, np.ndarray)):
+        return ", ".join([d(v) for v in val])
+    return str(val).strip()
+
+print("Maker:", d(ds_meta.PLATFORM_MAKER.values))
+print("Serial:", d(ds_meta.FLOAT_SERIAL_NO.values))
+print("Type:", d(ds_meta.PLATFORM_TYPE.values))
+print("Trans:", d(ds_meta.TRANS_SYSTEM.values))
+print("DC:", d(ds_meta.DATA_CENTRE.values))
+print("Sensors:", d(ds_meta.SENSOR.values))
+print("PTT:", d(ds_meta.PTT.values) if 'PTT' in ds_meta else "N/A")
+print("Launch date:", d(ds_meta.LAUNCH_DATE.values))
+print("Project:", d(ds_meta.PROJECT_NAME.values))
+print("PI:", d(ds_meta.PI_NAME.values))
+print("Lat:", float(ds_meta.LAUNCH_LATITUDE.values))
+
+cycle = int(np.nanmax(ds_prof.CYCLE_NUMBER.values))
+juld = ds_prof.JULD.values
+last_date_np = juld[~np.isnat(juld)]
+last_date = pd.to_datetime(last_date_np[-1]).strftime('%d/%m/%Y %H:%M:%S')
+
+last_pres = ds_prof.PRES.values[-1]
+last_temp = ds_prof.TEMP.values[-1]
+last_psal = ds_prof.PSAL.values[-1]
+
+valid_idx = ~np.isnan(last_pres)
+pres_v = last_pres[valid_idx]
+temp_v = last_temp[valid_idx]
+psal_v = last_psal[valid_idx]
+
+surface_idx = np.argmin(pres_v)
+bottom_idx = np.argmax(pres_v)
+print(f"Cycle: {cycle}, Last Date: {last_date}")
+print(f"Surface: {pres_v[surface_idx]} dbar {temp_v[surface_idx]} C {psal_v[surface_idx]} PSU")
+print(f"Bottom: {pres_v[bottom_idx]} dbar {temp_v[bottom_idx]} C {psal_v[bottom_idx]} PSU")

streamlit/scratch_nc_vars.py

@@ -0,0 +1,17 @@
+import xarray as xr
+ds = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902174_meta.nc")
+for v in ds.variables:
+    if ds[v].dtype.kind in ['S', 'U', 'O']:
+        try:
+            val = ds[v].values
+            if hasattr(val, "item") and callable(val.item) and val.ndim == 0:
+                val = val.item()
+            if isinstance(val, bytes):
+                val = val.decode('utf-8', errors='ignore').strip()
+            elif isinstance(val, np.ndarray) and val.dtype.kind == 'S':
+                val = ", ".join([x.decode('utf-8', errors='ignore').strip() for x in val.flat if x.decode('utf-8', errors='ignore').strip()])
+            else:
+                val = str(val).strip()
+            print(f"{v}: {val}")
+        except Exception as e:
+            pass

streamlit/scratch_nc_vars_2903424.py

@@ -0,0 +1,29 @@
+import xarray as xr
+import urllib.request
+from pathlib import Path
+import numpy as np
+
+wmo = "2903424"
+dac = "aoml"
+meta_url = f"ftp://ftp.ifremer.fr/ifremer/argo/dac/{dac}/{wmo}/{wmo}_meta.nc"
+meta_path = f"more_components/{wmo}_meta.nc"
+
+if not Path(meta_path).exists():
+    urllib.request.urlretrieve(meta_url, meta_path)
+
+ds_meta = xr.open_dataset(meta_path)
+for v in ds_meta.variables:
+    if ds_meta[v].dtype.kind in ['S', 'U', 'O']:
+        try:
+            val = ds_meta[v].values
+            if hasattr(val, "item") and callable(val.item) and val.ndim == 0:
+                val = val.item()
+            if isinstance(val, bytes):
+                val = val.decode('utf-8', errors='ignore').strip()
+            elif isinstance(val, np.ndarray) and val.dtype.kind == 'S':
+                val = ", ".join([x.decode('utf-8', errors='ignore').strip() for x in val.flat if x.decode('utf-8', errors='ignore').strip()])
+            else:
+                val = str(val).strip()
+            print(f"{v}: {val}")
+        except Exception as e:
+            pass

streamlit/scratch_nc_vars_2903424_specific.py

@@ -0,0 +1,22 @@
+import xarray as xr
+import numpy as np
+
+wmo = "2903424"
+meta_path = f"more_components/{wmo}_meta.nc"
+
+ds_meta = xr.open_dataset(meta_path)
+for v in ds_meta.variables:
+    if any(kw in v for kw in ["OWNER", "CENTRE", "INST", "DAC", "PI", "PROJECT"]):
+        try:
+            val = ds_meta[v].values
+            if hasattr(val, "item") and callable(val.item) and val.ndim == 0:
+                val = val.item()
+            if isinstance(val, bytes):
+                val = val.decode('utf-8', errors='ignore').strip()
+            elif isinstance(val, np.ndarray) and val.dtype.kind == 'S':
+                val = ", ".join([x.decode('utf-8', errors='ignore').strip() for x in val.flat if x.decode('utf-8', errors='ignore').strip()])
+            else:
+                val = str(val).strip()
+            print(f"{v}: {val}")
+        except Exception as e:
+            pass

streamlit/scratch_plot_test.py

@@ -0,0 +1,10 @@
+import xarray as xr
+import plot_utils
+
+try:
+    ds_prof = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902821_prof.nc")
+    cycles, dates, pres, temp, psal, rho = plot_utils.get_valid_data(ds_prof)
+    print("Success. Extracted valid data shapes:")
+    print("PRES:", pres.shape)
+except Exception as e:
+    print("Error:", e)

streamlit/scratch_prof_test.py

@@ -0,0 +1,47 @@
+import xarray as xr
+import numpy as np
+
+ds_prof = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902174_prof.nc")
+
+print("Checking last few cycles for valid PRES data...")
+pres_data = ds_prof.PRES.values
+valid_cycles = np.where(~np.isnan(pres_data).all(axis=1))[0]
+
+print(f"Total cycles: {pres_data.shape[0]}")
+print(f"Total valid cycles: {len(valid_cycles)}")
+
+if len(valid_cycles) > 0:
+    last_valid_idx = valid_cycles[-1]
+    print(f"Last valid cycle index: {last_valid_idx}, Cycle number: {ds_prof.CYCLE_NUMBER.values[last_valid_idx]}")
+    
+    last_pres = pres_data[last_valid_idx]
+    last_temp = ds_prof.TEMP.values[last_valid_idx] if 'TEMP' in ds_prof else np.full_like(last_pres, np.nan)
+    last_psal = ds_prof.PSAL.values[last_valid_idx] if 'PSAL' in ds_prof else np.full_like(last_pres, np.nan)
+    
+    valid_idx = ~np.isnan(last_pres)
+    pres_v = last_pres[valid_idx]
+    temp_v = last_temp[valid_idx]
+    psal_v = last_psal[valid_idx]
+    
+    print(f"Found {len(pres_v)} valid pressure points in this cycle.")
+    
+    if len(pres_v) > 0:
+        surface_idx = np.argmin(pres_v)
+        bottom_idx = np.argmax(pres_v)
+        print(f"Surface: {pres_v[surface_idx]:.2f} dbar {temp_v[surface_idx]:.3f}°C {psal_v[surface_idx]:.3f} PSU")
+        print(f"Bottom: {pres_v[bottom_idx]:.2f} dbar {temp_v[bottom_idx]:.3f}°C {psal_v[bottom_idx]:.3f} PSU")
+
+ds_meta = xr.open_dataset(r"C:\Users\harsh\incois\dashboard\more_components\2902174_meta.nc")
+def d(val):
+    if hasattr(val, "item") and callable(val.item) and val.ndim == 0:
+        val = val.item()
+    if isinstance(val, bytes):
+        return val.decode('utf-8', errors='ignore').strip()
+    elif isinstance(val, np.ndarray) and val.dtype.kind == 'S':
+        return ", ".join([v.decode('utf-8', errors='ignore').strip() for v in val.flat if v.decode('utf-8', errors='ignore').strip()])
+    return str(val).strip()
+
+print("\nData Centre fields:")
+print(f"DATA_CENTRE: {d(ds_meta.DATA_CENTRE.values) if 'DATA_CENTRE' in ds_meta else 'N/A'}")
+print(f"OPERATING_INSTITUTION: {d(ds_meta.OPERATING_INSTITUTION.values) if 'OPERATING_INSTITUTION' in ds_meta else 'N/A'}")
+

streamlit/test_counts.py

@@ -0,0 +1,20 @@
+import pandas as pd
+
+# Load data
+print("Loading data...")
+df = pd.read_parquet("cache/profiles.parquet")
+
+# Filter to Indian Ocean (default dashboard filter)
+df_io = df[
+    (df["longitude"] >= 20.0) & (df["longitude"] <= 145.0) & 
+    (df["latitude"] >= -70.1) & (df["latitude"] <= 30.0)
+]
+
+print("\n--- Metric 1: New Floats Deployed per Year (Current Dashboard Logic) ---")
+float_years = df_io.dropna(subset=["year"]).groupby("wmo_id")["year"].min().reset_index()
+yearly_new = float_years.groupby("year")["wmo_id"].nunique().reset_index()
+print(yearly_new[yearly_new["year"].isin([1999, 2001, 2003, 2011, 2014, 2016, 2020, 2025, 2026])].to_string(index=False))
+
+print("\n--- Metric 2: Active Floats per Year (Unique WMOs reporting in that year) ---")
+yearly_active = df_io.dropna(subset=["year"]).groupby("year")["wmo_id"].nunique().reset_index()
+print(yearly_active[yearly_active["year"].isin([1999, 2000, 2001, 2003, 2004, 2008, 2016, 2020, 2026])].to_string(index=False))

streamlit/test_last7.py

@@ -0,0 +1,21 @@
+import pandas as pd
+from datetime import timedelta
+
+print('Loading data...')
+df = pd.read_parquet('cache/profiles.parquet')
+
+print('\n--- Indian Ocean last 7 days ---')
+df_io = df[
+    (df['longitude'] >= 20.0) & (df['longitude'] <= 145.0) & 
+    (df['latitude'] >= -70.1) & (df['latitude'] <= 30.0)
+]
+latest_io = df_io['date'].max()
+last7_io = df_io[df_io['date'] >= latest_io - timedelta(days=7)]
+print(f"Floats: {last7_io['wmo_id'].nunique()}")
+print(f"Profiles: {len(last7_io)}")
+
+print('\n--- Indian Ocean last 7 days by institution ---')
+tree_data = last7_io.groupby('institution').agg(floats=('wmo_id', 'nunique'), profiles=('file', 'count')).reset_index().sort_values('floats', ascending=False)
+print(tree_data.to_string(index=False))
+
+print('\n--- Let us also try with ONLY BGC floats? No, the image says All Communities ---')