Initial deployment (no data - downloaded from HF Dataset at startup)

.gitattributes

@@ -0,0 +1,40 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.shp filter=lfs diff=lfs merge=lfs -text
+*.dbf filter=lfs diff=lfs merge=lfs -text
+*.shx filter=lfs diff=lfs merge=lfs -text
+*.cpg filter=lfs diff=lfs merge=lfs -text
+*.prj filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+*.pyo
+.DS_Store
+data/

.streamlit/config.toml

@@ -0,0 +1,9 @@
+[theme]
+primaryColor     = "#00ff88"
+backgroundColor  = "#0a0f0d"
+secondaryBackgroundColor = "#111a14"
+textColor        = "#e8f5ec"
+font             = "monospace"
+
+[server]
+maxUploadSize = 50

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.13.5-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+COPY src/ ./src/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,13 @@
+---
+title: ArtenTracker
+emoji: 🦫
+colorFrom: green
+colorTo: green
+sdk: streamlit
+sdk_version: 1.57.0
+app_file: app.py
+pinned: false
+---
+
+Arten Tracker — Verbreitung invasiver und ausgewählter heimischer Arten in Europa.
+Datenquelle: [GBIF](https://www.gbif.org)

app.py

@@ -0,0 +1,559 @@
+import math
+from pathlib import Path
+import pandas as pd
+import streamlit as st
+from streamlit_folium import st_folium
+
+# ── Daten-Download von HF Dataset (nur beim ersten Start auf dem Server) ───────
+_DATA_DIR = Path(__file__).parent / "data"
+_HF_DATASET = "Sueamit/arten-tracker-data"
+
+def _ensure_data():
+    cache_dir = _DATA_DIR / "species_cache"
+    parquet_files = list(cache_dir.glob("*.parquet")) if cache_dir.exists() else []
+    boundaries_ok = (_DATA_DIR / "boundaries" / "vg250" / "VG250_LAN.shp").exists()
+    if len(parquet_files) >= 4 and boundaries_ok:
+        return
+    st.info(
+        "Erster Start: Daten werden vom Hugging Face Dataset heruntergeladen (~1,6 GB). "
+        "Dies dauert einmalig 5–15 Minuten."
+    )
+    with st.spinner("Download läuft …"):
+        from huggingface_hub import snapshot_download
+        snapshot_download(
+            repo_id=_HF_DATASET,
+            repo_type="dataset",
+            local_dir=str(_DATA_DIR),
+        )
+    st.rerun()
+
+_ensure_data()
+# ── Ende Daten-Download ────────────────────────────────────────────────────────
+
+from src.utils import (
+    SCOPE_OPTIONS, BUNDESLAENDER_LIST, EUROPEAN_COUNTRIES,
+    CURRENT_YEAR, HIST_YEAR_TO, YEAR_FROM,
+)
+from src.species_config import SPECIES, SPECIES_DISPLAY_LABELS
+from src.data_cache import (
+    cache_exists, cache_info, load_historical, save_historical,
+    historical_year_range,
+)
+from src.gbif_client import fetch_all_occurrences, fetch_current_year, get_occurrence_count
+from src.csv_importer import import_gbif_csv
+from src.boundary_loader import (
+    get_boundary_gdf, filter_gemeinden_by_bundesland, filter_admin1_by_country,
+    check_boundary_availability,
+)
+from src.spatial_analysis import build_geodataframe, spatial_join
+from src.temporal_analysis import filter_current_year as filter_cy
+from src.map_builder import build_current_map
+from src.chart_builder import build_trend_chart, prepare_per_unit_data, build_unit_row_chart, compute_trend_from_df
+from src.utils import UNIT_NAME_COL
+from src.styles_v1_naturetech import inject_css, hide_sidebar
+
+st.set_page_config(
+    page_title="Arten Tracker",
+    page_icon="🦫",
+    layout="wide",
+    initial_sidebar_state="auto",
+)
+inject_css()
+
+
+# ── Home page ──────────────────────────────────────────────────────────────────
+
+def render_home():
+    hide_sidebar()
+
+    # Hero
+    st.markdown("""
+<div class="at-hero">
+  <h1>🦫 Arten Tracker</h1>
+  <p>Interaktive Verbreitungskarten für Tiere und Pflanzen in Europa — basierend auf GBIF-Daten</p>
+</div>
+""", unsafe_allow_html=True)
+
+    # Feature tiles
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.markdown("""<div class="at-feature-box">
+<div class="at-feature-icon">🗺️</div>
+<strong>Interaktive Karten</strong>
+<p>Fundpunkte und Choropleth-Karten auf Gemeinde-, Bundes&shy;land- und Länderebene</p>
+</div>""", unsafe_allow_html=True)
+    with col2:
+        st.markdown("""<div class="at-feature-box">
+<div class="at-feature-icon">📈</div>
+<strong>Zeitverlauf</strong>
+<p>Jahrestrends von 2006 bis heute — live ergänzt durch aktuelle GBIF-Meldungen</p>
+</div>""", unsafe_allow_html=True)
+    with col3:
+        st.markdown("""<div class="at-feature-box">
+<div class="at-feature-icon">🔬</div>
+<strong>Mehrere Arten</strong>
+<p>Asiatische Hornisse, Europäischer Biber, Wildkatze, Kanadagans und mehr</p>
+</div>""", unsafe_allow_html=True)
+
+    # Start button
+    st.markdown("<br>", unsafe_allow_html=True)
+    col_btn = st.columns([1, 2, 1])[1]
+    with col_btn:
+        st.markdown("""
+<style>
+div[data-testid="stButton"].start-btn > button {
+    width: 100%; font-size: 1.1rem !important; padding: 0.75rem 2rem !important;
+    border-radius: 12px !important; font-weight: 700 !important;
+}
+</style>""", unsafe_allow_html=True)
+        def _go_to_tracker():
+            st.session_state["nav_radio"] = "🔍 Arten Tracker"
+        st.button("🔍 Arten Tracker starten →", type="primary", use_container_width=True,
+                  on_click=_go_to_tracker)
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # Data source card
+    st.markdown("""<div class="at-card">
+<h3>📡 Datenherkunft</h3>
+<p>Die Funddaten stammen aus dem <strong>Global Biodiversity Information Facility (GBIF)</strong>,
+dem weltweit größten offenen Datennetzwerk für Biodiversitätsinformationen.
+GBIF aggregiert Meldungen von Museen, Naturschutzbehörden, Forschungsinstituten
+und Bürgerwissenschaftsprojekten. 🔗 <a href="https://www.gbif.org" target="_blank">gbif.org</a></p>
+<p><strong>⚠️ Hinweis zur Datenqualität:</strong> Die GBIF-Daten sind unvollständig und können Fehler
+enthalten. Fundpunkte spiegeln nicht die tatsächliche Verbreitung einer Art wider, sondern zeigen,
+wo Beobachtungen gemeldet und eingepflegt wurden. Regionale Unterschiede in der Meldeintensität,
+fehlerhafte Koordinaten und taxonomische Unstimmigkeiten sind bekannte Einschränkungen.
+Die Daten eignen sich für eine erste Orientierung, jedoch nicht für wissenschaftliche Analysen
+ohne weitere Qualitätsprüfung.</p>
+</div>""", unsafe_allow_html=True)
+
+    # About card
+    st.markdown("""<div class="at-card">
+<h3>💡 Über dieses Projekt</h3>
+<p>Arten Tracker wurde von <strong>Johannes Timaeus</strong> entwickelt — mit Unterstützung von
+<a href="https://claude.ai/code" target="_blank">Claude Code</a> (Anthropic) als Beispiel
+für <em>Vibe Coding</em>: die experimentelle, KI-gestützte Softwareentwicklung, bei der Ideen
+direkt in funktionsfähigen Code übersetzt werden.</p>
+<p>Es handelt sich um <strong>experimentelle Software</strong>. Funktionsumfang und Datenqualität
+werden kontinuierlich weiterentwickelt.</p>
+</div>""", unsafe_allow_html=True)
+
+    # Feedback card
+    st.markdown("""<div class="at-card">
+<h3>✉️ Feedback</h3>
+<p>Fehler, Verbesserungsvorschläge oder Artenwünsche sind herzlich willkommen:<br>
+📧 <a href="mailto:johannes.timaeus@bio-kultur.org">johannes.timaeus@bio-kultur.org</a></p>
+</div>""", unsafe_allow_html=True)
+
+
+# ── Sidebar ────────────────────────────────────────────────────────────────────
+
+def render_sidebar():
+    st.sidebar.title("🦫 Arten Tracker")
+    st.sidebar.caption("Ausgewählte Arten · GBIF-Daten")
+    st.sidebar.divider()
+
+    _NAV_OPTIONS = ["🏠 Startseite", "🔍 Arten Tracker"]
+    st.session_state.setdefault("nav_radio", "🏠 Startseite")
+
+    st.sidebar.subheader("Navigation")
+    page = st.sidebar.radio(
+        "Seite",
+        options=_NAV_OPTIONS,
+        key="nav_radio",
+        label_visibility="collapsed",
+    )
+    st.sidebar.divider()
+
+    if page == "🏠 Startseite":
+        return None  # signal to main() to render home page
+
+    st.sidebar.subheader("Art auswählen")
+    species_options = [None] + list(SPECIES.keys())
+    selected_label = st.sidebar.selectbox(
+        "Art",
+        options=species_options,
+        format_func=lambda k: "— Art auswählen —" if k is None else SPECIES_DISPLAY_LABELS[k],
+        key="selected_species",
+    )
+
+    if selected_label is None:
+        st.sidebar.info("Bitte oben eine Art auswählen, um die Analyse zu starten.")
+        return "no_species"
+
+    species_cfg = SPECIES[selected_label]
+    taxon_key = species_cfg["taxon_key"]
+    species_name = selected_label
+
+    st.sidebar.divider()
+
+    st.sidebar.subheader("Geografische Skala")
+    dl_option = st.sidebar.radio(
+        "Download & Auswertungsebene",
+        options=[1, 2, 3],
+        index=1,
+        format_func=lambda x: {
+            1: "Weltweit + Vergleich Länder",
+            2: "Länder + Vergleich Bundesländer",
+            3: "Bundesland + Vergleich Kommunen",
+        }[x],
+    )
+
+    country_filter = None
+    bl_filter = "Alle"
+
+    if dl_option == 2:
+        eu_names = sorted(EUROPEAN_COUNTRIES.keys())
+        default_idx = eu_names.index("Deutschland")
+        country_name = st.sidebar.selectbox("Land auswählen", options=eu_names, index=default_idx)
+        country_filter = EUROPEAN_COUNTRIES[country_name]
+    elif dl_option == 3:
+        country_filter = "DE"
+        bl_filter = st.sidebar.selectbox("Bundesland", options=BUNDESLAENDER_LIST)
+
+    st.sidebar.divider()
+    st.sidebar.subheader("Datenqualität")
+    max_uncertainty = st.sidebar.slider(
+        "Max. Koordinatengenauigkeit (m)",
+        min_value=100, max_value=50000, value=50000, step=100,
+    )
+
+    st.sidebar.divider()
+    st.sidebar.caption("Daten: [GBIF](https://www.gbif.org) | Grenzen: BKG VG250, Natural Earth")
+
+    return (
+        taxon_key, species_name, species_cfg,
+        dl_option, country_filter, bl_filter,
+        max_uncertainty,
+    )
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _get_scope(dl_option: int, country_filter: str | None) -> str:
+    if dl_option == 1:
+        return "countries"
+    elif dl_option == 2:
+        return "bundeslaender" if country_filter == "DE" else "admin1"
+    return "gemeinden"
+
+
+def _fmt_mb(mb: float) -> str:
+    return f"{mb:.1f} MB" if mb >= 1 else f"{mb * 1024:.0f} KB"
+
+
+def _show_cache_panel(taxon_key: int, country_filter: str | None, species_name: str):
+    """Render the cache status box. Returns True if data is ready, False otherwise."""
+    hist_from, hist_to = historical_year_range()
+    country_label = country_filter if country_filter else "weltweit"
+    info = cache_info(taxon_key, country_filter)
+
+    if info:
+        fallback_note = " *(weltweiter Cache, gefiltert)*" if info.get("worldwide_fallback") else ""
+        st.success(
+            f"**Historische Daten gespeichert** ({hist_from}–{hist_to}, {country_label}){fallback_note}  \n"
+            f"{info['rows']:,} Datensätze · {_fmt_mb(info['size_mb'])} · "
+            f"Stand: {info['modified'].strftime('%d.%m.%Y %H:%M')}"
+        )
+        return True
+
+    # No cache — two options: API download or local CSV import
+    st.warning(
+        f"Keine gespeicherten historischen Daten für **{species_name}** ({country_label}). "
+        "Einmalig herunterladen oder lokale GBIF-Datei importieren.",
+        icon="📥",
+    )
+
+    tab_api, tab_import = st.tabs(["⬇️ Via GBIF-API herunterladen", "📂 Lokale GBIF-Datei importieren"])
+
+    with tab_api:
+        with st.spinner("Prüfe verfügbare Datensätze bei GBIF…"):
+            total = get_occurrence_count(taxon_key, country_filter, hist_from, hist_to)
+
+        if total <= 0:
+            st.info(
+                "GBIF meldet keine Fundpunkte für diesen Bereich im historischen Zeitraum."
+                if total == 0 else "GBIF-Abfrage fehlgeschlagen."
+            )
+        else:
+            pages = math.ceil(min(total, 99_700) / 300)
+            est_min = max(1, round(pages * 1.2 / 60))
+            st.info(
+                f"**{total:,}** Fundpunkte verfügbar ({country_label}, {hist_from}–{hist_to})  \n"
+                f"Geschätzte Ladezeit: ~{est_min} Minute(n). Download läuft einmalig.",
+                icon="ℹ️",
+            )
+            if st.button("⬇️ Historische Daten laden & speichern", type="primary",
+                         key=f"dl_{taxon_key}_{country_filter}"):
+                df_hist = fetch_all_occurrences(
+                    taxon_key, country=country_filter,
+                    year_from=hist_from, year_to=hist_to,
+                    progress_label=f"Lade {species_name} ({hist_from}–{hist_to})…",
+                )
+                if df_hist.empty:
+                    st.error("Download lieferte keine Daten. Bitte erneut versuchen.")
+                else:
+                    save_historical(taxon_key, country_filter, df_hist)
+                    st.success(f"{len(df_hist):,} Datensätze gespeichert.")
+                    st.rerun()
+
+    with tab_import:
+        st.markdown(
+            "Pfad zur heruntergeladenen GBIF-Datei (CSV oder TSV, tab-getrennt).  \n"
+            "Die Datei wird als **weltweiter Cache** gespeichert und für alle Länderfilter genutzt."
+        )
+
+        local_file = species_cfg.get("local_file", "")
+        if local_file:
+            st.info(f"Lokale Datei konfiguriert: `{local_file}`", icon="📁")
+            if st.button("⚡ Schnell-Import (vorkonfigurierter Pfad)", type="primary",
+                         key=f"quickimport_{taxon_key}"):
+                try:
+                    with st.spinner(f"Lese {local_file} …"):
+                        df_imported = import_gbif_csv(local_file, exclude_current_year=True)
+                    if df_imported.empty:
+                        st.error("Keine gültigen Koordinaten in der Datei gefunden.")
+                    else:
+                        save_historical(taxon_key, None, df_imported)
+                        st.success(
+                            f"{len(df_imported):,} Datensätze importiert und als weltweiter Cache gespeichert."
+                        )
+                        st.rerun()
+                except FileNotFoundError as e:
+                    st.error(str(e))
+                except Exception as e:
+                    st.error(f"Fehler beim Import: {e}")
+            st.divider()
+
+        csv_path = st.text_input(
+            "Oder anderen Dateipfad eingeben",
+            placeholder="/home/…/0010143-250426092105405.csv",
+            key=f"csv_path_{taxon_key}",
+        )
+        if st.button("📂 Importieren & speichern", type="secondary",
+                     key=f"import_{taxon_key}"):
+            if not csv_path:
+                st.error("Bitte einen Dateipfad eingeben.")
+            else:
+                try:
+                    with st.spinner(f"Lese {csv_path} …"):
+                        df_imported = import_gbif_csv(csv_path, exclude_current_year=True)
+                    if df_imported.empty:
+                        st.error("Keine gültigen Koordinaten in der Datei gefunden.")
+                    else:
+                        save_historical(taxon_key, None, df_imported)
+                        st.success(
+                            f"{len(df_imported):,} Datensätze importiert und als weltweiter Cache gespeichert."
+                        )
+                        st.rerun()
+                except FileNotFoundError as e:
+                    st.error(str(e))
+                except Exception as e:
+                    st.error(f"Fehler beim Import: {e}")
+
+    return False
+
+
+# ── Main ───────────────────────────────────────────────────────────────────────
+
+def main():
+    result = render_sidebar()
+    if result is None:
+        render_home()
+        return
+    if result == "no_species":
+        st.markdown("""
+<div class="at-hero" style="text-align:center;padding:3rem 2rem">
+  <h1 style="font-size:1.8rem">Art auswählen</h1>
+  <p style="font-size:1.05rem;margin-top:0.75rem">
+    Wähle links in der Seitenleiste eine Art aus, um die Analyse und Karten zu laden.
+  </p>
+</div>""", unsafe_allow_html=True)
+        return
+
+    (
+        taxon_key, species_name, species_cfg,
+        dl_option, country_filter, bl_filter,
+        max_uncertainty,
+    ) = result
+
+    icon = species_cfg["icon"]
+    common = species_cfg["common_name_de"]
+    st.markdown(
+        f"<h1 style='margin-bottom:0.1rem'>{icon} {common}</h1>"
+        f"<p style='color:#7ab89a;font-size:0.95rem;margin-top:0.2rem'>"
+        f"<em>{species_name}</em> &nbsp;·&nbsp; {species_cfg['description']}</p>",
+        unsafe_allow_html=True,
+    )
+    st.divider()
+
+    scope = _get_scope(dl_option, country_filter)
+
+    # ── Cache panel ──────────────────────────────────────────────────────────
+    hist_ready = _show_cache_panel(taxon_key, country_filter, species_name)
+    if not hist_ready:
+        return
+
+    # ── Load data (full range, unfiltered by year) ────────────────────────────
+    df_hist = load_historical(taxon_key, country_filter)
+    df_current = fetch_current_year(taxon_key, country_filter)
+
+    n_hist = len(df_hist)
+    n_current = len(df_current)
+    st.caption(
+        f"Historische Daten: **{n_hist:,}** Fundpunkte ({YEAR_FROM}–{HIST_YEAR_TO}) · "
+        f"Aktuelles Jahr ({CURRENT_YEAR}): **{n_current:,}** Funde (live von GBIF)"
+    )
+
+    df_full = pd.concat([df_hist, df_current], ignore_index=True) if not df_current.empty else df_hist.copy()
+
+    # Coordinate uncertainty filter (applied to all data)
+    if "coordinateUncertaintyInMeters" in df_full.columns:
+        before = len(df_full)
+        df_full = df_full[
+            df_full["coordinateUncertaintyInMeters"].isna() |
+            (df_full["coordinateUncertaintyInMeters"] <= max_uncertainty)
+        ].copy()
+        removed = before - len(df_full)
+        if removed > 0:
+            st.caption(f"{removed:,} Funde wegen Koordinatengenauigkeit > {max_uncertainty} m ausgeblendet")
+
+    if df_full.empty:
+        st.warning("Keine Fundpunkte nach Filterung vorhanden.")
+        return
+
+    # ── Boundary data ────────────────────────────────────────────────────────
+    boundary_gdf = get_boundary_gdf(scope)
+    outline_gdf = None
+
+    if dl_option == 2 and country_filter and country_filter != "DE" and boundary_gdf is not None:
+        boundary_gdf = filter_admin1_by_country(boundary_gdf, country_filter)
+    elif dl_option == 3:
+        if boundary_gdf is not None and bl_filter != "Alle":
+            boundary_gdf = filter_gemeinden_by_bundesland(boundary_gdf, bl_filter)
+        bl_gdf = get_boundary_gdf("bundeslaender")
+        if bl_gdf is not None:
+            outline_gdf = bl_gdf[bl_gdf["GEN"] == bl_filter].copy() if bl_filter != "Alle" else bl_gdf
+
+    # ── Spatial join on full dataset ──────────────────────────────────────────
+    occurrences_gdf = build_geodataframe(df_full)
+    has_boundary = boundary_gdf is not None and not boundary_gdf.empty
+
+    if has_boundary:
+        with st.spinner("Räumliche Zuordnung läuft…"):
+            joined_gdf = spatial_join(occurrences_gdf, boundary_gdf, scope)
+    else:
+        joined_gdf = occurrences_gdf
+
+    joined_filtered = joined_gdf
+
+    unit_col = UNIT_NAME_COL.get(scope, "GEN")
+
+    # All years actually present in data (for dropdowns and trend charts)
+    all_data_years = sorted(
+        joined_gdf["year"].dropna().astype(int).unique()
+    ) if "year" in joined_gdf.columns else []
+
+    # ── Tabs ─────────────────────────────────────────────────────────────────
+    tab1, tab2, tab3 = st.tabs([
+        f"📍 Aktuell ({CURRENT_YEAR})",
+        "🗂️ Historische Karte",
+        "📈 Zeitverlauf",
+    ])
+
+    with tab1:
+        current_gdf = filter_cy(joined_filtered)
+        st.subheader(f"Fundpunkte {CURRENT_YEAR} — {len(current_gdf):,} Funde (live)")
+        if len(current_gdf) == 0:
+            st.info(
+                f"Keine Fundpunkte für {CURRENT_YEAR} in diesem Bereich. "
+                "GBIF-Daten haben oft einen Verzug von Wochen bis Monaten.",
+                icon="��️",
+            )
+        current_map = build_current_map(current_gdf, scope, boundary_gdf, outline_gdf)
+        st_folium(current_map, width="100%", height=600, returned_objects=[], key="map_current")
+
+    with tab2:
+        if boundary_gdf is None:
+            st.warning("Keine Grenzdaten verfügbar — Karte benötigt politische Grenzen.")
+        elif not all_data_years:
+            st.info("Keine Jahresdaten vorhanden.")
+        else:
+            year_options = list(reversed(all_data_years))
+            _ctx = f"{species_name}|{dl_option}|{country_filter}|{bl_filter}"
+            if st.session_state.get("_hist_ctx") != _ctx:
+                st.session_state["_hist_ctx"] = _ctx
+                st.session_state["hist_year_select"] = year_options[0]
+            selected_year = st.selectbox("Jahr wählen", options=year_options,
+                                         key="hist_year_select")
+            year_gdf = joined_gdf[joined_gdf["year"] == selected_year].copy()
+            st.subheader(f"Fundkarte {selected_year} — {len(year_gdf):,} Funde")
+            if len(year_gdf) == 0:
+                st.info(f"Keine Funde für {selected_year} in diesem Bereich.", icon="ℹ️")
+            hist_map = build_current_map(year_gdf, scope, boundary_gdf, outline_gdf)
+            st_folium(hist_map, width="100%", height=600, returned_objects=[],
+                      key="map_hist")
+
+    with tab3:
+        # Overall trend — full data range
+        trend_df = compute_trend_from_df(joined_gdf if has_boundary else df_full)
+
+        if trend_df.empty:
+            st.info("Keine Trenddaten vorhanden.")
+        else:
+            y_from = int(trend_df["year"].min())
+            y_to = int(trend_df["year"].max())
+            total_all = int(trend_df["count"].sum())
+            current_n = int(trend_df[trend_df["year"] == CURRENT_YEAR]["count"].sum())
+            peak_year = int(trend_df.loc[trend_df["count"].idxmax(), "year"])
+
+            col1, col2, col3 = st.columns(3)
+            col1.metric(f"Gesamt {y_from}–{y_to}", f"{total_all:,}")
+            col2.metric(f"Funde {CURRENT_YEAR} (live)", f"{current_n:,}")
+            col3.metric("Jahr mit meisten Funden", str(peak_year))
+
+            # Scope-dependent labels
+            scope_labels = {
+                "countries":     ("Gesamt (weltweit)",       "Land",          "Länder"),
+                "bundeslaender": (f"Gesamt ({country_filter or 'Land'})", "Bundesland", "Bundesländer"),
+                "admin1":        (f"Gesamt ({country_filter or 'Land'})", "Region",     "Regionen"),
+                "gemeinden":     (f"Gesamt ({bl_filter})",   "Gemeinde",      "Gemeinden"),
+                "kreise":        (f"Gesamt ({bl_filter})",   "Kreis",         "Kreise"),
+            }
+            top_label, unit_label, units_label = scope_labels.get(
+                scope, ("Gesamt", "Einheit", "Einheiten")
+            )
+
+            # ── Overall chart ──────────────────────────────────────────────
+            st.subheader(f"Funde pro Jahr — {top_label}")
+            overall_chart = build_trend_chart(trend_df, species_name, y_from, y_to)
+            st.altair_chart(overall_chart, width="stretch")
+
+            # ── Per-unit charts (one full-width row per unit) ──────────────
+            if has_boundary and unit_col in joined_gdf.columns:
+                n_units = joined_gdf[unit_col].nunique()
+                max_show = 16 if scope == "bundeslaender" else min(n_units, 20)
+
+                st.subheader(
+                    f"Funde pro Jahr je {unit_label}"
+                    + (f" (Top {max_show} von {n_units})" if n_units > max_show else "")
+                )
+
+                top_units, unit_data = prepare_per_unit_data(
+                    joined_gdf, unit_col=unit_col, max_units=max_show
+                )
+
+                if not top_units:
+                    st.info("Keine Einheitendaten für Detaildarstellung verfügbar.")
+                else:
+                    global_y_max = int(unit_data["count"].max())
+                    for unit_name in top_units:
+                        st.markdown(f"**{unit_name}**")
+                        df_unit = unit_data[unit_data[unit_col] == unit_name]
+                        chart = build_unit_row_chart(df_unit, y_max=global_y_max)
+                        st.altair_chart(chart, width="stretch")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,14 @@
+streamlit>=1.57.0
+huggingface_hub>=0.23.0
+streamlit-folium>=0.27.0
+pygbif>=0.6.6
+geopandas>=1.0.0
+shapely>=2.1.0
+pyproj>=3.7.0
+fiona>=1.9.0
+pandas>=2.2.0
+numpy>=1.26.0
+folium>=0.20.0
+altair>=6.0.0
+requests>=2.31.0
+pyarrow>=16.0.0

src/boundary_loader.py

@@ -0,0 +1,111 @@
+from pathlib import Path
+from functools import lru_cache
+import geopandas as gpd
+
+from src.utils import VG250_DIR, NE_DIR, BKG_FILES, NE_FILES, AGS_TO_BUNDESLAND
+
+
+def _find_shapefile(directory: Path, filename: str) -> Path | None:
+    direct = directory / filename
+    if direct.exists():
+        return direct
+    for sub in sorted(directory.iterdir()):
+        if sub.is_dir():
+            candidate = sub / filename
+            if candidate.exists():
+                return candidate
+    return None
+
+
+def _load_and_reproject(path: Path, keep_cols: list[str]) -> gpd.GeoDataFrame:
+    gdf = gpd.read_file(path)
+    available = [c for c in keep_cols if c in gdf.columns] + ["geometry"]
+    gdf = gdf[available].copy()
+    if gdf.crs and gdf.crs.to_epsg() != 4326:
+        gdf = gdf.to_crs("EPSG:4326")
+    elif gdf.crs is None:
+        # No CRS info — assume WGS84 (unlikely for BKG but safe fallback)
+        gdf = gdf.set_crs("EPSG:4326")
+    return gdf
+
+
+@lru_cache(maxsize=None)
+def load_bundeslaender() -> gpd.GeoDataFrame | None:
+    path = _find_shapefile(VG250_DIR, BKG_FILES["bundeslaender"])
+    if path is None:
+        return None
+    return _load_and_reproject(path, ["GEN", "AGS", "EWZ"])
+
+
+@lru_cache(maxsize=None)
+def load_kreise() -> gpd.GeoDataFrame | None:
+    path = _find_shapefile(VG250_DIR, BKG_FILES["kreise"])
+    if path is None:
+        return None
+    return _load_and_reproject(path, ["GEN", "AGS", "BEZ", "EWZ"])
+
+
+@lru_cache(maxsize=None)
+def load_gemeinden() -> gpd.GeoDataFrame | None:
+    path = _find_shapefile(VG250_DIR, BKG_FILES["gemeinden"])
+    if path is None:
+        return None
+    gdf = _load_and_reproject(path, ["GEN", "AGS", "BEZ", "EWZ"])
+    if "AGS" in gdf.columns:
+        gdf["bundesland"] = gdf["AGS"].str[:2].map(AGS_TO_BUNDESLAND)
+    return gdf
+
+
+@lru_cache(maxsize=None)
+def load_world_countries() -> gpd.GeoDataFrame | None:
+    path = _find_shapefile(NE_DIR, NE_FILES["countries"])
+    if path is None:
+        return None
+    return _load_and_reproject(path, ["NAME", "ISO_A2", "CONTINENT", "POP_EST"])
+
+
+@lru_cache(maxsize=None)
+def load_admin1() -> gpd.GeoDataFrame | None:
+    path = _find_shapefile(NE_DIR, NE_FILES["admin1"])
+    if path is None:
+        return None
+    return _load_and_reproject(path, ["name", "admin", "iso_a2", "type_en"])
+
+
+def get_boundary_gdf(scope: str) -> gpd.GeoDataFrame | None:
+    loaders = {
+        "bundeslaender": load_bundeslaender,
+        "kreise": load_kreise,
+        "gemeinden": load_gemeinden,
+        "countries": load_world_countries,
+        "admin1": load_admin1,
+    }
+    loader = loaders.get(scope)
+    if loader is None:
+        return None
+    try:
+        return loader()
+    except Exception as e:
+        print(f"[boundary] FEHLER beim Laden von scope={scope}: {e}")
+        return None
+
+
+def filter_gemeinden_by_bundesland(gdf: gpd.GeoDataFrame, bundesland: str) -> gpd.GeoDataFrame:
+    if "bundesland" not in gdf.columns or bundesland == "Alle":
+        return gdf
+    return gdf[gdf["bundesland"] == bundesland].copy()
+
+
+def filter_admin1_by_country(gdf: gpd.GeoDataFrame, iso2: str) -> gpd.GeoDataFrame:
+    if "iso_a2" not in gdf.columns or not iso2:
+        return gdf
+    return gdf[gdf["iso_a2"].str.upper() == iso2.upper()].copy()
+
+
+def check_boundary_availability() -> dict[str, bool]:
+    result = {}
+    for scope, filename in BKG_FILES.items():
+        result[scope] = _find_shapefile(VG250_DIR, filename) is not None
+    for scope, filename in NE_FILES.items():
+        result[scope] = _find_shapefile(NE_DIR, filename) is not None
+    return result

src/chart_builder.py

@@ -0,0 +1,122 @@
+import pandas as pd
+import altair as alt
+
+from src.utils import PERIODS, CURRENT_YEAR, UNIT_NAME_COL
+
+
+def build_trend_chart(trend_df: pd.DataFrame, species_name: str,
+                      year_from: int = None, year_to: int = None) -> alt.Chart:
+    base = alt.Chart(trend_df).encode(
+        x=alt.X("year:O", title="Jahr", axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y("count:Q", title="Anzahl Funde", scale=alt.Scale(zero=True)),
+        tooltip=[
+            alt.Tooltip("year:O", title="Jahr"),
+            alt.Tooltip("count:Q", title="Funde"),
+        ],
+    )
+
+    line = base.mark_line(color="#00cc6a", strokeWidth=2)
+    points = base.mark_circle(color="#00cc6a", size=40)
+
+    current_data = trend_df[trend_df["year"] == CURRENT_YEAR]
+    current_point = alt.Chart(current_data).mark_circle(
+        color="#ff6b35", size=80
+    ).encode(
+        x=alt.X("year:O"),
+        y=alt.Y("count:Q"),
+        tooltip=[alt.Tooltip("year:O", title="Jahr"), alt.Tooltip("count:Q", title="Funde")],
+    )
+
+    y_label = f"{year_from or PERIODS[0][0]}–{year_to or CURRENT_YEAR}"
+    chart = (line + points + current_point).properties(
+        title=alt.TitleParams(
+            text=f"Fundtrend: {species_name}",
+            subtitle=f"Jährliche GBIF-Funde {y_label} | Rot = aktuelles Jahr",
+            fontSize=14,
+            subtitleFontSize=11,
+        ),
+        height=300,
+    ).interactive()
+
+    return chart
+
+
+def prepare_per_unit_data(
+    df: pd.DataFrame,
+    unit_col: str,
+    max_units: int = 20,
+) -> tuple[list[str], pd.DataFrame]:
+    """Return (ordered list of top unit names, aggregated year/count DataFrame).
+
+    The returned DataFrame has columns [unit_col, 'year', 'count'].
+    Units are ordered by total descending.
+    """
+    if unit_col not in df.columns or "year" not in df.columns:
+        return [], pd.DataFrame()
+
+    data = (
+        df.dropna(subset=["year", unit_col])
+        .assign(year=lambda d: d["year"].astype(int))
+        .groupby([unit_col, "year"])
+        .size()
+        .reset_index(name="count")
+    )
+
+    if data.empty:
+        return [], pd.DataFrame()
+
+    top_units = (
+        data.groupby(unit_col)["count"].sum()
+        .nlargest(max_units).index.tolist()
+    )
+    data = data[data[unit_col].isin(top_units)].copy()
+    return top_units, data
+
+
+def build_unit_row_chart(unit_data: pd.DataFrame,
+                         y_max: int | None = None) -> alt.Chart:
+    """Full-width line chart for a single geographic unit, same style as overall trend.
+
+    y_max: shared Y-axis maximum across all unit charts for comparability.
+    """
+    y_scale = alt.Scale(zero=True, domain=[0, y_max]) if y_max is not None else alt.Scale(zero=True)
+
+    base = alt.Chart(unit_data).encode(
+        x=alt.X("year:O", title="Jahr", axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y("count:Q", title="Funde", scale=y_scale),
+        tooltip=[
+            alt.Tooltip("year:O", title="Jahr"),
+            alt.Tooltip("count:Q", title="Funde"),
+        ],
+    )
+
+    line = base.mark_line(color="#00cc6a", strokeWidth=2)
+    points = base.mark_circle(color="#00cc6a", size=40)
+
+    current_data = unit_data[unit_data["year"] == CURRENT_YEAR]
+    current_point = alt.Chart(current_data).mark_circle(
+        color="#ff6b35", size=80
+    ).encode(
+        x=alt.X("year:O"),
+        y=alt.Y("count:Q", scale=y_scale),
+        tooltip=[alt.Tooltip("year:O", title="Jahr"), alt.Tooltip("count:Q", title="Funde")],
+    )
+
+    return (line + points + current_point).properties(
+        height=140,
+    ).interactive()
+
+
+def compute_trend_from_df(df: pd.DataFrame) -> pd.DataFrame:
+    """Count occurrences per year from any DataFrame with a 'year' column."""
+    if df.empty or "year" not in df.columns:
+        return pd.DataFrame(columns=["year", "count"])
+    counts = (
+        df.dropna(subset=["year"])
+        .assign(year=lambda d: d["year"].astype(int))
+        .groupby("year")
+        .size()
+        .reset_index(name="count")
+        .sort_values("year")
+    )
+    return counts

src/csv_importer.py

@@ -0,0 +1,93 @@
+"""Import GBIF occurrence CSV/TSV downloads (tab-separated) into our parquet cache format.
+
+GBIF standard download columns differ slightly from our API-derived fields:
+- 'datasetKey' instead of 'datasetName'
+- 'countryCode' (ISO 2-letter) instead of 'country' (full name)
+- No 'country' full-name column
+"""
+
+import pandas as pd
+from pathlib import Path
+
+from src.utils import CURRENT_YEAR
+
+GBIF_CSV_RENAME = {
+    "datasetKey": "datasetName",
+}
+
+TARGET_FIELDS = [
+    "gbifID", "occurrenceID", "decimalLatitude", "decimalLongitude",
+    "year", "month", "day", "eventDate",
+    "datasetName", "institutionCode", "recordedBy",
+    "scientificName", "species", "country", "countryCode",
+    "stateProvince", "locality", "coordinateUncertaintyInMeters",
+]
+
+# Columns we need from the raw file (including aliases)
+_READ_COLS = set(TARGET_FIELDS) | {"datasetKey"}
+_CHUNK_SIZE = 200_000
+
+
+def _process_chunk(chunk: pd.DataFrame, exclude_current_year: bool) -> pd.DataFrame:
+    # Rename datasetKey -> datasetName only when datasetName isn't also present
+    if "datasetKey" in chunk.columns and "datasetName" in chunk.columns:
+        chunk = chunk.drop(columns=["datasetKey"])
+    elif "datasetKey" in chunk.columns:
+        chunk = chunk.rename(columns=GBIF_CSV_RENAME)
+
+    # Numeric conversions
+    chunk["decimalLatitude"] = pd.to_numeric(chunk.get("decimalLatitude"), errors="coerce")
+    chunk["decimalLongitude"] = pd.to_numeric(chunk.get("decimalLongitude"), errors="coerce")
+    chunk["year"] = pd.to_numeric(chunk.get("year"), errors="coerce")
+    chunk["month"] = pd.to_numeric(chunk.get("month"), errors="coerce")
+    chunk["day"] = pd.to_numeric(chunk.get("day"), errors="coerce")
+    if "coordinateUncertaintyInMeters" in chunk.columns:
+        chunk["coordinateUncertaintyInMeters"] = pd.to_numeric(
+            chunk["coordinateUncertaintyInMeters"], errors="coerce"
+        )
+
+    chunk = chunk.dropna(subset=["decimalLatitude", "decimalLongitude"])
+
+    if exclude_current_year and "year" in chunk.columns:
+        chunk = chunk[chunk["year"] < CURRENT_YEAR]
+
+    for col in TARGET_FIELDS:
+        if col not in chunk.columns:
+            chunk[col] = None
+
+    return chunk[TARGET_FIELDS].copy()
+
+
+def import_gbif_csv(filepath: str | Path, exclude_current_year: bool = True) -> pd.DataFrame:
+    """Read a GBIF CSV/TSV download and return a cleaned DataFrame.
+
+    Reads only the columns we need (huge memory saving for large files),
+    processes in chunks to handle files of any size, skips malformed lines.
+    """
+    filepath = Path(filepath)
+    if not filepath.exists():
+        raise FileNotFoundError(f"Datei nicht gefunden: {filepath}")
+
+    # Detect separator and available columns
+    with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+        header_line = f.readline()
+    sep = "\t" if "\t" in header_line else ","
+    available_cols = [c.strip() for c in header_line.split(sep)]
+    usecols = [c for c in available_cols if c in _READ_COLS]
+
+    chunks = pd.read_csv(
+        filepath,
+        sep=sep,
+        encoding="utf-8",
+        encoding_errors="replace",
+        low_memory=False,
+        dtype=str,
+        on_bad_lines="skip",
+        usecols=usecols,
+        chunksize=_CHUNK_SIZE,
+    )
+
+    parts = [_process_chunk(chunk, exclude_current_year) for chunk in chunks]
+    if not parts:
+        return pd.DataFrame(columns=TARGET_FIELDS)
+    return pd.concat(parts, ignore_index=True)

src/data_cache.py

@@ -0,0 +1,94 @@
+"""Disk-based Parquet cache for historical GBIF occurrences (YEAR_FROM … HIST_YEAR_TO).
+
+Cache files live in data/species_cache/ and are named:
+    {taxon_key}_{scope}.parquet
+where scope is a country code (e.g. "DE") or "worldwide".
+
+Fallback rule: if no country-specific cache exists but a "worldwide" cache does,
+load_best() returns the worldwide data filtered to the requested country in-memory.
+"""
+
+import pandas as pd
+from pathlib import Path
+from datetime import datetime
+
+from src.utils import CACHE_DIR, YEAR_FROM, HIST_YEAR_TO
+
+
+def _scope_str(country: str | None) -> str:
+    return country if country else "worldwide"
+
+
+def cache_path(taxon_key: int, country: str | None) -> Path:
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    return CACHE_DIR / f"{taxon_key}_{_scope_str(country)}.parquet"
+
+
+def cache_exists(taxon_key: int, country: str | None) -> bool:
+    if cache_path(taxon_key, country).exists():
+        return True
+    # worldwide cache can serve any country filter
+    if country is not None:
+        return cache_path(taxon_key, None).exists()
+    return False
+
+
+def cache_info(taxon_key: int, country: str | None) -> dict | None:
+    """Return size (MB), row count, modification date, and whether worldwide fallback is used."""
+    p = cache_path(taxon_key, country)
+    using_fallback = False
+    if not p.exists() and country is not None:
+        p = cache_path(taxon_key, None)
+        using_fallback = True
+    if not p.exists():
+        return None
+    size_mb = p.stat().st_size / 1_048_576
+    mtime = datetime.fromtimestamp(p.stat().st_mtime)
+    try:
+        df_meta = pd.read_parquet(p, columns=["year"])
+        rows = len(df_meta)
+    except Exception:
+        rows = -1
+    return {
+        "size_mb": size_mb,
+        "rows": rows,
+        "modified": mtime,
+        "path": p,
+        "worldwide_fallback": using_fallback,
+    }
+
+
+def load_historical(taxon_key: int, country: str | None) -> pd.DataFrame:
+    """Load cached data. If no country-specific cache, falls back to worldwide + in-memory filter."""
+    p = cache_path(taxon_key, country)
+    if p.exists():
+        return pd.read_parquet(p)
+
+    # Worldwide fallback
+    if country is not None:
+        p_world = cache_path(taxon_key, None)
+        if p_world.exists():
+            df = pd.read_parquet(p_world)
+            if "countryCode" in df.columns:
+                return df[df["countryCode"] == country].copy()
+            return df
+
+    return pd.DataFrame()
+
+
+def save_historical(taxon_key: int, country: str | None, df: pd.DataFrame) -> Path:
+    p = cache_path(taxon_key, country)
+    df.to_parquet(p, index=False)
+    return p
+
+
+def delete_cache(taxon_key: int, country: str | None) -> bool:
+    p = cache_path(taxon_key, country)
+    if p.exists():
+        p.unlink()
+        return True
+    return False
+
+
+def historical_year_range() -> tuple[int, int]:
+    return YEAR_FROM, HIST_YEAR_TO

src/gbif_client.py

@@ -0,0 +1,186 @@
+import time
+import pandas as pd
+import streamlit as st
+from pygbif import occurrences
+
+from src.utils import GBIF_PAGE_SIZE, GBIF_MAX_OFFSET, CURRENT_YEAR
+
+OCCURRENCE_FIELDS = [
+    "gbifID", "occurrenceID", "decimalLatitude", "decimalLongitude",
+    "year", "month", "day", "eventDate",
+    "datasetName", "institutionCode", "recordedBy",
+    "scientificName", "species", "country", "countryCode",
+    "stateProvince", "locality", "coordinateUncertaintyInMeters",
+]
+
+
+def get_occurrence_count(taxon_key: int, country: str | None = None,
+                         year_from: int | None = None, year_to: int | None = None) -> int:
+    params = dict(
+        taxonKey=taxon_key,
+        hasCoordinate=True,
+        hasGeospatialIssue=False,
+        limit=0,
+    )
+    if country:
+        params["country"] = country
+    if year_from is not None and year_to is not None:
+        params["year"] = f"{year_from},{year_to}"
+    try:
+        result = occurrences.search(**params)
+        return result.get("count", 0)
+    except Exception:
+        return -1
+
+
+def _fmt_remaining(elapsed_s: float, pct: float) -> str:
+    if pct <= 0.01:
+        return ""
+    remaining = elapsed_s / pct * (1.0 - pct)
+    if remaining < 60:
+        return f" · noch ca. {int(remaining) + 1} Sek."
+    mins, secs = divmod(int(remaining), 60)
+    return f" · noch ca. {mins} Min. {secs} Sek."
+
+
+def _clean_dataframe(records: list[dict]) -> pd.DataFrame:
+    df = pd.DataFrame(records)
+    if df.empty:
+        return df
+    keep = [c for c in OCCURRENCE_FIELDS if c in df.columns]
+    df = df[keep].copy()
+    df["decimalLatitude"] = pd.to_numeric(df.get("decimalLatitude"), errors="coerce")
+    df["decimalLongitude"] = pd.to_numeric(df.get("decimalLongitude"), errors="coerce")
+    df = df.dropna(subset=["decimalLatitude", "decimalLongitude"])
+    df["year"] = pd.to_numeric(df.get("year", pd.Series(dtype=int)), errors="coerce")
+    return df
+
+
+def fetch_all_occurrences(taxon_key: int, country: str | None = None,
+                          year_from: int | None = None, year_to: int | None = None,
+                          progress_label: str = "Lade Daten von GBIF…") -> pd.DataFrame:
+    """Download all available records (no max_records cap) and show a progress bar.
+
+    Intended for the one-time historical cache download, not for repeated app calls.
+    """
+    params = dict(
+        taxonKey=taxon_key,
+        hasCoordinate=True,
+        hasGeospatialIssue=False,
+        limit=GBIF_PAGE_SIZE,
+    )
+    if country:
+        params["country"] = country
+    if year_from is not None and year_to is not None:
+        params["year"] = f"{year_from},{year_to}"
+
+    # Pre-check total count
+    count_params = {k: v for k, v in params.items() if k != "limit"}
+    count_params["limit"] = 0
+    try:
+        total = occurrences.search(**count_params).get("count", 0)
+    except Exception:
+        total = 0
+
+    limit = min(total, GBIF_MAX_OFFSET) if total > 0 else GBIF_MAX_OFFSET
+    progress_bar = st.progress(0.0, text=progress_label)
+    all_records: list[dict] = []
+    offset = 0
+    t0 = time.time()
+
+    try:
+        while offset < limit:
+            params["offset"] = offset
+            result = occurrences.search(**params)
+            batch = result.get("results", [])
+            if not batch:
+                break
+            all_records.extend(batch)
+            offset += len(batch)
+            pct = min(len(all_records) / max(limit, 1), 1.0)
+            eta = _fmt_remaining(time.time() - t0, pct)
+            progress_bar.progress(
+                pct,
+                text=f"{len(all_records):,} / {total:,} Datensätze geladen{eta}"
+            )
+            if result.get("endOfRecords", True):
+                break
+            time.sleep(0.05)
+    finally:
+        progress_bar.empty()
+
+    return _clean_dataframe(all_records)
+
+
+MAX_CURRENT_YEAR_RECORDS = 10_000
+
+
+def fetch_current_year(taxon_key: int, country: str | None = None) -> pd.DataFrame:
+    """Always fetch live from GBIF for the current year. Cached in session_state.
+
+    Capped at MAX_CURRENT_YEAR_RECORDS to keep response times reasonable.
+    """
+    cache_key = f"current_{taxon_key}_{country}"
+    if cache_key in st.session_state:
+        return st.session_state[cache_key]
+
+    params = dict(
+        taxonKey=taxon_key,
+        year=f"{CURRENT_YEAR},{CURRENT_YEAR}",
+        hasCoordinate=True,
+        hasGeospatialIssue=False,
+        limit=GBIF_PAGE_SIZE,
+    )
+    if country:
+        params["country"] = country
+
+    # Pre-check total so we can show a meaningful progress bar
+    count_params = {**params, "limit": 0}
+    try:
+        total = occurrences.search(**count_params).get("count", 0)
+    except Exception:
+        total = 0
+
+    fetch_limit = min(total, MAX_CURRENT_YEAR_RECORDS)
+    capped = total > MAX_CURRENT_YEAR_RECORDS
+
+    country_label = country if country else "weltweit"
+    progress_bar = st.progress(
+        0.0,
+        text=f"Lade aktuelle Daten {CURRENT_YEAR} ({country_label}): {total:,} verfügbar…",
+    )
+
+    all_records: list[dict] = []
+    offset = 0
+    t0 = time.time()
+    try:
+        while len(all_records) < fetch_limit:
+            params["offset"] = offset
+            result = occurrences.search(**params)
+            batch = result.get("results", [])
+            if not batch:
+                break
+            all_records.extend(batch)
+            offset += len(batch)
+            pct = min(len(all_records) / max(fetch_limit, 1), 1.0)
+            eta = _fmt_remaining(time.time() - t0, pct)
+            progress_bar.progress(
+                pct,
+                text=f"Aktuelle Daten {CURRENT_YEAR}: {len(all_records):,} / {fetch_limit:,}{eta}",
+            )
+            if result.get("endOfRecords", True):
+                break
+            time.sleep(0.05)
+    except Exception:
+        pass
+    finally:
+        progress_bar.empty()
+
+    df = _clean_dataframe(all_records)
+    if capped:
+        st.caption(
+            f"Aktuelle Daten {CURRENT_YEAR} auf {MAX_CURRENT_YEAR_RECORDS:,} begrenzt "
+            f"({total:,} insgesamt verfügbar, {country_label})."
+        )
+    st.session_state[cache_key] = df
+    return df

src/map_builder.py

@@ -0,0 +1,151 @@
+import geopandas as gpd
+import folium
+import shapely
+
+from src.utils import MAP_CENTER, MAP_ZOOM, UNIT_NAME_COL
+
+
+TILE = "CartoDB positron"
+
+
+def _clean_geometries(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """Drop null/empty geometries and repair invalid ones before any spatial operation."""
+    gdf = gdf[~gdf["geometry"].isna()].copy()
+    gdf = gdf[~gdf["geometry"].is_empty].copy()
+    gdf["geometry"] = shapely.make_valid(gdf["geometry"])
+    # Drop any geometry that still has non-finite bounds
+    def _has_finite_bounds(geom):
+        try:
+            b = geom.bounds
+            return all(v == v and abs(v) != float("inf") for v in b)  # NaN check + inf check
+        except Exception:
+            return False
+    gdf = gdf[gdf["geometry"].apply(_has_finite_bounds)].copy()
+    return gdf
+
+
+def _format_popup(row: dict) -> str:
+    fields = [
+        ("Art", row.get("scientificName") or row.get("species")),
+        ("Datum", row.get("eventDate") or f"{row.get('year','')}-{str(row.get('month','')).zfill(2)}-{str(row.get('day','')).zfill(2)}"),
+        ("Datenquelle", row.get("datasetName")),
+        ("Institution", row.get("institutionCode")),
+        ("Erfasser", row.get("recordedBy")),
+        ("Ort", row.get("locality")),
+        ("Bundesland/Region", row.get("stateProvince")),
+        ("Land", row.get("country")),
+        ("GBIF-ID", row.get("gbifID")),
+        ("Koordinatengenauigkeit", row.get("coordinateUncertaintyInMeters")),
+    ]
+    rows_html = "".join(
+        f"<tr><td style='font-weight:bold;padding-right:8px'>{k}</td><td>{v}</td></tr>"
+        for k, v in fields
+        if v and str(v).strip() and str(v) not in ("nan", "None", "--")
+    )
+    return f"<table style='font-size:12px;min-width:220px'>{rows_html}</table>"
+
+
+def build_current_map(occurrences_gdf: gpd.GeoDataFrame, scope: str,
+                       boundary_gdf: gpd.GeoDataFrame | None = None,
+                       outline_gdf: gpd.GeoDataFrame | None = None) -> folium.Map:
+    center = MAP_CENTER.get(scope, (51.2, 10.4))
+    zoom = MAP_ZOOM.get(scope, 6)
+    m = folium.Map(location=center, zoom_start=zoom, tiles=TILE)
+
+    if outline_gdf is not None and not outline_gdf.empty:
+        simplified_outline = _clean_geometries(outline_gdf.copy())
+        simplified_outline["geometry"] = simplified_outline["geometry"].simplify(tolerance=0.005, preserve_topology=True)
+        folium.GeoJson(
+            simplified_outline.__geo_interface__,
+            style_function=lambda _: {"color": "#1a1a1a", "weight": 2.5, "fillOpacity": 0},
+            name="Übergeordnete Grenze",
+        ).add_to(m)
+
+    if boundary_gdf is not None and not boundary_gdf.empty:
+        simplified = _clean_geometries(boundary_gdf.copy())
+        simplified["geometry"] = simplified["geometry"].simplify(tolerance=0.005, preserve_topology=True)
+        folium.GeoJson(
+            simplified.__geo_interface__,
+            style_function=lambda _: {"color": "#444", "weight": 0.8, "fillOpacity": 0},
+            name="Grenzen",
+        ).add_to(m)
+
+    points_layer = folium.FeatureGroup(name="Fundpunkte")
+    for _, row in occurrences_gdf.iterrows():
+        lat = row.get("decimalLatitude")
+        lon = row.get("decimalLongitude")
+        if lat is None or lon is None:
+            continue
+        popup_html = _format_popup(row.to_dict())
+        folium.CircleMarker(
+            location=[lat, lon],
+            radius=5,
+            color="#c0392b",
+            fill=True,
+            fill_color="#e74c3c",
+            fill_opacity=0.7,
+            popup=folium.Popup(popup_html, max_width=320),
+            tooltip=row.get("scientificName", ""),
+        ).add_to(points_layer)
+    points_layer.add_to(m)
+
+    folium.LayerControl().add_to(m)
+    return m
+
+
+
+def build_choropleth_map(occurrences_gdf: gpd.GeoDataFrame, boundary_gdf: gpd.GeoDataFrame,
+                          scope: str, period_label: str) -> folium.Map:
+    center = MAP_CENTER.get(scope, (51.2, 10.4))
+    zoom = MAP_ZOOM.get(scope, 6)
+    m = folium.Map(location=center, zoom_start=zoom, tiles=TILE)
+
+    unit_col = UNIT_NAME_COL.get(scope, "GEN")
+    if unit_col not in boundary_gdf.columns:
+        return m
+
+    # Count occurrences per unit
+    counts = occurrences_gdf.groupby(unit_col).size().reset_index(name="count") \
+        if unit_col in occurrences_gdf.columns else None
+
+    # Simplify for performance (clean invalid geometries first)
+    boundary_plot = _clean_geometries(boundary_gdf.copy())
+    boundary_plot["geometry"] = boundary_plot["geometry"].simplify(tolerance=0.005, preserve_topology=True)
+
+    if counts is not None and not counts.empty:
+        boundary_plot = boundary_plot.merge(counts, on=unit_col, how="left")
+        boundary_plot["count"] = boundary_plot["count"].fillna(0).astype(int)
+
+        folium.Choropleth(
+            geo_data=boundary_plot.__geo_interface__,
+            data=boundary_plot[[unit_col, "count"]],
+            columns=[unit_col, "count"],
+            key_on=f"feature.properties.{unit_col}",
+            fill_color="YlOrRd",
+            fill_opacity=0.75,
+            line_opacity=0.4,
+            legend_name=f"Funde {period_label}",
+            nan_fill_color="#eeeeee",
+            name=f"Funde {period_label}",
+        ).add_to(m)
+
+        # Tooltip overlay
+        tooltip_gdf = boundary_plot[[unit_col, "count", "geometry"]].copy()
+        folium.GeoJson(
+            tooltip_gdf.__geo_interface__,
+            style_function=lambda _: {"color": "#555", "weight": 0.5, "fillOpacity": 0},
+            tooltip=folium.GeoJsonTooltip(
+                fields=[unit_col, "count"],
+                aliases=["Einheit:", "Funde:"],
+                localize=True,
+            ),
+            name="Info",
+        ).add_to(m)
+    else:
+        folium.GeoJson(
+            boundary_plot.__geo_interface__,
+            style_function=lambda _: {"color": "#888", "weight": 0.8, "fillColor": "#eeeeee", "fillOpacity": 0.4},
+        ).add_to(m)
+
+    folium.LayerControl().add_to(m)
+    return m

src/spatial_analysis.py

@@ -0,0 +1,81 @@
+import pandas as pd
+import geopandas as gpd
+import shapely
+from shapely.geometry import Point
+
+from src.utils import PERIODS, CURRENT_YEAR, YEAR_FROM, UNIT_NAME_COL
+
+
+def build_geodataframe(df: pd.DataFrame) -> gpd.GeoDataFrame:
+    geometry = [Point(lon, lat) for lon, lat in zip(df["decimalLongitude"], df["decimalLatitude"])]
+    return gpd.GeoDataFrame(df.copy(), geometry=geometry, crs="EPSG:4326")
+
+
+def _prepare_boundary(boundary_gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """Reproject to WGS84 and drop invalid/degenerate geometries."""
+    # Ensure CRS is set and in WGS84
+    if boundary_gdf.crs is None:
+        gdf = boundary_gdf.set_crs("EPSG:4326", allow_override=True)
+    else:
+        gdf = boundary_gdf.to_crs("EPSG:4326")
+
+    # Drop null / empty geometries
+    gdf = gdf[~gdf["geometry"].isna()].copy()
+    gdf = gdf[~gdf["geometry"].is_empty].copy()
+
+    # Repair invalid geometries (fixes self-intersections etc.)
+    gdf["geometry"] = shapely.make_valid(gdf["geometry"])
+
+    # Drop geometries with non-finite coordinate bounds (NaN / Inf)
+    def _finite_bounds(geom):
+        try:
+            return all(v == v and abs(v) != float("inf") for v in geom.bounds)
+        except Exception:
+            return False
+
+    gdf = gdf[gdf["geometry"].apply(_finite_bounds)].copy()
+    return gdf
+
+
+def spatial_join(occurrences_gdf: gpd.GeoDataFrame, boundary_gdf: gpd.GeoDataFrame,
+                 scope: str) -> gpd.GeoDataFrame:
+    occ = occurrences_gdf.to_crs("EPSG:4326") if occurrences_gdf.crs else occurrences_gdf.set_crs("EPSG:4326")
+    bnd = _prepare_boundary(boundary_gdf)
+
+    if bnd.empty:
+        return occurrences_gdf.iloc[0:0]
+
+    unit_col = UNIT_NAME_COL.get(scope, "GEN")
+    join_cols = [c for c in [unit_col, "AGS", "bundesland", "ISO_A2", "admin", "iso_a2"]
+                 if c in bnd.columns] + ["geometry"]
+    bnd_slim = bnd[join_cols].copy()
+
+    joined = gpd.sjoin(occ, bnd_slim, how="inner", predicate="intersects")
+    return joined.drop(columns=["index_right"], errors="ignore")
+
+
+def count_by_unit(joined_gdf: gpd.GeoDataFrame, unit_col: str) -> pd.Series:
+    if unit_col not in joined_gdf.columns:
+        return pd.Series(dtype=int)
+    return joined_gdf.groupby(unit_col).size().rename("count")
+
+
+def build_count_table(joined_gdf: gpd.GeoDataFrame, boundary_gdf: gpd.GeoDataFrame,
+                      scope: str, year_from: int = YEAR_FROM,
+                      year_to: int = CURRENT_YEAR) -> pd.DataFrame:
+    unit_col = UNIT_NAME_COL.get(scope, "GEN")
+    if unit_col not in boundary_gdf.columns:
+        return pd.DataFrame()
+
+    all_units = boundary_gdf[unit_col].dropna().unique()
+    table = pd.DataFrame(index=all_units)
+    table.index.name = unit_col
+
+    for year in range(year_from, year_to + 1):
+        year_data = joined_gdf[joined_gdf["year"] == year]
+        counts = count_by_unit(year_data, unit_col)
+        table[str(year)] = counts.reindex(table.index).fillna(0).astype(int)
+
+    table["Gesamt"] = table.sum(axis=1)
+    table = table[table["Gesamt"] > 0].sort_values("Gesamt", ascending=False)
+    return table.reset_index()

src/species_config.py

@@ -0,0 +1,34 @@
+SPECIES = {
+    "Vespa velutina": {
+        "taxon_key": 1311477,
+        "common_name_de": "Asiatische Hornisse",
+        "icon": "🐝",
+        "description": "Invasive Neobiota, ursprünglich aus Südostasien; breitet sich seit ~2004 in Europa aus.",
+    },
+    "Castor fiber": {
+        "taxon_key": 2439952,
+        "common_name_de": "Europäischer Biber",
+        "icon": "🦫",
+        "description": "Heimische Art; nach starker Dezimierung heute wieder weit verbreitet in Europa.",
+        "local_file": "/home/johannes/Nextcloud2/vespa_velutina_python/claude_vespa_dyna/Castor fiber bis 2025/occurrence.txt",
+    },
+    "Branta canadensis": {
+        "taxon_key": 5232437,
+        "common_name_de": "Kanadagans",
+        "icon": "🦢",
+        "description": "Eingebürgerter Neozoon aus Nordamerika; zahlreiche stabile Populationen in Europa.",
+        "local_file": "/home/johannes/Nextcloud2/vespa_velutina_python/claude_vespa_dyna/Branta canadensis bis 2025/Branta_canadensis_bis_2025.csv",
+    },
+    "Felis silvestris": {
+        "taxon_key": 7964291,
+        "common_name_de": "Wildkatze",
+        "icon": "🐱",
+        "description": "Heimische Art; stark gefährdet durch Lebensraumverlust und Hybridisierung.",
+        "local_file": "/home/johannes/Nextcloud2/vespa_velutina_python/claude_vespa_dyna/Wildkatze bis 2025/occurrence.txt",
+    },
+}
+
+SPECIES_DISPLAY_LABELS = {
+    key: f"{cfg['icon']} {key} – {cfg['common_name_de']}"
+    for key, cfg in SPECIES.items()
+}

src/streamlit_app.py

@@ -0,0 +1,40 @@
+import altair as alt
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+"""
+# Welcome to Streamlit!
+
+Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
+If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
+forums](https://discuss.streamlit.io).
+
+In the meantime, below is an example of what you can do with just a few lines of code:
+"""
+
+num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
+num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
+
+indices = np.linspace(0, 1, num_points)
+theta = 2 * np.pi * num_turns * indices
+radius = indices
+
+x = radius * np.cos(theta)
+y = radius * np.sin(theta)
+
+df = pd.DataFrame({
+    "x": x,
+    "y": y,
+    "idx": indices,
+    "rand": np.random.randn(num_points),
+})
+
+st.altair_chart(alt.Chart(df, height=700, width=700)
+    .mark_point(filled=True)
+    .encode(
+        x=alt.X("x", axis=None),
+        y=alt.Y("y", axis=None),
+        color=alt.Color("idx", legend=None, scale=alt.Scale()),
+        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
+    ))

src/styles.py

@@ -0,0 +1,219 @@
+import streamlit as st
+
+_CSS = """
+<style>
+/* ── Fonts ─────────────────────────────────────────────────────────────── */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+
+html, body, [class*="css"], [class*="st-"] {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif !important;
+}
+
+/* ── Main container ─────────────────────────────────────────────────────── */
+.main .block-container {
+    padding: 2rem 2.5rem 3rem !important;
+    max-width: 1200px !important;
+}
+
+/* ── Typography ─────────────────────────────────────────────────────────── */
+h1 { font-weight: 700 !important; letter-spacing: -0.4px !important; line-height: 1.2 !important; }
+h2 { font-weight: 600 !important; color: #2d3748 !important; }
+h3 { font-weight: 600 !important; }
+
+[data-testid="stCaptionContainer"] p {
+    color: #64748b !important;
+    font-size: 0.85rem !important;
+}
+
+/* ── Sidebar ────────────────────────────────────────────────────────────── */
+[data-testid="stSidebar"] {
+    border-right: 1px solid #e2e8f0 !important;
+}
+[data-testid="stSidebar"] > div:first-child {
+    padding-top: 1.5rem;
+}
+[data-testid="stSidebarUserContent"] h1 {
+    font-size: 1.3rem !important;
+}
+
+/* ── Metric cards ───────────────────────────────────────────────────────── */
+[data-testid="stMetric"] {
+    background: #ffffff;
+    border: 1px solid #e2e8f0;
+    border-radius: 12px;
+    padding: 1.1rem 1.3rem !important;
+    box-shadow: 0 1px 4px rgba(0,0,0,0.06);
+}
+[data-testid="stMetricValue"] {
+    font-size: 1.9rem !important;
+    font-weight: 700 !important;
+    color: #1e6b3b !important;
+}
+[data-testid="stMetricLabel"] {
+    font-size: 0.78rem !important;
+    font-weight: 500 !important;
+    color: #64748b !important;
+    text-transform: uppercase !important;
+    letter-spacing: 0.4px !important;
+}
+
+/* ── Tabs ───────────────────────────────────────────────────────────────── */
+[data-testid="stTabs"] [role="tablist"] {
+    gap: 2px;
+    border-bottom: 2px solid #e2e8f0 !important;
+    padding-bottom: 0 !important;
+}
+[data-testid="stTabs"] button[role="tab"] {
+    border-radius: 8px 8px 0 0 !important;
+    font-weight: 500 !important;
+    padding: 0.55rem 1.1rem !important;
+    color: #64748b !important;
+    border: 1px solid transparent !important;
+    border-bottom: none !important;
+    transition: color 0.15s, background 0.15s;
+}
+[data-testid="stTabs"] button[role="tab"]:hover {
+    color: #1e6b3b !important;
+    background: #f4f7f5 !important;
+}
+[data-testid="stTabs"] button[role="tab"][aria-selected="true"] {
+    color: #1e6b3b !important;
+    font-weight: 600 !important;
+    background: #ffffff !important;
+    border-color: #e2e8f0 !important;
+    border-bottom-color: #ffffff !important;
+    margin-bottom: -2px;
+}
+
+/* ── Alerts (info / success / warning / error) ──────────────────────────── */
+[data-testid="stAlert"] {
+    border-radius: 10px !important;
+    border-left-width: 4px !important;
+    padding: 0.75rem 1rem !important;
+}
+
+/* ── Buttons ────────────────────────────────────────────────────────────── */
+[data-testid="stButton"] > button {
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+    transition: filter 0.15s, transform 0.1s !important;
+}
+[data-testid="stButton"] > button:hover {
+    filter: brightness(0.92) !important;
+    transform: translateY(-1px) !important;
+}
+[data-testid="stButton"] > button[kind="primary"] {
+    padding: 0.5rem 1.4rem !important;
+    font-weight: 600 !important;
+}
+
+/* ── Select / Input ─────────────────────────────────────────────────────── */
+[data-testid="stSelectbox"] > div > div,
+[data-testid="stTextInput"] > div > div > input {
+    border-radius: 8px !important;
+}
+
+/* ── Divider ────────────────────────────────────────────────────────────── */
+hr {
+    border-color: #e2e8f0 !important;
+    margin: 0.8rem 0 !important;
+}
+
+/* ── Home page cards ────────────────────────────────────────────────────── */
+.at-card {
+    background: #ffffff;
+    border: 1px solid #e2e8f0;
+    border-radius: 14px;
+    padding: 1.5rem 1.75rem;
+    margin-bottom: 1.25rem;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.05);
+}
+.at-card h3 {
+    margin-top: 0 !important;
+    color: #1e6b3b !important;
+}
+.at-hero {
+    background: linear-gradient(135deg, #1e6b3b 0%, #2d9c59 100%);
+    border-radius: 16px;
+    padding: 2.5rem 2rem;
+    margin-bottom: 2rem;
+    color: #ffffff !important;
+}
+.at-hero h1, .at-hero p {
+    color: #ffffff !important;
+    margin: 0 !important;
+}
+.at-hero h1 { font-size: 2rem !important; margin-bottom: 0.5rem !important; }
+.at-hero p  { font-size: 1.05rem !important; opacity: 0.92; }
+.at-feature-icon { font-size: 1.8rem; margin-bottom: 0.4rem; }
+.at-feature-box {
+    background: #f4f7f5;
+    border-radius: 12px;
+    padding: 1.2rem 1rem;
+    text-align: center;
+    height: 100%;
+}
+.at-feature-box p { color: #4a5568 !important; font-size: 0.9rem !important; margin: 0 !important; }
+.at-feature-box strong { color: #1a2332 !important; font-size: 0.95rem; }
+
+/* ── Spinner ────────────────────────────────────────────────────────────── */
+[data-testid="stSpinner"] > div { border-top-color: #1e6b3b !important; }
+
+/* ── Mobile responsive ──────────────────────────────────────────────────── */
+@media (max-width: 768px) {
+    .main .block-container {
+        padding: 1rem 0.9rem 2rem !important;
+    }
+    h1 { font-size: 1.55rem !important; }
+    h2 { font-size: 1.15rem !important; }
+
+    /* Stack the 3-column metric row */
+    [data-testid="stHorizontalBlock"] {
+        flex-wrap: wrap !important;
+        gap: 0.6rem !important;
+    }
+    [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] {
+        min-width: calc(50% - 0.3rem) !important;
+        flex: 1 1 calc(50% - 0.3rem) !important;
+    }
+
+    /* Smaller tab labels */
+    [data-testid="stTabs"] button[role="tab"] {
+        padding: 0.4rem 0.65rem !important;
+        font-size: 0.82rem !important;
+    }
+
+    /* Map iframe: shorter on phone */
+    .stFoliumChart iframe, iframe[title*="folium"] {
+        height: 340px !important;
+    }
+
+    .at-hero { padding: 1.5rem 1.25rem; }
+    .at-hero h1 { font-size: 1.5rem !important; }
+    .at-card { padding: 1.1rem 1.2rem; }
+}
+
+@media (max-width: 480px) {
+    [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] {
+        min-width: 100% !important;
+    }
+}
+</style>
+"""
+
+
+_HIDE_SIDEBAR_CSS = """
+<style>
+[data-testid="stSidebar"]               { display: none !important; }
+[data-testid="stSidebarCollapsedControl"]{ display: none !important; }
+.main .block-container { max-width: 900px !important; margin: 0 auto !important; }
+</style>
+"""
+
+
+def inject_css() -> None:
+    st.markdown(_CSS, unsafe_allow_html=True)
+
+
+def hide_sidebar() -> None:
+    st.markdown(_HIDE_SIDEBAR_CSS, unsafe_allow_html=True)

src/styles_v1_naturetech.py

@@ -0,0 +1,376 @@
+"""
+Variant 1 — NatureTech
+Biolumineszenz trifft digitalen Wald. Dunkles Substrat, organische Datengitter,
+neongrüne Signale. Wie ein Mikroskop-Slide im Terminal.
+
+config.toml für beste Ergebnisse:
+  [theme]
+  primaryColor             = "#00ff88"
+  backgroundColor          = "#0a0f0d"
+  secondaryBackgroundColor = "#111a14"
+  textColor                = "#e8f5ec"
+  font                     = "monospace"
+"""
+import streamlit as st
+
+_CSS = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Oxanium:wght@300;400;600;700;800&family=JetBrains+Mono:wght@400;500;700&display=swap');
+
+/* ── Keyframes ──────────────────────────────────────────────────── */
+@keyframes neon-pulse {
+  0%,100% { box-shadow: 0 0 4px #00ff8855, 0 0 14px #00ff8818; }
+  50%      { box-shadow: 0 0 10px #00ff88aa, 0 0 30px #00ff8835, 0 0 55px #00ff8810; }
+}
+@keyframes data-in {
+  from { opacity: 0; transform: translateY(5px); }
+  to   { opacity: 1; transform: translateY(0); }
+}
+@keyframes cursor-blink {
+  0%,100% { opacity: 1; } 50% { opacity: 0; }
+}
+
+/* ── Base ───────────────────────────────────────────────────────── */
+.stApp {
+  background-color: #0a0f0d !important;
+  background-image:
+    linear-gradient(rgba(0,255,136,0.018) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(0,255,136,0.018) 1px, transparent 1px);
+  background-size: 44px 44px !important;
+}
+html, body { background-color: #0a0f0d !important; }
+section.main, [data-testid="stAppViewContainer"] {
+  background-color: #0a0f0d !important;
+}
+
+/* ── Main container ─────────────────────────────────────────────── */
+.main .block-container {
+  padding: 2rem 2.5rem 3rem !important;
+  max-width: 1200px !important;
+}
+
+/* ── Typography ─────────────────────────────────────────────────── */
+html, body, [class*="css"], [class*="st-"] {
+  font-family: 'JetBrains Mono', monospace !important;
+  color: #e8f5ec !important;
+}
+h1, h2, h3 {
+  font-family: 'Oxanium', sans-serif !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2.5px !important;
+  color: #e8f5ec !important;
+}
+h1 {
+  font-weight: 800 !important;
+  font-size: 2rem !important;
+  text-shadow: 0 0 24px #00ff8840 !important;
+  line-height: 1.2 !important;
+}
+h2 {
+  font-weight: 700 !important;
+  color: #00cc6a !important;
+  font-size: 1.15rem !important;
+}
+h3 {
+  font-weight: 600 !important;
+  color: #00ff8899 !important;
+  font-size: 0.95rem !important;
+}
+/* Nur spezifische Streamlit-Textcontainer überschreiben, nicht generisch div/span */
+.stMarkdown p, .stMarkdown li, .stMarkdown a { color: #e8f5ec !important; }
+.stText p { color: #e8f5ec !important; }
+[data-testid="stCaptionContainer"] p {
+  color: #5a9a72 !important;
+  font-size: 0.77rem !important;
+  letter-spacing: 0.5px !important;
+}
+
+/* ── Sidebar ────────────────────────────────────────────────────── */
+[data-testid="stSidebar"] {
+  background-color: #060d08 !important;
+  border-right: 1px solid #00ff8828 !important;
+  background-image:
+    radial-gradient(circle, #00ff8820 1.5px, transparent 1.5px),
+    radial-gradient(circle at 12px 12px, #00ff8810 1px, transparent 1px) !important;
+  background-size: 24px 24px, 24px 24px !important;
+}
+[data-testid="stSidebar"] > div:first-child { padding-top: 1.5rem; }
+[data-testid="stSidebarUserContent"] h1 {
+  font-size: 1.15rem !important;
+  color: #00ff88 !important;
+  text-shadow: 0 0 14px #00ff8870 !important;
+}
+[data-testid="stSidebarUserContent"] label {
+  font-size: 0.72rem !important;
+  color: #2e6645 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1.5px !important;
+}
+
+/* ── Selectbox / Input ──────────────────────────────────────────── */
+[data-testid="stSelectbox"] > div > div,
+[data-testid="stTextInput"] > div > div > input {
+  background-color: #0d1a10 !important;
+  border: 1px solid #00ff8835 !important;
+  border-radius: 3px !important;
+  color: #e8f5ec !important;
+  font-size: 0.82rem !important;
+}
+[data-testid="stSelectbox"] > div > div:focus-within {
+  border-color: #00ff8890 !important;
+  box-shadow: 0 0 0 2px #00ff8818 !important;
+}
+
+/* ── Metric cards ───────────────────────────────────────────────── */
+[data-testid="stMetric"] {
+  background: rgba(0,255,136,0.035) !important;
+  border: 1px solid #00ff8830 !important;
+  border-radius: 5px !important;
+  padding: 1.1rem 1.3rem !important;
+  backdrop-filter: blur(6px) !important;
+  animation: neon-pulse 3.5s ease-in-out infinite !important;
+  transition: border-color 0.2s, background 0.2s !important;
+}
+[data-testid="stMetric"]:hover {
+  border-color: #00ff8875 !important;
+  background: rgba(0,255,136,0.06) !important;
+}
+[data-testid="stMetricValue"] {
+  font-family: 'JetBrains Mono', monospace !important;
+  font-size: 2rem !important;
+  font-weight: 700 !important;
+  color: #00ff88 !important;
+  text-shadow: 0 0 14px #00ff8855 !important;
+  animation: data-in 0.45s ease both !important;
+}
+[data-testid="stMetricLabel"] {
+  font-size: 0.68rem !important;
+  font-weight: 400 !important;
+  color: #2e6645 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2px !important;
+}
+
+/* ── Tabs ───────────────────────────────────────────────────────── */
+[data-testid="stTabs"] [role="tablist"] {
+  gap: 0 !important;
+  border-bottom: 1px solid #00ff8820 !important;
+  padding-bottom: 0 !important;
+}
+[data-testid="stTabs"] button[role="tab"] {
+  border-radius: 0 !important;
+  font-family: 'Oxanium', sans-serif !important;
+  font-weight: 600 !important;
+  font-size: 0.78rem !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2px !important;
+  padding: 0.6rem 1.2rem !important;
+  color: #2e6645 !important;
+  border: none !important;
+  border-bottom: 2px solid transparent !important;
+  background: transparent !important;
+  transition: color 0.15s, border-color 0.15s !important;
+}
+[data-testid="stTabs"] button[role="tab"]:hover {
+  color: #7fffbe !important;
+  background: rgba(0,255,136,0.04) !important;
+}
+[data-testid="stTabs"] button[role="tab"][aria-selected="true"] {
+  color: #00ff88 !important;
+  border-bottom-color: #00ff88 !important;
+  text-shadow: 0 0 10px #00ff8840 !important;
+  background: rgba(0,255,136,0.05) !important;
+  margin-bottom: -2px !important;
+}
+
+/* ── Alerts ─────────────────────────────────────────────────────── */
+[data-testid="stAlert"] {
+  background: rgba(0,255,136,0.04) !important;
+  border: 1px solid #00ff8825 !important;
+  border-left: 3px solid #00ff88 !important;
+  border-radius: 3px !important;
+  font-size: 0.83rem !important;
+}
+
+/* ── Buttons ────────────────────────────────────────────────────── */
+[data-testid="stButton"] > button {
+  background: transparent !important;
+  border: 1px solid #00ff8850 !important;
+  border-radius: 2px !important;
+  color: #00ff88 !important;
+  font-family: 'Oxanium', sans-serif !important;
+  font-weight: 700 !important;
+  font-size: 0.82rem !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1.5px !important;
+  transition: all 0.18s !important;
+  padding: 0.5rem 1.4rem !important;
+}
+[data-testid="stButton"] > button:hover {
+  background: rgba(0,255,136,0.1) !important;
+  border-color: #00ff88 !important;
+  box-shadow: 0 0 14px #00ff8835 !important;
+  transform: translateY(-1px) !important;
+}
+[data-testid="stButton"] > button[kind="primary"] {
+  background: rgba(0,255,136,0.12) !important;
+  border-color: #00ff88 !important;
+  box-shadow: 0 0 10px #00ff8825 !important;
+}
+
+/* ── Sidebar collapse button ────────────────────────────────────── */
+[data-testid="stSidebarCollapseButton"] span,
+[data-testid="stSidebarCollapseButton"] p,
+[data-testid="stSidebarCollapseButton"] [data-testid="stIconMaterial"],
+[data-testid="stSidebarCollapsedControl"] span,
+[data-testid="stSidebarCollapsedControl"] [data-testid="stIconMaterial"] {
+  font-size: 0 !important;
+  color: transparent !important;
+}
+[data-testid="stSidebarCollapseButton"] button::after {
+  content: "Sidebar Einklappen" !important;
+  font-size: 0.7rem !important;
+  font-family: 'Oxanium', sans-serif !important;
+  color: #00ff8870 !important;
+  letter-spacing: 1.5px !important;
+  text-transform: uppercase !important;
+  pointer-events: none !important;
+}
+
+/* ── Divider ────────────────────────────────────────────────────── */
+hr {
+  border: none !important;
+  height: 1px !important;
+  background: linear-gradient(to right, transparent, #00ff8830, transparent) !important;
+  margin: 0.9rem 0 !important;
+}
+
+/* ── Spinner ────────────────────────────────────────────────────── */
+[data-testid="stSpinner"] > div {
+  border-top-color: #00ff88 !important;
+  filter: drop-shadow(0 0 5px #00ff88) !important;
+}
+
+/* ── Hero ───────────────────────────────────────────────────────── */
+.at-hero {
+  background: linear-gradient(135deg, #001408 0%, #002a12 50%, #001408 100%) !important;
+  border: 1px solid #00ff8828 !important;
+  border-top: 2px solid #00ff8870 !important;
+  border-radius: 5px !important;
+  padding: 2.5rem 2rem !important;
+  margin-bottom: 2rem !important;
+  position: relative !important;
+  overflow: hidden !important;
+}
+.at-hero::before {
+  content: '' !important;
+  position: absolute !important; inset: 0 !important;
+  background: repeating-linear-gradient(
+    0deg, transparent, transparent 3px,
+    rgba(0,255,136,0.012) 3px, rgba(0,255,136,0.012) 4px
+  ) !important;
+  pointer-events: none !important;
+}
+.at-hero::after {
+  content: '' !important;
+  position: absolute !important;
+  width: 280px; height: 280px !important;
+  top: -90px; right: -40px !important;
+  background: radial-gradient(circle, #00ff8818 0%, transparent 65%) !important;
+  pointer-events: none !important;
+}
+.at-hero h1, .at-hero p { margin: 0 !important; color: #ffffff !important; }
+.at-hero h1 {
+  font-family: 'Oxanium', sans-serif !important;
+  color: #00ff88 !important;
+  text-shadow: 0 0 30px #00ff8855 !important;
+  font-size: 2.2rem !important;
+  margin-bottom: 0.5rem !important;
+}
+.at-hero p {
+  color: #4a9966 !important;
+  font-size: 0.95rem !important;
+  opacity: 0.9 !important;
+}
+
+/* ── Feature boxes ──────────────────────────────────────────────── */
+.at-feature-icon { font-size: 1.8rem; margin-bottom: 0.4rem; }
+.at-feature-box {
+  background: rgba(0,255,136,0.025) !important;
+  border: 1px solid #00ff8820 !important;
+  border-top: 2px solid #00ff8855 !important;
+  border-radius: 4px !important;
+  padding: 1.2rem 1rem !important;
+  text-align: center !important;
+  height: 100% !important;
+  transition: background 0.18s, border-color 0.18s !important;
+}
+.at-feature-box:hover {
+  background: rgba(0,255,136,0.05) !important;
+  border-top-color: #00ff88 !important;
+}
+.at-feature-box strong {
+  font-family: 'Oxanium', sans-serif !important;
+  color: #c8f5dc !important;
+  font-size: 0.88rem !important;
+  text-transform: uppercase !important;
+  letter-spacing: 0.8px !important;
+}
+.at-feature-box p {
+  color: #2e6645 !important;
+  font-size: 0.8rem !important;
+  margin: 0 !important;
+}
+
+/* ── Cards ──────────────────────────────────────────────────────── */
+.at-card {
+  background: rgba(6,13,8,0.9) !important;
+  border: 1px solid #00ff8825 !important;
+  border-radius: 5px !important;
+  padding: 1.5rem 1.75rem !important;
+  margin-bottom: 1.25rem !important;
+  backdrop-filter: blur(4px) !important;
+  transition: border-color 0.2s !important;
+}
+.at-card:hover { border-color: #00ff8848 !important; }
+.at-card h3 {
+  margin-top: 0 !important;
+  color: #00ff88 !important;
+  text-shadow: 0 0 8px #00ff8830 !important;
+}
+
+/* ── Mobile ─────────────────────────────────────────────────────── */
+@media (max-width: 768px) {
+  .main .block-container { padding: 1rem 0.9rem 2rem !important; }
+  h1 { font-size: 1.5rem !important; }
+  [data-testid="stHorizontalBlock"] { flex-wrap: wrap !important; gap: 0.6rem !important; }
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] {
+    min-width: calc(50% - 0.3rem) !important;
+    flex: 1 1 calc(50% - 0.3rem) !important;
+  }
+  [data-testid="stTabs"] button[role="tab"] { padding: 0.4rem 0.65rem !important; font-size: 0.72rem !important; }
+  .at-hero { padding: 1.5rem 1.25rem !important; }
+  .at-hero h1 { font-size: 1.5rem !important; }
+  .at-card { padding: 1.1rem 1.2rem !important; }
+}
+@media (max-width: 480px) {
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] { min-width: 100% !important; }
+}
+</style>
+"""
+
+_HIDE_SIDEBAR_CSS = """
+<style>
+[data-testid="stSidebar"]                { display: none !important; }
+[data-testid="stSidebarCollapsedControl"]{ display: none !important; }
+.main .block-container { max-width: 900px !important; margin: 0 auto !important; }
+</style>
+"""
+
+
+def inject_css() -> None:
+    st.markdown(_CSS, unsafe_allow_html=True)
+
+
+def hide_sidebar() -> None:
+    st.markdown(_HIDE_SIDEBAR_CSS, unsafe_allow_html=True)

src/styles_v2_fieldguide.py

@@ -0,0 +1,331 @@
+"""
+Variant 2 — Field Guide
+Historisches Naturforschertagebuch. Pergament, Tinte, botanische Ästhetik.
+Wie Alexander von Humboldt auf einem Tablet.
+
+config.toml:
+  [theme]
+  primaryColor             = "#2d5016"
+  backgroundColor          = "#faf5e4"
+  secondaryBackgroundColor = "#f0e8d0"
+  textColor                = "#2a1f0e"
+  font                     = "serif"
+"""
+import streamlit as st
+
+_CSS = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Cormorant+Garamond:ital,wght@0,300;0,400;0,600;0,700;1,400;1,600&family=IM+Fell+English:ital@0;1&family=Space+Mono:ital,wght@0,400;0,700;1,400&display=swap');
+
+/* ── Base ───────────────────────────────────────────────────────── */
+.stApp {
+  background-color: #faf5e4 !important;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.75' numOctaves='4' stitchTiles='stitch'/%3E%3CfeColorMatrix type='saturate' values='0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='0.035'/%3E%3C/svg%3E") !important;
+}
+html, body { background-color: #faf5e4 !important; }
+
+/* ── Main container ─────────────────────────────────────────────── */
+.main .block-container {
+  padding: 2rem 2.5rem 3rem !important;
+  max-width: 1200px !important;
+}
+
+/* ── Typography ─────────────────────────────────────────────────── */
+html, body, [class*="css"], [class*="st-"] {
+  font-family: 'IM Fell English', Georgia, serif !important;
+  color: #2a1f0e !important;
+}
+h1, h2, h3 {
+  font-family: 'Cormorant Garamond', Georgia, serif !important;
+  color: #1a1008 !important;
+}
+h1 {
+  font-weight: 700 !important;
+  font-style: italic !important;
+  font-size: 2.2rem !important;
+  letter-spacing: 0.5px !important;
+  line-height: 1.2 !important;
+}
+h2 {
+  font-weight: 600 !important;
+  font-size: 1.4rem !important;
+  color: #2d5016 !important;
+  letter-spacing: 0.3px !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2px !important;
+  font-style: normal !important;
+}
+h3 {
+  font-weight: 600 !important;
+  font-size: 1.1rem !important;
+  font-style: italic !important;
+}
+[data-testid="stCaptionContainer"] p {
+  font-family: 'Space Mono', monospace !important;
+  color: #8b6e4e !important;
+  font-size: 0.75rem !important;
+  font-style: italic !important;
+}
+
+/* ── Sidebar ────────────────────────────────────────────────────── */
+[data-testid="stSidebar"] {
+  background-color: #f5ecda !important;
+  border-right: 2px solid #c4a882 !important;
+  border-right-style: solid !important;
+}
+[data-testid="stSidebar"]::after {
+  content: '' !important;
+  position: absolute !important;
+  top: 0; right: -8px; bottom: 0 !important;
+  width: 6px !important;
+  background: linear-gradient(to right, rgba(196,168,130,0.2), transparent) !important;
+  pointer-events: none !important;
+}
+[data-testid="stSidebar"] > div:first-child { padding-top: 1.5rem; }
+[data-testid="stSidebarUserContent"] h1 {
+  font-family: 'Cormorant Garamond', serif !important;
+  font-size: 1.3rem !important;
+  font-style: italic !important;
+  color: #2d5016 !important;
+}
+[data-testid="stSidebarUserContent"] label {
+  font-family: 'Space Mono', monospace !important;
+  font-size: 0.7rem !important;
+  color: #7a5c3a !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1px !important;
+}
+
+/* ── Selectbox / Input ──────────────────────────────────────────── */
+[data-testid="stSelectbox"] > div > div,
+[data-testid="stTextInput"] > div > div > input {
+  background-color: #fdf8ee !important;
+  border: 1px dashed #c4a882 !important;
+  border-radius: 3px !important;
+  color: #2a1f0e !important;
+  font-family: 'Space Mono', monospace !important;
+  font-size: 0.8rem !important;
+}
+[data-testid="stSelectbox"] > div > div:focus-within {
+  border-color: #2d5016 !important;
+  border-style: solid !important;
+  box-shadow: 0 0 0 2px rgba(45,80,22,0.1) !important;
+}
+
+/* ── Metric cards ───────────────────────────────────────────────── */
+[data-testid="stMetric"] {
+  background: #fdf8ee !important;
+  border: 1px dashed #c4a882 !important;
+  border-radius: 4px !important;
+  padding: 1.1rem 1.3rem !important;
+  box-shadow: 2px 3px 10px rgba(139,90,43,0.12) !important;
+  position: relative !important;
+}
+[data-testid="stMetricValue"] {
+  font-family: 'Space Mono', monospace !important;
+  font-size: 1.85rem !important;
+  font-weight: 700 !important;
+  color: #2d5016 !important;
+}
+[data-testid="stMetricLabel"] {
+  font-family: 'Cormorant Garamond', serif !important;
+  font-size: 0.9rem !important;
+  font-style: italic !important;
+  font-weight: 400 !important;
+  color: #8b6e4e !important;
+  text-transform: none !important;
+  letter-spacing: 0.2px !important;
+}
+
+/* ── Tabs ───────────────────────────────────────────────────────── */
+[data-testid="stTabs"] [role="tablist"] {
+  gap: 4px !important;
+  border-bottom: 1px solid #c4a882 !important;
+  border-bottom-style: dashed !important;
+  padding-bottom: 0 !important;
+}
+[data-testid="stTabs"] button[role="tab"] {
+  border-radius: 4px 4px 0 0 !important;
+  font-family: 'Cormorant Garamond', serif !important;
+  font-weight: 600 !important;
+  font-size: 1rem !important;
+  font-style: italic !important;
+  padding: 0.5rem 1.1rem !important;
+  color: #8b6e4e !important;
+  border: 1px dashed transparent !important;
+  border-bottom: none !important;
+  background: transparent !important;
+  transition: color 0.15s, background 0.15s !important;
+}
+[data-testid="stTabs"] button[role="tab"]:hover {
+  color: #2d5016 !important;
+  background: rgba(45,80,22,0.05) !important;
+}
+[data-testid="stTabs"] button[role="tab"][aria-selected="true"] {
+  color: #2d5016 !important;
+  font-weight: 700 !important;
+  background: #fdf8ee !important;
+  border-color: #c4a882 !important;
+  border-bottom-color: #fdf8ee !important;
+  margin-bottom: -2px !important;
+}
+
+/* ── Alerts ─────────────────────────────────────────────────────── */
+[data-testid="stAlert"] {
+  background: #fdf8ee !important;
+  border: 1px dashed #c4a882 !important;
+  border-left: 3px solid #8b3a3a !important;
+  border-left-style: solid !important;
+  border-radius: 4px !important;
+  font-family: 'IM Fell English', serif !important;
+}
+
+/* ── Buttons ────────────────────────────────────────────────────── */
+[data-testid="stButton"] > button {
+  background: #f0e8d0 !important;
+  border: 1px solid #c4a882 !important;
+  border-radius: 3px !important;
+  color: #2d5016 !important;
+  font-family: 'Cormorant Garamond', serif !important;
+  font-weight: 600 !important;
+  font-style: italic !important;
+  font-size: 1rem !important;
+  transition: all 0.15s !important;
+  padding: 0.45rem 1.4rem !important;
+  letter-spacing: 0.3px !important;
+}
+[data-testid="stButton"] > button:hover {
+  background: #e8dcc0 !important;
+  border-color: #8b6e4e !important;
+  transform: translateY(-1px) !important;
+  box-shadow: 2px 3px 8px rgba(139,90,43,0.18) !important;
+}
+[data-testid="stButton"] > button[kind="primary"] {
+  background: #2d5016 !important;
+  color: #faf5e4 !important;
+  border-color: #1a3009 !important;
+}
+
+/* ── Divider ────────────────────────────────────────────────────── */
+hr {
+  border: none !important;
+  height: 1px !important;
+  background: linear-gradient(to right, transparent, #c4a882 30%, #c4a882 70%, transparent) !important;
+  margin: 1rem 0 !important;
+}
+
+/* ── Spinner ────────────────────────────────────────────────────── */
+[data-testid="stSpinner"] > div { border-top-color: #2d5016 !important; }
+
+/* ── Hero ───────────────────────────────────────────────────────── */
+.at-hero {
+  background: linear-gradient(135deg, #2d5016 0%, #3d7020 60%, #2d5016 100%) !important;
+  border: 2px solid #1a3009 !important;
+  border-radius: 5px !important;
+  padding: 2.5rem 2rem !important;
+  margin-bottom: 2rem !important;
+  position: relative !important;
+  overflow: hidden !important;
+  box-shadow: 4px 6px 20px rgba(45,80,22,0.25) !important;
+}
+.at-hero::before {
+  content: '' !important;
+  position: absolute !important; inset: 0 !important;
+  background: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='300' height='300'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.8' numOctaves='3' stitchTiles='stitch'/%3E%3CfeColorMatrix type='saturate' values='0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='0.06'/%3E%3C/svg%3E") !important;
+  pointer-events: none !important;
+}
+.at-hero h1, .at-hero p { margin: 0 !important; color: #faf5e4 !important; }
+.at-hero h1 {
+  font-family: 'Cormorant Garamond', serif !important;
+  color: #faf5e4 !important;
+  font-style: italic !important;
+  text-shadow: none !important;
+  font-size: 2.2rem !important;
+  font-weight: 700 !important;
+  letter-spacing: 1px !important;
+  margin-bottom: 0.5rem !important;
+}
+.at-hero p {
+  color: #b8d4a8 !important;
+  font-family: 'IM Fell English', serif !important;
+  font-style: italic !important;
+  font-size: 1.05rem !important;
+  opacity: 0.92 !important;
+}
+
+/* ── Feature boxes ──────────────────────────────────────────────── */
+.at-feature-icon { font-size: 1.8rem; margin-bottom: 0.4rem; }
+.at-feature-box {
+  background: #fdf8ee !important;
+  border: 1px dashed #c4a882 !important;
+  border-radius: 4px !important;
+  padding: 1.2rem 1rem !important;
+  text-align: center !important;
+  height: 100% !important;
+  box-shadow: 1px 2px 6px rgba(139,90,43,0.1) !important;
+}
+.at-feature-box strong {
+  font-family: 'Cormorant Garamond', serif !important;
+  color: #1a1008 !important;
+  font-size: 1.05rem !important;
+  font-weight: 700 !important;
+  font-style: italic !important;
+}
+.at-feature-box p {
+  color: #7a5c3a !important;
+  font-family: 'IM Fell English', serif !important;
+  font-style: italic !important;
+  font-size: 0.88rem !important;
+  margin: 0 !important;
+}
+
+/* ── Cards ──────────────────────────────────────────────────────── */
+.at-card {
+  background: #fdf8ee !important;
+  border: 1px dashed #c4a882 !important;
+  border-radius: 5px !important;
+  padding: 1.5rem 1.75rem !important;
+  margin-bottom: 1.25rem !important;
+  box-shadow: 2px 3px 10px rgba(139,90,43,0.1) !important;
+}
+.at-card h3 {
+  margin-top: 0 !important;
+  color: #2d5016 !important;
+  font-style: italic !important;
+}
+
+/* ── Mobile ─────────────────────────────────────────────────────── */
+@media (max-width: 768px) {
+  .main .block-container { padding: 1rem 0.9rem 2rem !important; }
+  h1 { font-size: 1.7rem !important; }
+  [data-testid="stHorizontalBlock"] { flex-wrap: wrap !important; gap: 0.6rem !important; }
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] {
+    min-width: calc(50% - 0.3rem) !important;
+    flex: 1 1 calc(50% - 0.3rem) !important;
+  }
+  [data-testid="stTabs"] button[role="tab"] { padding: 0.4rem 0.65rem !important; font-size: 0.88rem !important; }
+  .at-hero { padding: 1.5rem 1.25rem !important; }
+  .at-hero h1 { font-size: 1.6rem !important; }
+  .at-card { padding: 1.1rem 1.2rem !important; }
+}
+@media (max-width: 480px) {
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] { min-width: 100% !important; }
+}
+</style>
+"""
+
+_HIDE_SIDEBAR_CSS = """
+<style>
+[data-testid="stSidebar"]                { display: none !important; }
+[data-testid="stSidebarCollapsedControl"]{ display: none !important; }
+.main .block-container { max-width: 900px !important; margin: 0 auto !important; }
+</style>
+"""
+
+
+def inject_css() -> None:
+    st.markdown(_CSS, unsafe_allow_html=True)
+
+
+def hide_sidebar() -> None:
+    st.markdown(_HIDE_SIDEBAR_CSS, unsafe_allow_html=True)

src/styles_v3_scientific.py

@@ -0,0 +1,316 @@
+"""
+Variant 3 — Scientific Observatory
+Präzisions-Datenzentrum. Klar, kantig, kompromisslos.
+Wie eine Seite aus Nature — aber interaktiv.
+
+config.toml:
+  [theme]
+  primaryColor             = "#0056b3"
+  backgroundColor          = "#f8fafc"
+  secondaryBackgroundColor = "#ffffff"
+  textColor                = "#212529"
+  font                     = "sans serif"
+"""
+import streamlit as st
+
+_CSS = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:ital,wght@0,300;0,400;0,500;0,600;0,700;1,400&family=IBM+Plex+Mono:wght@400;500;600&display=swap');
+
+/* ── Base ───────────────────────────────────────────────────────── */
+.stApp { background-color: #f8fafc !important; }
+html, body { background-color: #f8fafc !important; }
+
+/* ── Main container ─────────────────────────────────────────────── */
+.main .block-container {
+  padding: 2rem 2.5rem 3rem !important;
+  max-width: 1200px !important;
+}
+
+/* ── Typography ─────────────────────────────────────────────────── */
+html, body, [class*="css"], [class*="st-"] {
+  font-family: 'IBM Plex Sans', sans-serif !important;
+  color: #212529 !important;
+}
+h1 {
+  font-weight: 700 !important;
+  font-size: 1.85rem !important;
+  letter-spacing: -0.2px !important;
+  line-height: 1.2 !important;
+  color: #0d1117 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 3px !important;
+}
+h2 {
+  font-weight: 600 !important;
+  font-size: 1.05rem !important;
+  color: #0056b3 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2.5px !important;
+  border-bottom: 2px solid #0056b3 !important;
+  padding-bottom: 0.35rem !important;
+}
+h3 {
+  font-weight: 600 !important;
+  font-size: 0.9rem !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1.5px !important;
+  color: #495057 !important;
+}
+[data-testid="stCaptionContainer"] p {
+  font-family: 'IBM Plex Mono', monospace !important;
+  color: #6c757d !important;
+  font-size: 0.75rem !important;
+}
+
+/* ── Sidebar ────────────────────────────────────────────────────── */
+[data-testid="stSidebar"] {
+  background-color: #ffffff !important;
+  border-right: 2px solid #0056b3 !important;
+}
+[data-testid="stSidebar"] > div:first-child { padding-top: 1.5rem; }
+[data-testid="stSidebarUserContent"] h1 {
+  font-size: 0.95rem !important;
+  font-weight: 700 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2.5px !important;
+  color: #0056b3 !important;
+  border-bottom: 1px solid #dee2e6 !important;
+  padding-bottom: 0.5rem !important;
+}
+[data-testid="stSidebarUserContent"] label {
+  font-family: 'IBM Plex Mono', monospace !important;
+  font-size: 0.7rem !important;
+  color: #6c757d !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1.5px !important;
+  font-weight: 500 !important;
+}
+
+/* ── Selectbox / Input ──────────────────────────────────────────── */
+[data-testid="stSelectbox"] > div > div,
+[data-testid="stTextInput"] > div > div > input {
+  background-color: #ffffff !important;
+  border: 1px solid #ced4da !important;
+  border-radius: 0 !important;
+  color: #212529 !important;
+  font-family: 'IBM Plex Mono', monospace !important;
+  font-size: 0.82rem !important;
+}
+[data-testid="stSelectbox"] > div > div:focus-within {
+  border-color: #0056b3 !important;
+  box-shadow: 0 0 0 3px rgba(0,86,179,0.12) !important;
+}
+
+/* ── Metric cards ───────────────────────────────────────────────── */
+[data-testid="stMetric"] {
+  background: #ffffff !important;
+  border: 1px solid #dee2e6 !important;
+  border-top: 4px solid #0056b3 !important;
+  border-radius: 0 !important;
+  padding: 1.1rem 1.3rem !important;
+  box-shadow: 0 1px 3px rgba(0,0,0,0.06) !important;
+}
+[data-testid="stMetricValue"] {
+  font-family: 'IBM Plex Mono', monospace !important;
+  font-size: 1.9rem !important;
+  font-weight: 600 !important;
+  color: #0056b3 !important;
+}
+[data-testid="stMetricLabel"] {
+  font-family: 'IBM Plex Mono', monospace !important;
+  font-size: 0.65rem !important;
+  font-weight: 500 !important;
+  color: #6c757d !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2px !important;
+}
+
+/* ── Tabs ───────────────────────────────────────────────────────── */
+[data-testid="stTabs"] [role="tablist"] {
+  gap: 0 !important;
+  border-bottom: 2px solid #dee2e6 !important;
+  padding-bottom: 0 !important;
+}
+[data-testid="stTabs"] button[role="tab"] {
+  border-radius: 0 !important;
+  font-family: 'IBM Plex Sans', sans-serif !important;
+  font-weight: 600 !important;
+  font-size: 0.75rem !important;
+  text-transform: uppercase !important;
+  letter-spacing: 2px !important;
+  padding: 0.6rem 1.2rem !important;
+  color: #6c757d !important;
+  border: none !important;
+  border-bottom: 3px solid transparent !important;
+  background: transparent !important;
+  transition: color 0.12s, border-color 0.12s !important;
+}
+[data-testid="stTabs"] button[role="tab"]:hover {
+  color: #0056b3 !important;
+  background: rgba(0,86,179,0.04) !important;
+}
+[data-testid="stTabs"] button[role="tab"][aria-selected="true"] {
+  color: #0056b3 !important;
+  border-bottom-color: #0056b3 !important;
+  background: transparent !important;
+  margin-bottom: -2px !important;
+}
+
+/* ── Alerts ─────────────────────────────────────────────────────── */
+[data-testid="stAlert"] {
+  background: #ffffff !important;
+  border: 1px solid #dee2e6 !important;
+  border-left: 4px solid #0056b3 !important;
+  border-radius: 0 !important;
+  font-size: 0.85rem !important;
+}
+
+/* ── Buttons ────────────────────────────────────────────────────── */
+[data-testid="stButton"] > button {
+  background: #ffffff !important;
+  border: 1px solid #0056b3 !important;
+  border-radius: 0 !important;
+  color: #0056b3 !important;
+  font-family: 'IBM Plex Sans', sans-serif !important;
+  font-weight: 600 !important;
+  font-size: 0.8rem !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1.5px !important;
+  transition: background 0.12s, color 0.12s !important;
+  padding: 0.5rem 1.4rem !important;
+}
+[data-testid="stButton"] > button:hover {
+  background: #0056b3 !important;
+  color: #ffffff !important;
+}
+[data-testid="stButton"] > button[kind="primary"] {
+  background: #0056b3 !important;
+  color: #ffffff !important;
+  border-color: #0046a0 !important;
+  padding: 0.5rem 1.6rem !important;
+  font-weight: 700 !important;
+}
+[data-testid="stButton"] > button[kind="primary"]:hover {
+  background: #0046a0 !important;
+}
+
+/* ── Divider ────────────────────────────────────────────────────── */
+hr {
+  border: none !important;
+  border-top: 1px solid #dee2e6 !important;
+  margin: 0.8rem 0 !important;
+}
+
+/* ── Spinner ────────────────────────────────────────────────────── */
+[data-testid="stSpinner"] > div { border-top-color: #0056b3 !important; }
+
+/* ── Hero ───────────────────────────────────────────────────────── */
+.at-hero {
+  background: #0056b3 !important;
+  border-radius: 0 !important;
+  padding: 2.5rem 2rem !important;
+  margin-bottom: 2rem !important;
+  border-left: 6px solid #002b6b !important;
+  position: relative !important;
+}
+.at-hero::after {
+  content: '' !important;
+  position: absolute !important;
+  top: 0; right: 0; bottom: 0 !important;
+  width: 4px !important;
+  background: #e63946 !important;
+}
+.at-hero h1, .at-hero p { margin: 0 !important; color: #ffffff !important; }
+.at-hero h1 {
+  color: #ffffff !important;
+  font-size: 1.9rem !important;
+  font-weight: 700 !important;
+  letter-spacing: 4px !important;
+  text-transform: uppercase !important;
+  margin-bottom: 0.6rem !important;
+}
+.at-hero p {
+  font-family: 'IBM Plex Mono', monospace !important;
+  color: rgba(255,255,255,0.75) !important;
+  font-size: 0.85rem !important;
+}
+
+/* ── Feature boxes ──────────────────────────────────────────────── */
+.at-feature-icon { font-size: 1.4rem; margin-bottom: 0.4rem; }
+.at-feature-box {
+  background: #ffffff !important;
+  border: 1px solid #dee2e6 !important;
+  border-top: 3px solid #0056b3 !important;
+  border-radius: 0 !important;
+  padding: 1.2rem 1rem !important;
+  text-align: center !important;
+  height: 100% !important;
+}
+.at-feature-box strong {
+  font-family: 'IBM Plex Sans', sans-serif !important;
+  color: #0d1117 !important;
+  font-size: 0.82rem !important;
+  font-weight: 700 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1px !important;
+}
+.at-feature-box p {
+  font-family: 'IBM Plex Mono', monospace !important;
+  color: #6c757d !important;
+  font-size: 0.78rem !important;
+  margin: 0 !important;
+}
+
+/* ── Cards ──────────────────���───────────────────────────────────── */
+.at-card {
+  background: #ffffff !important;
+  border: 1px solid #dee2e6 !important;
+  border-radius: 0 !important;
+  padding: 1.5rem 1.75rem !important;
+  margin-bottom: 1.25rem !important;
+  box-shadow: 0 1px 3px rgba(0,0,0,0.05) !important;
+}
+.at-card h3 {
+  margin-top: 0 !important;
+  color: #0056b3 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1.5px !important;
+  font-style: normal !important;
+}
+
+/* ── Mobile ─────────────────────────────────────────────────────── */
+@media (max-width: 768px) {
+  .main .block-container { padding: 1rem 0.9rem 2rem !important; }
+  h1 { font-size: 1.35rem !important; }
+  [data-testid="stHorizontalBlock"] { flex-wrap: wrap !important; gap: 0.6rem !important; }
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] {
+    min-width: calc(50% - 0.3rem) !important;
+    flex: 1 1 calc(50% - 0.3rem) !important;
+  }
+  [data-testid="stTabs"] button[role="tab"] { padding: 0.4rem 0.65rem !important; font-size: 0.7rem !important; }
+  .at-hero { padding: 1.5rem 1.25rem !important; }
+  .at-hero h1 { font-size: 1.3rem !important; }
+  .at-card { padding: 1.1rem 1.2rem !important; }
+}
+@media (max-width: 480px) {
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] { min-width: 100% !important; }
+}
+</style>
+"""
+
+_HIDE_SIDEBAR_CSS = """
+<style>
+[data-testid="stSidebar"]                { display: none !important; }
+[data-testid="stSidebarCollapsedControl"]{ display: none !important; }
+.main .block-container { max-width: 900px !important; margin: 0 auto !important; }
+</style>
+"""
+
+
+def inject_css() -> None:
+    st.markdown(_CSS, unsafe_allow_html=True)
+
+
+def hide_sidebar() -> None:
+    st.markdown(_HIDE_SIDEBAR_CSS, unsafe_allow_html=True)

src/styles_v4_forestguardian.py

@@ -0,0 +1,360 @@
+"""
+Variant 4 — Deep Forest Guardian
+Nächtliche Umweltüberwachungszentrale. Reiches Dunkelgrün,
+warmes Amber, wie ein Leitstand tief im Wald.
+
+config.toml:
+  [theme]
+  primaryColor             = "#4caf50"
+  backgroundColor          = "#0d1f0f"
+  secondaryBackgroundColor = "#142916"
+  textColor                = "#c8e6c9"
+  font                     = "sans serif"
+"""
+import streamlit as st
+
+_CSS = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Nunito:ital,wght@0,300;0,400;0,500;0,600;0,700;0,800;1,400&family=Fira+Code:wght@400;500;600&display=swap');
+
+/* ── Keyframes ──────────────────────────────────────────────────── */
+@keyframes status-pulse {
+  0%,100% { opacity: 1; box-shadow: 0 0 0 0 rgba(76,175,80,0.5); }
+  50%      { opacity: 0.85; box-shadow: 0 0 0 5px rgba(76,175,80,0); }
+}
+@keyframes amber-pulse {
+  0%,100% { opacity: 1; box-shadow: 0 0 0 0 rgba(255,167,38,0.45); }
+  50%      { opacity: 0.8; box-shadow: 0 0 0 5px rgba(255,167,38,0); }
+}
+@keyframes slide-up {
+  from { opacity: 0; transform: translateY(8px); }
+  to   { opacity: 1; transform: translateY(0); }
+}
+
+/* ── Base ───────────────────────────────────────────────────────── */
+.stApp {
+  background-color: #0d1f0f !important;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='200' height='200'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='4' stitchTiles='stitch'/%3E%3CfeColorMatrix type='saturate' values='0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='0.03'/%3E%3C/svg%3E") !important;
+}
+html, body { background-color: #0d1f0f !important; }
+section.main, [data-testid="stAppViewContainer"] {
+  background-color: #0d1f0f !important;
+}
+
+/* ── Main container ─────────────────────────────────────────────── */
+.main .block-container {
+  padding: 2rem 2.5rem 3rem !important;
+  max-width: 1200px !important;
+}
+
+/* ── Typography ─────────────────────────────────────────────────── */
+html, body, [class*="css"], [class*="st-"] {
+  font-family: 'Nunito', sans-serif !important;
+  color: #c8e6c9 !important;
+}
+h1, h2, h3 {
+  font-family: 'Nunito', sans-serif !important;
+  color: #e8f5e9 !important;
+}
+h1 {
+  font-weight: 800 !important;
+  font-size: 2rem !important;
+  letter-spacing: -0.3px !important;
+  line-height: 1.2 !important;
+}
+h2 {
+  font-weight: 700 !important;
+  font-size: 1.15rem !important;
+  color: #81c784 !important;
+}
+h3 {
+  font-weight: 600 !important;
+  font-size: 1rem !important;
+  color: #a5d6a7 !important;
+}
+p, span, div { color: #c8e6c9 !important; }
+[data-testid="stCaptionContainer"] p {
+  font-family: 'Fira Code', monospace !important;
+  color: #558b5a !important;
+  font-size: 0.76rem !important;
+}
+
+/* ── Sidebar ────────────────────────────────────────────────────── */
+[data-testid="stSidebar"] {
+  background-color: #0a1a0b !important;
+  border-right: 1px solid #1e3a1f !important;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='200' height='200'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='3' stitchTiles='stitch'/%3E%3CfeColorMatrix type='saturate' values='0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='0.04'/%3E%3C/svg%3E") !important;
+}
+[data-testid="stSidebar"] > div:first-child { padding-top: 1.5rem; }
+[data-testid="stSidebarUserContent"] h1 {
+  font-size: 1.2rem !important;
+  font-weight: 800 !important;
+  color: #4caf50 !important;
+}
+[data-testid="stSidebarUserContent"] label {
+  font-family: 'Fira Code', monospace !important;
+  font-size: 0.72rem !important;
+  color: #558b5a !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1px !important;
+}
+
+/* ── Selectbox / Input ──────────────────────────────────────────── */
+[data-testid="stSelectbox"] > div > div,
+[data-testid="stTextInput"] > div > div > input {
+  background-color: #142916 !important;
+  border: 1px solid #1e3a1f !important;
+  border-radius: 8px !important;
+  color: #c8e6c9 !important;
+  font-family: 'Fira Code', monospace !important;
+  font-size: 0.82rem !important;
+}
+[data-testid="stSelectbox"] > div > div:focus-within {
+  border-color: #4caf50 !important;
+  box-shadow: 0 0 0 2px rgba(76,175,80,0.2) !important;
+}
+
+/* ── Metric cards ────���──────────────────────────────────────────── */
+[data-testid="stMetric"] {
+  background: #142916 !important;
+  border: 1px solid #1e3a1f !important;
+  border-left: 3px solid #4caf50 !important;
+  border-radius: 10px !important;
+  padding: 1.1rem 1.3rem !important;
+  box-shadow: 0 2px 8px rgba(0,0,0,0.3) !important;
+  animation: slide-up 0.4s ease both !important;
+  transition: border-color 0.2s !important;
+}
+[data-testid="stMetric"]:hover {
+  border-left-color: #66bb6a !important;
+  background: #183318 !important;
+}
+[data-testid="stMetricValue"] {
+  font-family: 'Fira Code', monospace !important;
+  font-size: 1.9rem !important;
+  font-weight: 600 !important;
+  color: #4caf50 !important;
+}
+[data-testid="stMetricLabel"] {
+  font-family: 'Nunito', sans-serif !important;
+  font-size: 0.72rem !important;
+  font-weight: 700 !important;
+  color: #558b5a !important;
+  text-transform: uppercase !important;
+  letter-spacing: 1.5px !important;
+}
+
+/* ── Tabs ───────────────────────────────────────────────────────── */
+[data-testid="stTabs"] [role="tablist"] {
+  gap: 4px !important;
+  border-bottom: 1px solid #1e3a1f !important;
+  padding-bottom: 0 !important;
+}
+[data-testid="stTabs"] button[role="tab"] {
+  border-radius: 8px 8px 0 0 !important;
+  font-family: 'Nunito', sans-serif !important;
+  font-weight: 700 !important;
+  font-size: 0.85rem !important;
+  padding: 0.55rem 1.1rem !important;
+  color: #558b5a !important;
+  border: 1px solid transparent !important;
+  border-bottom: none !important;
+  background: transparent !important;
+  transition: color 0.15s, background 0.15s !important;
+}
+[data-testid="stTabs"] button[role="tab"]:hover {
+  color: #81c784 !important;
+  background: rgba(76,175,80,0.08) !important;
+}
+[data-testid="stTabs"] button[role="tab"][aria-selected="true"] {
+  color: #ffa726 !important;
+  font-weight: 800 !important;
+  background: #142916 !important;
+  border-color: #1e3a1f !important;
+  border-bottom-color: #142916 !important;
+  margin-bottom: -1px !important;
+}
+
+/* ── Alerts ─────────────────────────────────────────────────────── */
+[data-testid="stAlert"] {
+  background: #142916 !important;
+  border: 1px solid #1e3a1f !important;
+  border-left: 3px solid #ffa726 !important;
+  border-radius: 8px !important;
+  font-size: 0.85rem !important;
+}
+
+/* ── Buttons ────────────────────────────────────────────────────── */
+[data-testid="stButton"] > button {
+  background: #142916 !important;
+  border: 1px solid #2d5a30 !important;
+  border-radius: 8px !important;
+  color: #4caf50 !important;
+  font-family: 'Nunito', sans-serif !important;
+  font-weight: 700 !important;
+  font-size: 0.9rem !important;
+  transition: all 0.18s !important;
+  padding: 0.5rem 1.4rem !important;
+}
+[data-testid="stButton"] > button:hover {
+  background: #1e3a1f !important;
+  border-color: #4caf50 !important;
+  color: #a5d6a7 !important;
+  transform: translateY(-1px) !important;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.3) !important;
+}
+[data-testid="stButton"] > button[kind="primary"] {
+  background: #2d5a30 !important;
+  border-color: #4caf50 !important;
+  color: #e8f5e9 !important;
+  padding: 0.5rem 1.6rem !important;
+}
+[data-testid="stButton"] > button[kind="primary"]:hover {
+  background: #3d7a40 !important;
+}
+
+/* ── Divider ────────────────────────────────────────────────────── */
+hr {
+  border: none !important;
+  border-top: 1px solid #1e3a1f !important;
+  margin: 0.8rem 0 !important;
+}
+
+/* ── Spinner ────────────────────────────────────────────────────── */
+[data-testid="stSpinner"] > div {
+  border-top-color: #4caf50 !important;
+}
+
+/* ── Hero ───────────────────────────────────────────────────────── */
+.at-hero {
+  background: radial-gradient(ellipse at 60% 40%, #1a4020 0%, #0d1f0f 65%) !important;
+  border: 1px solid #1e3a1f !important;
+  border-radius: 14px !important;
+  padding: 2.8rem 2rem !important;
+  margin-bottom: 2rem !important;
+  position: relative !important;
+  overflow: hidden !important;
+  box-shadow: 0 4px 24px rgba(0,0,0,0.4) !important;
+}
+.at-hero::before {
+  content: '' !important;
+  position: absolute !important;
+  width: 200px; height: 200px !important;
+  top: -50px; left: -50px !important;
+  background: radial-gradient(circle, rgba(76,175,80,0.15) 0%, transparent 65%) !important;
+  pointer-events: none !important;
+}
+.at-hero::after {
+  content: '' !important;
+  position: absolute !important;
+  width: 12px; height: 12px !important;
+  top: 1.2rem; right: 1.5rem !important;
+  border-radius: 50% !important;
+  background: #4caf50 !important;
+  animation: status-pulse 2.5s ease-in-out infinite !important;
+}
+.at-hero h1, .at-hero p { margin: 0 !important; color: #e8f5e9 !important; }
+.at-hero h1 {
+  color: #e8f5e9 !important;
+  font-weight: 800 !important;
+  font-size: 2.2rem !important;
+  margin-bottom: 0.5rem !important;
+}
+.at-hero p {
+  color: #81c784 !important;
+  font-size: 1rem !important;
+  opacity: 0.88 !important;
+}
+
+/* ── Feature boxes ──────────────────────────────────────────────── */
+.at-feature-icon { font-size: 1.8rem; margin-bottom: 0.4rem; }
+.at-feature-box {
+  background: #142916 !important;
+  border: 1px solid #1e3a1f !important;
+  border-radius: 12px !important;
+  padding: 1.2rem 1rem !important;
+  text-align: center !important;
+  height: 100% !important;
+  transition: background 0.18s, border-color 0.18s !important;
+}
+.at-feature-box:hover {
+  background: #183318 !important;
+  border-color: #2d5a30 !important;
+}
+.at-feature-box strong {
+  font-family: 'Nunito', sans-serif !important;
+  color: #a5d6a7 !important;
+  font-size: 0.95rem !important;
+  font-weight: 700 !important;
+}
+.at-feature-box p {
+  color: #558b5a !important;
+  font-size: 0.85rem !important;
+  margin: 0 !important;
+}
+
+/* ── Cards ──────────────────────────────────────────────────────── */
+.at-card {
+  background: #142916 !important;
+  border: 1px solid #1e3a1f !important;
+  border-left: 3px solid #4caf50 !important;
+  border-radius: 12px !important;
+  padding: 1.5rem 1.75rem !important;
+  margin-bottom: 1.25rem !important;
+  box-shadow: 0 2px 10px rgba(0,0,0,0.25) !important;
+}
+.at-card h3 {
+  margin-top: 0 !important;
+  color: #81c784 !important;
+}
+
+/* ── Pulsing status dot — reusuable helper ──────────────────────── */
+.at-status-dot {
+  display: inline-block !important;
+  width: 8px; height: 8px !important;
+  border-radius: 50% !important;
+  background: #4caf50 !important;
+  margin-right: 0.4rem !important;
+  vertical-align: middle !important;
+  animation: status-pulse 2.5s ease-in-out infinite !important;
+}
+.at-status-dot.amber {
+  background: #ffa726 !important;
+  animation: amber-pulse 2.5s ease-in-out infinite !important;
+}
+
+/* ── Mobile ─────────────────────────────────────────────────────── */
+@media (max-width: 768px) {
+  .main .block-container { padding: 1rem 0.9rem 2rem !important; }
+  h1 { font-size: 1.6rem !important; }
+  [data-testid="stHorizontalBlock"] { flex-wrap: wrap !important; gap: 0.6rem !important; }
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] {
+    min-width: calc(50% - 0.3rem) !important;
+    flex: 1 1 calc(50% - 0.3rem) !important;
+  }
+  [data-testid="stTabs"] button[role="tab"] { padding: 0.4rem 0.65rem !important; font-size: 0.78rem !important; }
+  .at-hero { padding: 1.5rem 1.25rem !important; }
+  .at-hero h1 { font-size: 1.6rem !important; }
+  .at-card { padding: 1.1rem 1.2rem !important; }
+}
+@media (max-width: 480px) {
+  [data-testid="stHorizontalBlock"] > [data-testid="stColumn"] { min-width: 100% !important; }
+}
+</style>
+"""
+
+_HIDE_SIDEBAR_CSS = """
+<style>
+[data-testid="stSidebar"]                { display: none !important; }
+[data-testid="stSidebarCollapsedControl"]{ display: none !important; }
+.main .block-container { max-width: 900px !important; margin: 0 auto !important; }
+</style>
+"""
+
+
+def inject_css() -> None:
+    st.markdown(_CSS, unsafe_allow_html=True)
+
+
+def hide_sidebar() -> None:
+    st.markdown(_HIDE_SIDEBAR_CSS, unsafe_allow_html=True)

src/temporal_analysis.py

@@ -0,0 +1,35 @@
+import pandas as pd
+import geopandas as gpd
+
+from src.utils import PERIODS, CURRENT_YEAR, YEAR_FROM
+
+
+def filter_by_period(gdf: gpd.GeoDataFrame, start: int, end: int) -> gpd.GeoDataFrame:
+    return gdf[gdf["year"].between(start, end)].copy()
+
+
+def filter_current_year(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    return gdf[gdf["year"] == CURRENT_YEAR].copy()
+
+
+def compute_annual_trend(df: pd.DataFrame, year_from: int = YEAR_FROM,
+                         year_to: int = CURRENT_YEAR) -> pd.DataFrame:
+    if df.empty or "year" not in df.columns:
+        years = range(year_from, year_to + 1)
+        return pd.DataFrame({"year": list(years), "count": [0] * len(list(years))})
+
+    counts = df.dropna(subset=["year"]).groupby("year").size().reset_index(name="count")
+    all_years = pd.DataFrame({"year": range(year_from, year_to + 1)})
+    trend = all_years.merge(counts, on="year", how="left").fillna(0)
+    trend["count"] = trend["count"].astype(int)
+    trend["year"] = trend["year"].astype(int)
+    return trend
+
+
+def period_label_for_year(year: int) -> str:
+    for start, end, label in PERIODS:
+        if start <= year <= end:
+            return label
+    if year == CURRENT_YEAR:
+        return str(CURRENT_YEAR)
+    return str(year)

src/utils.py

@@ -0,0 +1,133 @@
+from pathlib import Path
+
+BASE_DIR = Path(__file__).parent.parent
+BOUNDARIES_DIR = BASE_DIR / "data" / "boundaries"
+VG250_DIR = BOUNDARIES_DIR / "vg250"
+NE_DIR = BOUNDARIES_DIR / "natural_earth"
+CACHE_DIR = BASE_DIR / "data" / "species_cache"
+
+PERIODS = [
+    (2006, 2009, "2006–2009"),
+    (2010, 2013, "2010–2013"),
+    (2014, 2017, "2014–2017"),
+    (2018, 2021, "2018–2021"),
+    (2022, 2025, "2022–2025"),
+]
+CURRENT_YEAR = 2026
+YEAR_FROM = 2006
+HIST_YEAR_TO = CURRENT_YEAR - 1  # last year included in on-disk cache
+
+SCOPE_OPTIONS = {
+    "Gemeinden (DE)": "gemeinden",
+    "Kreise (DE)": "kreise",
+    "Bundesländer (DE)": "bundeslaender",
+    "Admin-1 (Welt)": "admin1",
+    "Länder (Welt)": "countries",
+}
+
+UNIT_NAME_COL = {
+    "gemeinden": "GEN",
+    "kreise": "GEN",
+    "bundeslaender": "GEN",
+    "admin1": "name",
+    "countries": "NAME",
+}
+
+AGS_TO_BUNDESLAND = {
+    "01": "Schleswig-Holstein",
+    "02": "Hamburg",
+    "03": "Niedersachsen",
+    "04": "Bremen",
+    "05": "Nordrhein-Westfalen",
+    "06": "Hessen",
+    "07": "Rheinland-Pfalz",
+    "08": "Baden-Württemberg",
+    "09": "Bayern",
+    "10": "Saarland",
+    "11": "Berlin",
+    "12": "Brandenburg",
+    "13": "Mecklenburg-Vorpommern",
+    "14": "Sachsen",
+    "15": "Sachsen-Anhalt",
+    "16": "Thüringen",
+}
+
+BUNDESLAENDER_LIST = sorted(AGS_TO_BUNDESLAND.values())
+
+EUROPEAN_COUNTRIES = {
+    "Albanien": "AL",
+    "Andorra": "AD",
+    "Belgien": "BE",
+    "Bosnien und Herzegowina": "BA",
+    "Bulgarien": "BG",
+    "Dänemark": "DK",
+    "Deutschland": "DE",
+    "Estland": "EE",
+    "Finnland": "FI",
+    "Frankreich": "FR",
+    "Griechenland": "GR",
+    "Irland": "IE",
+    "Island": "IS",
+    "Italien": "IT",
+    "Kosovo": "XK",
+    "Kroatien": "HR",
+    "Lettland": "LV",
+    "Liechtenstein": "LI",
+    "Litauen": "LT",
+    "Luxemburg": "LU",
+    "Malta": "MT",
+    "Moldau": "MD",
+    "Monaco": "MC",
+    "Montenegro": "ME",
+    "Niederlande": "NL",
+    "Nordmazedonien": "MK",
+    "Norwegen": "NO",
+    "Österreich": "AT",
+    "Polen": "PL",
+    "Portugal": "PT",
+    "Rumänien": "RO",
+    "San Marino": "SM",
+    "Schweden": "SE",
+    "Schweiz": "CH",
+    "Serbien": "RS",
+    "Slowakei": "SK",
+    "Slowenien": "SI",
+    "Spanien": "ES",
+    "Tschechien": "CZ",
+    "Türkei": "TR",
+    "Ukraine": "UA",
+    "Ungarn": "HU",
+    "Vereinigtes Königreich": "GB",
+    "Weißrussland": "BY",
+    "Zypern": "CY",
+}
+
+BKG_FILES = {
+    "gemeinden": "VG250_GEM.shp",
+    "kreise": "VG250_KRS.shp",
+    "bundeslaender": "VG250_LAN.shp",
+}
+
+NE_FILES = {
+    "countries": "ne_10m_admin_0_countries.shp",
+    "admin1": "ne_10m_admin_1_states_provinces.shp",
+}
+
+MAP_CENTER = {
+    "gemeinden": (51.2, 10.4),
+    "kreise": (51.2, 10.4),
+    "bundeslaender": (51.2, 10.4),
+    "admin1": (20.0, 0.0),
+    "countries": (20.0, 0.0),
+}
+
+MAP_ZOOM = {
+    "gemeinden": 6,
+    "kreise": 6,
+    "bundeslaender": 6,
+    "admin1": 2,
+    "countries": 2,
+}
+
+GBIF_PAGE_SIZE = 300
+GBIF_MAX_OFFSET = 99_700