Deploy Teich Space (rooted from froschgruppe/latest_froschgruppe)

.gitignore

@@ -0,0 +1,7 @@
+.env
+__pycache__/
+.DS_Store
+artifacts/
+data/
+.gradio/
+report.md

README.md

@@ -0,0 +1,11 @@
+---
+title: Teich
+emoji: 🐸
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: "4.44.1"
+app_file: app.py
+pinned: false
+---
+

app.py

@@ -0,0 +1,290 @@
+import os, sys, json
+from datetime import datetime, date
+from pathlib import Path
+
+import gradio as gr
+
+# Make src importable
+sys.path.append("src")
+
+from src.latest_froschgruppe.tools.organizer_tool import OrganizerTool
+from src.latest_froschgruppe.tools.payroll_tool import PayrollTool
+from src.latest_froschgruppe.tools.roadkill_gbif_tool import RoadkillGBIFTool
+from src.latest_froschgruppe.tools.calendar_tool import CalendarTool  # ICS generator
+from src.latest_froschgruppe.tools.gbif_occurrence_tool import GBIFOccurrenceTool
+
+
+# Optional: if you have folium map tool
+# from latest_froschgruppe.tools.map_tool import build_map
+
+DATA_DIR = Path(os.getenv("DATA_DIR", "data"))
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+EVENTS_FILE = DATA_DIR / "events.json"
+
+organizer = OrganizerTool()
+payroll = PayrollTool()
+gbif = GBIFOccurrenceTool()
+roadkill = RoadkillGBIFTool()
+cal = CalendarTool()
+
+
+def _load_events():
+    if not EVENTS_FILE.exists():
+        return []
+    return json.loads(EVENTS_FILE.read_text(encoding="utf-8"))
+
+
+def _save_events(events):
+    EVENTS_FILE.write_text(json.dumps(events, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def add_event(title: str, start_date: str, start_time: str, end_time: str, location: str):
+    events = _load_events()
+    # store ISO-ish strings
+    start = f"{start_date}T{start_time}"
+    end = f"{start_date}T{end_time}"
+    ev = {
+        "id": f"E{len(events)+1:04d}",
+        "title": title.strip(),
+        "start": start,
+        "end": end,
+        "location": location.strip(),
+        "created_at": datetime.utcnow().isoformat() + "Z",
+    }
+    events.append(ev)
+    _save_events(events)
+    return list_events()
+
+
+def delete_event(event_id: str):
+    events = _load_events()
+    events = [e for e in events if e["id"] != event_id.strip()]
+    _save_events(events)
+    return list_events()
+
+
+def list_events():
+    events = _load_events()
+    events_sorted = sorted(events, key=lambda e: e.get("start", ""))
+    # dataframe-like list
+    rows = []
+    for e in events_sorted[:200]:
+        rows.append([e["id"], e["start"], e.get("end",""), e["title"], e.get("location","")])
+    return rows
+
+
+def dashboard_snapshot():
+    # Todos
+    todos_md = organizer._run("list_todos", "{}")
+    vols_md = organizer._run("list_volunteers", "{}")
+
+    # Payroll report
+    payroll_md = payroll._run("report", "{}")
+
+    # Events
+    events_rows = list_events()
+    events_md = "## Nächste Events\n"
+    if not events_rows:
+        events_md += "Keine Events gespeichert."
+    else:
+        # show only next 10
+        events_md += "\n".join([f"- {r[1]} | {r[3]} @ {r[4]} (ID {r[0]})" for r in events_rows[:10]])
+
+    # Next migration window (simple heuristic)
+    today = date.today()
+    year = today.year
+    # Typical window for DE: Feb 15 – Apr 30 (configurable)
+    # If already past, show next year.
+    window_start = date(year, 2, 15)
+    window_end = date(year, 4, 30)
+    if today > window_end:
+        window_start = date(year + 1, 2, 15)
+        window_end = date(year + 1, 4, 30)
+    mig_md = (
+        "## Nächste Wanderphase (operatives Fenster)\n"
+        f"- Fenster: **{window_start.isoformat()} bis {window_end.isoformat()}**\n"
+        "- Trigger (praktisch): milde, feuchte Abende/Nächte + Regen → Einsatzwahrscheinlichkeit hoch.\n"
+        "- Tipp: täglich 17:00 Wettercheck + bei Trigger Nachtteam aktivieren."
+    )
+
+    return mig_md, events_md, todos_md, vols_md, payroll_md
+
+
+def add_todo(title: str, priority: str):
+    payload = json.dumps({"title": title, "priority": priority}, ensure_ascii=False)
+    msg = organizer._run("add_todo", payload)
+    return msg, organizer._run("list_todos", "{}")
+
+
+def add_volunteer(name: str, phone: str, availability: str):
+    payload = json.dumps({"name": name, "phone": phone, "availability": availability}, ensure_ascii=False)
+    msg = organizer._run("add_volunteer", payload)
+    return msg, organizer._run("list_volunteers", "{}")
+
+
+def payroll_plan(hourly_rate: float, monthly_cap: float):
+    payload = json.dumps({"hourly_rate": hourly_rate, "monthly_cap": monthly_cap}, ensure_ascii=False)
+    return payroll._run("plan", payload)
+
+
+def payroll_add_worker(name: str, hourly_rate: float, monthly_cap: float):
+    payload = json.dumps({"name": name, "hourly_rate": hourly_rate, "monthly_cap": monthly_cap}, ensure_ascii=False)
+    msg = payroll._run("add_worker", payload)
+    rep = payroll._run("report", "{}")
+    return msg, rep
+
+
+def payroll_log_hours(name: str, date_str: str, hours: float, note: str):
+    payload = json.dumps({"name": name, "date": date_str, "hours": hours, "note": note}, ensure_ascii=False)
+    msg = payroll._run("log_hours", payload)
+    rep = payroll._run("report", "{}")
+    return msg, rep
+
+
+def fetch_hotspots(species: str, country: str, year_from: int, year_to: int):
+    # Tools return markdown tables + google maps links
+    gbif_md = gbif._run(scientific_name=species, country=country, year_from=year_from, year_to=year_to, limit=300)
+    road_md = roadkill._run(country=country, scientific_name=species, year_from=year_from, year_to=year_to, limit=300)
+    return gbif_md, road_md
+
+
+def generate_migration_ics(region: str, year: int, start_month: int, start_day: int, end_month: int, end_day: int):
+    # CalendarTool returns a path in text; we want a file output
+    txt = cal._run(region=region, year=year, start_month=start_month, start_day=start_day, end_month=end_month, end_day=end_day)
+    # Extract file path from tool output
+    # expected: "✅ ICS erstellt: <path>"
+    path = None
+    for token in txt.split():
+        if token.endswith(".ics"):
+            path = token
+            break
+    return txt, path
+
+
+with gr.Blocks(title="Teich – Management Partner (Froschrettung)") as demo:
+    gr.Markdown("# 🐸 Teich – Management Partner (Froschrettung)\n**Dashboard • Kalender • Einsätze • Daten • Team • Budget**")
+
+    with gr.Tab("Dashboard"):
+        btn_refresh = gr.Button("🔄 Dashboard aktualisieren")
+
+        mig_md = gr.Markdown()
+        events_md = gr.Markdown()
+        todos_md = gr.Markdown()
+        vols_md = gr.Markdown()
+        payroll_md = gr.Markdown()
+
+        btn_refresh.click(fn=dashboard_snapshot, inputs=[], outputs=[mig_md, events_md, todos_md, vols_md, payroll_md])
+        demo.load(fn=dashboard_snapshot, inputs=[], outputs=[mig_md, events_md, todos_md, vols_md, payroll_md])
+
+    with gr.Tab("Kalender & Schichten"):
+        gr.Markdown("## Events\nEvents werden lokal in `data/events.json` gespeichert.")
+        events_table = gr.Dataframe(headers=["ID", "Start", "Ende", "Titel", "Ort"], interactive=False)
+
+        with gr.Row():
+            ev_title = gr.Textbox(label="Titel", placeholder="z.B. Zaunkontrolle / Nachtpatrouille")
+            ev_location = gr.Textbox(label="Ort", placeholder="z.B. Straße X / Teich Y")
+        with gr.Row():
+            ev_date = gr.Textbox(label="Datum (YYYY-MM-DD)", value=str(date.today()))
+            ev_start = gr.Textbox(label="Start (HH:MM)", value="20:00")
+            ev_end = gr.Textbox(label="Ende (HH:MM)", value="23:00")
+        with gr.Row():
+            btn_add_ev = gr.Button("➕ Event anlegen")
+            del_id = gr.Textbox(label="Event ID löschen", placeholder="E0001")
+            btn_del_ev = gr.Button("🗑️ Löschen")
+            btn_reload_ev = gr.Button("📋 Events neu laden")
+
+        btn_reload_ev.click(fn=list_events, inputs=[], outputs=[events_table])
+        demo.load(fn=list_events, inputs=[], outputs=[events_table])
+        btn_add_ev.click(fn=add_event, inputs=[ev_title, ev_date, ev_start, ev_end, ev_location], outputs=[events_table])
+        btn_del_ev.click(fn=delete_event, inputs=[del_id], outputs=[events_table])
+
+        gr.Markdown("## Wanderfenster (ICS)\nErzeugt einen Standard-ICS (Wettercheck, Zaunkontrolle, Patrouillenblock).")
+        with gr.Row():
+            region = gr.Textbox(label="Region", value="Deutschland")
+            year = gr.Number(label="Jahr", value=date.today().year, precision=0)
+        with gr.Row():
+            sm = gr.Number(label="Start Monat", value=2, precision=0)
+            sd = gr.Number(label="Start Tag", value=15, precision=0)
+            em = gr.Number(label="Ende Monat", value=4, precision=0)
+            ed = gr.Number(label="Ende Tag", value=30, precision=0)
+
+        btn_ics = gr.Button("📅 ICS generieren")
+        ics_status = gr.Markdown()
+        ics_file = gr.File(label="ICS Download")
+
+        btn_ics.click(fn=generate_migration_ics, inputs=[region, year, sm, sd, em, ed], outputs=[ics_status, ics_file])
+
+    with gr.Tab("Einsatz planen"):
+        gr.Markdown("## Einsatzplanung\nHier kannst du wie bisher einen Einsatz planen (später: Crew-Kickoff anbinden).")
+        user_prompt = gr.Textbox(label="Auftrag / Situation", lines=5, placeholder="z.B. Plane nächste Woche Froschrettung in Region X ...")
+        country = gr.Textbox(label="Land (GBIF Country Code)", value="DE")
+        region2 = gr.Textbox(label="Region (Freitext)", value="Deutschland")
+        species = gr.Dropdown(["Rana temporaria", "Bufo bufo", "Lissotriton vulgaris", "Triturus cristatus"], value="Rana temporaria", label="Zielart")
+        year_from = gr.Number(label="Jahr von", value=2020, precision=0)
+        year_to = gr.Number(label="Jahr bis", value=date.today().year, precision=0)
+
+        # Optional: Hier später Crew kickoff (run_manager) wieder einhängen.
+        gr.Markdown("➡️ (Nächster Schritt) Crew-Kickoff als Button: erzeugt Plan + Tasks + Kalender + Budget automatisch.")
+
+    with gr.Tab("Daten & Hotspots (GBIF/Roadkill)"):
+        gr.Markdown("## Amphibien-Sichtungen & Roadkill-Hotspots\nTop-Cluster inkl. Google-Maps Links.")
+        with gr.Row():
+            d_species = gr.Dropdown(["Rana temporaria", "Bufo bufo", "Lissotriton vulgaris", "Triturus cristatus"], value="Rana temporaria", label="Art")
+            d_country = gr.Textbox(label="Land", value="DE")
+            d_y1 = gr.Number(label="Jahr von", value=2020, precision=0)
+            d_y2 = gr.Number(label="Jahr bis", value=date.today().year, precision=0)
+        btn_data = gr.Button("📡 Daten laden (Hotspots)")
+        out_gbif = gr.Markdown()
+        out_road = gr.Markdown()
+        btn_data.click(fn=fetch_hotspots, inputs=[d_species, d_country, d_y1, d_y2], outputs=[out_gbif, out_road])
+
+    with gr.Tab("Team & Budget (450€)"):
+        gr.Markdown("## To-Dos / Volunteers / Payroll\nAlles wird lokal gespeichert (DATA_DIR).")
+
+        with gr.Accordion("To-Dos", open=True):
+            todo_title = gr.Textbox(label="Neue Aufgabe", placeholder="z.B. Materialliste erstellen")
+            todo_prio = gr.Dropdown(["L", "M", "H"], value="M", label="Priorität")
+            btn_todo = gr.Button("➕ To-Do anlegen")
+            todo_msg = gr.Markdown()
+            todo_list = gr.Markdown()
+            btn_todo.click(fn=add_todo, inputs=[todo_title, todo_prio], outputs=[todo_msg, todo_list])
+            demo.load(fn=lambda: organizer._run("list_todos", "{}"), inputs=[], outputs=[todo_list])
+
+        with gr.Accordion("Volunteers", open=False):
+            v_name = gr.Textbox(label="Name")
+            v_phone = gr.Textbox(label="Telefon")
+            v_avail = gr.Textbox(label="Verfügbarkeit", placeholder="z.B. Mo/Di ab 18 Uhr")
+            btn_vol = gr.Button("➕ Volunteer hinzufügen")
+            vol_msg = gr.Markdown()
+            vol_list = gr.Markdown()
+            btn_vol.click(fn=add_volunteer, inputs=[v_name, v_phone, v_avail], outputs=[vol_msg, vol_list])
+            demo.load(fn=lambda: organizer._run("list_volunteers", "{}"), inputs=[], outputs=[vol_list])
+
+        with gr.Accordion("450€ Plan & Payroll", open=True):
+            p_rate = gr.Number(label="Stundenlohn €", value=12.0, precision=2)
+            p_cap = gr.Number(label="Monatscap €", value=450.0, precision=2)
+            btn_plan = gr.Button("🧮 450€ Plan berechnen")
+            plan_md = gr.Markdown()
+            btn_plan.click(fn=payroll_plan, inputs=[p_rate, p_cap], outputs=[plan_md])
+
+            gr.Markdown("### Worker anlegen")
+            w_name = gr.Textbox(label="Name")
+            btn_add_w = gr.Button("➕ Worker hinzufügen")
+            w_msg = gr.Markdown()
+            rep_md = gr.Markdown()
+            btn_add_w.click(fn=payroll_add_worker, inputs=[w_name, p_rate, p_cap], outputs=[w_msg, rep_md])
+            demo.load(fn=lambda: payroll._run("report", "{}"), inputs=[], outputs=[rep_md])
+
+            gr.Markdown("### Stunden loggen")
+            l_name = gr.Textbox(label="Name (wie Worker)")
+            l_date = gr.Textbox(label="Datum", value=str(date.today()))
+            l_hours = gr.Number(label="Stunden", value=3.0, precision=2)
+            l_note = gr.Textbox(label="Notiz", placeholder="z.B. Nachtpatrouille")
+            btn_log = gr.Button("⏱️ log_hours")
+            log_msg = gr.Markdown()
+            btn_log.click(fn=payroll_log_hours, inputs=[l_name, l_date, l_hours, l_note], outputs=[log_msg, rep_md])
+
+    gr.Markdown("---\n**Hinweis:** In Hugging Face empfehle ich Persistent Storage aktivieren und `DATA_DIR=/data` setzen, dann bleiben Tasks/Events auch nach Restart erhalten.")
+
+demo.queue()
+demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))

knowledge/user_preference.txt

@@ -0,0 +1,4 @@
+User name is John Doe.
+User is an AI Engineer.
+User is interested in AI Agents.
+User is based in San Francisco, California.

pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "latest_froschgruppe"
+version = "0.1.0"
+description = "latest-froschgruppe using crewAI"
+authors = [{ name = "Your Name", email = "you@example.com" }]
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "crewai[tools]==1.8.0"
+]
+
+[project.scripts]
+latest_froschgruppe = "latest_froschgruppe.main:run"
+run_crew = "latest_froschgruppe.main:run"
+train = "latest_froschgruppe.main:train"
+replay = "latest_froschgruppe.main:replay"
+test = "latest_froschgruppe.main:test"
+run_with_trigger = "latest_froschgruppe.main:run_with_trigger"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.crewai]
+type = "crew"

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+crewai==1.8.0
+openai==1.83.0
+python-dotenv
+requests
+folium
+pandas

src/latest_froschgruppe/config/agents.yaml

@@ -0,0 +1,34 @@
+aktivismus_team_organisation:
+  role: "Aktivismus- & Team-Organisation"
+  goal: "Koordiniert Einsätze, plant Schichten, hält To-Dos & Kalender aktuell und liefert eine tägliche operative Lageübersicht."
+  backstory: "Erfahren in Logistik, Teamführung und Einsatzplanung. Denkt in Checklisten, Prioritäten, Risiken und Ressourcen."
+  allow_delegation: true
+  verbose: true
+
+marketing_oeffentlichkeit_medien:
+  role: "Marketing, Öffentlichkeitsarbeit & Medienproduktion"
+  goal: "Erstellt klare, mobilisierende Kommunikation für Volunteers, Sponsoren und Öffentlichkeit – inkl. Storytelling und Content-Plan."
+  backstory: "Sehr gut in Storytelling, Social Media, Pressearbeit. Übersetzt Wissenschaft in verständliche Botschaften."
+  allow_delegation: true
+  verbose: true
+
+wissenschaft_umwelt_tiere:
+  role: "Wissenschaft (Umwelt & Tiere)"
+  goal: "Liefert belastbare Fakten, nutzt Datenquellen (GBIF/Roadkill), findet Hotspots und erzeugt evidenzbasierte Empfehlungen."
+  backstory: "Biologie/Ökologie-Hintergrund. Analysiert Daten, erkennt Muster, dokumentiert Unsicherheiten."
+  allow_delegation: true
+  verbose: true
+
+finanzen_partnerschaften:
+  role: "Finanzen & Partnerschaften"
+  goal: "Plant Budget, Minijobs (450€ Annahme), Fundraising-Pitches und Sponsoring-Pakete. Hält Kosten & Auszahlungen nachvollziehbar."
+  backstory: "NGO-Finanzierung, Fundraising, Budgetplanung. Denkt in Szenarien und Compliance."
+  allow_delegation: true
+  verbose: true
+
+recht_und_politik:
+  role: "Recht und Politik"
+  goal: "Checkt Risiken (Genehmigungen, Haftung, Datenschutz, Straßenaktionen) und formuliert sichere Alternativen."
+  backstory: "Kennt Verwaltungslogik, Stakeholder, Policies. Setzt auf sichere, rechtlich robuste Vorgehensweisen."
+  allow_delegation: true
+  verbose: true

src/latest_froschgruppe/config/tasks.yaml

@@ -0,0 +1,65 @@
+intake_brief:
+  description: >
+    Erstelle aus dem Input {{user_prompt}} ein kurzes Einsatz-Briefing für eine Umweltschutzorganisation (Froschrettung).
+    Enthält: Ziel, Ort/Region, Zeitraum, Stakeholder, Constraints, Erfolgskriterien.
+    Lege 5-10 To-Dos an (Priorität H/M/L) über OrganizerTool.
+  expected_output: >
+    Markdown-Briefing + To-Do-Liste (IDs, Priorität).
+  agent: aktivismus_team_organisation
+
+data_hotspots:
+  description: >
+    Nutze GBIFOccurrenceTool für {{species}} in {{country}} (optional Zeitraum {{year_from}}–{{year_to}}).
+    Erzeuge Hotspots (Top 10) und leite daraus 3-5 konkrete Fokusgebiete ab.
+    Nutze RoadkillGBIFTool ebenfalls (country={{country}}, optional scientific_name={{species}}) und vergleiche Hotspots.
+  expected_output: >
+    1) Tabelle GBIF-Hotspots
+    2) Tabelle Roadkill-Hotspots
+    3) Empfehlung: welche 3-5 Hotspots operativ priorisieren (mit Begründung).
+  agent: wissenschaft_umwelt_tiere
+
+migration_calendar:
+  description: >
+    Leite eine operative Kalenderstrategie ab (Wetter-Trigger, täglicher Ablauf, Patrouillenfenster).
+    Erzeuge eine ICS-Datei über CalendarTool für Region {{region}} im Jahr {{year}}.
+  expected_output: >
+    ICS-Pfad + kurzer Leitfaden "Wie wir aktivieren" (Triggerlogik, Rollen, Sicherheit).
+  agent: aktivismus_team_organisation
+
+team_and_shift_plan:
+  description: >
+    Erstelle einen Schichtplan (Rollen: Fahrer, Sammler, Datenlogger, Teamlead).
+    Nutze OrganizerTool: füge To-Dos für "Team rekrutieren", "Briefing", "Materialliste", "Sicherheitscheck" hinzu.
+    Plane idealerweise 2-3 Personen pro Nacht-Schicht.
+  expected_output: >
+    Schichtplan-Template + konkrete nächste Schritte (To-Dos) für die kommende Woche.
+  agent: aktivismus_team_organisation
+
+payroll_and_budget:
+  description: >
+    Nutze PayrollTool (450€-Annahme): plane max. Stunden pro Person basierend auf {{hourly_rate}} €/h und cap {{monthly_cap}} €.
+    Schlage ein faires Modell vor (Wer übernimmt welche Schichten?).
+  expected_output: >
+    Budget-Plan (Stunden/Person/Monat) + Empfehlung zur Aufgabenverteilung.
+  agent: finanzen_partnerschaften
+
+legal_risk_check:
+  description: >
+    Prüfe rechtliche/politische Risiken: Aktionen an Straßen, Datenerhebung, Fotos/PR, Haftung.
+    Gib eine Go/No-Go Checkliste und sichere Alternativen.
+  expected_output: >
+    Risk Checklist + Go/No-Go pro Maßnahme.
+  agent: recht_und_politik
+
+final_management_brief:
+  description: >
+    Erstelle ein kompaktes "Daily Management Brief":
+    - Was ist diese Woche wichtig (Top 5)
+    - Operative Hotspots
+    - Kalender/Schichten
+    - Budget/450€-Plan
+    - Risiken + Mitigation
+    Output soll sofort nutzbar sein.
+  expected_output: >
+    Ein Management-Brief in Markdown (max 1-2 Seiten) + klare Next Actions.
+  agent: aktivismus_team_organisation

src/latest_froschgruppe/crew.py

@@ -0,0 +1,59 @@
+from crewai import Agent, Crew, Process
+from crewai.project import CrewBase, agent, crew
+
+from .tools import (
+    GBIFOccurrenceTool,
+    RoadkillGBIFTool,
+    OrganizerTool,
+    PayrollTool,
+    CalendarTool,
+)
+
+@CrewBase
+class LatestFroschgruppe():
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    @agent
+    def wissenschaft_umwelt_tiere(self) -> Agent:
+        return Agent(
+            config=self.agents_config["wissenschaft_umwelt_tiere"],
+            tools=[GBIFOccurrenceTool(), RoadkillGBIFTool()],
+        )
+
+    @agent
+    def recht_und_politik(self) -> Agent:
+        return Agent(
+            config=self.agents_config["recht_und_politik"],
+            tools=[],
+        )
+
+    @agent
+    def finanzen_partnerschaften(self) -> Agent:
+        return Agent(
+            config=self.agents_config["finanzen_partnerschaften"],
+            tools=[PayrollTool()],
+        )
+
+    @agent
+    def marketing_oeffentlichkeit_medien(self) -> Agent:
+        return Agent(
+            config=self.agents_config["marketing_oeffentlichkeit_medien"],
+            tools=[],
+        )
+
+    @agent
+    def aktivismus_team_organisation(self) -> Agent:
+        return Agent(
+            config=self.agents_config["aktivismus_team_organisation"],
+            tools=[OrganizerTool(), CalendarTool()],
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )

src/latest_froschgruppe/main.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+import sys
+import warnings
+from datetime import datetime
+
+from latest_froschgruppe.crew import LatestFroschgruppe
+
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
+
+
+def run_manager(
+    user_prompt: str,
+    country: str = "DE",
+    region: str = "Deutschland",
+    species: str = "Rana temporaria",
+    year: int | None = None,
+    year_from: int | None = None,
+    year_to: int | None = None,
+    hourly_rate: float = 12.0,
+    monthly_cap: float = 450.0,
+):
+    """
+    Main entrypoint für Gradio / Hugging Face.
+    Diese Inputs matchen deine tasks.yaml Platzhalter.
+    """
+    y = year or datetime.now().year
+    inputs = {
+        "user_prompt": user_prompt,
+        "country": country,
+        "region": region,
+        "species": species,
+        "year": str(y),
+        "year_from": str(year_from or y),
+        "year_to": str(year_to or y),
+        "hourly_rate": str(hourly_rate),
+        "monthly_cap": str(monthly_cap),
+    }
+    return LatestFroschgruppe().crew().kickoff(inputs=inputs)
+
+
+def run():
+    """
+    Run the crew locally (quick test).
+    """
+    # Default-Test: Froschrettung statt "AI LLMs"
+    inputs = {
+        "user_prompt": "Plane eine Woche Froschrettung inklusive Hotspots, Kalender und Minijob-Budget.",
+        "country": "DE",
+        "region": "Deutschland",
+        "species": "Rana temporaria",
+        "year": str(datetime.now().year),
+        "year_from": "2020",
+        "year_to": str(datetime.now().year),
+        "hourly_rate": "12",
+        "monthly_cap": "450",
+    }
+
+    try:
+        return LatestFroschgruppe().crew().kickoff(inputs=inputs)
+    except Exception as e:
+        raise Exception(f"An error occurred while running the crew: {e}")
+
+
+def train():
+    """
+    Train the crew for a given number of iterations.
+    """
+    inputs = {
+        "user_prompt": "Training run",
+        "country": "DE",
+        "region": "Deutschland",
+        "species": "Rana temporaria",
+        "year": str(datetime.now().year),
+        "year_from": "2020",
+        "year_to": str(datetime.now().year),
+        "hourly_rate": "12",
+        "monthly_cap": "450",
+    }
+    try:
+        LatestFroschgruppe().crew().train(
+            n_iterations=int(sys.argv[1]),
+            filename=sys.argv[2],
+            inputs=inputs
+        )
+    except Exception as e:
+        raise Exception(f"An error occurred while training the crew: {e}")
+
+
+def replay():
+    """
+    Replay the crew execution from a specific task.
+    """
+    try:
+        LatestFroschgruppe().crew().replay(task_id=sys.argv[1])
+    except Exception as e:
+        raise Exception(f"An error occurred while replaying the crew: {e}")
+
+
+def test():
+    """
+    Test the crew execution and returns the results.
+    """
+    inputs = {
+        "user_prompt": "Test run",
+        "country": "DE",
+        "region": "Deutschland",
+        "species": "Rana temporaria",
+        "year": str(datetime.now().year),
+        "year_from": "2020",
+        "year_to": str(datetime.now().year),
+        "hourly_rate": "12",
+        "monthly_cap": "450",
+    }
+
+    try:
+        LatestFroschgruppe().crew().test(
+            n_iterations=int(sys.argv[1]),
+            eval_llm=sys.argv[2],
+            inputs=inputs
+        )
+    except Exception as e:
+        raise Exception(f"An error occurred while testing the crew: {e}")
+
+
+def run_with_trigger():
+    """
+    Run the crew with trigger payload.
+    """
+    import json
+
+    if len(sys.argv) < 2:
+        raise Exception("No trigger payload provided. Please provide JSON payload as argument.")
+
+    try:
+        trigger_payload = json.loads(sys.argv[1])
+    except json.JSONDecodeError:
+        raise Exception("Invalid JSON payload provided as argument")
+
+    inputs = {
+        "crewai_trigger_payload": trigger_payload,
+        # sichere Defaults, falls Trigger nichts liefert:
+        "user_prompt": trigger_payload.get("user_prompt", ""),
+        "country": trigger_payload.get("country", "DE"),
+        "region": trigger_payload.get("region", "Deutschland"),
+        "species": trigger_payload.get("species", "Rana temporaria"),
+        "year": str(trigger_payload.get("year", datetime.now().year)),
+        "year_from": str(trigger_payload.get("year_from", 2020)),
+        "year_to": str(trigger_payload.get("year_to", datetime.now().year)),
+        "hourly_rate": str(trigger_payload.get("hourly_rate", 12)),
+        "monthly_cap": str(trigger_payload.get("monthly_cap", 450)),
+    }
+
+    try:
+        return LatestFroschgruppe().crew().kickoff(inputs=inputs)
+    except Exception as e:
+        raise Exception(f"An error occurred while running the crew with trigger: {e}")

src/latest_froschgruppe/tools/__init__.py

@@ -0,0 +1,13 @@
+from .gbif_occurrence_tool import GBIFOccurrenceTool
+from .roadkill_tool import RoadkillGBIFTool
+from .organizer_tool import OrganizerTool
+from .payroll_tool import PayrollTool
+from .calendar_tool import CalendarTool
+
+__all__ = [
+    "GBIFOccurrenceTool",
+    "RoadkillGBIFTool",
+    "OrganizerTool",
+    "PayrollTool",
+    "CalendarTool",
+]

src/latest_froschgruppe/tools/calendar_tool.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from datetime import datetime, date, time, timedelta
+import os
+
+from crewai.tools import BaseTool
+
+ARTIFACT_DIR = os.getenv("ARTIFACT_DIR", "artifacts")
+os.makedirs(ARTIFACT_DIR, exist_ok=True)
+
+
+def _ics_escape(s: str) -> str:
+    return s.replace("\\", "\\\\").replace(";", "\\;").replace(",", "\\,").replace("\n", "\\n")
+
+
+def _event(uid: str, dtstart: datetime, dtend: datetime, summary: str, description: str = "") -> str:
+    return "\n".join(
+        [
+            "BEGIN:VEVENT",
+            f"UID:{uid}",
+            f"DTSTAMP:{datetime.utcnow().strftime('%Y%m%dT%H%M%SZ')}",
+            f"DTSTART:{dtstart.strftime('%Y%m%dT%H%M%S')}",
+            f"DTEND:{dtend.strftime('%Y%m%dT%H%M%S')}",
+            f"SUMMARY:{_ics_escape(summary)}",
+            f"DESCRIPTION:{_ics_escape(description)}",
+            "END:VEVENT",
+        ]
+    )
+
+
+class CalendarTool(BaseTool):
+    name: str = "Calendar (ICS) – Migration & Schichten"
+    description: str = (
+        "Erstellt einen Basis-Kalender (ICS) für Froschwanderung: "
+        "Wettercheck, Zaunkontrolle, Nachtpatrouille. Gibt Pfad zur ICS zurück."
+    )
+
+    def _run(
+        self,
+        region: str = "Deutschland",
+        year: int = datetime.now().year,
+        start_month: int = 2,
+        start_day: int = 15,
+        end_month: int = 4,
+        end_day: int = 30,
+    ) -> str:
+        start = date(int(year), int(start_month), int(start_day))
+        end = date(int(year), int(end_month), int(end_day))
+
+        events = []
+        cur = start
+        idx = 0
+
+        while cur <= end:
+            idx += 1
+
+            # Wettercheck täglich 17:00–17:10
+            dt1 = datetime.combine(cur, time(17, 0))
+            dt2 = datetime.combine(cur, time(17, 10))
+            events.append(
+                _event(
+                    uid=f"weathercheck-{year}-{idx}@teich",
+                    dtstart=dt1,
+                    dtend=dt2,
+                    summary="Frosch-Wettercheck (Trigger: milde Nacht + Regen)",
+                    description=f"Region: {region}. Prüfe Abendtemp/Feuchte/Regen. Bei Aktivität: Nachtteam alarmieren.",
+                )
+            )
+
+            # Zaunkontrolle morgens 06:30–07:00
+            dt3 = datetime.combine(cur, time(6, 30))
+            dt4 = datetime.combine(cur, time(7, 0))
+            events.append(
+                _event(
+                    uid=f"fence-{year}-{idx}@teich",
+                    dtstart=dt3,
+                    dtend=dt4,
+                    summary="Zaunkontrolle & Eimercheck",
+                    description="Eimer leeren, Tiere sicher umsetzen, Daten notieren.",
+                )
+            )
+
+            # Patrouille-Window 20:00–23:00 (nur bei Aktivität)
+            dt5 = datetime.combine(cur, time(20, 0))
+            dt6 = datetime.combine(cur, time(23, 0))
+            events.append(
+                _event(
+                    uid=f"patrol-{year}-{idx}@teich",
+                    dtstart=dt5,
+                    dtend=dt6,
+                    summary="Nacht-Patrouille (nur bei Aktivität)",
+                    description="Nur aktiv, wenn Wettercheck -> Zugwahrscheinlichkeit hoch.",
+                )
+            )
+
+            cur += timedelta(days=1)
+
+        ics = "\n".join(
+            [
+                "BEGIN:VCALENDAR",
+                "VERSION:2.0",
+                "PRODID:-//Teich//Froschgruppe//DE",
+                *events,
+                "END:VCALENDAR",
+                "",
+            ]
+        )
+
+        out_path = os.path.join(ARTIFACT_DIR, f"migration_{region}_{year}.ics".replace(" ", "_"))
+        with open(out_path, "w", encoding="utf-8") as f:
+            f.write(ics)
+
+        return f"✅ ICS erstellt: {out_path}\n\nHinweis: Die Aktivierung 'Patrouille' erfolgt operativ nach Wettercheck."

src/latest_froschgruppe/tools/custom_tool.py

@@ -0,0 +1,19 @@
+from crewai.tools import BaseTool
+from typing import Type
+from pydantic import BaseModel, Field
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = (
+        "Clear description for what this tool is useful for, your agent will need this information to use it."
+    )
+    args_schema: Type[BaseModel] = MyCustomToolInput
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."

src/latest_froschgruppe/tools/gbif_occurrence_tool.py

@@ -0,0 +1,90 @@
+import requests
+from typing import Dict, Any, List, Tuple
+
+from crewai.tools import BaseTool
+
+GBIF_OCCURRENCE_SEARCH = "https://api.gbif.org/v1/occurrence/search"
+
+
+def _cluster_key(lat: float, lon: float, precision: float = 0.05) -> Tuple[float, float]:
+    # ~0.05° ~ wenige km (je nach Breite) – gut als “Hotspot-Kachel”
+    return (round(lat / precision) * precision, round(lon / precision) * precision)
+
+
+class GBIFOccurrenceTool(BaseTool):
+    name: str = "GBIF Occurrence Explorer"
+    description: str = (
+        "Sucht GBIF-Beobachtungsdaten (Occurrences) für eine Art (scientificName), "
+        "optional nach Land und Zeitraum. Gibt Hotspot-Cluster (Lat/Lon) zurück."
+    )
+
+    def _run(
+        self,
+        scientific_name: str,
+        country: str = "DE",
+        year_from: int | None = None,
+        year_to: int | None = None,
+        limit: int = 300,
+    ) -> str:
+        params: Dict[str, Any] = {
+            "scientificName": scientific_name,
+            "country": country,
+            "hasCoordinate": "true",
+            "limit": min(int(limit), 300),
+            "offset": 0,
+        }
+
+        if year_from is not None:
+            yf = int(year_from)
+            yt = int(year_to if year_to is not None else year_from)
+            params["year"] = f"{yf},{yt}"
+
+        results: List[Dict[str, Any]] = []
+        fetched = 0
+        limit = int(limit)
+
+        while fetched < limit:
+            params["offset"] = fetched
+            r = requests.get(GBIF_OCCURRENCE_SEARCH, params=params, timeout=30)
+            r.raise_for_status()
+            data = r.json()
+
+            batch = data.get("results", [])
+            if not batch:
+                break
+
+            results.extend(batch)
+            fetched += len(batch)
+
+            if fetched >= int(data.get("count", 0) or 0):
+                break
+
+        # cluster
+        cluster: Dict[Tuple[float, float], int] = {}
+        for row in results:
+            lat = row.get("decimalLatitude")
+            lon = row.get("decimalLongitude")
+            if lat is None or lon is None:
+                continue
+            key = _cluster_key(float(lat), float(lon))
+            cluster[key] = cluster.get(key, 0) + 1
+
+        top = sorted(cluster.items(), key=lambda x: x[1], reverse=True)[:10]
+
+        lines: List[str] = []
+        lines.append(f"## GBIF Hotspots – {scientific_name} ({country})")
+        lines.append(f"- Treffer geladen: **{len(results)}** (max requested: {limit})")
+        if year_from is not None:
+            lines.append(f"- Zeitraum: **{year_from}–{year_to if year_to is not None else year_from}**")
+        lines.append("")
+        lines.append("| Rang | Lat | Lon | Beobachtungen | Google Maps |")
+        lines.append("|---:|---:|---:|---:|---|")
+
+        for i, ((clat, clon), cnt) in enumerate(top, start=1):
+            gmaps = f"https://www.google.com/maps?q={clat},{clon}"
+            lines.append(f"| {i} | {clat:.4f} | {clon:.4f} | {cnt} | {gmaps} |")
+
+        if not top:
+            lines.append("\nKeine Hotspots gefunden (evtl. Land/Art/Zeitraum anpassen).")
+
+        return "\n".join(lines)

src/latest_froschgruppe/tools/local_docs_tool.py

@@ -0,0 +1,51 @@
+# src/latest_froschgruppe/tools/local_docs_tool.py
+import os
+import re
+from typing import List, Dict, Tuple
+
+import pdfplumber  # add to requirements if not already present
+
+DOCS_DIR = os.getenv("DOCS_DIR", "knowledge/docs")
+
+def _extract_text(pdf_path: str) -> str:
+    texts = []
+    with pdfplumber.open(pdf_path) as pdf:
+        for page in pdf.pages:
+            t = page.extract_text() or ""
+            texts.append(t)
+    return "\n".join(texts)
+
+def search_docs(query: str, top_k: int = 5) -> List[Dict]:
+    """
+    Naive keyword search: returns snippets from PDFs stored in knowledge/docs
+    """
+    q = query.strip()
+    if not q:
+        return []
+    if not os.path.isdir(DOCS_DIR):
+        return [{"error": f"Docs folder not found: {DOCS_DIR}. Lege PDFs dort ab und committe sie."}]
+
+    results: List[Tuple[int, str, str]] = []  # score, file, snippet
+    for fn in os.listdir(DOCS_DIR):
+        if not fn.lower().endswith(".pdf"):
+            continue
+        path = os.path.join(DOCS_DIR, fn)
+        text = _extract_text(path)
+
+        # scoring: count occurrences of query terms
+        terms = [t for t in re.split(r"\s+", q.lower()) if len(t) >= 4]
+        score = sum(text.lower().count(t) for t in terms) if terms else text.lower().count(q.lower())
+
+        if score <= 0:
+            continue
+
+        # snippet: first hit location
+        idx = text.lower().find(terms[0]) if terms else text.lower().find(q.lower())
+        start = max(0, idx - 400)
+        end = min(len(text), idx + 600)
+        snippet = text[start:end].replace("\n", " ").strip()
+
+        results.append((score, fn, snippet))
+
+    results.sort(key=lambda x: x[0], reverse=True)
+    return [{"file": f, "score": s, "snippet": snip} for s, f, snip in results[:top_k]]

src/latest_froschgruppe/tools/map_tool.py

@@ -0,0 +1,31 @@
+# src/latest_froschgruppe/tools/map_tool.py
+import os
+from typing import List, Dict, Optional
+
+import folium
+
+def build_map(points: List[Dict], center_lat: Optional[float]=None, center_lon: Optional[float]=None) -> str:
+    """
+    points: [{"lat":..., "lon":..., "label":...}, ...]
+    Returns path to generated HTML map.
+    """
+    pts = [p for p in points if p.get("lat") and p.get("lon")]
+    if not pts:
+        raise ValueError("Keine Punkte mit lat/lon.")
+
+    if center_lat is None or center_lon is None:
+        center_lat = pts[0]["lat"]
+        center_lon = pts[0]["lon"]
+
+    m = folium.Map(location=[center_lat, center_lon], zoom_start=10)
+    for p in pts[:200]:  # cap
+        folium.Marker([p["lat"], p["lon"]], popup=p.get("label","")).add_to(m)
+
+    out_dir = os.getenv("DATA_DIR", ".data")
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = os.path.join(out_dir, "hotspots_map.html")
+    m.save(out_path)
+    return out_path
+
+def google_maps_link(lat: float, lon: float, zoom: int = 14) -> str:
+    return f"https://www.google.com/maps?q={lat},{lon}&z={zoom}"

src/latest_froschgruppe/tools/organizer_tool.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Dict, Any
+import json
+import os
+
+from crewai.tools import BaseTool
+
+DATA_DIR = os.getenv("DATA_DIR", "data")
+STATE_FILE = os.path.join(DATA_DIR, "organizer.json")
+
+
+def _load() -> Dict[str, Any]:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    if not os.path.exists(STATE_FILE):
+        return {"todos": [], "volunteers": []}
+    with open(STATE_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _save(state: Dict[str, Any]) -> None:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(STATE_FILE, "w", encoding="utf-8") as f:
+        json.dump(state, f, ensure_ascii=False, indent=2)
+
+
+class OrganizerTool(BaseTool):
+    """
+    CrewAI Tool: Local organizer for todos and volunteers (stored as JSON).
+    """
+
+    name: str = "Organizer (To-Dos & Team)"
+    description: str = (
+        "Verwaltet To-Dos und Volunteer-Liste lokal (JSON). "
+        "Aktionen: add_todo, list_todos, complete_todo, add_volunteer, list_volunteers."
+    )
+
+    def _run(self, action: str, payload_json: str = "{}") -> str:
+        state = _load()
+        payload = json.loads(payload_json or "{}")
+
+        if action == "add_todo":
+            title = payload.get("title", "").strip()
+            priority = payload.get("priority", "M")
+            if not title:
+                return "❌ title fehlt"
+            todo = {
+                "id": f"T{len(state['todos'])+1:04d}",
+                "title": title,
+                "priority": priority,
+                "done": False,
+            }
+            state["todos"].append(todo)
+            _save(state)
+            return f"✅ To-Do angelegt: {todo['id']} – {title} (Prio {priority})"
+
+        if action == "list_todos":
+            todos = state["todos"]
+            if not todos:
+                return "Keine To-Dos."
+            lines = ["## To-Dos", "| ID | Prio | Done | Title |", "|---|---|---|---|"]
+            for t in todos:
+                lines.append(f"| {t['id']} | {t['priority']} | {t['done']} | {t['title']} |")
+            return "\n".join(lines)
+
+        if action == "complete_todo":
+            tid = payload.get("id")
+            for t in state["todos"]:
+                if t["id"] == tid:
+                    t["done"] = True
+                    _save(state)
+                    return f"✅ erledigt: {tid}"
+            return f"❌ To-Do nicht gefunden: {tid}"
+
+        if action == "add_volunteer":
+            name = payload.get("name", "").strip()
+            phone = payload.get("phone", "").strip()
+            availability = payload.get("availability", "").strip()  # z.B. "Mo/Di ab 18 Uhr"
+            if not name:
+                return "❌ name fehlt"
+            state["volunteers"].append(
+                {"name": name, "phone": phone, "availability": availability}
+            )
+            _save(state)
+            return f"✅ Volunteer hinzugefügt: {name}"
+
+        if action == "list_volunteers":
+            vols = state["volunteers"]
+            if not vols:
+                return "Keine Volunteers."
+            lines = ["## Volunteers", "| Name | Phone | Availability |", "|---|---|---|"]
+            for v in vols:
+                lines.append(
+                    f"| {v['name']} | {v.get('phone','')} | {v.get('availability','')} |"
+                )
+            return "\n".join(lines)
+
+        return f"❌ Unbekannte action: {action}"

src/latest_froschgruppe/tools/payroll_tool.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from typing import Dict, Any
+import json
+import os
+
+from crewai.tools import BaseTool
+
+DATA_DIR = os.getenv("DATA_DIR", "data")
+STATE_FILE = os.path.join(DATA_DIR, "payroll.json")
+
+
+def _load() -> Dict[str, Any]:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    if not os.path.exists(STATE_FILE):
+        return {"workers": {}, "logs": []}
+    with open(STATE_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _save(state: Dict[str, Any]) -> None:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(STATE_FILE, "w", encoding="utf-8") as f:
+        json.dump(state, f, ensure_ascii=False, indent=2)
+
+
+class PayrollTool(BaseTool):
+    """
+    CrewAI Tool: Plan and track minijob budget (450€ assumption).
+    Stored locally as JSON in DATA_DIR/payroll.json.
+    """
+
+    name: str = "Payroll & Budget (450€)"
+    description: str = (
+        "Plant und trackt Minijob-Budget (450€ Annahme). "
+        "Aktionen: plan, add_worker, log_hours, report."
+    )
+
+    def _run(self, action: str, payload_json: str = "{}") -> str:
+        state = _load()
+        payload = json.loads(payload_json or "{}")
+
+        if action == "plan":
+            monthly_cap = float(payload.get("monthly_cap", 450))
+            hourly_rate = float(payload.get("hourly_rate", 12))
+            max_hours = monthly_cap / hourly_rate if hourly_rate > 0 else 0
+            return (
+                "## 450€-Plan\n"
+                f"- Monatsbudget: **{monthly_cap:.2f}€**\n"
+                f"- Stundenlohn: **{hourly_rate:.2f}€**\n"
+                f"- Max Stunden/Monat pro Person: **{max_hours:.2f}h**\n"
+                "\nTipp: Für Schichten à 3h sind das ca. "
+                f"**{max_hours/3:.1f} Schichten/Monat**."
+            )
+
+        if action == "add_worker":
+            name = payload.get("name", "").strip()
+            hourly_rate = float(payload.get("hourly_rate", 12))
+            monthly_cap = float(payload.get("monthly_cap", 450))
+            if not name:
+                return "❌ name fehlt"
+            state["workers"][name] = {"hourly_rate": hourly_rate, "monthly_cap": monthly_cap}
+            _save(state)
+            return f"✅ Worker angelegt: {name} ({hourly_rate}€/h, cap {monthly_cap}€)"
+
+        if action == "log_hours":
+            name = payload.get("name", "").strip()
+            hours = float(payload.get("hours", 0))
+            date = payload.get("date", "").strip()  # "2026-03-14"
+            note = payload.get("note", "").strip()
+            if not name or hours <= 0:
+                return "❌ name/hours ungültig"
+            state["logs"].append({"name": name, "hours": hours, "date": date, "note": note})
+            _save(state)
+            return f"✅ Stunden geloggt: {name} – {hours}h ({date})"
+
+        if action == "report":
+            # sehr einfache Summen
+            sums: Dict[str, float] = {}
+            for row in state["logs"]:
+                sums[row["name"]] = sums.get(row["name"], 0.0) + float(row["hours"])
+
+            lines = ["## Payroll Report", "| Name | Hours | Est. € | Cap € |", "|---|---:|---:|---:|"]
+            for name, hrs in sums.items():
+                w = state["workers"].get(name, {"hourly_rate": 12, "monthly_cap": 450})
+                est = hrs * float(w["hourly_rate"])
+                lines.append(
+                    f"| {name} | {hrs:.2f} | {est:.2f} | {float(w['monthly_cap']):.2f} |"
+                )
+
+            if not sums:
+                lines.append("\nKeine Logs vorhanden.")
+            return "\n".join(lines)
+
+        return f"❌ Unbekannte action: {action}"

src/latest_froschgruppe/tools/roadkill_gbif_tool.py

@@ -0,0 +1,148 @@
+# src/latest_froschgruppe/tools/roadkill_gbif_tool.py
+
+import requests
+from typing import Dict, Any, List, Tuple
+
+from crewai.tools import BaseTool
+
+GBIF_API = "https://api.gbif.org/v1"
+
+# Roadkill.at Dataset auf GBIF (aus GBIF Dataset-Seite)
+ROADKILL_AT_DATASET_KEY = "d0d5ef85-71b2-4da6-b6f6-c1c3d60987d3"
+
+
+def _cluster_key(lat: float, lon: float, precision: float = 0.05) -> Tuple[float, float]:
+    # ~0.05° ~ wenige km (je nach Breite) – gut als “Hotspot-Kachel”
+    return (round(lat / precision) * precision, round(lon / precision) * precision)
+
+
+def gbif_roadkill_search(
+    country: str | None = None,
+    scientific_name: str | None = None,
+    year_from: int | None = None,
+    year_to: int | None = None,
+    limit: int = 100,
+    offset: int = 0,
+    dataset_key: str = ROADKILL_AT_DATASET_KEY,
+) -> Dict[str, Any]:
+    """
+    Pull roadkill occurrences from a GBIF roadkill dataset.
+    Returns raw GBIF response JSON.
+    """
+    params: Dict[str, Any] = {
+        "datasetKey": dataset_key,
+        "limit": min(int(limit), 300),
+        "offset": max(int(offset), 0),
+    }
+    if country:
+        params["country"] = country  # e.g. "DE", "AT"
+    if scientific_name:
+        params["scientificName"] = scientific_name  # e.g. "Rana temporaria"
+    if year_from is not None or year_to is not None:
+        y1 = int(year_from if year_from is not None else year_to)
+        y2 = int(year_to if year_to is not None else year_from)
+        params["eventDate"] = f"{y1}-01-01,{y2}-12-31"
+
+    r = requests.get(f"{GBIF_API}/occurrence/search", params=params, timeout=30)
+    r.raise_for_status()
+    return r.json()
+
+
+def simplify_occurrences(occ_results: Dict[str, Any]) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for it in occ_results.get("results", []):
+        out.append(
+            {
+                "species": it.get("species") or it.get("scientificName"),
+                "eventDate": it.get("eventDate"),
+                "country": it.get("country"),
+                "lat": it.get("decimalLatitude"),
+                "lon": it.get("decimalLongitude"),
+                "basisOfRecord": it.get("basisOfRecord"),
+                "occurrenceID": it.get("occurrenceID") or it.get("key"),
+                "datasetKey": it.get("datasetKey"),
+            }
+        )
+    return out
+
+
+class RoadkillGBIFTool(BaseTool):
+    name: str = "Roadkill (GBIF Dataset) Explorer"
+    description: str = (
+        "Sucht Roadkill-Occurrences in einem GBIF-Roadkill-Dataset (Default: roadkill.at). "
+        "Optional nach Land, Art und Zeitraum. Gibt Hotspot-Cluster (Lat/Lon) zurück."
+    )
+
+    def _run(
+        self,
+        country: str = "DE",
+        scientific_name: str = "Rana temporaria",
+        year_from: int | None = None,
+        year_to: int | None = None,
+        limit: int = 300,
+        dataset_key: str = ROADKILL_AT_DATASET_KEY,
+    ) -> str:
+        limit = int(limit)
+        params_country = country.strip() if country else None
+        params_sci = scientific_name.strip() if scientific_name else None
+
+        results: List[Dict[str, Any]] = []
+        fetched = 0
+
+        while fetched < limit:
+            data = gbif_roadkill_search(
+                country=params_country,
+                scientific_name=params_sci,
+                year_from=year_from,
+                year_to=year_to,
+                limit=min(300, limit - fetched),
+                offset=fetched,
+                dataset_key=dataset_key,
+            )
+
+            batch = data.get("results", [])
+            if not batch:
+                break
+
+            results.extend(batch)
+            fetched += len(batch)
+
+            if fetched >= int(data.get("count", 0) or 0):
+                break
+
+        # cluster
+        cluster: Dict[Tuple[float, float], int] = {}
+        for row in results:
+            lat = row.get("decimalLatitude")
+            lon = row.get("decimalLongitude")
+            if lat is None or lon is None:
+                continue
+            key = _cluster_key(float(lat), float(lon))
+            cluster[key] = cluster.get(key, 0) + 1
+
+        top = sorted(cluster.items(), key=lambda x: x[1], reverse=True)[:10]
+
+        lines: List[str] = []
+        lines.append("## Roadkill Hotspots (GBIF)")
+        lines.append(f"- Dataset: **{dataset_key}**")
+        if params_sci:
+            lines.append(f"- Art: **{params_sci}**")
+        if params_country:
+            lines.append(f"- Land: **{params_country}**")
+        lines.append(f"- Treffer geladen: **{len(results)}** (max requested: {limit})")
+        if year_from is not None or year_to is not None:
+            yf = year_from if year_from is not None else year_to
+            yt = year_to if year_to is not None else year_from
+            lines.append(f"- Zeitraum: **{yf}–{yt}**")
+        lines.append("")
+        lines.append("| Rang | Lat | Lon | Beobachtungen | Google Maps |")
+        lines.append("|---:|---:|---:|---:|---|")
+
+        for i, ((clat, clon), cnt) in enumerate(top, start=1):
+            gmaps = f"https://www.google.com/maps?q={clat},{clon}"
+            lines.append(f"| {i} | {clat:.4f} | {clon:.4f} | {cnt} | {gmaps} |")
+
+        if not top:
+            lines.append("\nKeine Hotspots gefunden (evtl. Land/Art/Zeitraum anpassen).")
+
+        return "\n".join(lines)

src/latest_froschgruppe/tools/roadkill_tool.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List, Tuple
+import requests
+
+from crewai.tools import BaseTool
+
+GBIF_OCCURRENCE_SEARCH = "https://api.gbif.org/v1/occurrence/search"
+
+# Roadkill (Citizen Science) Dataset auf GBIF (aus Suchergebnis):
+# https://www.gbif.org/dataset/d0d5ef85-71b2-4da6-b6f6-c1c3d60987d3
+DEFAULT_ROADKILL_DATASET_KEY = "d0d5ef85-71b2-4da6-b6f6-c1c3d60987d3"
+
+
+def _cluster_key(lat: float, lon: float, precision: float = 0.05) -> Tuple[float, float]:
+    return (round(lat / precision) * precision, round(lon / precision) * precision)
+
+
+@dataclass
+class RoadkillGBIFTool(BaseTool):
+    name: str = "Roadkill Hotspot Finder (GBIF)"
+    description: str = (
+        "Nutzt GBIF-Roadkill-Datasets (default: Roadkill citizen science) "
+        "und erzeugt Hotspots, optional für eine Art und Land."
+    )
+
+    def _run(
+        self,
+        country: str = "DE",
+        scientific_name: Optional[str] = None,
+        dataset_key: str = DEFAULT_ROADKILL_DATASET_KEY,
+        year_from: Optional[int] = None,
+        year_to: Optional[int] = None,
+        limit: int = 300,
+    ) -> str:
+        params: Dict[str, Any] = {
+            "datasetKey": dataset_key,
+            "country": country,
+            "hasCoordinate": "true",
+            "limit": min(limit, 300),
+            "offset": 0,
+        }
+        if scientific_name:
+            params["scientificName"] = scientific_name
+        if year_from:
+            params["year"] = f"{year_from},{year_to or year_from}"
+
+        results: List[Dict[str, Any]] = []
+        fetched = 0
+
+        while fetched < limit:
+            params["offset"] = fetched
+            r = requests.get(GBIF_OCCURRENCE_SEARCH, params=params, timeout=30)
+            r.raise_for_status()
+            data = r.json()
+            batch = data.get("results", [])
+            if not batch:
+                break
+            results.extend(batch)
+            fetched += len(batch)
+            if fetched >= data.get("count", 0):
+                break
+
+        cluster: Dict[Tuple[float, float], int] = {}
+        for row in results:
+            lat = row.get("decimalLatitude")
+            lon = row.get("decimalLongitude")
+            if lat is None or lon is None:
+                continue
+            key = _cluster_key(float(lat), float(lon))
+            cluster[key] = cluster.get(key, 0) + 1
+
+        top = sorted(cluster.items(), key=lambda x: x[1], reverse=True)[:10]
+
+        title = "## Roadkill Hotspots (GBIF)"
+        if scientific_name:
+            title += f" – {scientific_name}"
+        title += f" ({country})"
+
+        lines = [title]
+        lines.append(f"- DatasetKey: `{dataset_key}`")
+        lines.append(f"- Treffer geladen: **{len(results)}**")
+        if year_from:
+            lines.append(f"- Zeitraum: **{year_from}–{year_to or year_from}**")
+        lines.append("")
+        lines.append("| Rang | Lat | Lon | Roadkill-Funde | Google Maps |")
+        lines.append("|---:|---:|---:|---:|---|")
+
+        for i, ((clat, clon), cnt) in enumerate(top, start=1):
+            gmaps = f"https://www.google.com/maps?q={clat},{clon}"
+            lines.append(f"| {i} | {clat:.4f} | {clon:.4f} | {cnt} | {gmaps} |")
+
+        if not top:
+            lines.append("\nKeine Hotspots gefunden – ggf. Land/Dataset/Zeitraum anpassen.")
+
+        return "\n".join(lines)

src/latest_froschgruppe/tools/storage.py

@@ -0,0 +1,11 @@
+import os
+from pathlib import Path
+
+def get_data_dir() -> Path:
+    # If persistent storage is enabled on HF Spaces, /data exists.
+    if Path("/data").exists():
+        base = Path("/data")
+    else:
+        base = Path(os.getenv("DATA_DIR", "./data"))
+    base.mkdir(parents=True, exist_ok=True)
+    return base